动态分配的顺序线性表的十五种操作—C语言实现

 1 /************************************************************************/
 2 /*函数定义在此文件                                                    */
 3 /************************************************************************/
 4 #include "ADT.h"
 5 /************************************************************************/
 6 /*第一类：初始化操作，记住各种数据结构开始使用都要初始化                */
 7 /************************************************************************/
 8 
 9 //注意c数组下标从0开始，但是用户并不知道，一般都是选择从1到length的位置，以用户的角度看问题
10 
11 //1、线性表的初始化，构造一个空的线性表,因为要改变线性表，必须用指针做参数
12 int InitList(SqList *L)
13 {
14     //在堆中为线性表分配内存,初始化elem为该内存空间的首地址（基址）
15     L->elem = (int *)malloc(LIST_INIT_SIZE * sizeof(int));//结构里只是存储了表的地址值，而表本身存储在其他地方
16     //判断是否分配成功
17     if (!L->elem)//如果 !L->elem 为真（为空），执行下面代码
18     {
19         printf("线性表内存分配失败！退出程序。\n");
20         exit(1);//函数异常退出，返回给操作系统1
21     }
22     //表内存空间分配成功
23     L->length = 0;//开始是空表,没有存储任何元素，故表长置为0
24     //当前为线性表分配的存储容量
25     L->listsize = LIST_INIT_SIZE;//初始化表的存储容量，这是当前表最大的存储量
26     return 0;//分配成功返回0
27 }

 1 /************************************************************************/
 2 /*第二类：销毁操作，记住各种数据结构使用了都要有销毁的步骤              */
 3 /************************************************************************/
 4 
 5 //2、释放内存，销毁表操作,直接把内存释放的操作！类似free（）和c++的delete操作符
 6 //注意：用malloc函数分配的空间在释放时是连续释放的，即将物理地址相邻的若干空间全部释放
 7 //所以顺序表销毁可以只释放基址，就自动释放所有空间，而链表要一个一个的把节点删除
 8 void Destory(SqList *L)
 9 {
10     if (L->elem)//如果当前表还存在
11     {
12         free(L->elem);//销毁之
13         //内存都没了，整个表也就不存在了，别的不用管。
14         printf("本线性表已销毁！\n");
15     }
16 }

 1 /************************************************************************/
 2 /* 第三类：引用型操作，操作不改变线性表里的数据元素，也不改变他们之间的关系
 3 /************************************************************************/
 4 
 5 //3、判空操作
 6 void ListEmpty(SqList L)
 7 {
 8     //判断表是否存在
 9     if (L.elem)
10     {
11         //判断是否存储了内容
12         if (0 == L.length)
13         {
14             puts("本表为空!");//自动换行
15         }
16         else
17         {
18             puts("表不为空！");
19         }
20     }
21     else
22     {
23         puts("表不存在!");
24     }
25 }

 1 //4、求长度操作，若线性表已经存在，则返回表L中元素个数
 2 int ListLength(SqList L)
 3 {
 4     if (L.elem)
 5     {
 6         return L.length;
 7     }
 8     puts("表不存在，无法求长度！");
 9     return 0;
10 }

 1 //5、定位操作：线性表 L 已存在，返回 L 中第 1 个与 e 满足相等关系的元素位置。
 2 int LocateElem(SqList L, int e)
 3 {
 4     int i;//定位
 5     for (i = 0; i < L.length; i++)
 6     {
 7         //数组名本身就是数组的首地址
 8         if (e == L.elem[i] && i < L.length)
 9         {
10             printf("定位成功，该元素的位置 = %d\n", i + 1);
11             return i + 1;
12         }
13     }
14     puts("定位失败！没有找到该元素");
15     return 0;
16 }

 1 //6、求元素后继，线性表 L 已存在。若 cur_e是 L 中的元素，返回后继
 2 void NextElem(SqList L, int cur_e)
 3 {
 4     int i = LocateElem(L, cur_e);//先定位参照元素的位置
 5 
 6     if (0 != i)
 7     {
 8         if (i == L.length)
 9         {
10             puts("这是最后一个元素，没有后继！");
11         }
12         else
13         {
14             printf("%d的后继是%d\n", L.elem[i - 1], L.elem[i]);
15         }
16     }
17     else
18     {
19         puts("表中没有这个元素！");
20     }
21 }

 1 //7、得到指定的元素值，线性表 L 已存在, e 返回 L 中第 i 个元素的值。 
 2 int GetElem(SqList L, int i, int e)
 3 {
 4     if (i < 1 || i > L.length)
 5     {
 6         puts("超出了查找范围，重新输入！");
 7         return 0;
 8     }
 9     e = L.elem[i - 1];
10     return e;
11 }

 1 int GetElem(SqList L, int i, int *e)
 2 {
 3     if (i < 1 || i > L.length)
 4     {
 5         puts("超出了查找范围，重新输入！");
 6         return 0;
 7     }
 8     *e = L.elem[i - 1];
 9     printf("%d\n", *e);
10     return *e;
11 }

 1 /8、求元素前驱，线性表L已经存在，若cur_e是L的数据,则返回前驱
 2 void PriorElem(SqList L, int cur_e)
 3 {
 4     int i = LocateElem(L, cur_e);//如果定位失败返回0
 5 
 6     if (0 != i)
 7     {
 8         if (1 == i)
 9         {
10             puts("这是第一个元素，没有前驱！");
11         }
12         else
13         {
14             printf("找到了%d的前驱%d \n",  L.elem[i - 1], L.elem[i - 2]);
15         }
16     } 
17     else
18     {
19         puts("找不到这个元素！");
20     }
21 }

 1 //9、遍历表中元素，线性表 L 已存在，打印出表中每个元素 
 2 void ListTraverse(SqList L)
 3 {
 4     int i;
 5 
 6     for (i = 0; i < L.length; i++)
 7     {
 8         printf("%5d", L.elem[i]);
 9     }
10 
11 }

 1 /************************************************************************/
 2 /* 第四类：加工型操作                                                   */
 3 /************************************************************************/
 4 
 5 //10、把表清空（不释放内存），线性表 L 已存在，将 L 重置为空表。 
 6 void ClearList(SqList *L)
 7 {
 8     if (L->elem)
 9     {
10         L->length = 0;//顺序表置空，表长为0即可
11     }
12 }

 1 //11、给表元素赋值，线性表 L 已存在，1≤i≤LengthList(L)
 2 //L 中第 i 个元素赋值为 e  
 3 void PutElem(SqList *L, int i, int e )
 4 {
 5     if (i < 1 || i > L->length)
 6     {
 7         puts("超出表范围！");
 8     }
 9     L->elem[i - 1] = e;
10 }

 1 //12、插入操作，线性表 L 已存在，1≤i≤LengthList(L)+1。在 L 的第 i 个元素之前插入新的元素 e，L 的长度增 1。 
 2 void ListInsert(SqList *L, int i, int e )
 3 {
 4     SqList *NL;//声明一个额外的结构指针指向重新分配的表内存空间
 5     int *j;
 6     int *k;
 7     //注意c数组下标从0开始，但是用户并不知道，一般都是选择从1到length的位置，以用户的角度看问题
 8     //在元素i之前插入，则把i和i后面的全部元素顺次后移一位
 9     if (i < 1 || i > L->length + 1)//最后一个元素后一位插入合法，不用移动直接插即可
10     {
11         puts("超出表范围！");
12     }
13     //考虑问题要全，因为可能会不止一次插入操作，早晚会超出表的存储容量
14     else if (L->length >= L->listsize)
15     {
16         //重新分配内存，增加存储空间
17         NL->elem = (int *)realloc(L->elem, (L->listsize + LISTINCREMENT) * sizeof(int));
18         if (!NL->elem)//分配失败，返回NULL
19         {
20             exit(0);//退出
21         }
22         //分配成功
23         L->elem = NL->elem;//得到扩大之后的新基址
24     }
25     //指示用户的实际插入位置
26     j = &(L->elem[i - 1]);//数组下标从0开始
27     //最后一个数据元素的实际位置是length-1
28     for (k = &(L->elem[L->length - 1]); k >= j; k--)//这里k--不是1的减量！而是指针的减量操作，每次是int类型字节大小变化
29     {
30         *(k + 1) = *k;//从j到k的元素顺次后移一位
31     }
32     *j = e;//完成插入
33     L->length++;//别忘表长加1
34 }

 1 //13、删除操作，表 L 已存在且非空，1≤i≤LengthList(L)。删除 L 的第 i 个元素，并用 e 返回其值，长度减 1。 
 2 void ListDelete(SqList *L, int i, int *e )
 3 {
 4     int *p;
 5 
 6     if (i < 1 || i > L->length)
 7     {
 8         puts("i的值不合法！重新输入！");
 9     } 
10     else
11     {
12         //找到被删除元素的实际位置
13         p = &(L->elem[i - 1]);
14         *e = L->elem[i - 1];
15         //p（不包含p）后面的元素依次前移一位
16         for (; p < &(L->elem[L->length - 1]); p++)
17         {
18             *p = *(p + 1);
19         }
20         L->length--;
21     }
22 }