fix: 增加线性表和链表排序相关知识

Author: subond.yu

linear_list.md

@@ -0,0 +1,86 @@
+## 线性表 Linear List
+
+1. [线性表的存储结构](#线性表的存储结构)  
+  1.1 [顺序存储](#顺序存储)  
+  1.2 [链式存储](#链式存储)  
+
+**线性表**：零个或多个数据元素的有限序列
+
+**抽象的数据结构**
+
+```
+定义
+    线性表
+数据
+    线性表的数据对象集合为{a1, a2, ..., an}，每个数据元素类型均为DataType
+    其中，除第一个元素a1外，每个元素都有且只有一个直接前驱元素
+    除最后一个元素an外，每个元素都有且只有一个直接后驱元素
+    数据元素之间的关系是一对一的关系
+操作
+    初始化
+    增，删，改，除
+    空判断
+    获取元素
+    清空元素
+```
+
+### 线性表的存储结构
+
+* 顺序存储
+* 链式存储
+
+### 顺序存储
+
+1. 线性表顺序存储的三个基本属性
+
+  * 存储空间的起始位置
+  * 线性表的最大存储容量
+  * 线性表的当前长度
+
+2. 顺序存储的优点及缺点
+  * 优点：
+    * 不需要为表示表中元素之间的逻辑关系而增加额外的存储空间
+    * 可以快速存取表中的任意一个位置的元素
+  * 缺点：
+    * 插入和删除操作，需要移动大量的元素
+    * 当线性表长度变化较大时，难以确定存储空间的容量
+    * 造成存储空间的“碎片化”
+
+数组就是最常见的顺序存储的线性表。
+
+### 链式存储
+
+1. 线性表链式存储的属性
+  * 头指针，头节点
+  * 指针域，数据域
+
+  头指针与头节点的区别：
+  * 头指针
+    * 头指针是指向链表第一个节点的指针，若链表有头节点，则是指向头节点的指针
+    * 头指针具有标识作用，常用于标识链表的名字
+    * 无论链表是否为空，头指针都不为空。**头指针是链表的必要元素**。
+  * 头节点
+    * 头节点是为了操作的统一和方便设计的，放在第一个元素的节点之前，其数据一般无意义（可以存放链表的长度信息）。
+    * 头节点不是链表的必要元素。
+
+2. 链式存储的优点和缺点
+  * 优点：
+    * 采用链式存储单元存放线性表数据元素
+    * 不需要预先分配固定大小的存储空间
+  * 缺点：
+    * 查找时间复杂度O(n)
+    * 找到元素后，插入和删除操作的时间复杂度为O(1)
+
+链式存储的线性表根据指针域的不同，可分为单向链表，循环链表和双向链表等。
+
+### 单向链表
+
+单向链表中每个节点有两个域，一个数据域和一个指针域。数据域用于表示单链表中的数据，指针域用于指向当前节点后驱节点的指针，简称为单链表。
+
+### 循环链表
+
+将单链表中的最后一个节点的指针指向该单链表的头节点，使得整个链表形成一个环。这种首尾相连的单链表称为单循环链表，简称循环链表。
+
+### 双向链表
+
+若在单链表中增加一个指向当前节点前驱节点的指针域，则构成双向链表。双向链表中包含三个域，一个数据域和两个指针域（一个指向后驱节点，一个指向前驱节点）。

linkedlist/linkedlist_sort.md

@@ -0,0 +1,160 @@
+## 单链表的排序算法
+
+  * 1.[插入排序](#插入排序)
+  * 2.[选择排序](#选择排序)
+  * 3.[快速排序](#快速排序)
+  * 4.[归并排序](#归并排序)
+
+### 插入排序
+
+插入排序可以通过直接交换节点得到。
+
+```go
+/*
+功能：插入排序
+参数：传入链表头指针作为参数，返回排序后的头指针
+说明：时间复杂度O(n^2)，空间复杂度O(1)
+第一步：选择插入的位置;
+第二步：如果在已排序的链表的尾部，则直接加入到尾部，否则，插入到选好的位置。注意：需要保存前驱节点。
+ */
+
+func InsertSort(head *ListNode) *ListNode {
+  if head == nil || head.Next == nil { return head }
+  var pre, p, start, end *ListNode
+  p, start, end, pre = head.Next, head, head, head
+  var next *ListNode
+  for p != nil {
+    next, pre = p.Next, start
+    for next != p && p.Val >= next.Val {
+      next = next.Next
+      pre = pre.Next
+    }
+    // 追加到已经排序的队尾
+    if next == p {
+      pend = p
+    } else {
+      pend.Next = p.Next
+      p.Next = next
+      pre.Next = p
+    }
+    p = pend.Next
+  }
+  return head
+}
+```
+
+### 选择排序
+
+```
+/*
+功能：选择排序(选择未排序序列中的最值，然后放到已排序的最前面或最后面，只交换节点的值)
+参数：输入链表的头指针，返回排序后的头指针
+说明：时间复杂度O(n^2)，空间复杂度O(1)
+ */
+Node *SelectSort(Node *phead) {
+  if(phead == NULL || phead->next == NULL) return phead;
+  Node *pend = phead;
+  while(pend->next != NULL) {
+    Node *minNode = pend->next;
+    Node *p = minNode->next;
+    while(p != NULL) {
+      if(p->val < minNode->val)
+        minNode = p;
+      p = p->next;
+    }
+    swap(minNode->val, pend->val);
+    pend = pend->next;
+  }
+  return phead;
+}
+```
+
+### 快速排序
+
+```
+/*
+功能：快速排序，链表指向下一个元素的特性，partition是选择左闭合区间
+第一步，partiton，因为链表不支持随机访问元素，因此partiton中选取第一个节点值作为基准
+第二步，排序
+参数：输入链表头指针，输出排序后的头指针
+说明：平均时间复杂度O(nlogn)，空间复杂度O(1)
+ */
+Node *Partition(Node *low, Node *high) {
+  //左闭合区间[low, high)
+  int base = low->val;
+  Node *location = low;
+  for(Node *i = low->next; i != high; i = i->next) {
+    if(i->val > base) {
+      location = location->next;
+      swap(location->val, i->val);
+    }
+  }
+  swap(low->val, location->val);
+  return location;
+}
+void QuickList(Node *phead, Node *tail) {
+  //左闭合区间[phead, tail)
+  if(phead != tail && phead->next != tail) {
+    Node *mid = Partition(phead, tail);
+    QuickList(phead, mid);
+    QuickList(mid->next, tail);
+  }
+}
+Node *QuickSort(Node *phead) {
+  if(phead == NULL || phead->next == NULL) return phead;
+  QuickList(phead, NULL);
+  return phead;
+}
+```
+
+### 归并排序
+
+```
+/*
+功能：归并排序，交换链表节点
+第一步：先写归并函数；第二步：利用快慢指针找到链表中点，然后递归对子链进行排序
+参数：输出链表的头指针，输出排序后的头指针
+说明：时间复杂度O(nlogn)，空间复杂度O(1)。归并排序应该算是链表排序中最佳的选择，保证最好和最坏的时间复杂度都是O(nlogn)，而且在将空间复杂度由数组中O(n)，降到链表中的O(1)
+ */
+Node *merge(Node *phead1, Node *phead2) {
+  if(phead1 == NULL) return phead2;
+  if(phead2 == NULL) return phead1;
+  Node *res, *p;
+  if(phead1->val < phead2->val) {
+    res = phead1;
+    phead1 = phead1->next;
+  } else {
+    res = phead2;
+    phead2 = phead2->next;
+  }
+  p = res;
+  while(phead1 != NULL && phead2 != NULL) {
+    if(phead1->val < phead2->val) {
+      p->next = phead1;
+      phead1 = phead1->next;
+    } else {
+      p->next = phead2;
+      phead2 = phead2->next;
+    }
+    p = p->next;
+  }
+  if(phead1 != NULL) p->next = phead1;
+  else if(phead2 != NULL) p->next = phead2;
+  return res;
+}
+Node *MergeSort(Node *phead) {
+  if(phead == NULL || phead->next == NULL) return phead;
+  Node *fast = phead;
+  Node *slow = phead;
+  while(fast->next != NULL && fast->next->next != NULL) {
+    fast = fast->next->next;
+    slow = slow->next;
+  }
+  fast = slow;
+  slow = slow->next;
+  fast->next = NULL;
+  fast = MergeSort(phead);
+  slow = MergeSort(slow);
+  return merge(fast, slow);
+}
+```