5个常用的排序算法总结

1.插入排序

基本思想：插入排序就是每一步都将一个待排数据按其大小插入到已经排序的数据中的适当位置，直到全部插入完毕。

void insertSort(vector<int>& nums)
{
    int k = 0;
    for (int i = 0; i < nums.size(); ++i)
    {
        int temp = nums[i];
        int j = i;
        for (; j > 0 && temp < nums[j-1]; --j)
            nums[j] = nums[j-1];
        nums[j] = temp;
    }
}

2.谢尔排序

基本思想：先将整个待排元素序列分割成若干个子序列（由相隔某个“增量”的元素组成的）分别进行直接插入排序，然后依次缩减增量再进行排序，待整个序列中的元素基本有序（增量足够小）时，再对全体元素进行一次直接插入排序。因为直接插入排序在元素基本有序的情况下（接近最好情况），效率是很高的，因此希尔排序在时间效率上比前两种方法有较大提高。

void shellSort(vector<int>& nums)
{
    for (int gap = nums.size() / 2; gap > 0; gap /= 2)
    {
        for (int i = gap; i < nums.size(); ++i)
        {
            int temp = nums[i];
            int j = i;
            for (; j >=gap && temp < nums[j-gap]; j -= gap)
                nums[j] = nums[j - gap];
            nums[j] = temp;
        }
    }
}

3.堆排序

4.归并排序

基本思想：归并排序是利用递归和分而治之的技术将数据序列划分成为越来越小的半子表，再对半子表排序，最后再用递归步骤将排好序的半子表合并成为越来越大的有序序列，归并排序包括两个步骤，分别为：
1）划分子表
2）合并半子表
刚好最近刷leetcode有道题用的归并排序：sort list

class Solution {
public:
  //归并排序
    ListNode* getMiddleOfList(ListNode* head)
    {
        ListNode* mid = head;
        ListNode* last = head;
        while (last->next!=NULL&&last->next->next!=NULL)
        {
            mid = mid->next;
            last = last->next->next;
        }
        return mid;
    }
    ListNode* sortList(ListNode* head) {
        if (head == NULL || head->next == NULL)return head;
        ListNode* mid = getMiddleOfList(head);
        ListNode* midnext = mid->next;
        mid->next = NULL;
        return mergeList(sortList(head), sortList(midnext));
    }
    ListNode* mergeList(ListNode* a, ListNode* b)
    {
        ListNode* res = new ListNode(-1);
        ListNode* cur = res;
        while (a != NULL&&b != NULL)
        {
            if (a->val < b->val)
            {
                cur->next = a;
                a = a->next;
            }
            else
            {
                cur->next = b;
                b = b->next;
            }
            cur = cur->next;
        }
        cur->next = a != NULL ? a : b;
        return res->next;
    }
};

5.快速排序

基本思想：先将整个待排元素序列分割成若干个子序列（由相隔某个“增量”的元素组成的）分别进行直接插入排序，然后依次缩减增量再进行排序，待整个序列中的元素基本有序（增量足够小）时，再对全体元素进行一次直接插入排序。因为直接插入排序在元素基本有序的情况下（接近最好情况），效率是很高的，因此希尔排序在时间效率上比前两种方法有较大提高。

class sort {
public:
    int median3(vector<int>& nums, int left, int right)
    {
        int mid = (left + right) / 2;
        if (nums[left] > nums[mid])swap(nums[left], nums[mid]);
        if (nums[mid] > nums[right])swap(nums[mid], nums[right]);
        if (nums[left] > nums[mid])swap(nums[left], nums[mid]);

        swap(nums[mid], nums[left]);
        return nums[left];
    }
    void quickSort(vector<int>& nums,  int i, int j)
    {
        if (i > j)return;
        int partition = median3(nums, i, j);
        int low = i+1, high = j;
        while (low < high)
        {
            while (nums[low] < partition)low++;         
            while (nums[high] > partition)high--;
            if (low < high)swap(nums[low], nums[high]);
            else
                break;
        }
        swap(nums[i], nums[high]);
        quickSort(nums, i, high - 1);
        quickSort(nums, high + 1, j);
    }
    void qs(vector<int>& nums)
    {
        quickSort(nums, 0, nums.size() - 1);
    }
};