排序实现

#include<stdio.h>
#include<stdlib.h>
const int SIZE=9;


void swap(int &a,int &b){
    int temp;
    temp = a;
    a    = b;
    b    = temp;     
}

//插入排序  稳定 
void insertion_sort(int s[],int n){
    int i,j;
    int next;
    for(i=1;i<n;i++){
        next = s[i];
        for(j=i-1;j>=0 && next<s[j];j--){
            s[j+1] = s[j];
        }
        s[j+1] = next;
    }
}

 
//shell排序 不稳定 分组插入
void shell(int s[],int n){
    int i,j,k,t;
    (n/2)%2 == 0?k=n/2+1:k=n/2;//increat by odder;
    while(k>0){
        for(j=k;j<n;j++){
            t = s[j];
            i = j - k;
            while(i>=0 && t<s[i]){
                s[i+k] = s[i];
                i = i - k;
            }
            s[i+k]=t;
        }
        if(k == 1) break;
        (k/2)%2 == 0?k=k/2+1:k=k/2;
    }
}


//快速排序  不稳定 
void quicksort(int s[],int left,int right){
     int pivot,i,j;
     int temp;
     if(left<right){
         i=left; j = right+1;
         pivot = s[left];
         do{
             do{
                 i++;
             }while(s[i]<pivot);
             do{
                 j--;
             }while(s[j]>pivot);
             if(i<j){
                    // swap(s[i],s[j]);
                 s[i] = s[i] + s[j];
                 s[j] = s[i] - s[j];
                 s[i] = s[i] - s[j];
             }
             
         }while(i<j);
         swap(s[left],s[j]);
         quicksort(s,left,j-1);
         quicksort(s,j+1,right);  
     }
     
    
} 

//快速排序
int quicksort(vector<int> &v, int left, int right){
        if(left < right){
                int key = v[left];
                int low = left;
                int high = right;
                while(low < high){
                        while(low < high && v[high] > key){
                                high--;
                        }
                        v[low] = v[high];
                        while(low < high && v[low] < key){
                                low++;
                        }
                        v[high] = v[low];
                }
                v[low] = key;
                quicksort(v,left,low-1);
                quicksort(v,low+1,right);
        }
}

//快速排序
void quick_sort(int s[], int l, int r)
{
    if (l < r)
    {
        //Swap(s[l], s[(l + r) / 2]); //将中间的这个数和第一个数交换 参见注1
        int i = l, j = r, x = s[l];
        while (i < j)
        {
            while(i < j && s[j] >= x) // 从右向左找第一个小于x的数
                j--;  
            if(i < j) 
                s[i++] = s[j];
            while(i < j && s[i] < x) // 从左向右找第一个大于等于x的数
                i++;  
            if(i < j) 
                s[j--] = s[i];
        }
        s[i] = x;
        quick_sort(s, l, i - 1); // 递归调用 
        quick_sort(s, i + 1, r);
    }
}

//直接选择排序 不稳定 

void choose_sort(int s[],int n){
    int k,t;
    for(int i=0;i<n;i++){
        k = i;
        for(int j =i+1;j<n;j++){
            if(s[j]<s[k]) k = j;
        }
        if(k!=i){
            swap(s[k],s[i]);
        }
    
    }
} 
//冒泡排序 不稳定
void bubble(int s[],int n){
    int bound,t;
    int j;
    bound = n-1;
    while(bound != 0){
       t = 0;
       for(j=0;j<bound;j++){
           if(s[j]>s[j+1]){
               swap(s[j],s[j+1]);
               t = j;
           }
       }
       bound = t;
    }
} 
//堆排序
/*void adjust(int s[],int root,int n){
    int child;
    int temp;
    temp = s[root];
    child = 2*root;
    while(child<=n){
        if(child<n && (s[child]<s[child+1]))
            child++;
        if(temp>s[child])
            break;
        else{
            s[child/2] = s[child];
            child *=2;
        }
        s[child/2] = temp;  
    }
} 
void heapsort(int s[],int n){
    int i,j;
    int temp;
    for(i = n/2;i>0;i--)
        adjust(s,i,n);
    for(i=n-1;i>0;i--){
        swap(s[1],s[i+1]);
        adjust(s,1,i);
    }
} */
void adjust(int s[],int root,int n){
    int child;
    int temp;
    temp = s[root];
    child = 2*(root+1);
    while(child<=n){
        if(child>0 && (s[child-1]>s[child]))
            child--;
        if(temp>s[child])
            break;
        else{
            s[(child+1)/2-1] = s[child];
            child = 2*(child+1);
        }
        s[(child+1)/2-1] = temp;  
    }
} 
void heapsort(int s[],int n){
    int i,j;
    int temp;
    for(i = (n+1)/2-1;i>=0;i--)
        adjust(s,i,n-1);
    for(i=n-2;i>=0;i--){
        swap(s[0],s[i+1]);
        adjust(s,0,i);
    }
}
int main(){
    //freopen("sort_out.txt","w",stdout);
    int a[]={5,4,1,2,3,8,6,9,7};
    //insertion_sort(a,SIZE);
    //quicksort(a,0,SIZE-1);
    //shell(a,SIZE);
    //choose_sort(a,SIZE);
    //bubble(a,SIZE);
    //heapsort(a,SIZE);
    adjust(a,0,SIZE-1); 
    for(int i=0;i<SIZE;i++)
        printf("%5d",a[i]);
    printf("\n");
    //getchar();
    system("pause");
    return 0;
}