关于排序

插入排序(Insertion Sort)

有一个已经有序的数据序列，要求在这个已经排好的数据序列中插入一个数，但要求插入后此数据序列仍然有序，这个时候就要用到插入排序法

void InsertionSort(int A[],int N)
{
    int j,p;
    int temp;
    for(p=1;p<N;p++)
    {
        temp=A[p];
        for(j=p;j>0&&A[j-1]>temp;j--)
        {
            A[j]=A[j-1];
        }
        A[j]=temp;
    }
 } 

例子：

初始	34	8	64	51	32	21	移动的位置
在p=1之后	8	34	64	51	32	21	1
在p=2之后	8	34	64	51	32	21	0
在p=3之后	8	34	51	64	32	21	1
在p=4之后	8	32	34	51	64	21	3
在p=5之后	8	21	32	34	51	64	4

冒泡排序(Bubble sort)

它重复地走访过要排序的数列，一次比较两个元素，如果他们的顺序错误就把他们交换过来。走访数列的工作是重复地进行直到没有再需要交换，也就是说该数列已经排序完成。

void Bubblesort(int a[],N)
{
    int i,j=0;
    int temp=0;
    for(i=1;i<N;i++)
    {
        for(j=0;j<N-i;j++)
        {
            if(a[j]>a[j+1])
            {
                temp=a[j];
                a[j]=a[j+1];
                a[j+1]=temp;
            }
        }
    }   
} 

例子：

初始	34	8	64	51	32	21
在i=1之后	8	34	51	32	21	64
在i=2之后	8	34	32	21	51	64
在i=3之后	8	32	21	34	51	64
在i=4之后	8	21	32	34	51	64
在i=5之后	8	21	32	34	51	64

快速排序(Quicksort)

它的基本思想是：通过一趟排序将要排序的数据分割成独立的两部分，其中一部分的所有数据都比另外一部分的所有数据都要小，然后再按此方法对这两部分数据分别进行快速排序，整个排序过程可以递归进行，以此达到整个数据变成有序序列。

方法①:利用C语言编译器函数库自带的快速排序函数。

#include<stdio.h>
#include<stdlib.h>
#define N 6//本例数组长度暂定为6 
int compare(const void*a,const void*b)//指定排序顺序 
{
    return *(int*)a-*(int*)b;//由小到大排序
    //return *(int*)b-*(int*)a //由大到小排序 
}
int main()
{
    int A[N]={34,8,64,51,32,21};
    qsort(A,N,sizeof(int),compare);
    //A表示带排序数组首地址
    //N表示待排序元素数量
    //sizeof(int)表示各元素的占用大小
    //compare指向函数的指针,用于确定排序的顺序 
    return 0;
} 

方法②:自己编写函数

//此函数参考《啊哈！算法》中的快速排序程序
int A[6]={34,8,64,51,32,21};//定义全局变量，需在子函数中使用 
void quicksort(int left,int right)
{
    int i,j=0;
    int temp1,temp2=0;
    if(left>right)
        return;
    temp1=A[left];//使用temp1存储基准数 
    i=left;
    j=right;
    while(i!=j)
    {
        while(A[j]>=temp1&&i<j)//顺序很重要，要先从右往左找 
        {
            j--;
        }
        while(A[i]<=temp1&&i<j)//再从左往右找 
        {
            i++;
        }
        if(i<j)
        {
            temp2=A[i];
            A[i]=A[j];
            A[j]=temp2;
        }
    }
    A[left]=A[i];
    A[i]=temp1;
    quicksort(left,i-1);//继续处理左边的，这是一个递归 
    quicksort(i+1,right);//继续处理右边的，这是一个递归 
}

第一次:
temp1=A[0]=34 ; left=0 ,right=5 ;

position	A[0]	A[1]	A[2]	A[3]	A[4]	A[5]
初始	34	8	64	51	32	21
round1	34	8	21	51	32	64
round2	34	8	21	32	51	64
round3	32	8	21	34	51	64

第二次左边:quicksort(0,2)
第二次右边:quick(4,5)

第二次左边:
temp1=A[0]=32; left=0 ,right =2

position	A[0]	A[1]	A[2]
初始	32	8	21
round1	21	8	32

第三次左边:quicksort(0,1)
第三次右边:quicksort(3,2)

第三次左边:
temp1=A[0]=21; left=0 ,right =1

position	A[0]	A[1]
初始	21	8
round1	8	21

第三次右边:return;

第二次右边:
temp1=A[4]=51 ; left=4 ,right=5 ;

position	A[4]	A[5]
初始	51	64
round1	51	64

第三次左边:quicksort(4,3)
第三次右边:quicksort(5,5)

第三次左边:return;

第三次右边:return;

End