JAVA排序算法实现代码-快速(Quick Sort)排序
- /**
- * JAVA排序算法实现代码-快速(Quick Sort)排序。
- *
- * @author 老紫竹 JAVA世纪网(java2000.net)
- *
- */
- public class Test {
- public static int[] a = { 10, 32, 1, 9, 5, 7, 12, 0, 4, 3 }; // 预设数据数组
- public static void main(String args[]) {
- System.out.print("排序前: ");
- for (int i = 0; i < a.length; i++)
- System.out.printf("%3s", a[i]);
- System.out.println("");
- int Index = a.length;
- QuickSort(0, Index - 1, Index); // 快速排序
- // 排序后结果
- System.out.print("排序后: ");
- for (int i = 0; i < a.length; i++)
- System.out.printf("%3s", a[i]);
- System.out.println("");
- }
- public static void QuickSort(int Left, int Right, int Index) {
- int i, j, k; // 循环计数变量
- int Pivot; // 枢纽变量
- int Temp; // 暂存变量
- i = Left; // 设定左指针
- j = Right; // 设定右指针
- Pivot = a[Left]; // 取最左边的元素
- if (i < j) {
- do {
- while (a[i] <Pivot && i < Right) // 从左往右找比Pivot大的值
- {
- i++;
- }
- while (a[j] > Pivot && j > Left) // 从右往左找比Pivot小的值
- {
- j--;
- }
- if (i < j) // 交换a[i]和a[j]
- {
- Temp = a[i];
- a[i] = a[j];
- a[j] = Temp;
- }
- } while (i < j);
- if (i > j) {
- Temp = a[Left]; // 交换a[Left]和a[j]
- a[Left] = a[j];
- a[j] = Temp;
- // 打印目前排序结果
- System.out.print("排序中: ");
- for (k = 0; k <= Index; k++) {
- System.out.printf("%3s", a[k]);
- }
- System.out.println("");
- }
- QuickSort(Left, j - 1, Index); // 排序左半边
- QuickSort(j + 1, Right, Index); // 排序右半边
- }
- }
- }
运行结果
排序前: 10 32 1 9 5 7 12 0 4 3
排序后: 0 1 3 4 5 7 9 10 12 32
JAVA排序算法实现代码-冒泡(Bubble Sort)排序
- /**
- * JAVA排序算法实现代码-冒泡(Bubble Sort)排序。
- *
- * @author 老紫竹 JAVA世纪网(java2000.net)
- *
- */
- public class Test {
- public static void main(String[] args) {
- int[] a = { 10, 32, 1, 9, 5, 7, 12, 0, 4, 3 };
- System.out.print("排序前: ");
- for (int i = 0; i < a.length; i++)
- System.out.printf("%3s", a[i]);
- System.out.println();
- Test test = new Test();
- test.bubbleSort(a);
- System.out.print("排序后: ");
- for (int i = 0; i < a.length; i++)
- System.out.printf("%3s", a[i]);
- System.out.println();
- }
- public void bubbleSort(int[] a) {
- int len = a.length;
- System.out.println("数组大小是:" + len);
- boolean change = false;
- int temp;
- int count = 0;
- for (int i = len; i > 1; i--) {
- for (int j = 0; j < i - 1; j++) {
- if (a[j + 1] < a[j]) {
- temp = a[j + 1];
- a[j + 1] = a[j];
- a[j] = temp;
- change = true;
- count++;
- }
- }
- if (change) {
- System.out.print("第" + count + "趟交换: ");
- for (int k = 0; k < len; k++)
- System.out.print(a[k] + " ");
- System.out.println();
- }
- }
- }
- }
运行结果
排序前: 10 32 1 9 5 7 12 0 4 3
数组大小是:10
第8趟交换: 10 1 9 5 7 12 0 4 3 32
第15趟交换: 1 9 5 7 10 0 4 3 12 32
第20趟交换: 1 5 7 9 0 4 3 10 12 32
第23趟交换: 1 5 7 0 4 3 9 10 12 32
第26趟交换: 1 5 0 4 3 7 9 10 12 32
第29趟交换: 1 0 4 3 5 7 9 10 12 32
第31趟交换: 0 1 3 4 5 7 9 10 12 32
第31趟交换: 0 1 3 4 5 7 9 10 12 32
第31趟交换: 0 1 3 4 5 7 9 10 12 32
排序后: 0 1 3 4 5 7 9 10 12 32
JAVA排序算法实现代码-堆(Heap)排序
- /**
- * JAVA排序算法实现代码-堆(Heap)排序。
- *
- * @author 老紫竹 JAVA世纪网(java2000.net)
- *
- */
- public class Test {
- public static int[] Heap = { 10, 32, 1, 9, 5, 7, 12, 0, 4, 3 }; // 预设数据数组
- public static void main(String args[]) {
- int i; // 循环计数变量
- int Index = Heap.length; // 数据索引变量
- System.out.print("排序前: ");
- for (i = 1; i < Index - 1; i++)
- System.out.printf("%3s", Heap[i]);
- System.out.println("");
- HeapSort(Index - 2); // 堆排序
- System.out.print("排序后: ");
- for (i = 1; i < Index - 1; i++)
- System.out.printf("%3s", Heap[i]);
- System.out.println("");
- }
- /**
- * 建立堆
- */
- public static void CreateHeap(int Root, int Index) {
- int i, j; // 循环计数变量
- int Temp; // 暂存变量
- int Finish; // 判断堆是否建立完成
- j = 2 * Root; // 子节点的Index
- Temp = Heap[Root]; // 暂存Heap的Root 值
- Finish = 0; // 预设堆建立尚未完成
- while (j <= Index && Finish == 0) {
- if (j < Index) // 找最大的子节点
- if (Heap[j] < Heap[j + 1])
- j++;
- if (Temp >= Heap[j])
- Finish = 1; // 堆建立完成
- else {
- Heap[j / 2] = Heap[j]; // 父节点 = 目前节点
- j = 2 * j;
- }
- }
- Heap[j / 2] = Temp; // 父节点 = Root值
- }
- public static void HeapSort(int Index) {
- int i, j, Temp;
- // 将二叉树转成Heap
- for (i = (Index / 2); i >= 1; i--)
- CreateHeap(i, Index);
- // 开始进行堆排序
- for (i = Index - 1; i >= 1; i--) {
- Temp = Heap[i + 1]; // Heap的Root值和最后一个值交换
- Heap[i + 1] = Heap[1];
- Heap[1] = Temp;
- CreateHeap(1, i); // 对其余数值重建堆
- System.out.print("排序中: ");
- for (j = 1; j <= Index; j++)
- System.out.printf("%3s",Heap[j]);
- System.out.println("");
- }
- }
- }
运行结果
排序前: 32 1 9 5 7 12 0 4
排序中: 12 7 9 5 1 4 0 32
排序中: 9 7 4 5 1 0 12 32
排序中: 7 5 4 0 1 9 12 32
排序中: 5 1 4 0 7 9 12 32
排序中: 4 1 0 5 7 9 12 32
排序中: 1 0 4 5 7 9 12 32
排序中: 0 1 4 5 7 9 12 32
排序后: 0 1 4 5 7 9 12 32
JAVA排序算法实现代码-选择(Select)式排序
- /**
- * JAVA排序算法实现代码-选择(Select)式排序。
- *
- * @author 老紫竹 JAVA世纪网(java2000.net)
- *
- */
- public class Test {
- public static int[] a = { 10, 32, 1, 9, 5, 7, 12, 0, 4, 3 }; // 预设数据数组
- public static void main(String args[]) {
- int i; // 循环计数变量
- int Index = a.length;// 数据索引变量
- System.out.print("排序前: ");
- for (i = 0; i < Index - 1; i++)
- System.out.printf("%3s", a[i]);
- System.out.println("");
- SelectSort(Index - 1); // 选择排序
- // 排序后结果
- System.out.print("排序后: ");
- for (i = 0; i < Index - 1; i++)
- System.out.printf("%3s", a[i]);
- System.out.println("");
- }
- public static void SelectSort(int Index) {
- int i, j, k; // 循环计数变量
- int MinValue; // 最小值变量
- int IndexMin; // 最小值索引变量
- int Temp; // 暂存变量
- for (i = 0; i < Index - 1; i++) {
- MinValue = 32767; // 目前最小数值
- IndexMin = 0; // 储存最小数值的索引值
- for (j = i; j < Index; j++) {
- if (a[j] < MinValue) // 找到最小值
- {
- MinValue = a[j]; // 储存最小值
- IndexMin = j;
- }
- Temp = a[i]; // 交换两数值
- a[i] = a[IndexMin];
- a[IndexMin] = Temp;
- }
- System.out.print("排序中: ");
- for (k = 0; k < Index; k++)
- System.out.printf("%3s", a[k]);
- System.out.println("");
- }
- }
- }
运行结果
排序前: 10 32 1 9 5 7 12 0 4
排序中: 1 32 10 9 5 7 12 0 4
排序中: 1 5 32 10 9 7 12 0 4
排序中: 1 5 9 32 10 7 12 0 4
排序中: 1 5 9 10 32 7 12 0 4
排序中: 1 5 9 10 32 7 12 0 4
排序中: 1 5 9 10 32 7 12 0 4
排序中: 1 5 9 10 32 7 12 0 4
排序中: 1 5 9 10 32 7 12 0 4
排序后: 1 5 9 10 32 7 12 0 4
JAVA排序算法实现代码-二叉树排序
- /**
- * JAVA排序算法实现代码-二叉树排序。
- *
- * @author 老紫竹 JAVA世纪网(java2000.net)
- *
- */
- public class Test {
- public static int[] a = { 0, 10, 32, 1, 9, 5, 7, 12, 2, 4, 3 }; // 预设数据数组
- public static int[] Data = new int[20]; // 预设数据数组
- public static void main(String args[]) {
- int i; // 循环计数变量
- int Index = 1; // 数据索引变量
- BNTreeArray BNTree = new BNTreeArray(); // 声明二叉树数组
- Data[Index] = a[Index];
- BNTreeArray.TreeData[0] = Data[Index];
- Index++;
- for (i = 2; i < a.length; i++) {
- Data[Index] = a[Index];
- BNTree.Create(Data[Index]); // 建立二叉查找树
- Index++;
- }
- // 排序前数据内容
- System.out.print("排序前 : ");
- for (i = 1; i < Index; i++)
- System.out.print(" " + Data[i] + " ");
- System.out.println("");
- // 排序后结果
- System.out.print("排序后 : ");
- BNTreeArray.InOrder(0); // 中序遍历
- }
- }
- class BNTreeArray {
- public static int MaxSize = 20;
- public static int[] TreeData = new int[MaxSize];
- public static int[] RightNode = new int[MaxSize];
- public static int[] LeftNode = new int[MaxSize];
- public BNTreeArray() {
- int i; // 循环计数变量
- for (i = 0; i < MaxSize; i++) {
- TreeData[i] = 0;
- RightNode[i] = -1;
- LeftNode[i] = -1;
- }
- }
- // ----------------------------------------------------
- // 建立二叉树
- // ----------------------------------------------------
- public void Create(int Data) {
- int i; // 循环计数变量
- int Level = 0; // 树的阶层数
- int Position = 0;
- for (i = 0; TreeData[i] != 0; i++)
- ;
- TreeData[i] = Data;
- while (true) // 寻找节点位置
- {
- // 判断是左子树或是右子树
- if (Data > TreeData[Level]) {
- // 右树是否有下一阶层
- if (RightNode[Level] != -1)
- Level = RightNode[Level];
- else {
- Position = -1; // 设定为右树
- break;
- }
- } else {
- // 左树是否有下一阶层
- if (LeftNode[Level] != -1)
- Level = LeftNode[Level];
- else {
- Position = 1; // 设定为左树
- break;
- }
- }
- }
- if (Position == 1) // 建立节点的左右连结
- LeftNode[Level] = i; // 连结左子树
- else
- RightNode[Level] = i; // 连结右子树
- }
- // ---------------------------------------------------------
- // 二叉树中序遍历
- // ---------------------------------------------------------
- public static void InOrder(int Pointer) {
- if (Pointer != -1) // 遍历的终止条件
- {
- InOrder(LeftNode[Pointer]); // 处理左子树
- // 处理打印节点内容
- System.out.print(" " + TreeData[Pointer] + " ");
- InOrder(RightNode[Pointer]); // 处理右子树
- }
- }
- }
运行结果
排序前 : 10 32 1 9 5 7 12 2 4 3
排序后 : 1 2 3 4 5 7 9 10 12 32
JAVA排序算法实现代码-希尔Shell排序
- /**
- * JAVA排序算法实现代码-希尔Shell排序。
- *
- * @author 老紫竹 JAVA世纪网(java2000.net)
- *
- */
- public class Test {
- public static int[] a = { 10, 32, 1, 9, 5, 7, 12, 0, 4, 3 }; // 预设数据数组
- public static void main(String args[]) {
- int i; // 循环计数变量
- int Index = a.length;// 数据索引变量
- System.out.print("排序前: ");
- for (i = 0; i < Index - 1; i++)
- System.out.printf("%3s ", a[i]);
- System.out.println("");
- ShellSort(Index - 1); // 选择排序
- // 排序后结果
- System.out.print("排序后: ");
- for (i = 0; i < Index - 1; i++)
- System.out.printf("%3s ", a[i]);
- System.out.println("");
- }
- public static void ShellSort(int Index) {
- int i, j, k; // 循环计数变量
- int Temp; // 暂存变量
- boolean Change; // 数据是否改变
- int DataLength; // 分割集合的间隔长度
- int Pointer; // 进行处理的位置
- DataLength = (int) Index / 2; // 初始集合间隔长度
- while (DataLength != 0) // 数列仍可进行分割
- {
- // 对各个集合进行处理
- for (j = DataLength; j < Index; j++) {
- Change = false;
- Temp = a[j]; // 暂存Data[j]的值,待交换值时用
- Pointer = j - DataLength; // 计算进行处理的位置
- // 进行集合内数值的比较与交换值
- while (Temp < a[Pointer] && Pointer >= 0 && Pointer <= Index) {
- a[Pointer + DataLength] = a[Pointer];
- // 计算下一个欲进行处理的位置
- Pointer = Pointer - DataLength;
- Change = true;
- if (Pointer < 0 || Pointer > Index)
- break;
- }
- // 与最后的数值交换
- a[Pointer + DataLength] = Temp;
- if (Change) {
- // 打印目前排序结果
- System.out.print("排序中: ");
- for (k = 0; k < Index; k++)
- System.out.printf("%3s ", a[k]);
- System.out.println("");
- }
- }
- DataLength = DataLength / 2; // 计算下次分割的间隔长度
- }
- }
- }
运行结果
排序前: 10 32 1 9 5 7 12 0 4
排序中: 5 32 1 9 10 7 12 0 4
排序中: 5 7 1 9 10 32 12 0 4
排序中: 5 7 1 0 10 32 12 9 4
排序中: 4 7 1 0 5 32 12 9 10
排序中: 1 7 4 0 5 32 12 9 10
排序中: 1 0 4 7 5 32 12 9 10
排序中: 1 0 4 7 5 9 12 32 10
排序中: 1 0 4 7 5 9 10 32 12
排序中: 0 1 4 7 5 9 10 32 12
排序中: 0 1 4 5 7 9 10 32 12
排序中: 0 1 4 5 7 9 10 12 32
排序后: 0 1 4 5 7 9 10 12 32
JAVA排序算法实现代码-插入排序
- /**
- * JAVA排序算法实现代码-插入排序。
- *
- * @author 老紫竹 JAVA世纪网(java2000.net)
- *
- */
- public class Test {
- public static int[] a = { 10, 32, 1, 9, 5, 7, 12, 0, 4, 3 }; // 预设数据数组
- public static void main(String args[]) {
- int i; // 循环计数变量
- int Index = a.length;// 数据索引变量
- System.out.print("排序前: ");
- for (i = 0; i < Index - 1; i++)
- System.out.print(" " + a[i] + " ");
- System.out.println("");
- InsertSort(Index - 1); // 选择排序
- // 排序后结果
- System.out.print("排序后: ");
- for (i = 0; i < Index - 1; i++)
- System.out.print(" " + a[i] + " ");
- System.out.println("");
- }
- public static void InsertSort(int Index) {
- int i, j, k; // 循环计数变量
- int InsertNode; // 欲插入数据变量
- for (i = 1; i < Index; i++) // 依序插入数值
- {
- InsertNode = a[i]; // 设定欲插入的数值
- j = i - 1; // 欲插入数组的开始位置
- // 找适当的插入位置
- while (j >= 0 && InsertNode < a[j]) {
- a[j + 1] = a[j];
- j--;
- }
- a[j + 1] = InsertNode; // 将数值插入
- // 打印目前排序结果
- System.out.print("排序中: ");
- for (k = 0; k < Index; k++)
- System.out.print(" " + a[k] + " ");
- System.out.println("");
- }
- }
- }
运行结果
排序前: 10 32 1 9 5 7 12 0 4
排序中: 10 32 1 9 5 7 12 0 4
排序中: 1 10 32 9 5 7 12 0 4
排序中: 1 9 10 32 5 7 12 0 4
排序中: 1 5 9 10 32 7 12 0 4
排序中: 1 5 7 9 10 32 12 0 4
排序中: 1 5 7 9 10 12 32 0 4
排序中: 0 1 5 7 9 10 12 32 4
排序中: 0 1 4 5 7 9 10 12 32
排序后: 0 1 4 5 7 9 10 12 32
排序算法总结
from:http://blog.csdn.net/myjava_024/archive/2008/11/04/3220319.aspx
学习了这么多的排序算法,还没有做个总结,呵呵
冒泡排序
冒泡排序是最慢的排序算法。在实际运用中它是效率最低的算法。它通过一趟又一趟地比较数组中的每一个元素,使较大的数据下沉,较小的数据上升。它是O(n^2)的算法。
快速排序
快速排序是一个就地排序,分而治之,大规模递归的算法。从本质上来说,它是归并排序的就地版本。快速排序可以由下面四步组成。
(1)
如果不多于1个数据,直接返回。
(2)
一般选择序列最左边的值作为支点数据。
(3)
将序列分成2部分,一部分都大于支点数据,另外一部分都小于支点数据。
(4)
对两边利用递归排序数列。
快速排序比大部分排序算法都要快。尽管我们可以在某些特殊的情况下写出比快速排序快的算法,但是就通常情况而言,没有比它更快的了。快速排序是递归的,对于内存非常有限的机器来说,它不是一个好的选择。
归并排序
归并排序先分解要排序的序列,从1分成2,2分成4,依次分解,当分解到只有1个一组的时候,就可以排序这些分组,然后依次合并回原来的序列中,这样就可以排序所有数据。合并排序比堆排序稍微快一点,但是需要比堆排序多一倍的内存空间,因为它需要一个额外的数组。
堆排序
堆排序适合于数据量非常大的场合(百万数据)。
堆排序不需要大量的递归或者多维的暂存数组。这对于数据量非常巨大的序列是合适的。比如超过数百万条记录,因为快速排序,归并排序都使用递归来设计算法,在数据量非常大的时候,可能会发生堆栈溢出错误。
堆排序会将所有的数据建成一个堆,最大的数据在堆顶,然后将堆顶数据和序列的最后一个数据交换。接下来再次重建堆,交换数据,依次下去,就可以排序所有的数据。
希尔排序
Shell排序通过将数据分成不同的组,先对每一组进行排序,然后再对所有的元素进行一次插入排序,以减少数据交换和移动的次数。平均效率是O(nlogn)。其中分组的合理性会对算法产生重要的影响。现在多用D.E.Knuth的分组方法。
Shell排序比冒泡排序快5倍,比插入排序大致快2倍。Shell排序比起QuickSort,MergeSort,HeapSort慢很多。但是它相对比较简单,它适合于数据量在5000以下并且速度并不是特别重要的场合。它对于数据量较小的数列重复排序是非常好的。
插入排序
插入排序通过把序列中的值插入一个已经排序好的序列中,直到该序列的结束。插入排序是对冒泡排序的改进。它比冒泡排序快2倍。一般不用在数据大于1000的场合下使用插入排序,或者重复排序超过200数据项的序列。
交换排序和选择排序
这两种排序方法都是交换方法的排序算法,效率都是 O(n2)。在实际应用中处于和冒泡排序基本相同的地位。它们只是排序算法发展的初级阶段,在实际中使用较少。
基数排序
基数排序和通常的排序算法并不走同样的路线。它是一种比较新颖的算法,但是它只能用于整数的排序,如果我们要把同样的办法运用到浮点数上,我们必须了解浮点数的存储格式,并通过特殊的方式将浮点数映射到整数上,然后再映射回去,这是非常麻烦的事情,因此,它的使用同样也不多。而且,最重要的是,这样算法也需要较多的存储空间。
总结
下面是一个总的表格,大致总结了我们常见的所有的排序算法的特点。
学习了这么多的排序算法,还没有做个总结,呵呵
冒泡排序
冒泡排序是最慢的排序算法。在实际运用中它是效率最低的算法。它通过一趟又一趟地比较数组中的每一个元素,使较大的数据下沉,较小的数据上升。它是O(n^2)的算法。
快速排序
快速排序是一个就地排序,分而治之,大规模递归的算法。从本质上来说,它是归并排序的就地版本。快速排序可以由下面四步组成。
(1)
如果不多于1个数据,直接返回。
(2)
一般选择序列最左边的值作为支点数据。
(3)
将序列分成2部分,一部分都大于支点数据,另外一部分都小于支点数据。
(4)
对两边利用递归排序数列。
快速排序比大部分排序算法都要快。尽管我们可以在某些特殊的情况下写出比快速排序快的算法,但是就通常情况而言,没有比它更快的了。快速排序是递归的,对于内存非常有限的机器来说,它不是一个好的选择。
归并排序
归并排序先分解要排序的序列,从1分成2,2分成4,依次分解,当分解到只有1个一组的时候,就可以排序这些分组,然后依次合并回原来的序列中,这样就可以排序所有数据。合并排序比堆排序稍微快一点,但是需要比堆排序多一倍的内存空间,因为它需要一个额外的数组。
堆排序
堆排序适合于数据量非常大的场合(百万数据)。
堆排序不需要大量的递归或者多维的暂存数组。这对于数据量非常巨大的序列是合适的。比如超过数百万条记录,因为快速排序,归并排序都使用递归来设计算法,在数据量非常大的时候,可能会发生堆栈溢出错误。
堆排序会将所有的数据建成一个堆,最大的数据在堆顶,然后将堆顶数据和序列的最后一个数据交换。接下来再次重建堆,交换数据,依次下去,就可以排序所有的数据。
希尔排序
Shell排序通过将数据分成不同的组,先对每一组进行排序,然后再对所有的元素进行一次插入排序,以减少数据交换和移动的次数。平均效率是O(nlogn)。其中分组的合理性会对算法产生重要的影响。现在多用D.E.Knuth的分组方法。
Shell排序比冒泡排序快5倍,比插入排序大致快2倍。Shell排序比起QuickSort,MergeSort,HeapSort慢很多。但是它相对比较简单,它适合于数据量在5000以下并且速度并不是特别重要的场合。它对于数据量较小的数列重复排序是非常好的。
插入排序
插入排序通过把序列中的值插入一个已经排序好的序列中,直到该序列的结束。插入排序是对冒泡排序的改进。它比冒泡排序快2倍。一般不用在数据大于1000的场合下使用插入排序,或者重复排序超过200数据项的序列。
交换排序和选择排序
这两种排序方法都是交换方法的排序算法,效率都是 O(n2)。在实际应用中处于和冒泡排序基本相同的地位。它们只是排序算法发展的初级阶段,在实际中使用较少。
基数排序
基数排序和通常的排序算法并不走同样的路线。它是一种比较新颖的算法,但是它只能用于整数的排序,如果我们要把同样的办法运用到浮点数上,我们必须了解浮点数的存储格式,并通过特殊的方式将浮点数映射到整数上,然后再映射回去,这是非常麻烦的事情,因此,它的使用同样也不多。而且,最重要的是,这样算法也需要较多的存储空间。
总结
下面是一个总的表格,大致总结了我们常见的所有的排序算法的特点。
排序法 |
|
最差情形 |
稳定度 |
额外空间 |
备注 |
冒泡 |
O(n2) |
O(n2) |
|
O(1) |
n小时较好 |
交换 |
O(n2) |
O(n2) |
不稳定 |
O(1) |
n小时较好 |
选择 |
O(n2) |
O(n2) |
不稳定 |
O(1) |
n小时较好 |
插入 |
O(n2) |
O(n2) |
稳定 |
O(1) |
大部分已排序时较好 |
基数 |
O(logRB) |
O(logRB) |
稳定 |
O(n) |
B是真数(0-9),R是基数(个十百) |
Shell |
O(nlogn) |
O(ns) 1<s<2 |
不稳定 |
O(1) |
s是所选分组 |
快速 |
O(nlogn) |
O(n2) |
不稳定 |
O(nlogn) |
n大时较好 |
归并 |
O(nlogn) |
O(nlogn) |
稳定 |
O(1) |
n大时较好 |
堆 |
O(nlogn) |
O(nlogn) |
不稳定 |
O(1) |
n大时较好 |