建设服装网站目的,装修网站设计案例,销售平台网站建设,摄影网站模板前言
随着我们C语言的不断深入学习#xff0c;我们要开始学习一点数据结构来增加我们的内功了#xff0c;虽说现在很多高级语言的顺序表#xff0c;链表等可以不用自己实现#xff0c;但在C语言中是需要我们自己来实现的#xff0c;这并不能说明C语言和其他语言比C语言很…前言
随着我们C语言的不断深入学习我们要开始学习一点数据结构来增加我们的内功了虽说现在很多高级语言的顺序表链表等可以不用自己实现但在C语言中是需要我们自己来实现的这并不能说明C语言和其他语言比C语言很拉跨我们通过C语言模拟实现一下这种数据结构可以让我们更加深入理解一个其他语言中我们经常使用的一些内容。当然我们所要学习的不仅仅是它们的实现更重要的是它们的思想。 一、顺序表
顺序表是在计算机内存中以数组的形式保存的线性表线性表的顺序存储是指用一组地址连续的存储单元依次存储线性表中的各个元素、使得线性表中在逻辑结构上相邻的数据元素存储在相邻的物理存储单元中。顺序表是将表中的结点依次存放在计算机内存中一组地址连续的存储单元中。 在内存中的存储情况如下
二、顺序表的功能
常见的顺序表的功能有增加删除查找修改。还有一些其他的功能排序合并返回元素个数等。 增加增加可以分为头部增加和尾部增加和指定位置增加指定位置的增加又可以分为在指定元素左边或右边进行增加。 删除删除可以分为头部删除和尾部删除和指定位置删除。 查找顾名思义查找指定元素或位置。 修改把指定元素或位置的元素修改为其他元素。 排序把结构中的数据进行排序。 合并把多个结构合并为一个。 返回元素个数把顺序表中的具体的元素个数显示出来。
三、顺序表的实现
顺序表的实现又有静态和动态之分。 静态的顺序表的大小已经固定而动态顺序表的大小是可以发生变化的静态的顺序表使用局限性太大会出现空间浪费和空间不够的尴尬局面。而动态顺序表则解决静态顺序表的问题。但我们还是要学习一下静态顺序表观察动态和静态的异同点。我们的函数实现都是通过传址进行的不用传值是避免进行大规模的拷贝进而造成时间和空间的浪费。
1.顺序表的静态实现
顺序表的创建
#define MAX 10 //存放元素的最大个数
typedef int datatype;//把类型重新命名方便后面的参数类型的修改增加代码的鲁棒性
typedef struct SList//定义顺序表的结构体
{int position;//表中元素的个数和位置datatype arr[MAX];//用来存放元素
}SL;//把结构体类型重新命名为SL我们实现的是一个简单的顺序表存储类型是int类型的数据放在的int类型的数组中。
顺序表的初始化打印和销毁
void Initialization(SL *sl)//初始话顺序表
{assert(sl);//进行断言防止传入的指针或者地址不合法而造成的错误sl-position 0;//开始没有元素所以位置为0
}
SL* InitializationList()
{SL* sl (SL*)malloc(sizeof(SL));sl-position 0;return sl;
}
void print(const SL *sl)//打印顺序表
{assert(sl);//进行断言for (int i 0; i sl-position; i){printf(%d , sl-arr[i]);}printf(\n);
}
void Destroy1(SL* sl)//销毁顺序表
{assert(sl);sl-position 0;//把元素个数置为0
}
void Destroy2(SL* sl)//销毁顺序表
{assert(sl);free(sl);//把空间进行释放sl-position 0;sl NULL;//把指针置空
}顺序表的初始化有两种一种是在主函数中创建完成通过第一个函数进行初始化一种是在函数中进行创建并且通过返回类型返回给主函数。销毁函数也是针对上面的两种初始化函数而进行设计的第一个不是动态开辟的所以不可以用free第二个是在函数中动态开辟的空间所以需要free进行释放。防止造成内存泄漏。 这里我们不是静态实现吗为什么还会用动态开辟呢 这里的静态是指数据的储存大小是不变的我们动态开辟的一块结构体所需要的内存是固定不变的结构体里面数组的大小是固定的他的存储元素个数和我们结构体是否是动态开辟的无关。和数组大小有关。 我们进行的是传址调用当我们不需要对元素进行修改时我们可以加上const进行修饰防止我们进行修改。
顺序表的增加和删除
我们先看代码的实现
void Popback(SL* sl, datatype n)//头插
{assert(sl);//进行断言if (sl-position MAX )//判断数组中是否还有空间{int sum sl-position;//创建一个变量等于数组中插入元素后的位置for (; sum 0; sum--){sl-arr[sum] sl-arr[sum - 1];//把插入元素后的前一个元素向后移动}sl-arr[sum] n;//把数组中的一个元素设置为传入的值sl-position;//元素位置向后移动}else{printf(空间不足\n);return;}
}
void Popfornt(SL* sl)//头删
{assert(sl);//进行断言int sum 1;for (; sum sl-position; sum){sl-arr[sum - 1] sl-arr[sum];//把数组中元素进行前移进行覆盖}sl-position--; //元素位置向前移动
}
void Pushback(SL* sl, datatype n)//尾插
{assert(sl);if (sl-position MAX)//判断数组中是否还有空间{sl-arr[sl-position] n;//直接在数组后插入元素sl-position;//元素位置向后移动}else{printf(空间不足\n);return;}
}
void Pushfornt(SL* sl)//尾删
{assert(sl);sl-position--;//直接进行个数减一表明这个位置可以进行覆盖
}头插和头删把元素插入在数组的第一个位置所以需要第一个位置后面的所有元素向后进行移动头删则需要把第一个位置后面的所有元素向前覆盖。 尾插和尾删直接把元素插入在最后位置或者直接对元素个数进行减一达到尾插和尾删的效果。
void test1()//进行头删尾删头插尾插。
{SL sl;Initialization(sl);//初始话顺序表Popback(sl, 1);//进行头插Popback(sl, 2);Popback(sl, 3);Popback(sl, 4);Popback(sl, 5);printf(头插后);print(sl);Pushback(sl, 6);//进行尾插Pushback(sl, 7);Pushback(sl, 8);Pushback(sl, 9);Pushback(sl, 10);Pushback(sl, 11);//超过数组中的大小,空间不足printf(尾插后);print(sl);//打印顺序表的元素Pushfornt(sl);//进行尾删printf(尾删后);print(sl);Popfornt(sl);//进行头删printf(头删后);print(sl);Destroy1(sl);
}
int main()
{test1();return 0;
}顺序表的插入查询和修改
顺序表的插入和修改都依赖于查询功能所以我们要先实现顺序表的查询修改我们也可以直接修改我们想修改的下标的元素但是我们一般不知道我们要修改的下标的元素是什么所以需要查找功能如即将要实现的通讯录这个我们可以通过姓名查找到该人物的下标进而修改我们的数值。 下面是我们的实现代码
int Seeklift(const SL *sl, datatype n)//左查找
{assert(sl);int sum 0;for (sum 0; sum sl-position; sum){if (sl-arr[sum] n)//判断改下标的元素是否和我们所需的元素相同。{return sum1;//数组下标从0开始所以返回位置进行加1}}return -1;
}
int Seekright(const SL *sl, datatype n)//右查找
{assert(sl);int sum sl-position-1;for (; sum 0; sum--){if (sl-arr[sum] n){return sum1;}}return -1;
}
void Modify(SL *sl, int n, datatype num)//修改
{assert(sl);sl-arr[n - 1] num;//把坐标还原为数组的下标
}
void Insertpos(SL* sl, int n, datatype num)//按数组位置插入,在元素左插入
{assert(sl);//判断数组中是否还有空间if (sl-position MAX){int sum sl-position;//创建一个变量等于数组中插入元素后的位置for (; sum n-1; sum--)//把坐标还原为数组的下标{sl-arr[sum] sl-arr[sum - 1];//把插入元素后的前一个元素向后移动}sl-arr[n-1] num;//把数组中的一个元素设置为传入的值sl-position;//元素位置向后移动}else{printf(空间不足\n);return;}
}
void Insertright(SL* sl, int n, datatype num)//在元素右插入
{assert(sl);//判断数组中是否还有空间if (sl-position MAX){int sum sl-position;//创建一个变量等于数组中插入元素后的位置for (; sum n; sum--)//把坐标还原为数组的下标{sl-arr[sum] sl-arr[sum - 1];//把插入元素后的前一个元素向后移动}sl-arr[n] num;//把数组中的一个元素设置为传入的值sl-position;//元素位置向后移动}else{printf(空间不足\n);return;}
}查找我们把查找分为从左查找和从右查找分别为左边第一个找到我们所需要的数和右边第一个找到我们所需要的数。我们把返回值设为int类型如果找不到我们返回 -1。只有找到我们所需要的元素时才可以进行修改。 插入我们分为左边插入和右边插入左插入和正常插入逻辑一样所以默认也是左插入右插入只是边界和左插入不同代码实现逻辑一模一样。 修改修改则是通过我们查找到的元素的下标来进行修改的。如果找不到则不能进行修改。 下面是我们的测试函数
void test2()//进行插入查询修改
{SL sl;Initialization(sl);//初始话顺序表Popback(sl, 1);//进行头插Popback(sl, 2);Popback(sl, 2);Popback(sl, 2);Popback(sl, 3);printf(修改前);print(sl);if (-1 ! Seeklift(sl, 2))//左查找{printf(左查找查到的下标%d\n, Seeklift(sl, 2));Modify(sl, Seeklift(sl, 2), 7);//修改printf(修改后);print(sl);}if (-1 ! Seekright(sl, 2))//右查找{printf(右查找查到的下标%d\n, Seekright(sl, 2));Modify(sl, Seekright(sl, 2), 9);printf(修改后);print(sl);}Insertpos(sl, 3, 8);//按数组位置插入printf(按数组位置插入后);print(sl);Insertpos(sl, Seeklift(sl, 2), 3);//在元素左插入printf(在元素左插入后);print(sl);Insertright(sl, Seeklift(sl, 2), 4);//在元素右插入printf(在元素右插入后);print(sl);Destroy1(sl);
}
int main()
{test2();return 0;
}我们测试的逻辑是先进行头插5个元素分别进行左右查找并且进行修改最后在进行左右插入。
顺序表的升降排序和元素个数的返回
这里的排序我们都是使用的冒泡排序等到排序章节会改造为算法更优的排序方法。这里的升排序和降排序唯一的区别就是我们判断大小方式的不同。而我们返回元素个数则是直接返回我们结构体元素下标的总位置这个也是我们元素的总个数。
void Sortmax(SL* sl)//升排序
{assert(sl);//冒泡排序int i, j, temp;for (i 1; i sl-position; i){for (j 0; j sl-position - i; j){if (sl-arr[j] sl-arr[j 1]){temp sl-arr[j];sl-arr[j] sl-arr[j 1];sl-arr[j 1] temp;}}}
}
void Sortmin(SL* sl)//降排序
{assert(sl);//冒泡排序int i, j, temp;for (i 1; i sl-position; i){for (j 0; j sl-position - i; j){if (sl-arr[j] sl-arr[j 1]){temp sl-arr[j];sl-arr[j] sl-arr[j 1];sl-arr[j 1] temp;}}}
}
int Size(const SL *sl)//返回顺序表中元素个数
{assert(sl);return sl-position;
}下面是我们的测试代码
void test3()//进行升降排序
{SL* sl;sl InitializationList();//初始话顺序表Popback(sl, 1);Popback(sl, 5);Popback(sl, 3);Popback(sl, 4);Popback(sl, 2);printf(排序前);print(sl);Sortmax(sl);//升序排列printf(升序后);print(sl);Sortmin(sl);//降序排列printf(降序后);print(sl);printf(元素总个数%d, Size(sl));Destroy2(sl);
}
int main()
{test3();return 0;
}这里我们用的第二种初始化方式所以进行传参是不需要在加取地址符了。销毁函数也是用的第二个防止内存泄漏。
顺序表的合并
顺序表的合并我们是进行升序合并的而且也是两个升序的顺序表进行合并的。 下面是我们的思路
SL* Merge(const SL* sl1,const SL* sl2)//合并两个有序的顺序表
{assert(sl1 sl2);SL* sl (SL*)malloc(sizeof(SL));sl-position 0;int i 0;//用来访问数组中的元素int j 0;while (i sl1-position j sl2-position)//当任意一个数组中的元素到达尾部时结束循环{if (sl1-arr[i] sl2-arr[j])//判断数组中的元素大小谁小谁进行尾插{Pushback(sl, sl1-arr[i]);i;}else{Pushback(sl, sl2-arr[j]);j;}}if (i sl1-position)//判断哪一个数组到达了尾部把没到达尾部的数组元素进行尾插{while(j sl2-position){Pushback(sl, sl2-arr[j]);j;}}else{while (i sl1-position){Pushback(sl, sl1-arr[i]);i;}}return sl;
}合并的思路是先创建一个结构体然后两个结构体中的数组进行比较小的一方插入到我们创建的结构体中。然后当一个顺序表的元素用完时把另一个顺序表中的元素全部插入到我们创建的结构体中。 下面是我们的测试代码
void test4()//合并两个有序的顺序表
{SL *sl;SL sl1 { 3,{1,6,7}};SL sl2 { 3,{2,3,5}};printf(s1);print(sl1);printf(s2);print(sl2);sl Merge(sl1, sl2);//合并两个有序的顺序表printf(合并后);print(sl);Destroy2(sl);Destroy1(sl1);Destroy1(sl2);
}
int main()
{test4();return 0;
}1.顺序表的动态实现
顺序表的创建
顺序表的动态实现本质是通过指针来实现的。
typedef int datatype;
typedef struct SList//定义顺序表的结构体
{datatype* num;//数据类型的指针int sz;//数据元素的个数int max;//数据元素的最大个数
}TSL;这里我们把之前的数组改为相应的指针类型但是额外的加入了一个元素的最大个数元素的最大个数是用来判断我们当前的存储是否已满存储满的话就要进行扩容了。
顺序表的初始化打印和销毁
void InitIalization(TSL* sl)//初始话顺序表
{sl-max 4;//数据初始元素最大为4个sl-sz 0;//数据的起始元素为0个sl-num (datatype*)malloc(sizeof(datatype) * sl-max);
}这里我们把开始的容量设置为4当我们元素的个数和我们的容量大小相同时我们就要进行扩容了。这里我们只写了初始化的代码打印和销毁代码和静态的实现方式一模一样。
顺序表的增加和删除
void Expansion(TSL* sl)//进行扩容
{datatype* sl1 (datatype*)realloc(sl-num, sizeof(datatype) * (sl-max * 2));{if (sl1 NULL)//判断是否开辟空间成功{perror(sl1 err\n);//开辟失败进行报错return;}else{sl-num sl1;sl-max * 2;//更改容量的大小}}
}
void PopBack(TSL* sl, datatype n)//头插
{assert(sl);if (sl-sz sl-max)//判断空间是否已满,满则扩容{Expansion(sl);//传递的是sl的地址不是sl存放的地址}int i 0;for (i sl-sz; i 0; i--){sl-num[i] sl-num[i - 1];//把插入元素后的前一个元素向后移动}sl-num[0] n;//把数组中的一个元素设置为传入的值sl-sz;//元素位置向后移动
}这里我们可以看到进行增加的代码逻辑和静态的一模一样只是多了一个扩容的操作。 注意我们要注意增容可能会失败所以不能直接用我们的地址而是先创建一个结构体创建成功后在把我们的创建赋给我们原结构体。 我们这里只演示了头插的代码尾插的逻辑和静态一样只是把判断代码换成是否要扩容的判断。 下面是演示代码
void test5()
{TSL sl;InitIalization(sl);//初始话顺序表PopBack(sl, 4);PopBack(sl, 3);PopBack(sl, 2);PopBack(sl, 1);Print(sl);PushBack(sl, 5);PushBack(sl, 6);PushBack(sl, 7);PushBack(sl, 8);Print(sl);PopFornt(sl);Print(sl);PushFornt(sl);Print(sl);DEstroy(sl);
}
int main()
{test5();
}动态顺序表的总结
动态顺序表只是在判断是否已满的地方多加一个扩容的函数其他的代码和静态一模一样思路也一模一样我们把静态中的数组换为相应的指针可以通过动态开辟的方式来进行增容。我们的增容是对结构体中的指针进行增容而非对结构体本身进行增容。
1.顺序表的动态代码
动态测试代码
//main1.c 动态测试代码
#includemain1.h
void test5()
{TSL sl;InitIalization(sl);//初始话顺序表PopBack(sl, 4);PopBack(sl, 3);PopBack(sl, 2);PopBack(sl, 1);Print(sl);PushBack(sl, 5);PushBack(sl, 6);PushBack(sl, 7);PushBack(sl, 8);Print(sl);PopFornt(sl);Print(sl);PushFornt(sl);Print(sl);DEstroy(sl);
}
void test6()
{TSL sl;InitIalization(sl);//初始话顺序表PopBack(sl, 3);PopBack(sl, 2);PopBack(sl, 2);PopBack(sl, 2);PopBack(sl, 1);Print(sl);if (-1 ! SeekLift(sl, 2))//左查找{printf(%d\n, SeekLift(sl, 2));MODify(sl, SeekLift(sl, 2), 20);//修改Print(sl);}if (-1 ! SeekRight(sl, 2))//右查找{printf(%d\n, SeekRight(sl, 2));MODify(sl, SeekRight(sl, 2), 200);Print(sl);}InsertPos(sl, 3, 8);//按数组位置插入Print(sl);InsertPos(sl, SeekLift(sl, 2), 33);//在元素左插入Print(sl);InsertRight(sl, SeekLift(sl, 2), 44);//在元素右插入Print(sl);printf(%d\n, SIze(sl));DEstroy(sl);
}
void test7()
{TSL sl;InitIalization(sl);//初始话顺序表PopBack(sl, 1);PopBack(sl, 5);PopBack(sl, 3);PopBack(sl, 4);PopBack(sl, 2);Print(sl);SortMax(sl);//升序排列Print(sl);SortMin(sl);//降序排列Print(sl);DEstroy(sl);
}
void test8()
{TSL* sl;TSL sl1;InitIalization(sl1);//初始话顺序表TSL sl2;InitIalization(sl2);//初始话顺序表PushBack(sl1, 1);PushBack(sl1, 6);PushBack(sl1, 7);PushBack(sl2, 2);PushBack(sl2, 3);PushBack(sl2, 5);Print(sl1);Print(sl2);sl MErge(sl1, sl2);//合并两个有序的顺序表Print(sl);DEstroy(sl);DEstroy(sl1);DEstroy(sl2);
}
int main()
{test5();test6();test7();test8();return 0;
}动态实现头文件
//main1.h 动态头文件
#pragma once
#define _CRT_SECURE_NO_WARNINGS
#includestdio.h
#includestdlib.h
#includeassert.h
#define MAX 10
typedef int datatype;
typedef struct SList//定义顺序表的结构体
{datatype* num;//数据类型的指针int sz;//数据元素的个数int max;//数据元素的最大个数
}TSL;
void InitIalization(TSL* sl);//初始话顺序表
void PopBack(TSL* sl, datatype n);//头插
void PopFornt(TSL* sl);//头删
void PushBack(TSL* sl, datatype n);//尾插
void PushFornt(TSL* sl);//尾删
int SeekLift(const TSL* sl, datatype n);//左查找
int SeekRight(const TSL* sl, datatype n);//右查找
void MODify(TSL* sl, int n, datatype num);//修改
void InsertPos(TSL* sl, int n, datatype num);//按数组位置插入,在元素左插入
void InsertRight(TSL* sl, int n, datatype num);//在元素右插入
void SortMax(TSL* sl);//升排序
void SortMin(TSL* sl);//降排序
int SIze(const TSL* sl);//返回顺序表中元素个数
TSL* MErge(TSL* sl1, TSL* sl2);//合并两个有序的顺序表
void Print(const TSL* sl);//打印顺序表
void DEstroy(TSL* sl);//销毁顺序表动态具体函数的实现
//test1.c 动态具体函数的实现
#includemain1.h
void InitIalization(TSL* sl)//初始话顺序表
{sl-max 4;//数据初始元素最大为4个sl-sz 0;//数据的起始元素为0个sl-num (datatype*)malloc(sizeof(datatype) * sl-max);
}
void Expansion(TSL* sl)//进行扩容
{datatype* sl1 (datatype*)realloc(sl-num, sizeof(datatype) * (sl-max * 2));{if (sl1 NULL)//判断是否开辟空间成功{perror(sl1 err\n);//开辟失败进行报错return;}else{sl-num sl1;sl-max * 2;//更改容量的大小}}
}
void PopBack(TSL* sl, datatype n)//头插
{assert(sl);if (sl-sz sl-max)//判断空间是否已满,满则扩容{Expansion(sl);}int i 0;for (i sl-sz; i 0; i--){sl-num[i] sl-num[i - 1];//把插入元素后的前一个元素向后移动}sl-num[0] n;//把数组中的一个元素设置为传入的值sl-sz;//元素位置向后移动
}
void PopFornt(TSL* sl)//头删
{assert(sl);int i 0;for (i 0; i sl-sz; i){sl-num[i] sl-num[i 1];}sl-sz--;
}
void PushBack(TSL* sl, datatype n)//尾插
{assert(sl);if (sl-sz sl-max){Expansion(sl);}sl-num[sl-sz] n;sl-sz;
}
void PushFornt(TSL* sl)//尾删
{assert(sl);sl-sz--;
}
int SeekLift(const TSL* sl, datatype n)//左查找
{assert(sl);int i 0;for (i 0; i sl-sz; i){if (sl-num[i] n){return i 1;//数组下标从0开始所以返回位置进行加1}}return -1;
}
int SeekRight(const TSL* sl, datatype n)//右查找
{assert(sl);int i sl-sz - 1;for (; i 0; i--){if (sl-num[i] n){return i 1;}}return -1;
}
void MODify(TSL* sl, int n, datatype num)//修改
{assert(sl);sl-num[n - 1] num;
}
void InsertPos(TSL* sl, int n, datatype num)//按数组位置插入,在元素左插入
{assert(sl);//判断数组中是否还有空间if (sl-sz sl-max){Expansion(sl);}int sum sl-sz;//创建一个变量等于数组中插入元素后的位置for (; sum n - 1; sum--)//把坐标还原为数组的下标{sl-num[sum] sl-num[sum - 1];//把插入元素后的前一个元素向后移动}sl-num[n - 1] num;//把数组中的一个元素设置为传入的值sl-sz;//元素位置向后移动
}
void InsertRight(TSL* sl, int n, datatype num)//在元素右插入
{assert(sl);//判断数组中是否还有空间if (sl-sz sl-max){Expansion(sl);}int sum sl-sz;//创建一个变量等于数组中插入元素后的位置for (; sum n ; sum--)//把坐标还原为数组的下标{sl-num[sum] sl-num[sum - 1];//把插入元素后的前一个元素向后移动}sl-num[n] num;//把数组中的一个元素设置为传入的值sl-sz;//元素位置向后移动
}
void SortMax(TSL* sl)//升排序
{assert(sl);//冒泡排序int i, j, temp;for (i 1; i sl-sz; i){for (j 0; j sl-sz - i; j){if (sl-num[j] sl-num[j 1]){temp sl-num[j];sl-num[j] sl-num[j 1];sl-num[j 1] temp;}}}
}
void SortMin(TSL* sl)//降排序
{assert(sl);//冒泡排序int i, j, temp;for (i 1; i sl-sz; i){for (j 0; j sl-sz - i; j){if (sl-num[j] sl-num[j 1]){temp sl-num[j];sl-num[j] sl-num[j 1];sl-num[j 1] temp;}}}
}
int SIze(const TSL* sl)//返回顺序表中元素个数
{assert(sl);return sl-sz;
}
TSL* MErge(TSL* sl1, TSL* sl2)//合并两个有序的顺序表
{assert(sl1 sl2);TSL* sl (TSL*)malloc(sizeof(TSL));if (sl NULL)//判断是否为空{perror(malloc: );//报错且退出return;}InitIalization(sl);int i 0;//用来访问数组中的元素int j 0;while (i sl1-sz j sl2-sz)//当任意一个数组中的元素到达尾部时结束循环{if (sl1-num[i] sl2-num[j])//判断数组中的元素大小谁小谁进行尾插{if (sl-sz sl-max){Expansion(sl);}PushBack(sl, sl1-num[i]);i;}else{if (sl-sz sl-max){Expansion(sl);}PushBack(sl, sl2-num[j]);j;}}if (i sl1-sz)//判断哪一个数组到达了尾部把没到达尾部的数组元素进行尾插{while (j sl2-sz){if (sl-sz sl-max){Expansion(sl);}PushBack(sl, sl2-num[j]);j;}}else{while (i sl1-sz){if (sl-sz sl-max){Expansion(sl);}PushBack(sl, sl1-num[i]);i;}}return sl;
}
void Print(const TSL* sl)//打印顺序表
{int i 0;for (i 0; i sl-sz; i){printf(%d , sl-num[i]);}printf(\n);
}
void DEstroy(TSL* sl)//销毁顺序表
{assert(sl);free(sl-num);sl-num NULL;sl-max 0;sl-sz 0;
}总结
大家可以对比一下静态和动态的区别动态只是在静态的基础上稍稍的进行一下改进增加一个扩容的函数其他的一模一样我们下一个将会用一个小项目来加深我们顺序表印象这是我们的第一个数据结构我们还要用它和后面的链表进行对比。学习每个结构的优缺点是我们在不同问题上选择最优的方案。
