常用排序算法

1、交换排序－冒泡排序
（1）思想：从待排数据自上向下对相邻的两个元素进行比较，必要时交换，使大的元素下沉，小的元素上冒。

第一次比较时，将待排数据中的最大的元素，沉到最低；第二次比较将第二大元素沉到最低，……
所以如果有n个元素，进行n－1次排序；对于第i次排序，内部需要交换的次数为n－i－1；
（2）代码

//冒泡排序
void bubbleSort(int a[], int n){
    for(int i =0 ; i< n-1; ++i) {
        for(int j = 0; j < n-i-1; ++j) {
            if(a[j] > a[j+1])
            {
                int tmp = a[j] ; a[j] = a[j+1] ;  a[j+1] = tmp;
            }
        }
    }

}

(3)改进：传统冒泡排序中每一趟排序操作只能找到一个最大值或最小值,我们考虑利用在每趟排序中进行正向和反向两遍冒泡的方法一次可以得到两个最终值(最大者和最小者) , 从而使排序趟数几乎减少了一半。

void Bubble_2 ( int r[], int n){
    int low = 0; 
    int high= n -1; //设置变量的初始值
    int tmp,j;
    while (low < high) {
        for (j= low; j< high; ++j) //正向冒泡,找到最大者
            if (r[j]> r[j+1]) {
                tmp = r[j]; r[j]=r[j+1];r[j+1]=tmp;
            } 
        --high;                 //修改high值, 前移一位
        for ( j=high; j>low; --j) //反向冒泡,找到最小者
            if (r[j]<r[j-1]) {
                tmp = r[j]; r[j]=r[j-1];r[j-1]=tmp;
            }
        ++low;                  //修改low值,后移一位
    } 
}

2、交换排序－快速排序
（1）基本思想：
＊选一个基准元素(一般是第一个元素)，有两个分别指向第一个元素和最后一个元素的指针
＊进行第一趟排序，从后开始依次向前查找，找到比基准元素小的元素就和基准元素交换位置；然后从前依次向后查找，找到比基准元素的大的元素就和基准元素交换位置。第一趟排完后，带排序数据以基准元素为界分为两部分，基准元素在其排好序的正确位置。
＊然后分别对两部分在按照同样的方法排序

一趟排序的过程：

排序的全过程

（2）代码

//快速排序
void swap(int *a,int *b){
    int temp = *a;
    *a = *b;
    *b = temp;

}

int partition(int a[],int low,int high){

    int key = a[low];
    while (low < high) {
        while (low < high && a[high] >= key)
            --high;
        swap(&a[low], &a[high]);
        while (low<high && a[low] <= key) {
            ++low;
         swap(&a[low], &a[high]);
        }

    }

    return low;
}

void quickSort(int a[],int low,int high){
    if (low < high) {
        int keyLoc = partition(a, low, high);
        quickSort(a, low, keyLoc-1);
        quickSort(a, keyLoc+1, high);
    }


}

3、插入排序－直接插入排序
（1）先将序列的第一个记录看成是有序的字序列，然后从第二个记录开始逐个进行插入，直至整个序列有序为止（如果碰见一个和插入元素相等的，那么插入元素把想插入的元素放在相等元素的后面。）。
要点：设立哨兵，作为临时存储和判断数组边界之用。

（2）代码

//直接插入排序
void insert_sort(int a[],int n)
{

    for(int i=1;i<n;i++) {
        int t=a[i];
        int j;
        for(j=i-1;j>=0&&a[j]>t;j--) {
                a[j+1]=a[j];
        }
        a[j+1]=t;
        print(a,n);
    }

}

4、插入排序－希尔排序
（1）将整个待排序记录分割成为若干子序列分别进行直接插入排序，当整个序列中的纪录’基本有序’时，在对全体纪录依次直接插入排序

我们简单处理增量序列：增量序列d = {n/2 ,n/4, n/8 …..1} n为要排序数的个数
即：先将要排序的一组记录按某个增量d（n/2,n为要排序数的个数）分成若干组子序列，每组中记录的下标相差d.对每组中全部元素进行直接插入排序，然后再用一个较小的增量（d/2）对它进行分组，在每组中再进行直接插入排序。继续不断缩小增量直至为1，最后使用直接插入排序完成排序。

（2）代码

void shellsort(int a[],int n){

    int gap=n/2;
    while(gap>0){
        for(int i=gap;i<n;i++){
            int t=a[i];
            int j;
            for(j=i-gap;j>=0&&a[j]>t;j-=gap)
                a[j+gap]=a[j];
            a[j+gap]=t;
        }
        gap/=2;
    }
}

5.选择排序－简单选择排序

（1）第一趟，从n个记录中找出关键码最小的记录与第一个记录交换；第二趟，从n－1个记录中在找到关键码最小的记录与第二个记录交换；…….

（2）代码

int SelectMinKey(int a[], int n, int i)
{
    int k = i;
    for(int j=i+1 ;j< n; ++j) {
        if(a[k] > a[j]) k = j;
    }
    return k;
}


void selectSort(int a[], int n){
    int key, tmp;
    for(int i = 0; i< n; ++i) {
        key = SelectMinKey(a, n,i);           //选择最小的元素
        if(key != i){
            tmp = a[i];  a[i] = a[key]; a[key] = tmp; //最小元素与第i位置元素互换
        }
        print(a,  n , i);
    }
}