初阶数据结构二C语言实现顺序表

Posted ℡小男孩

tags:

篇首语：本文由小常识网(cha138.com)小编为大家整理，主要介绍了初阶数据结构二C语言实现顺序表相关的知识，希望对你有一定的参考价值。

从本篇开始，我们进入数据结构的真正重点内容，话不多说，我们开始吧！

文章目录

一、线性表

线性表（linear list）是n个具有相同特性的数据元素的有限序列。 线性表是一种在实际中广泛使用的数据结构，常见的线性表：顺序表、链表、栈、队列、字符串…
线性表在逻辑上是线性结构，也就说是连续的一条直线。但是在物理结构上并不一定是连续的，线性表在物理上存储时，通常以数组和链式结构的形式存储。

接下来，我们进入今天的主讲内容：顺序表

二、顺序表

1、概念及结构

何为顺序表？
顺序表是用一段物理地址连续的存储单元依次存储数据元素的线性结构，一般情况下采用数组存储。在数组上完成数据的增删查改。

简单理解：顺序表就是数组，但是在数组的基础上，还要求数据是从头开始存并且连续存储的，不能有跳跃间隔

顺序表一般可以分为：
1.静态顺序表：使用定长数组存储元素

 顺序表的静态存储
#define N 100
typedef int SLDataType;
typedef struct SeqList
{
	SLDataType array[N]; // 定长数组
	size_t size; // 有效数据的个数
}SeqList;

图示：

2.动态顺序表：使用动态开辟的数组存储

顺序表的动态存储
typedef struct SeqList
{
	SLDataType* array;   // 指向动态开辟的数组
	size_t size ;        // 有效数据个数
	size_t capicity ;   // 容量空间的大小
}SeqList;

图示：

这两种哪个更好一点呢？

  • 静态顺序表

只适用于确定知道需要存多少数据的场景
局限：静态顺序表的定长数组，若N定大了，空间开多了浪费，若N定小了不够用。

  • 动态顺序表

现实使用时多采用动态顺序表
优势：需要多少用多少

2、顺序表接口的实现

我们以vs2019为环境搭建顺序表工程

  • 创建一个SeqList.h顺序表头文件
  • 创建一个SeqList.c顺序表实现文件
  • 创建一个test.c测试文件

    说明：
  • SeqList.h头文件用来创建顺序表,和一些函数方法的声明
  • SeqList.c文件用来实现顺序表函数的定义
  • test.c文件用来测试每次实现一个函数后是否成功

2.1 顺序表的创建

我们以整型顺序表为例:

//静态版本的顺序表
#define N 1000 //方便以后修改大小
struct SeqList
{
	int a[N];
	int size;//表示数组中存储了多少个有效数据
};

//动态版本的顺序表
struct SeqList
{
    int* a;     	//动态开辟数组.
    int size;       //表示数组中已存储了多少个数据
    int capacity;   //数组实际能存数据的空间容量是多大
};

上面就是我们创建的两种形式的顺序表，我们会以实现动态顺序表为例（静态顺序表可以依法炮制~）。

看到上面定义的顺序表，其实还有一个小小的问题，就是当我们不再需要整型，而是要换成其他类型，那就需要去改int，要知道一个项目里，当用到结构体次数过多时，我们则需要一个个的去修改，这样太麻烦。

那有没有很好的办法解决呢? 有,那就是typedef.
修改如下：

typedef int SLDataType
//动态顺序表
typedef struct SeqList
{
	SLDataType* a;		//动态开辟数组.
	int size;			//表示数组中已存储了多少个数据
	int capacity;		//数组实际能存数据的空间容量是多大
}SL;//将结构体也重命名，后面定义结构体变量也方便。

这样的话,以后如果不需要int型,我们就可以直接修改typedef定义的int,非常便捷

定义好后,我们该将这段程序放在哪里呢?
上面已经讲解了：SeqList.h头文件用来创建顺序表,和一些函数方法的声明
所以我们将它放在SeqList.h头文件中.

2.2 顺序表的初始化SeqListInit

//顺序表的初始化
void SeqListInit(SL* ps)
{
	ps->a = NULL;
	ps->size = ps->capacity = 0;
}

我们将其定义好后，怎么放呢？
SeqList.h中放程序初始化声明: void SeqListInit(SL* ps);
SeqList.c中放上面的函数定义.

2.3 顺序表的尾插SeqListPushBack

什么叫做尾插呢？请看下面一副动图：

顾名思义,尾插,即在最后面插入.接下来我们看看是如何实现的。

在SeqList.h文件中声明

//顺序表的尾插
void SeqListPushBack(SL* ps, SLDataType x);

在SeqList.c文件中定义

//顺序表的尾插
void SeqListPushBack(SL* ps, SLDataType x)
{
	//如果没有空间或者空间不足，我们就扩容
	if (ps->size == ps->capacity)
	{
		int newcapacity = ps->capacity == 0 ? 4 : ps->capacity * 2;
		SLDataType* tmp = (SLDataType*)realloc(ps->a, newcapacity * sizeof(SLDataType));
		if (tmp == NULL)
		{
			printf("realloc fail\\n");
			exit(-1);//结束程序--异常退出
		}
		ps->a = tmp;
		ps->capacity = newcapacity;
	}
	ps->a[ps->size] = x;
	ps->size++;
}

2.4 顺序表的尾删SeqListPopBack

我们了解尾插是如何进行的之后，就可以了解尾删了，顾名思义,尾删,即从最后面开始删除数据.如图：

接下来我们看看是如何实现的。
在SeqList.h文件中声明

//顺序表的尾删
void SeqListPopBack(SL* ps, SLDataType x);

在SeqList.c文件中定义

//顺序表的尾删
void SeqListPopBack(SL* ps, SLDataType x)
{
	//温柔的方式
	//if (ps->size > 0)//防止越界，当数组中的数据全部删除之后，不可在删
	//{
	// 	//ps->a[ps->size - 1] = 0;//这一句可以不要
	//	ps->size--;
	//}

	//暴力的方式
	assert(ps->size > 0);//断言
	ps->size--;
}

2.5 顺序表的打印SeqListPrint

打印就非常简单了，如下:
在SeqList.h文件中声明

//顺序表的打印
void SeqListPrint(SL* ps);

在SeqList.c文件中定义

//顺序表的打印
void SeqListPrint(SL* ps)
{
	for (int i = 0; i < ps->size; i++)
	{
		printf("%d ", ps->a[i]);
	}
	printf("\\n");
}

2.6 顺序表的销毁SeqListDestory

我们都知道，当我们向内存申请了一块内存空间后，若我们不再使用，则需要归还系统，不然会造成内存泄漏等问题。
在SeqList.h中声明

//顺序表的销毁
void SeqListDestory(SL* ps);

在SeqList.c中定义

//顺序表的销毁
void SeqListDestory(SL* ps)
{
	free(ps->a);
	ps->a = NULL;
	ps->capacity = ps->size = 0;
}

我们完成上面这些接口之后，就可以进行一下测试了，如下：

2.7 顺序表的头插SeqListPushFront

头插演示：

在SeqList.h中声明

//顺序表的头插
void SeqListPushFront(SL* ps, SLDataType x);

在SeqList.c中定义

//顺序表的头插
void SeqListPushFront(SL* ps, SLDataType x)
{
	//如果没有空间或者空间不足，我们就扩容
	if (ps->size == ps->capacity)
	{
		int newcapacity = ps->capacity == 0 ? 4 : ps->capacity * 2;
		SLDataType* tmp = (SLDataType*)realloc(ps->a, newcapacity * sizeof(SLDataType));
		if (tmp == NULL)
		{
			printf("realloc fail\\n");
			exit(-1);//结束程序--异常退出
		}
		ps->a = tmp;
		ps->capacity = newcapacity;
	}
	//挪动数据
	int end = ps->size - 1;
	while (end >= 0)
	{
		ps->a[end + 1] = ps->a[end];
		end--;
	}
	ps->a[0] = x;
	ps->size++;
}

2.8 顺序表的增容SeqListCheckCapacity

由于我们无论是在进行尾插还是头插，都必须检查顺序表的容量是否足够，若不够，则需要进行增容，所以我们将顺序表的检查增容单独写成一个函数，我们只需在尾插和头插时调用它即可。如下：
在SeqList.h中声明

//顺序表检查增容
void SeqListCheckCapacity(SL* ps);

在SeqList.c中定义

//顺序表检查增容
void SeqListCheckCapacity(SL* ps)
{
	//如果没有空间或者空间不足，我们就扩容
	if (ps->size == ps->capacity)
	{
		int newcapacity = ps->capacity == 0 ? 4 : ps->capacity * 2;
		SLDataType* tmp = (SLDataType*)realloc(ps->a, newcapacity * sizeof(SLDataType));
		if (tmp == NULL)
		{
			printf("realloc fail\\n");
			exit(-1);//结束程序--异常退出
		}
		ps->a = tmp;
		ps->capacity = newcapacity;
	}
}

2.9 顺序表的头删SeqListPopFront

头删演示：

在SeqList.h中声明

//顺序表的头删
void SeqListPopFront(SL* ps, SLDataType x);

在SeqList.c中定义

//顺序表的头删
void SeqListPopFront(SL* ps, SLDataType x)
{
	assert(ps->size > 0);
	int begin = 1;//把第二个元素的下标赋给begin,这样到了size的位置的时候就可停止
	while (begin < ps->size)
	{
		ps->a[begin - 1] = ps->a[begin];
		begin++;
	}
	ps->size--;
}

这里我们来测试一下头插与头删是否成功：

2.10 顺序表之查找元素SeqListFind

在SeqList.h中声明

// 顺序表查找
int SeqListFind(SL* ps, SLDataType x);

在SeqList.c中定义

//顺序表之查找元素,找到返回下标，没找到返回-1
int SeqListFind(SL* ps, SLDataType x)
{
	for (int i = 0; i < ps->size; i++)
	{
		if (ps->a[i] == x)
		{
			return i;
		}
	}
	return -1;
}

2.11 顺序表之在指定位置插入元素SeqListInsert

思路：

  1. 输入指定下标, 想要插入的元素,就在此下标位置插入
  2. 实现方法: 输入的下标位置及其后,所有数据都往后面挪
  3. 然后插入数据,size加1

在SeqList.h中声明

//在指定下标位置插入
void SeqListInsert(SL* ps, int pos, SLDataType x);

在SeqList.c中定义

//在指定下标位置插入
void SeqListInsert(SL* ps, int pos, SLDataType x)
{
	//在插入之前需判断pos的位置是否符合顺序表的特征(必须保持连续)

	//温柔处理方式
	//if (pos > ps->size || pos < 0)
	//{
	//	printf("pos invalid\\n");
	//	return;
	//}
	
	//暴力处理方式
	assert(pos <= ps->size && pos >= 0);
	SeqListCheckCapacity(ps);
	int end = ps->size - 1;
	while (end >= pos)
	{
		ps->a[end + 1] = ps->a[end];
		end--;
	}
	ps->a[pos] = x;
	ps->size++;
}

2.12 顺序表之删除指定位置的数据SeqListErase

在SeqList.h中声明

//删除指定位置的数据
void SeqListErase(SL* ps, int pos);

在SeqList.c中定义

//删除指定位置的数据
void SeqListErase(SL* ps, int pos)
{
	assert(pos < ps->size && pos >= 0);

	int begin = pos + 1;
	while (begin < ps->size)
	{
		ps->a[begin - 1] = ps->a[begin];
		begin++;
	}
	ps->size--;
}

三、综合

SeqList.h

#include <stdio.h>
#include <stdlib.h>
#include <assert.h>
//#define N 1000 //方便以后修改大小
//静态顺序表 
//struct SeqList
//{
//	int a[N];
//	int size;//表示数组中存储了多少个有效数据
//};

//动态顺序表
typedef int SLDataType;//方便后期修改数据类型

typedef struct SeqList
{
	SLDataType* a;		//动态开辟数组.
	int size;			//表示数组中已存储了多少个数据
	int capacity;		//数组实际能存数据的空间容量是多大
}SL;//将结构体也重命名，后面定义结构体变量也方便。


//顺序表的打印
void SeqListPrint(SL* ps);
//顺序表的初始化
void SeqListInit(SL* ps);
//顺序表的销毁
void SeqListDestory(SL* ps);
//顺序表检查增容
void SeqListCheckCapacity(SL* ps);
//顺序表的尾插
void SeqListPushBack(SL* ps, SLDataType x);
//顺序表的尾删
void SeqListPopBack(SL* ps, SLDataType x);
//顺序表的头插
void SeqListPushFront(SL* ps, SLDataType x);
//顺序表的头删
void SeqListPopFront(SL* ps, SLDataType x);

// 顺序表查找
int SeqListFind(SL* ps, SLDataType x);

//在指定下标位置插入
void SeqListInsert(SL* ps, int pos, SLDataType x);

//删除指定位置的数据
void SeqListErase(SL* ps, int pos);

SeqList.c

#include "SeqList.h"

//顺序表的打印
void SeqListPrint(SL* ps)
{
	for (int i = 0; i < ps->size; i++)
	{
		printf("%d ", ps->a[i]);
	}
	printf("\\n");
}

//顺序表的初始化
void SeqListInit(SL* ps)
{
	ps->a = NULL;
	ps->size = ps->capacity = 0;
}

//顺序表检查增容
void SeqListCheckCapacity(SL* ps)
{
	//如果没有空间或者空间不足，我们就扩容
	if (ps->size == ps->capacity)
	{
		int newcapacity = ps->capacity == 0 ? 4 : ps->capacity * 2;
		SLDataType* tmp = (SLDataType*)realloc(ps->a, newcapacity * sizeof(SLDataType));
		if (tmp == NULL)
		{
			printf("realloc fail\\n");
			exit(-1);//结束程序--异常退出
		}
		ps->a = tmp;
		ps->capacity = newcapacity;
	}
}

//顺序表的销毁
void SeqListDestory(SL* ps)
{
	free(ps->a);
	ps->a = NULL;
	ps->capacity = ps->size = 0;
}

//顺序表的尾插
void SeqListPushBack(SL* ps, SLDataType x)
{
	SeqListCheckCapacity(ps);
	ps->a[ps->size] = x;
	ps->size++;
}

//顺序表的尾删
void SeqListPopBack(SL* ps, SLDataType x)
{
	//温柔的方式
	//if (ps->size > 0)//防止越界，当数组中的数据全部删除之后，不可在删
	//{
	// 	//ps->a[ps->size - 1] = 0;//这一句可以不要
	//	ps->size--;
	//}

	//暴力的方式
	assert(ps->size > 0);
	ps->size--;
}


//顺序表的头插
void SeqListPushFront(SL* ps, SLDataType x)
{
	SeqListCheckCapacity(ps);
	//挪动数据
	int end = ps->size - 1;//将最后一个数的下标赋给end
	while (end >= 0)
	{
		ps->a[end + 1] = ps->a[end];
		end--;
	}
	ps->a[0] = x;
	ps->size++;
}

//顺序表的头删
void SeqListPopFront(SL* ps, SLDataType x)
{
	assert(ps->size > 0);
	int begin = 1;
	while (begin < ps->size)
	{
		ps->a[begin - 1] = ps->a[begin];
		begin++;
	}
	ps->size--;
}



//顺序表之查找元素,找到返回下标，没找到返回-1
int SeqListFind(SL* ps, SLDataType x)
{
	for (int i = 0; i < ps->size; i++)
	{
		if (ps->a[i] == x)
		{
			return i;
		}
	}
	return -1;
}

//在指定下标位置插入
void SeqListInsert(SL* ps, int pos, SLDataType x
以上是关于初阶数据结构二C语言实现顺序表的主要内容，如果未能解决你的问题，请参考以下文章
 

 数据结构初阶：动态顺序表的功能实现（用C语言实现，附图分析）


 数据结构顺序表（增删查改）的实现 [初阶篇_ 复习专用]


 初阶数据结构——线性表——顺序表


 [ 数据结构--C语言 ]不收藏必后悔系列--二叉树初阶


 [ 数据结构--C语言 ]不收藏必后悔系列--二叉树初阶


 数据结构初阶——顺序表