/*
直插排序
 */
void InsertSort(vector<int> &arr){
    for(int i = 1;i < arr.size();++i){
        for(int j = i;j > 0;--j){
            if(arr[j] < arr[j - 1]){
                int temp = arr[j];
                arr[j] = arr[j-1];
                arr[j-1] = temp;
            }
            else break;
        }
    }
}    

/*
冒泡排序
 */
void BubbleSort1(vector<int> &arr){
    for (int i = 0; i < arr.size() - 1; i++) {
    	bool flag=true;
        for (int j = 0; j < arr.size() - i - 1; j++) { //經過第1趟可以找出最大的數
            if (arr[j] > arr[j + 1]) {
                int temp = arr[j];
                arr[j] = arr[j + 1];
                arr[j + 1] = temp;
                flag=false;
            }
        }
        if(flag) return;
    }
}

void BubbleSort2(vector<int> &arr){
    for (int i = 0; i < arr.size() - 1; i++) {
    	bool flag=true;
        for (int j = arr.size()-1; j > i; j--) {
            if (arr[j] < arr[j - 1]) {
                int temp = arr[j];
                arr[j] = arr[j + 1];
                arr[j + 1] = temp;
                flag=false;
            }
        }
        if(flag) return;
    }
}

/*
快速排序
 */
void quicksort(vector<int> &arr, int left, int right)
{
    if(left >= right) return ;
    int i = left;
    int j = right;
    int key = arr[left]; //比較的是第一個數
    while(i < j)                             
    {
        while(i < j && key <= a[j])
        {
            j--;
        }
        arr[i] = arr[j];      
        while(i < j && key >= a[i])
        {
            i++;
        }
        arr[j] = arr[i];
    }
    arr[i] = key;/*當在當組內找完一遍以後就把中間數key回歸*/
    quicksort(arr, left, i - 1);
    quicksort(arr, i + 1, right);               
}


/*
歸並排序
 */

void Merge(int& arr[], int reg[], int start, int end) {
    if (start >= end) return;
    int mid = (end + start) >> 1;
    //分成兩部分
    int start1 = start, end1 = mid;
    int start2 = mid + 1, end2 = end;
    //然後合並
    Merge(arr, reg, start1, end1);
    Merge(arr, reg, start2, end2);

    int k = start;
    //兩個序列一一比較,哪的序列的元素小就放進reg序列裏面,然後位置+1再與另一個序列原來位置的元素比較
    //如此反復,可以把兩個有序的序列合並成一個有序的序列
    while (start1 <= end1 && start2 <= end2)
        reg[k++] = arr[start1] < arr[start2] ? arr[start1++] : arr[start2++];

    //然後這裏是分情況,如果arr2序列的已經全部都放進reg序列了然後跳出了循環
    //那就表示arr序列還有更大的元素(一個或多個)沒有放進reg序列,所以這一步就是接著放
    while (start1 <= end1)
        reg[k++] = arr[start1++];

    //這一步和上面一樣
    while (start2 <= end2)
        reg[k++] = arr[start2++];
    //把已經有序的reg序列放回arr序列中
    for (k = start; k <= end; k++)
        arr[k] = reg[k];
}

void MergeSort(int& arr[], const int len) {
    //創建一個同樣長度的序列,用於臨時存放
    int reg[len];
    Merge(arr, reg, 0, len - 1);
}


//折半插入排序  O(nlog2(n)) 穩定 
int low,high,middle;
void BinaryInsertSort(int a[], int len){
   for(int i=0;i<len;i++){
      int temp=a[i];
      low=0;high=i-1;
      while(low<=high){
         middle=(low+high)/2;
         if(temp<a[middle]){
            high=middle-1;
         }
         else{
            low=middle+1;
         }
      }
      for(int k=i;k>low;k--){
         a[k]=a[k-1];
      }
      a[low]=temp;
   }
}

 
/**************************************/
//希爾排序  速度很難定量 但是效率挺高的 不穩定的算法 
void Shellsort(int a[], int len){
   int gap=len-1;  //初始增量 
   bool flag=0;
   while(gap>=1){
      if(gap==1) flag=1;
      for(int i=0;i<len;i++){
         if(i+gap<len){
            if(a[i]>a[i+gap]){
               int temp=a[i];
               a[i]=a[i+gap];
               a[i+gap]=temp;
            }           
         }
         else break;
      }
      gap=gap/3+1; //增量計算公式
      if(flag) break;
   }
} 


//堆排序
void HeapSort(int arr[],int len){
    int i;
    //初始化堆，從最後一個父節點開始
    for(i = len/2 - 1; i >= 0; --i){
        Heapify(arr,i,len);
    }
    //從堆中的取出最大的元素再調整堆
    for(i = len - 1;i > 0;--i){
        int temp = arr[i];
        arr[i] = arr[0];
        arr[0] = temp;
        //調整成堆
        Heapify(arr,0,i);
    }
}
//再看 調整成堆的函數

void Heapify(int arr[], int first, int end){
    int father = first;
    int son = father * 2 + 1;
    while(son < end){
        if(son + 1 < end && arr[son] < arr[son+1]) ++son;
        //如果父節點大於子節點則表示調整完畢
        if(arr[father] > arr[son]) break;
        else {
         //不然就交換父節點和子節點的元素
            int temp = arr[father];
            arr[father] = arr[son];
            arr[son] = temp;
            //父和子節點變成下一個要比較的位置
            father = son;
            son = 2 * father + 1;
        }
    }
}

c++各種排序的簡單實現