线性表

线性表(List)：零个或多个数据元素的有限序列。

首先它是一个序列，也就是说，元素之间是有顺序的，若元素存在多个则第一个元素无前驱，第二个元素无后继，其他每个元素都有一个前驱和后继。

                                                                                                                  图1. 线性表

线性表元素的个数n（n > 0）定义为线性表的长度，当n = 0时，称为空表。

在非空表中的每一个数据元素都有一个确定的位置，如a1是一个个元素，an是最后一个元素，ai是第i个元素，称i为数据元素ai在线性表中的位序。

顺序存储结构：

线性表的顺序存储结构，指的是用一段地址连续的存储单元依次存储线性表的数据元素。

对于顺醋存储方式我们可以采用一维数组来实现顺序存储结构。顺序存储结构的代码如下：

#define MAXSIZE 20typedef int ElemType;typedef struct{    ElemType data[MAXSIZE];    int length;} SqList;

用数组存储顺序表意味着要分配固定长度的数组空间，由于线性表中可以进行插入和删除操作，因此分配的数组空间要大于当前线性表的长度。

获取元素操作：

获取元素操作，对于线性表的顺序储存结构来说，如果我们要实现GetElem操作，即使线性表L中的第i个位置元素值返回，其实是非常简单的。就程序而言，只要i的数值在数组下标范围内，就是把数组第i -1下标的值返回即可。代码如下：

#define OK 1#define ERROR 0#define TRUE 1#define FALSE 0typedef int Status;Status GetElem(SqList L, int i, ElemType *e){      if(L.length == 0 || i < 1 || i >L.length)      return ERROR;     *e = L.data[i -1];      return OK;}

插入操作：

插入算法的思路：

如果插入位置不合格，得出异常；

如果线性表长度大于等于数组长度，则抛出异常或动态增加容量；

从最后一个元素开始向前遍历到第i个位置，分别将它们都向后移动一位；

将要插入元素填入位置i处；

表长加1；

实现代码如下

Status ListInsert(SqList *L, int i, ElemType e){      int k;      if(L->length == MAXSIZE)          return ERROR;     if(i < 1 || i > L->length +1)          return ERROR;     if(i <= L->length)     {            for(k = L->length - 1; k >= i -1; k--)           L->data[k+1]=L->data[k];      }      L->data[i -1] = e;      L->length ++;      return OK;}

删除操作：

删除算法的思路如下：

如果删除位置不合理抛出异常；

取出删除元素；

从删除元素位置开始遍历到最后一个元素位置，分别将它们都向前移动一位；

表长减1；

实现代码如下：

Status ListDelete(SqList *L, int i,ElemType *e){       int k;       if(L->length == 0)            return ERROR;       if(i < 1 || i> L->length)            return ERROR;       *e = L->data[i -1];       if(i < L->length)       {             for(k = i; k< L->length; k++)             {                     L-data[k -1] = L->data[k];              }       }       L->length--;       return OK;}

线性表的链式存储：
线性表的最大缺点就是插入和删除时需要移动大量元素，这需要耗费时间。

线性表的链式存储的特点是-----用一组任意的存储单元存储线性表的数据元素，这组存储单元可以是连续的，也可以是不连续的，这就以为着，这些数据元素可以存在内存未被占用的任意位置。

在顺序存储机构中，每个数据元素只需要存储数据元素信息就可以了，在链式表结构中，除了要存储数据元素信息外，还要存储它的后继元素的存储地址。

我们把存储数据元素的信息的域称为数据域，把存储后继位置的域称为指针域。我们把链表中第一个结点点存储位置叫做头指针。最后一个结点的指针域为空（用NULL表示）。

有时我们为了方便对链表进行操作，会在单链表的第一个结点前附设一个节点，称为头节点。头节点的数据域可以不存储任何信息，也可以存储如线性表的长度等附加信息，头节点的指针域存储指向第一个结点的指针。

头指针与头结点的异同：

                                                                     图2.头指针与头结点的异同

                                                                                         图3. 单链表

                                                                                                 图4. 带头结点的单链表

用C语言描述的单链表：

typedef struct Node{      ElemType  data;      struct  Node   *next;}  Node;typedef struct Node *LinkList;

单链表的读取：

获取链表第i个数据元素的算法思路：

1.声明一个结点p指向链表第一个结点，初始化j从1开始；

2.当j<i时，就遍历链表，让p的指针向后移动，不能指向下一结点，j累加1；

3.若到链表末尾p为空，则说明第i个元素不存在；

4.否则查找成功，返回结点p的数据；

实现代码如下：

Status GetElem(LinkList L, int i, ElemType *e){      int j;      LinkList p;      p = L->next;      j = 1;      while(p && j < i)      {             p = p->next;              ++j;      }      if( !p || j > i)           return ERROR;      *e = p->data;      return  OK;}

单链表的插入：

单链表第i个数据插入的算法思路：

1.声明一结点p指向链表第一个结点，初始化j从1开始；

2.当j<i时，就遍历链表，让p的指针向后移动，不断指向下一个结点，j累加1；

3.若到链表末尾p为空，则说明第i个元素不存在；

4.否则查找成功，在系统中生成一个空结点s；

5.将数据元素e赋值给s->data；

6.单链表的插入标准语句s->next=p->next;  p->next = s;

7.返回成功。

实现代码如下：

Status ListInsert(LinkList *L, int i, ElemType e){     int j;     LinkType p ,s;     p = *L;     j = 1;     while(p && j < i){           p = p->next;           ++j;      }       if(!p || j >i)            return ERROR;      s = (LinkList)malloc(sizeof(Node));      s->data = p->next;      p->next = s;      return OK;}

单链表的删除：

单链表第i个数据删除结点的算法思路：

1.声明一个结点p指向链表第一个结点，初始化j从i开始；

2.当j < i时，就遍历链表，让p的指针向后移动，不断指向下一个结点，j累加1；

3.若到链表末尾p为空，则说明第i个元素不存在；

4.否则查找成功，将欲删除的结点p->next赋值给q;

5.单链表的删除标准语句p->next=q->next;

6.将q结点中的数据赋值给e，作为返回；

7.释放q结点；

8.返回成功。

实现代码如下：

Status ListDelete(LinkList *L, int i, ElemType *e){      int j;      LinkList p,q;      p = *L;      j = 1;      while(p->next && j < i)      {              p = p->next;              ++j;      }       if(!(p->next) || j > i)             return ERROR;       q = p->next;       p->next = q->next;       *e = q->data;       free(q);       return OK;}

单链表的整表创建：

思路如下：

1.声明一结点p和计数器变量i;

2.初始化一空链表L;

3.让L的头结点的指针指向NULL，即建立一个带头结点的单链表；

4.循环：

生成一新结点赋值给p；

随机生成一数字赋值给p的数据域p->data;

将p插入到头结点与前一节点之间。

实现代码如下：

void CreatListTail(LinkList *L, int n){      LinkList p,r;      int  i;      srand(time(0));      *L = (LinkList)malloc(sizeof(Node));      r = *L;      for(i = 0; i < n; i++)      {             p = (Node *)malloc(sizeof(Node));             p->data = rand()%100 + 1;             r->next = p;             r = p;      }      r->next = NULL;}

单链表的整表删除：

思路如下：

1.声明一结点p,q；

2.将第一个结点赋值给p;

3.循环

将下一结点赋值给q;

释放p;

将q赋值给p；

实现代码如下：

Status ClearList(LinkList *L){     LinkList p,q;     p = (*L)->next;     while(p)     {           q= p->next;           free(p);           p= q;     }      (*L)->next = NULL;      return OK;}