c语言排序算法

为了应付面试，不得不将c语言再来复习一遍，现在将所写的排序算法保存下来，以便以后再次复习。这里的排序都是从小到大排序。

1. 冒泡排序

冒泡法大家都较熟悉，原理也比较简单。第一次循环从第一个元素开始，一个和相邻的下一个数比较，若a[n]>a[n+1] 则就交换，这样第一次循环将最大的数排在了最后；依次第二次循环，第三次循环。。。。具体请分析代码。

int sort_bubble(int *array,int len)
{
        if(NULL == array)
                return -1;
        int i,j;
        for(i=0; i<len; i++)
                for(j=0; j < len-i-1; j++)
                {
                        if(array[j]>array[j+1])
                        {
                                SWITCH(array[j],array[j+1]);
                        }
                }
        return 0;
}

2. 选择排序算法：

选择法循环过程与冒泡法一致，它还定义了记号k=i,然后依次把a[k]同后面元素比较，若a[k]>a[j],则使k=j.最后看看k=i是否还成立，不成立则交换a[k],a[i],这样就比冒泡法省下许多无用的交换，提高了效率。

3.快速排序算法：

    快速排序（quick sort）。在这种方法中， * n 个元素被分成三段（组）：左段left， * 右段right和中段middle。中段
 * 仅包含一个元素。左段中各元素都小于等 * 于中段元素，右段中各元素都大于等于中 * 段元素。因此left和right中的元 * 素可以独立排序，并且不必对left和 * right的排序结果       进行合并。
 * 使用快速排序方法对a[0:n-1]排序
 * 从a[0:n-1]中选择一个元素作为middle， * 该元素为支点把余下的元素分割为两段left * 和right，使得left中的元素都小于
 * 等于支点，而right 中的元素都大于等于支点 * 递归地使用快速排序方法对left 进行排序 * 递归地使用快速排序方法对right 进行排序 * 所得结果为left+middle+right 

4. 插入排序算法：

    插入法是一种比较直观的排序方法。它首先把数组头两个元素排好序，再依次把后面的元素插入适当的位置。把数组元素插完也就完成了排序。

5. 希尔排序算法：

    shell法是一个叫 shell 的美国人与1969年发明的。它首先把相距k(k>=1)的那几个元素排好序，再缩小k值（一般取其一半），再排序，直到k=1时完成排序。下面让我们来分     析其代码：

附整个源程序：

#include <stdio.h>
#define Num 10
#define ARRAY_LEN(array) (sizeof(array)/sizeof(array[0]))
#define SWITCH(a,b) {a = a+b; b = a-b; a=a-b; }
int sort_bubble(int *array, int len);
int sort_choose(int *array, int len);
int sort_quick(int *array, int start, int end);
int sort_insert(int *array, int len);
int sort_shell(int *array, int len);
void print_array(char *s,int *, int);
int main()
{
        int array0[] = {90,46,56,245,987,74,34,67,97,25,63,25,265,26,96,36,48,39,354,523,239,185,56,36,123,345,321,94,56,74,34,235,6
77,644,22,3232,11,45,67,54,22,33,223,345,678,987,564,453,345};
        int array1[] = {90,46,56,245,987,74,34,67,97,25,63,25,265,26,96,36,48,39,354,523,239,185,56,36,123,345,321,94,56,74,34,235,6
77,644,22,3232,11,45,67,54,22,33,223,345,678,987,564,453,345};
        int array2[] = {90,46,56,245,987,74,34,67,97,25,63,25,265,26,96,36,48,39,354,523,239,185,56,36,123,345,321,94,56,74,34,235,6
77,644,22,3232,11,45,67,54,22,33,223,345,678,987,564,453,345};
        int array3[] = {90,46,56,245,987,74,34,67,97,25,63,25,265,26,96,36,48,39,354,523,239,185,56,36,123,345,321,94,56,74,34,235,6
77,644,22,3232,11,45,67,54,22,33,223,345,678,987,564,453,345};
        int array4[] = {90,46,56,245,987,74,34,67,97,25,63,25,265,26,96,36,48,39,354,523,239,185,56,36,123,345,321,94,56,74,34,235,6
77,644,22,3232,11,45,67,54,22,33,223,345,678,987,564,453,345};
        sort_bubble(array0,ARRAY_LEN(array0));
        print_array("Sort_Bubble:",array0,ARRAY_LEN(array0));

        sort_choose(array1,ARRAY_LEN(array1));
        print_array("Sort_Choose:",array1,ARRAY_LEN(array1));

        sort_quick(array2, 0, ARRAY_LEN(array2)-1);
        print_array("Sort_Quick:",array2,ARRAY_LEN(array2));

        sort_insert(array3, ARRAY_LEN(array3));
        print_array("Sort_Insert:",array3,ARRAY_LEN(array3));

        sort_shell(array4, ARRAY_LEN(array4));
        print_array("Sort_shell:",array4,ARRAY_LEN(array4));
        return 0;
}
int sort_bubble(int *array,int len)
{
        if(NULL == array)
                return -1;
        int i,j;
        for(i=0; i<len; i++)
                for(j=0; j < len-i-1; j++)
                {
                        if(array[j]>array[j+1])
                        {
                                SWITCH(array[j],array[j+1]);
                        }
                }
        return 0;
}
void print_array(char *s,int *array, int len)
{
        if(NULL==array)
                return;
        int i;
        printf("%s",s);
        for(i=0; i<len; i++)
        {
                if(i%Num == 0)
                        printf("\n");
                printf("%d\t",array[i]) ;
        }
        printf("\n");

}
int sort_choose(int *array, int len)
{
        if(NULL == array)
                return -1;
        int i,j,k;
        for(i=0;i<len; i++)
        {
                k = 0;
                for(j=0; j<len-i; j++)
                {
                        if(array[k]<array[j])
                        {
                                //SWITCH(array[k],array[j]);
                                k = j;
                        }
                }
                if(k!=j-1)
                        SWITCH(array[k],array[j-1]);
        }

        return 0;
}
int sort_quick(int *array, int start, int end)
{
        if(NULL == array || start >= end)
                return -1;
        int low,high,tmp;
        low = start;
         high = end;
        tmp = array[low];
        while(low<high)
        {
                while(high>low && array[high]>tmp) high--;
                if(high==low)
                        break;
                array[low] = array[high];
                low++;
                while(low<high && array[low]<tmp ) low++;
                if(high == low)
                        break;
                array[high] = array[low];
                high--;

        }
        array[low] = tmp;
        sort_quick(array,low+1,end);
        sort_quick(array,start,low-1);


        return 0;
}
int sort_insert(int *array, int len)
{
        if(NULL == array)
                return -1;

        int i,j,tmp;
        for(i=1; i<len; i++)
        {
                tmp = array[i];
                for(j=i-1; j>-1&&array[j]>tmp; j--)
                {
                        array[j+1] = array[j];
                        array[j] = tmp;
                }
        }
        return 0;
}
int sort_shell(int *array, int len)
{
        int i,j,tmp,step;
        step = len/2;
        while(step>=1){
                for(i=step; i<len; i++)
                {
                        tmp = array[i];
                        j = i-step;
                        while(j>=0 && array[j]>tmp)
                        {
                                array[j+step] = array[j];
                                j-=step;
                        }
                        array[j+step] = tmp;

                }
        step/=2;
        }
        return 0;
}

运行结果：

Sort_Bubble:
11      22      22      25      25      26      33      34      34      36
36      39      45      46      48      54      56      56      56      63
67      67      74      74      90      94      96      97      123     185
223     235     239     245     265     321     345     345     345     354
453     523     564     644     677     678     987     987     3232
Sort_Choose:
11      22      22      25      25      26      33      34      34      36
36      39      45      46      48      54      56      56      56      63
67      67      74      74      90      94      96      97      123     185
223     235     239     245     265     321     345     345     345     354
453     523     564     644     677     678     987     987     3232
Sort_Quick:
11      22      22      25      25      26      33      34      34      36
36      39      45      46      48      54      56      56      56      63
67      67      74      74      90      94      96      97      123     185
223     235     239     245     265     321     345     345     345     354
453     523     564     644     677     678     987     987     3232
Sort_Insert:
11      22      22      25      25      26      33      34      34      36
36      39      45      46      48      54      56      56      56      63
67      67      74      74      90      94      96      97      123     185
223     235     239     245     265     321     345     345     345     354
453     523     564     644     677     678     987     987     3232
Sort_shell:
11      22      22      25      25      26      33      34      34      36
36      39      45      46      48      54      56      56      56      63
67      67      74      74      90      94      96      97      123     185
223     235     239     245     265     321     345     345     345     354
453     523     564     644     677     678     987     987     3232