七大排序算法一文通（易懂图解+优化代码）

news2024/11/18 1:48:34

目录

1.直接插入排序

2.希尔排序

3.选择排序

4.堆排序

5.冒泡排序

6.快速排序

6.1 递归实现——Hoare版

6.2 递归实现——挖坑法

6.3 非递归实现

6.4 优化

7.归并排序

7.1 归并排序——递归实现

7.2 归并排序——非递归实现

8.复杂度以及稳定性

1.直接插入排序

😄基本思路

  1. 从待排序数组的第 i (初始情况下i = 2)个元素开始，依次拿该元素与其前面的 i-1 个元素进行比较。
  2. 在这 i-1 个元素中，如果存在比第i个元素大的元素，则将这个元素向后移动一位；否则将当前元素 i 放在比它小的第一个元素的后边.
  3. 比较完一趟后将 i 向后调整，重复上述 1， 2操作。总共进行 arr.length - 1轮即可完成排序.

🙂直接插入排序代码

//直接插入排序
public void insertSortDirectly(int[] array) {
if(array == null || array.length == 0) {
        return;
    }
    for(int i=1;i<array.length;i++) {
        int temp = array[i];
        int j = i-1;
        for(;j >= 0;j--) {
            if(array[j] > temp) {
                array[j+1] = array[j];
            } else {
                break;
            }
        }
        //将当前元素放在j + 1 的位置上
        array[j+1] = temp;
    }
}

2.希尔排序

希尔排序实质上还是一种插入排序，不同的是采用了分组插入排序的思想，每次对每组进行的插入排序都会整组数据的插入排序效率更高，所以希尔排序的平均效率相对于普通的插入排序要高。

😄基本思路：

  1. 首先确定一个组数值：gap。通常情况下我们取 整组元素个数/2 作为gap的初始值。
  2. 根据gap将整组数据分成gap组（具体的分组方式见下方图解），对每一组进行一次普通插入排序。
  3. 将gap值缩小为原来的二分之一，再次将整组数据分成gap组，对魅族数据进行插入排序。
  4. 重复 3 步骤，直至gap值变为0，我们就可以得到一个有序序列。

😄希尔排序代码

public void shellSort(int[] array) {
    if (array == null || array.length == 0) {
        return;
    }
    int gap = array.length;
    while (gap > 1) {
        gap /= 2;
        shell(array, gap);
    }
}

private void shell(int[] array, int gap) {
    for (int i = gap; i < array.length; i++) {
        int temp = array[i];
        int j = i - gap;
        for (; j >= 0; j -= gap) {
            if (temp < array[j]) {
                array[j + gap] = array[j];
            } else {
                break;
            }
        }
        array[j + gap] = temp;
    }
}

3.选择排序

😄基本思路

  1. 从第i（初始情况下i=1）元素开始，从其后边的元素中挑选出一个比该元素小的最小的元素，然后与该元素进行交换。
  2. i 向后移动，重复步骤1
  3. 当 i 的值指向为这组数据的倒数第一个元素时，就完成了排序。

😄选择排序代码

public static void selectSort(int[] array) {
    if (array == null || array.length == 0) {
        return;
    }
    for (int i = 0; i < array.length - 1; i++) {
        int minPos = i;
        for (int j = i + 1; j < array.length; j++) {
            if (array[j] < array[minPos]) {
                minPos = j;
            }
        }
        if (minPos != i) {
            int temp = array[i];
            array[i] = array[minPos];
            array[minPos] = temp;
        }
    }
}

4.堆排序

😄基本思路

  1. 升序排列建大堆，降序排列建小堆
  2. 将堆顶元素与堆的最后一个没有被交换过的元素进行交换
  3. 进行一次堆的向下调整，调整范围为堆的大小-调整轮数
  4. 重复2、3操作，进行堆的大小size-1轮操作即可得到有序序列

😄堆排序代码

public static void heapSort(int[] array) {
    if (array == null || array.length == 0) {
        return;
    }
    //此处我们以升序排列为例，所以建大根堆
    createBigHeap(array);

    //进行排序操作
    int end = array.length - 1;
    while (end > 0) {
        int temp = array[0];
        array[0] = array[end];
        array[end] = temp;
        siftDown(array, 0, end);
        end--;
    }
}

private static void createBigHeap(int[] array) {
    for (int i = (array.length - 1 - 1) / 2; i >= 0; i--) {
        siftDown(array, i, array.length);  //从下标为i的位置向下调整
    }
}

private static void siftDown(int[] array, int parent, int size) {
    int childLeft = parent * 2 + 1;
    while (childLeft < size) {
        if (childLeft + 1 < size && array[childLeft] < array[childLeft + 1]) {
            childLeft = childLeft + 1;
        }
        if (array[parent] < array[childLeft]) {
            int temp = array[parent];
            array[parent] = array[childLeft];
            array[childLeft] = temp;
        }
        parent = childLeft;
        childLeft = parent * 2 + 1;
    }
}

5.冒泡排序

😄基本思路

  1. 依次比较待比较组中的相邻元素，满足排序序列比较条件则进行值的交换。假设待排序序列的长度为length，经过这样的一轮比较后，最大或最小的元素就位于了序列中的最前/最后（或最后/最前）的位置上。
  2. 再重复 1步骤 length-1 次，即可完成排序。
  3. 及其详细的实现步骤可以查看之前发布的这篇文章
    冒泡排序详解

😄冒泡排序代码

public static void bubbleSort(int[] array) {
    if (array == null || array.length == 0) {
        return;
    }
    for (int i = 0; i < array.length - 1; i++) {
        boolean flag = false;    //标志变量。如果进行了一轮比较而没有进行交换操作，说明已经有序了
        for (int j = 0; j < array.length - 1 - i; j++) {
            if (array[j] > array[j + 1]) {
                flag = true;
                int temp = array[j];
                array[j] = array[j + 1];
                array[j + 1] = temp;
            }
        }
        if(!flag) {
            break;
        }
    }
}

6.快速排序

😄基本思路

  1. 快速排序本质上也是一种基于交换排序来实现的。在进行排序之前，我们需要先在排序序列中指定一个基准值；
  2. 然后定义两个指针从序列的最左侧和最右侧分别寻找一个比基准值大和小的元素，进行交换；重复进行上述操作，直至左右指针相遇。然后将基准值与左右指针相遇的位置上的值进行交换。
  3. 以基准值分割左右序列，在其左右序列中重复上述 1 ，2 步骤直至序列有序

6.1 递归实现——Hoare版

😄快速排序递归实现图解

😄快速排序递归实现代码——Hoare

public static void quickSort(int[] array) {
    if (array == null || array.length == 0) {
        return;
    }
    quickSort(array, 0, array.length - 1);
}

private static void quickSort(int[] array, int start, int end) {
    if (start >= end) {
        return;
    }
    int pivot = getPivot(array, start, end);
    quickSort(array, start, pivot - 1);
    quickSort(array, pivot + 1, end);
}

private static int getPivot(int[] array, int left, int right) {
    int startPos = left;
    int temp = array[left];
    while (left < right) {
        while (left < right && array[right] >= temp) {
            right--;
        }
        while (left < right && array[left] <= temp) {
            left++;
        }
        int cur = array[left];
        array[left] = array[right];
        array[right] = cur;
    }
    array[startPos] = array[left];
    array[left] = temp;
    return left;
}

6.2 递归实现——挖坑法

😄基本思路

这种方法与Hoare版本的快排区别在于根据基准调整左右序列的做法。挖坑法是直接将基准位置空出，从右侧开始找到一个比基准小的数就将该数放在基准的位置上，从左侧开始找到一个比基准大的数就放在右侧空出的位置上，左右交替进行；当左右指针相遇时，就将基准值放在相遇位置上，并更新基准值下标。剩余的做法和Hoare一致，即在其左右子序列中重复上述操作。

 😄快速排序递归实现代码——挖坑法

public static void quickSortNonRecursive(int[] array) {
    if (array == null || array.length == 0) {
        return;
    }
    Stack<Integer> stack = new Stack<>();
    int start = 0;
    int end = array.length - 1;
    int pivot = getPivot(array, start, end);
    if (pivot > start + 1) {
        stack.push(start);
        stack.push(pivot - 1);
    }
    if (pivot < end - 1) {
        stack.push(pivot + 1);
        stack.push(end);
    }
    while (!stack.isEmpty()) {
        end = stack.pop();
        start = stack.pop();
        pivot = getPivot(array, start, end);
        if (pivot > start + 1) {
            stack.push(start);
            stack.push(pivot - 1);
        }
        if (pivot < end - 1) {
            stack.push(pivot + 1);
            stack.push(end);
        }
    }
}

6.3 非递归实现

😄非递归实现图解

 😄非递归实现代码

public static void quickSortNonRecursive(int[] array) {
    if (array == null || array.length == 0) {
        return;
    }
    Stack<Integer> stack = new Stack<>();
    int start = 0;
    int end = array.length-1;
    int pivot = getPivot(array, start, end);
    if (pivot > start + 1) {
        stack.push(start);
        stack.push(pivot - 1);
    }
    if (pivot < end - 1) {
        stack.push(pivot + 1);
        stack.push(end);
    }
    while (!stack.isEmpty()) {
        end = stack.pop();
        start = stack.pop();
        pivot = getPivot(array, start, end);
        if (pivot > start + 1) {
            stack.push(start);
            stack.push(pivot - 1);
        }
        if (pivot < end - 1) {
            stack.push(pivot + 1);
            stack.push(end);
        }
    }
}

6.4 优化

三数取中法

要解决的问题：

  • 当使用递归法快速排序时，如果序列已经趋于有序。那么每次的pivot值可能会取在序列的最左边或者最右边，这样就可能会出现下边的单项递归，大大增加了递归的层数，很有可能会导致栈溢出错误。我们使用“三数取中”这种优化就是为了提升递归快排的健壮性。

做法：

  • private static int threeNum(int[] array, int left, int right) {
    int mid = (left + right) / 2;
    if (array[left] < array[right]) {
        if (array[mid] < array[left]) {
            return left;
        } else if (array[mid] > array[right]) {
            return right;
        } else {
            return mid;
        }
    } else {
        if (array[mid] < array[right]) {
            return right;
        } else if (array[mid] > array[left]) {
            return left;
        } else {
            return mid;
        }
    }
}

7.归并排序

归并排序采用归并思想，将已经分割好的子序列进行合并，并且在合并的过程中对归并的子序列进行比较排序，这样，当归并结束总序列也就有序了。

😄基本思路

  1. 定义待排序数组的初始位置指针和结束位置指针 start和end，计算中间值 mid = (left +right)/2
  2. 以mid值为左右序列界限进行分割，对左序列和又序列重复1过程，当递归下去发现开始位置和结束位置相等了，就说明元素序列已经不可再分了。
  3. 对分割后的序列之间进行二路归并，并且在归并的过程中对数组进行排序，这样当子序列合并结束数组也就有序了

7.1 归并排序——递归实现

😄归并排序递归实现图解

😄归并排序递归实现代码

/**
 * 归并排序
 * @param array 待排序数组
 */
public static void mergeSort(int[] array) {
    mergeSort(array, 0, array.length - 1);
}

private static void mergeSort(int[] array, int start, int end) {
    //归
    if (start >= end) {
        return;
    }
    int mid = (start + end) / 2;
    mergeSort(array, start, mid);
    mergeSort(array, mid + 1, end);

    //并
    merge(array, start, mid, end);
}

private static void merge(int[] array, int start, int mid, int end) {
    int s1 = start;
    int s2 = mid + 1;
    int[] temp = new int[end - start + 1];
    int pos = 0;
    while (s1 <= mid && s2 <= end) {
        if(array[s1] <= array[s2]) {
            temp[pos++] = array[s1++];
        } else {
            temp[pos++] = array[s2++];
        }
    }
    while(s1 <= mid) {
        temp[pos++] = array[s1++];
    }
    while(s2 <= end) {
        temp[pos++] = array[s2++];
    }
    //将这个归并好的数组拷贝到排序数组中
    for (int i = start; i <= end; i++) {
        array[i] = temp[i-start];
    }
}

7.2 归并排序——非递归实现

😄归并排序非递归实现图解

 😄归并排序非递归实现代码

public static void mergeSortNonRecursive(int[] array) {
    if (array == null || array.length == 0) {
        return;
    }
    int gap = 1;
    while (gap < array.length) {
        for (int i = 0; i < array.length; i += gap * 2) {
            int left = i;
            int mid = left + gap - 1;
            int right = mid + gap;
            //right和mid有可能会越界，对其进行修正
            if (mid >= array.length) {
                mid = array.length - 1;
            }
            if (right >= array.length) {
                right = array.length - 1;
            }
            merge(array, left, mid, right);
        }
        gap *= 2;
    }
}

private static void merge(int[] array, int start, int mid, int end) {
    int s1 = start;
    int s2 = mid + 1;
    int[] temp = new int[end - start + 1];
    int pos = 0;
    while (s1 <= mid && s2 <= end) {
        if (array[s1] <= array[s2]) {
            temp[pos++] = array[s1++];
        } else {
            temp[pos++] = array[s2++];
        }
    }
    while (s1 <= mid) {
        temp[pos++] = array[s1++];
    }
    while (s2 <= end) {
        temp[pos++] = array[s2++];
    }
    //将这个归并好的数组拷贝到排序数组中
    for (int i = start; i <= end; i++) {
        array[i] = temp[i - start];
    }
}

8.复杂度以及稳定性

排序算法时间复杂度空间复杂度稳定性
直接插入排序O(n²)O(1)稳定
希尔排序O()O(1)不稳定
选择排序O(n²)O(1)不稳定
堆排序O(n*log2n)O(1)不稳定
冒泡排序O(n²)O(1)稳定
快速排序O(n*logn)O(logn)不稳定
归并排序O(n*logn)O(n)稳定

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：http://www.coloradmin.cn/o/503192.html

如若内容造成侵权/违法违规/事实不符，请联系多彩编程网进行投诉反馈，一经查实，立即删除！

相关文章

一列数到中位数的总距离最小

一列数到中位数的总距离最小

一列数到中位数的总距离最小 3554.二进制&#xff08;二进制数的加减法-转化为十进制运算再将结果转回二进制3565.完美矩阵1824.钻石收藏家&#xff08;经典双指针&#xff09; 3554.二进制&#xff08;二进制数的加减法-转化为十进制运算再将结果转回二进制 输入样例&#xff…
阅读更多...
i春秋 Misc Web 爆破-1

i春秋 Misc Web 爆破-1

打开链接是PHP源码 代码审计&#xff1a; include "flag.php"; 表示文件中包含flag.php文件&#xff0c;即根目录下存在flag.php $a $_REQUEST[hello]; 命名一个变量a来接收超全局变量$_REQUEST&#xff08;接收表单’hello’数据&#xff0c;请求一个为hello的参…
阅读更多...
研发效能系列 - 质量与速度能否兼得？

研发效能系列 - 质量与速度能否兼得？

作者&#xff1a;冬哥 引言 我们的时间&#xff0c;应该是用于提高软件质量&#xff0c;还是专注在发布更有价值的功能&#xff1f;这貌似是软件研发中永恒的话题。 到底什么是质量&#xff1f;质量有什么特质&#xff1f; 质量与速度是什么关系&#xff0c;两者是一个硬币的…
阅读更多...
spring.factories 的作用是什么

spring.factories 的作用是什么

spring.factories 文件用于在 Spring Boot 项目中配置自动配置项。它包含了一系列 key-value 对,key 是自动配置类的全限定名,value 是这些配置类对应的条件类。Spring Boot 会在启动时扫描 classpath 下的 META-INF/spring.factories 文件,并加载其中定义的自动配置类。这些自…
阅读更多...
[IAR][CC2642R1] IDE安装和环境搭建，CC2642的环境配置

[IAR][CC2642R1] IDE安装和环境搭建，CC2642的环境配置

文章目录 一、IAR安装&#xff08;1&#xff09;压缩包下载&#xff08;2&#xff09;IAR安装(3) 注册(4) 补丁 二、在IAR中使用CC2642&#xff08;0&#xff09;打开IAR&#xff0c;配置环境。&#xff08;1&#xff09;例程位置&#xff08;2&#xff09;打开例程&#xff08…
阅读更多...
4.Redis10大数据类型

4.Redis10大数据类型

Redis10大数据类型 Which 101.String&#xff08;字符串&#xff09;2.List&#xff08;列表&#xff09;3.hash &#xff08;哈希&#xff09;4.Set&#xff08;集合&#xff09;5.zset(sorted set&#xff1a;有序集合)6.Redis GEO &#xff08;地理空间&#xff09;7.HyperL…
阅读更多...
金融贷款行业怎么找客户，运营商数据了解过没？

金融贷款行业怎么找客户，运营商数据了解过没？

现如今随着信息社会发展的来临&#xff0c;销售市场呈碎片化发展趋向&#xff0c;各个行业为寻找用户&#xff0c;根据网上广告投放线下推广做活动&#xff0c;但效果微乎其微。拓客越来越难&#xff0c;且成本费也越来越高&#xff0c;成为很多公司的烦恼之处。 从被动获取客…
阅读更多...
K8S基础理论，核心组件，数据流向详解

K8S基础理论，核心组件，数据流向详解

目录 第一章.k8s概述 1.1.什么是云原生 1.2.什么是K8S 1.3.K8S的优势 1.4.K8S的功能 1.5.K8S 的特性&#xff1a; 1.6.Kubernetes 集群架构与组件 第二章.K8S的核心组件 2.1.Master 组件 2.2.配置存储中心 2.3.Node 组件 第三章.Kubernetes 核心概念 3.1.Pod 3.2…
阅读更多...
【Unity项目实战】手把手教学：飞翔的小鸟（6）添加障碍

【Unity项目实战】手把手教学：飞翔的小鸟（6）添加障碍

承接上一篇&#xff1a;【Unity项目实战】手把手教学&#xff1a;飞翔的小鸟&#xff08;5&#xff09;背景滚动&#xff0c;我们已经让主角在停止不动的情况下&#xff0c;移动背景图&#xff0c;使得主角小鸟像是自己往前移动了一样&#xff0c;接下来我们将继续往下&#xf…
阅读更多...
【王道·计算机网络】第二章 物理层

【王道·计算机网络】第二章 物理层

一、通信基础 1. 基本概念 1.1 物理层接口特性 物理层解决如何在连接各种计算机的传输媒体上传输比特流&#xff0c;不指定具体的传输媒体主要任务&#xff1a;确定与传输媒体接口有关的一些特性 → 定义标准接口特性&#xff1a; 机械特性&#xff1a;定义物理连接的特性&a…
阅读更多...
区间预测 | MATLAB实现QRDNN深度神经网络分位数回归时间序列区间预测

区间预测 | MATLAB实现QRDNN深度神经网络分位数回归时间序列区间预测

区间预测 | MATLAB实现QRDNN深度神经网络分位数回归时间序列区间预测 目录 区间预测 | MATLAB实现QRDNN深度神经网络分位数回归时间序列区间预测效果一览基本介绍模型描述程序设计参考资料 效果一览 基本介绍 MATLAB实现QRDNN深度神经网络分位数回归时间序列区间预测。QRDNN模型…
阅读更多...
linux 超过4个G的文件传不上去的解决办法

linux 超过4个G的文件传不上去的解决办法

服务器是内网的要挂载镜像 哎呀。。。。超过4个G还挂载不上。。。 解决先分卷压缩&#xff0c;然后上传 上传文件 单个上传再把文件合并成一个 cat Kylin-Server-10-SP2-Release-Build09-20210524-x86_64.zip* >ky.zip 再次解压就好了 unzip ky.zip
阅读更多...
Opencv+Python图像基本操作

Opencv+Python图像基本操作

目录 图像的读取、显示和保存 获取图像属性 图像截取 绘图功能 画线 画矩形 画圆圈 画椭圆 画多边形 向图像添加文本 图像的读取、显示和保存 # 导入 OpenCV import cv2 # 读取图片-与python文件相同目录 img cv2.imread("image.png", cv2.NORM_HAMMING) …
阅读更多...
Java版本工程项目管理系统源码,助力工程企业实现数字化管理

Java版本工程项目管理系统源码,助力工程企业实现数字化管理

Java版工程项目管理系统 Spring CloudSpring BootMybatisVueElementUI前后端分离 功能清单如下&#xff1a; 首页 工作台&#xff1a;待办工作、消息通知、预警信息&#xff0c;点击可进入相应的列表 项目进度图表&#xff1a;选择&#xff08;总体或单个&#xff09;项目显示…
阅读更多...
实验10 人工神经网络(1)

实验10 人工神经网络(1)

1. 实验目的 ①理解并掌握误差反向传播算法&#xff1b; ②能够使用单层和多层神经网络&#xff0c;完成多分类任务&#xff1b; ③了解常用的激活函数。 2. 实验内容 ①设计单层和多层神经网络结构&#xff0c;并使用TensorFlow建立模型&#xff0c;完成多分类任务&#xf…
阅读更多...
第四范式AIGC的野心，改变软件行业游戏规则

第四范式AIGC的野心，改变软件行业游戏规则

图片AI算法提供&#xff1a;Midjourney 在国内众多发布大模型的科技企业中&#xff0c;第四范式入局的方式与众不同。 “我们并不需要完整地对标OpenAI&#xff0c;也并不需要OpenAI能做什么就一定要做什么……我们不去参与一场全面的竞争&#xff0c;而是专注于其中一场比赛。…
阅读更多...
关联分割点云中的实例和语义＜论文＞

关联分割点云中的实例和语义＜论文＞

题目&#xff1a;Associatively Segmenting Instances and Semantics in Point Clouds 代码&#xff1a;https://github.com/WXinlong/ASIS 文章讨论&#xff1a; Instances Segmentation 和 Semantics Segmentation 实例Instances Segmentation&#xff1a;分辨出每个单独事…
阅读更多...
帮助中心对企业有用吗？要不要做帮助中心页面

帮助中心对企业有用吗？要不要做帮助中心页面

对绝大部分企业来说&#xff0c;打造站点帮助中心平台已是当下势不可挡的发展趋势。本文小编将告诉大家企业是否有必要做帮助中心&#xff0c;如何制作帮助中心。 什么是帮助中心&#xff1a; 帮助中心定位&#xff1a;帮助用户更好的解决问题&#xff1b;给新手用户好的第一…
阅读更多...
详解c++---模拟实现stack和queue

详解c++---模拟实现stack和queue

目录标题 设计模式stack的模拟实现准备工作各种函数的实现 queue的模拟实现准备工作queue的接口实现 deque的介绍为什么会有dequedeque的原理deque的迭代器为什么使用deque 设计模式 设计模式分为两个&#xff1a;迭代器模式和适配器模式 第一个&#xff1a;迭代器模式 迭代器…
阅读更多...
vector、deque、list相关知识点

vector、deque、list相关知识点

vector erase返回迭代器指向删除元素后的元素insert返回迭代器指插入的元素reserve只给容器底层开指定大小内存空间&#xff0c;并不添加新元素 deque 底层数据结构 动态开辟的二维数组&#xff0c;一维数组从2开始&#xff0c;以2倍方式扩容&#xff0c;每次扩容和&#x…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023