第二章——线性表

Posted 2020-10-05

线性表

一、定义

线性表是最常用且最简单的一种数据结构。

简而言之，一个线性表是n个数据元素的有限的序列。

线性表中数据元素之间的关系是一对一的关系，即除了第一个和最后一个数据元素之外，其它数据元素都是首尾相接的

（注意，这句话只适用大部分线性表，而不是全部。比如，循环链表逻辑层次上也是一种线性表（存储层次上属于链式存储），但是把最后一个数据元素的尾指针指向了首位结点）。by~百度百科

二、线性表的顺序表示和实现

1.顺序表示指的是用一组地址连续的储存单元依次储存线性表的数据元素。

   通常用数组来描述数据结构中的顺序存储结构。

2.顺序表的实现（以int数组为例）

 1 typedef struct List
 2 {
 3     int *elem;  //存储空间地址
 4     int length; //当前长度
 5     int listsize; //当前分配的储存容量
 6 };
 7 bool InitList (List &L,int list_init_size)
 8 {
 9     L.elem=(int*)malloc(list_init_size*sizeof(int));
10     if(!L.elem)
11         return false;
12     L.length=0;
13     L.listsize=list_init_size;
14     return true;
15 }

 

3.顺序表的插入删除操作

 1 bool ListInsert(List &L,int pos,int date)
 2 {
 3     //在线性表的第Pos个位置之前插入元素date
 4     if(pos<1||pos>L.length+1)  //pos值不合法
 5         return false;
 6     if(L.length>=L.listsize)  //线性表已满
 7     {
 8         int *newbase = (int*)realloc(L.elem,L.listsize*2*sizeof(int));//改变指针指向的内存大小
 9         if(!newbase)
10             return false; //分配失败
11         //free(L.elem);
12         L.elem=newbase;
13         L.listsize=L.listsize*2;
14     }
15     int *q=&(L.elem[pos-1]);
16     for(int *p=&(L.elem[L.length-1]);p>=q;p--)
17     {
18         *(p+1)=*(q);
19     }
20     *q=date;
21     L.length++;
22     return true;
23 }

3.有序顺序表的合并操作

 1 bool MergeList (List La,List Lb,List Lc)
 2 {
 3     //合并两个非递减排序的线性表为新的线性表
 4     int *pa=La.elem;
 5     int *pb=Lb.elem;
 6     Lc.listsize=Lc.length=La.length+Lb.length;
 7     int *pc=Lc.elem=(int* )malloc(Lc.listsize*sizeof(int));
 8     if(!Lc.elem)
 9         return false;
10     int *pa_last=La.elem+La.length-1;
11     int *pb_last=Lb.elem+Lb.length-1;
12     while(pa<=pa_last&&pb<=pb_last)
13     {
14         if(*pa<=*pb)
15             *pc++=*pa++;
16         else
17             *pc++=*pb++;
18     }
19     while(pa<=pa_last)
20         *pc++=*pa++;
21     while(pb<=pb_last)
22         *pb++=*pb++:
23     return true;
24 }

三.线性表的链式实现（即链表）

线性表的链式存储结构的特点是用一组任意的存储单元存储线性表的数据结构（这组存储单元可以是连续的，也可以是不连续的）

线性表的链式存储结构其实又可以成为链表，可以在较低的复杂度情况下实现数据的插入与删除。

如同，链表就像一个链子，利用指针，将原本分散的一个一个元素串联起来。

1.链表结构的实现

typedef struct LNode
{
    int date;
    struct LNode *next;
}LNode,*LinkList;//LinkList作为头指针;

2.获得第i个元素的值

 1 bool GetElem(LinkList L,int i,int &e)
 2 {
 3     //当第i个元素存在时，将其值赋给e并返回true，否则返回false;
 4     LinkList p=L->next;
 5     int j=1;
 6     while(!p||j<i)
 7     {
 8         p=p->next;
 9         j++;
10     }
11     if(!p||j>i)
12         return false;
13     e=p->date;
14     return true;
15 }

3.合并两个有序链表

 1 bool MergeList_ (LinkList &La,LinkList &Lb,LinkList &Lc)
 2 {
 3     LinkList pa=La->next;
 4     LinkList pb=Lb->next;
 5     LinkList pc=LC=La;
 6     while(pa&&pb)
 7     {
 8         if(pa->date<=pb->date)
 9         {
10             pc->next=pa;
11             pc=pa;
12             pa=pa->next;
13         }
14         else
15         {
16             pc->next=pb;
17             pc=pb;
18             pb=pb->next;
19         }
20     }
21     pc->next=pa?pa:pb;
22     free(Lb);
23     return true;
24 }