• 数据结构之详解【排序算法】

    目录

    1.排序的理解+10种排序比较

    2.直接插入排序（有序使用最好）

    3.希尔排序（缩小增量算法）

    4.直接选择排序

    5.堆排序

    6.冒泡排序

    7.快速排序（无序使用最好）

    7.1 递归实现 

    7.1.1 Hoare法  找基准

    7.1.2 挖坑法（建议用这个）

    7.1.3 前后指针法

    7.1.4 三数取中找基准

     7.2 非递归实现

    8.归并排序

    8.1 归并排序的递归方法 

    8.2 归并排序的非递归方法 

    9.计数排序（不比较）

    10. 基数排序

    11. 桶排序

    1.排序的理解+10种排序比较

    定义：是一个序列对象按照某个关键字进行递增或递减的操作

    几个关键词理解：

    （1）稳定性：如果a原本在b前面，并且a=b，排序之后a仍然在b的前面，说明这个是稳定的，反之，就不稳定。

    （2）内部排序：数据元素全部放在内存中的排序。

    （3）外部排序：数据元素太多不能同时放在内存中，所以把数据放在磁盘中，而排序通过磁盘和内存的数据传输才能进行；

    一个稳定的排序，可以变成不稳定的排序

    一个不稳定的排序，不可以变成稳定的排序

    （4）10中排序比较 

    排序方法最好平均最坏空间复杂度稳定性
    冒泡排序O(n)O(n^2)O(n^2)O(1)稳定
    插入排序O(n)O(n^2)O(n^2)O(1)稳定
    选择排序O(n^2)O(n^2)O(n^2)O(1)不稳定
    希尔排序O(n^1.3)O(n^1.3)O(n^1.5)O(1)不稳定
    堆排序O(n*logn)O(n*logn)O(n*logn)O(1)不稳定
    快速排序O(n*logn)O(n*logn)O(n^2)O(logn)~O(n)不稳定
    归并排序O(n*logn)O(n*logn)O(n*logn)O(n)稳定
    计数排序O(MAX(n,范围))O(MAX(n,范围))O(MAX(n,范围))O(范围)稳定
    基数排序O(n*k)O(n*k)O(n*k)O(n+k)稳定
    桶排序O(n)O(n+k)O(n^2)O(n+k)基于桶内比较算法

    2.直接插入排序（有序使用最好）

    基本思想：将未排序的数据元素，在已经排好的有序序列中从后向前扫描，找到对应位置然后插入

    在扫描的过程中，需要反复把已经排序的元素向后挪动，为准备新插入的元素提供空间

    1.      * 直接插入排序
    2.      * 时间复杂度：
    3.      *       最坏：O(n^2) 数据元素全部逆序时
    4.      *       最好：O(n) 数据元素全部有序时
    5.      * 空间复杂度：O(1)
    6.      * 稳定性：稳定
    7.      * 数据元素基本上有序时，使用效果最好

     实现步骤：比如

     上代码：

    1.  public void insertSort(int[] array) {
    2.         for (int i  = 1; i < array.length; i++) {
    3.             int tmp = array[i];
    4.             int j = i-1;
    5.             for (; j >= 0; j--) {
    6.                 if(array[j] > tmp) {
    7.                     array[j+1] = array[j];
    8.                 }else {
    9.                     break;
    10.                 }
    11.             }
    12.             array[j+1] = tmp;
    13.         }
    14.     }
    对记录（54,38,96,23,15,72,60,45,83）进行从小到大的直接插入排序时，当把第8个记录45插入到有序表时，为找到插入 位置需比较   (C)   次？（采用从后往前比较）
    A: 3 B: 4 C: 5 D:6

     

     3.希尔排序（缩小增量算法）

    基本思想：希尔排序是选的一个增量值分组，然后对每组使用直接插入排序算法排序，随着增量值减小，每组包含的值也越来越多，当增量值减为1时，整个序列在一组内排序

    1.      * 希尔排序
    2.      * 时间复杂度：O(n^1.3 - n^1.5)
    3.      * 空间复杂度：O(1)
    4.      * 稳定性：不稳定

     实现步骤：

    1.   private static void shell(int[] array,int gap) {
    2.         for (int i  = gap; i < array.length; i++) {
    3.             int tmp = array[i];
    4.             int j = i-gap;
    5.             for (; j >= 0; j-=gap) {
    6.                 if(array[j] > tmp) {
    7.                     array[j+gap] = array[j];
    8.                 }else {
    9.                     break;
    10.                 }
    11.             }
    12.             array[j+gap] = tmp;
    13.         }
    14.     }
    15.     public static void shellSort(int[] array) {
    16.         int gap = array.length;
    17.         while (gap > 1) {
    18.             shell(array,gap);
    19.             gap /= 2;
    20.         }
    21.         shell(array,1);
    22.     }
    下列排序法中，最坏情况下时间复杂度最小的是   （A）
    A: 堆排序 B: 快速排序 C: 希尔排序 D: 冒泡排序

     O(n*logn)   O(n*2)         O(n^1.5)     O(n^2)

    4.直接选择排序

    基本思想：在未排序序列中找到最小（大）元素，存放到排序序列的起始位置，然后，再从剩余未排序元素中继续寻找最小（大）元素，然后放到已排序序列的末尾。以此类推，直到所有元素均排序完毕。

    1.      * 直接选择排序     
    2.      * 数据复杂度：O(n^2) （对数据不敏感，不管数据有序还是无序都是这样）
    3.      * 空间复杂度：O(1)
    4.      * 稳定性：不稳定

    1.  public static void selectSort(int[] array) {
    2.         for (int i = 0; i < array.length; i++) {
    3.             //每次将i下标的值当做最小值
    4.             int minIndex = i;
    5.             for (int j = i+1; j < array.length; j++) {
    6.                 if(array[j] < array[minIndex]) {
    7.                    minIndex = j;
    8.                 }
    9.             }
    10.             swap(array,minIndex,i);
    11.         }
    12.     }
    13.     private static void swap(int[] array,int i, int j) {
    14.         int tmp = array[i];
    15.         array[i] = array[j];
    16.         array[j] = tmp;
    17.     }

    （2）前面是用了一个minIndex去找最小值然后交换，最后排序

    那么如果用两个一个minIndex去找最小值，一个maxIndex去找最大值，

    然后用left指向前，right指向后，

    比如说是升序那就minIndex和left交换，

    maxIndex和right交换，这样效率应该是比第一种方法要快

    1.  public static void selectSort2(int[] array) {
    2.         int left = 0;
    3.         int right = array.length-1;
    4.         while(left < right) {
    5.             int minIndex = left;
    6.             int maxIndex = left;
    7.             for(int i = left+1; i <= right; i++) {
    8.                 if (array[i] < array[minIndex]) {
    9.                     minIndex = i;
    10.                 }
    11.                 if (array[i] > array[maxIndex]) {
    12.                     maxIndex = i;
    13.                 }
    14.             }
    15.             swap(array,left,maxIndex);
    16.             //修正maxIndex下标
    17.             if(left == maxIndex) {
    18.                 maxIndex = minIndex;
    19.             }
    20.             swap(array,right,maxIndex);
    21.             left++;
    22.             right--;
    23.         }
    24.     }

    5.堆排序

    基本思想：堆排序(Heapsort)是指利用堆这种数据结构所设计的一种排序算法，它是选择排序的一种。它是通过堆来进行选择数据。需要注意的是排升序要建大堆，排降序建小堆。

    不了解堆的可以看一下，我的另一篇博客，里面有很好的介绍

    数据结构之【堆】（Heap）http://t.csdn.cn/H0i2R

    1.      * 堆排序    
    2.      * 时间复杂度：O(n*logn)
    3.      * 空间复杂度：O(1)
    4.      * 稳定性：不稳定

    1.   public static void heapSort(int[] array) {
    2.         createBigHeap(array);
    3.         int end = array.length-1;
    4.         while(end >= 0) {
    5.             swap(array,0,end);
    6.             shiftDown(array,0,end);
    7.             end--;
    8.         }
    9.     }
    10.     private static void createBigHeap(int[] array) {
    11.         for (int parent= (array.length-1-1)/2; parent >= 0 ; parent--) {
    12.            shiftDown(array,parent,array.length);
    13.         }
    14.     }
    15.     //向下调整
    16.     private static void  shiftDown(int[] array,int parent,int len) {
    17.         int child = 2*parent+1;
    18.         while(child < len) {
    19.             if(child+1 < len && array[child] < array[child+1]){
    20.                 child++;
    21.             }
    22.             if (array[child] > array[parent]) {
    23.                 swap(array,child,parent);
    24.                 parent = child;
    25.                 child = 2*parent+1;
    26.             }else {
    27.                 break;
    28.             }
    29.         }
    30.     }
    关于排序，下面说法不正确的是   (D)
    A: 快排时间复杂度为O(N*logN)，空间复杂度为O(logN)
    B: 归并排序是一种稳定的排序,堆排序和快排均不稳定
    C: 序列基本有序时，快排退化成冒泡排序，直接插入排序最快
    D: 归并排序空间复杂度为O(N), 堆排序空间复杂度的为O(logN)
    堆排序空间复杂度的为O(1)

    6.冒泡排序

    基本思想：冒泡排序是一种简单的排序算法。它重复地走访过要排序的数列，一次比较两个元素，如果它们的顺序错误就把它们交换过来。重复的进行上面的步骤，直到没有再需要交换的

    基本步骤

    1. public static void bubbleSort(int[] array) {
    2.         for (int i = 0; i < array.length-1; i++) {
    3.             for (int j = 0; j < array.length-i-1; j++) {
    4.                 if(array[j] > array[j+1]) {
    5.                     swap(array,j,j+1);
    6.                 }
    7.             }
    8.         }
    9.     }

    （2）如果是10个数据 ，假如在第7趟就有序了 ，前面一种还是必须比较9趟，那么能不能优化一下，让值比较7趟就可以了

    优化后 时间复杂度O(n)

    1.  public static void bubbleSort(int[] array) {
    2.         for (int i = 0; i < array.length-1; i++) {
    3.             boolean flg = false;
    4.             for (int j = 0; j < array.length-i-1; j++) {
    5.                 if(array[j] > array[j+1]) {
    6.                     swap(array,j,j+1);
    7.                     flg = true;
    8.                 }
    9.             }
    10.             if(flg == false) {
    11.                 break;
    12.             }//这一趟没有发生交换，说明有序
    13.         }
    14.     }
    下列排序算法中稳定且时间复杂度为O(n2)的是     (B)
    A: 快速排序    B: 冒泡排序     C: 直接选择排序     D: 归并排序

    7.快速排序（无序使用最好）

    基本思想:任取待排序元素序列中的某元素作为基准值，按照该排序码将待排序集合分割成两子序列，左子序列中所有元素均小于基准值，右子序列中所有元素均大于基准值，然后最左右子序列重复该过程，直到所有元素都排列在相应位置上为止。

    在写递归的过程中可联想 二叉树的前序遍历 找基准值 进行区间划分

    1.      * 时间复杂度：
    2.      *    最优：O(n*logn)  每次均分待排序数组
    3.      *    最坏：O(n^2)  数组有序或逆序
    4.      * 空间复杂度：最好：O(logN)
    5.      *            最坏：O(N)   当n足够大时，递归的深度就大
    6.      * 稳定性：不稳定

    7.1 递归实现 

    7.1.1 Hoare法  找基准

    1.   public static void quickSort(int[] array) {
    2.         quick(array,0, array.length-1);
    3.     }
    4.  
    5.     private static void quick(int[] array,int left, int right) {
    6.         //取= 是只有一个节点了 >有可能没有子树
    7.         if (left >= right) {
    8.             return;
    9.         }
    10.         int pivot = partition(array,left,right);
    11.         quick(array,left,pivot-1);
    12.         quick(array,pivot+1,right);
    13.     }
    14.     //找k
    15.     private static int partition(int[] array,int start, int end) {
    16.         int i = start;
    17.         int key = array[start];
    18.         while (start < end) {
    19.             while (start < end && array[end] >= key) {
    20.                 end--;
    21.             }
    22.             while (start < end && array[start] <= key) {
    23.                 start++;
    24.             }
    25.             swap(array,start,end);
    26.         }
    27.         swap(array,start,i);
    28.         return start;
    29.     }

    快排在有序情况下，使用可能会栈溢出，所以在使用时要注意这个问题

    7.1.2 挖坑法（建议用这个）

    注意先走左边

    1.  //挖坑法
    2.     private static int partition2(int[] array,int start, int end) {
    3.         int key = array[start];
    4.  
    5.         while(start < end) {
    6.             while(start < end && array[end] >= key) {
    7.                 end--;
    8.             }
    9.             array[start] = array[end];
    10.             while(start < end && array[start] <= key) {
    11.                 start++;
    12.             }
    13.             array[end] = array[start];
    14.         }
    15.         array[start] = key;
    16.         return start;
    17.     }

    7.1.3 前后指针法

     大家也可以看一下这篇文章，双指针写的很详细

     http://t.csdn.cn/LMe1L

    1.     private static int partition3(int[] array,int left, int right) {
    2.         int prev = left ;
    3.         int cur = left+1; 
    4.         while (cur <= right) { 
    5.             if(array[cur] < array[left] && array[++prev] != array[left]) { 
    6.                 swap(array,cur,prev); 
    7.             }
    8.             cur++;
    9.         }
    10.         swap(array,prev,left); return prev;
    11.     }

    🤠 然而，这样写出来的快排，如果实在遇到有序或逆序情况下，可能会栈溢出，所以我们要想办法解决这个问题 

    那么如何找出三个数字中间大小的数字

     

    上代码

    7.1.4 三数取中找基准

    1.  private static int midNumIndex(int[] array, int left, int right) {
    2.         int mid = (left+right) / 2;
    3.  
    4.         if (array[left] < array[right]) {
    5.             if(array[mid] < array[left]) {
    6.                 return left;
    7.             }else if(array[mid] > array[right]) {
    8.                 return right;
    9.             }else {
    10.                 return mid;
    11.             }
    12.         }else {
    13.             if(array[mid] > array[left]) {
    14.                 return left;
    15.             }else if(array[mid] < array[right]) {
    16.                 return right;
    17.             }else {
    18.                 return mid;
    19.             }
    20.         }
    21.     }

    三数取中递归 

    1.   private static void quick1(int[] array,int left, int right) {
    2.         //取= 是只有一个节点了 >有可能没有子树
    3.         if (left >= right) {
    4.             return;
    5.         }
    6.         int index = midNumIndex(array,left,right);
    7.         //找到三数中，中间大小的数字，和第一个交换
    8.         swap(array,left,right);
    9.         //此时就按之前正常那个Hearo法执行就可以了
    10.         int pivot = partition1(array,left,right);
    11.         quick(array,left,pivot-1);
    12.         quick(array,pivot+1,right);
    13.     }

     还可以继续改进

    既然数组要一层层递归，并且大部分递归的次数，都在最后一层，如果在最后一层时，直接插入排序，那么能否更快一些，并且前面找基准时用上三数取中，更快

    1.  private static void quick2(int[] array,int left, int right) {
    2.         if(left >= right) {
    3.             return;
    4.         }
    5.         if(right - left + 1 <= 15) {
    6.             //趋于有序，用直接插入排序
    7.             insertSort2(array,left,right);
    8.             return;
    9.         }
    10.     }
    11.     //快排改进后使用的改进插排（给指定的区间进行排序）
    12.     private static void insertSort2(int[] array,int start, int end) {
    13.         for (int i  = start+1; i <= end; i++) {
    14.             int tmp = array[i];
    15.             int j = i-1;
    16.             for (; j >= start; j--) {
    17.                 if(array[j] > tmp) {
    18.                     array[j+1] = array[j];
    19.                 }else {
    20.                     break;
    21.                 }
    22.             }
    23.             array[j+1] = tmp;
    24.         }
    25.     }

     7.2 非递归实现

    1.  public static void quickSort(int[] array) {
    2.         Stack stack = new Stack<>();
    3.         int left = 0;
    4.         int right = array.length-1;
    5.         //三数取中：解决递归深度问题 基本上 有了三数取中  你的待排序序列 基本上每次都是二分N*logn
    6.         int index = midNumIndex(array,left,right);
    7.         swap(array,left,index);
    8.         int pivot = partition2(array,left,right);
    9.  
    10.         if (pivot > left + 1) {
    11.             stack.push(left);
    12.             stack.push(pivot - 1);
    13.         }
    14.         if (pivot < right - 1) {
    15.             stack.push(pivot + 1);
    16.             stack.push(right);
    17.         }
    18.  
    19.         while (!stack.empty()) {
    20.             right = stack.pop();
    21.             left = stack.pop();
    22.             pivot = partition1(array, left, right);
    23.             //当左边或右边区间只剩一个元素时，不用给栈中放
    24.             if (pivot > left + 1) {
    25.                 stack.push(left);
    26.                 stack.push(pivot - 1);
    27.             }
    28.             if (pivot < right - 1) {
    29.                 stack.push(pivot + 1);
    30.                 stack.push(right);
    31.             }
    32.         }
    33.     }
    1.快速排序算法是基于()的一个排序算法。   （A）
    A：分治法     B：贪心法     C：递归法     D：动态规划法
    2.设一组初始记录关键字序列为(65,56,72,99,86,25,34,66)，则以第一个关键字65为基准而得到的一趟快速排序结果是       （A）
    A: 34，56，25，65，86，99，72，66    B: 25，34，56，65，99，86，72，66
    C: 34，56，25，65，66，99，86，72    D: 34，56，25，65，99，86，72，66
    用挖坑法得出选A

    8.归并排序

    基本思想：归并排序是建立在归并操作上的一种有效的排序算法,

    将已有序的子序列合并，得到完全有序的序列；

    也就是先使每个子序列有序，再使子序列段间有序。若将两个有序表合并成一个有序表，称为二路归并。 

    实现步骤： 

    1.      * 时间复杂度：O(n*logn)
    2.      * 空间复杂度：O(n)
    3.      * 稳定性：稳定
    4.      * 归并排序

    8.1 归并排序的递归方法 

    分割 

    1.   //分割
    2.     private static void mergerSortFunc(int[] array,int left, int right) {
    3.         if(left >= right) {
    4.             return;
    5.         }
    6.         int mid = (left+right)/2;
    7.         //1.分解左边
    8.         mergerSortFunc(array,left,mid);
    9.         //2.分解右边
    10.         mergerSortFunc(array,mid+1,right);
    11.         //3.进行合并
    12.         merge(array,left,right,mid);
    13.     }

    合并

    1.  //合并
    2.     private static void merge(int[] array,int start, int end, int midIndex) {
    3.         //合并放到一个新数组
    4.         int[] tmpArr = new int[end-start+1];
    5.         int k = 0;//tmpArrA数组下标
    6.  
    7.         int s1 = start;
    8.         int s2 = midIndex+1;
    9.  
    10.         //两个归并段，都有数据
    11.         while(s1 <= midIndex && s2 <= end) {
    12.             if (array[s1] <= array[s2]) {
    13.                 tmpArr[k++] = array[s1++];
    14.             }else {
    15.                 tmpArr[k++] = array[s2++];
    16.             }
    17.         }
    18.         //此时，说明有个归并段中没有了数据，拷贝到另一半的全部到tmpArr数组中
    19.         while(s1 <= midIndex) {
    20.             tmpArr[k++] = array[s1++];
    21.         }
    22.         while(s2 <= end) {
    23.             tmpArr[k++] = array[s2++];
    24.         }
    25.         //把排好序的数字 拷贝回 原来的数字
    26.         for (int i = 0; i < k; i++) {
    27.             array[i+start] = array[i];
    28.         }
    29.     }
    1.   public static  void mergerSort(int[] array) {
    2.         mergerSortFunc(array,0, array.length-1);
    3.     }

    8.2 归并排序的非递归方法 

    1.  public static  void mergerSort2(int[] array) {
    2.         int gap = 1;//每组的数据
    3.         while(gap < array.length) {
    4.             for (int i = 0; i < array.length; i += gap*2) {
    5.                 int s1 = i;
    6.                 int e1 = s1+gap-1;
    7.                 if(e1 >= array.length) {
    8.                     e1 = array.length-1;
    9.                 }
    10.                 int s2 = e1+1;
    11.                 if(s2 >= array.length) {
    12.                     s2 = array.length -1;
    13.                 }
    14.                 int e2 = s2+gap-1;
    15.                 if (e2 >= array.length) {
    16.                     e2 = array.length-1;
    17.                 }
    18.                 merge(array,s1,e2,e1);
    19.             }
    20.             gap *= 2;
    21.         }
    22.     }
    以下排序方式中占用O(n)辅助存储空间的是   (D)
    A: 简单排序    B: 快速排序     C: 堆排序     D: 归并排序

    9.计数排序（不比较）

    基本思想：计数排序通过计算数组中每个元素的出现次数来对数组的元素进行排序。将计数存储在辅助数组中，并通过将计数映射为辅助数组的索引来完成排序。

     实现步骤

    1.  public static void countSort(int[] array) {
    2.         int maxVal = array[0];
    3.         int minVal = array[0];
    4.         for (int i = 0; i < array.length; i++) {
    5.             if(array[i] < minVal) {
    6.                 minVal = array[i];
    7.             }
    8.             if (array[i] > maxVal) {
    9.                 maxVal = array[i];
    10.             }
    11.         }
    12.         //确定了最大 最小值
    13.         int len = maxVal - minVal + 1;
    14.         int[] count = new int[len];
    15.         //开始遍历array数组 进行计数
    16.         for (int i = 0; i < array.length; i++) {
    17.             int val = array[i];
    18.             count[val-minVal]++;
    19.         }
    20.         int index = 0;//array数组下标
    21.         for (int i = 0; i < count.length; i++) {
    22.             //确保当前count数组 可以检查完
    23.             while(count[i] != 0) {
    24.                 array[index] = i + minVal;
    25.                 index++;
    26.                 count[i]--;
    27.             }
    28.         }
    29.     }

    10. 基数排序

    基本思想：基数排序是利用分配和收集两种基本操作。

    基数排序是一种按记录关键字的各位值逐步进行排序的方法。

    此种排序一般适用于记录的关键字为整数类型的情况。所有对于字符串和文字排序不适合。

      实现步骤：

    1.   private static void radixSort(int[] arr) {
    2.         //待排序列最大值
    3.         int max = arr[0];
    4.         int exp;//指数
    5.         //计算最大值
    6.         for (int anArr : arr) {
    7.             if (anArr > max) {
    8.                 max = anArr;
    9.             }
    10.         }
    11.         //从个位开始，对数组进行排序
    12.         for (exp = 1; max / exp > 0; exp *= 10) {
    13.             //存储待排元素的临时数组
    14.             int[] temp = new int[arr.length];
    15.             //分桶个数
    16.             int[] buckets = new int[10];
    17.  
    18.             //将数据出现的次数存储在buckets中
    19.             for (int value : arr) {
    20.                 //(value / exp) % 10 :value的最底位(个位)
    21.                 buckets[(value / exp) % 10]++;
    22.             }
    23.             //更改buckets[i]，
    24.             for (int i = 1; i < 10; i++) {
    25.                 buckets[i] += buckets[i - 1];
    26.             }
    27.             //将数据存储到临时数组temp中
    28.             for (int i = arr.length - 1; i >= 0; i--) {
    29.                 temp[buckets[(arr[i] / exp) % 10] - 1] = arr[i];
    30.                 buckets[(arr[i] / exp) % 10]--;
    31.             }
    32.             //将有序元素temp赋给arr
    33.             System.arraycopy(temp, 0, arr, 0, arr.length);
    34.         }
    35.  
    36.     }

    11. 桶排序

    基本思想：将要排序的数据分到几个有序的桶里，每个桶里的数据再单独进行排序。桶内排完序之后，再把每个桶里的数据按照顺序依次取出，组成的序列就是有序的了

    实现步骤：

    1. public static void bucketSort(int[] arr){
    2.     // 计算最大值与最小值
    3.     int max = Integer.MIN_VALUE;
    4.     int min = Integer.MAX_VALUE;
    5.     for(int i = 0; i < arr.length; i++){
    6.         max = Math.max(max, arr[i]);
    7.         min = Math.min(min, arr[i]);
    8.     }
    9.     // 计算桶的数量
    10.     int bucketNum = (max - min) / arr.length + 1;
    11.     ArrayList> bucketArr = new ArrayList<>(bucketNum);
    12.     for(int i = 0; i < bucketNum; i++){
    13.         bucketArr.add(new ArrayList());
    14.     }
    15.     // 将每个元素放入桶
    16.     for(int i = 0; i < arr.length; i++){
    17.         int num = (arr[i] - min) / (arr.length);
    18.         bucketArr.get(num).add(arr[i]);
    19.     }
    20.     // 对每个桶进行排序
    21.     for(int i = 0; i < bucketArr.size(); i++){
    22.         Collections.sort(bucketArr.get(i));
    23.     }
    24.     // 将桶中的元素赋值到原序列
    25. 	int index = 0;
    26. 	for(int i = 0; i < bucketArr.size(); i++){
    27. 		for(int j = 0; j < bucketArr.get(i).size(); j++){
    28. 			arr[index++] = bucketArr.get(i).get(j);
    29. 		}
    30. 	}  
    31. }

  • 相关阅读:
    理解JavaScript事件循环机制
    MySQL-3-多表查询和事务(结合案例学习)
    LVS之DR模式（最常见的LVS负载方式，直接路由模式）
    v4l2打开相机获取流demo及命令打开相机设备
    Matlab迭代算法实现
    Spark的内存管理
    ChatGPT成精了！
    1. 带有一个隐藏层的平面数据分类
    Java基础知识—Arrays工具类
    failed to parse field [name] of type [text] in document with id ‘1‘
  • 原文地址：https://blog.csdn.net/m0_58761900/article/details/125822239