七种排序算法

最新推荐文章于 2022-11-21 11:23:07 发布

Yukle

最新推荐文章于 2022-11-21 11:23:07 发布

阅读量132

点赞数

文章标签：数据结构算法

本文链接：https://blog.csdn.net/qq_44758862/article/details/109334165

版权

1.排序的相关概念

平时的上下文中，如果提到排序，通常指的是排升序（非降序）
两个相等的数据，如果经过排序后，排序算法能保证其相对位置不发生变化，则我们称该算法是具备稳定性的排序算法。(稳定性)

2.算法的实现

常见的排序算法

在这里插入图片描述

2.1插入排序(直接插入排序)

实现思想：
整个区间被分为

有序区间
无序区间
每次选择无序区间的第一个元素，在有序区间内选择合适的位置插入

代码：

public static void insertSort(long[]array){
      // n个数进行排序时外层的排序次数是n-1次。
        for(int i=0;i<array.length-1;i++){
            long key=array[i+1];
            int j=0;
             //第一次循环是现将0号下标位置看做有序
            for( j=i;j>=0;j--){
                if(array[j]>key){
                    array[j+1]=array[j];
                }else{
                    break;
                }
            }
            array[j+1]=key;
        }
    }

时间复杂度

最好情况	最坏情况	平均情况
O(n)	O(n²)	O(n²)
有序数组	逆序数组

空间复杂度：O(1)
稳定性：稳定

2.2选择排序

实现原理：每一次从无序区间选出最大的一个元素，存放在无序区间的最后，直到全部待排序的数据元素排完。

private static void swap(long []array,int i,int j){
        long t=array[i];
        array[i]=array[j];
        array[j]=t;
    }
public static void selectSort(long []array){
        for(int i=0;i<array.length-1;i++){
            int maxIndex=0;
            int j=1;
            for(;j<array.length-i;j++){
                if(array[maxIndex]<array[j]){
                    maxIndex=j;
                }
            }
            swap(array,maxIndex,j-1);
        }
    }

时间复杂度

最好情况	最坏情况	平均情况
O(n²	O(n²)	O(n²)

空间复杂度：O(1)
稳定性：不稳定

2.3冒泡排序

public static void bulSort(long[]array){
        for(int i=0;i<array.length-1;i++){
            boolean isSorted=true;
            for(int j=0;j<array.length-1-i;j++){
                if(array[j]>array[j+1]){
                    isSorted=false;
                    swap(array,j,j+1);
                }
            }
            if(isSorted){
                break;
            }
        }
    }

时间复杂度

最好情况	最坏情况	平均情况
O(n)	O(n²)	O(n²)
有序数组	逆序数组

空间复杂度：O(1)
稳定性：不稳定

2.4堆排序

实现原理：采用建堆操作(建大堆)，这样就能将最大的数放到数组的0号下标处，再将0号下标与最后一个元素进行交换，之后再进行向下调整操作，依次循环

 public static void heapSort(long[]array){
        //建堆
        createHeap(array);
        for(int i=0;i<array.length-1;i++){
            swap(array,array.length-1-i,0);
            adjustDown(array,array.length-i-1,0);
        }
    }

    private static void createHeap(long[] array) {
        int size=array.length;
        int parentIndex=(size-2)/2;
        for(int i=parentIndex;i>=0;i--){
            adjustDown(array,size,i);
        }
    }

    private static void adjustDown(long[] array, int size, int index) {
        while(index*2+1<size){
            int maxIndex=index*2+1;
            if(maxIndex+1<size&&array[maxIndex]<array[maxIndex+1]){
                maxIndex++;
            }
            if(array[index]>=array[maxIndex]){
                break;
            }
            swap(array,index,maxIndex);
            index=maxIndex;
        }
    }

性能分析

时间复杂度	空间复杂度
O(n*log(n)）	O(1))

稳定性：不稳定

2.5快速排序

实现原理

从待排序区间选择一个数，作为基准值(pivot)；
Partition: 遍历整个待排序区间，将比基准值小的（可以包含相等的）放到基准值的左边，将比基准值大的（可以包含相等的）放到基准值的右边；
采用分治思想，对左右两个小区间按照同样的方式处理，直到小区间的长度 == 1，代表已经有序，或者小区间的长度 == 0，代表没有数据。

 public static void quickSort(long[]array){
        quickSortInternal(array,0,array.length-1);
    }

    private static void quickSortInternal(long[] array, int lowIndex, int heightIndex) {
        int size=heightIndex-lowIndex+1;
        if(size<=1){
            return;
        }
        int index=partition(array,lowIndex,heightIndex);
        //index左边的数都小于等于array[index] ,右边的数都大于等于array[index]
        quickSortInternal(array,lowIndex,index-1);
        quickSortInternal(array,index+1,heightIndex);
    }
    private static int partition(long[] array, int lowIndex, int heightIndex) {
        long key=array[lowIndex];
        while(lowIndex<heightIndex){
            //这里两个while循环中至少出现一个=号（>=或<=）不然在lowIndex,heightIndex对应两个相同的数时就会死循环
            while(lowIndex<heightIndex&&array[heightIndex]>=key){
                heightIndex--;
            }
            array[lowIndex]=array[heightIndex];
            while(lowIndex<heightIndex&&array[lowIndex]<=key){
                lowIndex++;
            }
            array[heightIndex]=array[lowIndex];
        }
        array[lowIndex]=key;
        return lowIndex;
    }

时间复杂度

最好情况	最坏情况	平均情况
O(n*log(n)）	O(n²)	O(n*log(n)）

空间复杂度：

最好情况	最坏情况	平均情况
O(log(n))）	O(log(n))	O(n)）

稳定性：不稳定
优化：

选择基准值很重要，通常使用几数取中法
partition 过程中把和基准值相等的数也选择出来

2.6归并排序

排序原理：采用分治法，将已有序的子序列合并，得到完全有序的序列；即先使每个子序列有序，再使子序列段间有序。

public static void mergeSort(long[]array){
        mergeSortInternal(array,0,array.length);//半闭半开
    }

    private static void mergeSortInternal(long[] array, int lowIndex, int heightIndex) {
        int size=heightIndex-lowIndex;
        if(size<=1){
            return;
        }
        int midIndex=(heightIndex+lowIndex)/2;
        mergeSortInternal(array,lowIndex,midIndex);
        mergeSortInternal(array,midIndex,heightIndex);
        mergeArray(array,lowIndex,midIndex,heightIndex);

    }

    private static void mergeArray(long[] array, int lowIndex, int midIndex, int heightIndex) {
        int size=heightIndex-lowIndex;
        long[]arrays=new long[size];
        int leftIndex=lowIndex;
        int rightIndex=midIndex;
        int index=0;
        while(leftIndex<midIndex&&rightIndex<heightIndex){
            if(array[leftIndex]<array[midIndex]){
                arrays[index++]=array[leftIndex++];
            }else{
                arrays[index++]=array[rightIndex++];
            }
        }
        if(leftIndex>=midIndex){
            while(rightIndex<heightIndex){
                arrays[index++]=array[rightIndex++];
            }
        }else{
            while(leftIndex<midIndex){
                arrays[index++]=array[leftIndex++];
            }
        }
        for(int i=0;i<size;i++){
            array[i+lowIndex]=arrays[i];
        }
    }

性能分析

时间复杂度	空间复杂度
O(n*log(n)）	O(n)

稳定性：稳定

2.7 希尔排序

实现原理：希尔排序法又称缩小增量法。希尔排序法的基本思想是：先选定一个整数，把待排序文件中所有记录分成个组，所有
距离为的记录分在同一组内，并对每一组内的记录进行排序。然后，取，重复上述分组和排序的工作。当到达=1时，
所有记录在统一组内排好序。

希尔排序是对直接插入排序的优化。
当gap > 1时都是预排序，目的是让数组更接近于有序。当gap == 1时，数组已经接近有序的了，这样就会很
快。这样整体而言，可以达到优化的效果。我们实现后可以进行性能测试的对比。

public static void shellSort(long[]array){
        int gap=array.length-1/2;
        while(true){
            if(gap==1){
                break;
            }
            insertGapSort(array,gap);
            gap/=2;
        }
    }
    private static void insertGapSort(long[] array, int gap) {
        for(int i=gap;i<array.length;i++){
            long key=array[i];
            int j=0;
            for(j=i-gap;j>=0;j=j-gap){
                if(array[j]>key){
                    array[j+gap]=array[j];
                }else{
                    break;
                }
            }
            array[j+gap]=key;
        }
    }

时间复杂度

最好情况	最坏情况	平均情况
O(n)）	O(n^2)	O(n^1.3)
数据有序		比较难构造

空间复杂度:O(1)

Yukle

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
七种排序算法

1.排序的相关概念平时的上下文中，如果提到排序，通常指的是排升序（非降序）两个相等的数据，如果经过排序后，排序算法能保证其相对位置不发生变化，则我们称该算法是具备稳定性的排序算法。(稳定性)2.算法的实现常见的排序算法2.1插入排序(直接插入排序)实现思想：整个区间被分为有序区间无序区间每次选择无序区间的第一个元素，在有序区间内选择合适的位置插入代码：public static void insertSort(long[]array){ // n个数进
复制链接

扫一扫