八大排序算法

一、直接插入：（从小到大排）

从第二个开始（记为i）依次往后，每次和的前一个（i-1）比较。

如果第i个元素  大于  第i-1个元素就不做改变，往后走。

如果第i个元素  小于  第i-1个元素：

把第i个元素当做哨兵，在0~i-1之间找到哨兵该呆的位置，插进去。

核心代码：

void InsertSort(int a[], int n)  
{  
    for(int i= 1; i<n; i++)
      {  
        if(a[i] < a[i-1])
          {                 
            int j= i-1;   
            int x = a[i];       
            a[i] = a[i-1];        
            while(x < a[j])
            {  
                a[j+1] = a[j];  
                j--;         //元素后移  
            }  
            a[j+1] = x;      //插入到正确位置  
        }  
    }  
} 

二、希尔排序：

相对直接排序有较大的改进。希尔排序又叫缩小增量排序

先将整个待排序的记录序列分割成为若干子序列分别进行直接插入排序，待整个序列中的记录“基本有序”时，再对全体记录进行依次直接插入排序。

先分一半，两两对应的插入排序；

再对半分，这一组进行插入排序；

再对半分，这样一直到以一个元素为单位......

核心代码：

void ShellInsertSort(int a[], int n, int dk)  
{  
    for(int i= dk; i<n; ++i){  
        if(a[i] < a[i-dk]){          //若第i个元素大于i-1元素，直接插入。小于的话，移动有序表后插入  
            int j = i-dk;     
            int x = a[i];           //复制为哨兵，即存储待排序元素  
            a[i] = a[i-dk];         //首先后移一个元素  
            while(x < a[j]){       //查找在有序表的插入位置  
                a[j+dk] = a[j];  
                j -= dk;             //元素后移  
            }  
            a[j+dk] = x;            //插入到正确位置  
        }  
        print(a, n,i );  
    }  
      
} 
/*
 * 先按增量d（n/2,n为要排序数的个数进行希尔排序 
 */  
void shellSort(int a[], int n){  
  
    int dk = n/2;  
    while( dk >= 1  ){  
        ShellInsertSort(a, n, dk); //希尔直接插入排序 
        dk = dk/2;  
    }  
} 

三、选择排序：

在要排序的一组数中，选出最小（或者最大）的一个数与第1个位置的数交换；

然后在剩下的数当中再找最小（或者最大）的与第2个位置的数交换。

依次类推，直到第n-1个元素（倒数第二个数）和第n个元素（最后一个数）比较为止。

核心代码：

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);  
    }  
} 

四、堆排序：

“参考数据结构里的最小堆最大堆”

五、冒泡排序：

每一趟冒出最小的（或最大的）数。

核心代码：

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;  
            }  
        }  
    }  
}

六、快速排序：

1）选择一个基准元素,通常选择第一个元素或者最后一个元素,

2）跑去基准元素，在头和尾分别设一个指针，头比基准元素小，尾比基准元素大，否则就等待交换，两个指针相遇后,

3）此时基准元素在其排好序后的正确位置

4）然后分别对这两部分记录用同样的方法继续进行排序，直到整个序列有序

核心代码：

void swap(int *a, int *b)  
{  
    int tmp = *a;  
    *a = *b;  
    *b = tmp;  
}  
  
int partition(int a[], int low, int high)  
{  
    int privotKey = a[low];  //选定基准元素                          
    while(low < high)        //开始扫描
    {                                  
        while(low < high  && a[high] >= privotKey) 
              --high;  
        swap(&a[low], &a[high]);  
        while(low < high  && a[low] <= privotKey ) 
              ++low;  
        swap(&a[low], &a[high]);  
    }  
    print(a,10);  
    return low;  
}  
  
  
void quickSort(int a[], int low, int high){  
    if(low < high){  
        int privotLoc = partition(a,  low,  high);  //将表一分为二  
        quickSort(a,  low,  privotLoc -1);          //递归对低子表递归排序  
        quickSort(a,   privotLoc + 1, high);        //递归对高子表递归排序  
    }  
}

--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------

还剩下给归并和基数排序，我下次再更吧......(sorry!)