=======题目描述=======
题目链接：https://leetcode.com/problems/binary-tree-level-order-traversal/
题目内容：
Sort a linked list in O(n log n) time using constant space complexity.
Example 1:
Input: 4->2->1->3
Output: 1->2->3->4
Example 2:
Input: -1->5->3->4->0
Output: -1->0->3->4->5
=======算法实现=======
/**
* Definition for singly-linked list.
* struct ListNode {
* int val;
* ListNode *next;
* ListNode(int x) : val(x), next(NULL) {}
* };
*/
class Solution {
public:
int temp=0;
ListNode* getPartition(ListNode* pBegin, ListNode* pEnd){
int key = pBegin->val;//基准元素
ListNode* left = pBegin;
ListNode* right = pBegin->next;
while(right != pEnd){
//小于基准元素的进行交换
if(right->val < key)
{
left = left->next;
this->temp = right->val;
right->val = left->val;
left->val = this->temp;
}
right = right->next;
}
//交换
this->temp = left->val;
left->val = pBegin->val;
pBegin->val = this->temp;
return left; //返回基准的索引
}
void quickSort(ListNode* pBegin, ListNode*pEnd){
if(pBegin != pEnd){
ListNode* partition = getPartition(pBegin, pEnd); //基准的索引
quickSort(pBegin, partition);
quickSort(partition->next, pEnd);
}
}
ListNode* sortList(ListNode* head) {
quickSort(head, nullptr);
return head;
}
};
=======算法笔记*排序算法=======
快速排序(Quick Sort)
快速排序是由东尼·霍尔所发展的一种排序算法。在平均状况下，排序n个元素要O(nlogn)次比较。在最坏状况下则需要O(n^2)次比较，但这种状况并不常见。事实上，快速排序通常明显比其他O(nlogn)算法更快，因为它的内部循环可以在大部分的架构上很有效率地被实现出来。
快速排序使用分治策略(Divide and Conquer)来把一个序列分为两个子序列。步骤为：
- 从序列中挑出一个元素，作为"基准"(pivot).
- 把所有比基准值小的元素放在基准前面，所有比基准值大的元素放在基准的后面（相同的数可以到任一边），这个称为分区(partition)操作。
- 对每个分区递归地进行步骤1~2，递归的结束条件是序列的大小是0或1，这时整体已经被排好序了。
使用快速排序法对一列数字进行排序的过程： 
快速排序是不稳定的排序算法，不稳定发生在基准元素与A[tail+1]交换的时刻。
比如序列：{ 1, 3, 4, 2, 8, 9, 8, 7, 5 }，基准元素是5，一次划分操作后5要和第一个8进行交换，从而改变了两个元素8的相对次序。
之前总结整理的：
常用排序算法总结
https://blog.csdn.net/qq_42189368/article/details/84023271
内容目录：
冒泡排序（Bubble Sort）
冒泡排序的改进：鸡尾酒排序
选择排序（Selection Sort）
插入排序（Insertion Sort）
插入排序的改进：二分插入排序
插入排序的更高效改进：希尔排序(Shell Sort)
归并排序(Merge Sort)
快速排序(Quick Sort)