排序算法

最近忙着复习找工作，熟悉了下排序算法，动手写了一下，发现有些问题的边界条件还是没有考虑清楚，不过好在调试成功。

不稳定排序：堆排序，快速排序，希尔排序；稳定排序：插入排序，冒泡排序，选择排序，归并排序，基数排序等。

插入排序算法代码：

void InsertSort(int A[],int n)

{

    for(int i=1;i<n;i++)

    {

        int key=A[i];

        int j=i-1;

        while(j>=0 && A[j]>key)

        {

            A[j+1]=A[j];

            j--;

        }

        A[j+1]=key;

    }

}

冒泡排序代码：

void BubbleSort(int data[],int n)

{

    int flag=0;

    for(int i=0;i<n;i++)

    {

        flag=0;

        for(int j=n-1;j>i;j--)

        {

            if(data[j]<data[j-1])

            {

                swap(data[j],data[j-1]);

                flag=1;

            }

        }

        if(flag==0)

            break;

    }

下面是堆排序代码：

#include <iostream>



using namespace std;

//堆筛选函数

//已知H[start~end]中除了start之外均满足堆的定义

//本函数进行调整，使H[start~end]成为一个大顶堆

void HeapAdjust(int H[], int start, int end)

{

    int temp = H[start];

    for(int i = 2*start + 1; i<=end; i*=2)

    {

        //因为假设根结点的序号为0而不是1，所以i结点左孩子和右孩子分别为2i+1和2i+2

        if(i<end && H[i]<H[i+1])//左右孩子的比较

        {

            ++i;//i为较大的记录的下标

        }



        if(temp > H[i])//左右孩子中获胜者与父亲的比较

        {

            break;

        }

        //将孩子结点上位，则以孩子结点的位置进行下一轮的筛选

        H[start]= H[i];

        start = i;

    }

    H[start]= temp; //插入最开始不和谐的元素

}

void HeapSort(int A[], int n)

{

    //先建立大顶堆

    for(int i=n/2; i>=0; --i)

    {

        HeapAdjust(A,i,n-1);

    }

    //进行排序

    for(int i=n-1; i>0; --i)

    {

        //最后一个元素和第一元素进行交换

        swap(A[0],A[i]);

        //然后将剩下的无序元素继续调整为大顶堆

        HeapAdjust(A,0,i-1);

    }

}

int main()

{

    int A[]={4,1,3,2,16,9,10,14,8,7};

    HeapSort(A,10);

    for(int i=0;i<10;i++)

        cout << A[i] << " ";

    return 0;

}

快速排序：

int RandomInRange(int start,int end)

{

    int random=rand()%(end-start+1)+start;

    return random;

}

int Partition(int data[],int length,int start,int end)

{

    if(data==NULL||length<=0||start<0||end>=length)

    {

        cout << "Invaild Parameters" << endl;

        return -1;

    }

    int index=RandomInRange(start,end);

    swap(data[index],data[end]);

    int small=start-1;

    for(index=start;index<=end;index++)

    {

        if(data[index]<data[end])

        {

            ++small;

            if(small!=index)

                swap(data[index],data[small]);

        }

    }

    ++small;

    swap(data[small],data[end]);

    return small;

}

void QuickSort(int data[],int length,int start,int end)

{

    if(start==end)

        return;

    int index=Partition(data,length,start,end);

    if(index>start)

        QuickSort(data,length,start,index-1);

    if(index<end)

        QuickSort(data,length,index+1,end);

}

归并排序代码：

void mergeArray(int a[],int first,int mid,int last,int temp[])

{

    int i=first,j=mid+1;

    int m=mid,n=last;

    int k=0;

    while(i<=m&&j<=n)

    {

        if(a[i]<a[j])

        {

            temp[k++]=a[i++];

        }

        else

            temp[k++]=a[j++];

    }

    while(i<=m)

        temp[k++]=a[i++];

    while(j<=n)

        temp[k++]=a[j++];

    for(int i=0;i<k;i++)

        a[first+i]=temp[i];

}

void mergesort(int a[],int first,int last,int temp[])

{

    if(first<last)

    {

        int mid=(last+first)/2;

        mergesort(a,first,mid,temp);

        mergesort(a,mid+1,last,temp);

        mergeArray(a,first,mid,last,temp);

    }

}

选择排序：

void SelectSort(int data[],int n)

{

    for(int i=0;i<n-1;i++)

    {

        int index=i;

        for(int j=i+1;j<n;j++)

        {

            if(data[j]<data[index])

                index=j;

        }

        if(index!=i)

            swap(data[index],data[i]);

    }

}

希尔排序：

void ShellInsert(int data[],int d,int n)

{

    for(int i=d;i<n;i++)

    {

        int j=i-d;

        int temp=data[i];

        while(j>=0 && data[j]>temp)

        {

            data[j+d]=data[j];

            j-=d;

        }

        if(j!=i-d)

            data[j+d]=temp;

    }

}

void ShellSort(int data[],int n)

{

    int d=n/2;

    while(d>=1)

    {

        ShellInsert(data,d,n);

        d/=2;

    }

}

基数排序：

#define RADIX 10

#define KEYNUM 10   //关键字位数

int GetDigit(int num,int pos)

{

    int temp=1;

    for(int i=0;i<pos-1;i++)

        temp *= 10;

    return (num/temp)%10;

}

void RadixSort(int data[],int n)

{

    int *Radix[10];

    for(int i=0;i<10;i++)

    {

        Radix[i]=(int *)malloc(sizeof(int) * (n + 1));

        Radix[i][0]=0;

    }

    for(int pos=1;pos<=KEYNUM;pos++)

    {

        for(int i=0;i<n;i++)

        {

            int digit=GetDigit(data[i],pos);

            int index=++Radix[digit][0];

            Radix[digit][index]=data[i];

        }

        for(int i=0,j=0;i<10;i++)

        {

            for(int k=1;k<=Radix[i][0];k++)

            {

                data[j++]=Radix[i][k];

            }

            Radix[i][0]=0;

        }

    }

}