第 二 章 线 性 表

1.线性表：是由n(n≥0)个数据元素组成的有限序列。

2.线性表的基本运算有：
1）InitList(L),构造空表，即表的初始化；
2）ListLength(L),求表的结点个数，即表长；
3）GetNode(L,i),取表中第i个结点，要求1≤i≤ListLength(L)；
4）LocateNode(L,x)查找L中值为x的结点并返回结点在L中的位置，有多个x则返回首个，没有则返回特殊值表示查找失败。
5）InsertList(L,x,i)在表的第i个位置插入值为x的新结点，要求1≤i≤ListLength(L)+1；
6）DeleteList(L,i)删除表的第i个位置的结点，要求1≤i≤ListLength(L)；

3.顺序表：把线性表的结点按逻辑次序存放在一组地址连续的存储单元里。

4.顺序表结点的存储地址计算公式：Loc(ai)=Loc(a1)+(i-1)*C；1≤i≤n

5.顺序表上的基本运算
 
（1）插入
void insertlist(seqlist *L,datatype x,int i)
{
 int j;
 if(i<1||i>L->length+1)
  error(“position error”);
 if(L->length>=listsize)
  error(“overflow”);
 for(j=L->length-1;j>=i-1;j--)
  L->data[j+1]=L->data[j];  结点后移
 L->data[i-1]=x;
 L->length++;
}
在顺序表上插入要移动表的n/2结点，算法的平均时间复杂度为O(n)。
（2）删除
void delete (seqlist *L,int i)
{
 int j;
 if(i<1||i>L->length)
  error(“position error”);
 for(j=i;j<=L->length-1;j++)
  L->data[j-1]=L->data[j];  结点前移
  L->length--;
}
在顺序表上删除要移动表的（n+1）/2结点，算法的平均时间复杂度为O(n)。

6.单链表：只有一个链域的链表称单链表。
在结点中存储结点值和结点的后继结点的地址，data  next  data是数据域，next是指针域。
（1）建立单链表。时间复杂度为O(n)。
加头结点的优点：1）链表第一个位置的操作无需特殊处理；2）将空表和非空表的处理统一。
（2）查找运算。时间复杂度为O(n)。
1） 按序号查找。
Listnode * getnode(linklist head,int i)
{
 int j;
 listnode *p;
 p=head;j=0;
 while(p->next&&j<i){
  p=p->next; 指针下移
  j++;
 }
 if(i==j)
  return p;
 else
  return NULL;
}
2） 按值查找。
Listnode * locatenode(linklist head ,datatype key)
{
 listnode *p=head->next;
 while(p&&p->data!=key)
  p=p->next;
 return p;
}
（3）插入运算。时间复杂度为O(n)。
Void insertlist(linklist head ,datatype x, int i)
{
 listnode *p;
 p=getnode(head,i-1);
 if(p==NULL);
  error(“position error”);
 s=(listnode *)malloc(sizeof(listnode));
 s->data=x;
 s->next=p->next;
 p->next=s;
}
（4） 删除运算。时间复杂度为O(n)。
Void deletelist(linklist head ,int i)
{
 listnode *p ,*r;
 p=getnode(head ,i-1);
 if(p==NULL||p->next==NULL)
  error(“position error”);
 r=p->next;
 p->next=r->next;
 free(r);
}

7.循环链表：是一种首尾相连的链表。特点是无需增加存储量，仅对表的链接方式修改使表的处理灵活方便。
8.空循环链表仅由一个自成循环的头结点表示。
9.很多时候表的操作是在表的首尾位置上进行，此时头指针表示的单循环链表就显的不够方便，改用尾指针rear来表示单循环链表。用头指针表示的单循环链表查找开始结点的时间是O(1),查找尾结点的时间是O(n)；用尾指针表示的单循环链表查找开始结点和尾结点的时间都是O(1)。

10.在结点中增加一个指针域，prior|data|next。形成的链表中有两条不同方向的链称为双链表。
1) 双链表的前插操作。时间复杂度为O(1)。
Void dinsertbefore(dlistnode *p ,datatype x)
{
 dlistnode *s=malloc(sizeof(dlistnode));
 s->data=x;
 s->prior=p->prior;
 s->next=p;
 p->prior->next=s;
 p->prior=s;
}
2) 双链表的删除操作。时间复杂度为O(1)。
Void ddeletenode(dlistnode *p)
{
 p->prior->next=p->next;
 p->next->prior=p->prior;
 free(p);
}

11.顺序表和链表的比较
1） 基于空间的考虑：顺序表的存储空间是静态分配的，链表的存储空间是动态分配的。顺序表的存储密度比链表大。因此，在线性表长度变化不大，易于事先确定时，宜采用顺序表作为存储结构。
2） 基于时间的考虑：顺序表是随机存取结构，若线性表的操作主要是查找，很少有插入、删除操作时，宜用顺序表结构。对频繁进行插入、删除操作的线性表宜采用链表。若操作主要发生在表的首尾时采用尾指针表示的单循环链表。

12.存储密度=（结点数据本身所占的存储量）/（整个结点结构所占的存储总量）
存储密度：顺序表=1，链表<1。