LeetCode:Sort List链表排序

=======题目描述=======

题目链接：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)来把一个序列分为两个子序列。步骤为：

1. 从序列中挑出一个元素，作为"基准"(pivot).
2. 把所有比基准值小的元素放在基准前面，所有比基准值大的元素放在基准的后面（相同的数可以到任一边），这个称为分区(partition)操作。
3. 对每个分区递归地进行步骤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)