数据结构（C语言版）---线性表链式存储表示

1、单链表：线性表的链式存储。

1）特点：用一组任意的存储单元存储数据元素（存储单元可以连续，也可以不连续），逻辑上相邻的元素存储位置不一定相邻。

2）结点包括两个域：数据域（存储数据元素信息）、指针域（存储直接后继存储位置）

3）指针或链：指针域中存储的信息。

2、头指针：链表中第一个结点的存储位置，整个链表的存取必须从头指针开始。

3、头结点：在单链表的第一个结点前附设一个结点，其数据域可不存储信息，可存储附加信息。若指针域为空，则线性表为空表。

引入头结点的优点：

1）使得在链表的第一个位置上的操作和在表的其他位置上的操作一致。

2）空表和非空表的处理一致。

4、单链表的结点类型

typedef struct LNode {
 int data;
 struct LNode * next;
}LNode,* Linklist;

5、 单链表
 LNode * s, *p, *q;
 Linklist L;
 int i, temp;
 1）插入结点的代码片段，时间复杂度为O(n)。
 p = GetElem(L, i - 1);
 s->next = p->next;
 p->next = s;
 2）将* s结点插入到* p之前的代码片段，时间复杂度为O(1)。
 s->next = p->next;
 p->next = s;
 temp = p->data;
 p->data = s->data;
 s->data = temp;
 3）删除结点的代码片段，，时间复杂度为O(n)。
 p = GetElem(L, i - 1);
 q = p->next;
 p->next = q->next;
 free(q);
 4）删除结点* p，时间复杂度为O(1)。
 q = p->next;
 p->data = p->next->data;
 p->next = q->next;
 free(q);

6、采用头插法建立单链表，从表尾到表头逆向建立单链表L，每次均在头结点之后插入元素，时间复杂度为O(n)。
Linklist list_headinsert(Linklist &L)
{
 LNode * s;
 int x;
 L = (Linklist)malloc(sizeof(LNode));
 L->data = NULL;
 scanf("%d", &x);
 while (x!=9999)
 {
  s = (LNode *)malloc(sizeof(LNode));
  s->data = x;
  s->next = L->next;
  L->next = s;
  scanf("%d", &x);
 }
 return L;
}
7、采用尾插法建立单链表，从表尾到表头正向建立单链表L，每次均在表尾插入元素，时间复杂度为O(n)。
Linklist List_tailinsert(Linklist &L)
{
 int x;
 L = (Linklist)malloc(sizeof(LNode));
 LNode * s, *r = L;//r为表尾指针。
 scanf("%d", &x);
 while (x!=9999)
 {
  s = (LNode *)malloc(sizeof(LNode));
  s->data = x;
  r->next = s;
  r = s;
  scanf("%d", &x);
 }
 r->next = NULL;
 return L;
}
8、按序号查找结点的值，取出单链表L中第i个位置的结点指针，时间复杂度为O(n)。
LNode * GetElem(Linklist L, int i)
{
 int j = 1;
 LNode * p = L->next;
 if (i == 0)
 {
  return L;
 }
 if (i < 1)
 {
  return NULL;
 }
 while (p&&j<i)
 {
  p = p->next;
  j++;
 }
 return p;
}
9、按值查找表结点，查找单链表L中数据域值等于e的结点指针，时间复杂度为O(n)。
LNode * LocateElem(Linklist L, int e)
{
 LNode *p = L->next;
 while (p!=NULL&&p->data!=e)
 {
  p = p->next;
 }
 return p;
}

10、求表长，时间复杂度为O(n)。
int listlength(LNode * p)
{
 int len = 0;
 while (p->next != NULL)
 {
  len++;
  p = p->next;
 }
 return len;
}

11、循环单链表：表中最后一个结点的指针指向头结点。

1）判空条件：头结点的指针指向头指针。

2）设头指针，对表尾进行操作，时间复杂度为O(n)。

3）设尾指针，对表尾和表头进行操作，时间复杂度为O(1)。

12、双链表结点中含有两个指针域，一个指向前驱结点，一个指向后继结点。

13、双链表结点类型
typedef struct DNode {
 int data;
 struct DNode * prior, * next;
}DNode,* DLinklist;

14、 双链表

DNode * m, *k;
 1）插入操作片段，时间复杂度为O(1)。
 m->next = k->next;
 k->next->prior = m;
 m->prior = k;
 k->next = m;
 2）删除操作片段，时间复杂度为O(1)。
 m->next = k->next;
 k->next->prior = m;
 free(k);

15、静态链表：借助数组来描述线性表的链式存储结构。其中指针是结点的相对地址（数组下标），又称游标。

16、静态链表的结构类型

#define maxsize 50
typedef struct {
 int data;
 int next;
}slinklist[maxsize];