前言
线性表是在实际中广泛应用的数据结构.常见的线性表有:顺序表,链表,队列等等. 线性表在逻辑上宿舍连续的,我们可以认为是连续的直线.但是线性表在内存存储中不一定是连续存放的.比如链表.也有可能是连续存放的--顺序表. 内存存储是否连续各有优劣,没有高下之分
一、顺序表是什么?
简单来说,顺序表就是数组.但是和数组有些不同,数组存放数据可以说随机的,而顺序表按顺序进行存放. 顺序表是线性表的一种,线性表是n个具有相同特性的元素组合成的有限序列 (比如int型组成int类型的数组) .线性表在逻辑上面是连续存放的,但是在物理结构上面却不一定是连续的. 顺序表在物理结构上是连续存放的,而且必须是按顺序进行存放.
二.静态顺序表和动态顺序表的优劣对比
静态顺序表
c
#define N 7
typedef int SLDataType;
typedef struct SeqList
{
SLDataType a[N];//定长数组
int size;//有效个数
}SL;
在外面的课本上面多数举得案例都是静态数组.为什么呢?因为它相对于动态顺序表更好写一点 但是它的缺点也很明确: 我们虽然可以通过define定义的宏变量来修改定长数组的值,但是每次写完数组的长度就固定了.除非你明确知道要存放的数据的大小,不然开辟少了不够,开多了浪费.
动态顺序表
c
typedef int SLDataType;//要修改数据类型只需要修改这一行
typedef struct SeqList
{
SLDataType* a;//指向将要进行动态开辟的数组
int size;//当前存放的有效个数
int capacity;//当前的容量
}SL;
因为我们要存放的数据类型不一定是int型,也有可能是double甚至是指针. 所以我们把类型进行重定义.以后要进行数据类型的修改只需要改一行就行 因为数组是动态开辟的,所以它会有一个变量来显示当前的容量,如果不够就变大.动态顺序表比静态顺序表就好得不是一星半点了,它极大地降低了内存的浪费,让数据存储更省心.
三、动态顺序表实现步骤
1.初始化顺序表
c
typedef int SLDataType;
typedef struct SeqList
{
SLDataType* a;//指向将要进行动态开辟的数组
int size;//当前存放的有效个数
int capacity;//当前的容量
}SL;
先把结构体变量的值全部置为0 assert是判断pl指针是否为空.
c
void SeqListInit(SL* pl)
{
assert(pl);//不能对空指针进行解引用操作,防止传过来的是空指针
pl->a = NULL;//将要进行动态开辟的数组
pl->capacity = 0;//顺序表的容量置为0
pl->size = 0;//有效个数置为0
}
调用方式
c
void Test1()
{
SL sl;//定义一个结构体变量
SeqListInit(&sl);//传地址才会修改它的值
}
int main()
{
Test1();
return 0;
}
这里注意要传给SeqListInit()函数的是结构体变量sl的地址. 只有通过sl的地址才能修改它的值
2.尾插数据
在尾插数据之前,大家有没有发现上面不对劲? 我们要动态开辟的a数组面前为空 而且因为我们是动态开辟的,所以后面我们每次存储都要检查当前容量是否能够放下数据
c
void SLCheckCapacity(SL* pl)
{
assert(pl);
if (pl->size == pl->capacity)
{
int newcapacity = pl->capacity == 0 ? 4 : pl->capacity * 2;
//如果容量是0就改成4,不然就在本来的基础上翻倍
SLDataType* tmp = (SLDataType*)realloc(pl->a,sizeof(SLDataType)*newcapacity);
//当传给realloc的指针为空时,它相当于malloc
if (tmp == NULL)
{
perror("realloc fail");
//当realloc开辟失败后会传会空指针
exit(-1);//退出程序
}
pl->a = tmp;
pl->capacity = newcapacity;//覆盖旧容量
}
}
sizeof(SLDataType)newcapacity 类型的大小新的容量
SLDataType* tmp相当于给pl->a加了一道保险, 因为realloc开辟失败后会传会空指针,要是直接将realloc开辟出来的指针传给pl->a会出大问题. size当前的位置为空,所以直接将x的值赋给size.
c
void SeqListPushBack(SL* pl, SLDataType x)
{
assert(pl);
SLCheckCapacity(pl);
pl->a[pl->size] = x;
pl->size++;//插入数据size要变大
}
3.打印顺序表
努力了怎么久,总得听个响
c
void SeqListPrint(SL* pl)
{
assert(pl);
for (int i = 0; i < pl->size; i++)
{
printf("%d ", pl->a[i]);//打印有效数据
}
printf("\n");
}
按顺序打印顺序表a存放的值 测试:
c
void Test1()
{
SL sl;
SeqListInit(&sl);
SeqListPushBack(&sl, 1);
SeqListPushBack(&sl, 2);
SeqListPushBack(&sl, 6);
SeqListPushBack(&sl, 7);
SeqListPushBack(&sl, 9);
SeqListPrint(&sl);
}
int main()
{
Test1();
return 0;
}
4.头插数据
将begin的值放到size-1处 将begin的值向后面覆盖 当begin=-1时循环结束 给起始位置腾出空间来插入数据
c
void SeqListPushFront(SL* pl, SLDataType x)
{
assert(pl);
SLCheckCapacity(pl);//检查容量
int end = pl->size - 1;
while (end >= 0)
{
pl->a[end + 1] = pl->a[end];
end--;
}
pl->a[0] = x;
pl->size++;
}
调试
c
void Test1()
{
SL sl;
SeqListInit(&sl);
SeqListPushFront(&sl, 99);
SeqListPushFront(&sl, 98);
SeqListPushFront(&sl, 97);
SeqListPushFront(&sl, 96);
SeqListPrint(&sl);
}
int main()
{
Test1();
return 0;
}
5.尾删数据
我们不需要修改末尾位置的值,直接让size--,减少有效数据的个数,从而使打印顺序表的函数无法访问该数据.
c
void SeqListPopBack(SL* pl)
{
assert(pl);
assert(pl->size>0);//size为0就不能继续删了
pl->size--;
}
注意 size为0不能继续删,否则在后面free进行释放时会报错.
6.头删数据
对size的大小进行检查,为0不能再删 设begin=1,将begin所指向的值往前挪动.循环直到begin==size 然后有效个数size--;
c
void SeqListPopFront(SL* pl)
{
assert(pl);
assert(pl->size > 0);//为0不能删
int begin = 1;
while (begin < pl->size)
{
pl->a[begin - 1] = pl->a[begin];//不断往前挪动数据
begin++;
}
pl->size--;
}
测试
c
void Test2()
{
SL sl;
SeqListInit(&sl);
SeqListPushBack(&sl, 1);
SeqListPushBack(&sl, 2);
SeqListPushBack(&sl, 6);
SeqListPushBack(&sl, 7);
SeqListPushBack(&sl, 9);
SeqListPrint(&sl);
SeqListPopBack(&sl);
SeqListPopBack(&sl);//尾删
SeqListPrint(&sl);
SeqListPopFront(&sl);//头删
SeqListPopFront(&sl);
SeqListPrint(&sl);
}
int main()
{
Test2();
return 0;
}
7.任意位置插入数据
因为顺序表是连续存放的,所以这个任意位置也只是相对而言 对pos的位置进行检查 这个位置不能小于数组的起点,也就是a[0]; 也不能大于size(size里面是空的,所以可以插入值 ) 将end放到size-1的位置上,再挪动end的值到end+1上面,然后end--. 到pos=end,循环结束.
给pos挪出空间来存放数据.
c
oid SeqListInsert(SL* pl, int pos, SLDataType x)
{
assert(pl);
assert(pos>=0 &&pos<=pl->size);//检查pos位置是否规范
SLCheckCapacity(pl);//检查容量
int end = pl->size - 1;
while (end >= pos)
{
pl->a[end + 1] = pl->a[end];
end--;
}
pl->a[pos] = x;
pl->size++;//增加和删除都会改变size的值
}
调试
c
void Test3()
{
SL sl;
SeqListInit(&sl);
SeqListPushBack(&sl, 1);
SeqListPushBack(&sl, 2);
SeqListPushBack(&sl, 6);
SeqListPushBack(&sl, 7);
SeqListPrint(&sl);
SeqListInsert(&sl, 2, 999);//任意位置插入数据
SeqListInsert(&sl, 0, 333);
SeqListPrint(&sl);
}
int main()
{
Test3();
return 0;
}
8.任意位置删除数据
因为顺序表是连续存放的,所以这个任意位置也只是相对而言 对pos的位置进行检查 这个位置不能小于数组的起点,也就是a[0]; 不能大于或者等于当前的有效存储量size,size当前没有存放值 pos所在的位置要删除,我们可以把pos+1的值对pos进行覆盖,然后begin++. 以此类推,当begin遇到size,循环结束, 覆盖的任务完成.
c
void SeqListErase(SL* pl, int pos)
{
assert(pl);
assert(pos >= 0 && pos < pl->size);//对pos的位置进行检查
int begin = pos + 1;
while (begin < pl->size)
{
pl->a[begin - 1] = pl->a[begin];
begin++;
}
pl->size--;
}
增加和删除都会改变size的值,而容量capacity的大小只与动态开辟realloc有关. 调试:
c
void Test3()
{
SL sl;
SeqListInit(&sl);
SeqListPushBack(&sl, 1);
SeqListPushBack(&sl, 2);
SeqListPushBack(&sl, 6);
SeqListPushBack(&sl, 7);
SeqListPrint(&sl);
SeqListErase(&sl, 1);//任意位置删除
SeqListPrint(&sl);
}
int main()
{
Test3();
return 0;
}
9.销毁顺序表
*首先出于稳妥,我们还是给结构体指针pl进行断言一下
c
void SeqListDestroy(SL* pl)
{
assert(pl);
if(pl->a != NULL)
{
free(pl->a);
pl->a = NULL;
pl->capacity = 0;//将容量置为0
pl->size = 0;////将大小置为0
}
}
记得要将pl->a置为NULL,不然会变成野指针
总结
简单来说,顺序表就是一个数据连续存放的数组. 因为顺序表物理存储连续,所以我们对顺序表的访问非常方便,修改数据也相对容易,但数据表也存在问题.
顺序表存在的问题:
1.在我们进行头插/删或者是任意位置插入和删除时,我们都要挪动后面的数据,时间复杂度是O(N)
2.realloc扩容方式有原地扩容和异地扩容.当数组后面的空间足够时,进行原地扩容.相反,当数组后面的空间不够时,会进行异地扩容. 异地扩容:另外找一片地方存储数据,会拷贝之前的数据并对原地址进行释放异地扩容会有不小的消耗.
3.虽然动态顺序表相对于静态顺序表来说,浪费问题降低了不少,当还是存在.假如当前容量为100,而我要存储110个数据,容量满了会扩容道200.会有90个数据空间的浪费.
如何解决上面的问题呢? 数据结构下一弹---链表会给出答案.