排序算法

 一、 首先说明一个几个概念     

       1） 如果待排序列中有两个相同的关键字 Ki = Kj，其顺序是Ki在Kj之前。如果经过排序之后，Ki 和 Kj的顺序颠倒了，则说明这个排序方法是不稳定的。否则则是稳定排序。

       2）在内存中就可以完成的排序过程，称为内部排序。如果待排数据量很大，内存不够容纳全部数据，在排序过程中必须对外存进行访问，则叫做外部排序。

二、排序算法

1、直接插入排序

       时间复杂度为O(N^2)，空间复杂度为O(1)，关于插入排序的概念可以谷歌、百度，下面直接上代码

#include<stdio.h>

#define N 6

void inc_sort(int* keys,int size);

int main()
{
    int i;
    int array[6] = {49,38,65,97,76,13};

    inc_sort(array,N);
    
    for(i = 0;i < N;i++)
    {
        printf("%d ",array[i]);
    }
    printf("\n");

    return 0;
}


void inc_sort(int* keys,int size)
{
    int tmp;
    int i,j;

    for(i = 1;i < size;i++)
    {
        tmp = keys[i];
        for(j = i -1;j >= 0;j--)
        {
            if(tmp < keys[j])
            {
                keys[j+1] = keys[j];
            }
            else break;
        }
        keys[j+1] = tmp;
    }

}

2、希尔排序

       希尔排序是对直接插入排序的改良，其时间复杂度是O(NlogN)，空间复杂度为O(1)希尔排序是不稳定的。希尔自己推荐步长为N/2，但是在经过很多人的测试后，发现如果采用步长为1、3、5、7……这样的步长，要优于其他的步长，这样的步长有个特点是相邻步长之间（除1外）没有公因子。

#include<stdio.h>

#define N 6

void shell_sort(int* keys,int size);

int main()
{
    int i;
    int array[6] = {49,38,65,97,76,13};

    shell_sort(array,N);
    
    for(i = 0;i < N;i++)
    {
        printf("%d ",array[i]);
    }
    printf("\n");

    return 0;
}


void shell_sort(int* keys,int size)
{
    int tmp,step;
    int i,j;
    
    step = size/3 + 1;
    do
    {
        for(i = step; i < size; i++)
        {
            tmp = keys[i];
            for(j = i - step ;j >= 0;j -= step )
            {
                if(tmp < keys[j])
                {
                    keys[j+step] = keys[j];
                }
                else break;
            }
            keys[j+step] = tmp;
        }

        step = step / 3 + 1;
    }while(step > 1);

}

3、冒泡排序

        冒泡排序是比较直观易懂的排序算法，所以历来是教科书的必选，冒泡排序的时间复杂度为O(N^2),空间复杂度为O(N)，冒泡是稳定算法。

        下面的冒泡写法可能与传统的冒泡稍有改进，不同的地方在于交换数据上，自己体会吧。

#include<stdio.h>

#define N 6

void bubble_sort(int* keys,int size);

int main()
{
    int i;
    int array[6] = {49,38,65,97,76,13};

    bubble_sort(array,N);
    
    for(i = 0;i < N;i++)
    {
        printf("%d ",array[i]);
    }
    printf("\n");

    return 0;
}


void bubble_sort(int* keys,int size)
{
    int tmp,addr;
    int i,j;

    for(i = 0;i < size;i++)
    {
        tmp = keys[i];
        addr = i;
        for(j = i + 1 ;j < size;j++)
        {
            if(tmp > keys[j])
            {
                tmp = keys[j];
                addr = j;
            }
        }
        
        keys[addr] = keys[i];
        keys[i] = tmp;
    }

}

4、快速排序
       快速排序是分治思想的一种实现，其时间复杂度为O(NlogN)，快速排序是不稳定的。

      具体的做法是：对待排序列keys[n]确定两个指针(low=0，high=n-1)。然后取第一个关键字keys[0]作为pivotkey(枢轴)。首先从high所指的位置起向前搜索找到第一个关键字小于pivotkey的记录，并将这个记录的关键字与pivotkey交换。然后从low所指的位置向后搜索，找到第一个关键字大于pivotkey的记录，并交换。轮流重复这两个步骤直到low=high位置。这样一个过程我们叫做一次快排(又叫一次划分)。

 

#include<stdio.h>

#define N 6

void quick_sort(int* keys,int size);
void quick_sort_impl(int* keys,int left,int right);

int main()
{
    int i;
    int array[6] = {49,38,65,97,76,13};

    quick_sort(array,N);
    
    for(i = 0;i < N;i++)
    {
        printf("%d ",array[i]);
    }
    printf("\n");

    return 0;
}

void quick_sort(int* keys,int size)
{
    if(size > 1)
        quick_sort_impl(keys,0,size - 1);
}

void quick_sort_impl(int* keys,int left,int right)
{
    int pivotkey;
    int save_left,save_right;
    save_left = left;
    save_right = right;
    
    pivotkey = keys[left];
    
    while(left < right)
    {
        while(left < right && keys[right] > pivotkey) right--;
        if(left < right)
        {
            keys[left] = keys[right];
            left++;
        }
    
        while(left < right && keys[left] < pivotkey) left++;
        if(left < right)
        {
            keys[right] = keys[left];
            right --;
        }
    }
    keys[left] = pivotkey;

    if(save_left < left)
        quick_sort_impl(keys,save_left,left-1);
    if(save_right > left)
        quick_sort_impl(keys,left+1,save_right);


}

5、归并排序