【LittleXi】排序算法

【LittleXi】排序算法

基于比较的排序

简单排序：选择排序

高级排序：归并排序、快速排序、桶排序、堆排序

工业：Introspective Sort 、Tim Sort

其它排序：希尔排序

排序的稳定性

• 稳定的排序算法：

  插入排序、冒泡排序、归并排序
  

• 不稳定的排序算法

  选择排序、快速排序、堆排序

示例：

待排序列： 34 12 34 08 96

稳定： 08 12 34 34 96

不稳定： 08 12 34 34 96

插入排序

时间复杂度:最坏情况：$O(n)$,最好情况：$O(n^2)$

空间复杂度:$O(1)$

冒泡排序

时间复杂度:最坏情况：$O(n^2)$,最好情况：$O(n^2)$

空间复杂度:$O(1)$

选择排序

时间复杂度:最坏情况：$O(n^2)$,最好情况：$O(n^2)$

空间复杂度:$O(1)$

归并排序

分治：把两个或两个以上的有序序列合并成一个新的有序序列

时间：O(nlog₂n)

空间：$O(n)$

优化：

• 对小规模子数组使用插入排序

• 检测待归并数组是否已经有序

• 去除原数组到辅助数组的拷贝

• 并行优化

      vector<int> dfs(vector<int> nums)
      {
          if(nums.size()==1) return nums;
          if(nums.size()==2) 
          {
              int mi=min(nums[0],nums[1]);
              int ma=max(nums[0],nums[1]);
              return {mi,ma};
          }
          int l=0;
          int r=nums.size()-1;
          int m=(l+r)/2;
          vector<int> tv1;
          for(int i=l;i<=m;i++) tv1.push_back(nums[i]);
          vector<int> tv2;
          for(int i=m+1;i<=r;i++) tv2.push_back(nums[i]);
          vector<int> g1=dfs(tv1);
          vector<int> g2=dfs(tv2);
          vector<int> rev;
          int p=0,q=0;
          while(p<g1.size()||q<g2.size())
          {
              if(q==g2.size()||(p<g1.size()&&g1[p]<g2[q]))
                  rev.push_back(g1[p++]);
              else
                  rev.push_back(g2[q++]);
          }
          return rev;
      }
  
      vector<int> mergesort(vector<int> &nums)
      {
          return dfs(nums);
      } 
  

堆排序(heap sort)

堆：完全二叉树

基本思想：借助对结构进行排序

快速排序(quick sort)

基本思想：先选取一个基准值，然后利用左右指针去寻找基准值对应的位置，并寻找过程中不断交换i、j所对应的值

代码实现：

void quicksort(int arr[],int l,int r)
{
    if(l>=r) return;
    int temp=arr[l];
    int i=l;
    int j=r;
    while(i!=j)
    {
        while(arr[j]>=temp&&j>i)
            j--;
        while(arr[i]<=temp&&j>i)
            i++;
        if(j>i)
            swap(arr[i],arr[j]);
    }
    swap(arr[i],arr[l]);
    quicksort(arr,l,i-1);
    quicksort(arr,i+1,r);
}