回顾知识——单链表的实现

　　链表是一种物理存储单元上非连续、非顺序的存储结构，数据元素的逻辑顺序是通过链表中的指针链接次序实现的。链表由一系列结点（链表中每一个元素称为结点）组成，结点可以在运行时动态生成。每个结点包括两个部分：一个是存储数据元素的数据域，另一个是存储下一个结点地址的指针域。 相比于线性表顺序结构，操作复杂。由于不必须按顺序存储，链表在插入的时候可以达到O(1)的复杂度，比另一种线性表顺序表快得多，但是查找一个节点或者访问特定编号的节点则需要O(n)的时间，而线性表和顺序表相应的时间复杂度分别是O(logn)和O(1)。

1 typedef int ElemType;
2 typedef struct LNode {
3     ElemType data;
4     struct LNode *next;
5 }LNode,*LinkList;

单链表的储存结构

 1 //单链表的初始化
 2 LinkList InitList() {
 3     LinkList list;
 4     list = new LNode;
 5     list->next = NULL;
 6     list->data = 0;
 7     return list;
 8 }
 9 //节点初始化
10 LNode* InitNode(ElemType value) {
11     LNode *node;
12     node = new LNode;
13     node->data = value;
14     node->next = NULL;
15     return node;
16 }

单链表的初始化

 1 //往单链表头部插入节点
 2 void push_front(LinkList &list, LNode* node) {
 3     LinkList temp;
 4     temp = list->next;
 5     list->next = node;
 6     list->next->next = temp;
 7 }
 8 //往单链表的尾部插入节点
 9 void push_back(LinkList &list, LNode* node) {
10     LinkList temp;
11     temp = list;
12     while (temp->next != NULL)temp = temp->next;
13     temp->next = node;
14 }
15 //根据位置插入节点
16 void Insert(LinkList &list,LNode* node,int index) {
17     int k = 1, ans = 1;
18     LinkList temp;
19     temp = list;
20     while (temp->next != NULL) {
21         temp = temp->next;
22         ans++;
23     }
24         //若插入位置小于或等于1号位，将节点插入链表头部
25     if (index <= 1) {
26         temp = list->next;
27         list->next = node;
28         list->next->next = temp;
29     }
30         //若插入的位置大于或等于最大节点位置，将节点插入链表尾部
31     else if (index >= ans) {
32         temp = list;
33         while (temp->next != NULL)temp = temp->next;
34         temp->next = node;
35     }
36         //根据插入位置index，将节点插入链表中
37     else {
38         LinkList p;
39         temp = list;
40         while (k < index) {
41             k++;
42             temp = temp->next;
43         }
44         p = temp->next;
45         temp->next = node;
46         temp->next->next = p;
47     }
48 }    

单链表的节点插入

 1 //删除第一个节点
 2 void pop_front(LinkList &list) {
 3     LinkList temp = list;
 4     temp = temp->next->next;
 5     delete list->next;
 6     list->next = temp;
 7 }
 8 //删除最后一个节点
 9 void pop_back(LinkList &list) {
10     LinkList temp = list;
11     while (temp->next->next != NULL)
12             temp = temp->next;
13     delete temp->next;
14     temp->next = NULL;
15 }
16 //根据节点位置删除
17 void remove(LinkList &list, int index) {
18     int k = 1, ans = 1;
19     LinkList temp;
20     temp = list;
21     while (temp->next != NULL) {
22         temp = temp->next;
23         ans++;
24     }
25     if (index <= 1)
26         pop_front(list);
27     else if (index >= ans)
28         pop_back(list);
29     else {
30         LinkList p;
31         temp = list;
32         while (k < index) {
33             k++;
34             temp = temp->next;
35         }
36         p = temp->next->next;
37         delete temp->next;
38         temp->next = p;
39     }
40 }
41 //删除全部节点
42 void clear(LinkList &list) {
43     LinkList temp = list;
44     if (temp->next == NULL)return;
45     pop_front(list);
46     clear(list);
47 }    

单链表的节点删除

 1 void reverse(LinkList &list) {
 2     LinkList temp, p= InitList();
 3     p = list->next;
 4     list->next = NULL;
 5     while (p) {
 6         temp = p->next;
 7         p->next = list->next;
 8         list->next = p;
 9         p = temp;
10     }
11 }

单链表的翻转

 1 bool isLoop(LinkList list) {
 2     LinkList p = list, q = list;
 3     while (p != NULL && p->next != NULL)
 4     {
 5         p = p->next->next;
 6         q = q->next;
 7         //如果有环，则p会超过q一圈
 8         if (p == q)
 9             break;
10     }
11     if (p == NULL || p->next == NULL)
12         return false;
13     else
14         return true;
15 }

单链表是否有环

　　链表是数据结构的基础，掌握链表的操作对后面的数据结构的理解很有帮助的。

　　翻以前的知识忘得也差不多了，知识点也是很模糊，现在回顾一下以前的知识和代码，顺便记录知识回顾路程，太久没敲过代码，难免有些生疏，可能有些不太正确的地方，还望看客纠正。对于翻转以及判断是否有环这两个可以用IDE调试一下，单步调试走多几圈就能理解为什么这么写了。