【数据结构复习】（2）线性表（一）

线性表的定义

　　线性表是最简单的数据结构，一个线性表是由n个数据元素的有限序列。具有下列特点：

　　　　（1）存在唯一一个被称为“第一个”的数据元素；

　　　　（2）存在唯一一个被称为“最后一个”的数据元素；

　　　　（3）除了第一个之外，集合中的每一个数据元素均只有一个前驱；

　　　　（4）除最后一个之外，集合中的每一个数据元素均只有一个后继。

线性表的实现

　　下面在Visual Stduio C++ 6.0环境下对线性表的实现进行描述。由于线性表中的数据元素可以为许多类型（int、float、char等等），为了方便起见，只介绍int型作为线性表的数据元素的类型的线性表。并且在《数据结构（C语言版）》中，线性表中元素的脚码是从1开始，而在C语言中，脚码均是从0开始。因此，在下面的介绍中，a0为第一个元素，a1为第二个元素，以此类推。

线性实现

　　线性表的顺序实现指的是用一组地址连续的存储单元依次存储线性表的数据元素。由于每个数据元素的大小均确定，根据数据元素的脚码与线性表第一个数据元素的存储位置（即基地址），即可确定任一数据元素的位置。所以线性表的顺序存储结构是一种随机存取的存储结构。

　　高级语言中一般使用数据来描述数据结构中顺序存储结构，因为它们具有比较相似的特性。

需要的一些共有信息

1 #include <stdlib.h>
2 #include <stdio.h>
3 #define Status int
4 #define OK 0
5 #define ERROR -1

线性表的结构

1 #define LIST_INIT_SIZE 100        //线性表的初始分配量
2 #define LISTINCREMENT 10        //线性表的分配增量
3 typedef struct 
4 {
5     int *elem;                    //线性表的基址
6     int length;                    //当前长度
7     int listsize;                //当前分配的存储容量(最大长度)
8 }SqList,*pSqList;

线性表的初始化函数InitList_Sq

1 Status InitList_Sq(pSqList L)
2 {
3     //构造一个空的线性表L
4     L=(pSqList)malloc(sizeof(SqList));    //为线性表分配空间
5     L->elem=(int*)malloc(sizeof(int)*LIST_INIT_SIZE);
6     L->length=0;                        //当前长度为0
7     L->listsize=LIST_INIT_SIZE;            //最大长度为初始分配量
8     return OK;
9 }

 

 线性表的插入函数ListInsert_Sq

 

 1 Status ListInsert_Sq(pSqList L,int i,int e)
 2 {
 3     //在顺序线性表L中第i个位置之前插入新的元素e
 4     //i的合法性为0<=i<=ListLength_Sq(L)
 5     if(i<0||i>L->length)    //i值不合法 
 6         return ERROR;  
 7     if(L->length>=L->listsize)    //当前存储空间已满
 8     {
 9         int* newbase=(int*)realloc(L->elem,(L->listsize+LISTINCREMENT)*sizeof(int)); //分配新的空间
10         if(!newbase)     //分配失败
11             exit(ERROR);
12         L->elem=newbase;    //新基址
13         L->listsize+=LISTINCREMENT;    //新的最大长度
14     }
15 
16     
17     for(int j=L->length;j>i;j--)
18     {
19         //i为新元素在顺序表中的位置,数组中第i个以及第i个之后的所有元素都要右移
20         L->elem[j]=L->elem[j-1];
21     }
22     L->elem[i]=e;    //插入e
23     L->length++;    //表长增1
24     return OK;
25 }

线性表的删除函数ListDelete_Sq

 1 Status ListDelete_Sq(pSqList L,int i,int* e)
 2 {
 3     //在线性表L中删除第i个元素，并用e返回其值
 4     if(i<0||i>=L->length)    //i值不合法
 5         return ERROR;
 6     *e=L->elem[i]; //被删除元素赋予*e
 7     for(int j=i;j<L->length;j++)    
 8     {
 9         //被删除元素之后的元素左移
10         L->elem[j]=L->elem[j+1];
11     }
12     L->length--;
13     return OK;
14 }

线性表查找函数LocateElem_Sq

 1 int LocateElem_Sq(pSqList L,int e,Status (*compare)(int ,int ))
 2 {
 3     //在顺序线性表L中查找第1个值与e满足compare()的元素的位序
 4     //若找到，则返回其在L中的位序，否则返回-1
 5     for(int i=0;i<L->length;i++)
 6     {
 7         if(!compare(e,L->elem[i])) //不满足compare则继续查找
 8             continue;
 9         else        //满足compare则退出循环
10             break;
11     }
12     if(i==L->length)  //没有找到与e比较后相等的元素
13         return -1;
14     else        //返回相应的元素位序
15         return i;
16 }

 

线性表的合并函数MergeList_Sq

 1 void MergeList_Sq(pSqList La,pSqList Lb,pSqList Lc)
 2 {
 3     //已知顺序线性表La和Lb的元素按值非递减排列
 4     //归并La和Lb得到新的顺序线性表Lc,Lc的元素也按值非递减排列
 5 
 6     Lc=(pSqList)malloc(sizeof(SqList)); //为Lc分配空间
 7     Lc->listsize=La->length+Lb->length;  //Lc的已使用长度
 8     Lc->length=La->length+Lb->length;    //Lc的最大长度
 9 
10     Lc->elem=(int *)malloc(sizeof(int)*Lc->listsize);    //分配线性表的存储空间
11     if(!Lc)  //分配失败
12     {
13         free(Lc);
14         exit(ERROR);
15     }
16 
17     //开始归并
18     int pa=0;    //指向La表的首元
19     int pb=0;    //指向Lb表的首元
20     int pc=0;    //指向Lc表的首元
21     while(pa<La->length&&pb<Lb->length)
22     {
23         if(La->elem[pa]<Lb->elem[pb])
24         {
25             Lc->elem[pc]=La->elem[pa];
26             pa++;
27             pc++;
28         }
29         else
30         {
31             Lc->elem[pc]=Lb->elem[pb];
32             pb++;
33             pc++;
34         }
35     }
36 
37     //插入剩余元素
38     while(pa<La->length)
39     {
40         Lc->elem[pc]=La->elem[pa];
41         pa++;
42         pc++;        
43     }
44     while(pb<Lb->length)
45     {
46         Lc->elem[pc]=Lb->elem[pb];
47         pb++;
48         pc++;
49     }
50 }