算法分析与设计八大排序

合集下载

深入浅出-C语言8种经典排序算法

C语言——8种经典排序算法1.排序算法的稳定性分析:若待排序的序列中，存在多个具有相同关键字的记录，经过排序，这些记录的相对次序保持不变，则称该算法是稳定的；若经排序后，记录的相对次序发生了改变，则称该算法是不稳定的。

(1)冒泡排序冒泡排序就是把小的元素往前调或者把大的元素往后调。

比较是相邻的两个元素比较，交换也发生在这两个元素之间。

所以，如果两个元素相等，我想你是不会再无聊地把他们俩交换一下的；如果两个相等的元素没有相邻，那么即使通过前面的两两交换把两个相邻起来，这时候也不会交换，所以相同元素的前后顺序并没有改变，所以冒泡排序是一种稳定排序算法。

(2)选择排序选择排序是给每个位置选择当前元素最小的，比如给第一个位置选择最小的，在剩余元素里面给第二个元素选择第二小的，依次类推，直到第n-1个元素，第n个元素不用选择了，因为只剩下它一个最大的元素了。

那么，在一趟选择，如果当前元素比一个元素小，而该小的元素又出现在一个和当前元素相等的元素后面，那么交换后稳定性就被破坏了。

比较拗口，举个例子，序列5 8 5 2 9，我们知道第一遍选择第1个元素5会和2交换，那么原序列中2个5的相对前后顺序就被破坏了，所以选择排序不是一个稳定的排序算法。

(3)插入排序插入排序是在一个已经有序的小序列的基础上，一次插入一个元素。

当然，刚开始这个有序的小序列只有1个元素，就是第一个元素。

比较是从有序序列的末尾开始，也就是想要插入的元素和已经有序的最大者开始比起，如果比它大则直接插入在其后面，否则一直往前找直到找到它该插入的位置。

如果碰见一个和插入元素相等的，那么插入元素把想插入的元素放在相等元素的后面。

所以，相等元素的前后顺序没有改变，从原无序序列出去的顺序就是排好序后的顺序，所以插入排序是稳定的。

(4)快速排序快速排序有两个方向，左边的i下标一直往右走，当a[i] <= a[center_index]，其中center_index 是中枢元素的数组下标，一般取为数组第0个元素。

常用排序算法分析比较

常用排序算法分析比较排序算法是计算机科学中的基本概念之一，它主要用于对一组元素进行排序，使得这些元素按照某种规则有序排列。

常见的排序算法包括冒泡排序、插入排序、选择排序、快速排序、归并排序等等，这些算法都有自己的特点和适用场景，下面针对这些排序算法进行分析比较。

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)。

通过比较以上五种排序算法，可以发现每种算法都有自己的特点和适用场景，对于元素数量较少的情况下，可以选择冒泡排序、插入排序或选择排序，这些算法思路简单易懂，实现也比较容易；对于大规模数据排序，可以选择归并排序或快速排序，因为它们的时间复杂度比较优秀。

算法_八大排序算法总结

算法_⼋⼤排序算法总结最近笔试⾯试中经常考到排序算法，及其对应的时间复杂度和空间复杂度分析，现做如下总结。

⼀，冒泡排序思想：对于0~n-1，依次⽐较相邻两个数，前者⽐后者⼤就交换，⼀轮后A[n-1]是最⼤数，在对0~n-2执⾏以上步骤，则A[n-2]是第⼆⼤的数，循环执⾏上⾯的步骤即可，形象的可以理解为⼤的数⼀个个冒到后⾯去，所以叫冒泡排序。

⽰意图：⾸先6和3⽐较，6⽐3⼤，交换6和5⽐较，交换6和7⽐较，不⽤交换依次执⾏以上步骤，第⼀轮后，序列变为接着，在0到n-2上执⾏以上步骤⼀轮过后，则变为依次执⾏以上步骤，最后序列为时间复杂度： O(n^2)空间复杂度：O(1)代码：1class BubbleSort {2public:3int* bubbleSort(int* A, int n)4 {5int temp;6// write code here7for(int i = 0; i < n; i++)8 {9for(int j = 0; j < n - i - 1; j++)10 {11if(A[j] > A[j+1])12 {13 temp = A[j];14 A[j] = A[j + 1];15 A[j + 1] = temp;16 }17 }1819 }20return A;21 }22 };⼆，选择排序思想：在序列中依次选择最⼩值放到最前端，重复以上步骤，只到排序完成⽰意图：最⼩数为0，放到最前端1到n-1最⼩数为1，放到最前端依次执⾏以上步骤，最后为时间复杂度：O(n^2)空间复杂度：O(1)代码：1class SelectionSort {2public:3int* selectionSort(int* A, int n)4 {5// write code here6//从前往后依次放⼊为排序的数组的最⼩值7int min_b;8int temp;9for(int i = 0; i < n - 1; i++)10 {11 min_b = i;12for(int j = i; j < n; j++) //寻找最⼩值13 {14if(A[min_b] > A[j])15 min_b = j;1617 }18 temp = A[i];19 A[i] = A[min_b];20 A[min_b] = temp;21 }22return A;23 }24 };三，插⼊排序思想：对于数组A[n]，保证前⾯的A[0]~A[m]是排序好的，再把A[m+1]插⼊到前⾯排好序的序列中，m递增，知道m=n-2⽰意图：原始序列为：6和5⽐较，6⽐5⼤，要交换接下来把3插⼊到前⾯排好序的序列中，⾸先3和6⽐，6⼤，后移⼀位接着3和5⽐较，5⼤，后移⼀位只到前⾯没有数了，或者前⾯的数⽐要插⼊的数⼩，就在对应的位置插⼊该数再对1执⾏以上步骤重复以上步骤，只到整个序列排序完成时间复杂度：O(n^2)空间复杂度：O(1)代码1class InsertionSort {2public:3int* insertionSort(int* A, int n)4 {5// write code here6int temp;7for(int i = 1; i < n; i ++)8 {9 temp = A[i];10for(int j = i - 1; j >= 0; j--)11 {12if(temp < A[j])13 {14 A[j + 1] = A[j];15if(j == 0)16 {17 A[j] = temp;18 }19 }20else21 {22 A[j + 1] = temp;23break;24 }25 }26 }27return A;28 }29 };四，归并排序思想：对数组中每个数看成是长度为1的有序区间，接着合并相邻两个长度为1的有序区间，变为长度为2的有序区间，接着合并相邻长度为2的有序区间变成长度为4的有序区间，依次进⾏，只到排序完成⽰意图：⾸先为长度为1的有序区间合并为长度为2的有序区间合并为长度为4的有序区间合并为长度为8的有序区间，排序完成时间复杂度：O(nlogn)空间复杂度：O(N)代码1class MergeSort {2public:3int* mergeSort(int* A, int n)4 {5 mergeSort(A,0,n-1);6return A;78 }9void mergeSort(int* A, int left, int right)10 {11if(left == right)12return;13int mid=(left+right)/2;14 mergeSort(A,left,mid);15 mergeSort(A,mid+1,right);16 merge_p(A,left,mid,right);17return;18 }1920void merge_p(int* A, int left, int mid, int right)21 {22int* temp = new int[right - left + 1];23int l = left;24int r = mid + 1;25int k = 0;26while(l <= mid && r <= right)27 {28if(A[l] < A[r])29 temp[k++] = A[l++];30else31 temp[k++] = A[r++];32 }33while(l <= mid)34 temp[k++] = A[l++];35while(r <= right)36 temp[k++] = A[r++];37for(int i = 0; i < k; i++)38 {39 A[left + i] = temp[i];40 }41 }4243 };五，快速排序思想：随机选择数组中的数，⼩于等于这个数的放在左边，⼤于这个数的放在右边，递归调⽤以上步骤，完成排序⽰意图：⾸先随机选择，划分区间递归调⽤，即可完成排序。

排序算法总结

排序算法总结排序算法是计算机科学中最基础且常用的算法之一。

它们的作用是将一组数据按照指定的顺序进行排列。

根据数据量的大小和特点，选择适合的排序算法可以提高程序的性能。

常见的排序算法有冒泡排序、插入排序、选择排序、希尔排序、归并排序、快速排序、堆排序和计数排序等。

冒泡排序是最简单、最直观的排序算法。

它通过多次比较相邻的元素，将较大的数往后移动，将较小的数往前移动，从而实现排序。

但是冒泡排序的时间复杂度较高，为O(n^2)。

插入排序的思想是将数组分为有序区和无序区，每次将无序区的第一个元素插入到有序区的合适位置。

它的时间复杂度也为O(n^2)，但在实际应用中对小规模数据进行排序时表现良好。

选择排序每次从数组中选择最小的元素，与数组的第一个元素交换位置，然后从剩下的元素中选择最小的元素，与数组的第二个元素交换位置，依此类推。

它的时间复杂度也为O(n^2)，但它的交换次数相对较少。

希尔排序是直接插入排序的改进版，它将数组按照一定的步长进行分组，对每组进行插入排序，然后缩小步长，直到步长为1，最后再进行一次插入排序。

希尔排序的时间复杂度介于O(n^1.3)和O(n^2)之间，具体取决于步长的选择。

归并排序是一种稳定且分治的排序算法，它将数组分为两个子数组，分别对子数组进行排序，然后将排好序的子数组合并成一个有序的数组。

归并排序的时间复杂度为O(nlogn)，但需要额外的空间来存储临时数组。

快速排序是一种高效且不稳定的排序算法，它通过选取一个基准元素，将数组分为左右两个子数组，使得左边的元素都小于等于基准元素，右边的元素都大于等于基准元素，然后在左右子数组中递归地进行快速排序。

快速排序的时间复杂度为O(nlogn)，但在最坏情况下可能达到O(n^2)。

堆排序利用堆这种数据结构进行排序。

堆排序的思想是将数组构建成一个最大堆或最小堆，然后将堆顶的元素与数组的最后一个元素交换位置，再对剩余的元素进行调整，再重复执行这个过程。

C语言课程设计---各种排序算法的设计和分析

C语言课程设计各种排序算法的设计和分析华中科技大学文华学院11级课程设计华中科技大学文华学院数据结构课程设计学号： __________________________学部：信息科学与技术学部专业： ________________班级： ___________________题目：各种排序算法的设计和分析教师:2013年03月07日一.课程设计报告的内容1.设计题目2.运行环境（软、硬件环境）3.算法设计的思想4.算法的流程图5.算法设计分析6.源代码7.运行结果分析&收获及体会二・《数据结构》课程设计题目各种排序算法的设计和分析1.设计题目⑴、需求分析利用随机函数产生N个随机整数（N=4000）,利用直接插入排序、折半插入排序，起泡排序、快速排序、选择排序、堆排序，基数排序七种排序方法（可添加其它排序方法）进行排序（结果为由小到大的顺序），并统计每一种排序所耗费的时间。

把排序花的时间排在表格里面。

（2人程序的主要功能1・用户输入任意个数，产生相应的随机数2•用户可以自己选择排序方式（直接插入排序、折半插入排序、起泡排序、快速排序、选择排序、堆排序、基数排序）的一种3 •程序给出原始数据、排序后从小到大的数据，并给出排序所用的时间。

（3）.程序运行平台Visual C++ 6.0 版本⑷、数据结构（5）、算法及时间复杂度（一）各个排序是算法思想：（1）直接插入排序：将一个记录插入到已排好的有序表中，从而得到一个新的，记录数增加1的有序表。

(2)折半插入排序：插入排序的基本插入是在一个有序表中进行查找和插入，这个查找可利用折半查找来实现，即为折半插入排序。

(3)起泡排序：首先将第一个记录的关键字和第二个记录的关键字进行比较，若为逆序，则将两个记录交换，然后比较第二个记录和第三个记录的关键字。

依此类推，直到第N-1和第N个记录的关键字进行过比较为止。

上述为第一趟排序，其结果使得关键字的最大纪录被安排到最后一个记录的位置上。

【十大经典排序算法(动图演示)】必学十大经典排序算法

【十大经典排序算法（动图演示）】必学十大经典排序算法0.1 算法分类十种常见排序算法可以分为两大类：比较类排序：通过比较来决定元素间的相对次序，由于其时间复杂度不能突破O(nlogn)，因此也称为非线性时间比较类排序。

非比较类排序：不通过比较来决定元素间的相对次序，它可以突破基于比较排序的时间下界，以线性时间运行，因此也称为线性时间非比较类排序。

0.2 算法复杂度0.3 相关概念稳定：如果a原本在b前面，而a=b，排序之后a仍然在b的前面。

不稳定：如果a原本在b的前面，而a=b，排序之后a 可能会出现在b 的后面。

时间复杂度：对排序数据的总的操作次数。

反映当n变化时，操作次数呈现什么规律。

空间复杂度：是指算法在计算机内执行时所需存储空间的度量，它也是数据规模n的函数。

1、冒泡排序（Bubble Sort）冒泡排序是一种简单的排序算法。

它重复地走访过要排序的数列，一次比较两个元素，如果它们的顺序错误就把它们交换过来。

走访数列的工作是重复地进行直到没有再需要交换，也就是说该数列已经排序完成。

这个算法的名字由来是因为越小的元素会经由交换慢慢“浮”到数列的顶端。

1.1 算法描述比较相邻的元素。

如果第一个比第二个大，就交换它们两个；对每一对相邻元素作同样的工作，从开始第一对到结尾的最后一对，这样在最后的元素应该会是最大的数；针对所有的元素重复以上的步骤，除了最后一个；重复步骤1~3，直到排序完成。

1.2 动图演示1.3 代码实现1.unction bubbleSort(arr) {2. varlen = arr.length;3. for(vari = 0; i arr[j+1]) {// 相邻元素两两对比6. vartemp = arr[j+1];// 元素交换7. arr[j+1] = arr[j];8. arr[j] = temp;9. }10. }11. }12. returnarr;13.}2、选择排序（Selection Sort）选择排序(Selection-sort)是一种简单直观的排序算法。

算法与程序设计知识点

算法与程序设计知识点算法与程序设计知识点1. 算法的定义和特性算法是指解决问题的一系列清晰而有序的操作步骤。

算法具有输入和输出。

算法应该是确定性的，即给定相同的输入，应该得到相同的输出。

算法必须在有限的时间内结束。

2. 时间复杂度和空间复杂度时间复杂度是指算法运行所需要的时间量度，一般用大O符号表示。

空间复杂度是指算法运行所需要的存储空间量度，也用大O符号表示。

3. 常用的算法和数据结构排序算法：冒泡排序、插入排序、选择排序、快速排序、归并排序等。

查找算法：线性查找、二分查找、哈希查找等。

数据结构：数组、链表、栈、队列、树、图等。

4. 编程语言的选择C语言：适合系统级编程和底层开发。

C++：在C语言的基础上增加了面向对象的特性。

Java：适合跨平台开发，拥有强大的面向对象特性。

：简洁易学的脚本语言，适合快速开发。

5. 常用的编程技巧分而治之：将问题分解为更小的子问题进行求解，然后将结果合并。

动态规划：将问题分解为重叠子问题，通过保存中间结果来优化计算。

贪心算法：每一步都选择当前最优解，不进行回退。

回溯算法：穷举所有可能的解，找到满足条件的解。

6. 算法优化和复杂度分析循环不变式：在循环过程中保持某个条件成立，可以帮助理解算法的正确性。

空间换时间：通过增加额外的存储空间来减少运行时间。

复杂度分析：通过时间复杂度和空间复杂度来评估算法的效率。

7. 程序调试和错误处理调试工具：使用断点、日志、调试器等工具来跟踪程序执行过程。

异常处理：使用try-catch语句来捕获和处理异常。

错误处理：使用返回值、错误码、异常等方式来处理错误情况。

8. 算法与数据结构的应用图像处理：使用算法和数据结构来处理图像，如滤波、边缘检测等。

文本处理：使用算法和数据结构来处理文本，如字符串匹配、自然语言处理等。

数据挖掘：使用算法和数据结构来发现和分析大量数据中的隐藏关系。

：使用算法和数据结构来实现智能决策和学习能力。

以上是一些算法与程序设计的基本知识点，希望对你有所帮助！。

八大排序

八大排序算法排序的基本概念排序是将一批(组)任意次序的记录重新排列成按关键字有序的记录序列的过程。

排序算法有许多，但就全面性能而言，还没有一种公认为最好的。

每种算法都有其优点和缺点，分别适合不同的数据量和硬件配置。

评价排序算法的标准有：执行时间和所需的辅助空间，其次是算法的稳定性。

若排序算法所需的辅助空间不依赖问题的规模n，即空间复杂度是O(1) ，则称排序方法是就地排序，否则是非就地排序。

排序的分类待排序的记录数量不同，排序过程中涉及的存储器的不同，有不同的排序分类。

① 待排序的记录数不太多：所有的记录都能存放在内存中进行排序，称为内部排序；② 待排序的记录数太多：所有的记录不可能存放在内存中，排序过程中必须在内、外存之间进行数据交换，这样的排序称为外部排序。

内部排序的基本操作对内部排序地而言，其基本操作有两种：◆ 比较两个关键字的大小；◆ 存储位置的移动：从一个位置移到另一个位置。

第一种操作是必不可少的；而第二种操作却不是必须的，取决于记录的存储方式，具体情况是：① 记录存储在一组连续地址的存储空间：记录之间的逻辑顺序关系是通过其物理存储位置的相邻来体现，记录的移动是必不可少的；② 记录采用链式存储方式：记录之间的逻辑顺序关系是通过结点中的指针来体现，排序过程仅需修改结点的指针，而不需要移动记录；③ 记录存储在一组连续地址的存储空间：构造另一个辅助表来保存各个记录的存放地址(指针) ：排序过程不需要移动记录，而仅需修改辅助表中的指针，排序后视具体情况决定是否调整记录的存储位置。

①比较适合记录数较少的情况；而②、③则适合记录数较少的情况。

为讨论方便，假设待排序的记录是以①的情况存储，且设排序是按升序排列的；关键字是一些可直接用比较运算符进行比较的类型。

一交换类排序法所谓交换排序法是指借助数据元素之间互相交换进行排序的方法。

冒泡排序与快速排序法都属于交换类排序方法。

交换排序— 冒泡排序：基本思想：1.比较相邻的元素。

数据结构--排序算法介绍

数据结构--排序算法总结概述排序的分类：内部排序和外部排序内部排序：数据记录在内存中进行排序外部排序：因排序的数据量大，需要内存和外存结合使用进行排序这里总结的八大排序是属于内部排序：当n比较大的时候，应采用时间复杂度为（nlog2n）的排序算法：快速排序、堆排序或归并排序。

其中，快速排序是目前基于比较的内部排序中被认为最好的方法，当待排序的关键字是随机分布时，快速排序的平均时间最短。

———————————————————————————————————————————————————————————————————————插入排序——直接插入排序（Straight Insertion Sort）基本思想：将一个记录插入到已排序好的有序表中，从而得到一个新的，记录数增1的有序表。

即：先将序列的第1个记录看成一个有序的子序列，然后从第2个记录逐个进行插入，直至整个序列有序为止。

要点：设立哨兵，用于临时存储和判断数组边界直接插入排序示例：插入排序是稳定的，因为如果一个带插入的元素和已插入元素相等，那么待插入元素将放在相等元素的后边，所以，相等元素的前后顺序没有改变。

算法实现：[cpp]view plain copy1.#include<iostream>ing namespace std;3.4.void print(int a[], int n ,int i)5.{6. cout<<i<<":";7.for(int j= 0; j<8; j++){8. cout<<a[j] <<" ";9. }10. cout<<endl;11.}12.13.void InsertSort(int a[],int n)14.{15.int i,j,tmp;16.for(i=1;i<n;++i)17. {18.// 如果第i个元素大于第i-1个元素，直接插入19.// 否则20.// 小于的话，移动有序表后插入21.if(a[i]<a[i-1])22. {23. j=i-1;24. tmp=a[i]; // 复制哨兵，即存储待排序元素25. a[i]=a[i-1]; // 先后移一个元素26.while(tmp<a[j])27. {28.// 哨兵元素比插入点元素小，后移一个元素29. a[j+1]=a[j];30. --j;31. }32. a[j+1]=tmp; // 插入到正确的位置33. }34. print(a,n,i); // 打印每一趟排序的结果35. }36.}37.38.int main()39.{40.int a[8]={3,1,5,7,3,4,8,2};41. print(a,8,0); // 打印原始序列42. InsertSort(a,8);43.return 0;44.}分析：时间复杂度：O（n^2）———————————————————————————————————————————————————————————————————————插入排序——希尔排序（Shell Sort）基本思想：先将整个待排序的记录序列分割成为若干子序列，分别进行直接插入排序，待整个序列中的记录“基本有序”时，再对全体记录依次进行直接插入排序。

八大排序详解

八大排序详解八大排序算法包括插入排序、希尔排序、选择排序、冒泡排序、归并排序、快速排序、堆排序和基数排序。

1. 插入排序：这是一种简单直观的排序算法，其工作原理是通过构建有序序列，对于未排序数据，在已排序序列中从后向前扫描，找到相应位置并插入。

在插入过程中，如果待插入的元素与有序序列中的某个元素相等，则将待插入元素插入到相等元素的后面，因此插入排序是稳定的。

2. 希尔排序：也称递减增量排序算法，是插入排序的一种更高效的改进版本。

3. 选择排序：它的工作原理是首先在未排序序列中找到最小（或最大）元素，存放到排序序列的起始位置，然后再从剩余未排序元素中继续寻找最小（或最大）元素，然后放到已排序序列的末尾。

以此类推，直到所有元素均排序完毕。

4. 冒泡排序：这种排序算法会重复地遍历待排序的数列，一次比较两个元素，如果他们的顺序错误就把他们交换过来。

5. 归并排序：归并排序是一种采用分治法的排序算法。

它将待排序的序列分成若干个子序列，每个子序列单独进行排序，然后将已排序的子序列进行合并，得到最终的排序结果。

6. 快速排序：快速排序采用分治法进行排序。

在每一步中，它选择一个“基准”元素，并将数组分为两部分，其中一部分的所有元素都比基准元素小，另一部分的所有元素都比基准元素大。

然后，对这两部分独立地进行快速排序。

7. 堆排序：堆排序是一种树形选择排序，是对直接选择排序的有效改进。

堆是一种特殊的树形数据结构，它的每个父节点都大于或等于（小于或等于）其子节点（通常称为大顶堆或小顶堆）。

8. 基数排序：基数排序是一种非比较整数排序算法，其原理是将整数按位数切割成不同的数字，然后按每个位数分别比较。

以上就是八大排序算法的详解，这些算法各有特点和使用场景，可以根据实际情况选择合适的算法。

20191209-八大排序之基数排序

20191209-⼋⼤排序之基数排序1. 基数排序算法核⼼思想基数排序(radix sort)是⼀种只适⽤于数字或字母类型的排序⽅法，它检查数字或字母的每⼀位，将之分类，按照位数的特定顺序，来将元素排列。

以数字为例，将所有元素按照个位数字分类，分类好后，将个位数字⼤⼩排列组合起来，再按照⼗位数字分类，再按照数字⼤⼩排列组合起来，⼀直到最⼤数位为⽌。

基数排序分类基数排序的⽅式分为2类：1. LSD（Least significant digital）：LSD的排序⽅式由键值的最右边开始，先⽐较最低位，也就是个位，进⾏分桶，分桶过程中分到⼀个桶中的数据直接追加到桶中即可，⽆需排序。

然后将所有同种的元素按桶的顺序拿出，重新组成序列，然后⽐较⼗位，进⾏分桶…直到⽐较到最⾼位，重新组成序列即可完成排序。

2. MSD（Most significant digital）：由键值的最左边开始，先⽐较最⾼位，最⾼位分到⼀个桶中的，再按照第⼆位进⾏分桶…，知道分到最后⼀位，然后再从最⼩的桶中逐层向上，把元素都拿出来，即完成排序。

3. ⾸先确定待排序数组中值的最⼤位数，⽤于确定程序中要作⼏轮排序；4. 定义⼀个集合数组，数组⼤⼩⼗，对应⾓标范围0-9，⽤来保存每轮排序过程中对应的位数上的值；5. 每轮排序依次从原始数组中取值，并判断对应位数上的值，不⾜位数时在前⾯补上相应的0，然后放到对应⾓标的桶内；6. 每轮排序后，按⾓标⼤⼩依次取出不为空的桶内的值，合并成为⼀个部分排序后的新数组；7. 将上述部分排序后的新数组作为下⼀轮⾼⼀位位数上的值排序的原始数组，重复上述排序的步骤，直到⽣成最终排好序的数组。

LSD具体逻辑如下：MSD具体逻辑如下：从最⾼位数上的值开始排序，⼀轮排序结束后，并没有急着合并整理，⽽是判断每个桶内的元素，如果桶内的元素⼤于1个则继续对当前桶进⾏排序，直到排到最低位数上的值，最终做⼀次性合并整理，形成排序后的数组。

常用的排序算法总结

常用的排序算法总结排序算法是计算机科学中的一项基本算法，它用于将一组数据按照一定的顺序进行排列。

常用的排序算法有多种，每种算法都有其特点和适用的场景。

下面将对常用的排序算法进行总结。

首先，插入排序是最基本的排序算法之一。

它的思想是从待排序的数据中逐个选择一个元素，并将其插入到已排序的序列中的合适位置。

插入排序的时间复杂度为O(n^2)，对于小规模的数据来说，其性能还是相对较好的。

其次，选择排序也是一种简单且直观的排序算法。

它的思想是每次从待排序的数据中选择最小（或最大）的元素，并放到已排序序列的末尾。

选择排序的时间复杂度也是O(n^2)，但相比插入排序，它少了一些元素比较和交换的操作，因此在某些情况下，选择排序可能更适合。

再次，冒泡排序是一种交换排序算法。

它的思想是依次比较相邻的两个元素，如果顺序不对，则交换它们的位置。

在每一轮的遍历过程中，最大（或最小）的元素会被交换到序列的末尾。

冒泡排序的时间复杂度也是O(n^2)，但相对于选择排序和插入排序来说，它的性能较差。

此外，快速排序是一种常用且高效的排序算法。

它采用了分治的思想，通过递归地将序列划分为较小的子序列，并将子序列分别排序，最终合并起来得到有序序列。

快速排序的平均时间复杂度为O(nlogn)，但在最坏情况下，时间复杂度可能达到O(n^2)。

另外，归并排序也是一种常用的排序算法。

它也是基于分治的思想，将序列划分为较小的子序列，然后分别对子序列进行排序，最后将排好序的子序列进行合并。

归并排序的时间复杂度始终为O(nlogn)，并且它是一种稳定的排序算法。

还有，堆排序是一种利用二叉堆进行排序的算法。

它的思想是将待排序的数据看成是完全二叉树，并将其构建成一个最大（或最小）堆。

然后，每次将堆顶的元素移出，并调整堆使得剩下的元素仍然构成最大（或最小）堆。

堆排序的时间复杂度也是O(nlogn)，并且它可以原地排序，不需要额外的空间。

最后，计数排序和桶排序是两种线性时间复杂度的排序算法。

八种排序方法

⼋种排序⽅法⼀.直接（选择）插⼊排序有两种⽅式：升序和降序我使⽤升序直接（简单）插⼊排序：每次向已经排序好的队列⾥⾯找个合适的位置，将值插⼊//笔试和⾯试：//1.算法的描述 2.算法的实现 3.效率（时间复杂度和空间复杂度和稳定性）//稳定性定义：如果两个关键值A和A`,如果⼀开始A就在A`前⾯，你排序后A还在A`前⾯，我们就认为是稳定的//怎么看稳定性：看有没有跳跃交换直接插⼊排序：如果数组基本有序，我们就⽤直接插⼊排序，越有序，时间复杂度越⼩，极端情况下为O（n）时间复杂度O（n^2）空间复杂度O（1），稳定的为什么不⽤从前向后找：如果数组有序，则时间复杂度太⼤具体代码实现：#include <stdio.h>#include <assert.h>void InsertSort(int arr[], int len){//循环多少次个数-1//⽤临时量tmp保存关键值，从后向前找，⽐它⼩的或者⾛到了头，就将关键值放到下⼀个位置上assert(arr != NULL);if (NULL == arr)return;int count = 0;int tmp = 0;int j = 0;for (int i = 1; i < len; i++)//控制揭牌后需要排序的次数{tmp = arr[i];for (j = i - 1; j >= 0; j--)//从后向前找{if (arr[j] > tmp)//⽐关键值⼤，则向后移动{arr[j + 1] = arr[j];count++;}else{break;//找到了⽐它⼩的值退出}}arr[j + 1] = tmp;}printf("count %d\n", count);}void Show(int* arr, int len){assert(arr != NULL);if (NULL == arr)return;for (int i = 0; i < len; i++){printf("%d ", arr[i]);}printf("\n");}int main(){int arr[] = { 2,4,6,8,23,98,76,56,74,36,1,3,5,7,99,66,77,88 };InsertSort(arr, sizeof(arr) / sizeof(arr[0]));Show(arr, sizeof(arr) / sizeof(arr[0]));return0;}希尔shell排序：就是⼀种特殊的直接插⼊排序，只不过调⽤了很多次直接插⼊排序，按增量分组要求：增量最后⼀个必须为1，增量保持互素时间复杂度O（n^1.3~1.5），空间复杂度O(1) ，稳定性：发⽣了跳跃交换，所以不稳定例如：分成5组，处理之后的值：分成3组，处理之后的值：最后分成1组，处理之后的值：具体代码实现：#include <stdio.h>#include <assert.h>static void Shell(int arr[], int len, int gap)//gap 分成多少组（间隔）{int tmp = 0;int j = 0;int count = 0;for (int i = gap; i < len; i++)//i开始的位置{tmp = arr[i];for (j = i - gap; j >= 0; j = j - gap){if (arr[j] > tmp){arr[j + gap] = arr[j];count++;}else{break;}}arr[j + gap] = tmp;}printf("%d count %d\n", gap, count);}void ShellSort(int arr[], int len){assert(arr != nullptr);if (NULL == arr)return;int dk[] = { 5, 3, 1 };for (int i = 0; i < sizeof(dk) / sizeof(dk[0]); i++){Shell(arr, len, dk[i]);}}void Show(int* arr, int len){assert(arr != NULL);if (NULL == arr)return;for (int i = 0; i < len; i++){printf("%d ", arr[i]);}printf("\n");}int main(){int arr2[] = { 2,4,6,8,23,98,76,56,74,36,1,3,5,7,99,66,77,88 };ShellSort(arr2, sizeof(arr2) / sizeof(arr2[0]));Show(arr2, sizeof(arr2) / sizeof(arr2[0]));return0;}⼆.交换排序冒泡（沉⽯）排序：两两⽐较，⼤的向后挪，⼩的向前挪时间复杂度O（n^2）空间复杂度O（1）稳定的具体代码实现：//冒泡排序：两两⽐较，⼤的向后挪void BubbleSort(int arr[], int len){//assert/*int count=0;bool tag = true;*/int tmp = 0;for(int i=0; i<len-1; i++)//次数{//tag = true;for(int j=0;j+1<len-i; j++)//两两⽐较，⼤的向后挪{if(arr[j] > arr[j+1]){tmp = arr[j];arr[j] = arr[j+1];arr[j+1] = tmp;//tag = false;}//count++;}/*if(tag){break;}*/}//printf("count = %d\n", count);}int main(){int arr[] = {2,4,6,8,23,98,76,56,74,36,1,3,5,7,99,66,77,88};BubbleSort(arr, sizeof(arr)/sizeof(arr[0]));Show(arr, sizeof(arr)/sizeof(arr[0]));return 0;}快速排序法每次找到基准值，以基准值为分界线，将数据分成两块，左边的数据都⽐基准值⼩，右边的数据都⽐基准值⼤快速排序，越有序越慢，规则:1.从右向左找⽐基准值⼩的数据，找到后，向左挪动2.从左向右找⽐基准值⼤的数据，找到后，向右挪动3.重复1，2，直到left == right，结束，将基准值放到arr[left] 或者arr[right]内缺点：越有序越慢，不稳定具体实现代码：#include<stdio.h>#include<assert.h>static int Partition(int arr[], int left, int right){int tmp = arr[left];while (left < right)//进来保证有两个值{while(left < right && arr[right] > tmp)right--;if(left == right){break;}arr[left] = arr[right];while(left < right && arr[left] <= tmp)left++;if(left == right){break;}arr[right] = arr[left];}arr[left] = tmp;//arr[right] = tmp;return left;//return right; 因为此时left == right}static void Quick(int arr[], int left, int right){if(left < right){//第⼀种优化：如果有效个数特别少，直接调⽤直接插⼊排序/*if(right-left+1<20 ) //⾃⼰设置有效个数{Insertsort(arr,left, high)return;} // Insertsirt表⽰⼀个插⼊排序类*///第⼆种优化：三数取中/*GetMiddleNumber(arr,left,mid,right);*///第三种优化：防⽌完全有序，⾃⼰打乱⼀下/*Swap(arr,start,rand()%(right-left+1)+start;*///第四种/*if(left < right){int midindex = Partition(arr, left, right);if(left < midindex-1){Quick(arr, left, midindex-1);}if(midindex+1 < right){Quick(arr, midindex+1, right);}}*/int midindex = Partition(arr, left, right);Quick(arr, left, midindex-1);Quick(arr, midindex+1, right);}}//⽤栈static void Quick_stack(int arr[], int left, int right){stack<int> st;if (left < right){int midindex = Partition(arr, left, right);if (left < midindex - 1){st.push(left);st.push(midindex - 1);}if (midindex + 1 < right){st.push(midindex + 1);st.push(right);}}while (!st.empty()){int q = st.top();st.pop();int p = st.top();st.pop();int midindex = Partition(arr, p, q);if (p < midindex - 1){st.push(p);st.push(midindex - 1);}if (midindex + 1 < q){st.push(midindex + 1);st.push(q);}}}void QuickSort(int arr[], int len)//时间复杂度O（nlogn）空间复杂度O（1）不稳定{//assertQuick_stack(arr, 0, len-1);}第⼀种优化代码：void InsertSort(int arr[], int left, int right){int tmp = arr[left];for (int i = left + 1; i <= right; i++){tmp = arr[i];int j = i - 1;while (j >= right && arr[i] > tmp){arr[j + 1] = arr[j];j--;}arr[j + 1] = tmp;}}第⼆种优化代码：void GetMiddleNumber(int arr[], int left, int right){if (arr[left] > arr[right]){Swap(arr, left, right);//交换左右端数据，保证左端较⼩}if (arr[mid] > arr[right]){Swap(arr, left, right);//交换中间和右边，保证中间较⼩}if (arr[mid] > arr[left]){Swap(arr, left, right);//交换中间和左端数据，保证左边不是最⼩的那⼀个}}第三种优化代码：Swap(arr, left, rand() % (end - start + 1) + start);//取⼀个⼩于有效长度随机值+最左端值的下标作为随机基准值的下标与start进⾏交换三.选择排序直接选择（简单选择排序）：每次从待排序队列中找到最⼩值，和待排序队列的第⼀位交换即可时间复杂度O（n^2）空间复杂度O（1）不稳定的具体实现代码：#include<stdio.h>#include<assert.h>void SelectSort(int arr[], int len){assert(arr != NULL);if (NULL == NULL)return;int tmp = 0;for (int i = 0; i < len - 1; i++){int m= i;//存放最⼩值下标for (int j = i + 1; j < len ; j++){if (arr[j] <arr[m]){m = j;}}if (m != i)//if判断可省略{tmp = arr[m];arr[m] = arr[i];arr[i] = tmp;}}}void Show(int* arr, int len){assert(arr != NULL);if (NULL == arr)return;for (int i = 0; i < len; i++){printf("%d ", arr[i]);}printf("\n");}int main(){int arr[] = { 2,4,6,8,23,98,76,56,74,36,1,3,5,7,99,66,77,88 };SelectSort(arr, sizeof(arr) / sizeof(arr[0]));Show(arr, sizeof(arr) / sizeof(arr[0]));return 0;}堆排序：堆排序的时间复杂度O（nlogn）空间复杂度O（1）不稳定什么是堆？堆分为两种：⼤顶堆和⼩顶堆两个统称为堆⼤顶堆：⼀个⼆叉树，⽗节点的值⼤于⼦节点的值⼩顶堆：⼀个⼆叉树，⽗节点的值⼩于⼦节点的值什么是树形结构：⼆叉树，树根，深度，叶⼦结点，左孩⼦，右孩⼦，完全⼆叉树，满⼆叉树深度怎么求：log2n+1⼤顶堆和⼩顶堆的关系，和兄弟节点的值⽆关，只和⽗⼦节点有关调整2个要点：1.从最后⼀个⾮叶⼦节点⼦树开始从后向前调整2.调整的时候顺序是从上向下3.升序(⼤顶堆)，降序（⼩顶堆）具体实现代码：#include<stdio.h>#include<assert.h>static void HeapAdjust(int arr[], int start, int end)//时间复杂度O（log2n）空间复杂度O（1）{int tmp = arr[start];for(int i=2*start+1; i<=end; i=i*2+1)//i? 堆排序效率⾼体现在这⾥i=i*2+1{//1.左右孩⼦都存在//2.只有左孩⼦，没有右孩⼦if(i<end && arr[i] < arr[i+1])//通过i<end保证右孩⼦存在，且arr[i] <arr[i+1]保证左孩⼦⼩于右孩⼦ {i++;//这时候让i指向较⼤的右孩⼦下标}//if判断失败的话，要么没有右孩⼦，要么有右孩⼦但是左孩⼦⽐右孩⼦值⼤，所以i不需要改变if(arr[i] > tmp)//判断较⼤孩⼦节点的值是否⽐⽗节点的值⼤，⼤的话向上覆盖，不然就找到了合适位置 {arr[start] = arr[i];start = i;}else{break;//左右孩⼦中较⼤的孩⼦值⼩于tmp}}arr[start] = tmp;//有两种情况执⾏到这⼀⾏代码：1.触底 2.找到放tmp的合适位置}//堆排序的时间复杂度O（nlog2n）空间复杂度O（1）不稳定void HeapSort(int arr[], int len){//assert//2.调整为⼤顶堆for(int i=(len-1-1)/2; i>=0; i--)//O（nlog2n）{HeapAdjust(arr, i, len-1);//}//第⼀个for循环⾛出来，这时已经为⼤顶堆了int tmp = 0;for(int j=0; j<len-1; j++)//j指的是循环的次数（顶部数据和最后⼀个节点交换的次数）//O（nlog2n）{//3.将顶部数据和最后⼀个节点进⾏了交换tmp = arr[0];arr[0] = arr[len-1-j];arr[len-1-j] = tmp;//已经将顶部数据和最后⼀个节点进⾏了交换 //4.重复2.3操作HeapAdjust(arr, 0, (len-1-j)-1);}}void Show(int* arr, int len){assert(arr != NULL);if (NULL == arr)return;for (int i = 0; i < len; i++){printf("%d ", arr[i]);}printf("\n");}int main(){int arr[] = { 2,4,6,8,23,98,76,56,74,36,1,3,5,7,99,66,77,88 };HeapSort(arr, sizeof(arr) / sizeof(arr[0]));Show(arr, sizeof(arr) / sizeof(arr[0]));return0;}四.⼆路归并排序⼆路归并排序，⾮递归形式：将两个有序的段合并成⼀个有序的段，直到全部数据在同⼀个段内有序，则完成有序时间复杂度O（n log2n）空间复杂度O（1）稳定的具体代码实现：//⼀次归并以gapgap合并static void Merge(int arr[], int len, int gap)//gap 标志⼏⼏合并{int *brr = (int*)malloc(sizeof(int) * len);assert(brr != NULL);int low1 = 0;int high1 = low1 + gap -1;int low2 = high1 + 1;int high2 = low2+gap-1<len ? low2+gap-1 : len-1;//H2 有可能越界若⼩于则low2+gap-1,不是则len-1int i = 0;while(low2 < len)//有两个有序段{while(low1 <= high1 && low2 <= high2)//两个段内头指针都没⾛到尾巴{if(arr[low1] <= arr[low2]){brr[i++] = arr[low1++];}else{brr[i++] = arr[low2++];}}//左边的段⾛到尾，那直接将右边的段内数据向下拷贝到brr内即可while(low2 <= high2){brr[i++] = arr[low2++];}//右边的段⾛到尾，那直接将左边的段内数据向下拷贝到brr内即可while(low1 <= high1){brr[i++] = arr[low1++];}//更改L1L2 H1H1,让指向接下来的两个有序段即可low1 = high2 + 1;high1 = low1+gap-1;low2 = high1 + 1;high2 = low2+gap-1<len ? low2+gap-1 : len-1;}//只有⼀个有序段while(low1 < len){brr[i++] = arr[low1++];}//将brr⾥的全部值拷贝到arr⾥⾯，然后将brr释放for(int j=0; j<len; j++){arr[j] = brr[j];}free(brr);brr = NULL;}void MergeSort(int arr[], int len)//控制合并次数{assert(arr != NULL);if(NULL == arr)return;for(int i=1; i<len; i*=2){Merge(arr, len, i);}}int main(){int arr[] = {2,4,6,8,23,98,76,56,74,36,1,3,5,7,99,66,77,88};MergeSort(arr, sizeof(arr)/sizeof(arr[0]));Show(arr, sizeof(arr)/sizeof(arr[0]));return0;}五.基数排序⼜称桶排序低位优先，所有数据从低位（个）位开始，依次放⼊到对应的⼗个桶内（队列中），再依次从桶中将数据依次取出（出队），直到所有数据循环次数和最⼤位数有关时间复杂度o(n) , 空间复杂度o(n)此时完全有序具体实现代码：#include<stdio.h>#include<assert.h>//基数排序//获取数组中最⼤值的位数static int Get_Figure(int arr[], int len) {int max = 0;for(int i=0; i<len; i++){if(arr[i] > max){max = arr[i];}}int count = 0;while(max != 0)max /= 10;}return count;}//获取n的第fin位的值//1234，2 = 2//234，0 = 4//12345，4 = 1//12345，7 = 0static int Get_num(int n, int fin){for(int i=0; i<fin; i++){n = n / 10;}return n % 10;//return n/(int)(pow((double)10, fin)) % 10;}//⽤⼆维数组调⽤static void Radix(int arr[], int len, int fin)//⼆维数组 fin判断的依据，到底是以什么位排序//时间复杂度O（n）空间复杂度O（n）{int bucket[10][20] = {0};//桶int num[10] = {0};//对应的桶中有多少个有效值//所有的数据都以fin位为依据，放到了桶内for(int i=0; i<len; i++)//数组的下标从0开始放{int index = Get_num(arr[i], fin);//获取arr[i]的fin位的值，找到对应的桶bucket[index][num[index]] = arr[i];//放到对⽤的桶中第num[index]位上num[index]++;//对应的桶中有效个数++}//从0-9桶内依次取值到arr⾥int k = 0;for(int i=0; i<10; i++)//⼏号桶{for(int j=0; j<num[i]; j++)//j桶中有效值个数{arr[k++] = bucket[i][j];}}}//⽤链式队列调⽤static void Radix_queue(int arr[], int len, int fin)//时间复杂度O（n）空间复杂度O（n）{LQueue queArr[10];for(int i=0; i<10; i++){InitLQueue(&queArr[i]);}for(int i=0; i<len; i++){int index = Get_num(arr[i], fin);Push(&queArr[index], arr[i]);}int k = 0;for(int i=0; i<10; i++){while(!IsEmpty(&queArr[i])){Pop(&queArr[i], &arr[k++]);}}for(int i=0; i<10; i++){Destroy(&queArr[i]);}}void RadixSort(int arr[], int len)//时间复杂度O（dn）空间复杂度（n）稳定{//assertint count = Get_Figure(arr, len);for(int i=0; i<count; i++)//循环的趟数，低位优先{Radix_queue(arr, len, i);}。

数据结构之——八大排序算法

数据结构之——⼋⼤排序算法排序算法⼩汇总冒泡排序⼀般将前⾯作为有序区（初始⽆元素），后⾯作为⽆序区（初始元素都在⽆序区⾥），在遍历过程中把当前⽆序区最⼩的数像泡泡⼀样，让其往上飘，然后在⽆序区继续执⾏此操作，直到⽆序区不再有元素。

这块是对⽼式冒泡排序的⼀种优化，因为当某次冒泡结束后，可能数组已经变得有序，继续进⾏冒泡排序会增加很多⽆⽤的⽐较次数，提⾼时间复杂度。

所以我们增加了⼀个标识变量flag，将其初始化为1，外层循环还是和⽼式的⼀样从0到末尾，内存循环我们改为从最后⾯向前⾯i（外层循环所处的位置）处遍历找最⼩的，如果在内存没有出现交换，说明⽆序区的元素已经变得有序，所以不需要交换，即整个数组已经变得有序。

(感谢@站在远处看童年在评论区的指正)#include<iostream>using namespace std;void sort(int k[] ,int n){int flag = 1;int temp;for(int i = 0; i < n-1 && flag; i++){flag = 0;for(int j = n-1; j > i; j--){/*下⾯这⾥和i没关系，注意看这块，从下往上travel，两两⽐较，如果不合适就调换，如果上来后⼀次都没调换，说明下⾯已经按顺序拍好了，上⾯也是按顺序排好的，所以完美！*/if(k[j-1] > k[j]){temp = k[j-1];k[j-1] = k[j];k[j] = temp;flag = 1;}}}}int main(){int k[3] = {0,9,6};sort(k,3);for(int i =0; i < 3; i++)printf("%d ",k[i]);}快速排序（Quicksort），基于分治算法思想，是对冒泡排序的⼀种改进。

快速排序由C. A. R. Hoare在1960年提出。

图解八大排序算法——我见过的最详细的讲解（转）

图解⼋⼤排序算法——我见过的最详细的讲解（转）⼀、分类1.内部排序和外部排序　内部排序：待排序记录存放在计算机随机存储器中（说简单点，就是内存）进⾏的排序过程。

外部排序：待排序记录的数量很⼤，以致于内存不能⼀次容纳全部记录，所以在排序过程中需要对外存进⾏访问的排序过程。

2.⽐较类排序和⾮⽐较排序⽐较类排序：通过⽐较来决定元素间的相对次序，由于其时间复杂度不能突破O(nlogn)，因此也称为⾮线性时间⽐较类排序。

⾮⽐较类排序：不通过⽐较来决定元素间的相对次序，它可以突破基于⽐较排序的时间下界，以线性时间运⾏，因此也称为线性时间⾮⽐较类排序。

⼆、复杂度分析，算法稳定性和适⽤场景稳定：如果a原本在b前⾯，⽽a=b，排序之后a仍然在b的前⾯。

不稳定：如果a原本在b的前⾯，⽽a=b，排序之后 a 可能会出现在 b 的后⾯。

时间复杂度：对排序数据的总的操作次数。

反映当n变化时，操作次数呈现什么规律。

空间复杂度：是指算法在计算机内执⾏时所需存储空间的度量，它也是数据规模n的函数。

三、⼋⼤排序算法详解1.选择排序1.1 动图演⽰1.2 思路分析1. 第⼀个跟后⾯的所有数相⽐，如果⼩于（或⼩于）第⼀个数的时候，暂存较⼩数的下标，第⼀趟结束后，将第⼀个数，与暂存的那个最⼩数进⾏交换，第⼀个数就是最⼩（或最⼤的数）2. 下标移到第⼆位，第⼆个数跟后⾯的所有数相⽐，⼀趟下来，确定第⼆⼩（或第⼆⼤）的数重复以上步骤直到指针移到倒数第⼆位，确定倒数第⼆⼩（或倒数第⼆⼤）的数，那么最后⼀位也就确定了，排序完成。

1.3 负杂度分析1. 不管原始数组是否有序，时间复杂度都是O（n2），因为没⼀个数都要与其他数⽐较⼀次，（n-1）2次，分解：n2-2n+1, 去掉低次幂和常数，剩下n2,所以最后的时间复杂度是n22. 空间复杂度是O（1）,因为只定义了两个辅助变量，与n的⼤⼩⽆关，所以空间复杂度为O（1）1.4 Java 代码如下：import java.util.Arrays;public class Main {public static void main(String[] args) {int[] n = new int[]{1,6,3,8,33,27,66,9,7,88};int temp,index = -1;for (int i = 0; i < n.length-1; i++) {index=i;//如果⼤于，暂存较⼩的数的下标for (int j = i+1; j <n.length; j++) {if(n[index]>n[j]){index = j;}}////将⼀趟下来求出的最⼩数，与这个数交换if(index>0){temp = n[i];n[i] = n[index];n[index] = temp;}System.out.println(Arrays.toString(n));}System.out.println(Arrays.toString(n));}}2. 冒泡排序2.1 动图演⽰2.2 思路分析1. 相邻两个数两两相⽐，n[i]跟n[j+1]⽐，如果n[i]>n[j+1]，则将连个数进⾏交换，2. j++, 重复以上步骤，第⼀趟结束后，最⼤数就会被确定在最后⼀位，这就是冒泡排序⼜称⼤（⼩）数沉底，3. i++,重复以上步骤，直到i=n-1结束，排序完成。

常见排序算法归纳总结

常见排序算法归纳总结排序算法是计算机科学中的重要基础知识，通过对一组数据进行排序，可以快速查找、统计和比较数据。

常见的排序算法包括冒泡排序、选择排序、插入排序、归并排序、快速排序等等。

本文将对这些常见排序算法进行归纳总结，以便读者更好地理解和应用这些算法。

一、冒泡排序（Bubble Sort）冒泡排序是一种简单直观的排序算法。

它的基本思想是重复地遍历要排序的序列，每次比较相邻的元素，如果顺序不对则交换它们。

经过一轮遍历，最大（或最小）的元素就会移动到序列的末尾，然后再对剩下的元素进行排序，直到整个序列有序。

冒泡排序的时间复杂度为O(n^2)，其中n为要排序的元素数量。

虽然冒泡排序算法简单，但是对于大规模数据的排序效率较低，通常用于教学和简单的排序场景。

二、选择排序（Selection Sort）选择排序是一种简单但低效的排序算法。

它的基本思想是在序列中找到最小（或最大）的元素，将其放到序列的起始位置，然后再在剩下的元素中寻找最小（或最大）的元素，放到已排序的子序列的末尾。

重复进行这个过程，直到整个序列有序。

选择排序的时间复杂度也为O(n^2)，它的交换次数较冒泡排序要少，因此在一些特殊场景下，选择排序可能会比冒泡排序稍微高效一些。

三、插入排序（Insertion Sort）插入排序是一种简单且稳定的排序算法。

它的基本思想是将待排序的序列分为两部分，一部分是已排序的序列，另一部分是未排序的序列。

每次从未排序的序列中取出一个元素，插入到已排序的序列中的合适位置，直到所有元素都插入完毕。

插入排序的时间复杂度也为O(n^2)，但是在某些特定情况下，插入排序的性能要优于冒泡排序和选择排序。

例如，当序列几乎有序时，插入排序的时间复杂度可以接近O(n)。

四、归并排序（Merge Sort）归并排序是一种高效的排序算法，它基于分治的思想。

它的基本思路是将待排序的序列一分为二，对每个子序列进行排序，然后将排好序的子序列合并，最终得到完全有序的序列。

排序算法详解

排序算法详解排序算法详解排序算法是计算机科学中最基本的算法之一。

它的主要目的是把一组无序的数据按照指定的顺序进行排列。

在实际开发中，经常需要对大量数据进行排序，因此选择一个高效的排序算法非常重要。

目前，排序算法可以分为两类：比较排序和非比较排序。

比较排序只能通过比较来确定两个数据之间的大小关系，而非比较排序则直接对数据进行一定的操作来实现排序。

常见的比较排序算法包括冒泡排序、插入排序、选择排序、归并排序和快速排序等。

冒泡排序是最简单的排序算法之一。

它通过反复交换相邻的两个元素，把最大的元素移到最后面，从而实现排序。

时间复杂度为O(n²)。

插入排序则是从前往后依次将元素插入到已排序的部分中。

时间复杂度也为O(n²)。

选择排序每次选择最小的元素，放在已排序数组的后面，直到把所有元素都排序完成。

时间复杂度也为O(n²)。

归并排序则采用分治的思想，将数组不断地分成两个子数组，然后将这两个子数组进行合并，最后得到一个有序的数组。

时间复杂度为O(nlogn)。

快速排序是一种常用的排序算法，也是分治思想的典型应用。

通过一趟排序将数组分成两部分，分别对这两部分进行递归排序，最后实现排序。

时间复杂度为O(nlogn)。

除了比较排序，还有非比较排序。

非比较排序包括计数排序、桶排序和基数排序。

计数排序先统计小于等于每个元素的个数，然后依次累加，最后把每个元素放到它的正确位置上。

时间复杂度为O(n+k)，其中k是最大值和最小值之差加1。

桶排序是将元素划分到不同的桶中，然后对每个桶进行排序，最后把所有桶中的元素依次取出来得到有序序列。

时间复杂度为O(n)，但需要额外的空间。

基数排序则通过将数字按位数切割成不同的数字，然后按每个位数分别比较进行排序，最后得到有序序列。

时间复杂度为O(d(n+r))，其中d是位数，n是元素个数，r是基数。

不同的排序算法各有优缺点，选择合适的排序算法取决于具体的应用场景。