Angelo Lee's Blog
This is my kingdom .If i don't fight for it ,who will ?
java排序算法实现代码

JAVA排序算法实现代码-快速(Quick Sort)排序

 
  1. /**  
  2.  * JAVA排序算法实现代码-快速(Quick Sort)排序。  
  3.  *   
  4.  * @author 老紫竹 JAVA世纪网(java2000.net)  
  5.  *   
  6.  */  
  7. public class Test {   
  8.   public static int[] a = { 10, 32, 1, 9, 5, 7, 12, 0, 4, 3 }; // 预设数据数组   
  9.   
  10.   public static void main(String args[]) {   
  11.   
  12.     System.out.print("排序前: ");   
  13.     for (int i = 0; i < a.length; i++)   
  14.       System.out.printf("%3s", a[i]);   
  15.   
  16.     System.out.println("");   
  17.   
  18.     int Index = a.length;   
  19.   
  20.     QuickSort(0, Index - 1, Index); // 快速排序   
  21.   
  22.     // 排序后结果   
  23.     System.out.print("排序后: ");   
  24.     for (int i = 0; i < a.length; i++)   
  25.       System.out.printf("%3s", a[i]);   
  26.   
  27.     System.out.println("");   
  28.   }   
  29.   
  30.   public static void QuickSort(int Left, int Right, int Index) {   
  31.     int i, j, k; // 循环计数变量   
  32.     int Pivot; // 枢纽变量   
  33.     int Temp; // 暂存变量   
  34.   
  35.     i = Left; // 设定左指针   
  36.     j = Right; // 设定右指针   
  37.   
  38.     Pivot = a[Left]; // 取最左边的元素   
  39.   
  40.     if (i < j) {   
  41.       do {   
  42.         while (a[i] <Pivot && i < Right) // 从左往右找比Pivot大的值   
  43.         {   
  44.           i++;   
  45.         }   
  46.         while (a[j] > Pivot && j > Left) // 从右往左找比Pivot小的值   
  47.         {   
  48.           j--;   
  49.         }   
  50.   
  51.         if (i < j) // 交换a[i]和a[j]   
  52.         {   
  53.           Temp = a[i];   
  54.           a[i] = a[j];   
  55.           a[j] = Temp;   
  56.         }   
  57.       } while (i < j);   
  58.       if (i > j) {   
  59.         Temp = a[Left]; // 交换a[Left]和a[j]   
  60.         a[Left] = a[j];   
  61.         a[j] = Temp;   
  62.   
  63.         // 打印目前排序结果   
  64.   
  65.         System.out.print("排序中: ");   
  66.         for (k = 0; k <= Index; k++) {   
  67.           System.out.printf("%3s", a[k]);   
  68.         }   
  69.         System.out.println("");   
  70.       }   
  71.       QuickSort(Left, j - 1, Index); // 排序左半边   
  72.       QuickSort(j + 1, Right, Index); // 排序右半边   
  73.     }   
  74.   }   
  75. }  


运行结果
排序前: 10 32 1 9 5 7 12 0 4 3
排序后: 0 1 3 4 5 7 9 10 12 32
 

JAVA排序算法实现代码-冒泡(Bubble Sort)排序

 
  1. /**  
  2.  * JAVA排序算法实现代码-冒泡(Bubble Sort)排序。  
  3.  *   
  4.  * @author 老紫竹 JAVA世纪网(java2000.net)  
  5.  *   
  6.  */  
  7. public class Test {   
  8.   public static void main(String[] args) {   
  9.     int[] a = { 10, 32, 1, 9, 5, 7, 12, 0, 4, 3 };   
  10.   
  11.     System.out.print("排序前: ");   
  12.   
  13.     for (int i = 0; i < a.length; i++)   
  14.       System.out.printf("%3s", a[i]);   
  15.   
  16.     System.out.println();   
  17.   
  18.     Test test = new Test();   
  19.     test.bubbleSort(a);   
  20.   
  21.     System.out.print("排序后: ");   
  22.   
  23.     for (int i = 0; i < a.length; i++)   
  24.       System.out.printf("%3s", a[i]);   
  25.   
  26.     System.out.println();   
  27.   }   
  28.   
  29.   public void bubbleSort(int[] a) {   
  30.     int len = a.length;   
  31.   
  32.     System.out.println("数组大小是:" + len);   
  33.   
  34.     boolean change = false;   
  35.     int temp;   
  36.     int count = 0;   
  37.   
  38.     for (int i = len; i > 1; i--) {   
  39.       for (int j = 0; j < i - 1; j++) {   
  40.         if (a[j + 1] < a[j]) {   
  41.           temp = a[j + 1];   
  42.           a[j + 1] = a[j];   
  43.           a[j] = temp;   
  44.           change = true;   
  45.           count++;   
  46.         }   
  47.   
  48.       }   
  49.       if (change) {   
  50.         System.out.print("第" + count + "趟交换:  ");   
  51.         for (int k = 0; k < len; k++)   
  52.           System.out.print(a[k] + " ");   
  53.   
  54.         System.out.println();   
  55.       }   
  56.     }   
  57.   }   
  58. }  


运行结果
排序前: 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)排序

 
  1. /**  
  2.  * JAVA排序算法实现代码-堆(Heap)排序。  
  3.  *   
  4.  * @author 老紫竹 JAVA世纪网(java2000.net)  
  5.  *   
  6.  */  
  7. public class Test {   
  8.   public static int[] Heap = { 10, 32, 1, 9, 5, 7, 12, 0, 4, 3 }; // 预设数据数组   
  9.   
  10.   public static void main(String args[]) {   
  11.     int i; // 循环计数变量   
  12.     int Index = Heap.length; // 数据索引变量   
  13.   
  14.     System.out.print("排序前: ");   
  15.     for (i = 1; i < Index - 1; i++)   
  16.       System.out.printf("%3s", Heap[i]);   
  17.     System.out.println("");   
  18.   
  19.     HeapSort(Index - 2); // 堆排序   
  20.   
  21.     System.out.print("排序后: ");   
  22.     for (i = 1; i < Index - 1; i++)   
  23.       System.out.printf("%3s", Heap[i]);   
  24.     System.out.println("");   
  25.   }   
  26.   
  27.   /**  
  28.    * 建立堆  
  29.    */  
  30.   public static void CreateHeap(int Root, int Index) {   
  31.     int i, j; // 循环计数变量   
  32.     int Temp; // 暂存变量   
  33.     int Finish; // 判断堆是否建立完成   
  34.   
  35.     j = 2 * Root; // 子节点的Index   
  36.     Temp = Heap[Root]; // 暂存Heap的Root 值   
  37.     Finish = 0; // 预设堆建立尚未完成   
  38.   
  39.     while (j <= Index && Finish == 0) {   
  40.       if (j < Index) // 找最大的子节点   
  41.         if (Heap[j] < Heap[j + 1])   
  42.           j++;   
  43.       if (Temp >= Heap[j])   
  44.         Finish = 1; // 堆建立完成   
  45.       else {   
  46.         Heap[j / 2] = Heap[j]; // 父节点 = 目前节点   
  47.         j = 2 * j;   
  48.       }   
  49.     }   
  50.     Heap[j / 2] = Temp; // 父节点 = Root值   
  51.   }   
  52.   
  53.   public static void HeapSort(int Index) {   
  54.     int i, j, Temp;   
  55.     // 将二叉树转成Heap   
  56.     for (i = (Index / 2); i >= 1; i--)   
  57.       CreateHeap(i, Index);   
  58.   
  59.     // 开始进行堆排序   
  60.     for (i = Index - 1; i >= 1; i--) {   
  61.       Temp = Heap[i + 1]; // Heap的Root值和最后一个值交换   
  62.       Heap[i + 1] = Heap[1];   
  63.       Heap[1] = Temp;   
  64.       CreateHeap(1, i); // 对其余数值重建堆   
  65.   
  66.       System.out.print("排序中: ");   
  67.       for (j = 1; j <= Index; j++)   
  68.         System.out.printf("%3s",Heap[j]);   
  69.       System.out.println("");   
  70.     }   
  71.   }   
  72. }  


运行结果
排序前: 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)式排序

 
  1. /**  
  2.  * JAVA排序算法实现代码-选择(Select)式排序。  
  3.  *   
  4.  * @author 老紫竹 JAVA世纪网(java2000.net)  
  5.  *   
  6.  */  
  7. public class Test {   
  8.   public static int[] a = { 10, 32, 1, 9, 5, 7, 12, 0, 4, 3 }; // 预设数据数组   
  9.   
  10.   public static void main(String args[]) {   
  11.     int i; // 循环计数变量   
  12.     int Index = a.length;// 数据索引变量   
  13.   
  14.     System.out.print("排序前: ");   
  15.     for (i = 0; i < Index - 1; i++)   
  16.       System.out.printf("%3s", a[i]);   
  17.     System.out.println("");   
  18.   
  19.     SelectSort(Index - 1); // 选择排序   
  20.     // 排序后结果   
  21.     System.out.print("排序后: ");   
  22.     for (i = 0; i < Index - 1; i++)   
  23.       System.out.printf("%3s", a[i]);   
  24.     System.out.println("");   
  25.   }   
  26.   
  27.   public static void SelectSort(int Index) {   
  28.     int i, j, k; // 循环计数变量   
  29.     int MinValue; // 最小值变量   
  30.     int IndexMin; // 最小值索引变量   
  31.     int Temp; // 暂存变量   
  32.   
  33.     for (i = 0; i < Index - 1; i++) {   
  34.       MinValue = 32767; // 目前最小数值   
  35.       IndexMin = 0; // 储存最小数值的索引值   
  36.       for (j = i; j < Index; j++) {   
  37.         if (a[j] < MinValue) // 找到最小值   
  38.         {   
  39.           MinValue = a[j]; // 储存最小值   
  40.           IndexMin = j;   
  41.         }   
  42.         Temp = a[i]; // 交换两数值   
  43.         a[i] = a[IndexMin];   
  44.         a[IndexMin] = Temp;   
  45.       }   
  46.   
  47.       System.out.print("排序中: ");   
  48.       for (k = 0; k < Index; k++)   
  49.         System.out.printf("%3s", a[k]);   
  50.       System.out.println("");   
  51.     }   
  52.   }   
  53. }  


运行结果
排序前: 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排序算法实现代码-二叉树排序

 
  1. /**  
  2.  * JAVA排序算法实现代码-二叉树排序。  
  3.  *   
  4.  * @author 老紫竹 JAVA世纪网(java2000.net)  
  5.  *   
  6.  */  
  7. public class Test {   
  8.   public static int[] a = { 0, 10, 32, 1, 9, 5, 7, 12, 2, 4, 3 }; // 预设数据数组   
  9.   public static int[] Data = new int[20]; // 预设数据数组   
  10.   
  11.   public static void main(String args[]) {   
  12.     int i; // 循环计数变量   
  13.     int Index = 1; // 数据索引变量   
  14.     BNTreeArray BNTree = new BNTreeArray(); // 声明二叉树数组   
  15.   
  16.     Data[Index] = a[Index];   
  17.     BNTreeArray.TreeData[0] = Data[Index];   
  18.     Index++;   
  19.     for (i = 2; i < a.length; i++) {   
  20.       Data[Index] = a[Index];   
  21.       BNTree.Create(Data[Index]); // 建立二叉查找树   
  22.       Index++;   
  23.     }   
  24.   
  25.     // 排序前数据内容   
  26.     System.out.print("排序前 : ");   
  27.     for (i = 1; i < Index; i++)   
  28.       System.out.print(" " + Data[i] + " ");   
  29.     System.out.println("");   
  30.   
  31.     // 排序后结果   
  32.     System.out.print("排序后 : ");   
  33.     BNTreeArray.InOrder(0); // 中序遍历   
  34.   }   
  35. }   
  36.   
  37. class BNTreeArray {   
  38.   public static int MaxSize = 20;   
  39.   public static int[] TreeData = new int[MaxSize];   
  40.   public static int[] RightNode = new int[MaxSize];   
  41.   public static int[] LeftNode = new int[MaxSize];   
  42.   
  43.   public BNTreeArray() {   
  44.     int i; // 循环计数变量   
  45.   
  46.     for (i = 0; i < MaxSize; i++) {   
  47.       TreeData[i] = 0;   
  48.       RightNode[i] = -1;   
  49.       LeftNode[i] = -1;   
  50.     }   
  51.   }   
  52.   
  53.   // ----------------------------------------------------   
  54.   // 建立二叉树   
  55.   // ----------------------------------------------------   
  56.   public void Create(int Data) {   
  57.     int i; // 循环计数变量   
  58.     int Level = 0; // 树的阶层数   
  59.     int Position = 0;   
  60.   
  61.     for (i = 0; TreeData[i] != 0; i++)   
  62.       ;   
  63.   
  64.     TreeData[i] = Data;   
  65.     while (true) // 寻找节点位置   
  66.     {   
  67.       // 判断是左子树或是右子树   
  68.       if (Data > TreeData[Level]) {   
  69.         // 右树是否有下一阶层   
  70.         if (RightNode[Level] != -1)   
  71.           Level = RightNode[Level];   
  72.         else {   
  73.           Position = -1; // 设定为右树   
  74.           break;   
  75.         }   
  76.       } else {   
  77.         // 左树是否有下一阶层   
  78.         if (LeftNode[Level] != -1)   
  79.           Level = LeftNode[Level];   
  80.         else {   
  81.           Position = 1; // 设定为左树   
  82.           break;   
  83.         }   
  84.       }   
  85.     }   
  86.   
  87.     if (Position == 1) // 建立节点的左右连结   
  88.       LeftNode[Level] = i; // 连结左子树   
  89.     else  
  90.       RightNode[Level] = i; // 连结右子树   
  91.   }   
  92.   
  93.   // ---------------------------------------------------------   
  94.   // 二叉树中序遍历   
  95.   // ---------------------------------------------------------   
  96.   public static void InOrder(int Pointer) {   
  97.     if (Pointer != -1) // 遍历的终止条件   
  98.     {   
  99.       InOrder(LeftNode[Pointer]); // 处理左子树   
  100.       // 处理打印节点内容   
  101.       System.out.print(" " + TreeData[Pointer] + " ");   
  102.       InOrder(RightNode[Pointer]); // 处理右子树   
  103.     }   
  104.   }   
  105. }  


运行结果
排序前 : 10 32 1 9 5 7 12 2 4 3
排序后 : 1 2 3 4 5 7 9 10 12 32

JAVA排序算法实现代码-希尔Shell排序

 
  1. /**  
  2.  * JAVA排序算法实现代码-希尔Shell排序。  
  3.  *   
  4.  * @author 老紫竹 JAVA世纪网(java2000.net)  
  5.  *   
  6.  */  
  7. public class Test {   
  8.   public static int[] a = { 10, 32, 1, 9, 5, 7, 12, 0, 4, 3 }; // 预设数据数组   
  9.   
  10.   public static void main(String args[]) {   
  11.     int i; // 循环计数变量   
  12.     int Index = a.length;// 数据索引变量   
  13.   
  14.     System.out.print("排序前: ");   
  15.     for (i = 0; i < Index - 1; i++)   
  16.       System.out.printf("%3s ", a[i]);   
  17.     System.out.println("");   
  18.   
  19.     ShellSort(Index - 1); // 选择排序   
  20.     // 排序后结果   
  21.     System.out.print("排序后: ");   
  22.     for (i = 0; i < Index - 1; i++)   
  23.       System.out.printf("%3s ", a[i]);   
  24.     System.out.println("");   
  25.   }   
  26.   
  27.   public static void ShellSort(int Index) {   
  28.     int i, j, k; // 循环计数变量   
  29.     int Temp; // 暂存变量   
  30.     boolean Change; // 数据是否改变   
  31.     int DataLength; // 分割集合的间隔长度   
  32.     int Pointer; // 进行处理的位置   
  33.   
  34.     DataLength = (int) Index / 2; // 初始集合间隔长度   
  35.   
  36.     while (DataLength != 0) // 数列仍可进行分割   
  37.     {   
  38.       // 对各个集合进行处理   
  39.       for (j = DataLength; j < Index; j++) {   
  40.         Change = false;   
  41.         Temp = a[j]; // 暂存Data[j]的值,待交换值时用   
  42.         Pointer = j - DataLength; // 计算进行处理的位置   
  43.   
  44.         // 进行集合内数值的比较与交换值   
  45.         while (Temp < a[Pointer] && Pointer >= 0 && Pointer <= Index) {   
  46.           a[Pointer + DataLength] = a[Pointer];   
  47.           // 计算下一个欲进行处理的位置   
  48.           Pointer = Pointer - DataLength;   
  49.           Change = true;   
  50.           if (Pointer < 0 || Pointer > Index)   
  51.             break;   
  52.         }   
  53.         // 与最后的数值交换   
  54.         a[Pointer + DataLength] = Temp;   
  55.   
  56.         if (Change) {   
  57.           // 打印目前排序结果   
  58.           System.out.print("排序中: ");   
  59.           for (k = 0; k < Index; k++)   
  60.             System.out.printf("%3s ", a[k]);   
  61.           System.out.println("");   
  62.         }   
  63.       }   
  64.       DataLength = DataLength / 2; // 计算下次分割的间隔长度   
  65.     }   
  66.   }   
  67. }  


运行结果
排序前: 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排序算法实现代码-插入排序

 
  1. /**  
  2.  * JAVA排序算法实现代码-插入排序。  
  3.  *   
  4.  * @author 老紫竹 JAVA世纪网(java2000.net)  
  5.  *   
  6.  */  
  7. public class Test {   
  8.   public static int[] a = { 10, 32, 1, 9, 5, 7, 12, 0, 4, 3 }; // 预设数据数组   
  9.   
  10.   public static void main(String args[]) {   
  11.     int i; // 循环计数变量   
  12.     int Index = a.length;// 数据索引变量   
  13.   
  14.     System.out.print("排序前: ");   
  15.     for (i = 0; i < Index - 1; i++)   
  16.       System.out.print(" " + a[i] + " ");   
  17.     System.out.println("");   
  18.   
  19.     InsertSort(Index - 1); // 选择排序   
  20.     // 排序后结果   
  21.     System.out.print("排序后: ");   
  22.     for (i = 0; i < Index - 1; i++)   
  23.       System.out.print(" " + a[i] + " ");   
  24.     System.out.println("");   
  25.   }   
  26.   
  27.   public static void InsertSort(int Index) {   
  28.     int i, j, k; // 循环计数变量   
  29.     int InsertNode; // 欲插入数据变量   
  30.   
  31.     for (i = 1; i < Index; i++) // 依序插入数值   
  32.     {   
  33.       InsertNode = a[i]; // 设定欲插入的数值   
  34.       j = i - 1; // 欲插入数组的开始位置   
  35.       // 找适当的插入位置   
  36.       while (j >= 0 && InsertNode < a[j]) {   
  37.         a[j + 1] = a[j];   
  38.         j--;   
  39.       }   
  40.       a[j + 1] = InsertNode; // 将数值插入   
  41.       // 打印目前排序结果   
  42.       System.out.print("排序中: ");   
  43.       for (k = 0; k < Index; k++)   
  44.         System.out.print(" " + a[k] + " ");   
  45.       System.out.println("");   
  46.     }   
  47.   }   
  48. }  


运行结果
排序前: 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(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大时较好



posted on 2008-12-05 12:58  Angelo Lee  阅读(205)  评论(0)  编辑  收藏  举报

Copyright © 2024 Angelo Lee
Powered by .NET 9.0 on Kubernetes Powered By博客园