十大排序算法（Java）

深藏阁楼爱情的钟 2022-11-27 05:24 369阅读 0赞

文章目录

  • 十大排序算法（Java）
      • 一、冒泡排序（Bubble Sort）
      • 二、选择排序（Selection Sort）
      • 三、堆排序（Heap Sort）
      • 四、插入排序（Insertion Sort）
      • 五、归并排序（Merge Sort）
      • 六、快速排序（Quick Sort）
      • 七、希尔排序（Shell Sort）
      • 八、计数排序（Counting Sort）
      • 九、基数排序（Radix Sort）
      • 十、桶排序（Bucket Sort）
      • 扩展：十一、史上“最强”排序-休眠排序666（仅供参考，不要用！！）

十大排序算法（Java）

小猴子自定义口诀（瞎编的，哈哈）：冒泡两个两个对比，选择最大的排在最后，插入前面有序列表，归并先分区后合并，快速将一列数划分小于pivot在左边大于pivot在右边再依次递归左右子列，希尔分列排序每列排序算法借用插入；以上是基于比较的排序算法

以下不是基于比较的排序算法，（以空间换时间），计数计算每个数出现的次数然后从小到大排序，基数非常适合非负整数个十百分别比较，桶是把每个数分到相应的桶再排序

各个排序图片归纳：

在这里插入图片描述

一、冒泡排序（Bubble Sort）

冒泡排序是一种简单的排序算法。它重复地走访过要排序的数列，一次比较两个元素，如果它们的顺序错误就把它们交换过来。走访数列的工作是重复地进行直到没有再需要交换，也就是说该数列已经排序完成。这个算法的名字由来是因为越小的元素会经由交换慢慢“浮”到数列的顶端。

  1. //原始排序（无优化）
  2. public void bubbleSort(Integer[] array){ 
  3.   for(int end=array.length-1;end>0;end--){ 
  4.     for(int begin=1;begin<=end;begin++){ 
  5.       if(array[begin] < array[begin-1]){ 
  6.         int temp = array[begin];
  7.         array[begin] = array[begin-1];
  8.         array[begin-1] = temp;
  9.       }
  10.     }
  11.   }
  12. }
  14. //优化方案1（当数组完全有序或者数组在循环少量次数后就有序时）
  15. public void bubbleSort1(Integer[] array){ 
  16.   for(int end=array.length-1;end>0;end--){ 
  17.     boolean sorted = true;
  18.     for(int begin=1;begin<=end;begin++){ 
  19.       if(array[begin] < array[begin-1]){ 
  20.         int temp = array[begin];
  21.         array[begin] = array[begin-1];
  22.         array[begin-1] = temp;
  23.         sorted = false;
  24.       }
  25.     }
  26.     if(sorted){ 
  27.       break;
  28.     }
  29.   }
  30. }
  32. //优化方案2（当数组中后面部分完全有序）
  33. public void bubbleSort2(Integer[] array){ 
  34.   for(int end=array.length-1;end>0;end--){ 
  35.     //sortedIndex的初始值在数组完全有序的时候有用
  36.     int sortedIndex = 1;
  37.     for(int begin=1;begin<=end;begin++){ 
  38.       if(array[begin] < array[begin-1]){ 
  39.         int temp = array[begin];
  40.         array[begin] = array[begin-1];
  41.         array[begin-1] = temp;
  42.         sortedIndex = begin;
  43.       }
  44.     }
  45.     end = sortedIndex;
  46.   }
  47. }

二、选择排序（Selection Sort）

选择排序(Selection-sort)是一种简单直观的排序算法。它的工作原理：首先在未排序序列中找到最小（大）元素，存放到排序序列的起始位置，然后，再从剩余未排序元素中继续寻找最小（大）元素，然后放到已排序序列的末尾。以此类推，直到所有元素均排序完毕。

  1. public void selectionSort(Integer[] arr){ 
  2.    for(int end=arr.length-1;end>0;end--){ 
  3.      int maxIndex = 0;
  4.      for(int begin=1;begin<=end;begin++){ 
  5.        if(arr[maxIndex] <= arr[begin]){  //增加其稳定性（=）
  6.          maxIndex = begin;
  7.        }
  8.      }
  9.      int temp = arr[maxIndex];
  10.      arr[maxIndex] = arr[end];
  11.      arr[end] = temp;
  12.   }
  13. }

三、堆排序（Heap Sort）

（可以看做对选择排序的优化）

堆排序（Heap-sort）是指利用堆这种数据结构所设计的一种排序算法。堆积是一个近似完全二叉树的结构，并同时满足堆积的性质：即子结点的键值或索引总是小于（或者大于）它的父节点。

  1. //重构代码，写一个父类，其他排序都继承这个抽象类，重写sort方法
  2. public abstract class Sort{ 
  3.   protected Integer[] arr;
  4.   protected int cmpCount; //比较的次数 
  5.   protected int swapCount; //交换的次数 
  6.   private long time;
  8.   public void sort(Integer[] arr){ 
  9.     if(arr == null || arr.length < 2) return;
  10.     this.arr = arr;
  11.     long begin = System.currentTimeMillis();
  12.     sort();
  13.     time = System.currentTimeMillis() - begin;//运行时间
  14.   }
  16.   protected abstract void sort();
  18.   //比较：等于0 arr[i] == arr[j]
  19.   //小于0 arr[i] < arr[j]
  20.   //大于0 arr[i] > arr[j]
  21.   protected int cmp(int i,int j){ 
  22.     cmpCount++;
  23.     return arr[i] - arr[j];
  24.   }
  26.   //比较元素大小
  27.   protected int compare(Integer v1,Integer v2){ 
  28.     return v1 - v2;
  29.   }
  31.   //交换
  32.   protected void swap(int i,int j){ 
  33.     swapCount++;
  34.     int temp = arr[i];
  35.     arr[i] = arr[j];
  36.     arr[j] = temp;
  37.   }
  39.   @Override
  40.   public String toString(){ 
  41.     String string = getClass().getSimpleName()+" "+"耗时："+(time/1000.0)+"s("+time+"ms)";
  42.     return string;
  43.   }
  44. }
  45. //注：上面两个排序的代码可重写，这里我就不写了
  47. //交换堆顶元素与尾元素
  48. //堆的元素数量减1
  49. //对0位置进行1次shiftDown操作
  50. public class HeapSort extends Sort{ 
  51.   private int heapSize;
  53.   @Override
  54.   protected void sort(){ 
  55.     heapSize = arr.length; 
  56.     //原地建堆
  57.     //heapSize>>1表示把heapSize右移1位，相当于heapSize/2
  58.     for(int i = (heapSize >> 1)-1;i >= 0;i--){  
  59.       shiftDown(i);
  60.     }
  62.     while(heapSize > 1){ 
  63.       //交换堆顶元素与尾元素
  64.       //swap(0,heapSize-1);
  65.       //heapSize--;
  66.       swap(0,--heapSize);//合并以上两步
  68.       //对0位置进行1次shiftDown操作(恢复堆的性质)
  69.       shiftDown(0);
  70.     }
  71.   }
  73.   private void shiftDown(int index){ 
  74.     Integer element = arr[index];
  76.     int half = heapSize >> 1;
  77.     while(index < half){  //index必须是非叶子节点
  78.       //默认是左边跟父节点比
  79.       int childIndex = (index << 1)+1;
  80.       Integer child = arr[childIndex];
  81.       //右子节点比左子节点大
  82.       int rightIndex = childIndex + 1;
  83.       if(rightIndex < heapSize && compare(arr[rightIndex],child) > 0){ 
  84.         child = arr[childIndex = rightIndex];
  85.       }
  87.       //大于等于子节点
  88.       if(compare(element,child) >= 0) break;
  90.       arr[index] = child;
  91.       index = childIndex;
  92.     }
  93.     arr[index] = element;
  94.   }
  95. }

四、插入排序（Insertion Sort）

类似扑克牌的排序

插入排序（Insertion-Sort）的算法描述是一种简单直观的排序算法。它的工作原理是通过构建有序序列，对于未排序数据，在已排序序列中从后向前扫描，找到相应位置并插入。

  1. public class InsertionSort extends Sort{ 
  3.     @Override
  4.     protected void sort(){ 
  5.       for(int begin=1;begin<arr.length;begin++){ 
  6.         int cur = begin;//要把当前begin记录下来，不能改变，所以用cur来代替begin变化
  7.         while(cur > 0 && cmp(cur,cur-1) < 0){ 
  8.            swap(cur,cur-1);
  9.            cur--;
  10.         }
  11.       }
  12.     }
  15.       //优化后的代码1
  16.     @Override
  17.     protected void sort(){ 
  18.       for(int begin=1;begin<arr.length;begin++){ 
  19.         int cur = begin;//要把当前begin记录下来，不能改变，所以用cur来代替begin变化
  20.         Integer v = arr[cur];
  21.         while(cur > 0 && cmp(cur,cur-1) < 0){ 
  22.            arr[cur] = arr[cur-1]; //逐个往右移一个位置
  23.            cur--;
  24.         }
  25.         arr[cur] = v; //最后前面空出来的那个位置，v直接插入进去
  26.       }
  27.     }  
  30.   //利用二分搜索优化代码2(见下面方法search)
  31.    @Override
  32.     protected void sort(){ 
  33.       for(int begin=1;begin<arr.length;begin++){ 
  34.         int v = arr[begin];
  35.         int searchIndex = search(begin);
  36.         //将searchIndex到begin位置的元素往右边挪动一位
  37.         //for(int i=begin-1;i>=searchIndex;i--){ 
  38.         // arr[i+1] = arr[i];
  39.         //}
  40.         for(int i=begin;i>searchIndex;i--){ 
  41.           arr[i] = arr[i-1];
  42.         }
  43.         arr[searchIndex] = v;
  44.       }
  45.     }  
  46.   //利用二分搜索找到index位置元素的待插入位置
  47.   //已经排好序数组的区间范围值[0,index)
  48.   private int search(int index){ 
  49.     int v = arr[index];
  50.     int begin = 0;
  51.     int end = index-1; //左闭右开区间 
  52.     while(begin < end){ 
  53.       int mid = (begin+end) >>1;
  54.       if(v <arr[mid]){  //compare(v,arr[mid])<0
  55.         end = mid;
  56.       }else{ 
  57.         begin = mid+1;
  58.       }
  59.     }
  60.     return begin;
  61.   }
  63. }
  66. //写一下二分搜索（可参考学习）
  67. public class BinarySearch{ 
  68.   //查找v在有序数组array中的位置
  69.   public static int indexOf(int[] array,int v){  //返回索引
  70.     if(array == null ||array.length == 0){ 
  71.       return -1;
  72.     }
  73.     int begin = 0;
  74.     int end = array.length; //左闭右开区间 
  75.     while(begin < end){ 
  76.       int mid = (begin+end)/2;
  77.       if(v<array[mid]){ 
  78.         end=mid;
  79.       }else if(v>array[mid]){ 
  80.         begin=mid+1;
  81.       }else{ 
  82.         return mid;
  83.       }
  84.     }
  85.     return -1;
  86.   }
  88.   //查找v在有序数组array中的插入位置，第一个比v大的位置的索引
  89.   public static int search(int[] array,int v){ 
  90.     if(array == null ||array.length == 0){ 
  91.       return -1;
  92.     }
  93.     int begin = 0;
  94.     int end = array.length; //左闭右开区间 
  95.     while(begin < end){ 
  96.       int mid = (begin+end) >>1;
  97.       if(v <array[mid]){ 
  98.         end = mid;
  99.       }else{ 
  100.         begin = mid+1;
  101.       }
  102.     }
  103.     return begin;
  104.   }
  106. }

五、归并排序（Merge Sort）

归并排序是建立在归并操作上的一种有效的排序算法。该算法是采用分治法（Divide and Conquer）的一个非常典型的应用。将已有序的子序列合并，得到完全有序的序列；即先使每个子序列有序，再使子序列段间有序。若将两个有序表合并成一个有序表，称为2-路归并。

  1. public class MergeSort extends Sort{ 
  2.   private Integer[] leftArray;
  4.   @Override
  5.   protected void sort(){ 
  6.     leftArray = new Integer[arr.length >> 1];
  7.     sort(0,arr.length);
  8.   }
  10.   //对[begin,end)范围内的数据进行归并排序
  11.   private void sort(int begin,int end){ 
  12.     if(end - begin < 2) return;//只有一个元素的情况
  13.     int mid = (begin+end) >> 1;
  14.     sort(begin,mid); //都是左闭右开区间
  15.     sort(mid,end); //都是左闭右开区间
  16.     merge(begin,mid,end);
  17.   }
  19.   //合并
  20.   //将[begin,end)与[mid,end)范围内的序列合并成一个有序的序列
  21.   private void merge(int begin,int mid,int end){ 
  22.     int li = 0,le = mid -begin;
  23.     int ri = mid,re = end;
  24.     int ai = begin;
  26.     //备份左边数组
  27.     for(int i=li;i<le;i++){ 
  28.       leftArray[i] = arr[begin+i];
  29.     }
  31.     while(li<le){  //如果左边还没有结束
  32.       if(ri<re && leftArray[li] > arr[ri]){ 
  33.         arr[ai] = arr[ri];
  34.         ri++;
  35.         ai++;
  36.       }else{ 
  37.         arr[ai++] = leftArray[li++];
  38.       }
  39.     }
  40.   }
  42. }

六、快速排序（Quick Sort）

快速排序的基本思想：通过一趟排序将待排记录分隔成独立的两部分，其中一部分记录的关键字均比另一部分的关键字小，则可分别对这两部分记录继续进行排序，以达到整个序列有序。

  1. /*快速排序的本质： 逐渐将每一个元素都转换成轴点元素（递归的过程）*/
  3. public class QuickSort extends Sort{ 
  5.     @Override
  6.     protected void sort(){ 
  7.         //sort(0,arr.length);
  8.         sort2(0,arr.length-1);
  9.     }
  11.     //对[begin,end)范围的元素进行快速排序
  12.     private void sort2(int begin,int end){ 
  13.         if(end-begin<2) return;
  15.         //确定轴点位置
  16.         int mid = partition(begin,end);
  17.         //对子序列进行快速排序
  18.         sort(begin,mid-1);
  19.         sort(mid+1,end);
  20.     }
  21.     private int partition(int begin,int end){ 
  22.         int privot = begin,index = privot+1;
  23.         for(int i=index;i<=end;i++){ 
  24.             if(arr[privot] > arr[i]){ 
  25.                 swap(i,index);
  26.                 index++;
  27.             }
  28.         }
  29.         swap(privot,index-1);
  30.         return index-1;
  31.     }
  32.     private void swap(int a,int b){ 
  33.         int temp = arr[a];
  34.         arr[a] = arr[b];
  35.         arr[b] = temp;
  36.     }
  38.     //对[begin,end)范围的元素进行快速排序
  39.     private void sort(int begin,int end){ 
  40.         if(end-begin<2) return;
  42.         //确定轴点位置
  43.         int mid = pivotIndex(begin,end);
  44.         //对子序列进行快速排序
  45.         sort(begin,mid);
  46.         sort(mid+1,end);
  47.     }
  48.     //确定[begin,end)范围的轴点位置，return begin=end的位置pivot
  49.     private int pivotIndex(int begin,int end){ 
  50.         //备份begin位置的元素
  51.         Integer v = arr[begin];  //arr[pivot] = v
  52.         //end指向最后一个元素
  53.         end--;
  54.         while(begin < end){ 
  55.           while(begin < end){ 
  56.             if(arr[end] > v){ 
  57.                 end--;
  58.             }else{ 
  59.                 arr[begin] = arr[end];
  60.                 begin++;
  61.                 break; //只退出当前循环，掉头了（本来是从右到左查找对比，只要arr[end]<v了就掉头，从begin方向往end方向查找）
  62.             }
  63.           }
  64.            while(begin < end){ 
  65.             if(arr[begin] < v){ 
  66.                 begin++;
  67.             }else{ 
  68.                 arr[end] = arr[begin];
  69.                  end--;
  70.                  break;
  71.             }
  72.           }
  73.         }
  74.         //将轴点元素放入最终的位置
  75.         arr[begin] = v;
  76.         return begin;//或者end，因为begin=end=pivot轴点元素的位置
  77.     }
  78. }

七、希尔排序（Shell Sort）

1959年Shell发明，第一个突破O(n2)的排序算法，是简单插入排序的改进版。它与插入排序的不同之处在于，它会优先比较距离较远的元素。希尔排序又叫缩小增量排序。

  1. public class ShellSort extends Sort{ 
  4.     @Override
  5.     protected void sort(){ 
  6.       List<Integer> stepSequence = myStepSequence(); //步长序列{8,4,2,1} 
  8.       for(Integer step:stepSequence){ 
  9.         sort(step);
  10.       }
  11.     }
  13.   //分成step列进行排序
  14.   private void sort(int step){ 
  15.     //col：第几列 
  16.     //对第col列进行排序
  17.     for(int col = 0;col < step;col++){ 
  18.       //col,col+step,col+2*step,col+3*step
  19.       for(int begin=col+step;begin<arr.length;begin+=step){ 
  20.         int cur = begin;//要把当前begin记录下来，不能改变，所以用cur来代替begin变化
  21.         while(cur > 0 && cmp(cur,cur-step) < 0){ 
  22.            swap(cur,cur-step);
  23.            cur-=step;
  24.         }
  25.       }
  26.     }
  27.   }
  29.   private List<Integer> myStepSequence(){ 
  30.     List<Integer> stepSequence = new ArrayList<>();
  31.     int step = arr.length;
  33.     while((step >> 1) > 0){ 
  34.       stepSequence.add(step);
  35.     }
  36.     return stepSequence;
  37.   }
  38. }

八、计数排序（Counting Sort）

计数排序不是基于比较的排序算法，其核心在于将输入的数据值转化为键存储在额外开辟的数组空间中。 作为一种线性时间复杂度的排序，计数排序要求输入的数据必须是有确定范围的整数

  1. public class CountingSort extends Sort{ 
  2.   @Override
  3.     protected void sort(){ 
  4.       //找出最大值
  5.       int max = arr[0];
  6.       for(int i=1;i<arr.length;i++){ 
  7.         if(arr[i] > max){ 
  8.           max = arr[i];
  9.         }
  10.       }
  12.       //开辟内存空间，存储每个整数出现的次数
  13.       int[] counts = new int[1+max];
  14.       //统计每个整数出现的次数
  15.       for(int i=0;i<arr.length;i++){ 
  16.         counts[arr[i]]++;
  17.       }
  19.       //根据整数的出现次数，对整数进行排序
  20.       int index=0;
  21.       for(int i=0;i<counts.length;i++){ 
  22.         while(conuts[i]-- >0){ 
  23.           arr[index++] = i;
  24.         }
  25.       }
  27.     }
  28. }
  31. //优化（内存浪费，无负数，不稳定）
  32. public class CountingSort extends Sort{ 
  33.   @Override
  34.     protected void sort(){ 
  35.       //找出最大值、最小值
  36.         int max = arr[0];
  37.         int min = arr[0];
  38.         for(int i=1;i<arr.length;i++){ 
  39.           if(arr[i] > max){ 
  40.             max = arr[i];
  41.         }
  42.         for(int i=1;i<arr.length;i++){ 
  43.           if(arr[i] < min){ 
  44.             min = arr[i];
  45.         }
  46.         //开辟内存空间 存储次数
  47.         int[] counts = new int[max-min+1];
  48.         //统计每个整数出现的次数
  49.         for(int i=0;i<arr.length;i++){ 
  50.           counts[arr[i] - min]++;
  51.         }
  52.         //累加次数 
  53.         for(int i=1;i<counts.length;i++){ 
  54.           counts[i] += counts[i-1];
  55.         }
  57.         //从后往前遍历元素，将其放到有序数组中的合适位置
  58.         int[] newArr = new int[arr.length];
  59.         for(int i=arr.length;i>0;i--){ 
  60.           //--counts[arr[i]-min] arr[i]-min就是这个数，counts[arr[i]-min]就是次数（前面次数和）要先减一才是新数组的索引
  61.           newArr[--counts[arr[i]-min]] = arr[i]; //理解
  62.         } 
  64.         //将有序数组赋值到arr
  65.         for(int i=0;i<arr.length;i++){ 
  66.           arr[i]=newArr[i];
  67.         }
  69.      }
  70. }

九、基数排序（Radix Sort）

基数排序是按照低位先排序，然后收集；再按照高位排序，然后再收集；依次类推，直到最高位。有时候有些属性是有优先级顺序的，先按低优先级排序，再按高优先级排序。最后的次序就是高优先级高的在前，高优先级相同的低优先级高的在前。（非常适合非负整数）

  1. public class RadixSort extends Sort{ 
  2.   @Override
  3.     protected void sort(){ 
  4.       //找出最大值
  5.       int max = arr[0];
  6.       for(int i=1;i<arr.length;i++){ 
  7.         if(arr[i] > max){ 
  8.           max = arr[i];
  9.         }
  10.       }
  12.       //max=593 593%10=3 593/10%10=9 593/100%10=5
  13.       for(int divider = 1;divider <= max;divider *= 10){ 
  14.         countingSort(divider);
  15.       }
  17.     }
  19.   //基于计数排序
  20.   protected void countingSort(int divider){  //divider=1、10、100、1000、... 
  21.         //开辟内存空间 存储次数
  22.         int[] counts = new int[10];  //0-9
  23.         //统计每个整数出现的次数
  24.         for(int i=0;i<arr.length;i++){ 
  25.           counts[arr[i] / divider % 10]++;
  26.         }
  27.         //累加次数 
  28.         for(int i=1;i<counts.length;i++){ 
  29.           counts[i] += counts[i-1];
  30.         }
  32.         //从后往前遍历元素，将其放到有序数组中的合适位置
  33.         int[] newArr = new int[arr.length];
  34.         for(int i=arr.length;i>0;i--){ 
  35.           //--counts[arr[i]-min] arr[i]-min就是这个数，counts[arr[i]-min]就是次数（前面次数和）要先减一才是新数组的索引
  36.           newArr[--counts[arr[i] / divider % 10] = arr[i]; //理解
  37.         } 
  39.         //将有序数组赋值到arr
  40.         for(int i=0;i<arr.length;i++){ 
  41.           arr[i]=newArr[i];
  42.         }
  44.      }
  45. }

十、桶排序（Bucket Sort）

桶排序是计数排序的升级版。它利用了函数的映射关系，高效与否的关键就在于这个映射函数的确定。桶排序 (Bucket sort)的工作的原理：假设输入数据服从均匀分布，将数据分到有限数量的桶里，每个桶再分别排序（有可能再使用别的排序算法或是以递归方式继续使用桶排序进行排）。（当数是小数时）

  1. public class BucketSort extends Sort{ 
  2.   @Override
  3.     protected void sort(){ 
  4.       //桶数组
  5.       List<Double>[] buckets = new List[arr.length];
  6.       for(int i=0;i<arr.length;i++){ 
  7.         int bucketIndex = (int) (arr[i] * arr.length);
  8.         List<Double> bucket = buckets[bucketIndex];
  9.         if(bucket == null){ 
  10.           bucket = new LinkedList<>();
  11.           buckets[bucketIndex] = bucket;
  12.         }
  13.         bucket.add(arr[i]);
  14.       }
  16.       //对每个桶进行排序
  17.       int index = 0;
  18.       for(int i=0;i<buckets;i++){ 
  19.         if(buckets[i] == null) continue;
  20.         buckets[i].sort(null);//java内部的排序方法
  21.         for(Double d:buckets[i]){ 
  22.           arr[index++] = d;
  23.         }
  24.       }
  25.     }
  26. }

扩展：十一、史上“最强”排序-休眠排序666（仅供参考，不要用！！）

  1. private static class SortThread extends Thread{ 
  2.   private int value;
  3.   public SortThread(int value){ 
  4.     this.value = value;
  5.   }
  6.   public void run(){ 
  7.     try{ 
  8.       Thread.sleep(value);
  9.       System.out.println(value);
  10.     }catch(IntereuptedException e){ 
  11.       e.printStackTrace();
  12.     }
  13.   }
  14. }
  16. public class SortThreadTest{ 
  17.   public static void main(String[] args){ 
  18.     int[] array = [10,100,50,60,30];
  19.     for(int i=0;i<array.length;i++){ 
  20.       new SortThread(array[i]).start();
  21.     }
  22.   }
  23. }

主要是理解某个算法本身的意义和思想，再根据代码联系思考。

这篇博客是自己在学习的时候跟着老师一起敲的，如有错误或不足之处还请多指教，以下是几个参考学习的链接。

可视化算法结构

前端JS实现十大排序算法可参见博文

学习视频bilibili

发表评论

表情：
评论列表 （有 0 条评论，369人围观）

还没有评论，来说两句吧...

相关阅读

    相关 十大排序算法Java实现

    > 之前写了JavaScript实现的排序算法，因为社会的压迫233333，Java可能也得写写，所以就将这个放在这里来了，算法介绍看之前JavaScript那一篇播客吧，这里

    向右看齐向右看齐/ 0 赞/ 280 阅读