C语言经典排序

1 直接插入排序

 在冒泡排序、选择排序编写代码之后，楼主渐渐找到了coding的信心，熟能生巧，就像写词唱曲之前，都得先背诵大量的诗词，熟悉各路歌曲，才能走出自己的路线，有自己的杰作。好吧，来让楼主继续进行"社会主义初级阶段"的任务，这次是插入排序。

一. 算法描述

    插入排序：插入即表示将一个新的数据插入到一个有序数组中，并继续保持有序。例如有一个长度为N的无序数组，进行N-1次的插入即能完成排序；第一次，数组第1个数认为是有序的数组，将数组第二个元素插入仅有1个有序的数组中；第二次，数组前两个元素组成有序的数组，将数组第三个元素插入由两个元素构成的有序数组中......第N-1次，数组前N-1个元素组成有序的数组，将数组的第N个元素插入由N-1个元素构成的有序数组中，则完成了整个插入排序。

以下面5个无序的数据为例：

65 27 59 64 58 （文中仅细化了第四次插入过程）

第1次插入: 27 65 59 64 58

第2次插入: 27 59 65 64 58

第3次插入: 27 59 64 65 58

第4次插入: 27 58 59 64 65

二. 算法分析

平均时间复杂度：O(n2)

空间复杂度：O(1)  (用于记录需要插入的数据)

稳定性：稳定

三. 算法实现

从前向后查找的插入排序：

void insertion_sort(int data[], int n)
{
    int i = 0;
    int j = 0;
    int k = 0;
    int tmp = 0;

    for( i=1;i<n;i++ )
    {   
        j = 0;
        while(j<i&&data[j]<data[i])
        {   
            j++;
        }   
            
        if(j<i)
        {   
            k = i;
            tmp = data[k];
            while(j<k)
            {   
                data[k] = data[k-1];
                k--;
            }   
            data[j] = tmp;                                                                                                                                               
        }
    }   
}

参考链接：http://blog.csdn.net/cjf_iceking/article/details/7916194#t0

2 冒泡法排序

经典排序算法 - 冒泡排序Bubble sort

原理是临近的数字两两进行比较,按照从小到大或者从大到小的顺序进行交换,

这样一趟过去后,最大或最小的数字被交换到了最后一位,

然后再从头开始进行两两比较交换,直到倒数第二位时结束,其余类似看例子

例子为从小到大排序,

原始待排序数组| 6 | 2 | 4 | 1 | 5 | 9 |

第一趟排序(外循环)

第一次两两比较6 > 2交换(内循环)

交换前状态| 6 | 2 | 4 | 1 | 5 | 9 |

交换后状态| 2 | 6 | 4 | 1 | 5 | 9 |

 

第二次两两比较,6 > 4交换

交换前状态| 2 | 6 | 4 | 1 | 5 | 9 |

交换后状态| 2 | 4 | 6 | 1 | 5 | 9 |

 

第三次两两比较,6 > 1交换

交换前状态| 2 | 4 | 6 | 1 | 5 | 9 |

交换后状态| 2 | 4 | 1 | 6 | 5 | 9 |

 

第四次两两比较,6 > 5交换

交换前状态| 2 | 4 | 1 | 6 | 5 | 9 |

交换后状态| 2 | 4 | 1 | 5 | 6 | 9 |

 

第五次两两比较,6 < 9不交换

交换前状态| 2 | 4 | 1 | 5 | 6 | 9 |

交换后状态| 2 | 4 | 1 | 5 | 6 | 9 |

 

第二趟排序(外循环)

第一次两两比较2 < 4不交换

交换前状态| 2 | 4 | 1 | 5 | 6 | 9 |

交换后状态| 2 | 4 | 1 | 5 | 6 | 9 |

 

第二次两两比较,4 > 1交换

交换前状态| 2 | 4 | 1 | 5 | 6 | 9 | 
交换后状态| 2 | 1 | 4 | 5 | 6 | 9 |

 

第三次两两比较,4 < 5不交换

交换前状态| 2 | 1 | 4 | 5 | 6 | 9 | 
交换后状态| 2 | 1 | 4 | 5 | 6 | 9 |

 

第四次两两比较,5 < 6不交换

交换前状态| 2 | 1 | 4 | 5 | 6 | 9 |

交换后状态| 2 | 1 | 4 | 5 | 6 | 9 |

 

第三趟排序(外循环)

第一次两两比较2 > 1交换

交换后状态| 2 | 1 | 4 | 5 | 6 | 9 |

交换后状态| 1 | 2 | 4 | 5 | 6 | 9 |

 

第二次两两比较,2 < 4不交换

交换后状态| 1 | 2 | 4 | 5 | 6 | 9 | 
交换后状态| 1 | 2 | 4 | 5 | 6 | 9 |

 

第三次两两比较,4 < 5不交换

交换后状态| 1 | 2 | 4 | 5 | 6 | 9 | 
交换后状态| 1 | 2 | 4 | 5 | 6 | 9 |

 

第四趟排序(外循环)无交换

第五趟排序(外循环)无交换

排序完毕,输出最终结果1 2 4 5 6 9

void bubble_sort(int data[], int num)
{
    int i = 0;
    int j = 0;
    int tmp = 0;

    for(i=1; i<num; i++)
    {   
        for(j=0; j<(num-i); j++)
        {                                                                                                                                                                
            if(data[j]>data[j+1])
            {   
                tmp = data[j];
                data[j] = data[j+1];
                data[j+1] = tmp;
            }   
        }   
    }   
}

参考链接：http://www.cnblogs.com/kkun/archive/2011/11/23/2260280.html

3  直接选择法排序

基本思想：每一趟(第i趟， i  = 0, 1, 2, ......n-1)在后面n-i个待排序记录中选出关键字最小的记录，作为有序记录序列的第i个记录。直到第n-2趟完，待排记录只剩下一个，不完再选了！

#include <stdio.h>

void select_sort(int data[], int num)
{
    int i = 0;
    int j = 0;
    int k=0;
    int tmp=0;

    for(i=0; i<num; i++)
    {
        int k = i;

        for(j=i+1; j<num; j++)
        {
            if(data[k] > data[j])
            {
                k = j;  
            }
        }

        if(k != i)
        {
            tmp = data[k];
            data[k] = data[i];
            data[i] = tmp;
        }
    }
}  

参考链接：http://blog.csdn.net/silenough/article/details/7194768