链表总结

一、单链表

单向链表（单链表）是链表的一种，其特点是链表的链接方向是单向的，对链表的访问要通过顺序读取从头部开始；链表是使用指针进行构造的列表；又称为节点列表，因为链表是由一个个节点组装起来的；其中每个节点都有指针成员变量指列表中的下一个节点；

列表是由节点构成，由head指针指向第一个成为表头的节点而终止于最后一个指向nuLL 的指针；

1.建立链表(尾插法)：

尾插法的基本思想：

1.生成一个节点，将读入的数据存放到新节点的数据域中

2.把新节点插到当前链表的尾节点之后

3.重复上述过程，直至输入结束标志

尾插法读入数据的顺序和线性表的逻辑顺序是相同的

[cpp]view plaincopyprint?

1.void creat_list( Node* &head) { //传入指向表头的指针，这个指针要保存下来。注

意Node* &，是Node* 类型的引用

2.

3.Node *pre,*newNode;

4.head = pre = new Node; //生成表头结点

5.

6.newNode = new Node; //建立新节点

7.cin>>newNode->num; //输入新节点的值

8.while(newNode->num) { //判断输入结束的条件

9.pre-> next = newNode; //上一个节点连接新节点

10.pre = newNode; //因为马上要申请新空间，此时的新节点即将变成“上一个节点”，保存给

pre

11.newNode = new Node; //再次申请新空间

12.cin >> newNode->num; //输入值

13.}

14.pre->next = NULL; //结束后，将单链表最后一个节点rear指针置为空，标志着结束

15.}

2.建立链表(头插法)

头插法的基本思想：

1.生成一个节点，将读入的数据存放到新节点的数据域中

2.把新节点作为第一个表节点查到单签链表头节点之后

3.重复上诉过程，直至输入结束标志为止

头插法读入数据的顺序和线性表的逻辑顺序是相反的。

[cpp]view plaincopyprint?

1.void creat_head(Node* &head) {

2.Node *newNode;

3.head = new Node;

4.head->next = NULL;

5.newNode = new Node;

6.cin>>newNode->num; //输入数据

7.while(newNode->num){

8.newNode->next = head->next;

9.head->next = newNode;

10.newNode = new Node;

11.cin >> newNode->num;

12.}

13.}

3.单链表查找：按值查找

[cpp]view plaincopyprint?

1.Node* search_value(Node *head, int x){ //x为要查找的值

2.Node *p=head->next;

3.while(p!=NULL && p->num!=x)

4.p = p->next;

5.if(p->num ==x )

6.return (p);

7.return NULL;

8.}

4.单链表查找：按位置查找

[cpp]view plaincopyprint?

1.Node* search_local(Node *head, int i) { //i为要查找的位置

2.Node *p=head;

3.int count=0;

4.while(p->next!=NULL && count

5.p = p->next;

6.++count;

7.}

8.if(count==i)

9.return (p);

10.return NULL;

11.}

5.单链表插入：前插(后插)

操作过程：

1.生成一个新节点newNode，将值x赋给新节点newNode的数据域

2.从表头节点开始，查找p的前驱节点q

3.修改有关节点的指针域，将newNode指针域指向p节点，q节点指向newNode

[cpp]view plaincopyprint?

1.Node* inset_front(Node *head,int i,int x){ //x为要插入的值，i是位置

2.Node *p,*newNode;

3.newNode = new Node; //申请新空间

4.newNode->num = x; //赋值

5.p = search_local(head,i-1); //只要把i-1改成i，就变成了插在i的后面（后插法）

6.newNode->next = p->next;

7.p->next = newNode;

8.return head;

9.}

6.单链表的删除(删除链表中的值x)

操作过程：

1.假设有两个节点pre和p，pre是p的前驱节点,p为要删除的节点

2.找pre，从链表head的头结点开始，一次向后进行搜索，当pre-next = p时，找到

3.修改pre-next = p-next,把p的前驱节点指向p的后继节点，并且删除空间

[cpp]view plaincopyprint?

1.Node* delete_link(Node *head,int x){

2.Node *pre,*p; //pre存p的前驱节点

3.p = head;

4.while(p!=NULL && p->num!=x) {

5.pre=p;

6.p = p->next;

7.}

8.if(p!=NULL) {

9.pre->next = p->next;

10.delete (p);

11.return head;

12.}

13.else {

14.cout<<"要删除的值不存在\n";

15.return NULL;

16.}

17.}

二、循环列表

循环链表：表中最后一个节点的指针域不再是空，而是指向第一个节点，整个链表形成一个环。

特点：从表中任一节点出发，就可搜寻到其他所有节点

作用：在许多实际应用中，对链表的操作运算是在表头、表尾进行的，这时可以改变链表的标识方法，不用头指针

而用指向尾节点的尾指针rear来标识，以提高效率。

和单链表的比较：

单链表中，找到第一个元素时间为O(1),最后一个元素为O(n);

而应用循环链表，则找到最后一个元素为O(1),由于最后一个元素指向第一个元素，因此找到第一个元素也为O(1)

运算: 循环链表与单链表的运算基本一致，区别在于判断遍历表完成条件不同，单链表判断当前指针域是否为空，而循环

链表判断当前节点指针域是否为表头指针。

//下面以查找运算为例

[cpp]view plaincopyprint?

1.//下面以查找运算为例

2.

3.Node* search_value(Node *head, int x){ //x为要查找的值

4.Node *p=head->next;

5.while(p->next!=head && p->num!=x) // p->next!=head

6.p = p->next;

7.if(p->num ==x )

8.return (p);

9.return NULL;

10.}

三、双向链表

双向链表：指沿着前驱和后继方向都能遍历的线性链表。

其每个节点都有两个指针域：一个指向其后继节点，另一个指向其前驱结点。

双向链表的节点类型定义为：

[cpp]view plaincopyprint?

1.struct Dnode{

2.int data; //data储存表中的元素

3.Dnode *next,*prior; //next指向后一节点指针，prior指向前一节点指针

4.};

双向链表优点：双向链表既有向前的指针域，又有向后的指针域，这就使得双向链表的前插和后插

以及删除操作都很方便，只需要修改几个节点的指针域，而不必进行大量的数据交换和遍历操作

[cpp]view plaincopyprint?

1.// 节点类型

2.struct Dnode{

3.int data; //data储存表中的元素

4.Dnode *next,*prior; //next指向后一节点指针，prior指向前一节点指针

5.};

6.

7.//双向链表的前插(在某节点p之前插入一个新节点s)

8.Dnode *insert_before(Dnode *head,Dnode *p, int x){

9.Dnode *s; //s为要插入的节点

10.s = new Dnode; //建立新节点

11.s->data = x; //给s节点的数据域赋值

12.s->next = p; //步骤1：将节点s的后继指针指向p；

13.s->prior = p->prior; //步骤2：将节点s的前驱指针指向节点p的前驱节点

14.p->prior->next = s; //步骤3：将p的前驱结点的后继指针修改为指向新节点s；

15.p->prior = s; //步骤4：将节点p的前驱指针修改为指向新节点s.

16.return head;

17.}

18.

19.

20.//双向链表的后插(在某节点p之后插入一个新节点s):

21.Dnode *insert_back(Dnode *head,Dnode *p, int x){

22.Dnode *s; //s为要插入的节点

23.s = new Dnode; //建立新节点

24.s->data = x; //给s节点的数据域赋值

25.s->next = p->next; //步骤1：将节点s的后继指针指向p；

26.s->prior = p; //步骤2：将节点s的前驱指针指向节点p的前驱节点

27.p->next->prior = s; //步骤3：将p的前驱结点的后继指针修改为指向新节点s；

28.p->next = s; //步骤4：将节点p的前驱指针修改为指向新节点s.

29.return head;

30.}

31.

32.

33.//双向链表节点的删除：

34.Dnode *delete_Dnode(Dnode *head,Dnode *p){

35.if(p != NULL){

36.p->prior->next = p->next; //步骤1：将p的前驱节点的后继指针改为指向p的后继

37.p->next->prior = p->prior; //步骤2：将p的后继结点的前驱指针改为指向p的前驱

38.delete (p); //步骤3：释放p的存储空间

39.return head; //返回带头结点双向链表的头指针

40.}

41.else

42.return NULL;

43.}