十大经典内部排序算法的设计思路及应用

最新推荐文章于 2022-08-01 20:59:33 发布

New俊

最新推荐文章于 2022-08-01 20:59:33 发布

阅读量1k

点赞数 2

CC 4.0 BY-SA版权

分类专栏：数据结构和算法及其应用文章标签：数据结构字符串 java 排序算法 github

本文链接：https://blog.youkuaiyun.com/ljfirst/article/details/102762758

项目介绍

本项目通过分解各大厂的常见笔面试题，追本溯源至数据结构和算法的底层实现原理，知其然知其所以然；
建立知识结构体系，方便查找，欢迎更多志同道合的朋友加入项目AlgorithmPractice，（欢迎提issue和pull request）。

Part One : 内部排序：

正文开始

1、冒泡排序

代码实现：BubbleSort
设计思路：
- 什么是冒泡排序：
  - 1.每次比较相邻的两个元素
  - 2.每次从头比到尾，能确定一个元素的最终位置
  - 3.除了之前最终确定的元素不需要比对外，其他元素重复1和2步骤。
- 冒泡排序的时间复杂度：
  - O( $n^2$ )。
  - (在一般情况下)第一次对比n-1次，第二次对比n-2次，…，第n-1次对比1次，共对比（1+n-1）*n-1=O( $n^2$ )。
- 冒泡排序的稳定性：稳定。
- 【代码展示】

public class BubbleSort implements SortInterface {
   
   
    //冒泡排序    参数：int类型数组，对数组进行排序
    public int[] sortMethod(int[] sortNum) {
   
   
        //交换变量：temp
        int temp;
        //当某次内部排序无数据交换发送时，flag不变，则此时数组有序，无序再循环对比
        boolean flag = false;
        //外部循环：循环元素个数减一次，因为最后一次默认有序
        for (int i = 0; i < sortNum.length - 1; i++) {
   
   
            //内部循环：外部循环i次，可以确定i个元素已经有序，因此剩余n-i个无序元素，
            //内部循环次数为元素个数n减去外部循环次数i,又因为i和i+1对比，因此防止的对比越界，需再减一
            for (int j = 0; j < sortNum.length - i - 1; j++) {
   
   
                if (sortNum[j] > sortNum[j + 1]) {
   
   
                    temp = sortNum[j];
                    sortNum[j] = sortNum[j + 1];
                    sortNum[j + 1] = temp;
                    flag = true;
                }
            }
            if (!flag) {
   
   
                break;
            }
            flag = false;
        }
        return sortNum;
    }
}

注意事项：内外层循环需要注意区分范围。

2、堆排序

代码实现：HeapSort，其实堆排序有两种实现方式，对比看看能不能更深入理解一下，堆排序的两种写法。
设计思路：
- 什么是堆排序：
  - 初试化建堆，建完后，堆顶即最大/最小元素。
  - 交换堆顶和数组末尾元素，然后针对剩余的n-1个元素，对堆顶元素进行调整即可。
  - 重复2),直到所有元素有序。
- 堆排序的时间复杂度：
  - 综合：O(n log 2ⁿ)。
  - 整堆的时间复杂度：O(n log 2ⁿ)。
  - 建堆的时间复杂度：O(n/2 * log 2ⁿ)。
- 堆排序的稳定性：不稳定。
- 【代码展示】（整堆的代码请见github）

public int[] sortMethod(int[] heap) {
   
   
    int temp;
    //输入检查
    if (heap == null || heap.length <= 1) {
   
   
        return heap;
    }
    //初试化建堆
    for (int i = (heap.length - 1) / 2; i >= 0 ; i--) {
   
   
        heapify_big(heap, i, heap.length - 1);
    }
    //交换堆顶和数组末尾元素，循环整堆,注意边界值
    for (int i = heap.length - 1; i > 0; i--) {
   
   
        temp = heap[0];
        heap[0] = heap[i];
        heap[i] = temp;
        heapify_big(heap, 0, i-1);
    }
    return heap;
}