各种排序

#include<iostream>
using namespace std;
/*
 *Insertion sort
 *stable
 *best case: n
 *worst case:n^2
 *average case:n^2
 */
void Insertionsort(int arr[],int n){
  for(int i=1;i<n;i++){
    for(int j=i;(j>0&&arr[j]<arr[j-1]);j--)//当arr[j]比它上面的记录的关键码值小时，向上移动
      swap(arr,j,j-1);
  }
}
/*
 *Bubblesort
 *stable
 *best case: n^2
 *worst case:n^2
 *average case:n^2
 */
void BubbleSort(int arr[],int n){
  bool noSwap; //是否发生交换的标志
  for(int i=0;i<n-1;i++) {//外层每个元素一趟
    noSwap = 1;
    for(int j=n-1;j>i;j--)//从后往前，在当前的i之后，进行两两比较
    {
      if(arr[j]<arr[j-1]){//判断是不是反了
        swap(arr,j,j-1);  //交换
        noSwap = 0;  //发生交换就为0
      }
      if(noSwap)
        return;
    }
  }
}
/*
 *selection sort
 *not stable
 *best case: n^2
 *worst case:n^2
 *average case:n^2
 *选择排序第i次就是选择数组中第i小的记录，放到A[i]中，寻找整个未排序部分
 */
void selsort(int arr[],int n){
  for(int i=0;i<n-1;i++){
    int lowindex = i; //记录选择次数,也是当前最小的值
    for(int j=n-1;j>i;j--){   //从后往前扫描剩余记录
      if(arr[j]<arr[lowindex])//如果发现更小的，记录其位置
        lowindex = j;
      swap(arr,i,lowindex); //把第I小的放到i位置中
    }
  }
}
/*
 *shell sort
 *not stable
 *best case: n^2/3
 *worst case:n^2/3
 *average case:n^2/3
 *将原序列分为n/2个长度为2的子序列，每一个子序列中两个元素的下标相差n/2，
 *第二轮排序有n/4个长度为4的子序列，每一个子序列中两个元素的下标相差n/4，
 *最后一次进行正常的insertion sort
 */
void shellsort(int arr[],int n){
  T temp;
  int gap = n/2;
  while(gap!=0){  //gap为0时停止
    for(int i = gap;i<n;i++){
      temp = arr[i];
      for(int j =i;j>gap;j-=gap)
        if(temp<arr[j-gap])
          arr[[j]=arr[j-gap];
              else
              break;
              arr[j]=temp;
    }
              gap =(int)(gap/2);
  }
}
/*
 *merge sort
 *stable
 *best case: nlogn
 *worst case:nlogn
 *average case:nlogn
 *
 */
     void mergesort(int arr[],int temp[],int left,int right){
      int middle;
      if(left<right){
       middle = (left+right)/2;
       //对左边一半进行递归
       mergesort(arr, temp, left, middle);
       mergesort(arr, temp, middle+1, right);
       //归并
       merge(arr, temp, left, right,middle);
      }
     }
/*
 *quick sort
 *not stable
 *best case: nlogn
 *worst case:nlogn
 *average case:n^2
 *
 */
     void quicksort(int arr[],int left,int right){
      int l = left;
      int r = right;
      int temp = 0;
      if(l<=r){
       temp = arr[l];  //待排序的第一个元素作为pivot
       while(l!=r){ //从左右两边交替扫描直到left=right
        
        while(l<r&&arr[l<=temp])
         l++;
        a[r]=a[l];

        while(r>l&&arr[r>=temp])//从右往左扫描，直到找到第一个 比pivot小的就停
         r--;
        a[l]=a[r]; //左右交换
        
       }
       arr[r]=temp;
       quicksort(arr, left, l-1);
       quicksort(arr, r+1, right);
      }
     }
     
     /*
      *heapsort
      *not stable
      *best case: nlogn
      *worst case:nlogn
      *average case:nlogn
      *
      */
     /*
      *radix sort
      *stable  nlogn
      *假设有10个盒子，对应着0-9，按照初始顺序，把每一个数字的最后一位与盒子的号，相对应，盒子是队列，一端进，另一边                    
      *出，都存进去后，依次dequeue出队，第二轮，按照第一轮排好的顺序，把每一个数字的第一位与号相对应，所有位数都排过
      *就停止。
      *
      */