排序算法介绍及稳定性

稳定性的定义

假定在待排序的记录序列中，存在多个具有相同的关键字的记录，若经过排序，这些记录的相对次序保持不变，即在原序列中，ri=rj，且ri在rj之前，而在排序后的序列中，ri仍在rj之前，则称这种排序算法是稳定的；否则称为不稳定的。

1.选择排序

选择排序是给每个位置选择当前元素最小的，比如给第一个位置选择最小的，在剩余元素里面给第二个元素选择第二小的，依次类推，直到第n - 1个元素，第n个元素不用选择了，因为只剩下它一个最大的元素了。

void selectionsort(vectorarr,int size)
{
    int i,j,min;
    i=0;
    j=0;
    min=0;
    for(i=0;i

2.堆排序

void percdown(vectora,int i,int n)
{
    int child;//孩子节点
    int parent;
    int tmp=a[i];//临时变量
    for(parent=i;parent*2+1a,int n)
{
    int i;
    //初始化堆
    for(i=n/2;i>=0;i--)
    {
        percdown(a,i,n);
    }
    //排序
    for(i=n-1;i>0;i--)
    {
        swap(a[0],a[i]);
        percdown(a,0,i);
    }

3.插入排序

插入排序是在一个已经有序的小序列的基础上，一次插入一个元素。

//插入排序
void insertionsort(vectorarr,int size)
{
    int i,j,tmp;
    for(i=1;i0&&arr[j-1]>tmp;j--)
            arr[j]=arr[j-1];//挪位置
        arr[j]=tmp;
    }
}

4.希尔排序

希尔排序就是插入排序的进阶。每次选择一个步长进行插入排序

void shellsort(vectorarr,int size)
{
    int i,j,gap,tmp;
    for(gap=size/2;gap>0;gap/=2)
    {
        for(i=gap;i0&&arr[j-gap]>tmp;j-=gap)
                arr[j]=arr[j-gap];
            arr[j]=tmp;
        }
    }
}

5.冒泡排序

冒泡排序就是把小的元素往前调或者把大的元素往后调。比较是相邻的两个元素比较，交换也发生在这两个元素之间。

void bubblesort(vectorarr,int size)
{
    int i,j;
    for(i=0;iarr[j+1])
                swap(arr[j],arr[j+1]);
        }
    }
}

6.快速排序

//三路快排
int median3(vectorarr,int left,int right)
{
    int center=(right+left)/2;
    if(arr[left]>arr[center])
        swap(arr[left],arr[center]);
    if(arr[left]>arr[right])
        swap(arr[left],arr[right);
    if(arr[center]>arr[right])
        swap(arr[center],arr[right]);
    swap(arr[center],arr[right-1]);
    return arr[right-1];
}

void quicksort(vectorarr,int left,int right)
{
    int center=median3(arr,left,right);
    int i=left;
    int j=right;
    while(i!=j){
        while(arr[i]arr[center] && i

8.归并排序

//归并排序
void merge(vector&arr,int left,int mid,int right)
{
    vector res;
    int len=right-left+1;
    int i=left;
    int j=mid+1;
    int index=0;
    while(i<=mid && j<=right)
    {
        res[index++] =(arr[i]<=arr[j])? arr[i++] : arr[j++];
    }
    while(i<=mid)
        res[index++]=arr[i++];
    while(j<=right)
        res[index++]=arr[j++];
    for(int k=0;k&arr,int len)
{
    if(left == right)
        return ;
    int mid=(left+right)/2;
    merge(arr,left,mid);
    merge(arr,mid+1,right);
    merge(arr,left,mid,right);

}

稳定性的意义
如果只是简单的进行数字的排序，那么稳定性将毫无意义。
如果排序的内容仅仅是一个复杂对象的某一个数字属性，那么稳定性依旧将毫无意义
如果要排序的内容是一个复杂对象的多个数字属性，但是其原本的初始顺序毫无意义，那么稳定性依旧将毫无意义。
除非要排序的内容是一个复杂对象的多个数字属性，且其原本的初始顺序存在意义，那么我们需要在二次排序的基础上保持原有排序的意义，才需要使用到稳定性的算法，例如要排序的内容是一组原本按照价格高低排序的对象，如今需要按照销量高低排序，使用稳定性算法，可以使得想同销量的对象依旧保持着价格高低的排序展现，只有销量不同的才会重新排序。（当然，如果需求不需要保持初始的排序意义，那么使用稳定性算法依旧将毫无意义）。