常用排序算法比较与分析报告
常用内排序算法的分析与比较
常用内排序算法的分析与比较排序算法的含义：排序是计算机程序设计中的一种重要操作, 在数据处理中占有极重要的位置, 其方法也很多, 有快速排序、冒泡法排序、选择法排序等。
排序算法的好坏, 直接影响到实现的复杂度。
在日常生活中经常需要对所收集到的各种数据信息进行处理, 这些数据处理中经常用的核心运算就是排序。
例如图书馆理员将书籍按照编号排序放置在书架上, 方便读者查找; 打开计算机的资源管理器, 可以选择不同类型来排列图标等等。
排序已经广泛应用在几乎所有领域。
在当今的计算机系统中, 花费在排序上的时间占系统CPU 运行时间的比重很大。
排序是计算机程序设计中的一种重要操作, 其功能是对一个数据元素集合或序列重新排列成一个按数据元素某个项值有序的序列。
作为排序依据的数据项称为“排序码”, 也即数据元素的关键码。
为了便于查找, 通常希望计算机中的数据表是按关键码有序排列的。
若关键码是主关键码, 则对于任意待排序序列, 经排序后得到的结果是唯一的; 若关键码是次关键码, 排序结果可能不唯一, 这是因为具有相同关键码的数据元素, 这些元素在排序结果中, 它们之间的位置关系与排序前不能保持一致。
若对任意的数据元素序列使用某个排序方法, 对它按关键码进行排序: 若相同关键码元素间的位置关系, 排序前与排序后保持一致, 称此排序方法是稳定的; 而不保持一致的排序方法则称为不稳定的。
排序分为两类: 内排序和外排序。
内排序: 指待排序列完全存放在内存中所进行的排序过程, 适合不太大的元素序列。
外排序: 指排序过程中还需访问外存储器, 足够大的元素序列, 因不能完全放入内存, 只能使用外排序。
排序算法分析：一；排序算法的基本操作①比较两个关键字的大小;②改变指向记录的指针或移动记录本身(其实现依赖于待排序记录的存储方式)。
二；待排文件的常用存储方式①以顺序表作为存储结构;②以链表作为存储结构;③用顺序的方式存储待排序的记录, 但同时建立一个索引表。
5种排序算法性能比较总结
5种排序算法性能比较总结1、概述本文对比较常用且比较高效的排序算法进行了总结和解析，并贴出了比较精简的实现代码，包括选择排序、插入排序、归并排序、希尔排序、快速排序等。
算法性能比较如下图所示：2、选择排序选择排序的第一趟处理是从数据序列所有n个数据中选择一个最小的数据作为有序序列中的第1个元素并将它定位在第一号存储位置，第二趟处理从数据序列的n-1个数据中选择一个第二小的元素作为有序序列中的第2个元素并将它定位在第二号存储位置，依此类推，当第n-1趟处理从数据序列的剩下的2个元素中选择一个较小的元素作为有序序列中的最后第2个元素并将它定位在倒数第二号存储位置，至此，整个的排序处理过程就已完成。
代码如下：3、插入排序直接插入排序法的排序原则是：将一组无序的数字排列成一排，左端第一个数字为已经完成排序的数字，其他数字为未排序的数字。
然后从左到右依次将未排序的数字插入到已排序的数字中。
代码如下：4、归并排序算法描述：把序列分成元素尽可能相等的两半。
把两半元素分别进行排序。
把两个有序表合并成一个。
代码如下：5、希尔排序希尔排序又称“缩小增量排序”，该方法的基本思想是：先将整个待排元素序列分割成若干个子序列（由相隔某个“增量”的元素组成的）分别进行直接插入排序，然后依次缩减增量再进行排序，待整个序列中的元素基本有序（增量足够小）时，再对全体元素进行一次直接插入排序。
因为直接插入排序在元素基本有序的情况下（接近最好情况），效率是很高的，因此希尔排序在时间效率上比前两种方法有较大提高。
代码如下：6、快速排序快速排序（Quicksort）是对冒泡排序的一种改进。
由C. A. R. Hoare在1962年提出。
它的基本思想是：通过一趟排序将要排序的数据分割成独立的两部分，其中一部分的所有数据都比另外一部分的所有数据都要小，然后再按此方法对这两部分数据分别进行快速排序，整个排序过程可以递归进行，以此达到整个数据变成有序序列。
常用排序算法分析比较
常用排序算法分析比较排序算法是计算机科学中的基本概念之一，它主要用于对一组元素进行排序，使得这些元素按照某种规则有序排列。
常见的排序算法包括冒泡排序、插入排序、选择排序、快速排序、归并排序等等，这些算法都有自己的特点和适用场景，下面针对这些排序算法进行分析比较。
1.冒泡排序冒泡排序是一种简单的排序算法，它的主要思想是依次比较相邻的两个元素，如果它们的顺序不对就交换它们的位置，可以保证每次循环后最后一个元素是已经排序好的。
冒泡排序的时间复杂度为O(n^2)，空间复杂度为O(1)。
2.插入排序插入排序是一种稳定的排序算法，它的基本思想是将待排序的数据分为两个区间，已排序区间和未排序区间，在未排序区间内遍历，将每个元素插入到已排序区间的合适位置。
插入排序的时间复杂度为O(n^2)，空间复杂度为O(1)。
3.选择排序选择排序是一种比较简单的排序算法，它的主要思想是通过不断选择未排序区间内的最小值，然后和未排序区间的第一个元素交换位置，以此类推，直到排序完毕。
选择排序的时间复杂度为O(n^2)，空间复杂度为O(1)。
4.快速排序快速排序是一种经典的排序算法，它的思想是采用分治的思想，将序列分为左右两个子序列，通过递归的方式对左右两个子序列进行快速排序，最后合并两个排好序的子序列。
快速排序的时间复杂度为O(nlogn)，空间复杂度为O(logn)。
5.归并排序归并排序是一种稳定的排序算法，它的基本思想是采用分治的思想，将序列分为左右两个子序列，通过递归的方式对左右两个子序列进行排序，最后将两个排好序的子序列合并成一个有序序列。
归并排序的时间复杂度为O(nlogn)，空间复杂度为O(n)。
通过比较以上五种排序算法，可以发现每种算法都有自己的特点和适用场景，对于元素数量较少的情况下，可以选择冒泡排序、插入排序或选择排序，这些算法思路简单易懂，实现也比较容易；对于大规模数据排序，可以选择归并排序或快速排序，因为它们的时间复杂度比较优秀。
各种排序算法的总结和比较
各种排序算法的总结和比较1 快速排序（QuickSort ）快速排序是一个就地排序，分而治之，大规模递归的算法。
从本质上来说，它是归并排序的就地版本。
快速排序可以由下面四步组成。
（1 ）如果不多于1 个数据，直接返回。
（2 ）一般选择序列最左边的值作为支点数据。
（3 ）将序列分成2 部分，一部分都大于支点数据，另外一部分都小于支点数据。
（4 ）对两边利用递归排序数列。
快速排序比大部分排序算法都要快。
尽管我们可以在某些特殊的情况下写出比快速排序快的算法，但是就通常情况而言，没有比它更快的了。
快速排序是递归的，对于内存非常有限的机器来说，它不是一个好的选择。
2 归并排序（MergeSort ）归并排序先分解要排序的序列，从1 分成2 ，2 分成4 ，依次分解，当分解到只有1 个一组的时候，就可以排序这些分组，然后依次合并回原来的序列中，这样就可以排序所有数据。
合并排序比堆排序稍微快一点，但是需要比堆排序多一倍的内存空间，因为它需要一个额外的数组。
3 堆排序( HeapSort )堆排序适合于数据量非常大的场合(百万数据)。
堆排序不需要大量的递归或者多维的暂存数组。
这对于数据量非常巨大的序列是合适的。
比如超过数百万条记录，因为快速排序，归并排序都使用递归来设计算法，在数据量非常大的时候，可能会发生堆栈溢出错误。
堆排序会将所有的数据建成一个堆，最大的数据在堆顶，然后将堆顶数据和序列的最后一个数据交换。
接下来再次重建堆，交换数据，依次下去，就可以排序所有的数据。
4 Shell 排序( ShellSort )Shell 排序通过将数据分成不同的组，先对每一组进行排序，然后再对所有的元素进行一次插入排序，以减少数据交换和移动的次数。
平均效率是O(nlogn) 。
其中分组的合理性会对算法产生重要的影响。
现在多用D.E.Knuth 的分组方法。
Shell 排序比冒泡排序快5 倍，比插入排序大致快2 倍。
Shell 排序比起QuickSort ，MergeSort ，HeapSort 慢很多。
排序基本算法实验报告
一、实验目的1. 掌握排序算法的基本原理和实现方法。
2. 熟悉常用排序算法的时间复杂度和空间复杂度。
3. 能够根据实际问题选择合适的排序算法。
4. 提高编程能力和问题解决能力。
二、实验内容1. 实现并比较以下排序算法：冒泡排序、插入排序、选择排序、快速排序、归并排序、堆排序。
2. 对不同数据规模和不同数据分布的序列进行排序，分析排序算法的性能。
3. 使用C++编程语言实现排序算法。
三、实验步骤1. 冒泡排序：将相邻元素进行比较，如果顺序错误则交换，直到序列有序。
2. 插入排序：将未排序的元素插入到已排序的序列中，直到序列有序。
3. 选择排序：每次从剩余未排序的元素中选取最小（或最大）的元素，放到已排序序列的末尾。
4. 快速排序：选择一个枢纽元素，将序列分为两部分，一部分比枢纽小，另一部分比枢纽大，递归地对两部分进行排序。
5. 归并排序：将序列分为两半，分别对两半进行排序，然后将两半合并为一个有序序列。
6. 堆排序：将序列构建成一个最大堆，然后依次取出堆顶元素，最后序列有序。
四、实验结果与分析1. 冒泡排序、插入排序和选择排序的时间复杂度均为O(n^2)，空间复杂度为O(1)。
这些算法适用于小规模数据或基本有序的数据。
2. 快速排序的时间复杂度平均为O(nlogn)，最坏情况下为O(n^2)，空间复杂度为O(logn)。
快速排序适用于大规模数据。
3. 归并排序的时间复杂度和空间复杂度均为O(nlogn)，适用于大规模数据。
4. 堆排序的时间复杂度和空间复杂度均为O(nlogn)，适用于大规模数据。
五、实验结论1. 根据不同数据规模和不同数据分布，选择合适的排序算法。
2. 冒泡排序、插入排序和选择排序适用于小规模数据或基本有序的数据。
3. 快速排序、归并排序和堆排序适用于大规模数据。
4. 通过实验，加深了对排序算法的理解，提高了编程能力和问题解决能力。
六、实验总结本次实验通过对排序算法的学习和实现，掌握了常用排序算法的基本原理和实现方法，分析了各种排序算法的性能，提高了编程能力和问题解决能力。
排序算法比较
排序算法比较在计算机科学中，排序算法是一类重要且基础的算法。
通过对数据进行排序，我们可以更高效地检索、查找以及分析数据。
在实际应用中，我们经常需要比较不同排序算法的性能和效率，以便选择最适合特定任务的排序算法。
本文将对几种常见的排序算法进行比较。
一、冒泡排序冒泡排序是一种简单但效率较低的排序算法。
其基本思想是通过多次交换相邻的元素，将最大（或最小）的元素逐渐“冒泡”到待排序序列的末尾。
具体实现过程如下：从头开始依次比较相邻的两个元素，如果顺序不正确，则进行交换。
重复此过程，直到没有任何交换发生。
冒泡排序的时间复杂度为O(n^2)，其中n为待排序序列的长度。
这使得冒泡排序在大规模数据排序时表现较差。
二、插入排序插入排序是一种简单且高效的排序算法。
它的基本思想是将未排序部分的元素依次插入到已排序部分的正确位置，直到全部元素都有序。
具体实现过程如下：将未排序部分的第一个元素插入到已排序部分中的正确位置，然后再将第二个元素插入到已排序部分中，依此类推。
插入排序的时间复杂度为O(n^2)，但在实际应用中，插入排序通常要比冒泡排序快得多。
插入排序对于小规模或基本有序的数据集合表现良好。
三、选择排序选择排序是一种简单但不稳定的排序算法。
其基本思想是从未排序部分选择最小（或最大）的元素，将其放到已排序部分的末尾。
具体实现过程如下：从未排序部分中选出最小的元素，将其与未排序部分的第一个元素交换位置，然后将已排序部分的长度加1。
重复此过程，直到全部元素都有序。
选择排序的时间复杂度为O(n^2)，与冒泡排序和插入排序相同。
尽管选择排序的性能较差，但由于其实现简单，对于小规模数据集合仍然是一种可用的排序方法。
四、快速排序快速排序是一种高效的排序算法，常被用作标准库中的排序函数实现。
其基本思想是通过分治的策略将待排序序列划分为较小和较大的两个子序列，然后分别对子序列进行递归排序。
具体实现过程如下：选择一个基准元素，通过一趟排序将待排序序列分割为两部分，使得左边部分的元素都小于等于基准元素，右边部分的元素都大于等于基准元素。
常见的排序算法比较及总结
常见的排序算法⽐较及总结三种线性排序算法计数排序、桶排序与基数排序[⾮基于⽐较的排序]在计算机科学中，排序是⼀门基础的算法技术，许多算法都要以此作为基础，不同的排序算法有着不同的时间开销和空间开销。
排序算法有⾮常多种，如我们最常⽤的快速排序和堆排序等算法，这些算法需要对序列中的数据进⾏⽐较，因为被称为基于⽐较的排序。
基于⽐较的排序算法是不能突破O(NlogN)的。
简单证明如下：N个数有N!个可能的排列情况，也就是说基于⽐较的排序算法的判定树有N!个叶⼦结点，⽐较次数⾄少为log(N!)=O(NlogN) (斯特林公式)。
⽽⾮基于⽐较的排序，如计数排序，桶排序，和在此基础上的基数排序，则可以突破O(NlogN)时间下限。
但要注意的是，⾮基于⽐较的排序算法的使⽤都是有条件限制的，例如元素的⼤⼩限制，相反，基于⽐较的排序则没有这种限制(在⼀定范围内)。
但并⾮因为有条件限制就会使⾮基于⽐较的排序算法变得⽆⽤，对于特定场合有着特殊的性质数据，⾮基于⽐较的排序算法则能够⾮常巧妙地解决。
本⽂着重介绍三种线性的⾮基于⽐较的排序算法：计数排序、桶排序与基数排序。
[计数排序]⾸先从计数排序(Counting Sort)开始介绍起，假设我们有⼀个待排序的整数序列A，其中元素的最⼩值不⼩于0，最⼤值不超过K。
建⽴⼀个长度为K的线性表C，⽤来记录不⼤于每个值的元素的个数。
算法思路如下：1. 扫描序列A，以A中的每个元素的值为索引，把出现的个数填⼊C中。
此时C[i]可以表⽰A中值为i的元素的个数。
2. 对于C从头开始累加，使C[i]<-C[i]+C[i-1]。
这样，C[i]就表⽰A中值不⼤于i的元素的个数。
3. 按照统计出的值，输出结果。
由线性表C我们可以很⽅便地求出排序后的数据，定义B为⽬标的序列，Order[i]为排名第i的元素在A中的位置，则可以⽤以下⽅法统计。
显然地，计数排序的时间复杂度为O(N+K)，空间复杂度为O(N+K)。
常用排序算法的分析与比较
２ 排 序 算 法 的 分 类
依据待排序 的问题大小（ 记录数量 ｎ 的不同 。 ） 排序
过 程 中需 要 的存 储 器 空 间 也 不 同 ． 由此 将 排 序 算 法 分 为 两 大类 ： 排 序 、 排 序 。 内排 序 指 待 排 序 数 据 记 录 内 外 存 放 于计 算 机 随 机 存 储 器 Ｒ Ｍ 中所 进 行 的 排 序 过 程 ． Ａ
收 稿 日期 ： ０ ２ ５ ２ ２ １ ￣０ — ５ 修 稿 日 期 ：０ ２ ０ —２ ２１—６ ５
个数依次 比较 ． 找出最 小值 ， 记下其位置 Ｐ 。比较完一 轮 后 ， 存放 了 １ｎ个数 中最小值所在 的位 置 。交换 ａ １ Ｐ － ［ Ｏ 与ａ】 ［ 的值 。这时 ａ 】 ｐ ［ 为原 ａ０到 ａ — 】 ｎ个数据 记 ０ ［ 】 ［ ｌ ｎ 的
关 键 词 ：排 序 算 法 ；时 间复 杂 度 ；空 间 复 杂度 ； 定性 ； ＋ 代 码 稳 ｃ＋ 源
１ 排 序 的 概 念
随着 计 算 机 的发 展 与 应 用 领 域 的越 来 越 广 ．基 于
内排 序 又 分 为 ： 比较 交 换 排 序 、 择 排 序 、 泡 排 序 、 选 冒 插
录 中的 最 小 次 比较 ， 找出第 ２ 数到第 ｎ 数 中的最小值 ． 个 个 记
作 者 简 介 ： 德 超 （９ ４ ， ， 庆 人 ， 教 授 ， 士 ， 究 方 向 为 计 算 机 应 用 、 法 设 计 与 分 析 王 １ ６－） 男 重 副 博 研 算
则使 序 列 （） 关 键 字 序 列 （ ） 增 （ 序 ） 递 减 １按 ２递 升 或
- 1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。
常用排序算法比较与分析一、常用排序算法简述下面主要从排序算法的基本概念、原理出发,分别从算法的时间复杂度、空间复杂度、算法的稳定性和速度等方面进行分析比较。
依据待排序的问题大小(记录数量 n)的不同，排序过程中需要的存储器空间也不同，由此将排序算法分为两大类：【排序】、【外排序】。
排序：指排序时数据元素全部存放在计算机的随机存储器RAM中。
外排序：待排序记录的数量很大，以致存一次不能容纳全部记录，在排序过程中还需要对外存进行访问的排序过程。
先了解一下常见排序算法的分类关系(见图1-1)图1-1 常见排序算法二、排序相关算法2.1 插入排序核心思想：将一个待排序的数据元素插入到前面已经排好序的数列中的适当位置，使数据元素依然有序，直到待排序数据元素全部插入完为止。
2.1.1 直接插入排序核心思想：将欲插入的第i个数据元素的关键码与前面已经排序好的i-1、i-2 、i-3、… 数据元素的值进行顺序比较，通过这种线性搜索的方法找到第i个数据元素的插入位置，并且原来位置的数据元素顺序后移，直到全部排好顺序。
直接插入排序中，关键词相同的数据元素将保持原有位置不变，所以该算法是稳定的，时间复杂度的最坏值为平方阶O(n2)，空间复杂度为常数阶O(l)。
Python源代码：1.#-------------------------直接插入排序--------------------------------2.def insert_sort(data_list):3.#遍历数组中的所有元素，其中0号索引元素默认已排序，因此从1开始4.for x in range(1, len(data_list)):5.#将该元素与已排序好的前序数组依次比较，如果该元素小，则交换6.#range(x-1,-1,-1):从x-1倒序循环到07.for i in range(x-1, -1, -1):8.#判断：如果符合条件则交换9.if data_list[i] > data_list[i+1]:10.temp= data_list[i+1]11.data_list[i+1] = data_list[i]12.data_list[i] = temp2.1.2 希尔排序核心思想：是把记录按下标的一定增量分组，对每组使用直接插入排序算法排序;随着增量逐渐减少，每组包含的关键词越来越多，当增量减至1时，整个文件恰被分成一组，算法便终止。
希尔排序时间复杂度会比O(n2)好一些，然而，多次插入排序中，第一次插入排序是稳定的，但在不同的插入排序过程中，相同的元素可能在各自的插入排序中移动，所以希尔排序是不稳定的。
Python源代码：1.#-------------------------希尔排序-------------------------------2.def insert_shell(data_list):3.#初始化step值，此处利用序列长度的一半为其赋值4.group= int(len(data_list)/2)5.#第一层循环：依次改变group值对列表进行分组6.while group> 0:7.#下面：利用直接插入排序的思想对分组数据进行排序8.#range(group,len(data_list)):从group开始9.for i in range(group, len(data_list)):10.#range(x-group,-1,-group):从x-group开始与选定元素开始倒序比较，每个比较元素之间间隔group11.for j in range(i-group, -1, -group):12.#如果该组当中两个元素满足交换条件，则进行交换13.if data_list[j] > data_list[j+group]:14.temp= data_list[j+group]15.data_list[j+group] = data_list[j]16.data_list[j] = temp17.#while循环条件折半18.group= int(group/ 2)2.2 选择排序核心思想：每一趟扫描时，从待排序的数据元素中选出关键码最小或最大的一个元素，顺序放在已经排好顺序序列的最后，直到全部待排序的数据元素排完为止。
2.2.1 直接选择排序核心思想：给每个位置选择关键码最小的数据元素，即：选择最小的元素与第一个位置的元素交换，然后在剩下的元素中再选择最小的与第二个位置的元素交换，直到倒数第二个元素和最后一个元素比较为止。
根据其基本思想，每当扫描一趟时，如果当前元素比一个元素小，而且这个小元素又出现在一个和当前元素相等的元素后面，则它们的位置发生了交换，所以直接选择排序时不稳定的，其时间复杂度为平方阶O(n2)，空间复杂度为O(l)。
Python源代码：1.#-------------------------直接选择排序-------------------------------2.def select_sort(data_list):3.#依次遍历序列中的每一个元素4.for i in range(0, len(data_list)):5.#将当前位置的元素定义此轮循环当中的最小值6.minimum = data_list[i]7.#将该元素与剩下的元素依次比较寻找最小元素8.for j in range(i+1, len(data_list)):9.if data_list[j] < minimum:10.temp= data_list[j];11.data_list[j] = minimum;12.minimum = temp13.#将比较后得到的真正的最小值赋值给当前位置14.data_list[i] = minimum2.2.2 堆排序堆排序时对直接选择排序的一种有效改进。
核心思想：将所有的数据建成一个堆，最大的数据在堆顶，然后将堆顶的数据元素和序列的最后一个元素交换;接着重建堆、交换数据，依次下去，从而实现对所有的数据元素的排序。
完成堆排序需要执行两个动作：建堆和堆的调整，如此反复进行。
堆排序有可能会使得两个相同值的元素位置发生互换，所以是不稳定的，其平均时间复杂度为0(nlog2n)，空间复杂度为O(l)。
Python源代码：1.#-------------------------堆排序--------------------------------2.#**********获取左右叶子节点**********3.def LEFT(i):4.return2*i + 15.6.def RIGHT(i):7.return2*i + 28.9.#********** 调整大顶堆**********10.#data_list:待调整序列length: 序列长度i:需要调整的结点11.def adjust_max_heap(data_list,length,i):12.#定义一个int值保存当前序列最大值的下标rgest = i14.#执行循环操作：两个任务：1 寻找最大值的下标；2.最大值与父节点交换15.while 1:16.#获得序列左右叶子节点的下标17.left, right= LEFT(i), RIGHT(i)18.#当左叶子节点的下标小于序列长度并且左叶子节点的值大于父节点时，将左叶子节点的下标赋值给largest19.if (left< length) and(data_list[left] > data_list[i]):rgest = left21.#print('左叶子节点')22.else:rgest = i24.#当右叶子节点的下标小于序列长度并且右叶子节点的值大于父节点时，将右叶子节点的下标值赋值给largest25.if (right< length) and(data_list[right] > data_list[largest]):rgest = right27.#print('右叶子节点')28.#如果largest不等于i 说明当前的父节点不是最大值，需要交换值29.if (largest != i):30.temp= data_list[i]31.data_list[i] = data_list[largest]32.data_list[largest] = temp33.i = largest34.#print(largest)35.continue36.else:37.break38.39.#********** 建立大顶堆**********40.def build_max_heap(data_list):41.length = len(data_list)42.for x in range(int((length-1)/2),-1,-1):43.adjust_max_heap(data_list,length,x)44.45.#********** 堆排序**********46.def heap_sort(data_list):47.#先建立大顶堆，保证最大值位于根节点；并且父节点的值大于叶子结点48.build_max_heap(data_list)49.#i：当前堆中序列的长度.初始化为序列的长度50.i = len(data_list)51.#执行循环：1. 每次取出堆顶元素置于序列的最后(len-1,len-2,len-3...)52.# 2. 调整堆，使其继续满足大顶堆的性质，注意实时修改堆中序列的长度53.while i > 0:54.temp= data_list[i-1]55.data_list[i-1] = data_list[0]56.data_list[0] = temp57.#堆中序列长度减158.i = i-159.#调整大顶堆60.adjust_max_heap(data_list, i, 0)2.3交换排序核心思想：顾名思义，就是一组待排序的数据元素中，按照位置的先后顺序相互比较各自的关键码，如果是逆序，则交换这两个数据元素，直到该序列数据元素有序为止。
2.3.1 冒泡排序核心思想：对于待排序的一组数据元素，把每个数据元素看作有重量的气泡，按照轻气泡不能在重气泡之下的原则，将未排好顺序的全部元素自上而下的对相邻两个元素依次进行比较和调整，让较重的元素往下沉，较轻的往上冒。
根据基本思想，只有在两个元素的顺序与排序要求相反时才将调换它们的位置，否则保持不变，所以冒泡排序时稳定的。
时间复杂度为平方阶O(n2)，空间复杂度为O(l)。