线性表

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

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

                                                                                                                  图1. 线性表

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

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

顺序存储结构：

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

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

#define MAXSIZE 20
typedef 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 0
typedef 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;
}