经典几种排序的实现方法

前言

主要写了学习写了排序算法，下边每种写一下他的思想，感觉好多细节还是很容易忘记的，一次记录一下自己的写的内容，后续逐渐补充完整

快排

快排好像是面试比较容易让写的一种，也是应用比较广泛的，在C++中STL库里边的sort()函数就是利用的快排实现，快排的核心思想是：有点像归并排序的找参照物的排序，这个怎么理解呢，首先找到一个参考值（一般也是数组中的值，取数组最左侧就行），然后根据这个值就可以将数组分成大于和小于的两组值，再将分好的组的进行快排，这样就可以让整个的数组是有序的，我感觉他这个思想很像归并的思想，只要每一个分部分搞好，最后整个数组也就是排好序的了。

归并排序

冒泡排序

希尔排序

插入排序

选择排序

堆排序

桶排序

拓扑排序（图排序的一种）

#include<bits/stdc++.h>
using namespace std;
class AC {
 public:
  //快排的递归写法的代码
  void quicksort(vector<int>&a,int left,int right) {
   if(left<right) {
    int standard = getindex(a,left,right);
    quicksort(a,left,standard-1);
    quicksort(a,standard-1,left);
   }
  }
  int getindex(vector<int>&arr,int lo,int hi) {
   int key = arr[lo];
   while(lo<hi) {
    while(lo<hi&&arr[hi]>=key)
     hi--;
    if(lo<hi)
     arr[lo]=arr[hi];
    while(lo<hi&&arr[lo]<=key)
     lo++;
    if(lo<hi)
     arr[hi]=arr[lo];
   }
   arr[lo]=key;
   return lo;
  }
  //插入排序的代码
  void insertsort(vector<int> &a) {
   int L = a.size();
   for(int i=1; i<L; i++) {
    int v = a[i];//首先记录一下要插入的那个值
    //下边是找到要插入的位置,依次对比，也就是找到那个位置
    int j;
    for(j=i-1; j>=0; j--) {
     if(v<a[j]) {
      a[j+1]=a[j];
     } else
      break;//注意跳出去以后的位置是j+1
    }
    a[j+1]=v;
   }
  }
  //选择排序
  void  xuansort(vector<int> &a) {
   int L = a.size();
   for(int i=0; i<L; i++) {
    auto it = min_element(a.begin()+i,a.end());
    if(i!=it-a.begin()) {
     swap(a[i],a[it-a.begin()]);
    }
   }
  }
  //冒泡排序
  void maopaosort(vector<int> &a) {
   int L = a.size();
   for(int i=0; i<L-1; i++) {
    for(int j=0; j<L-1; j++) {
     if(a[j]>a[j+1])
      swap(a[j],a[j+1]);
    }
   }
  }
  //希尔排序
  void xierpaixu(vector<int> &a) {
   int L = a.size();
   int temp,step=L/2;
   while(step>0) {
    //按照步长进行插入排序
    for(int i=step; i<L; i++) {
     temp = a[i];
     int j;
     for(j = i-step; j>=0; j -= step) {
      if(a[j]>temp)
       a[j+step] = a[j];
      else
       break;
     }
     a[j+step]=temp;//注意挑出来的时候多减去了一个step,因此正确位置应该再多加一个
    }
    step /= 2;
   }
  }
  //归并排序
  void guibingsort(vector<int> &a) {
   if(a.size()<2)
    return ;
   sortprocess(a,0,a.size()-1);
  }
  //堆排序
  void duipaisort(vector<int>& arr) {
   int L = arr.size();
   for(int i = L/2; i>=0; --i) {
    Heap_build(arr,i,L);
   }
   for(int j=L-1; j>0; --j) {
    swap(arr[0],arr[j]);
    Heap_build(arr,0,j);
   }
  }
 private:
  //归并排序的辅助函数
  void sortprocess(vector<int>&arr,int L,int R) {
   if(L==R) {
    return ;
   }
   if(L<R) {
    int mid = (L+R)/2;
    sortprocess(arr,L,mid);
    sortprocess(arr,mid+1,R);
    guibingmerge(arr,L,mid,R);
   }
  }
  void guibingmerge(vector<int>&arr,int L,int mid,int R) {
   vector<int> ans(R-L+1,0);
   int i=L,j=mid+1,index=0;//双指针
   while(i<=mid&&j<=R) {
    ans[index++] = arr[i]>arr[j]?arr[j++]:arr[i++];
   }
   while(i<=mid) {
    ans[index++]=arr[i];
   }
   while(j<=R) {
    ans[index++]=arr[j];
   }
   for(int i=0; i<R-L+1; i++) {
    arr[L+i] = ans[i];
   }
  }
  //堆排序辅助函数
  void Heap_build(vector<int>& a,int root,int length) {
   int lchild = root*2+1;//根节点的左子结点下标
   if (lchild < length) { //左子结点下标不能超出数组的长度
    int flag = lchild;//flag保存左右节点中最大值的下标
    int rchild = lchild+1;//根节点的右子结点下标
    if (rchild < length) { //右子结点下标不能超出数组的长度(如果有的话)
     if (a[rchild] > a[flag]) { //找出左右子结点中的最大值
      flag = rchild;
     }
    }
    if (a[root] < a[flag]) {
     //交换父结点和比父结点大的最大子节点
     swap(a[root],a[flag]);
     //从此次最大子节点的那个位置开始递归建堆
     Heap_build(a,flag,length);
    }
   } else
    return;
  }
};
int main() {
 int n;
 cout<<"输入数组的长度"<<endl;
 cin>>n;
 vector<int> arr(n);
 for(int i=0; i<n; i++) {
  cin>>arr[i];
 }
 AC ac;
 ac.guibingsort(arr);
 for(int i=0; i<n; i++) {
  cout<<arr[i]<<" ";
 }
 return 0;
}