八大排序算法

(一)选择排序法

原理:将序列划分为无序和有序区，寻找无序区中的最小值和无序区的首元素交换，有序区扩大一个，循环最终完成全部排序

void SortList::SelectSort(int *list,int length)
{
    int i,j,min; //i为有序区,j为无序区,min为无序区最小元素下标
    for(i=0;i<length-1;i++)
    {
        min = i;
        for(j=i;j<length;j++)
        {
            if(list[j]<list[min])
                min = j;
        }
        int t = list[i];
        list[i] = list[min];
        list[min] = t;
    }
}

(二)冒泡排序法

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

void SortList::BubbleSort(int *list,int length)
{
    int i ,j;
    for(i=0;i<length-1;i++)
    {
        for(j=0;j<length-i-1;j++)
        {
            if(list[j]>list[j+1])
            {
                int t = list[j+1];
                list[j+1]=list[j];
                list[j]=t;
            }
        }
    }
}

(三)插入排序法

原理:每一步都将一个待排数据按其大小插入到已经排序的数据中的适当位置,直到全部插入完毕。

void SortList::InsertSort(int *list,int length)
{
    int j,i;//分别为有序区和无序区

    for(i=1;i<length;i++)
    {
        j=i-1;
        if(list[i]<list[j])
        {
            int temp = list[i];
            while(j>=0&&list[j]>temp)
            {
                list[j+1] = list[j];
                j--;
            }
            list[j+1] = temp;
        }
    }
}

(四)快速排序法

原理:快速排序的分区过程，将比这个数大的数全放到它的右边，小于或等于它的数全放到它的左边。然后再对这个数左右两段递归进行，以此达到整个数据变成有序序列

void SortList::QuickSort(int *list,int left,int right)
{
    if(left<right)
    {
        int i = AdjustArray(list,left,right);
        QuickSort(list,left,i-1);
        QuickSort(list,i+1,right);
    }
}


//快速排序的分区过程，将比这个数大的数全放到它的右边，小于或等于它的数全放到它的左边。
int SortList::AdjustArray(int *list,int left,int right)
{
    int base = list[left];
    while(left<right)
    {
        while(list[right]>base)
            right--;
        if(left<right)
        {
            list[left]=list[right];
            left++;
        }

        while(list[left]<base)
            left++;
        if(left<right)
        {
            list[right]=list[left];
            right--;
        }
    }
        list[left] = base;
        return left;
}

(五)希尔排序法

原理:先取一个小于n的整数d1作为第一个增量，把文件的全部记录分成d1个组。所有距离为dl的倍数的记录放在同一个组中。先在各组内进行直接插人
排序；然后，取第二个增量d2<d1重复上述的分组和排序，直至所取的增量dt=1(dt<dt-l<…<d2<d1)，即所有记录放在同一组中进行直接插入排序为止

void SortList::ShellSort(int *list,int length)
{
    int d,n,i,j;  //
    d = length/2;
    while(d>=1)
    {
        for(n=0;n<d;n++)
        {
            for(i=n+d;i<length;i=i+d)
            {
                int temp ;
                j = i-d;
                if(list[j]>list[i])
                {
                    temp = list[i];
                    while(list[j]>temp&&j>=0)
                    {
                        list[j+d]=list[j];
                        j-=d;
                    }
                    list[j+d] = temp;
                }
            }
        }
        d=d/2;
    }
}

(六)堆排序法

原理:利用大根堆或小根堆思想，首先建立堆，然后将堆首与堆尾交换，堆尾之后为有序区

//堆排序,堆是完全二叉树,设父节点下标为i,则其左子节点下标为i*2+1,右子节点下标为i*2+2
void SortList::HeapSort(int *list,int length)
{
    //建堆,从最后一个根节点开始建堆,最后一个根节点下标为length/2-1
    for(int i=length/2-1;i>=0;i--)
    {
        HeapAdjust(list,i,length);
    }

    for(int i=length-1;i>0;i--)
    {
        //先交换再重排
        int temp = list[i];
        list[i] = list[0];
        list[0] = temp;

        HeapAdjust(list,0,i);        
    }
}

//调整堆(大顶堆)
void SortList::HeapAdjust(int *list,int i,int length)
{
    int left = i*2+1;
    int right = i*2+2;
    int maxindex = i;

    if(left<length&&list[left]>list[maxindex])
    {
        maxindex = left;
    }
    if(right<length&&list[right]>list[maxindex])
    {
        maxindex = right;
    }

    if(maxindex!=i)
    {
        int temp = list[i];
        list[i] = list[maxindex];
        list[maxindex] = temp;
        HeapAdjust(list,maxindex,length);
    }
}