常见排序算法整理

经常忘记简单的排序算法，有时间整理下来，便于随时翻阅，也为了随用随取

插入排序算法：
取第一个数作为有序队列，从后面的无序队列中依次取值，在有序队列中从后向前比较大小，插入到有序队列中。

void InsertSort(int unsort[],int n)
{
    for(int i=1;i<n;i++)
    {
        if(unsort[i-1]>unsort[i])
        {
            int temp=unsort[i];
            int j=i;
            while(j>0&&unsort[j-1]>temp)
            {
                unsort[j]=unsort[j-1];
                j--;
            }
            unsort[j]=temp;
        }
    }
}

选择排序算法：
与插入排序有点类似，但是选择排序是从无序队列中直接选择最小的数，插入有序队列的末尾。

void SelectSort(int unsort[],int n)
{
    for(int i=0;i<n;i++)
    {
        int mini=unsort[i],mini_index=i;
        for(int j=i;j<n;j++)
        {
            if(unsort[j]<mini)
            {
                mini=unsort[j];
                mini_index=j;
            }
        }
        if(mini_index!=i)
        {
            int temp=unsort[i];
            unsort[i]=unsort[mini_index];
            unsort[mini_index]=temp;
        }
    }
}

冒泡排序算法：
最简单的排序算法。相邻的两个数比较大小，小在前大在后，一直进行下去。

void BubbleSort(int unsort[],int n)
{
    int i,j;
    for(i=0;i<n-1;i++)
    {
        for(j=0;j<n-i-1;j++)
        {
            int temp;
            if(unsort[j]>unsort[j+1])
            {
                temp=unsort[j];
                unsort[j]=unsort[j+1];
                unsort[j+1]=temp;
            }
        }
    }
}

希尔排序算法：
改进的插入算法。

void ShellSort(int unsort[],int n)
{
    for (int group=n/2;group>0;group /= 2)
    {
        for (int i=group;i<n;i++)
        {
            for (int j=i-group;j>=0; j -= group)
            {
                if (unsort[j]>unsort[j+group])
                {
                    int temp=unsort[j];
                    unsort[j]=unsort[j+group];
                    unsort[j+group]=temp;
                }
            }
        }
    }
}

快速排序算法：
设置基数和两个哨兵，哨兵分别从左右同时相向前进，当左边的比基数大右边比基数小时交换。

void QuickSort(int unsort[],int left,int right)
{
    if(left<right)
    {
        int key=unsort[left];
        int low=left;
        int high=right;
        while(low<high)
        {
            while(low<high&&unsort[high]>key)
                high--;
            unsort[low]=unsort[high];
            while(low<high && unsort[low]<key)
                low++;
            unsort[high]=unsort[low];
        }
        unsort[low]=key;
        QuickSort(unsort,left,low-1);
        QuickSort(unsort,low+1,right);
    }
}