单链表快排

步骤：

1. pivot选取第一个节点

2. 声明两个指针，分别指向第一个节点和第二个节点；

3. 遍历整个链表，当right的值小于pivot时，交换left和right的值；

4. 遍历完整个链表，现在已是局部有序，将begin节点的值和left的值交换，实际上就是将主元放在局部有序的中间，即主元左边的值都是小于主元的，右边的值都是大于主元的；

5. 在所有递归中，重复第1、2、3和4步。

记得最后将生成的节点全部删除。

时间复杂度为O（nlogn），空间复杂度为O（n）。

 #include <iostream>
 #include <vector>
 using namespace std;
 ​
 struct Node
 {
     int val;
     Node* next;
     Node() : val(0), next(nullptr){}
     Node(int v) : val(v), next(nullptr) {}
     Node(int v, Node* n) : val(v), next(n) {}
 };
 ​
 void quickSort(Node* begin, Node* end)
 {
     if (!begin || !end || begin == end) return;
 ​
     Node* left = begin;
     Node* right = begin->next;
     
     //选取最左边的节点作为主元，先记录它的值
     int pivot = begin->val;
 ​    
     //这里不需要遍历完整个分组，需要判断right是否已经超过该分组，所以加上right != end->next
     while (right && right != end->next)
     {
         if (pivot > right->val)
         {
             left = left->next;
             swap(left->val, right->val);
         }
         right = right->next;
     }
 ​    
     //因为最左边的节点是主元，所以我们将其放在局部有序的中间
     //即主元左边的值都是小于主元的，右边的值都是大于等于主元的值
     swap(begin->val, left->val);
     quickSort(begin, left);
     quickSort(left->next, end);
 }
 ​
 int main()
 {
     Node* head = nullptr;
     Node* n1 = new Node(3);
     Node* n2 = new Node(2, n1);
     Node* n3 = new Node(10, n2);
     Node* n4 = new Node(7, n3);
     Node* n5 = new Node(8, n4);
     Node* n6 = new Node(5, n5);
     head = n6;
     Node* ptr = head;
     while (ptr)
     {
         cout << ptr->val << " ";
         ptr = ptr->next;
     }
     cout << endl;
     quickSort(head, n1);
     Node* p = head;
     while (p)
     {
         cout << p->val << " ";
         p = p->next;
     }
 ​
     while (head)
     {
         Node* tmp = head;
         head = head->next;
         delete tmp;
     }
     cout << endl;
     if (!head) cout << "成功删除" << endl;
     return 0;
 }