排序算法的稳定性总结

最新推荐文章于 2022-03-17 19:18:28 发布

原创最新推荐文章于 2022-03-17 19:18:28 发布 · 564 阅读

0 ·

CC 4.0 BY-SA版权

编程综合专栏收录该内容

23 篇文章

订阅专栏

1.首先我们来看看插入排序，从第2个元素开始，把每个元素依次插入前面有序的序列中。
因为只有小于前面的元素时，才进行插入和移动操作，所以不会改变相同元素的相对顺序。
所以该算法是稳定，但是如果把a[j]>a[i]改为a[j]>=a[i]那就是不稳定的了。

//直接插入排序
void InsertSort(int a[],int n){
    for(int i=1;i<n;i++){
        int t=a[i],j;
        for(j=i-1;j>=0&&a[j]>t;j--){
            a[j+1]=a[j];
        }
        a[j+1]=t;
       // print(a,n,i);
    }
}

排序过程测试：
这里写图片描述

2.希尔排序：
希尔排序是对直接插入排序的一个优化吧，
它是分段进行插入排序。

//希尔排序
void shellSort(int a[],int n){
    int dk=n/2;
    while(dk>=1){
        for(int i=dk;i<n;i++){
            int t=a[i],j;
            for(j=i-dk;j>=0&&a[j]>t;j-=dk){
                a[j+dk]=a[j];
            }
            a[j+dk]=t;
            print(a,n,i);
        }
        dk/=2;
    }
}

这里写图片描述

首先，插入排序是稳定的，但是希尔排序会在不同的长度dk直接多次进行插入排序，比如3,3,2,1
第一遍插入排序的时候就会交换第1个和第3个元素，变成2,3,3,1，两个3的相对顺序就改变了。
所以它是不稳定的。

3.选择排序：
每次选择最小的元素与有序的序列的第一个元素进行交换。

//选择排序
void selectSort(int a[],int n){
    for(int i=0;i<n-1;i++){
        int minn=INT_MAX,t;
        for(int j=i;j<n;j++){
            if(a[j]<minn){
                minn=a[j];t=j;
            }
        }
        swap(a[i],a[t]);
       // print(a,n,i);
    }
}

选择排序它是不稳定的，比如3,4,3,2,5,第一遍会选择最小的2与第一个元素进行交换，
交换后是2,4,3,3,5，两个数值相同的3的相对顺利就改变了。

4.快速排序

//快速排序
int Partition(int a[],int l,int r){
    int pivot=a[r];
    int i=l;
    for(int j=l;j<r;j++){
        if(a[j]<a[r]){
           swap(a[i++],a[j]);
        }
    }
    swap(a[i],a[r]);
    return i;
}

void quickSort(int a[],int l,int r){
    if(l<r){
        int t=Partition(a,l,r);
        quickSort(a,l,t-1);
        quickSort(a,t+1,r);
        print(a,8,t);
    }
}

快速排序也是不稳定的，因为在进行划分的时候其实是用了选择排序算法的一些思想，
每次选择数组最小的元素进行交换，这样就会改变相同元素的相对顺序了。

5.堆排序
关于堆排序的具体算法思想，网上很多，我就不再啰嗦了。

//堆排序
void HeapAdjust(int a[],int s,int n){
    int l=2*s+1;
    while(l<n){
        if(l+1<n&&a[l]<a[l+1]){//找到较大的子结点
            l++;
        }
        if(a[s]<a[l]){//如果较大的子结点大于父节点
            swap(a[s],a[l]);
            s=l;
            l=2*s+1;
        }else{
            break;
        }
    }
}

void BuildHeap(int a[],int n){//创建大根堆
    for(int i=(n-1)/2;i>=0;i--){
        HeapAdjust(a,i,n);
    }
}
void HeapSort(int a[],int n){
    BuildHeap(a,n);
    for(int i=n-1;i>=0;i--){
        swap(a[i],a[0]);
        HeapAdjust(a,0,i);
    }
}