c++各种排序的简单实现

/*
直插排序
 */
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;
        }
    }
}