经典十大排序算法（含升序降序，基数排序含负数排序）【Java版完整代码】【建议收...

杨利霞

3 ?8 r" i5 n2 }经典十大排序算法（含升序降序，基数排序含负数排序）【Java版完整代码】【建议收藏系列】
经典十大排序算法【Java版完整代码】
写在前面的话
十大排序算法对比
* }( y6 r1 e4 t% n  ~' U, O冒泡排序
, n. ?# Q$ a) k7 Q快速排序
直接选择排序
堆排序
3 O) \7 i* l% y6 E) ?7 l归并排序
4 d5 @$ z3 g: P0 q/ q# P插入排序
希尔排序
计数排序
桶排序
% y7 S5 ]1 r2 Z- Q" s基数排序
& A! `# g% l" x完整测试类
0 G2 ^/ y4 w! o/ V' T7 F% {* k写在前面的话
4 G  X! ~* W' O" k* L       虽然已经有很多人总结过这十大排序算法，优秀的文章也不少，但是Java完整版的好像不多，还存在某些文章代码存在错误的情况，同时也为了自己练手，决定把所有的写一遍巩固下，同时也真诚的希望阅读到这篇文章的小伙伴们可以自己去从头敲一遍，不要粘贴复制！希望我的文章对你有所帮助，每天进步一点点！！！

1 C- I- c4 M6 t9 Y: z! J
1 T3 H' J& F  O4 w/ x7 u& q       我用通俗的理解写下对算法的解释，对某个算法的运行过程不是很理解的话或者想看比较官方的解释的话，单独搜索某个算法，看几篇不同的解释，就可以有自己的理解了，这里我主要展示代码以及进行通俗的解释！整起来，再强调一次，一定要自己敲一遍，这样才能理解的更深刻！
: _0 H8 a0 \( w/ N

十大排序算法对比
6 X) m& b* B0 s6 p+ u# j
  p# ]) C! Z0 O% X$ R

  B: [+ @6 a, ~, j
关于最后一列的稳定性，我稍微解释下，例如对序列：1 2 4 2 6 排序，序列中存在两个2，如果我们把这两个2标记上（让他俩不同），排序之后，前面的2还在前面，那么就称这种排序是稳定的，反之不稳定。


冒泡排序
简单解释：
       原理就如算法名字一样，就像水中的气泡一样，每次我都把最大的或最小的放到最后面，这样总共需要n-1趟即可完成排序，这就是第一层循环，第二次循环就是遍历未被固定的那些数（理解成数组左边的数，因为每层循环都会把最大或最小的数升到最右边固定起来，下次就不遍历这些数了），两层循环遍历结束后，所有的数就排好序了。
! B$ o. I& c1 K- {+ Y: G       两层循环所以冒泡排序算法的时间复杂度是O(n 2 n^{2}n
1 Q% F7 D8 T' ~: w3 X2
)，是一个非常高的时间复杂度，我在下面的代码进行了优化，加了一个标志位，如果上一次循环未发生交换，就说明已经是有序的了，就不继续下去了，反之继续进行下一轮。

: R: s1 P0 ~& w9 Z7 V4 U  Z


( ^. e0 h1 A8 @& l6 R8 d2 I/ K

本文的图片来源网络，仅用于大家学习，侵权联系删除！（下同）
7 X) h, A  y8 f0 @

$ n. x/ x% v+ ]: h$ B$ S完整代码：


; u0 }. G6 h5 D/ A$ A1 Gpackage com.keafmd.Sequence;
( A+ M5 j1 @& V. C
) ^/ I0 v$ ~0 A5 P+ M; G
/**
; Z' H! Q9 }7 b3 Z: P * Keafmd
4 H+ n/ L2 s, q9 o+ m5 c! N0 v1 E% A *
* @ClassName: BubbleSort
* @Description: 冒泡排序
* @author: 牛哄哄的柯南
' {! t  `) W( h3 S# }) c * @date: 2021-06-24 10:31
$ H3 e4 I# }1 k */
public class BubbleSort {

& }, Q' f+ V) E$ o5 W1 ]
    //冒泡排序
$ V) E2 v1 a& q! I) o/ Z    public static void bubbleSort(int[] arr, boolean ascending) { //exchange标志表示为升序排序还是降序排序
& O3 g% s- Y( C
) s+ X- g  ^  t; m& B
        boolean flag = true; //加一个标志位，记录上一次是否发生了交换，如果是，我们则进行下一轮，如果没有，说明已经冒泡好了

; h4 ?( O7 w% N$ h1 _3 f  B
        for (int i = 1; i < arr.length && flag; i++) { //控制次数，第几趟排序，只需要n-1趟，有交换时进行，只有flag=false就说明上一次一个元素都没有进行交换

3 i! ~2 T" ?, f
; Z. s& n2 Y, g$ R* K            /*System.out.print("第"+i+"次遍历：");
1 G3 D5 q* A) _# P' N            for (int i1 : arr) {
( c" i, q( S( h+ V- Q0 Y9 I2 G                System.out.print(i1+" ");
' I: H- b4 n( Q$ N) F/ s' I3 m            }
! y: v7 ]7 m' `. N& T            System.out.println();*/
0 e0 b( f9 c6 W7 K- ?0 ^

            flag = false; //假定未交换

+ g- b/ t$ Z0 A2 F- n! p' Q
            for (int j = 0; j < arr.length - i; j++) {

0 ]: c  q5 `- s$ l8 U: L# s
                if (ascending ? arr[j] > arr[j + 1] : arr[j] < arr[j + 1]) { //控制升序还是降序
                    int temp = arr[j];
2 h* ]$ F! D6 w1 j. P                    arr[j] = arr[j + 1];
                    arr[j + 1] = temp;
1 y4 e! G+ m; r, p* o+ I                    flag = true;
                }

/ m. u) M( Y" ?. c
3 ?( A) ]+ P3 f- q3 j            }
9 J* w! l9 }- ^/ R        }
! a8 J* S- i/ Q' W' F7 f( n    }

5 P( p6 Y+ Z& U
* B3 }, H* w0 \, S3 V6 d    //冒泡排序 -- 默认不传参升序
4 @2 @  H  g2 n/ h6 \    public static void bubbleSort(int[] arr) {
: q$ p7 _  ~+ c        bubbleSort(arr, true);
( c+ p* q1 f3 F( C, P    }
}
1
) F0 ^3 C; h8 P  |$ t2
3
* E8 {- r8 ~# H. U' Y4
5
6 q; b% }% b! k) y1 D) y1 O- A+ X6
7
8
: G; g+ c/ B- ?9
10
11
12
13
2 D# p) e! L* \14
15
16
! h. J* D% y3 h# x4 }7 d17
18
3 [' I  ~* T5 N$ H19
20
3 Y' U/ E9 l  E9 G5 M21
22
& T7 _  k. j1 @* L/ {23
$ w. v' s7 K8 v+ V24
: T) J) R4 c* p0 G' z8 b25
% C- B' o+ Q4 d* h& D26
5 R% @: v# j! H% m( o" B27
28
29
30
5 g. I& O' O/ n7 o- ]: j31
32
- y3 }- y/ x4 b  ^5 \33
34
4 D# [- |# Y5 ]1 V! ~35
! V* N5 ]- ]; ~4 K- ~36
) v, e# r+ ~8 w37
38
39
40
4 Q! a9 d4 j/ R% T: [5 E; z* B41
! v  T" h, L9 _* O42
43
44
45
测试代码：
6 F" }6 j8 u4 v' W
; w* R% r) H+ y7 Y
升序排序（从小到大）


. T" \. k3 u) K! O6 p% L2 o: x  {' Bpackage com.keafmd.Sequence;
7 ^9 C, u6 j5 Q/ N3 g: q" _

import java.util.*;
, W4 B1 k0 u9 p. l4 g, s, jimport java.util.stream.IntStream;
import java.util.stream.Stream;

" g; P/ T- {" S  @0 f7 I
/**
0 E1 }8 u7 Y) \ * Keafmd
*
* @ClassName: Sort
, s) u# F; [- O3 W2 Z8 }- k * @Description: 十大排序算法
; @, u% A  }+ h# Z0 B * @author: 牛哄哄的柯南
- w( c$ N- c0 H * @date: 2021-06-16 21:27
*/
) ~3 h" U1 W+ `. z) U! U# c: I6 Kpublic class Sort {
    public static void main(String[] args) {
2 s+ M$ B  t4 k* E4 l
3 Q* q2 ]5 B9 c/ Y3 d; Z
+ ?' U) S, Q& @8 N4 o        int[] nums = {12, 4, 25, 47, 58, 34, 25, 9, 99, 26, 1, -13, 162, 10093, -66, -1};
. E  q( M) D$ w7 R  p( v8 ?. n" k0 R        int[] temparr;

$ C- e% i/ M% c: W5 R- i. E% M
        //测试冒泡排序
  y3 c8 p/ L0 M/ a        System.out.println("测试冒泡排序:");
        temparr = nums.clone();
/ U6 I3 S- ^9 }/ t( }        BubbleSort.bubbleSort(temparr);
3 H5 b, s5 E- Q  l        //逆序排序
# i0 K  r  a$ z; L$ c( o8 _$ W        //BubbleSort.bubbleSort(temparr,false);
        for (int i = 0; i < temparr.length; i++) {
: g0 [0 H8 g& j! r$ D            System.out.print(temparr + " ");
        }
        System.out.println();
1 `# g4 Q" M2 C% T: {! i  n; [6 \

) j! ]8 Y2 ^" T! P7 J1 b2 B; {) x* X; C    }
  k; F- Z) |( S" h5 G}
1
  F6 X9 g4 v( w2 o2
+ W' C) l8 X$ d& n9 w* C3
4
5
6
6 E3 j5 ^- J0 \2 b. U0 _0 I+ W- S7
8
9
10
11
12
2 @4 R# r+ @+ _. B2 F% O13
14
15
5 Y: q7 Q: B5 ?" d9 ^, Q16
17
18
6 T7 r2 w0 V  }9 F9 K; R6 x+ ^19
20
21
$ i! {7 i  C) L" k3 O' p; f7 D22
7 b: N; G  ]5 }% d& u4 v7 S23
24
25
: O: X) A8 x' n0 D26
, o( Z" S/ j4 S6 S27
28
* I8 G6 a+ n, w. j6 J5 \29
30
31
32
5 l& T/ n% z! \33
运行结果：
/ ]! }" u) U, ^8 w  N) c2 o  t, ~

测试冒泡排序:
-66 -13 -1 1 4 9 12 25 25 26 34 47 58 99 162 10093
( d; S: ]4 z. I/ f. h1 ?1
- N# ?2 V/ O2 F7 ^- x% ?2
降序排序（从大到小）
4 H8 Q! J  C5 W! D  a) ~- C4 ]
! F2 y0 H+ \7 T5 P' W: V; r
//测试冒泡排序
System.out.println("测试冒泡排序:");
temparr = nums.clone();
+ a9 t8 F% [5 e' v# g! vBubbleSort.bubbleSort(temparr,false);
for (int i = 0; i < temparr.length; i++) {
) L( M' U1 ]2 n& a% ?+ P! {% v3 n    System.out.print(temparr + " ");
}
System.out.println();
) Y" {- ?+ N8 t; J$ ^; V1
4 a# i0 z/ O3 n6 M/ {2
3
4
7 q) E8 U' v2 r: }5
( ?5 }" _& N8 J  X3 e6
- e+ Y6 z6 M" c! ]( s+ R  W7
8
运行结果：
+ U1 c0 S5 w; \
& ^5 A% A6 S5 a! ?" g
3 K. S/ g9 q; P2 f( F( v' M8 u' m测试冒泡排序:
10093 162 99 58 47 34 26 25 25 12 9 4 1 -1 -13 -66
0 i; L' A+ x2 i. Q$ u# Y% L4 t  k! p1
+ j/ M+ l; m1 ?, |: h2
下面几个算法的测试也就是换了下类名和方法名（换成相应的排序算法），如果想降序就在数组后面传个false即可。我就不一一复制了，我在最下面给出含所有算法的测试类，需要的自取即可。
- o2 U" o4 o0 ]$ r
5 M9 l* h) c+ }) U$ Z2 l
快速排序
+ r5 X: g/ x7 U+ i  m  ?简单解释：
9 A0 N) C: S2 Q6 p* ~快速排序就是每次找一个基点（第一个元素），然后两个哨兵，一个从最前面往后走，一个从最后面往前面走，如果后面那个哨兵找到了一个比基点大的数停下来，前面那个哨兵找到比基点大的数停下来，然后交换两个哨兵找到的数，如果找不到最后两个哨兵就会碰到一起就结束，最后交换基点和哨兵相遇的地方的元素，然后就将一个序列分为比基点小的一部分和比基点大的一部分，然后递归左半部分和右半部分，最后的结果就是有序的了。
  Q' }0 O* u: t1 q# d3 h

) Y0 {4 ?  Y) e" s2 E/ b4 _5 c5 P



完整代码：


; d$ y$ U6 H2 P9 mpackage com.keafmd.Sequence;
  ^1 h7 |- J' {2 G

/**
* Keafmd
*
* @ClassName: QuickSort
* @Description: 快速排序
* @author: 牛哄哄的柯南
/ o( O) O- v) n" o' A3 ^ * @date: 2021-06-24 10:32
( |# N5 N( u, _  R* x( {9 E* T */
public class QuickSort {
4 S' t% ~& r* _8 l; P  G. m% E2 G

    //快速排序
    public static void quickSort(int[] arr) {
! R  M7 j3 F  w( k- |        quickSort(arr, true);
! T. x( x7 E3 Q6 }    }


4 a6 P- G5 X2 ^3 E8 R: p: ~/ x) M" k    public static void quickSort(int[] arr, boolean ascending) {
        if (ascending) {
8 G/ ^8 ?4 _9 E1 P            quickSort(arr, 0, arr.length - 1, true);
3 W  U3 o& h0 U2 W- y        } else {
6 e- k" W3 D/ @5 y! f5 e# v. t            quickSort(arr, 0, arr.length - 1, false);
        }
    }
0 V8 x4 f$ j1 J7 Q* J# W

    public static void quickSort(int[] arr, int begin, int end, boolean ascending) {
  E. v# r- g4 |, D/ ]" {        if (ascending)
            quickSort(arr, begin, end);
        else
) W( W3 g6 k  ~% l            quickSortDescending(arr, begin, end);
) y+ f: N  g: L+ N; g9 i    }


    //快排序升序 -- 默认
    public static void quickSort(int[] arr, int begin, int end) {
        if (begin > end) { //结束条件
            return;
        }
        int base = arr[begin];
        int i = begin, j = end;
+ z2 U  y7 {& V6 o        while (i < j) { // 两个哨兵（i左边，j右边）没有相遇
. o) q& b' `, C) M4 y. H            while (arr[j] >= base && i < j) { //哨兵j没找到比base小的
4 l' l- z3 r3 X5 ?& N                j--;
            }
  X& U( K7 J7 u6 \            while (arr <= base && i < j) { //哨兵i没找到比base大的
                i++;
            }
            if (i < j) { //如果满足条件则交换
                int temp = arr;
                arr = arr[j];
6 L0 K* f  e1 v! w& L' G                arr[j] = temp;
            }
4 W. {" Z( U  G2 V* |

        }
        //最后将基准为与i和j相等位置的数字交换
+ E3 M! S0 a/ }& H, e$ v( L  z        arr[begin] = arr;
        arr = base;
( x9 a/ m6 S2 C$ C        quickSort(arr, begin, i - 1); //递归调用左半数组
        quickSort(arr, i + 1, end); //递归调用右半数组
( U* C6 `0 c# z2 Q: g* z

* n& P6 S% C. F6 z2 D, o2 f6 m7 @    }
. Z" @2 q, Y6 q$ G  W- F: V0 s5 I

, A% m1 x% [2 T/ s    //快排序降序
, s& @. [$ A1 m    public static void quickSortDescending(int[] arr, int begin, int end) {
0 f- Q7 h! s8 u# s6 N' r% P6 K        if (begin > end) { //结束条件
" b+ G8 q4 `- V: n3 z4 _            return;
        }
        int base = arr[begin];
# ~) u, |, s6 A        int i = begin, j = end;
        while (i < j) { // 两个哨兵（i左边，j右边）没有相遇
            while (arr[j] <= base && i < j) { //哨兵j没找到比base大的
* X. D( `: T  a0 S+ s. a% f0 \                j--;
# c0 b3 u; P$ i7 P* Q: `            }
            while (arr >= base && i < j) { //哨兵i没找到比base小的
                i++;
& a2 _4 L2 |& }6 E$ @            }
            if (i < j) { //如果满足条件则交换
- T9 a) U" n' w7 L! T9 g                int temp = arr;
+ ]" g4 c. V( O4 ^5 v                arr = arr[j];
                arr[j] = temp;
0 ^3 E" D4 Z9 {8 Q7 I            }

5 I3 Y, c9 p8 @6 w$ \- J. z6 o1 g. j
9 }# _$ S0 `! ]! l        }
1 v2 L  `0 G' m' G6 I# H) l        //最后将基准为与i和j相等位置的数字交换
        arr[begin] = arr;
        arr = base;
' o# a3 L6 E! d# H        quickSortDescending(arr, begin, i - 1); //递归调用左半数组
9 Y" y8 B# _' `5 p6 Z3 Y3 k        quickSortDescending(arr, i + 1, end); //递归调用右半数组
6 ?) d7 t  V9 L6 w

    }


: w( u- T' U2 u# D1 G( I- E}
1
0 n1 }) @9 a7 w* z6 G# N2
3
4 Q) Z$ @; H% i5 M3 b4
3 I, Z0 M% R' i3 b1 V9 O5
3 u2 e  |; H0 Z* K6
7
8
" X( _  X8 \( R9
10
11
12
0 Y- w9 H" s5 N0 Z& \2 n13
14
6 K7 h8 c& T% d. K! }15
16
& J7 W. @0 d" W1 f7 V2 C# y8 ?17
18
8 x5 x; g) ]8 n+ l19
20
21
22
) V- p& a' Z  Y+ Y. R+ d23
24
% ?+ \" g, @* W: ^# u  e25
, K; T; q( Z7 u26
( w7 ]! F; p) M$ n27
28
, N% `( y/ C' Q  E) l/ K29
30
6 J( f+ p  O. Y31
$ a; P4 P+ U& A3 s  n32
33
6 ^9 Q) d, S1 F/ G7 y34
! U; c  u6 ~: N35
$ t, T. a9 \; ^36
37
38
  @* E$ \+ [. x# {+ D, e# Q39
40
/ N0 b! x& Y* h# K5 b2 `41
- W( d( U/ b# o. ?9 p42
" b3 \* U0 g$ m% S8 D1 _43
44
45
' l6 q4 u1 s- a46
47
48
49
50
3 F& v. _4 d" h  t! O% \: I- d51
52
5 B) F) T) u: p0 u% S- B  G- q53
0 C0 n# s/ V2 r( X54
55
56
4 u: O  C3 K0 v( L$ f& `3 Q57
58
59
60
" i% p+ K) r6 Y61
62
5 N' }1 P0 O2 Z( M7 n7 C63
64
6 B, [8 t+ H5 R: i! a65
66
67
68
69
70
71
72
2 q5 W2 S4 S$ S73
74
75
+ W) ^1 z% h# V+ T, M% M76
77
78
3 P+ k) z2 g! ]. |79
, z3 C, ^) z  {  W80
81
82
83
84
" V0 z1 F& x% R# ^85
7 t9 f2 E1 j! N7 W86
87
$ F/ V  ~$ {% z* W# u" S6 x88
89
& k/ i' Q9 T) Z' s: B/ L90
91
- ]/ w3 y0 k& d$ [, q" D* B. O直接选择排序
简单解释：
% U- }! a+ x( K3 J  R数组分为已排序部分（前面）和待排序序列（后面）
* H0 p) s' x' x7 ]* u( D9 p  Z: T第一次肯定所有的数都是待排序的
- _; v- R0 L; r6 W' H5 u+ e" d从待排序的序列中找到最大或最小的那个元素，放到前面的已排序部分，然后一直找，不断缩小待排序的范围，直到所有的数都是已排序的了


/ q) a, O, S( ~) Y3 H; W& S

7 P9 }9 }% ~6 ~9 \, C

完整代码：

9 y. f8 f7 i: |+ f- R4 O
package com.keafmd.Sequence;
: S+ ]7 W0 ], n5 e
- G- v- k' j. Z* A: o+ y
/**
* Keafmd
*
8 @5 M% @; x# V% I8 F * @ClassName: SelectSort
* @Description: 选择排序
* @author: 牛哄哄的柯南
" H; v8 Y: I: w% `3 K * @date: 2021-06-24 10:33
*/
: u! c+ l$ y6 x1 ^, a& ]' kpublic class SelectSort {


    //直接选择排序
    public static void selectSort(int[] arr, boolean ascending) {
        for (int i = 0; i < arr.length; i++) {
            int m = i; //最小值或最小值的下标
            for (int j = i + 1; j < arr.length; j++) {
                if (ascending ? arr[j] < arr[m] : arr[j] > arr[m]) {
                    m = j; //找到待排序的数中最小或最大的那个数，记录下标
                }


. g% L* H. g- Y1 P) @- S: |( f            }
7 v# L- c; m/ Z$ B/ e! _/ r8 s            //交换位置
            int temp = arr;
            arr = arr[m];
            arr[m] = temp;

" s5 O8 m  B% |
        }
    }
# c; Z4 x  y; @
! w" K, m6 E$ S
    public static void selectSort(int[] arr) {
        selectSort(arr, true);
# b4 p: |6 A5 s2 A4 g5 a6 A    }
2 w' Y  e4 }( i) L& w) m' N}
. D+ r& L& O- T1
2
3
0 H! I8 t! a1 k/ m8 J4
5
9 e2 P$ @7 @0 Z: N/ Z0 m  b6
1 Z% _6 d5 E- S& R% ?, o0 J7
8
  [( O/ w7 s' v" R' [: L6 l0 b9
10
+ \8 ]/ B/ g- A& [11
12
' A- s: }* t& |$ X. N7 w4 I13
# H. d; J7 W/ F' q# z, p9 S5 C0 Q14
15
16
  F5 K2 w9 W( `( q17
6 s1 |4 v. Q8 S18
1 J- l5 C1 f! n! Z# y" Y19
  D; ?5 d4 J2 S* S+ h& i20
" M& d* @" V6 h" l5 P21
1 E& u, R# v( E, ?) {22
* q" z1 [5 e5 v. p2 L23
24
25
26
9 X4 P$ l1 w7 d4 p& e- n9 R27
8 _2 R; s/ L1 D0 `" |' m! u+ d28
- D$ W( O+ x0 j1 @29
- w& W$ \( W/ N- ~/ D1 k4 d30
3 J  X/ x3 x+ Q( v) a7 I31
5 v6 G' _5 }1 v" W32
7 S1 ^! h& s2 o33
34
堆排序
先理解下大顶堆和小顶堆，看图
大顶堆，双亲结点的值比每一个孩子结点的值都要大。根结点值最大
小顶堆，双亲结点的值比每一个孩子结点的值都要小。根结点值最小
5 `' m- b. w- h' i- I


! Y' R" M5 B( c
简单解释：
构建好大顶堆或小顶堆结构，这样最上面的就是最大值或最小值，那么我们取出堆顶元素，然后重新构建结构，一直取，一直重新构建，那么最后达到排序的效果了。
0 L0 A  y. r; E% Y' H3 u; ^
7 A8 B- d/ K: b, S. M2 D9 ?
" s2 n) ^) l( e/ X( k) j" q' g
' v1 [' M: R& `; }+ h2 v6 f3 t
, q& Q0 w7 N$ g& i5 e* `: ^
6 b' H9 q( p4 D, B# X
完整代码：
* J/ b& E3 I4 \6 {4 P: ~

package com.keafmd.Sequence;


/**
7 u$ }2 s5 V; s, E3 n9 v * Keafmd
*
* @ClassName: HeapSort
* @Description: 堆排序
5 e% S% }- K9 D- J8 ^ * @author: 牛哄哄的柯南
9 m. W2 c/ s) L% Y( p& p; V2 f * @date: 2021-06-24 10:34
2 A1 p- w& _7 `& Q3 r9 K */
public class HeapSort {
# m/ \# S2 u% k, ~! ]9 C4 @* @
: l* w+ P# e( R0 w
    //堆排序
- k  ]1 B0 D. z3 {+ {    public static void heapSort(int[] arr) {
        //对传入的数组进行建立堆，这里默认建立大顶堆，进行升序排列
$ b1 @5 |9 U  [  E$ O# d) K4 _        heapSort(arr, true);
    }


    public static void heapSort(int[] arr, boolean maxheap) {

$ l3 j+ ?: T' a$ ~! z; \5 D1 S
8 x, j! ]6 s1 N        //1.构建大顶堆
3 \; v$ B& X3 m% j+ q        for (int i = arr.length / 2 - 1; i >= 0; i--) {
8 h$ c, X7 o- y            //从第一个非叶子结点从下至上，从右至左调整结构
            sift(arr, i, arr.length , maxheap);
9 V: U4 ~3 f8 K7 E( \  y$ ?        }
$ v8 r5 T$ N! U9 T

: e: o" _% Y7 y% y( z# W+ A+ t        //2.调整堆结构+交换堆顶元素与末尾元素
' y( A% E, I) d- S! Y0 U9 x3 v0 K        for (int j = arr.length - 1; j > 0; j--) {

# C$ Z3 ]- i3 }0 x& ?: C. P
            //现在的数组第一个就是根结点，最小值所在，进行交换，把它放到最右边
( n3 u# C9 @$ r1 }5 p            int temp = arr[j];
            arr[j] = arr[0];
            arr[0] = temp;

% @) l2 z( N$ V) V$ v! P
1 j9 z/ d& ?& V0 R) t( \* A! \7 u            //重新建立堆
# J1 z% g/ E+ Q/ P& ?            sift(arr, 0, j , maxheap); //重新对堆进行调整
        }
- d8 Z0 I" y$ Y    }

  t5 ]! P- `, S: [
    //建立堆的方法
  Y+ |8 o% x& g' c  B8 V    /**
     * 私有方法，只允许被堆排序调用
# j3 C' `, B9 K; s) k2 s     *
     * @param arr     要排序数组
  M" u5 U5 b, L5 x' a$ Q* G     * @param parent  当前的双亲节点
     * @param len     数组长度
     * @param maxheap 是否建立大顶堆
     */
- O/ K. D8 t( Q% T    private static void sift(int[] arr, int parent, int len, boolean maxheap) {
. p$ D. y: y2 Z% o( J

        int value = arr[parent]; //先取出当前元素i

) H5 {3 Z; N+ D( h3 |
$ J- q7 ]& b! p4 i2 @& @5 g7 q        for (int child = 2 * parent + 1; child < len; child = child * 2 + 1) { //从parent结点的左子结点开始，也就是2*parent+1处开始


$ U" R% S; ^* M) `% U# b, e" b            if (child+1 < len && (maxheap ? arr[child] < arr[child + 1] : arr[child] > arr[child + 1])) { //如果左子结点小于右子结点，child指向右子结点
2 N4 b# V4 x7 S                child++; //右孩子如果比左孩子大，我们就将现在的孩子换到右孩子
            }


4 D8 i+ V8 G' B0 j: c7 c            //判断是否符合大顶堆的特性， 如果右孩子大于双亲，自然左孩子也大于双亲，符合
            //如果子节点大于父节点，将子节点值赋给父节点（不用进行交换)
            if (maxheap ? value < arr[child] : value > arr[child]) {
" P$ x2 V6 e$ l+ r; ^- n3 N                arr[parent]=arr[child];
  M9 z' x* n! N1 f1 g; B+ b' H                parent = child;
! h' A- P0 L1 T: H& u            }
            else {//如果不是，说明已经符合我们的要求了。
2 G7 e% w; P' u/ \+ d; D                break;
% P1 d' J2 K1 r: ]  l3 j            }
        }
        arr[parent] =value; //将value值放到最终的位置
, E- v. o) E8 _# B# d7 \! }( Q

2 n8 B" Y" J. {

/ M8 G" ?: {3 T0 f# W& |" G    }

, Y, J) w& E1 V" B! c' t2 U
}
1
- z/ Q0 e; w7 d# j. l2
3 E9 @; \: l+ i) g9 _3
- y/ S4 H  H' W# M4
, ]+ }( x. L2 w0 Y  O: @3 z# p) v5
: [6 }4 g/ d- i6
1 W2 S4 p6 e, \) p1 `, m1 o7
8
( s7 k' c2 j9 A8 z9
/ u$ K0 B' p, H8 j; p10
! g' X0 o5 d6 U, ?' M; s11
12
5 i* V# M% x7 t/ d; j. r13
. j) `7 C  T3 @5 d' D( `14
15
$ [6 C3 S# X6 {2 O2 v1 t16
# J: y" O2 V$ F, A17
18
. }+ s: n: `/ x$ a" _19
20
21
22
, k. a- R# H" M- N& w$ k0 n23
1 v9 R: v1 e7 W' P, C( u5 R/ o24
  b, P1 x" _. `/ M25
26
" Q# }) n$ }) F9 D27
8 C2 F' P) @- |: N28
8 f. q. }. h- t) o4 ~4 ^+ T# `29
30
31
# g( ?' D7 A: t- b/ R& A4 x3 t& {32
33
: K5 n7 B0 \! J9 f) m/ @34
35
% N' ~! P3 l9 c. c" o36
37
38
* }' o) r  V( I; u8 p: K3 ^39
40
& I/ ?5 X; {$ j: N' V; h7 c41
4 ?$ k/ ]+ k5 i1 k5 ?9 F$ V% `42
& y9 Z3 w* }5 F- {( r43
* _. x5 q1 C+ f( W! d44
) {: x, m+ v! n- |! u" s45
" G8 c$ B" T9 O* I/ b2 E. }, i46
) K( y. q" j  R! B47
* g7 s" _7 d% l& I/ h  L& B48
# [" {6 T. n) C% y$ l$ j, p49
50
; i6 Q! N% h) D6 {6 V. u: m9 V51
52
53
54
) J) X1 ?- D2 b8 }- f3 R55
56
3 S- N# W6 w6 }1 _57
58
59
60
9 T8 _4 f8 T; ]. ^61
4 H( y) j" ?. v' l' m/ s" E62
$ P0 T4 L  V+ ^' A63
( M, r+ b  }0 s9 p0 N* [64
65
66
5 Z' Y6 t( h( i8 l, ^* \' j7 W8 h67
; y6 k' [: w; T$ ?+ l68
  o5 g9 T) D: P2 I$ B5 c69
3 \. d8 I" X* E9 k1 J+ {5 w70
5 |- b; X5 o) k8 X2 Y& \; o) y71
4 I1 z+ f6 E# y, Y5 o72
) a5 U, n% }9 C! I. v1 j73
74
* T# \) A( ]' @* K归并排序
2 k. n& q0 A% b% `# }简单解释：
: B6 D! Y3 A, W7 Q+ R: d( u( Z该算法是采用分治法，把数组不断分割，直至成为单个元素，然后比较再合并（合并的过程就是两部分分别从头开始比较，取出最小或最大元素的放到新的区域内，继续取两部分中最大或最小的元素，直到这两部分合并完，最后所有的都合并完，最后形成完整的有序序列）
: k" O$ m& R" i* R
  [4 v0 a5 z# `' g6 H

0 J1 X0 R! U' `


完整代码：
7 y" u$ s+ A# N7 o2 @
  @3 o7 ?- R1 n, }6 H! D
. D/ a" @" ~3 _  `8 g/ i0 \- l) f* `8 bpackage com.keafmd.Sequence;

& ^9 d- Z/ o; i+ _
/**
& W4 k8 r# G# w4 f( [. q * Keafmd
5 r6 q- q! [2 V3 v0 V. F+ Q *
4 a3 F6 S1 K& T9 U2 _* \ * @ClassName: MergeSort
* @Description: 归并排序
* @author: 牛哄哄的柯南
* @date: 2021-06-24 10:35
& U6 S( p; L4 _  H */
8 s6 W6 n. }* ]" K3 P- Z  A4 hpublic class MergeSort {
1 p" X2 F. O: O# G8 s9 C$ ^4 y

5 {% L3 ], V0 y1 \8 M' }    //归并排序
/ w) ?. k! u5 k4 |    public static void mergeSort(int []arr ,boolean ascending){
        int[] temp = new int[arr.length]; //在排序前，先建好一个长度等于原数组长度的临时数组，避免递归中频繁开辟空间
        mergeSort(arr,0,arr.length-1,temp,ascending);
    }
    public static void mergeSort(int []arr){
9 t  c. {9 @$ P- S4 d: c        mergeSort(arr,true);
    }


    /**
     *
) O* h- |! ~  A- c+ X  e  V7 G     * @param arr 传入的数组
     * @param left 当前子数组的起始下标
     * @param right 当前子数组的结束下标
3 A7 D6 b- e, v/ M) b; C: R; r     * @param temp 拷贝暂存数组
     */
    public static void mergeSort(int []arr,int left,int right,int[] temp,boolean ascending){
, C! i& r8 ~- c$ d5 V4 }        if(left<right){ //这里是递归结束的条件，我们是对半分，那当left==right的时候肯定大家都是只有一个元素了。
: M6 g- d8 O0 k3 u  ?$ W- H

, H9 N( ~' A$ a" m            //对半分，比如总长度是10，left=0，right=9，mid=4确实是中间分了，0~4，5~9
% u" O3 L" j5 z% x            //当长度9，left=0，right=8，mid=4，0~4，5~8
7 g( s: F/ A, T2 R7 t# X( z0 Q            int mid = left + (right-left)/2; // 防止越界的写法
+ a1 N5 N. v( N5 t7 @3 R. D            //int mid = (left+right)/2;

, e: M- b  L7 ^: k
0 d; k& p9 ]; X            mergeSort(arr,left,mid,temp,ascending); //左边归并排序，使得左子序列有序
            mergeSort(arr,mid+1,right,temp,ascending); //右边归并排序，使得右子序列有序
2 b# y9 N% ^. a' c/ u# G

            merge(arr,left,mid,right,temp,ascending); //将两个有序子数组合并操作
        }
    }

0 q+ _) y/ a+ K
8 `+ K% [. t& V" N3 H! _' T    private static void merge(int[] arr,int left,int mid,int right,int[] temp,boolean ascending){
8 p- X' m! d$ U, L1 J, E4 t        int i = left; //左序列起始下标
7 }9 |" p5 N% v1 ?+ c        int j = mid+1; //右序列起始下标
; \" T+ L# O. ]6 G        int t = 0; //临时数组指针
9 f' D1 }  d4 R) V        while(i<=mid&&j<=right){
            if(ascending?arr<arr[j]:arr>arr[j]){ //比较两个序列第一个元素谁小，谁小先拷贝谁到temp，然后对应子序列下标加1
                temp[t++] = arr[i++];
            }else {
6 T; W  F' f4 g  T, `: z/ y( W                temp[t++] = arr[j++];
: j; ?* B" ^8 H$ Q1 L9 S            }
( Z! M" D; o: F# L        }

9 \/ e% E, x# S% `& A
        while(i<=mid){ //将左边剩余元素填充进temp中——左序列有一些数总是比右边的大的数
            temp[t++] = arr[i++];
        }
6 {1 |& O4 U+ b8 z2 {7 x

        while(j<=right){ //将右序列剩余元素填充进temp中——右序列有一些数总是比左边的大的数
            temp[t++] = arr[j++];
; U# |* j9 l6 Q5 w  O* Q9 H3 [        }
3 w) B1 Z, K8 N' W- M) Z0 l
- J$ j5 `: ?* K. g1 x) S" l9 @
        t = 0;
# T9 H" H! S7 ?& U
# P( z6 d8 ^4 c2 _. f  Z3 ~
7 n' m( J* Z, \+ G6 C* k        //将temp中的元素全部拷贝到原数组中
# K1 {$ ]2 K4 E* e, o0 a/ v        while(left<=right){
            arr[left++] = temp[t++];
3 L2 v' K; a  k" ]  d        }


8 m7 {2 R" i0 O9 g9 q    }
' S; a. {, H( C5 S. o; p% z. W
* c9 b/ w5 `7 R$ C. E# _
0 z5 o2 o, h- @2 M1 r3 @}
# X  W; N* C  D3 n5 p1
2
, q; _, w; c$ L/ w* E. o4 i3
  `3 R- l6 Y, E6 [: W4
! l% [# U( a8 |4 j; g5
  j5 y9 x9 |3 h3 b0 x  ]6
7
8
# \- V1 n( s2 a; N9
10
- ?, X2 A! @* u% c1 E0 d11
/ B" Q& M" p5 ~4 v; R12
, m( @  `+ T# x; F0 F; P% k  i7 G13
8 j# e7 e9 r- r- @( v7 O14
# |6 G# h. _" [9 R+ Y15
16
8 j% T/ ~  z! X2 E4 W8 G8 K0 z17
18
19
0 v1 |" r5 Y# m8 Q# h+ R. N20
2 u2 X( c% ]$ b+ ^/ c- w21
5 t2 o! a, ~) J6 l4 m. A7 B: G22
5 j( j$ i4 F, d. R+ T( u( R23
( A% l- r3 H! B* \# Y; ]24
25
26
27
28
: t6 G* y3 {" \6 t29
30
31
) O6 I; b$ u3 t) W7 j% z' J32
33
34
6 y$ h  E7 i2 {) E! H35
36
5 V/ L  i) t0 Z. m2 e37
38
6 P5 ]+ w# q3 a0 h39
: X) d' K# l" ^, f; y4 q40
41
42
- p2 N5 J. W- a43
) l0 I7 w7 w7 Z; r, Z+ b% I7 t44
. Y* e) g2 c$ H& Z2 j+ D45
" V% f, b' S+ Y# k46
47
: ]* z8 b! x  r9 j$ U+ H; g5 \( n48
49
50
51
52
53
54
$ m# V; S3 ~7 B  {" e0 U% r1 H55
56
  B1 L% u' f5 S; u# o% l57
58
59
8 ~+ m& O( `  Q1 h3 y2 o, H60
61
  L. s! @+ X  U$ T2 z$ Y62
3 @1 R& D) P" D% p6 Y63
64
  j) B: ^$ q) [) z65
66
- _) V% Z, _* d67
, o- ~" h  x3 o6 I1 v; w+ Q68
69
70
2 N8 L) [8 w0 |- ~71
72
4 `" m4 N: X1 {2 ]' h4 Y3 ^* ]73
3 L4 z$ w" K0 @$ R! b1 a插入排序
7 Q; ]8 S7 e4 l. {, R- \2 h3 f简单解释：
最简单的理解就是打地主时我们拿到牌后的整理过程，从第二个牌（假设我们拿起来这个牌开始比较）开始，（说下升序）从后往前比较如果比前面的那个牌小，就把牌往后移动，直到找到一个合适的位置（这个位置的前面的那个牌不比这个要放下的牌大）就把这个牌放到这个位置，慢慢的前面的部分变得有序，直至全部有序即可。


% ]) O+ }4 z" _2 x0 ]7 h
, y0 j/ C# _% _0 a/ F
( `$ \9 c$ q. m! {( C# F5 W
! _, ]4 F6 Y8 Z
完整代码：

* ], r/ d, D+ k+ D3 l$ m* ]
3 t' C% b3 j+ O' x) G& ]1 Vpackage com.keafmd.Sequence;
1 f+ e9 Y8 n7 S

/**
6 T& C& J, }* n4 I * Keafmd
*
* @ClassName: StraghtInsertSort
* @Description: 插入排序
* @author: 牛哄哄的柯南
* @date: 2021-06-24 10:36
*/
public class StraghtInsertSort {
9 ?" k5 g. G! o6 S4 g    //插入排序
- U: L4 z$ Y' s0 ?% `    public static void straghtInsertSort(int[] arr) {
        straghtInsertSort(arr, true);//默认进行升序
+ U! e, y; v# q1 y1 y    }

) I# \2 `! u; ]+ t
& {7 G- ~( f- t! `$ ]) j    public static void straghtInsertSort(int[] arr, boolean ascending) {
8 S: H* Y: d- n( t+ R8 O2 L/ w( `8 v

2 P# S$ N- s- k* W1 Y7 L5 U        for (int i = 1; i < arr.length; i++) {
            int temp = arr;
            int j=0; //这就是那个合适的位置
: ^7 p* K# K: `/ F- a            for (j = i - 1; j >= 0 && (ascending ? temp < arr[j] : temp > arr[j]); j--) {
                arr[j + 1] = arr[j];
            }
            //把牌放下，为啥是j+1，
            //是因为上面的循环遍历到不符合情况的时候 j是合适的位置的前面的那个数的位置
- ]2 f" Y9 T: |! k. T            //有点拗口，但是就是这个意思，看图方便理解下
            arr[j + 1] = temp;



! @9 E) O2 k4 d- |* Q! _' `6 T& ]+ y
        }


0 I8 v' q) t2 J    }
}
1
7 _: }5 y/ ~- K$ [- t2
3
4
9 n: o5 }4 `6 X8 U8 l. D5
! f+ c- {- u. q% W" G/ l6 T6
7
8
9
10
8 Y2 I  F9 V# @5 w: V4 A11
" t5 Y% q$ m" F, F# q& k) G; y12
13
" x0 y7 D( X* J: @14
7 T. G# }# W4 }& e6 X4 u: p15
$ p- Q- v1 R% W! v& R16
8 o2 l, I+ v4 E7 j, k5 B, o# V17
18
* |1 ?. x+ M2 y/ j19
8 J! {! X$ A$ c+ O0 M$ ~8 L' i5 {20
6 U6 c, C$ D3 W5 S: C21
22
& t1 h, \4 e- ^, ?. ]1 x# I23
24
8 T0 A! M$ H; H% ]4 E* X3 J: V25
26
27
  T# D: F3 P" O" |( c; @) P4 U$ u28
( R/ z' P  P1 d7 s2 a29
9 F' w: m; Y% u% {/ o30
4 T9 X9 t0 ?* ^) h9 g& e* b31
32
33
" C) j0 K5 X: i" O34
希尔排序
简单解释：
希尔排序是插入排序的改进版，我们理解一个叫做下标差的的东西，也就是下面那个图中的增量d，初始下标差为arr.length/2，然后继续/2，对在同一下标差（相当于把这几个数单独拿出来了）的若干个数进行插入排序即可。


; q4 d' b8 L1 M5 A( D



完整代码：
- N; l: [5 `: ]; j
2 L4 k8 F9 j2 T' w1 V% f
# F! ~- n6 Z' L* D" |2 Vpackage com.keafmd.Sequence;
. U* Y' M) V  o3 V6 ]

) q/ @0 f1 f4 ^/**
* Keafmd
*
& `* [6 T& A% A' d8 T% h8 Z * @ClassName: ShellSort
- e* h6 n+ O" ?7 e% D3 a: i * @Description: 希尔排序
5 g7 A7 q5 B: n) k% O * @author: 牛哄哄的柯南
* @date: 2021-06-24 10:39
*/
' Q; [  ^( d: U9 Rpublic class ShellSort {


+ y: g8 V/ }. K6 p. _    public static void shellSort(int[] arr) {
# x$ G+ E1 d# V$ P        shellSort(arr,true);
    }

9 C1 v+ N* H" r" [2 T
    public static void shellSort(int[] arr,boolean ascending) {

" c! ^- h8 t' |) l: J+ f8 M
        for(int d = arr.length/2;d>0;d/=2){
7 o4 Z& o. B6 K4 b" m9 r
4 \# r% O- ^; Y! h: q# a, Y
& @1 [; |4 Z: ~3 n3 R            for(int i=d;i< arr.length;i++){
                int temp = arr;
0 |2 V# @6 `  b8 h6 I8 F                int j=0;
8 y! k3 F' `2 G, V7 `! m                for(j=i-d;j>=0&&(ascending?temp<arr[j]:temp>arr[j]);j-=d){
                    arr[j+d]=arr[j];
1 X1 d/ W- D3 L3 r$ R, u5 X0 K* {                }
                arr[j+d] = temp;
; s! I  W  u' ~+ s            }
& D+ C2 h+ I/ g! c  A" L% R        }
4 x( {6 p! M* o6 W6 G# X
$ r  D$ t2 K5 z2 w2 K/ c; ?, h
    }
}
; [/ z/ t6 p6 Z2 |7 H) l8 `; d2 ?1
. C& j- L0 j4 G; p  u4 J4 Z& s$ n2
( V4 {) q% u+ V- f2 X3
4
  z6 v8 C  }3 e/ F2 u5
7 Y% f) ~6 q. m  }5 h4 I6
% [8 T8 a& m% v" B7
: W7 o9 ~7 `( o+ Q: ^  ^8
9
( f. F  V; v7 |7 n10
! V( x4 [* U' K+ s, a+ f: j7 x11
7 A/ p3 A: r1 B) o12
. `4 W" k8 o/ c+ w. X* J13
14
15
/ M# B. {' o- t0 @2 ^: b/ \% h16
5 \* Y/ ?& X5 q9 Z17
4 k) N( I2 u# j18
19
4 O6 L" e' J+ g1 ~3 [9 W20
. y/ h! b) q6 p; T' Y; i7 L% ^4 `21
22
2 G/ O- d' H( T. y23
' [3 p% H% I6 J* k+ T* ], @$ p' s24
25
26
27
28
29
30
31
32
7 j4 l$ J# t# k. }+ X& }7 G计数排序
: w' x. o8 V1 I简单解释：
这个排序算法看名字也很好理解，就是就是额外找个数组来计数，然后在这个数组从小到大或从大到小把数取出来即可。

, d& t; M3 Z3 a3 A( x. q
* m: ~* E6 r" J8 D' Q! u- B" X
5 i9 O' d' j2 z( @: v! |- @

2 A! i/ H, F  |0 B# N% P) x* U
完整代码：

% Y0 k, l* I) f( E7 B: n
; r4 J! n( [# \* xpackage com.keafmd.Sequence;
, X: H5 X: s, Y$ `2 p

. Q$ }# _' S4 s$ f, c; `8 d/**
& j: R- ~& ]7 x) u4 \( P * Keafmd
- m- w( Q! N9 g6 i% b+ k' |0 o; L3 i *
  K& u3 f2 X" ?, ^6 B * @ClassName: CountSort
* @Description: 计数排序
" P% F& m& |1 H( y7 t! L1 n2 P8 ?8 E * @author: 牛哄哄的柯南
) S7 [" Y/ A) U& _& { * @date: 2021-06-24 11:31
+ N& p- H1 t; S) z2 ^4 O */
public class CountSort {
! S" o- X, H0 G. X3 c2 H

# j$ r3 T$ c  `- t- c: {8 p    public static void countSort(int[]arr){
3 v) m  U' b4 s0 }: V5 V. g3 c! _        countSort(arr,true);
& w# o3 b7 X9 B2 g5 |    }
( P, h3 d1 {# q. n

    public static void countSort(int[]arr,boolean ascending){
5 j" y9 \( h, ]3 E5 g6 N& B3 b        int d,min=arr[0],max=arr[0];

% T$ d5 \( R7 [7 |$ T4 {! t+ k
2 \% E8 I. m# v        //找出最大、最小值
        for(int i=0;i< arr.length;i++){
            if(arr<min){
                min =arr;
, E, F" [0 d; Y# [- q! |            }
            if(arr>max){
' l( J( \, g( R- g- H9 O                max = arr;
/ I# E: C( K( T            }
        }


        //建立一个用于计数的数组
! h6 H/ b" I3 x( H        d = min;
        int[] count_map = new int[max-min+1];
  S5 ?$ I/ H; v* p6 K0 s9 k9 ~2 d" o        for(int i=0;i< arr.length;i++){
            count_map[arr-d]++;
  O5 p8 i3 Q: M! A2 [6 }. y        }
5 H* z+ E2 s; D( I& J' Z

        int k =0;
- A9 u+ a2 E6 V3 d        if(ascending){
, G. [& Z5 h% k' z            for(int i=0;i< arr.length;){
* U5 F" U8 w( T# d                if(count_map[k]>0){
                    arr = k+d;
                    i++;
$ o, y) o0 I1 }( `' @* b+ T                    count_map[k]--;
                }else
& X0 m$ d3 ~, g% z& d                    k++;
1 o! _( m, `( u0 {  E, C0 z3 F            }
8 `% k6 c5 ~( B9 E: e4 K3 c        }else {
8 u0 a! y' @! N: [/ d1 b            for(int i=arr.length-1;i>=0;){
: S8 P- S* N* f) U5 v6 ^                if(count_map[k]>0){
% T9 C+ L4 M" ^9 p" s* N                    arr = k+d;
% X8 T7 n; s" M: S0 e3 A                    i--;
$ J2 Y+ [1 o6 j1 c) H* M: E  r9 g                    count_map[k]--;
                }else
                    k++;
            }
, c  h$ V9 Y+ M+ a        }
% b4 v0 V1 b! M% }& p* Y: E" I% Q+ _2 a

- }+ ?3 w7 ]. M2 Y9 Y' [    }
0 ~4 v4 p5 L0 C; Y3 a( ^7 T}
1
& `7 o0 A7 R7 x6 u6 q- \5 j2
3
. q7 `4 v6 s" F, L4
  c& `9 k# z- u! x# f- t& T& @5
: }3 F$ }& I+ d0 U6
7
! U# C$ o4 _+ w0 \5 T7 i* y  o8
5 M3 R$ [, C- L$ r% A5 C9
3 t$ d  ]8 e! Y10
1 y5 l# y5 [% l11
12
/ K( j# g! S, Y3 K+ S13
$ `0 U7 B' E7 d4 t8 ?7 R14
15
16
17
18
; u; a) p/ L! ?# @! B! ]: O) v19
20
& F' _. ^% m3 d21
8 L. u3 \# _% q( i# H/ ~22
23
$ L1 P: }) i! H+ U+ ]) ~6 X. W24
; c2 ]& S. ^- N* R25
; y0 r- z. a% [( s7 v- F26
27
! n7 K4 Q$ ~; M  M# H  G28
+ C$ u' w! }$ M) F29
. l# q# ^7 ~! e  n$ l( N$ V30
31
32
4 Z. y8 G6 |+ {7 Q33
6 h! Z. f( Z/ M1 r" h2 T34
35
( x/ s. h# p5 a% A7 t: Q9 s36
37
38
! t% o& k" ^. W& B+ f39
7 i' R# C1 G. ~- o: @! l5 R$ i5 X40
/ W2 F6 o6 b" T; O" g- p6 u" x4 u2 L41
42
9 n5 q& H* f9 w8 g4 b4 K43
44
4 T: h' D/ s6 W& U0 X7 p; J45
46
47
: L2 b: [! X" F$ u3 m5 P% d48
49
50
( Y) n! o5 v6 Z6 b51
52
$ ~+ @7 m0 i+ q* Q6 g) I. ~- `5 E53
) o) t3 v7 `0 A54
" }8 ?" N* ^! M- Z  }4 g" m55
56
57
58
% E% {5 W- N8 i1 E0 @59
( f' h( J! a8 L4 |( S桶排序
9 _: O+ J6 I* }$ o. o: \% ^简单解释：
) f  m8 S5 S( B- y" W就是把一个数组分成几个桶（其实是几个区间，从小到大或从大到小的几个区间）装，然后让每个桶（区间）有序，然后取出来放一起就可以了，相当于把几个有序的段拿出来放一起，自然还是有序的，当然需要是按照区间的顺序拿了。


# G% D+ P. }( r# t

5 m! V' x6 T) u/ Y, [9 Y9 ?7 t! ^
6 c! L% o/ t: Z0 t4 O0 G+ x4 |) _
- s5 j3 i6 I% V6 J1 i9 y: s完整代码：
* B) P% j  G" ?

5 x. J4 z, S+ R6 ]+ v% m; b" P( Fpackage com.keafmd.Sequence;

  ?( |+ T" G1 e  Q9 C
import java.util.ArrayList;
/ p- L3 W5 D+ f# m8 X2 Q: u/ F" uimport java.util.Collections;
' K! W, N8 W/ ~& ^6 j  f
; X& J  M% `6 y+ T
/**
* Keafmd
& R' Q5 `/ \" l4 H. ^# ]% o, t *
. [. [+ W! z) V/ [' u2 f! K * @ClassName: BucketSort
9 b  {6 q+ f8 c: C * @Description: 桶排序
* @author: 牛哄哄的柯南
! J) [" R7 L1 ]9 O% J; ~ * @date: 2021-06-24 13:32
*/
public class BucketSort {

1 }3 B! f6 x4 n; n# ~
    public static void bucketSort(int[] arr){
        bucketSort(arr,true);
    }
# A! }0 x! v- y/ U) N" [4 h
& l8 H, m; _( R5 @8 l( |; v
& I' |; k7 o- e- ^" l    public static void bucketSort(int[] arr,boolean ascending){
        if(arr==null||arr.length==0){
0 C  U' l& m3 X+ F7 T            return;
        }
        //计算最大值与最小值
2 b. j! l- _4 Y5 }) G7 w% |        int max = Integer.MIN_VALUE;
1 ^1 {5 P. l7 \' ]! E9 G        int min = Integer.MAX_VALUE;
        for(int i=0;i<arr.length;i++){
, H2 l8 D  k5 M9 K( F            max = Math.max(arr,max);
8 E" E1 f+ C+ ^* u: R8 K7 P( W" h3 e; i; C. O            min = Math.min(arr,min);
4 d8 m& c/ h4 j% L( d) ^6 s2 d        }


- {1 }1 n2 T8 ^( @$ b        //计算桶的数量
        int bucketNUm = (max-min)/ arr.length+1;
        ArrayList<ArrayList<Integer>> bucketArr = new ArrayList<>(bucketNUm);
        for(int i=0;i<bucketNUm;i++){
            bucketArr.add(new ArrayList<>());
        }
! D# B/ K! `) \3 {6 y, u
$ c0 ~: D" ]3 M: }
        //将每个元素放入桶中
2 J- v3 `# i( ]8 C: y' L$ t: X7 l        for(int i=0;i<arr.length;i++){
            int num = (arr-min)/ (arr.length);
            bucketArr.get(num).add(arr);
7 z" B5 m  G* M% ^        }

0 U  V- K7 q. i; z. E2 L
  C; T0 h9 `+ N6 ]: M        //对每个桶进行排序
0 C. b- J0 q: m( g4 j5 }        for (int i = 0; i < bucketArr.size(); i++) {
" S  U, X" \/ c* R            //用系统的排序，速度肯定没话说
' H' Q6 j1 N( i) O            Collections.sort(bucketArr.get(i));
4 b% }) m" N1 u4 t! P% {        }

" |0 @! j  v+ |. J9 a
        //将桶中元素赋值到原序列
8 |) D9 {# R3 [+ y2 M        int index;
+ A; @+ I  K; S2 q+ V% `        if(ascending){
% B7 d4 T& w" C; X( w' O) v            index=0;
+ X! v  i( @" e1 E7 B3 `        }else{
            index=arr.length-1;
3 w5 `/ s, G) d        }

9 J0 t4 X* |* d) K/ A4 K
3 X6 |8 q7 |; e        for(int i=0;i<bucketArr.size();i++){
, Q$ s$ a+ ~4 o3 |# O$ `# ]6 h9 @            for(int j= 0;j<bucketArr.get(i).size();j++){
2 n, V5 q0 i( U# p0 T+ k9 u! E                arr[index] = bucketArr.get(i).get(j);
. ^, {( h- X- s( Q7 d, ]                if(ascending){
                    index++;
* X' g7 F. u3 X                }else{
/ l' Q% B' N5 I3 N' l. j& q) r+ i* B                    index--;
3 g! N0 M; y2 A! J, _4 }& V                }
            }
) u: S( o/ d. S" T; f( o

( l+ T( m8 o! v0 S/ n; |0 T. b        }
) n* z1 G4 s( |, b
, ~4 _2 [' @' u2 l% w' h
    }
}
8 L. [' J% Z( _) J  h. ~1
$ e( b/ I- C* x  Z6 C) P2
3
. P! H: H" A7 d, e4
% s+ y7 S6 e0 k: i) j( ]) |5
/ I! w! l+ ]4 ?  Z4 w. O# w6
7
0 T- z9 P/ X, f( \  ~8
9
10
11
12
13
14
15
16
17
18
6 {: @' w0 A' ~  q0 W/ w# ]' ?19
20
1 R% |- `% r5 o  [& q# z21
22
23
( o$ B' i" m4 C24
0 V$ I& U3 T7 m2 e! B2 ~/ Y& C$ r25
26
27
/ ?1 g6 I& `  Q9 r0 J28
6 u5 }1 S. O% X, }+ H6 M+ I29
  ?, X- r% p, u9 w30
1 o. N# ^8 u3 j9 e# t9 I( I8 G' Q31
32
$ q1 w# T" U  G* i  k, Q33
34
6 ~" B3 [3 C7 @35
6 D; G% _8 w( n5 {! W36
1 o6 [) z( ^; J3 Q; i37
- n1 {% B) I  T! L% c$ u$ f38
39
8 u, ~3 X% [5 P+ N  o40
41
42
43
2 d% }/ B# u- p# A+ A+ |. i& i& p44
: ]9 y! q+ l# e8 J! q$ h0 O45
+ W2 y; i! E/ }46
8 |* u& T/ w! z47
48
/ {9 A, v& ?: E- l3 o49
( |+ V: m' Z. M/ X" ~& m50
& y' b4 a% n2 S( \0 c51
52
53
# ~# L5 h7 y6 a+ M% B54
/ e8 d: X7 w( m" v% r) ~55
56
$ {; [- }- L5 n* e& C+ v57
58
59
/ m: x+ ?9 V& c% Y5 G60
61
- [- |, J4 A: `2 R# \! }6 _62
63
64
' ?  ^! y5 H& p* A65
66
67
68
69
  f# q/ o* j% q8 ?/ f9 q70
" L: c, Q9 C! m: o* \" e5 `71
3 X# m/ }' i. R0 z% c72
基数排序
简单解释：
首先说一下，我发现好多人写的基数排序只能排序正整数，其实只要处理下就可以排序含有负数的了，就是我们排序前先把所有的数整体变大（就是减上最小的负数，也就是加了），都变成正数，然后排序好之后，在减下来（加上最小的负数，也就减了）就好了。
$ T2 q' i) M* I! W& L* H基数排序就是按数位排序可分为LSD（从最低位[也就是个位]开始排序）和MSD（从最高位开始排序），下面写的事LSD基数排序。
基数排序就是把数按位考虑，让后我们一位数只能是[0，9]，就是我们在考虑某位（个位、百位· · ·）的时候就只看这个位的数，放到在[0，9]相应的位置，然后顺序取出，最后再按其它位这样操作（上面说了要不从低位开始到高位，要不就是从高位到低位）

# }( R0 @8 f9 C4 O# |# p


7 I' c+ h: k1 Q4 }* }
: ~' y' h7 ]) ~* f) x% _) V
5 X5 k: g9 f! P完整代码：
$ f/ x* ^* s: u

1 k9 Y+ t0 G5 K6 F3 wpackage com.keafmd.Sequence;
6 `* |' ~( @. O- V2 E

! w; l/ S- }8 B8 ]* M/**
* Keafmd
  k) @$ {* a  e6 `3 O *
2 P- x" r/ K2 a- r. {) u * @ClassName: RadixSort
* @Description: 基数排序
$ f# m0 z- b0 d1 X; B- v. B * @author: 牛哄哄的柯南
5 D* x: Q- L% P  n) t * @date: 2021-06-24 14:32
*/
4 H6 J$ C1 U5 w! u7 g, E8 Mpublic class RadixSort {
: p) j5 L4 Q! b1 P" J  U    public static void radixSort(int[] arr){
" n% T1 t5 W% Y' f% E$ u; u        radixSort(arr,true);
$ I4 @1 `+ Y& C: N/ Z& p    }
    public static void radixSort(int[]arr,boolean ascending){
% T% }* Y3 k  ], n2 }9 U        int max = Integer.MIN_VALUE;
        int min = Integer.MAX_VALUE;
5 ]! i0 h" Z: K$ v        //求出最大值、最小值
        for (int i = 0; i < arr.length; i++) {
            max = Math.max(max, arr);
' E/ @# J" ]2 Z/ U' }( x            min = Math.min(min, arr);
" M! b; k, m8 M6 k% u        }
% x9 b6 u! Q  K1 c( P4 v' n1 r' _        if (min<0) {        //如果最小值小于0，那么把每个数都减去最小值，这样可以保证最小的数是0
            for (int i = 0; i < arr.length; i++) {
                arr -= min;
            }
( b4 c3 t9 K# s, M+ o* ?            max -= min; //max也要处理！
        }
* k7 s+ i0 d+ V5 \        //很巧妙求出最大的数有多少位
! |  o9 t" L. ~- U  v' P        int maxLength = (max+"").length();
' _& r  N5 H+ C" s1 m7 q        int[][] bucket = new int[10][arr.length]; //一个二维数组，一维代表0到9，二维存放符合数
        int[] bucketElementCount = new int[10]; // 用于记录0到9某位存在数字的个数
4 w/ R$ |3 K, V% M, B        for (int i = 0 ,n = 1 ; i < maxLength ; i++,n*=10) { //个位 十位 百位 这样遍历
            for (int j = 0; j < arr.length ; j++) {
                int value = arr[j]/n % 10;
                bucket[value][bucketElementCount[value]] = arr[j];
: N4 R. N  S" `+ n1 ~2 ?. z% Y                bucketElementCount[value]++;
            }
' Z! ?! ]4 q4 t" p# }4 S& ]

4 c# h! z* v. z4 h3 T7 s            //升序
            if(ascending) {
5 J" j7 O# V- n* J! \7 z+ C! m! z" q                int index = 0;
" I' Q- n3 G, t+ s+ |% `                //从左到右，从下到上取出每个数
; O: g6 R1 R  E6 a                for (int j = 0; j < bucketElementCount.length; j++) {
9 d5 n( |- K- j1 O* h: w2 V" n/ |* Z                    if (bucketElementCount[j] != 0) {
                        for (int k = 0; k < bucketElementCount[j]; k++) {
6 E2 L* C& i- Y: \$ o                            arr[index] = bucket[j][k];
                            index++;
( n% W- d/ X/ ^7 B                        }
0 i; A7 `# ~' |8 e& V) w                    }
: j' A1 \8 i; D, o                    bucketElementCount[j] = 0;
" U5 ]' ]6 @( ~% n                }
            }else { // 降序
3 p; ?% J8 t& Y' G- E9 B  O                int index=0;
1 N0 z' h2 I& x                //从右到左，从下到上取出每个数
                for (int j = bucketElementCount.length-1; j >=0; j--) {
                    if (bucketElementCount[j] != 0) {
                        for (int k = 0; k <bucketElementCount[j]; k++) {
                            arr[index] = bucket[j][k];
" z' J6 a/ C4 U, `                            index++;
                        }
- E  g& v0 i: h' E" e$ Z                    }
6 Q7 h$ |9 y" h1 k2 b! U2 _6 n# c# _) U                    bucketElementCount[j] = 0;
5 e/ ]' J5 L( ?6 g8 ]# l                }
            }
& _" }7 x  Y8 @8 L  G+ j

; O0 R2 K* Y% i) u3 V0 A6 c3 Y7 d

            /*for (int i1 = 0; i1 < arr.length; i1++) {
                System.out.print(arr[i1]+" ");
8 H1 F: j0 p- f; l            }
            System.out.println();*/



5 @- E9 C$ K- _

, T8 P: I; o/ R2 j7 p
! g, X7 c2 y- ?# c& d' M* ~        }
* b4 B2 A8 C; Z# _( I* k+ @0 ?        if (min<0){
! V' u3 O+ z; i1 k/ q' ?: b$ q            for (int i = 0; i < arr.length ; i++) {
& i4 X1 N+ T$ ~: v1 O! B/ {                arr += min;
            }
        }


    }
}
1
2
3
& }& \( B, I- Z; p2 T# L2 k4
- c' Q/ E3 }5 G( q' Y) T! G. P5
6
& s* B# U/ U+ Z( a* l7 y7
, w5 ^7 K5 _$ O1 ~) V# P( v: |6 W8
9
4 {% u& S3 m3 w1 I9 c- k10
11
12
, R; }5 \# T" |/ ?# G( s/ O13
3 Y4 I$ P  Y, X' \14
7 A& s" J) Y/ _& ~" ^% p( b15
16
17
18
19
/ E1 t4 o5 z: h) c20
; S$ i* |% c( f21
3 W2 {* H) ]" e0 |% P& z! n22
% A8 {  A5 }& T4 |23
4 I1 R9 e; z, o; A9 ^24
25
26
27
9 z6 q& K3 G$ j. y28
29
30
31
32
' I' j6 k$ _4 m6 G33
34
35
36
6 b8 {. v6 ~9 C/ q, v' e37
4 @  B" M4 P, [, f, C& l38
39
40
41
42
43
( N7 x7 x. x  C$ b8 b0 D% O44
45
, K, D" b- C0 q/ f46
/ W% u. p# k8 U: }4 }47
48
) E5 L/ Q7 w% }3 {49
6 O' u& d/ y+ {7 T$ X5 L2 r50
  O$ Z/ K- ]. ~51
# _( P5 p7 M3 t" ^52
53
. }" w. }5 ^7 {1 y5 {54
55
56
7 g# k( T# y# t1 z' P$ P  A57
6 O2 F7 Z! n& B9 [58
$ \' G. s) V$ {; F59
60
. A+ R" @& c4 x* t5 w61
62
" ]8 c. H/ h/ i% X63
64
65
66
67
68
69
70
71
72
$ Z: C5 [3 a9 \( V6 T7 Q; a73
74
8 S: K4 S1 q' C; t: w9 [$ u+ e6 i75
: ]% Y& D% b4 q5 ?76
77
0 C0 G4 \& l, V8 H6 L9 q9 _78
- B; `6 e: a7 g79
80
81
82
83
完整测试类
8 [- R* T/ C6 ]package com.keafmd.Sequence;
. c. e- P. t# h- l
* N7 x5 z1 r; c' T" {  i
import java.util.*;
import java.util.stream.IntStream;
import java.util.stream.Stream;
+ H/ e- Q: K8 E5 P3 j

/**
$ u* ?7 F, [. M/ h% e  \! B$ v* N * Keafmd
7 C2 |# j. x" w" O6 O& T0 @ *
& n; v, [' M: R * @ClassName: Sort
: r) F) v( n. o; o0 L" X' k# _ * @Description: 十大排序算法测试类
( T# h/ V5 c5 M+ e; ?2 l4 B * @author: 牛哄哄的柯南
* @date: 2021-06-16 21:27
3 O' E2 f- x. |$ H: |" a2 ]& h+ I5 ~ */
public class Sort {

+ s' T: ]) `- P3 U4 @. C
- D/ Y" x/ h: J0 }

    public static void main(String[] args) {


( s( I  F: Z' ^" j& w        int[] nums = {12, 4, 25, 47, 58, 34, 25, 9, 99, 26, 1, -13, 162, 10093, -66, -1};
& Q$ W5 w1 m/ k3 m//        int[] nums = {12, 43,56,42,26,11};
        int[] temparr;
0 q5 t/ J) z7 _- Y" J' L

        //利用系统Collections.sort方法进行对比


$ ^9 b8 d. a. I2 a, O0 r        //将int数组转换为Integer数组
        //1、先将int数组转换为数值流
        temparr = nums.clone();
        IntStream stream = Arrays.stream(temparr);
        //2、流中的元素全部装箱，转换为流 ---->int转为Integer
, c$ d6 c% D; _& ?        Stream<Integer> integerStream = stream.boxed();
        //3、将流转换为数组
        Integer[] integers = integerStream.toArray(Integer[]::new);
& G7 M/ J% Z6 I  F$ U6 P, r1 B0 c        //把数组转为List
        List<Integer> tempList = new ArrayList<>(Arrays.asList(integers));
        //使用Collections.sort()排序
; e0 [7 v; R5 }' d( }+ z" g( a        System.out.println("使用系统的Collections.sort()的对比:");

; l/ u( j/ I! W3 [" O
$ J$ c/ A  J/ l% Y$ M8 S) A        //Collections.sort
- M$ C& A" b3 _# _8 U4 \" r; z4 V        Collections.sort(tempList, new Comparator<Integer>() {
            @Override
- C$ @% s9 b# s7 Y! J            public int compare(Integer o1, Integer o2) {
/ V) O9 y. \# u% k: H9 z                return o1-o2;
) w0 G. `: w; r+ P6 m# q  e; P) E                //return o2-o1;
            }
        });
) N1 y! x2 V  o1 _/ t

        //tempList.sort 也可以排序
       /* tempList.sort(new Comparator<Integer>() {
            @Override
& ~! u2 l8 K4 z1 k6 B2 Q, ?3 W* T            public int compare(Integer o1, Integer o2) {
( g% B6 X5 o) P, q1 e6 t0 S; y                //return o1-o2;
  C( Y# D: s7 u! \4 z- K! Y                return o2-o1;
9 v4 e, X. |$ c4 j) G* M            }
        });*/
6 e# u9 }2 k) A. Q
& A& C8 t' R1 ~5 P2 I
! \; Y! u3 x6 @# H# i- ?        //遍历输出结果
        for (Integer integer : tempList) {
# ?( j% [; m5 J            System.out.print(integer+" ");
7 ]3 m& Z5 y; M0 h1 `; J        }
( \+ P- t7 o9 D/ D0 [: ]  w
9 t9 P7 {; h. _3 ~" a$ H
  Z2 M+ e( I8 Z9 q; V' r/ B        System.out.println();
. S; n$ \7 P0 w( ^, B

( E1 _! U, @& w- F2 f5 v        //测试冒泡排序
        System.out.println("测试冒泡排序:");
        temparr = nums.clone();


& F3 n: C/ i  M7 m% ~        BubbleSort.bubbleSort(temparr);

8 L# B  A$ |  `% B( [6 y6 p& {
        //降序
        //BubbleSort.bubbleSort(temparr,false);

, a& V+ N' y- @4 _( v
$ h2 e& m0 g% S; C0 Q& a        for (int i = 0; i < temparr.length; i++) {
            System.out.print(temparr + " ");
        }
        System.out.println();
3 Z, v- z% w- R6 t

        //测试快速排序
; v' W/ Y* E; l$ k        System.out.println("测试快速排序:");
        temparr = nums.clone();
        QuickSort.quickSort(temparr);
        //QuickSort.quickSort(temparr,false);
, f* ]0 @! c' C# A1 R2 N- H        for (int i = 0; i < temparr.length; i++) {
            System.out.print(temparr + " ");
- ^- K* X9 O: b: V$ I5 c3 A2 K* V        }
/ ~6 `( W5 z+ m* w        System.out.println();
* W; W0 {7 m8 o* Z; [, g1 g

        //测试直接选择排序
        System.out.println("测试直接选择排序:");
        temparr = nums.clone();
! w; @0 p! g: J9 k) |        SelectSort.selectSort(temparr);
        //SelectSort.selectSort(temparr,false);
2 r0 M" }3 y6 `/ |1 @" J        for (int i = 0; i < temparr.length; i++) {
            System.out.print(temparr + " ");
        }
9 N* m7 l: R' e( I: ^: x& o        System.out.println();
7 i0 Y  [/ G- ^2 Q1 ~6 y

4 n( H+ P: J" r- G  Y" Q4 j* X        //测试堆排序
        System.out.println("测试堆排序:");
2 y9 ^' X$ Q/ r" B        temparr = nums.clone();
4 A3 P9 \8 G- D3 P4 d2 c        HeapSort.heapSort(temparr);
        //HeapSort.heapSort(temparr,false);
; E/ X& d) h9 m5 J2 x        for (int i = 0; i < temparr.length; i++) {
            System.out.print(temparr + " ");
        }
8 v/ V  H4 H4 I        System.out.println();
' ]; k" y8 K! N5 G- O: I

8 M+ @* I$ s% A  Q' t7 S        //测试归并排序
( ?1 b1 i2 L& p* W9 V        System.out.println("测试归并排序:");
        temparr = nums.clone();
        MergeSort.mergeSort(temparr);
        //MergeSort.mergeSort(temparr,false);
        for (int i = 0; i < temparr.length; i++) {
. y9 `  Q, A+ r            System.out.print(temparr + " ");
% `) C- o$ X# p4 v( t  g: v! s        }
4 E  z. n  b  V6 F) m        System.out.println();


. a7 C7 x; E$ \$ `! A7 Q' a        //测试插入排序
6 z9 Z; ]7 E& p* ?8 v        System.out.println("测试插入排序:");
  f( {; X* W; n4 r        temparr = nums.clone();
% Y3 k7 {+ L# m: ?4 F% Y        StraghtInsertSort.straghtInsertSort(temparr);
5 c4 Q9 X' q6 `        //StraghtInsertSort.straghtInsertSort(temparr,false);
% w3 N" P9 u) B, j  J$ b' O' X        for (int i = 0; i < temparr.length; i++) {
. Z7 E# m- \6 l+ U' F7 `3 c0 }, P, w            System.out.print(temparr + " ");
        }
        System.out.println();
8 y; H' M/ [0 `7 i0 |  t

+ J+ \9 ^# d+ }" ^

        //测试希尔排序
# T2 L. Y' n$ v4 Z/ m9 @+ q; F        System.out.println("测试希尔排序:");
$ N0 s. n1 [& j( T) [; V$ z        temparr = nums.clone();
! t1 x& l9 q: q; T- M% m        ShellSort.shellSort(temparr);
        //ShellSort.shellSort(temparr,false);
' T, L7 Z8 M1 u$ z$ C        for (int i = 0; i < temparr.length; i++) {
( b3 P# Q% f9 k            System.out.print(temparr + " ");
1 J' @: y; V9 [- C/ ]6 ?        }
& l) A) H8 R: g; Q        System.out.println();




        //测试计数排序
5 f, G; l8 f/ ?0 u6 x        System.out.println("测试计数排序:");
( X. w3 C# E0 }. K) {- v        temparr = nums.clone();
        CountSort.countSort(temparr);
        //CountSort.countSort(temparr,false);
( M- m& Q" t' u; V8 ?3 D: m- f        for (int i = 0; i < temparr.length; i++) {
- f% G  E; X0 ]! @3 Q6 F5 X0 ~5 l            System.out.print(temparr + " ");
        }
3 X! n; L0 ~) i: z        System.out.println();
2 @4 c6 l2 e* a' M1 y& i' @7 a

  s; n3 _  q+ `5 C$ B5 Q% u- l

/ f6 O2 \  L, B( {  B        //测试桶排序
        System.out.println("测试桶排序:");
        temparr = nums.clone();
        BucketSort.bucketSort(temparr);
5 l/ Q4 ]: r& p7 v        //BucketSort.bucketSort(temparr,false);
        for (int i = 0; i < temparr.length; i++) {
            System.out.print(temparr + " ");
; l& q+ D/ v3 k; e        }
        System.out.println();


/ n& |" ?  I) A% r- c        //测试基数排序
        System.out.println("测试基数排序:");
0 D, D" ^& R6 M8 w2 h5 G! R        temparr = nums.clone();
: ~9 s6 i9 ]6 K% d2 f8 h        RadixSort.radixSort(temparr);
        //RadixSort.radixSort(temparr,false);
        for (int i = 0; i < temparr.length; i++) {
& E  H' k+ X, A; z0 x. l% F% y            System.out.print(temparr + " ");
, Z8 Z+ a; q3 F' }! r$ i( c        }
        System.out.println();
- r2 \, C3 i0 j7 x1 V3 r/ Y

    }

2 Y+ C0 ]. O" M" L6 T
2 j( ~9 x: y6 J  Y% |}
1
2
4 K/ \9 f* [! n3
# [$ ?+ \: J2 A( I$ }% F3 v4 O4
9 y8 c. `6 _, |6 G# I1 c8 n5
' ?" K6 K! P( H( s5 ~: M& N: u* C6
7
$ V6 q$ l6 ~* B8
/ Q' N' E" D3 a1 W" L9
* h2 b0 k3 H; i) k4 `, t) w10
11
12
; q' ]" F; |1 Y1 A6 c13
8 p/ z/ y* ]: f. t# n+ o2 \& d3 [14
15
16
17
' R8 v5 K5 S9 u: ^8 `18
19
( ^, K8 y/ c/ |( {$ X20
1 U9 o3 x1 C- u# d% r21
22
8 N9 p/ L  W1 ^8 n# Z23
% m1 T( {1 w6 C, _! }% ~24
25
26
  f! N5 t3 @" m  c3 w3 R5 b27
28
29
- l2 u  [4 \. N0 i30
31
32
- T; w# P3 \4 ]/ V( f, U" N33
34
" a. n9 t9 q7 d% f35
+ M  C" n4 m0 F; w) N4 r8 Z; ]9 T36
8 G- D4 G9 p9 j3 Y! u4 ]# M% R) X& V37
38
39
40
41
42
( x5 ^4 n6 E6 L% R! M. n8 e7 v43
44
45
46
+ p0 S" t8 u- F& _$ u( B47
. q: \0 W2 m: V) ^0 ^6 U7 N48
8 P+ U6 L" ~+ U& F: @7 o. |9 z49
50
51
# V! @+ G* v4 ~( e52
* q+ H6 b# a7 b; I) C53
54
; v/ t3 t' A6 G  a55
56
57
58
8 i+ g) i0 k8 |" R; O5 K59
0 N# z4 ~9 S4 c* k0 |2 }# e60
- A5 @% S+ P' x: L8 h61
$ f9 b/ M6 C+ p" z( Z3 U62
63
+ @' S) d* e4 Y) j+ U64
65
8 @" @0 y/ z) Y$ {66
' ?4 c9 e, R" }5 G. I67
% E6 N4 w+ Z1 @5 P# P  j68
69
( `) v; q2 o4 M, S8 R70
; J* j( o; N) h9 ^5 j* _71
72
* g7 r3 _0 y* N6 @' B* e8 z3 i2 k73
74
' t- `$ }) V  _7 W75
76
$ j. A: H8 E0 A+ v: C77
78
79
9 D' i8 u3 @/ }( y+ F$ {" _80
81
1 @3 N+ I- y1 G* `3 I0 M82
% V' c$ [( x) @% @9 T$ K83
7 D2 \$ l8 K" C( e84
85
86
1 I9 B) j0 S) d1 s, c8 F87
! m1 w, o- c. {  F88
89
5 F2 n: V/ Y! [+ l4 Z$ _' [90
91
92
93
94
95
96
3 j. m, }0 x- b7 I97
98
99
100
9 q, c6 {+ U+ o$ y101
4 }7 x+ F% U* o* s1 k" p  _102
103
104
105
8 e; c4 l2 x: a& x( H4 z# w, i106
3 j$ |- G; _1 m* w& U107
108
# K" S; b; B% Z7 i8 N. r109
110
, ^+ G3 K. H% M0 t! T. Z  s6 s3 J( I111
# N8 j  j" g0 I: B  s112
! r. _& x' x6 Y) b& X113
114
115
116
117
118
119
. V7 }/ \% {# J- e120
121
122
123
124
125
* v, F( P, @4 a4 t7 p' g! @4 Q! S126
127
: w- O  ]/ z' ~( W5 W128
/ y  \- p6 b1 W! }4 t8 C" r8 E) ^0 z129
130
131
2 a2 c+ y2 ], F132
133
134
+ C2 `  \: ?  }' f0 W2 m135
136
- g* P. L# Y6 Q137
) r1 G8 P  v( h. p3 G138
139
140
6 c6 O# |# \9 `. b/ s3 ]& Z141
142
8 Q" r/ E! [; v2 @) m143
( `; A1 Y1 x& V. N! U, P144
9 O5 M5 X# b' h  X, n1 C5 z2 `145
2 l4 @1 ^+ b9 I$ D7 m9 w+ a146
: o1 R; P/ N3 T/ L/ N147
148
149
4 f6 H6 E/ {+ p6 X) U150
151
* S) D. n+ U1 U, d% U. Y152
8 P' a0 d  ?& R9 \$ w$ J153
0 d3 k/ d, W+ m/ Q  s154
155
9 b) O* K6 F% N/ Z156
3 W! z0 M: X. k  d157
2 O5 \% g) y9 e$ w: u158
& F2 t6 B& T1 ^; \3 U5 E159
160
161
162
163
164
8 C7 `& X2 I% Y1 v2 `( p& y165
166
167
7 t9 L( C( _0 Y+ H+ x168
' \; Z# E4 N8 t/ }: ?4 y7 j" ?6 X169
170
  U! [/ ?4 G8 i/ Z* D3 D. [5 z" g171
* B7 o/ x; ?. _# h172
$ P2 ^* e8 ?2 w" M8 m. B) Y173
每天进步一点点！
4 R/ i+ K" n) {& i/ I9 j3 C8 M不进则退！
$ i! W( K, S" D+ F9 ]/ o# M/ X9 Y- a
: Y8 p6 K/ n" E7 i  o6 N$ K' l
! P* I/ z- i! F, o2 p版权声明：
1 `7 }2 L* q' @* g+ G1 ^原创博主：牛哄哄的柯南
6 W: q6 j& r# S" B" Z博主原文链接：https://keafmd.blog.csdn.net/
————————————————
$ w- M9 ]" _: x版权声明：本文为CSDN博主「牛哄哄的柯南」的原创文章，遵循CC 4.0 BY-SA版权协议，转载请附上原文出处链接及本声明。
原文链接：https://blog.csdn.net/weixin_43883917/article/details/118193663

/ _9 a0 x* i$ p

1051373629

每天进步一点点！