深圳幻海软件技术有限公司 欢迎您！
更多

Java实现八大排序算法【九千字超详解】

2023-04-28

int void for
🎉博客首页：痛而不言笑而不语的浅伤📢欢迎关注🥳点赞👍收藏⭐留言📝欢迎讨论！🔮本文由痛而不言笑而不语的浅伤原创，CSDN首发！🌋系列专栏：《学习经验》🧿首发时间：2022年5月10日❤：热爱Java学习，期待一起交流！🙏🏻作者水平有限，如果发现错误，求告知，多谢！🥰有问题可以私信

🎉博客首页：痛而不言笑而不语的浅伤

📢欢迎关注🥳点赞 👍 收藏 ⭐留言 📝 欢迎讨论！

🔮本文由痛而不言笑而不语的浅伤原创，CSDN首发！

🌋系列专栏：《学习经验》

🧿首发时间：2022年5月10日

❤：热爱Java学习，期待一起交流！

🙏🏻作者水平有限，如果发现错误，求告知，多谢！

🥰有问题可以私信交流！！！

目录

一、排序的概述

排序的分类

优点及缺点

如何选择排序算法

8种排序之间的关系:

二、插入排序

分类

直接插入排序

希尔排序

三、交换排序

分类

冒泡排序法:

快速排序:

四、选择排序

分类

直接选择排序

堆排序

五、归并排序

使用方法

六、基数排序

使用方法：

总结:

按平均的时间性能来分

按平均的空间性能来分

排序方法的稳定性能

 

一、排序的概述

排序的分类

 分为5大类：

        1.插入排序(直接插入排序、希尔排序)。

        2.交换排序(冒泡排序、快速排序)。

        3.选择排序(直接选择排序、堆排序)。

        4.归并排序。

        5.分配排序(箱排序、基数排序)。

优点及缺点

        所需辅助空间最多:归并排序

        所需辅助空间最少:堆排序

        平均速度最快:快速排序

        不稳定:快速排序，希尔排序，堆排序。

如何选择排序算法

        1.数据的规模;

        2.数据的类型;

        3.数据已有的顺序。

        一般来说，当数据规模较小时，应选择直接插入排序或冒泡排序。任何排序算法在数据量小时基本体现不出来差距。考虑数据的类型，比如如果全部是正整数，那么考虑使用桶排序为最优。考虑数据已有顺序，快排是一种不稳定的排序(当然可以改进)，对于大部分排好的数据，快排会浪费大量不必要的步骤。数据量极小，而起已经基本排好序，冒泡是最佳选择。我们说快排好，是指大量随机数据下，快排效果最理想。而不是所有情况。

8种排序之间的关系:

 

二、插入排序

分类

1.直接插入排序。

2.希尔插入排序。

直接插入排序

说明

        将一个记录插入到已经排序好的有序表中。

        1.sorted数组的第0个位置没有放数据。

        2.从sorted第二个数据开始处理。

        如果该数据比它前面的数据要小，说明该数据要往前面移动。

 

 

 

用法

a.首先将该数据备份放到sorted的第0位置当哨兵。

b.然后将该数据前面那个数据后移。

c.然后往前搜索，找插入位置。

d.找到插入位置之后讲第0位置的那个数据插入对应位置。

O(n*n),当待排记录序列为正序时，时间复杂度提高至O(n)。

实例:

希尔排序

1.先将整个待排记录序列分割成若干个子序列分别进行直接插入排序。

2.待整个序列中的记录基本有序时，再对全体记录进行一次直接插入排序。

实例:

插入排序Java代码:

  1. public class InsertionSort{
  2.  
  3. //插入排序:直接插入排序，希尔排序
  4.  
  5. public void straightInsertionSort(double[]sorted){
  6.  
  7. int sortedLen=sorted.length;
  8.  
  9. for(intj=2;j<sortedLen;j++){
  10.  
  11. if(sorted[i]<sorted[j-1]){
  12.  
  13. sorted[0]=sorted[i];//先保存一下后面的那个
  14.  
  15. sorted[i]=sortedj-1];//前面的那个后移。
  16.  
  17. int insertPos=0;
  18.  
  19. for(int k=j-2;k>=0;k--){
  20.  
  21. if(sorted[k]>sorted[0]){
  22.  
  23. sorted[k+1]=sorted[k];
  24.  
  25. }else{
  26.  
  27. insertPos=k+1;
  28.  
  29. break;
  30.  
  31. }
  32.  
  33. }
  34.  
  35. sorted[insertPos]=sorted[0];
  36.  
  37. }
  38.  
  39. }
  40.  
  41. }
  42.  
  43. public void shellInertionSort(double[] sorted, int inc){
  44.  
  45. int sortedLen=sorted.length;
  46.  
  47. for(intj=inc+1:j<sortedLen;j++){
  48.  
  49. if(sorted[i]<sorted[j-inc]){
  50.  
  51. sorted[0]=sorted[i];//先保存一下后面的那个
  52.  
  53. int insertPosj;
  54.  
  55. for(int k=j-inc;k>=0;k-=inc){
  56.  
  57. if(sorted[k]>sorted[0]){
  58.  
  59. sorted[k+inc]=sorted[k];//数据结构课本上这个地方没有给出判读出错:
  60.  
  61. if(k-inc<=0){
  62.  
  63. insertPos=k;
  64.  
  65. }
  66.  
  67. }else{
  68.  
  69. insertPos=k+inc;
  70.  
  71. break;
  72.  
  73. }
  74.  
  75. }
  76.  
  77. sorted[insertPos]=sorted[0];
  78.  
  79. }
  80.  
  81. }
  82.  
  83. }
  84.  
  85.  
  86.  
  87. public void shellInsertionSort(double[] sorted){
  88.  
  89. int[]incs={7,5,3,1};
  90.  
  91. int num=incs.length;
  92.  
  93. int inc=0;
  94.  
  95. for(int j=0;j<num;j++){
  96.  
  97. inc= incs[j];
  98.  
  99. shellInertionSort(sorted,inc);
  100.  
  101. }
  102.  
  103. }
  104.  
  105.  
  106.  
  107. public static void main(String[]args){
  108.  
  109. Random random=new Random(6);
  110.  
  111. int arraysize=21;
  112.  
  113. double[]sorted=new double[arraysize];
  114.  
  115. System.out.print("Before Sort:");
  116.  
  117. for(int j=1;j<arraysize;j++){
  118.  
  119. sorted[i]=(int)(random.nextDouble()*100);
  120.  
  121. System.out.print((int)sorted[j]+"");
  122.  
  123. }
  124.  
  125. System.out.println();
  126.  
  127. InsertionSort sorter=new InsertionSort();
  128.  
  129. // sorter.straightInsertionSort(sorted);
  130.  
  131. sorter.shellInsertionSort(sorted);
  132.  
  133.  
  134.  
  135. System.out.print("After Sort:");
  136.  
  137. for(intj=1;j<sorted.length;j++){
  138.  
  139. System.out.print((int)sorted[j]+"");
  140.  
  141. }
  142.  
  143. System.out.println();
  144.  
  145. }
  146.  
  147. }

 

三、交换排序

分类

1.冒泡排序。

2.快速排序。

冒泡排序法:

        该算法是专门针对已部分排序的数据进行排序的一种排序算法。如果在你的数据清单中只有一两个数据是乱序的话，用这种算法就是最快的排序算法。如果你的数据清单中的数据是随机排列的，那么这种方法就成了最慢的算法了。因此在使用这种算法之前一定要慎重。这种算法的核心思想是扫描数据清单，寻找出现乱序的两个相邻的项目。当找到这两个项目后，交换项目的位置然后继续扫描。重复上面的操作直到所有的项目都按顺序排好。

快速排序:

        通过一趟排序，将待排序记录分割成独立的两个部分，其中一部分记录的关键字均比另一部分记录的关键字小，则可分别对这两部分记录继续进行排序，以达到整个序列有序。具体做法是:使用两个指针lowhigh，初值分别设置为序列的头，和序列的尾，设置pivotkey为第一个记录，首先从high开始向前搜索第一个小于pivotkey的记录和pivotkey所在位置进行交换，然后从low开始向后搜索第一个大于pivotkey的记录和此时pivotkey所在位置进行交换，重复知道low=high了为止。

冒泡排序Java代码:

  1. public class bubbleSort {
  2.  
  3. public bubbleSortO(){
  4.  
  5. int a[]={49,38,65,97,76,13,27,49,78,34,12,64,5,4,62,99,98,54,56,17,18,23,34,15,35,25,53,51};
  6.  
  7. int temp=0;
  8.  
  9. for(int i=0;i<a.length-1;i++){
  10.  
  11. for(int j=0;j<a.length-1-i;j++){
  12.  
  13. if(a[i]>a[j+1]){
  14.  
  15. temp=a[i];
  16.  
  17. a[i]=a[j+1];
  18.  
  19. a[j+1]=temp;
  20.  
  21. }
  22.  
  23. }
  24.  
  25. }
  26.  
  27. for(int i=0;i<a.length;i++){
  28.  
  29. System.out.println(a[i]);
  30.  
  31. }
  32.  
  33. }
  34.  
  35. }

快速排序Java代码:

  1. public class quickSort {
  2.  
  3. int a[]={49,38,65,97,76,13,27,49,78,34,12,64,5,4,62,99,98,54,56,17,18,23,34,15,35,25,53,51};
  4.  
  5. public quickSortO{ quick(a);
  6.  
  7. for(int i=0;i<a.length;i++){
  8.  
  9. System.outprintln(a[i]);
  10.  
  11. }
  12.  
  13. public int getMiddle(int list int low int high){
  14.  
  15. int tmp=list[low];//数组的第一个作为中轴
  16.  
  17. while(low<high) {
  18.  
  19. while(low<high &&list[high]>=tmp){
  20.  
  21. high--;
  22.  
  23. }
  24.  
  25. list[low]=list[high];//比中轴小的记录移到低端
  26.  
  27. while(low<high&&list[low]<=tmp){
  28.  
  29. low++;
  30.  
  31. }
  32.  
  33. list[high]=list[low];//比中轴大的记录移到高端
  34.  
  35. list[low]=tmp;//中轴记录到尾 return low;//返回中轴的位置
  36.  
  37. }
  38.  
  39. public void _quickSort(int[]list, int low int high){
  40.  
  41. if(low<high){
  42.  
  43. int middle=getMiddle(listlowhigh);//将list数组进行一分为二
  44.  
  45. quickSort(list,lowmiddle-1);//对低字表进行递归排序
  46.  
  47. quickSort(list,middle+1high);//对高字表进行递归排序
  48.  
  49. }
  50.  
  51. }
  52.  
  53. public void quick(int[] a2){
  54.  
  55. if(a2.length>0){//查看数组是否为空
  56.  
  57. quickSort(a2,0,a2.length-1);
  58.  
  59. }
  60.  
  61. }
  62.  
  63. }

 

四、选择排序

分类

1.直接选择排序。

2.堆排序

直接选择排序

第i次选取到arrayLength-1中间最小的值放在i位置。

堆排序

        首先，数组里面用层次遍历的顺序放一棵完全二叉树。从最后一个非终端结点往前面调整，直到到达根结点，这个时候除根节点以外的所有非终端节点都已经满足堆得条件了，于是需要调整根节点使得整个树满足堆得条件，于是从根节点开始，沿着它的儿子们往下面走(最大堆沿着最大的儿子走，最小堆沿着最小的儿子走)。主程序里面，首先从最后一个非终端节点开始调整到根也调整完，形成一个heap，然后将heap的根放到后面去(即:每次的树大小会变化，但是root都是在1的位置，以方便计算儿子们的index，所以如果需要升序排序，则要逐步大顶堆。因为根节点被一个个放在后面去了，降序排序则要建立小顶堆。

实例:

初始序列:46,79,56,38,40,84

建堆:

交换从堆中踢出最大数

剩余结点再建堆，再踢出最大数

依次类推:最后堆中剩余的最后两个结点交换踢出一个，排序完成。

代码中的问题:有时候第2个和第3个顺序不对(原因还没搞明白到底代码哪里有错)

选择排序Java代码:

  1. public class selectSort {
  2.  
  3. public selectSort(){
  4.  
  5. int a[]={1,54,6,3,78,34,12,45};
  6.  
  7. int position=0;
  8.  
  9. for(int i=0;i<a.length;i++){
  10.  
  11. int j=i+1;
  12.  
  13. position=i;
  14.  
  15. int temp=a[i];
  16.  
  17. for(;j<a.length;j++){
  18.  
  19. if(a[i]<temp){
  20.  
  21. temp=a[i];
  22.  
  23. position=j;
  24.  
  25. }
  26.  
  27. }
  28.  
  29. a[position]=a[i];
  30.  
  31. a[i]=temp;
  32.  
  33. }
  34.  
  35. for(int i=0;i<a.length;i++) {
  36.  
  37. System.outprintln(a[1]);
  38.  
  39. }
  40.  
  41. }
  42.  
  43. }

堆排序代码:

  1. importjava.util.Arrays;
  2.  
  3. public class HeapSort {
  4.  
  5. int a[]={49,38,65,97,76,13,27,49,78,34,12,64,5,4,62,99,98,54,56,17,18,23,34,15,35,25,53,51};
  6.  
  7. public HeapSort(){
  8.  
  9. heapSort(a);
  10.  
  11. }
  12.  
  13. public void heapSort(int[]a{
  15. System.outprintln("开始排序");
  16.  
  17. int arraylength=a.length;//循环建堆
  18.  
  19. for(int i=0;i<arrayLength-1;i++){
  20.  
  21. //建堆
  22.  
  23. buildMaxHeap(a,arrayLength-1-i);
  24.  
  25. //交换堆顶和最后一个元素
  26.  
  27. swap(a,0,arrayLength-1-i);
  28.  
  29. System.outprintln(Arrays.toString(a));
  30.  
  31. }
  32.  
  33. }
  34.  
  35. private void swap(int[] data, int i,int j){
  36.  
  37. // TODO Auto-generated method stub
  38.  
  39. int tmp=data[i];
  40.  
  41. data[i]=data[i];
  42.  
  43. data[j]=tmp;
  44.  
  45. }
  46.  
  47. //对data数组从0到lastIndex建大顶堆
  48.  
  49. private void buildMaxHeap(int] data,int lastIndex){
  50.  
  51. //TODO Auto-generated method stub
  52.  
  53. //从lastIndex处节点(最后一个节点)的父节点开始
  54.  
  55. for(int i=(lastIndex-1)/2;i>=0;i--){
  56.  
  57. //K保存正在判断的节点
  58.  
  59. int k=i;
  60.  
  61. //如果当前k节点的子节点存在
  62.  
  63. while(k*2+1<=lastIndex){
  64.  
  65. //k节点的左子节点的索引
  66.  
  67. int biggerIndex=2*k+1;
  68.  
  69. //如果biggerIndex小于lastIndex，即biggerIndex+1代表的k节点的右子节点存在
  70.  
  71. if(biggerIndex<lastIndex){
  72.  
  73. //如果右子节点的值较大
  74.  
  75. if(data[biggerIndex]<data[biggerIndex+1]){
  76.  
  77. //biggerIndex总是记录较大子节点的索引
  78.  
  79. biggerIndex++;
  80.  
  81. }
  82.  
  83. }
  84.  
  85.  
  86.  
  87. //如果k节点的值小于其较大的子节点的值
  88.  
  89. if(data[k]<data[biggerIndex]){
  90.  
  91. //交换他们
  92.  
  93. swap(data,k,biggerIndex);
  94.  
  95. //将biggerIndex赋予k，开始while循环的下一次循环，重新保证k节点的值大于其左右子节点的值
  96.  
  97. k=biggerIndex;
  98.  
  99. }else{
  100.  
  101. break;
  102.  
  103. }
  104.  
  105. }
  106.  
  107. }
  108.  
  109. }

五、归并排序

使用方法

        将两个或两个以上的有序表组合成一个新的有序表。归并排序要使用一个辅助数组，大小跟原数组相同，递归做法。每次将目标序列分解成两个序列，分别排序两个子序列之后，再将两个排序好的子序列merge到一起。

归并排序Java代码:

  1. public class MergeSort {
  2.  
  3. private double[]bridge;//辅助数组
  4.  
  5. public void sort(double[] obj){
  6.  
  7. if(obj==null){
  8.  
  9. throw new NullPointerException("The param can not be null!");
  10.  
  11. }
  12.  
  13. bridge=new double[obj.length];//初始化中间数组
  14.  
  15. mergeSort(obj,,obj.length-1);//归并排序
  16.  
  17. bridge =null;
  18.  
  19. }
  20.  
  21. private void mergeSort(double[] obj,int left,int right){
  22.  
  23. if(left<right){
  24.  
  25. int center=(left+right)/2; mergeSort(obj,left,center);
  26.  
  27. mergeSort(obj,center+1,right) merge(obj,left,center, right);
  28.  
  29. }
  30.  
  31. }
  32.  
  33. private void merge(double[] obj,int left,int center, int right){
  34.  
  35. intmid=center+1;
  36.  
  37. int third=left;
  38.  
  39. int tmp=left;
  40.  
  41. while(left<=center && mid<=right){
  42.  
  43. //从两个数组中取出小的放入中间数组
  44.  
  45. if(obj[left]-obj[mid]<=10e-6){
  46.  
  47. bridge[third++]=obj[left++];
  48.  
  49. } else{
  50.  
  51. bridge[third++]=obj[mid++];
  52.  
  53. }
  54.  
  55. }
  56.  
  57. //剩余部分依次置入中间数组
  58.  
  59. while(mid<=right){
  60.  
  61. bridge[third++]=obj[mid++];
  62.  
  63. }
  64.  
  65. while(left<=center){
  66.  
  67. bridge[third++]=obj[left++];
  68.  
  69. }
  70.  
  71. /将中间数组的内容拷贝回原数组
  72.  
  73. copy(obj, tmp, right);
  74.  
  75. }
  76.  
  77. private void copy(double[]obj,int left, int right){
  78.  
  79. while (left <= right){
  80.  
  81. obj[left] = bridge[left];
  82.  
  83. left++;
  84.  
  85. }
  86.  
  87. }
  88.  
  89. public static void main(String[] args){
  90.  
  91. Random random=new Random(6);
  92.  
  93.  
  94.  
  95. int arraysize=10;
  96.  
  97. double[] sorted=new double[arraysize];
  98.  
  99. System.outprint("Before Sort:");
  100.  
  101. for(intj=0;j<arraysize;j++) {
  102.  
  103. sorted[i]=(int)(random.nextDouble()*100);
  104.  
  105. System.outprint((int)sorted[i]+"");
  106.  
  107. }
  108.  
  109. System.outprintln();
  110.  
  111. MergeSort sorter=new MergeSort();
  112.  
  113. sorter.sort(sorted);
  114.  
  115.  
  116.  
  117. System.out.print("After Sort:");
  118.  
  119. for (intj=0;j<sorted.length;j++){
  120.  
  121. System.out.print((int) sorted[i]+"");
  122.  
  123. }
  124.  
  125. System.outprintln();
  126.  
  127. }
  128.  
  129. }

六、基数排序

使用方法：

        使用10个辅助队列，假设最大数的数字位数为 x，则一共做x次，从个位数开始往前，以第i位数字的大小为依据，将数据放进辅助队列，搞定之后回收。下次再以高一位开始的数字位为依据。

以Vector作辅助队列，基数排序的Java代码:

  1. public class RadixSort {
  2.  
  3. private int keyNum=-1;
  4.  
  5. private Vector<Vector<Double>> util;
  6.  
  7. public void distribute(double []sorted,int nth){
  8.  
  9. if(nth<=keyNum && nth>0){
  10.  
  11. util=new Vector<Vector<Double>>();
  12.  
  13. for(intj=0;j<10;j++){
  14.  
  15. Vector <Double>temp=new Vector<Double>();
  16.  
  17. util.add(temp);
  18.  
  19. }
  20.  
  21. for(int j=0;j<sorted.length;j++){
  22.  
  23. int index=getNthDigit(sorted[i],nth);
  24.  
  25. util.get(index).add(sorted[j]);
  26.  
  27. }
  28.  
  29. }
  30.  
  31. }
  32.  
  33. public int getNthDigit(double num,int nth){
  34.  
  35. String nn=Integer.toString((int)num);
  36.  
  37. int len=nn.length();
  38.  
  39. if(len>=nth){
  40.  
  41. return CharactergetNumericValue(nncharAt(len nth));
  42.  
  43. }else{
  44.  
  45. return 0;
  46.  
  47. }
  48.  
  49. }
  50.  
  51. public void collect(double[]sorted){
  52.  
  53. int k=0;
  54.  
  55. for(int j=0;j<10;j++){
  56.  
  57. int len=util.get(j).size();
  58.  
  59. if(len>0){
  60.  
  61. for(int i=0;i<len;i++){
  62.  
  63. sorted[k++]=utilget(i).get(i);
  64.  
  65. }
  66.  
  67. }
  68.  
  69. }
  70.  
  71. util=null;
  72.  
  73. }
  74.  
  75. public int getKeyNum(double[] sorted){
  76.  
  77. double max=Double.MIN VALUE:;
  78.  
  79. for(int j=0;j<sorted.length;j++){
  80.  
  81. if(sorted[j]>max){
  82.  
  83. max=sorted [j];
  84.  
  85. }
  86.  
  87. }
  88.  
  89. return Integer.toString((int)max).length();
  90.  
  91. }
  92.  
  93. public void radixSort(double[] sorted){
  94.  
  95. if(keyNum==-1){
  96.  
  97. keyNum= getKeyNum(sorted);
  98.  
  99. }
  100.  
  101. for(int i=1;i<=keyNum;i++){
  102.  
  103. distribute(sorted,i);
  104.  
  105. collect(sorted);
  106.  
  107. }
  108.  
  109. }
  110.  
  111. public static void main(String[]args){
  112.  
  113. Random random=new Random(6);
  114.  
  115. int arraysize=21;
  116.  
  117. double[]sorted=new double[arraysize] ;
  118.  
  119. System.outprint("Before Sort:");
  120.  
  121. for(intj=0;j<arraysize;j++){
  122.  
  123. sorted[j]=(int)(random.nextDouble()* 100);
  124.  
  125. System.outprint((int)sorted[j]+"");
  126.  
  127. }
  128.  
  129. System.out.println();
  130.  
  131.  
  132.  
  133. RadixSort sorter=new RadixSort();
  134.  
  135. sorterradixSort(sorted);
  136.  
  137.  
  138.  
  139. System.out.print("After Sort:")
  140.  
  141. for(intj=0;j<sorted.length;j++){
  142.  
  143. System.outprint((int)sorted[j]+" ");
  144.  
  145. }
  146.  
  147. System.out.println();
  148.  
  149. }
  150.  
  151. }

总结:

按平均的时间性能来分

 

1.时间复杂度为O(nlogn)的方法有:快速排序、堆排序和归并排序，其中以快速排序为最好;

2.时间复杂度为O(n2)的有:直接插入排序、冒泡排序和简单选择排序，其中以直接插入为最好，特别是对那些对关键字近似有序的记录序列尤为如此;

3.时间复杂度为O(n)的排序方法只有，基数排序。

        当待排记录序列按关键字顺序有序时，直接插入排序和起泡排序能达到O(n)的时间复杂度;而对于快速排序而言，这是最不好的情况，此时的时间性能蜕化为O(n2)，因此是应该尽量避免的情况。简单选择排序、堆排序和归并排序的时间性能不随记录序列中关键字的分布而改变。

按平均的空间性能来分

(指的是排序过程中所需的辅助空间大小):

1.所有的简单排序方法(包括:直接插入、冒泡和简单选择)和堆排序的空间复杂度为O(1);

2.快速排序为O(logn)，为栈所需的辅助空间；

3.归并排序所需辅助空间最多，其空间复杂度为O(n );

4.链式基数排序需附设队列首尾指针，则空间复杂度为O(rd)。

排序方法的稳定性能

1.稳定的排序方法指的是，对于两个关键字相等的记录，它们在序列中的相对位置，在排序之前和经过排序之后，没有改变。

2.当对多关键字的记录序列进行LSD方法排序时，必须采用稳定的排序方法。

3.对于不稳定的排序方法，只要能举出一个实例说明即可。

4.快速排序，希尔排序和堆排序是不稳定的排序方法。

     

 

        最后，大家重点要掌握每个排序算法的使用方法、还有如何选择，在什么样的情况下用什么的排序算法，以达到效率最好，使用后最优化代码。

好啦！今天的练习就到这里。看吧这么努力的你又学到了很多，新的一天加油鸭！！！

【完】

你的点赞是对我最大的鼓励。

你的收藏是对我文章的认可。

你的关注是对我创作的动力。

 

 

文章知识点与官方知识档案匹配，可进一步学习相关知识
算法技能树首页概览45247 人正在系统学习中
华杰科技工作室
微信公众号
创新突破，力争超越自我。
【算法系列篇】滑动窗口
走进人工智能|深度学习 算法的创世纪