直接插入排序 + 希尔排序+ 冒泡排序+ 快速排序 + 直接选择排序 + 堆排序

#include <iostream>
#include<stdio.h>

using namespace std;
//插入排序有 ： 直接插入排序 + 希尔排序
//交换排序有 ： 冒泡排序 + 快速排序
//选择排序有 ： 直接选择排序 + 堆排序

//直接插入排序****************
//对数组R[]的n个记录直接插入排序，记录依次存放在R[1]到R[n]中
void insertsort(int R[] , int n ){
    int i , j;
    for(i = 2 ; i <= n ; i++){
        R[0] = R[i] ;    // 监视哨存待插入记录
        j = i - 1 ; // 开始向前搜索插入位置
        while(R[0] < R[j]){
            R[j+1] = R[j] ; // 向后移动
            j-- ;    // 继续向前搜索
        }
        R[j + 1] = R[0] ;  //插入第i个记录
    }
}

// 希尔排序****************************
//对数组R[]中由R[1]到R[n]存放的n个记录进行希尔排序
void shellsort(int R[] , int n){
    int i , j , d ;
    d = n ;   // 增量d初始化
    do{
        d = ( d + 1) / 2 ;  //缩小增量d为 (d + 1) / 2
      //  cout<<"d = " << d << endl;
        for( i  = d + 1 ; i <= n ; i++){ // 分d组执行直接插入排序
            R[0] = R[i] ;  //存入待插入记录
            j = i - d ;  // 开始向前搜索插入位置
            while((j > 0) && (R[0]  <  R[j]) ){
                R[j + d] = R[j] ; // 向后移动
                j = j - d ;    //继续搜索
            }
            R[j + d] = R[0] ;  //插入第i个记录
        }
    }while(d > 1) ;
}
//冒泡排序*************************
// 对待排序文件 R[1]到R[n]冒泡排序
void bubblesort(int R[] ,  int n){
    int i , j , flag ;
    int temp ;
    for(i = 1 ; i<= n - 1 ; i++){ //进行n-1趟冒泡排序
        flag = 0 ;
        for(j = n ; j>= i + 1 ; j--){ // 一趟中由后向前扫描
            if(R[j - 1] > R[j] ){ //相邻记录交换
                temp = R[j - 1] ;
                R[j - 1] = R[j] ;
                R[j] = temp ;
                flag = flag + 1 ;
            }
        }
        if(flag == 0) //没有交换，可提前终止排序
            break ;
    }
}

//快速排序**********************

//快速排序中 分割排序算法
//对待排序记录区间[s ， t]，以R[s]为基准进行一次分割排序，并返回基准记录的最终位置

int divideareasort(int R[] ,  int s , int t){
    int i , j ; // 定义指示器变量
    int temp ; // 定义暂存基准记录
    i = s , j = t ;
    temp = R[s] ;
    do{
        while( (R[j] >= temp) && (i < j )){ // 自后向前扫描，找小于基准关键字的记录
            j--;
        }
        if(i < j){
            R[i] = R[j] ; //移动
            i++ ;
        }

        while((R[i] <= temp ) && ( i < j)){ //自前向后扫描，找大于基准关键字的记录
            i++ ;
        }
        if(i < j){
            R[j] = R[i] ; //移动
            j-- ;
        }
    }while(i < j) ;
    R[i] = temp ; //将基准记录移到最终位置
    return i ; // 返回基准记录的最终位置
}
void quicksort(int R[] , int s ,  int t){
    int i ;
  //  cout<<"s =" <<s <<"-" << "t = " << t << endl;
    if(s <t){ //递归结束条件是 s <= t 二叉树XXX遍历
        i = divideareasort(R , s ,t) ; // 分割区间
        quicksort(R , s , i - 1) ; //对基准记录前的区间快速排序
        quicksort(R , i+1 , t) ;//对基准记录后的区间快速排序
    }
}
//直接选择排序***********************
//对待排序R[1-n]进行直接选择排序
void selectsort(int R[] , int n){
    int i , j , m ;
    int temp ;
    for(i = 1 ; i<= n -1 ; i++){ //控制n -1 趟选择排序
        m = i ;  //预置i 为最小关键字记录的下标，存于m
        for(j = i + 1 ; j<= n ; j++){ // 在一趟中选最小关键字记录
            if(R[j] < R[m])
                m = j ; //更新最小值下标
        }
        if(m != i){
            temp = R[i] ;
            R[i] = R[m] ;
            R[m] = temp ;
        }
    }
}
// 堆排序**********************
// 对R[s ,t]进行堆调整的筛选算法，除R[s]外其他位置都满足最小值根堆定义
void heapadjust(int R[] ,  int s , int t){
    int i , j ; //定义指示器变量
    int temp  = R[s]; // temp存放待筛选的记录
    i = s ; // i初始化为s，即指向待筛选记录
    j = 2 * i ;//j初始化为2i，即指向待筛选记录的左孩子
    while(j <= t){ //逐层向下筛选
        if((j < t) && R[j] > R[j + 1]){
            j++ ; // 若右孩子记录关键字值小，让j指向右孩子
        }
        if(temp > R[j]){  // 孩子记录关键字值小的话，向下筛选
            R[i] = R[j] ; // 孩子记录上移
            i = j ;  //继续筛选
            j = 2 *i ;
        }
        else{
            j = t+ 1 ; // 孩子记录关键值大时，筛选结束，准备退出循环
        }
    }
    R[i] = temp ; //将最初待筛选记录填入正确位置，满足最小值根堆
}
//对 R[1-n] 进行 堆排序
void heapsort(int R[] ,  int n){
    int i ;
    int temp ;
    for(i = n / 2 ; i>= 1 ; i--){ // 调用筛选算法建立初始堆
        heapadjust(R , i , n) ;
    }
    cout << "初建堆" << endl;
     for(int i =1 ; i<= 8 ; i++ ){
        cout << R[i] << " - " ;
        }
       cout << endl  << "结束" << endl;
    for(i = n ; i> 1 ; i--){ // n -1 次 输出堆顶记录 并调整堆
        temp = R[1] ; // 堆顶记录与当前堆中最后一个记录交换
        R[1] = R[i] ;
        R[i] = temp ;
        heapadjust(R , 1 , i - 1) ; // 调用筛选算法重建堆
    }
}

int main()
{
   int insertTestA[9]  = {0 , 23 , 48 , 32 , 107 , 86 , 75  , 48 , 68} ;
   int shellTestB[11] = {0 , 52 , 38 , 66 , 87 , 77 , 16 , 30 , 52 , 62 , 7} ;
   int bubbleTestC[9] = {  0, 8,7,6,5,4,3,2,1} ;
   int quickTestD[8] = {36 , 73 , 65 , 97 , 13 , 27 , 36 , 29} ;
   int selectTestE[8] = {0 , 48 , 36 , 65 , 97 , 15 , 27 , 48} ;
   int heapTestF[9] = {0 , 47 , 33 , 61 , 82 , 72 , 11  ,25, 47} ;

 insertsort(insertTestA , 8) ;
 cout<<"insertsort" << endl ;
 for(int i = 1 ; i<= 8 ;i++)
    cout<<insertTestA[i] << "-" ;
 cout<< endl;

 shellsort(shellTestB , 10) ;
 cout<<"shellsort"<< endl;
 for(int i =1 ; i<= 10 ; i++)
    cout<<shellTestB[i] << "-" ;
 cout<< endl;

  bubblesort(bubbleTestC , 8) ;
  cout<< "bubblesort" << endl ;
  for(int i = 1 ; i<= 8 ; i++)
    cout<<bubbleTestC[i] << " -" ;
  cout<< endl;

  quicksort(quickTestD , 0 , 7) ;
  cout << "quicksort" << endl;
  for(int i = 0 ; i<= 7 ; i++){
    cout<< quickTestD[i] << " - ";
  }
  cout << endl;

   selectsort(selectTestE , 7) ;
   cout<<"selectsort" << endl;
   for(int i =1 ; i<= 7 ; i++ ){
    cout << selectTestE[i] << " - " ;
   }
   cout << endl ;

   heapsort(heapTestF , 8) ;
   cout << "heapsort"<< endl;
   for(int i = 1 ; i<= 8 ; i++)
        cout << heapTestF[i] << " - " ;
   cout << endl;
    return 0;
}