常见各种排序算法（C语言实现）

1、冒泡排序：每次把循环过程中最大的数放到最后，循环次数每次减一。

void BubbleSort(int a[],int length)
{
    int i,temp,num;
    for(num=length-1;num>0;num--)
    {
        for(i=0;i<num;i++)
        {
            if(a[i]>a[i+1])
            {
                temp=a[i];
                a[i]=a[i+1];
                a[i+1]=temp;
            }
        }
    }
}

2、选择排序：每次选择循环过程中最小的数放在最前面。

void ChooseSort(int a[],int length)
{
    int i,j,minNum,temp;
    for(j=0;j<length-1;j++)
    {
        minNum=j;
        for(i=j+1;i<length;i++)
        {
            if(a[minNum]>a[i])
            minNum=i;
        }
        if(minNum!=j)
        {
            temp=a[minNum];
            a[minNum]=a[j];
            a[j]=temp;
        }
    }
}

3、插入排序：前面的数已有序，后面的数不断插入，插入过程会伴随着数据位置的移动。

void InsertSort(int a[],int length)
{
    int i,j,s;
    for(j=0;j<length-1;j++)
    {
        s=a[j+1];
        for(i=j;i>=0;i--)
        {
            if(s>=a[i])
            break;
            else a[i+1]=a[i];
        }
        a[i+1]=s;
    }
}

 4、希尔排序：插入排序的一种优化，间隔依次从length/2到1，原理与插入排序一样。

void ShellSort(int a[],int length)
{
    int i,j,g,s;
    g=length/2;
    while(g>=1)
    {
        for(i=g;i<length;i++)
        {
            s=a[i];
            for(j=i-g;j>=0;j-=g)
            {
                if(s>=a[j])
                break;
                else
                a[j+g]=a[j];
            }
            a[j+g]=s;
        }
        g/=2;
    }
}

 5、递归排序：

#include <stdio.h>
#include <stdlib.h>
//函数的参数除了指针和数组，只能用它的值，不能随便改变，要新定义一个变量代替。
//递归就是要做3，就得做2，要做2就得做1，做1结束，再做完2，再做完3。
int main()
{
    void Merge(int a[],int first,int last);
    int a[8]={12,6,3,7,9,4,2,1};
    int i=0;
    Merge(a,0,7);
    for(i=0;i<8;i++)
    printf("%3d",a[i]);
    return 0;
}
void Merge(int a[],int first,int last)
{
    void MergeSort(int a[],int first,int mid,int last);
    if(first>=last)
    return;
    int mid=(first+last)/2;
    Merge(a,first,mid);
    Merge(a,mid+1,last);
    MergeSort(a,first,mid,last);
}
void MergeSort(int a[],int first,int mid,int last)
{
    int begin1=first,begin2=mid+1;
    int end1=mid,end2=last;
    int length=last-first+1;
    int b[length];
    int i=0;
    while(begin1<=end1 && begin2<=end2)
    {
        if(a[begin1]>a[begin2])
        b[i++]=a[begin2++];
        else b[i++]=a[begin1++];
    }
    while(begin2<=end2)
    {
        b[i++]=a[begin2++];
    }
    while(begin1<=end1)
    {
        b[i++]=a[begin1++];
    }
    for(i=0;i<length;i++)
    {
        a[first+i]=b[i];
    }
}

6、堆排序：

void heapadjust(int n[],int i,int length)
{
    while(2*i+1<length)
    {   int temp=n[i];
        int a=2*i+1;
        if((a+1)<length && n[a]>n[a+1])
        a++;
        if(n[i]>n[a])
        n[i]=n[a];
        else break;
        n[a]=temp;
        i=a;
    }
}

void swap(int *a,int *b)
{
    int temp;
    temp=*a;
    *a=*b;
    *b=temp;
}

void heapbuild(int n[],int length)
{
    int i;
    for(i=(length/2)-1;i>=0;i--)
    {
        heapadjust(n,i,length);
    }
    for(i=length-1;i>0;i--)
    {
        swap(&n[i],&n[0]);
        heapadjust(n,0,i);
    }
}

7、有标志位的冒泡排序：

void NewBubbleSort(int a[],int n)
{
    int i=0,j=0,flag=1;
    for(i=0;i<n-1;i++)
    {
        flag=1;
        for(j=0;j<n-i-1;j++)
        {
            if(a[j]>a[j+1])
            {
                swap(&a[j],&a[j+1]);
                flag=0;
            }
        }
        if(flag)
        break;
    }
}

8、c++堆排序（最大堆、最小堆）：

void heapadjust(int n[],int i,int length)
{
    while(2*i+1<length)
    {   int temp=n[i];
        int a=2*i+1;
        if((a+1)<length && n[a]>n[a+1])
        a++;
        if(n[i]>n[a])
        n[i]=n[a];
        else break;
        n[a]=temp;
        i=a;
    }
}

void swap(int *a,int *b)
{
    int temp;
    temp=*a;
    *a=*b;
    *b=temp;
}
void ShiftUp(int a[],int i,int n)
{
    int j=0,p=0;
    while(i>0)
    {
        j=((i&1)==0?i-1:i+1);
        p=(i-1)>>1;
        if(j<n && a[j]<a[i]) i=j;
        if(a[i]<a[p]) swap(&a[i],&a[p]);
        i=p;
    }
}
void heapbuild(int n[],int length)
{
    int c,i=0;
    cout<<"最小堆选1，最大堆选2：";
    cin>>c;
    switch(c)
    {
        case 2:
        for(i=(length/2)-1;i>=0;i--)
        {
            heapadjust(n,i,length);
        }
        for(i=length-1;i>0;i--)
        {
            swap(&n[i],&n[0]);
            heapadjust(n,0,i);
        }
        break;
        case 1:
        for(i=length-1;i>(length/2)-1;i--)
        {
            ShiftUp(n,i,length);
        }
        for(i=length-1;i>0;i--)
        {
            swap(&n[0],&n[i]);
            ShiftUp(n,i-1,i);
        }
        break;
        default: break;
    }
}

哈哈，未完待续……