下载文档原格式
排序算法所谓排序，就是使一串记录，按照其中的某个或某些关键字的大小，递增或递减的排列起来的操作。
排序算法，就是如何使得记录按照要求排列的方法。
排序算法在很多领域得到相当地重视，尤其是在大量数据的处理方面。
一个优秀的算法可以节省大量的资源。
在各个领域中考虑到数据的各种限制和规范，要得到一个符合实际的优秀算法，得经过大量的推理和分析。
分类排序(Sorting) 是计算机程序设计中的一种重要操作，它的功能是将一个数据元素(或记录)的任意序列，重新排列成一个关键字有序的序列。
稳定度(稳定性)一个排序算法是稳定的，就是当有两个相等记录的关键字R和S，且在原本的列表中R出现在S之前，在排序过的列表中R也将会是在S之前。
当相等的元素是无法分辨的，比如像是整数，稳定度并不是一个问题。
然而，假设以下的数对将要以他们的第一个数字来排序。
(4,1)(3,1)(3,7)(5,6)在这个状况下，有可能产生两种不同的结果，一个是依照相等的键值维持相对的次序，而另外一个则没有:(3,1)(3,7)(4,1)(5,6) (维持次序)(3,7)(3,1)(4,1)(5,6) (次序被改变)不稳定排序算法可能会在相等的键值中改变纪录的相对次序，但是稳定排序算法从来不会如此。
不稳定排序算法可以被特别地实现为稳定。
作这件事情的一个方式是人工扩充键值的比较，如此在其他方面相同键值的两个对象间之比较，就会被决定使用在原先数据次序中的条目，当作一个同分决赛。
然而，要记住这种次序通常牵涉到额外的空间负担。
在计算机科学所使用的排序算法通常被分类为:(a)计算的复杂度(最差、平均、和最好性能)，依据列表(list)的大小(n)。
一般而言，好的性能是O(nlogn)，且坏的性能是O(n^2)。
对于一个排序理想的性能是O(n)。
而仅使用一个抽象关键比较运算的排序算法总平均上总是至少需要O(nlogn)。
(b)存储器使用量(空间复杂度)(以及其他电脑资源的使用)(c)稳定度:稳定的排序算法会依照相等的关键(换言之就是值)维持纪录的相对次序。
⼗⼤经典排序算法总结最近⼏天在研究算法，将⼏种排序算法整理了⼀下，便于对这些排序算法进⾏⽐较，若有错误的地⽅，还请⼤家指正0、排序算法说明0.1 排序术语稳定：如果a=b,且a原本排在b前⾯，排序之后a仍排在b的前⾯不稳定：如果a=b,且a原本排在b前⾯，排序之后排在b的后⾯时间复杂度：⼀个算法执⾏所耗费的时间空间复杂度：⼀个算法执⾏完所需内存的⼤⼩内排序：所有排序操作都在内存中完成外排序：由于数据太⼤，因此把数据放在磁盘中，⽽排序通过磁盘和内存的数据传输才能进⾏0.2算法时间复杂度、空间复杂度⽐较0.3名词解释n:数据规模k:桶的个数In-place:占⽤常数内存，不占⽤额外内存Out-place:占⽤额外内存0.4算法分类1.冒泡排序冒泡排序是⼀种简单的排序算法。
它重复地⾛访过要排序的数列，⼀次⽐较两个元素，如果它们的顺序错误就把它们交换过来。
⾛访数列的⼯作是重复地进⾏直到没有再需要交换，也就是说该数列已经排序完成。
这个算法的名字由来是因为越⼩的元素会经由交换慢慢“浮”到数列的顶端1.1算法描述⽐较相邻的元素，如果前⼀个⽐后⼀个打，就交换对每⼀对相邻元素做同样的⼯作，从开始第⼀对到结尾最后⼀对，这样在最后的元素应该会是最⼤的数针对所有的元素重复以上的步骤，除了最后⼀个重复步骤1-3，知道排序完成1.2动图演⽰1.3代码实现public static int[] bubbleSort(int[] array) {if (array.length == 0)return array;for (int i = 0; i < array.length; i++)for (int j = 0; j < array.length - 1 - i; j++)if (array[j + 1] < array[j]) {int temp = array[j + 1];array[j + 1] = array[j];array[j] = temp;}return array;}1.4算法分析最佳情况：T(n) = O(n) 最差情况：T(n) = O(n2) 平均情况：T(n) = O(n2)2.选择排序表现简单直观的最稳定的排序算法之⼀，因为⽆论什么数据都是O(n2)的时间复杂度，⾸先在未排序序列中找到最⼩（⼤）元素，与数组中第⼀个元素交换位置，作为排序序列的起始位置，然后再从剩余未排序元素中继续寻找最⼩（⼤）的元素，与数组中的下⼀个元素交换位置，也就是放在已排序序列的末尾2.1算法描述1.初始状态：⽆序区为R[1..n],有序区为空2.第i躺排序开始时，当前有序区和⽆序区R[1..i-1]、R[i..n]3.n-1趟结束，数组有序化2.2动图演⽰2.3代码实现public static int[] selectionSort(int[] array) {if (array.length == 0)return array;for (int i = 0; i < array.length; i++) {int minIndex = i;for (int j = i; j < array.length; j++) {if (array[j] < array[minIndex]) //找到最⼩的数minIndex = j; //将最⼩数的索引保存}int temp = array[minIndex];array[minIndex] = array[i];array[i] = temp;}return array;}2.4算法分析最佳情况：T(n) = O(n2) 最差情况：T(n) = O(n2) 平均情况：T(n) = O(n2)3、插⼊排序是⼀种简单直观的排序算法，通过构建有序序列，对于未排序序列，在已排序序列中从后向前扫描，找到相应位置并插⼊，需要反复把已排序元素逐步向后挪位，为最新元素腾出插⼊空间3.1算法描述1.从第⼀个元素开始，该元素可以认为已经被排序2.取出下⼀个元素（h），在已排序的元素序列中从后往前扫描3.如果当前元素⼤于h，将当前元素移到下⼀位置4.重复步骤3，直到找到已排序的元素⼩于等于h的位置5.将h插⼊到该位置6.重复步骤2-53.2动图演⽰3.3代码实现public static int[] insertionSort(int[] array) {if (array.length == 0)return array;int current;for (int i = 0; i < array.length - 1; i++) {current = array[i + 1];int preIndex = i;while (preIndex >= 0 && current < array[preIndex]) {array[preIndex + 1] = array[preIndex];preIndex--;}array[preIndex + 1] = current;}return array;}3.4算法分析最佳情况：T(n) = O(n) 最坏情况：T(n) = O(n2) 平均情况：T(n) = O(n2)4、希尔排序是简单插⼊排序经过改进之后的⼀个更⾼效的版本，也称为缩⼩增量排序，同时该算法是冲破O(n2）的第⼀批算法之⼀。
习题九排序一、单项选择题1．下列内部排序算法中：A．快速排序 B.直接插入排序C. 二路归并排序D.简单选择排序E. 起泡排序F.堆排序（1）其比较次数与序列初态无关的算法是（）（2）不稳定的排序算法是（）（3）在初始序列已基本有序（除去n 个元素中的某 k 个元素后即呈有序， k<<n）的情况下，排序效率最高的算法是（）（4）排序的平均时间复杂度为O(n?logn)的算法是（）为 O(n?n) 的算法是（）2．比较次数与排序的初始状态无关的排序方法是( )。
A．直接插入排序B．起泡排序C．快速排序D．简单选择排序3．对一组数据（ 84， 47， 25， 15， 21）排序，数据的排列次序在排序的过程中的变化为（1） 84 47 25 15 21（2） 15 47 25 84 21（3） 15 21 25 84 47（4） 15 21 25 47 84则采用的排序是 ()。
A. 选择B.冒泡C.快速D.插入4．下列排序算法中 ( )排序在一趟结束后不一定能选出一个元素放在其最终位置上。
A. 选择B.冒泡C.归并D.堆5．一组记录的关键码为（46，79，56， 38，40， 84），则利用快速排序的方法，以第一个记录为基准得到的一次划分结果为（）。
A． (38,40,46,56,79,84) B. (40,38,46,79,56,84)C． (40,38,46,56,79,84) D. (40,38,46,84,56,79)6．下列排序算法中，在待排序数据已有序时，花费时间反而最多的是()排序。
A．冒泡 B. 希尔C. 快速D. 堆7.就平均性能而言，目前最好的内排序方法是() 排序法。
A. 冒泡B.希尔插入C.交换D.快速8.下列排序算法中，占用辅助空间最多的是：()A. 归并排序B.快速排序C.希尔排序D.堆排序9.若用冒泡排序方法对序列 {10,14,26,29,41,52}从大到小排序，需进行（）次比较。
【数据结构】常见排序算法复杂度相关概念1、稳定排序（stable sort）和⾮稳定排序稳定排序是指所有相等的数经过某种排序算法操作后仍然能保持它们在排序之前的相对次序。
反之就是⾮稳定排序。
2、内排序（internal sorting）和外排序（external sorting）在排序过程中，所有需要排序的数都在内存，并在内存中调整它们的存储顺序，称为内排序；在排序过程中，只有部分数被调⼊内存，并借助内存调整数在外存中的存放顺序排序⽅法称为外排序。
排序算法【冒泡排序】（Bubble Sort）冒泡排序⽅法是最简单的排序⽅法。
这种⽅法的基本思想是，将待排序的元素看作是竖着排列的“⽓泡”，较⼩的元素⽐较轻，从⽽要往上浮。
在冒泡排序算法中我们要对这个“⽓泡”序列处理若⼲遍。
所谓⼀遍处理，就是⾃底向上检查⼀遍这个序列，并时刻注意两个相邻的元素的顺序是否正确。
如果发现两个相邻元素的顺序不对，即“轻”的元素在下⾯，就交换它们的位置。
显然，处理⼀遍之后，“最轻”的元素就浮到了最⾼位置；处理⼆遍之后，“次轻”的元素就浮到了次⾼位置。
在作第⼆遍处理时，由于最⾼位置上的元素已是“最轻”元素，所以不必检查。
⼀般地，第i遍处理时，不必检查第i⾼位置以上的元素，因为经过前⾯i-1遍的处理，它们已正确地排好序。
冒泡排序是稳定的。
算法时间复杂度是O(n2)。
【选择排序】（Selection Sort）选择排序的基本思想是对待排序的记录序列进⾏n-1遍的处理，第 i 遍处理是将[i..n]中最⼩者与位置 i 交换位置。
这样，经过 i 遍处理之后，前 i 个记录的位置已经是正确的了。
选择排序是不稳定的。
算法复杂度是O(n2 )。
【插⼊排序】（Insertion Sort）插⼊排序的基本思想是，经过i-1遍处理后,L[1..i-1]⼰排好序。
第i遍处理仅将L插⼊L[1..i-1]的适当位置，使得L[1..i]⼜是排好序的序列。
要达到这个⽬的，我们可以⽤顺序⽐较的⽅法。
相关知识介绍（所有定义只为帮助读者理解相关概念，并非严格定义）：1、稳定排序和非稳定排序简单地说就是所有相等的数经过某种排序方法后，仍能保持它们在排序之前的相对次序，我们就说这种排序方法是稳定的。
反之，就是非稳定的。
比如：一组数排序前是a1,a2,a3,a4,a5，其中a2=a4，经过某种排序后为a1,a2,a4,a3,a5，则我们说这种排序是稳定的，因为a2排序前在a4的前面，排序后它还是在a4的前面。
假如变成a1,a4, a2,a3,a5就不是稳定的了。
2、内排序和外排序在排序过程中，所有需要排序的数都在内存，并在内存中调整它们的存储顺序，称为内排序；在排序过程中，只有部分数被调入内存，并借助内存调整数在外存中的存放顺序排序方法称为外排序。
3、算法的时间复杂度和空间复杂度所谓算法的时间复杂度，是指执行算法所需要的计算工作量。
一个算法的空间复杂度，一般是指执行这个算法所需要的内存空间。
功能：选择排序输入：数组名称（也就是数组首地址）、数组中元素个数算法思想简单描述：在要排序的一组数中，选出最小的一个数与第一个位置的数交换；然后在剩下的数当中再找最小的与第二个位置的数交换，如此循环到倒数第二个数和最后一个数比较为止。
选择排序是不稳定的。
算法复杂度O(n2)--[n的平方void select_sort(int *x, int n){int i, j, min, t;for (i=0; i<n-1; i++) /*要选择的次数：0~n-2共n-1次*/{min = i; /*假设当前下标为i的数最小，比较后再调整*/for (j=i+1; j<n; j++)/*循环找出最小的数的下标是哪个*/{if (*(x+j) < *(x+min)){min = j; /*如果后面的数比前面的小，则记下它的下标*/}}if (min != i) /*如果min在循环中改变了，就需要交换数据*/{t = *(x+i);*(x+i) = *(x+min);*(x+min) = t;}}/*功能：直接插入排序输入：数组名称（也就是数组首地址）、数组中元素个数算法思想简单描述：在要排序的一组数中，假设前面(n-1) [n>=2] 个数已经是排好顺序的，现在要把第n个数插到前面的有序数中，使得这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)是一种简单直观的排序算法。
这几天笔试了好几次了，连续碰到一个关于常见排序算法稳定性判别的问题，往往还是多选，对于我以及和我一样拿不准的同学可不是一个能轻易下结论的题目，当然如果你笔试之前已经记住了数据结构书上哪些是稳定的，哪些不是稳定的，做起来应该可以轻松搞定。
本文是针对老是记不住这个或者想真正明白到底为什么是稳定或者不稳定的人准备的。
首先，排序算法的稳定性大家应该都知道，通俗地讲就是能保证排序前2个相等的数其在序列的前后位置顺序和排序后它们两个的前后位置顺序相同。
在简单形式化一下，如果Ai = Aj, Ai原来在位置前，排序后Ai还是要在Aj位置前。
其次，说一下稳定性的好处。
排序算法如果是稳定的，那么从一个键上排序，然后再从另一个键上排序，第一个键排序的结果可以为第二个键排序所用。
基数排序就是这样，先按低位排序，逐次按高位排序，低位相同的元素其顺序再高位也相同时是不会改变的。
另外，如果排序算法稳定，对基于比较的排序算法而言，元素交换的次数可能会少一些(个人感觉，没有证实)。
回到主题，现在分析一下常见的排序算法的稳定性，每个都给出简单的理由。
(1)冒泡排序冒泡排序就是把小的元素往前调或者把大的元素往后调。
比较是相邻的两个元素比较，交换也发生在这两个元素之间。
所以，如果两个元素相等，我想你是不会再无聊地把他们俩交换一下的；如果两个相等的元素没有相邻，那么即使通过前面的两两交换把两个相邻起来，这时候也不会交换，所以相同元素的前后顺序并没有改变，所以冒泡排序是一种稳定排序算法。
(2)选择排序选择排序是给每个位置选择当前元素最小的，比如给第一个位置选择最小的，在剩余元素里面给第二个元素选择第二小的，依次类推，直到第n-1个元素，第n个元素不用选择了，因为只剩下它一个最大的元素了。
那么，在一趟选择，如果当前元素比一个元素小，而该小的元素又出现在一个和当前元素相等的元素后面，那么交换后稳定性就被破坏了。
比较拗口，举个例子，序列5 8 5 2 9，我们知道第一遍选择第1个元素5会和2交换，那么原序列中2个5的相对前后顺序就被破坏了，所以选择排序不是一个稳定的排序算法。
不稳定排序算法范文以下是几种常见的不稳定排序算法：1. 快速排序（Quick Sort）：快速排序是一种分治算法，通过选择一个枢纽元素（一般选择待排序序列中的第一个元素），将序列划分为两个子序列，其中一个子序列中的所有元素都小于枢纽元素，另一个子序列中的所有元素都大于枢纽元素。
然后对两个子序列分别进行递归排序。
具体步骤如下：- 选择一个枢轴元素pivot，将序列分为两部分，一部分是小于枢轴的元素，另一部分是大于枢轴的元素。
-对划分后的子序列分别进行递归调用快速排序。
-合并排序后的子序列。
快速排序是不稳定排序算法，因为在交换元素时可能导致相同元素的相对顺序改变。
2. 希尔排序（Shell Sort）：希尔排序是通过将待排序序列不断分割为更小的子序列来进行排序的算法。
具体步骤如下：- 假设待排序序列的长度为n，首先选择一个增量gap=n/2- 将序列分为gap个子序列，分别对这些子序列进行插入排序。
-缩小增量并重复上述过程，直到增量为1时，进行最后一次插入排序。
希尔排序的不稳定性主要是由于对子序列进行插入排序时的交换操作。
3. 堆排序（Heap Sort）：堆排序是基于二叉堆的一种排序算法。
具体步骤如下：-构建最大堆（或最小堆）：将待排序序列构建成一个堆，使得每个父节点的值都大于（或小于）其子节点的值。
-依次取出堆顶元素（即最大值或最小值），并将剩余的元素重新调整为堆。
-重复上述过程，直到所有元素都取出。
堆排序是不稳定的排序算法，因为在调整堆过程中，相同元素的相对顺序可能会发生改变。
除了上述几种不稳定排序算法外，诸如选择排序、插入排序等算法也是不稳定排序算法。
不稳定排序算法的应用场景相对较少，主要在不需关心相同键值元素的相对位置的情况下使用。
排序算法总结【篇一：排序算法总结】1、稳定排序和非稳定排序简单地说就是所有相等的数经过某种排序方法后，仍能保持它们在排序之前的相对次序，我们就说这种排序方法是稳定的。
反之，就是非稳定的。
比如：一组数排序前是a1，a2，a3，a4，a5，其中a2=a4，经过某种排序后为a1，a2，a4，a3，a5，则我们说这种排序是稳定的，因为a2排序前在a4的前面，排序后它还是在a4的前面。
假如变成a1，a4，a2，a3，a5就不是稳定的了。
2、内排序和外排序在排序过程中，所有需要排序的数都在内存，并在内存中调整它们的存储顺序，称为内排序；在排序过程中，只有部分数被调入内存，并借助内存调整数在外存中的存放顺序排序方法称为外排序。
3、算法的时间复杂度和空间复杂度所谓算法的时间复杂度，是指执行算法所需要的计算工作量。
一个算法的空间复杂度，一般是指执行这个算法所需要的内存空间。
功能：选择排序输入：数组名称（也就是数组首地址）、数组中元素个数算法思想简单描述：在要排序的一组数中，选出最小的一个数与第一个位置的数交换；然后在剩下的数当中再找最小的与第二个位置的数交换，如此循环到倒数第二个数和最后一个数比较为止。
选择排序是不稳定的。
【篇二：排序算法总结】在计算机科学所使用的排序算法通常被分类为：计算的复杂度（最差、平均、和最好性能），依据列表（list）的大小（n）。
一般而言，好的性能是O（nlogn），且坏的性能是O（n2）。
对于一个排序理想的性能是O（n）。
仅使用一个抽象关键比较运算的排序算法总平均上总是至少需要O（nlogn）。
内存使用量（以及其他电脑资源的使用）稳定度：稳定排序算法会依照相等的关键（换言之就是值）维持纪录的相对次序。
也就是一个排序算法是稳定的，就是当有两个有相等关键的纪录R和S，且在原本的列表中R出现在S之前，在排序过的列表中R也将会是在S之前。
一般的方法：插入、交换、选择、合并等等。
交换排序包含冒泡排序和快速排序。
第1篇一、引言排序是计算机科学中常见的基本操作之一，它涉及到将一组数据按照一定的顺序排列。
在数据处理、算法设计、数据分析等众多领域，排序算法都扮演着重要的角色。
本文将对常见的排序算法进行总结和分析，以期为相关领域的研究和开发提供参考。
二、排序算法概述排序算法可以分为两大类：比较类排序和非比较类排序。
比较类排序算法通过比较元素之间的值来实现排序，如冒泡排序、选择排序、插入排序等。
非比较类排序算法则不涉及元素之间的比较，如计数排序、基数排序、桶排序等。
三、比较类排序算法1. 冒泡排序冒泡排序是一种简单的排序算法，它通过相邻元素之间的比较和交换来实现排序。
冒泡排序的基本思想是：从数组的第一个元素开始，比较相邻的两个元素，如果它们的顺序错误就把它们交换过来；然后，对下一对相邻元素做同样的工作，以此类推，直到没有需要交换的元素为止。
冒泡排序的时间复杂度为O(n^2)，空间复杂度为O(1)。
虽然冒泡排序的时间复杂度较高，但它易于实现，且对数据量较小的数组排序效果较好。
2. 选择排序选择排序是一种简单直观的排序算法。
它的工作原理是：首先在未排序序列中找到最小（大）元素，存放到排序序列的起始位置，然后，再从剩余未排序元素中继续寻找最小（大）元素，然后放到已排序序列的末尾。
以此类推，直到所有元素均排序完毕。
选择排序的时间复杂度为O(n^2)，空间复杂度为O(1)。
与冒泡排序类似，选择排序也适用于数据量较小的数组排序。
3. 插入排序插入排序是一种简单直观的排序算法。
它的工作原理是：将一个记录插入到已经排好序的有序表中，从而得到一个新的、记录数增加1的有序表。
插入排序的基本操作是：在未排序序列中找到相应位置并插入。
插入排序的时间复杂度为O(n^2)，空间复杂度为O(1)。
对于部分有序的数组，插入排序的效率较高。
4. 快速排序快速排序是一种高效的排序算法，它的基本思想是：通过一趟排序将待排序的记录分割成独立的两部分，其中一部分记录的关键字均比另一部分的关键字小，则可分别对这两部分记录继续进行排序，以达到整个序列有序。
判断数组是否稳定公式1. 引言1.1 什么是数组的稳定性数组的稳定性是指在排序过程中相同元素的相对位置是否发生改变。
在排序算法中，如果输入数组中有两个相同元素a和b，且在排序后a仍然在b前面，那么就可以说这个排序算法是稳定的。
换句话说，稳定的排序算法会保持相同元素的原有顺序。
举个例子来说明数组的稳定性：假设有一个包含相同元素的数组[4, 3, 2, 1, 4]，如果使用稳定的排序算法对其进行排序，那么排序后的数组可能会是[1, 2, 3, 4, 4]，其中两个4的相对位置没有发生改变。
数组的稳定性在实际应用中非常重要，特别是在需要保持元素原有顺序的情况下。
在对学生成绩进行排序时，如果两个学生有相同的成绩，那么排序后仍然希望他们保持原有的排名。
在对多个条件进行排序时，稳定性也能够帮助我们更好地理解排序结果。
了解和判断数组的稳定性是非常有必要的，它可以帮助我们选择合适的排序算法，确保排序结果符合我们的需求。
接下来我们将进一步探讨如何判断数组是否稳定以及稳定性的重要性。
1.2 为什么需要判断数组是否稳定数组的稳定性在排序算法中起着至关重要的作用。
在很多实际应用中，我们需要保持数组中元素的相对位置不变。
在对学生进行成绩排序时，如果有多个学生成绩相同，我们希望他们在排序后的数组中仍然保持原来的相对顺序。
这就需要使用稳定的排序算法来实现。
在对数据进行多次排序时，如果我们希望保持之前的排序结果不变，就需要使用稳定的排序算法。
而如果使用非稳定的排序算法，可能会导致之前的排序结果被打乱，从而影响到后续的操作。
需要判断数组是否稳定是非常必要的。
通过判断数组的稳定性，我们可以选择合适的排序算法来满足实际需求，并确保排序结果的准确性和稳定性。
深入理解数组的稳定性也有助于我们对排序算法的设计和优化有更深入的认识，提高程序的效率和性能。
为了保证程序的正确性和效率，我们需要对数组的稳定性进行准确的判断和分析。
2. 正文2.1 什么是稳定的排序算法稳定的排序算法是指在排序过程中，对于相等元素的相对位置不发生改变的排序算法。
各种排序算法的稳定性和时间复杂度小结选择排序、快速排序、希尔排序、堆排序不是稳定的排序算法，冒泡排序、插入排序、归并排序和基数排序是稳定的排序算法。
冒泡法：这是最原始，也是众所周知的最慢的算法了。
他的名字的由来因为它的工作看来象是冒泡：复杂度为O(n*n)。
当数据为正序，将不会有交换。
复杂度为O(0)。
直接插入排序：O(n*n)选择排序：O(n*n)快速排序：平均时间复杂度log2(n)*n，所有内部排序方法中最高好的，大多数情况下总是最好的。
归并排序：log2(n)*n堆排序：log2(n)*n希尔排序：算法的复杂度为n的1.2次幂关于快速排序分析这里我没有给出行为的分析，因为这个很简单，我们直接来分析算法：首先我们考虑最理想的情况1.数组的大小是2的幂，这样分下去始终可以被2整除。
假设为2的k次方，即k=log2(n)。
2.每次我们选择的值刚好是中间值，这样，数组才可以被等分。
第一层递归，循环n次，第二层循环2*(n/2)......所以共有n+2(n/2)+4(n/4)+...+n*(n/n) = n+n+n+...+n=k*n=log2(n)*n所以算法复杂度为O(log2(n)*n)其他的情况只会比这种情况差，最差的情况是每次选择到的middle都是最小值或最大值，那么他将变成交换法（由于使用了递归，情况更糟）。
但是你认为这种情况发生的几率有多大？？呵呵，你完全不必担心这个问题。
实践证明，大多数的情况，快速排序总是最好的。
如果你担心这个问题，你可以使用堆排序，这是一种稳定的O(log2(n)*n)算法，但是通常情况下速度要慢于快速排序（因为要重组堆）。
本文是针对老是记不住这个或者想真正明白到底为什么是稳定或者不稳定的人准备的。
首先，排序算法的稳定性大家应该都知道，通俗地讲就是能保证排序前2个相等的数其在序列的前后位置顺序和排序后它们两个的前后位置顺序相同。
在简单形式化一下，如果Ai = Aj, Ai原来在位置前，排序后Ai还是要在Aj位置前。
1.稳定性比较插入排序、冒泡排序、二叉树排序、二路归并排序及其他线形排序是稳定的选择排序、希尔排序、快速排序、堆排序是不稳定的2.时间复杂性比较插入排序、冒泡排序、选择排序的时间复杂性为O(n2)其它非线形排序的时间复杂性为O(nlog2n)线形排序的时间复杂性为O(n);3.辅助空间的比较线形排序、二路归并排序的辅助空间为O(n),其它排序的辅助空间为O(1); 4.其它比较插入、冒泡排序的速度较慢，但参加排序的序列局部或整体有序时，这种排序能达到较快的速度。
反而在这种情况下，快速排序反而慢了。
当n较小时，对稳定性不作要求时宜用选择排序，对稳定性有要求时宜用插入或冒泡排序。
若待排序的记录的关键字在一个明显有限范围内时,且空间允许是用桶排序。
当n较大时，关键字元素比较随机，对稳定性没要求宜用快速排序。
当n较大时，关键字元素可能出现本身是有序的，对稳定性有要求时，空间允许的情况下。
宜用归并排序。
当n较大时，关键字元素可能出现本身是有序的，对稳定性没有要求时宜用堆排序。
********************************************************************* ****************重温经典排序思想--C语言常用排序全解/*===================================================================== ========相关知识介绍（所有定义只为帮助读者理解相关概念，并非严格定义）：1、稳定排序和非稳定排序简单地说就是所有相等的数经过某种排序方法后，仍能保持它们在排序之前的相对次序，我们就说这种排序方法是稳定的。
反之，就是非稳定的。
比如：一组数排序前是a1,a2,a3,a4,a5，其中a2=a4，经过某种排序后为a1,a2,a4,a3,a5，则我们说这种排序是稳定的，因为a2排序前在a4的前面，排序后它还是在a4的前面。
首先，排序算法的稳定性大家应该都知道，通俗地讲就是能保证排序前2个相等的数其在序列的前后位置顺序和排序后它们两个的前后位置顺序相同。
在简单形式化一下，如果Ai = Aj, Ai原来在位置前，排序后Ai还是要在Aj位置前。
其次，说一下稳定性的好处。
排序算法如果是稳定的，那么从一个键上排序，然后再从另一个键上排序，第一个键排序的结果可以为第二个键排序所用。
基数排序就是这样，先按低位排序，逐次按高位排序，低位相同的元素其顺序再高位也相同时是不会改变的。
另外，如果排序算法稳定，对基于比较的排序算法而言，元素交换的次数可能会少一些(个人感觉，没有证实)。
回到主题，现在分析一下常见的排序算法的稳定性，每个都给出简单的理由。
(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个元素。
而右边的j下标一直往左走，当a[j] > a[center_index]。
如果i和j都走不动了，i <= j, 交换
a[i]和a[j],重复上面的过程，直到i>j。
交换a[j]和a[center_index]，完成一趟快速排序。
在中枢元素和a[j]交换的时候，很有可能把前面的元素的稳定性打乱，比如序列为5 3 3 4 3 8 9 10 11，现在中枢元素5和3(第5个元素，下标从1开始计)
交换就会把元素3的稳定性打乱，所以快速排序是一个不稳定的排序算法，不稳定发生在中枢元素和a[j] 交换的时刻。
(5)归并排序
归并排序是把序列递归地分成短序列，递归出口是短序列只有1个元素(认为直接有序)或者2个序列(1次比较和交换),然后把各个有序的段序列合并成一个有序的长序列，不断合并直到原序列全部排好序。
可以发现，在1个或2个元素时，1个元素不会交换，2个元素如果大小相等也没有人故意交换，这不会破坏稳定性。
那么，在短的有序序列合并的过程中，稳定是是否受到破坏？没有，合并过程中我们可以保证如果两个当前元素相等时，我们把处在前面的序列的元素保存在结果序列的前面，这样就保证了稳定性。
所以，归并排序也是稳定的排序算法。
(6)基数排序
基数排序是按照低位先排序，然后收集；再按照高位排序，然后再收集；依次类推，直到最高位。
有时候有些属性是有优先级顺序的，先按低优先级排序，再按高优先级排序，最后的次序就是高优先级高的在前，高优先级相同的低优先级高的在前。
基数排序基于分别排序，分别收集，所以其是稳定的排序算法。
(7)希尔排序(shell)
希尔排序是按照不同步长对元素进行插入排序，当刚开始元素很无序的时候，步长最大，所以插入排序的元素个数很少，速度很快；当元素基本有序了，步长很小，插入排序对于有序的序列效率很高。
所以，希尔排序的时间复杂度会比o(n^2)好一些。
由于多次插入排序，我们知道一次插入排序是稳定的，不会改变相同元素的相对顺序，
但在不同的插入排序过程中，相同的元素可能在各自的插入排序中移动，最后其稳定性就会被打乱，所以shell排序是不稳定的。
(8)堆排序
我们知道堆的结构是节点i的孩子为2*i和2*i+1节点，大顶堆要求父节点大于等于其2个子节点，小顶堆要求父节点小于等于其2个子节点。
在一个长为n 的序列，堆排序的过程是从第n/2开始和其子节点共3个值选择最大(大顶堆)或者最小(小顶堆),这3个元素之间的选择当然不会破坏稳定性。
但当为n /2-1, n/2-2, ...1这些个父节点选择元素时，就会破坏稳定性。
有可能第n/2个父节点交换把后面一个元素交换过去了，而第n/2-1个父节点把后面一个相同的元素没有交换，那么这2个相同的元素之间的稳定性就被破坏了。
所以，堆排序不是稳定的排序算法。
综上，得出结论: 选择排序、快速排序、希尔排序、堆排序不是稳定的排序算法，而冒泡排序、插入排序、归并排序和基数排序是稳定的排序算法。
