关于Java中Array.sort()排序原理，越详细越好！

Posted 2023-04-15

是 Arrays.sort(a); 吧

给你看源码

=============

/*      */   public static void sort(int[] paramArrayOfInt)
/*      */   
/*   96 */     sort1(paramArrayOfInt, 0, paramArrayOfInt.length);
/*      */   

//

/*      */   private static void sort1(int[] paramArrayOfInt, int paramInt1, int paramInt2)
/*      */   
/*  558 */     if (paramInt2 < 7) 
/*  559 */       for (i = paramInt1; i < paramInt2 + paramInt1; i++)
/*  560 */         for (j = i; (j > paramInt1) && (paramArrayOfInt[(j - 1)] > paramArrayOfInt[j]); j--)
/*  561 */           swap(paramArrayOfInt, j, j - 1);
/*  562 */       return;
/*      */     
/*      */     
/*      */ 
/*  566 */     int i = paramInt1 + (paramInt2 >> 1);
/*  567 */     if (paramInt2 > 7) 
/*  568 */       j = paramInt1;
/*  569 */       k = paramInt1 + paramInt2 - 1;
/*  570 */       if (paramInt2 > 40) 
/*  571 */         m = paramInt2 / 8;
/*  572 */         j = med3(paramArrayOfInt, j, j + m, j + 2 * m);
/*  573 */         i = med3(paramArrayOfInt, i - m, i, i + m);
/*  574 */         k = med3(paramArrayOfInt, k - 2 * m, k - m, k);
/*      */       
/*  576 */       i = med3(paramArrayOfInt, j, i, k);
/*      */     
/*  578 */     int j = paramArrayOfInt[i];
/*      */     
/*      */ 
/*  581 */     int k = paramInt1;int m = k;int n = paramInt1 + paramInt2 - 1;int i1 = n;
/*      */     for (;;) 
/*  583 */       if ((m <= n) && (paramArrayOfInt[m] <= j)) 
/*  584 */         if (paramArrayOfInt[m] == j)
/*  585 */           swap(paramArrayOfInt, k++, m);
/*  586 */         m++;
/*      */        else 
/*  588 */         while ((n >= m) && (paramArrayOfInt[n] >= j)) 
/*  589 */           if (paramArrayOfInt[n] == j)
/*  590 */             swap(paramArrayOfInt, n, i1--);
/*  591 */           n--;
/*      */         
/*  593 */         if (m > n)
/*      */           break;
/*  595 */         swap(paramArrayOfInt, m++, n--);
/*      */       
/*      */     
/*      */     
/*  599 */     int i3 = paramInt1 + paramInt2;
/*  600 */     int i2 = Math.min(k - paramInt1, m - k);vecswap(paramArrayOfInt, paramInt1, m - i2, i2);
/*  601 */     i2 = Math.min(i1 - n, i3 - i1 - 1);vecswap(paramArrayOfInt, m, i3 - i2, i2);
/*      */     
/*      */ 
/*  604 */     if ((i2 = m - k) > 1)
/*  605 */       sort1(paramArrayOfInt, paramInt1, i2);
/*  606 */     if ((i2 = i1 - n) > 1) 
/*  607 */       sort1(paramArrayOfInt, i3 - i2, i2);
/*      */     
/*      */   
/*      */   
/*      */ 
/*      */   private static void swap(int[] paramArrayOfInt, int paramInt1, int paramInt2)
/*      */   
/*  614 */     int i = paramArrayOfInt[paramInt1];
/*  615 */     paramArrayOfInt[paramInt1] = paramArrayOfInt[paramInt2];
/*  616 */     paramArrayOfInt[paramInt2] = i;
/*      */   

追问

能不能通俗易懂的解释一下？

追答

看源码 ，用了快速排序

　1）当待排序的数组中的元素个数较少时，源码中的阀值为7，采用的是插入排序。尽管插入排序的时间复杂度为0(n^2)，但是当数组元素较少时，插入排序优于快速排序，因为这时快速排序的递归操作影响性能。
　　2）较好的选择了划分元（基准元素）。能够将数组分成大致两个相等的部分，避免出现最坏的情况。例如当数组有序的的情况下，选择第一个元素作为划分元，将使得算法的时间复杂度达到O(n^2).
　　源码中选择划分元的方法:
　　　　当数组大小为 size=7 时 ，取数组中间元素作为划分元。int n=m>>1;(此方法值得借鉴)
　　　　当数组大小 740 时 ，从待排数组中较均匀的选择9个元素，选出一个伪中数做为划分元。
　　3）根据划分元 v ，形成不变式 v* (v)* v*

参考技术A 直接看源码吧

Java Array.sort的六种常用方法总结

Arrays.sort()的六种用法

一：直接用，升序排序

        /**
         * 用法一，升序排序
         */
        int[] nums1 = new int[]{4, 6, 8, 0, 5, 9, 7, 2, 1, 3};
        Arrays.sort(nums1);

二：传入参数 fromIndex、toIndex，部分升序排序

        /**
         * 用法二，部分升序排序
         */
        int[] nums2 = new int[]{4, 6, 8, 0, 5, 9, 7, 2, 1, 3};
        Arrays.sort(nums2, 0, 3);

三：重写比较器Comparator，降序排序

        /**
         * 用法三，降序排序
         */
        Integer[] nums3 = new Integer[]{4, 6, 8, 0, 5, 9, 7, 2, 1, 3};
        Arrays.sort(nums3, new Comparator<Integer>() {
            @Override
            public int compare(Integer o1, Integer o2) {
                return o2 - o1;
            }
        });

四：结合二和三（传参 + 重写），部分降序排序

        /**
         * 用法四，部分降序排序
         */
        Integer[] nums4 = new Integer[]{4, 6, 8, 0, 5, 9, 7, 2, 1, 3};
        Arrays.sort(nums4, 0, 3, new Comparator<Integer>() {
            @Override
            public int compare(Integer o1, Integer o2) {
                return o2 - o1;
            }
        });

五：二维数组的特殊排序

        /**
         * 用法五，二维数组排序
         * 根据nums5[i][0]排序, 若num5[i][0]相同，则根据nums5[i][1]排序
         */
        int[][] nums5 = new int[][]{{1, 3}, {1, 2}, {4, 5}, {3, 7}};
        Arrays.sort(nums5, new Comparator<int[]>() {
            public int compare(int[] a, int[] b){
                if(a[0]==b[0]){
                    return a[1] - b[1];
                }else {
                    return a[0] - b[0];
                }
            }
        });

六：与五一样，写法不同

        /**
         * 用法六，与用法五一样，写法不同
         */
        int[][] nums6 = new int[][]{{1, 3}, {1, 2}, {4, 5}, {3, 7}};
        Arrays.sort(nums6, (a,b) -> (a[0]==b[0] ? a[1] - b[1] : a[0] - b[0]));

输出结果

待补充