几种常见的排序以及分析比较

最新推荐文章于 2021-12-13 09:57:26 发布

CHgoing

最新推荐文章于 2021-12-13 09:57:26 发布

阅读量413

点赞数

文章标签：数据结构 java

本文链接：https://blog.csdn.net/CHgoing/article/details/104591469

版权

排序，就是使一串记录，按照其中的某个或某些关键字的大小，递增或递减的排列起来的操作。
平时的上下文中，如果提到排序，通常指的是排升序（非降序）。
通常意义上的排序，都是指的原地排序(in place sort)。

这里简单的介绍几种排序算法：插入排序，希尔排序，选择排序，快速排序，冒泡排序，归并排序，当然还有其它的排序，比如折半插入排序，堆排序等。

1.插入排序：

整个区间被分为有序区间和无序区间，每次从无序区间里面取第一个元素，然后在有序区间里找到合适的位置插入。（有序空间一开始可以看作是空的，既然要排序的话，数据一开始一般是无序的）

public static void insertSort(int[] arr) {
        for(int i = 0; i < arr.length - 1; i++) {
            //i是已经排好序列的最后一个元素
            //key是下一个将要进行排序的元素
            int key = arr[i + 1];
            int end = i;
            while(end >= 0 && arr[end] > key) {
                //把大的元素向后移动
                arr[end + 1] = arr[end];
                end--;
            }
            //插入key元素
            arr[end + 1] = key;
        }
    }

插入排序的性能分析：
时间复杂度：最好O(n)，最坏O(n^2)，平均是O(n^2)。
空间复杂度：O（1）
稳定性：稳定
插入排序，初始数据越接近有序，时间效率越高。

2.希尔排序：

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

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

在这里插入图片描述

public static void shellSort(int[] arr) {
        int gap = arr.length;
        while(gap > 1) {
            gap = gap / 3 + 1;
            for(int i = 0; i < arr.length - gap; i++) {
                int end = i;
                int key = arr[i + gap];
                while(end >= 0 && arr[end] > key) {
                    arr[end + gap] = arr[end];
                    end -= gap;
                }
                arr[end + gap] = key;
            }
        }
    }

插入排序的性能分析：
时间复杂度：最好O(n)，最坏O(n^2)，平均是O(n^1.3)
空间复杂度：O（1）
稳定性：不稳定

3.选择排序

每一次从无序区间选出最大（或最小）的一个元素，存放在无序区间的最后（或最前），直到全部待排序的数据元
素排完。（swap只是一个简单的交换方法）

public static void selectSort2(int[] arr){
    //i: 未排序的最大位置
    for(int i = arr.length - 1; i > 0; --i)
    {
        int end = i;
        int maxIdx = i;
        //从所有未排序的数据中找最大值的索引
        for(int j = end - 1; j >=0; --j){
            if(arr[j] >arr[maxIdx])
                maxIdx = j;
        }
        swap(arr, maxIdx, end);
    }
}

另外一种是双向选择排序，就是每次从无序区间中取出最大和最小的元素，分别插到最大和最小的位置，
直到全部待排序的数据元素排完。

public static void selectSort(int[] arr) {
    int begin = 0;
    int end = arr.length - 1;
    while(begin < end) {
        int min = begin;
        int max = begin;
        for(int i = begin; i <= end; i++) {
            if(arr[i] < arr[min])
                min = i;
            if(arr[i] > arr[max])
                max = i;
        }
        swap(arr,begin,min);
        if(max == begin)
            max = min;
        swap(arr,end,max);
        begin++;
        end--;
    }
}

这里需要注意的是if(max == begin) max = min;
这两行代码，因为begin是无序数列的最开始的元素，当最大的元素在第一个元素是，此时max指向第一个元素，min是当前最小的元素，进行swap交换时，min首先交换到了第一个位置，也就是begin的位置，而此时max的位置已经发生了变化，不在是在begin的位置了，而是与min进行了交换到了之前min的位置了，如果不加这两行代码的话，就会出错，所以需要加一个判断来避免出错。

选择排序的性能分析：
时间复杂度：最好O(n^{2)，最坏O(n}2)，平均是O(n^2)。
空间复杂度：O（1）
稳定性：不稳定

4.堆排序

堆排序的基本原理也是选择排序，只是不在使用遍历的方式查找无序区间的最大的数，而是通过堆来选择无序区间的最大的
数。

注意：这里排升序要建大堆；排降序要建小堆。因为大堆是父节点大于孩子节点，并且每棵子树都如此，所以排升序要建大堆，每次将父节点和这棵树的最后一个节点进行交换，然后进行向下调整，以此类推，就排序完成。

在这里插入图片描述

//向下调整
public static void shitDownBig(int[] arr, int parent, int size) {
    int child = parent * 2 + 1;
    while(child <size) {
        if(child + 1 < size && arr[child + 1] > arr[child]) {
            child++;
        }
        if(arr[child] > arr[parent]) {
            swap(arr,child,parent);
            parent = child;
            child = 2 * parent + 1;
        } else {
            break;
        }
    }
}

//堆排序
public static void heapSort(int[] arr) {
    int len = arr.length;
    for(int i = (len / 2) + 2; i >=0; i--) {
        shitDownBig(arr,i,len);
    }
    //交换 + 向下调整
    //end是未排序的元素个数
    int end = len - 1;
    while(end > 0) {
        swap(arr,0,end);
        shitDownBig(arr,0,end);
        end--;
    }
}

堆排序性能分析：
时间复杂度： O(n^2)
稳定性：稳定
空间复杂度：常数空间 —> O(1)

5.冒泡排序

基本原理：在无序区间，通过相邻数的比较，将最大的数冒泡到无序区间的最后，持续这个过程，直到数组整体有序

public static void bubbleSort(int[] arr) {
    int len = arr.length;
    while(len >0) {
        boolean flag = true;
        //一轮排序，排好一个元素
        for(int i = 0; i < len - 1; i++) {
            if(arr[i] > arr[ i + 1])
                swap(arr, i, i + 1);
            flag = false;
        }
        if(flag)
            break;
        len--;
    }
}

注意：这里我们加了一个标记flag，这样可以优化冒泡排序的时间复杂度，如果进入循环的flag为true，说明此时的序列是有序的，这样就不用进行一轮的冒泡排序了，这样的话冒泡排序的时间复杂度就是O(n)。

冒泡排序性能分析：
时间复杂度：O(n) ~ O(n^2) 最好：顺序 + 标记最坏：逆序
稳定性：稳定
空间复杂度：常数空间 —> O(1)

6.快速排序

基本原理：

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

public static int partition(int[] arr, int left, int right) {
    int key = left;
    int star = left;
    while(left < right) {
        //先从后向前找第一个小于key的数据，否则会出现错误
        while(left < right && arr[right] >= key) {
            right--;
        }
        while(left < right && arr[left] <= key) {
            left++;
        }
        swap(arr,left,right);
    }
    //把基准值和相遇的位置数据进行交换
    swap(arr,left,star);
    return left;
}

//快速排序
public static void quickSort(int[] arr, int left, int right) {
    if(left < right) {
        int mid = partition(arr, left, right);
        //分组
        partition(arr, left, mid - 1);
        partition(arr,mid + 1, right);
    }
}

这里介绍的这种是霍尔法，其实快排的基本思想就是分治，在这基础上还有挖坑法，前后遍历法等等，思想都是一样的。其中前后遍历法中用到了三数取中，这可以有效的提高算法的性能，解决了递归中的栈溢出问题。
三数取中就是在一组数中不是只取第一个为基准值，而是取第一个，中间数和最后一个数的中间值作为基准值。

快排性能分析：
时间复杂度：O（n*log(n)）
空间复杂度：O(logn)
稳定性：不稳定

7.归并排序

基本原理：
归并排序（MERGE-SORT）是建立在归并操作上的一种有效的排序算法,该算法是采用分治法（Divide and
Conquer）的一个非常典型的应用。将已有序的子序列合并，得到完全有序的序列；即先使每个子序列有序，再使
子序列段间有序。若将两个有序表合并成一个有序表，称为二路归并。
其实就是分解，在合并和一个过程。
在这里插入图片描述

public static void mergeInternal(int[] arr, int left, int mid, int right, int[] tmp) {
    int begin1 = left, end1 = mid;
    int begin2 = mid + 1, end2 = right;
    int idx = left;
    while(begin1 <= end1 && begin2 <= end2) {
        //<=是稳定的，<是不稳定的
        if(arr[begin1] <= arr[begin2]) {
            //注意不能原地排序，会混乱数据元素
            tmp[idx++] = arr[begin1++];
        } else {
            tmp[idx++] = arr[begin2++];
        }
    }
    while(begin1 <= end1)
        tmp[idx++] = arr[begin1++];
    while (begin2 <= end2)
        tmp[idx++] = arr[begin2++];
    //拷贝
    for(int i = left; i <= right; i++)
        arr[i] = tmp[i];
}

public static void mergeSort(int[] arr, int left, int right, int[] tmp) {
    if(left >= right)
        return;
    int mid = (left + right) / 2;
    mergeSort(arr, left, mid, tmp);
    mergeSort(arr, mid + 1, right, tmp);

    mergeInternal(arr, left, mid, right, tmp);
}

这里仍然是递归的的，我们需要一个辅助数组tmp来进行排序，不能在原数组的基础上进行排序，这样会导致元素的覆盖，从而出错。

//非递归归并排序
public static void mergeSortNoR(int[] arr) {
    int[] tmp = new int[arr.length];
    //i是每次归并的元素个数
    for(int i = 1; i < arr.length; i *= 2) {
        //j是下一次归并的开始位置
        for(int j = 0; j < arr.length; j += 2 * i) {
            int left = j;
            int mid = j + i - 1;
            //判断右半部分是否有数据
            if(mid >= arr.length - 1)
                continue;
            int right = j + 2 * i - 1;
            //判断右边是否越界
            if(right >= arr.length) {
                right = arr.length - 1;
            }
            mergeInternal(arr, left, mid, right, tmp);
        }
    }
}

归并排序性能分析：
时间复杂度：O（nlog(n)）
空间复杂度：O (n)
稳定性：稳定

CHgoing

关注

0
点赞
踩
1

收藏

觉得还不错? 一键收藏
0
评论
几种常见的排序以及分析比较

这里是引用这里简单的介绍几种排序算法：插入排序，希尔排序，选择排序，快速排序，冒泡排序，归并排序，当然还有其它的排序，比如折半插入排序，堆排序等。1.插入排序：整个区间被分为有序区间和无序区间，每次从无序区间里面取第一个元素，然后在有序区间里找到合适的位置插入。（有序空间一开始可以看作是空的，既然要排序的话，数据一开始一般是无序的）...
复制链接

扫一扫