排序算法

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

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

插入排序算法代码：

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;
        }
    }
}