排序算法（不断更新）

今天发现算法还是挺有意思的，可以锻炼脑袋，有时还是挺考验脑力的。有待更新….边学边记录

排序算法

冒泡排序法

冒泡排序法最为核心的部分，就是交换数据，每次进行相邻数据的比较，条件成立的时候，交换位置，直到所有数据全部排完为止。

/*
冒泡排序法 n^2
首先遍历每个元素
在将这个元素和前面的每一个元素进行比较
大小不同进行交换，
*/
void BubbleSort(int a[], int n){
    int i, j, temp;
    for (i = 0; i < n; i++){
        for (j = i; j >= 0; j--){
            if (a[j-1] > a[j]){
                temp = a[j];
                a[j] = a[j - 1];
                a[j - 1] = temp;
            }
        }
    }
}

插入排序

插入排序主要通过插入的方法来确定元素的位置，我们首先将第一个数据作为基准，后面的数据和他进行比较，来排在他前面还是后面，然后在进行下个数据，和前面的数据进行比较，确定位置。

int* insertSort(int*a, int len){
    int i = 0;
    int temp;
    while (i<len)
    {
        for (int j = i - 1; j >= 0; j--){
            //当前数据比前面数据大，结束排序
            if (a[j + 1] >= a[j]){
                break;
            }
            else{
                //如果小的化，就重新排列
                temp = a[j + 1];
                a[j + 1] = a[j];
                a[j] = temp;
            }
        }
        i++;
    }
    return a;
}

希尔排序

其实希尔排序也是一个插入排序，不过它里面的思想比较重要，我这里就是写自己的见解：它是将一个数组分为好几个部分，每次分别将这几个部分别插入排序，然后每次减少部分，直到最后每个部分只有一个元素为止，这相当于最后直接在来一次插入排序。
这个比插入排序的优点是：当数据较多时候，我们需要排序，如果每次插入，需要比较的次数和交换的次数太多，那么如何解决这个问题，我们每次将分组的数据已经排序好了，那么最后一次插入排序的时候，交换次数明显较少，最多的是比较，但比较运行比交换快很多，所以希尔排序是对插入排序的改进。

/*
希尔排序法  n^2
将数据分为几组数据，每组进行插入排序
每次减少组数
最后在进行一次插入排序
实现核心就是到最后数据已经有序，比较次数会比较少
*/
void ShellSort(int a[], int n)
{
    int j, gap;

    for (gap = n / 2; gap > 0; gap /= 2)
    for (j = gap; j < n; j++)
        //从数组第gap个元素开始  
    if (a[j] < a[j - gap])
        //每个元素与自己组内的数据进行直接插入排序  
    {
        int temp = a[j];
        int k = j - gap;
        while (k >= 0 && a[k] > temp)
        {
            a[k + gap] = a[k];
            k -= gap;
        }
        a[k + gap] = temp;
    }
}

快速排序

快速排序，在排序算法中，比较快。
他的设计思想比较重要，先选择一个基准，一般选择第一个数据，通过将数组进行前后进行比较，将大于基准的数据排在后面，将小于基准的数据排在前面。第一次排完后，肯定数据分为两个部分，基准将其隔开，然后分别对两个部分在次进行，直到最后只剩下一个数据，一个数据肯定是有序的，然后排序也就完成了。
http://www.cnblogs.com/luchen927/archive/2012/02/29/2368070.html

void FastSort(int *a, int left, int right)
{
    /*如果左边索引大于或者等于右边的索引就代表已经整理完成一个组了*/
    if (left >= right)
    {
        return;
    }
    int i = left;
    int j = right;
    int key = a[left];

    while (i < j)                         
    {
        //从右往左寻找，找到第一个j的位置
        while (i < j && key <= a[j])

        {
            j--;
        }

        a[i] = a[j];

        //从左往右寻找，找到第一个i位置
        while (i < j && key >= a[i])            
        {
            i++;
        }
        //交换数据
        a[j] = a[i];
    }
    a[i] = key;
    //分成子模块继续进行，直到最后全部排完
    FastSort(a, left, i - 1);
    FastSort(a, i + 1, right);  
}

选择排序

选择排序和插入排序的思想相似，但是一个是通过元素找位置，而选择排序是通过位置找元素，每次在剩下来的数据寻找最大或最小的那个，然后将该数据排在指定位置。

/*选择排序 n^2
主要每次在数组中寻找最小值
然后将最小值放在对应的位置上
直到数据全部排完
*/
void SimpleSort(int* a, int n)
{
    int j, i, temp,j1;
    for (i = 0; i < n; i++){
        temp = a[i];
        j1 = i;
        for (j = i+1; j < n; j++){
            if (temp> a[j]){
                temp = a[j];
                //保存最小位置
                j1 = j;

            }
        }
        //交换数据
        a[j1] = a[i];
        a[i] = temp;        
    }
}

堆排序

http://blog.csdn.net/morewindows/article/details/6709644

归并排序

http://www.cnblogs.com/jillzhang/archive/2007/09/16/894936.html