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

杨利霞

经典十大排序算法（含升序降序，基数排序含负数排序）【Java版完整代码】【建议收藏系列】
经典十大排序算法【Java版完整代码】
写在前面的话
十大排序算法对比
冒泡排序
快速排序
6 G0 x/ t, l1 e0 ~8 y# i直接选择排序
5 U4 X* g# B2 a5 t堆排序
! K3 W$ p: p9 h( s4 E9 _1 D* q归并排序
插入排序
) j% Y( J  c1 c6 B* b. F, o2 K希尔排序
0 J9 p! r  [& E计数排序
桶排序
9 g) h- `3 v: W/ v9 {) V1 ^8 O! [6 i1 w& B基数排序
完整测试类
% S( `5 t0 V+ F+ O写在前面的话
0 f8 I+ m% o; e, m; F, f- ]       虽然已经有很多人总结过这十大排序算法，优秀的文章也不少，但是Java完整版的好像不多，还存在某些文章代码存在错误的情况，同时也为了自己练手，决定把所有的写一遍巩固下，同时也真诚的希望阅读到这篇文章的小伙伴们可以自己去从头敲一遍，不要粘贴复制！希望我的文章对你有所帮助，每天进步一点点！！！
/ O4 L! o9 z' }: g1 j' E
2 y+ z  K; B' ?3 L% w
' b9 R( Z0 T8 t9 }5 D& ~       我用通俗的理解写下对算法的解释，对某个算法的运行过程不是很理解的话或者想看比较官方的解释的话，单独搜索某个算法，看几篇不同的解释，就可以有自己的理解了，这里我主要展示代码以及进行通俗的解释！整起来，再强调一次，一定要自己敲一遍，这样才能理解的更深刻！

% ^; l3 E: J0 P3 {3 U: E" P1 e
: P2 h' [0 ?$ z! J3 _' p5 H十大排序算法对比
5 m8 ]: x* j+ g% W& e
# J* k; c: f" Z2 q( v
6 s# o, H3 q8 @& O/ d5 H" z+ Y: N

" X9 r" y: ?: U4 N& ?- n7 A1 n关于最后一列的稳定性，我稍微解释下，例如对序列：1 2 4 2 6 排序，序列中存在两个2，如果我们把这两个2标记上（让他俩不同），排序之后，前面的2还在前面，那么就称这种排序是稳定的，反之不稳定。
8 z( |) J, m6 V' X* V# Q: C7 j6 y
$ X/ x; @# n9 i0 E) Y
& k3 o, b& R* J; D  ?7 H7 _3 n冒泡排序
, R9 m) B) v# y8 y7 _$ E. |' v简单解释：
( {% [! W- U" O; l3 |* i       原理就如算法名字一样，就像水中的气泡一样，每次我都把最大的或最小的放到最后面，这样总共需要n-1趟即可完成排序，这就是第一层循环，第二次循环就是遍历未被固定的那些数（理解成数组左边的数，因为每层循环都会把最大或最小的数升到最右边固定起来，下次就不遍历这些数了），两层循环遍历结束后，所有的数就排好序了。
9 V1 K4 O* G: _+ e7 F! R       两层循环所以冒泡排序算法的时间复杂度是O(n 2 n^{2}n
2
6 b9 i9 {% v7 j8 ~8 t! ? )，是一个非常高的时间复杂度，我在下面的代码进行了优化，加了一个标志位，如果上一次循环未发生交换，就说明已经是有序的了，就不继续下去了，反之继续进行下一轮。
- p$ p7 Z: L5 T& I

4 m& F, i0 j# B. L


3 A( `. x& ~) B. U
: ^8 i+ F2 ~  s% @& m" g) E$ b本文的图片来源网络，仅用于大家学习，侵权联系删除！（下同）
% t, V1 |% N- s% n8 x) f" W) s

完整代码：

- W% j' X* Q2 Q3 o# z3 N
! J7 E, y# Z1 qpackage com.keafmd.Sequence;
2 B- F) U, l- K+ G8 v1 {

" ^3 N8 K) U. H2 I/**
* Keafmd
*
$ w$ N8 ~& U. R8 \1 P * @ClassName: BubbleSort
0 d0 P& L, _  C) Z8 m1 M * @Description: 冒泡排序
* @author: 牛哄哄的柯南
. r; |1 k& g* b% F, w1 J, H * @date: 2021-06-24 10:31
3 |/ v6 Y) \; e! v$ C1 v */
public class BubbleSort {


- ~/ i' H6 q0 P- T    //冒泡排序
) Y, X, \6 J2 y& ~/ K' U    public static void bubbleSort(int[] arr, boolean ascending) { //exchange标志表示为升序排序还是降序排序
8 h4 x6 K7 W2 p+ g2 y- |' O
6 Q* b/ X% S1 }. r% t1 J
5 G* k! h3 F6 W7 d3 y! c, w        boolean flag = true; //加一个标志位，记录上一次是否发生了交换，如果是，我们则进行下一轮，如果没有，说明已经冒泡好了


  u, p- q6 q9 P6 z8 m        for (int i = 1; i < arr.length && flag; i++) { //控制次数，第几趟排序，只需要n-1趟，有交换时进行，只有flag=false就说明上一次一个元素都没有进行交换

8 J- `& H% w$ q) U# c2 \/ I
            /*System.out.print("第"+i+"次遍历：");
+ \; o" ]! c8 g5 o2 X  }: _4 \' h            for (int i1 : arr) {
                System.out.print(i1+" ");
            }
            System.out.println();*/

, r* _2 z- `& c# w% K! e$ {
) C6 `1 D8 ]/ y! V  f6 p% o            flag = false; //假定未交换

; q& P/ I$ R- n; S$ V
9 u- C4 e8 ^$ j: V6 e; M4 |; I            for (int j = 0; j < arr.length - i; j++) {

7 E  n; ]  d" V# F( j* I
                if (ascending ? arr[j] > arr[j + 1] : arr[j] < arr[j + 1]) { //控制升序还是降序
  ]* B: K5 B  b  ?% A                    int temp = arr[j];
3 L. C0 i7 ?. p4 v. K# |                    arr[j] = arr[j + 1];
) \- C5 h4 D5 f) h; B& @                    arr[j + 1] = temp;
' S7 h2 }- W" j6 L8 n1 o) Q: c                    flag = true;
& ]4 q4 L9 V7 i: V3 ?                }

1 U/ ?) ?  }. H" Y# @3 s. ^
            }
) m: e$ j* e. I        }
    }


    //冒泡排序 -- 默认不传参升序
5 o( ^" w9 B+ T# _( _( q    public static void bubbleSort(int[] arr) {
: {9 x2 }8 m2 @6 _/ r8 M8 D( h, C        bubbleSort(arr, true);
& Q& Z- a8 E% v0 @1 N' o4 v" A    }
}
+ [3 B. H6 m  b1
2
3
. p8 x( I+ A8 ]" @) N# _: X8 b4
5
% M" v+ n% y0 o8 D6
7
9 T# w& |+ |- }9 `' q8
9
+ N4 A! ~! Q, W10
' \. R/ s3 c8 S4 z2 W11
6 j; t  F- r) e  d12
13
14
15
16
' D/ @# k: m7 e( e7 h2 Y17
18
19
20
1 f6 ~! G: e- J" f& a0 n21
5 \* t7 }3 |  M22
2 I0 e' w$ ]* x( {) c23
- F* C2 B; p  ^3 Z! s$ v24
+ ^9 n6 a1 n+ r+ J" z' C$ i; t& D25
26
27
28
29
30
9 E4 b; Z( u% G' N, x, @3 X31
1 \  [8 h4 C0 ^4 n& y# J32
33
34
, T0 ]! ?. J6 @. j5 e) n6 l$ r35
36
37
38
39
. t7 t/ V3 G3 s7 a. {4 v40
) T! ]# p5 ?1 ~# ]# k! t( T41
2 w) y( `8 M7 ~42
43
5 w- ]. K  C* O+ w! ?( M/ W1 J/ P44
45
: b  ~" {$ b0 d测试代码：

- m- T# h1 ~" e& C% k
升序排序（从小到大）
' e& N3 G" e3 q  t

package com.keafmd.Sequence;
2 w9 R3 K& E  O, r% n9 b# H

import java.util.*;
- o' o2 r, Z' A" j* b* Aimport java.util.stream.IntStream;
# K2 y3 @( u+ j" ]) D. \import java.util.stream.Stream;
6 p+ {" B' L9 w9 i

$ X/ s+ ], p5 e. O- H6 b/ s/**
5 X0 o6 e4 Q: |" H- b8 E * Keafmd
1 s9 |# j( n  ]7 R" p *
* @ClassName: Sort
* @Description: 十大排序算法
) w# H- |0 t" z  d+ {% j* `+ z) U * @author: 牛哄哄的柯南
- t2 x; U5 E: x, n * @date: 2021-06-16 21:27
*/
public class Sort {
0 o9 e0 U6 L  w( k; U; K& e/ ?    public static void main(String[] args) {

5 _  j' a- |& _  x6 W
" M; t9 a6 Q: w0 Y        int[] nums = {12, 4, 25, 47, 58, 34, 25, 9, 99, 26, 1, -13, 162, 10093, -66, -1};
0 |$ M( |- e9 }; A8 z        int[] temparr;
: ]" t' I. Z+ t5 S9 @

8 C$ D( s8 p% S% r0 D0 m  @        //测试冒泡排序
        System.out.println("测试冒泡排序:");
* T7 d- B, g2 y; o9 D        temparr = nums.clone();
, v/ O! y0 k# @8 e3 I. W1 A7 ]        BubbleSort.bubbleSort(temparr);
        //逆序排序
# a4 q7 r, U+ M) d        //BubbleSort.bubbleSort(temparr,false);
3 G+ o8 g$ q; W1 ]: _' H, H        for (int i = 0; i < temparr.length; i++) {
4 A; v1 s+ e  G1 s: X            System.out.print(temparr + " ");
        }
0 l( w# r+ r& A7 {. h8 q$ c        System.out.println();

+ w* _+ j2 G8 c0 [- u7 g
6 R0 W0 P0 C3 Q    }
  g+ Q  c* @# S* Y; P; H}
( I7 `( d, A( X: y1
" T( \( P$ Q  k* R5 [$ t) l2
3
4
2 D' ^/ c! X" ~; L1 _5 b5
6
) t6 m& u% I3 J- C7
4 e- a% j' t% l; t3 G) o8
9
10
1 B) E0 n4 @# }2 n11
12
0 F5 M  h* X7 F. c13
7 w# w1 g- N  K3 Z  J14
15
16
9 C) C" g- k' ?. I17
! @' A& s2 p2 B2 a18
7 r) N1 b) l+ [! S7 W  e19
20
7 f/ e! A' t6 Z( }# E21
+ w" r+ e& s8 ?$ m. i* v0 }22
23
/ m' W5 H6 F3 T/ P6 S# ]- a% T24
- f1 ^0 @: m8 Z8 `. O" B- H25
26
27
; M1 ~- U6 w, @) S28
29
30
8 P5 a- g! G( s1 |9 W31
7 A/ K: s% J+ L, L+ }32
& w  @' |) h# c+ R: ~% g8 ]( m33
运行结果：

, H# C: g4 a: i
2 l% L4 X# J' C测试冒泡排序:
-66 -13 -1 1 4 9 12 25 25 26 34 47 58 99 162 10093
1
2
降序排序（从大到小）
' L: ^+ x' T8 {5 ?! S& ^" y
; O3 N' n3 `6 [; h) N) `
//测试冒泡排序
% R0 W2 I+ V8 q. ^8 o" rSystem.out.println("测试冒泡排序:");
temparr = nums.clone();
1 J2 Y. n8 q6 H" d. @BubbleSort.bubbleSort(temparr,false);
1 P  B; D& d  M3 [( B$ Sfor (int i = 0; i < temparr.length; i++) {
    System.out.print(temparr + " ");
. F6 ^- S9 n$ E4 M}
$ [  t% C  z( `3 HSystem.out.println();
1
2
3
" {7 @: k' M& O4 a" _" {8 |2 y. {4
5
& x+ ^2 n+ [: |. S( ]1 U( L" k6
7
8
运行结果：
* a: P- Q* W% |" f; d5 B' H4 I
  y( P! o4 q* o6 k
5 ^/ Z) Y% r1 |1 E" }测试冒泡排序:
3 o3 p' g8 V6 L( X6 m/ P8 H! |10093 162 99 58 47 34 26 25 25 12 9 4 1 -1 -13 -66
1
2
/ X# Z7 p+ e* y- z2 S& P+ i下面几个算法的测试也就是换了下类名和方法名（换成相应的排序算法），如果想降序就在数组后面传个false即可。我就不一一复制了，我在最下面给出含所有算法的测试类，需要的自取即可。
% h  `& z7 B) H% A, }  s! p

$ `1 M4 G% D" P3 b" Z' G/ J# E快速排序
3 d  j" N! U; T/ b: e简单解释：
快速排序就是每次找一个基点（第一个元素），然后两个哨兵，一个从最前面往后走，一个从最后面往前面走，如果后面那个哨兵找到了一个比基点大的数停下来，前面那个哨兵找到比基点大的数停下来，然后交换两个哨兵找到的数，如果找不到最后两个哨兵就会碰到一起就结束，最后交换基点和哨兵相遇的地方的元素，然后就将一个序列分为比基点小的一部分和比基点大的一部分，然后递归左半部分和右半部分，最后的结果就是有序的了。
; v3 P# r7 r% k  k, [$ ?

3 W+ b2 Q* `6 n% Y
, J! B' y. r4 ]8 [- l% P( `9 i
% D& j1 {( o: o* _8 h0 l
! a! i+ h! L1 v3 s  w/ r+ L
完整代码：


package com.keafmd.Sequence;

1 N1 l$ a- O( `& a8 k( A) ^1 m
1 J- t1 h" h6 }  C  L/**
* Keafmd
*
* @ClassName: QuickSort
) K; M$ H1 V  t! m3 G* o/ p1 z8 c * @Description: 快速排序
4 I  I5 I6 p" @2 B8 C  p, Q * @author: 牛哄哄的柯南
* @date: 2021-06-24 10:32
; R: ^* U% ]9 |0 X- @ */
public class QuickSort {
& J- q- k. O8 r" C

    //快速排序
% b) V  K! |/ D; p* s" ]" Z4 |    public static void quickSort(int[] arr) {
        quickSort(arr, true);
# S+ K& a/ E: j* c% n    }

4 U4 X( z. G0 l# @6 J
    public static void quickSort(int[] arr, boolean ascending) {
) f8 S5 D: F$ v3 B( a  G        if (ascending) {
            quickSort(arr, 0, arr.length - 1, true);
' ]3 F2 V# G; P* e& r: _; P2 J        } else {
            quickSort(arr, 0, arr.length - 1, false);
        }
: M: U) |3 H* s' t6 B3 f    }

. V) O5 r7 K2 n# ~5 n0 u$ {
    public static void quickSort(int[] arr, int begin, int end, boolean ascending) {
        if (ascending)
            quickSort(arr, begin, end);
9 I1 A5 U. d2 S        else
1 d- c7 y/ D! g( @8 k4 {            quickSortDescending(arr, begin, end);
5 k2 L" ~) m$ u- H& j9 m9 z1 q9 t    }
; r1 e5 \& w" |4 Z2 o
+ ~  N% v$ }& @
0 h3 a" H2 x3 N" u    //快排序升序 -- 默认
    public static void quickSort(int[] arr, int begin, int end) {
        if (begin > end) { //结束条件
            return;
        }
' s  K+ C8 [3 t; s  A        int base = arr[begin];
        int i = begin, j = end;
        while (i < j) { // 两个哨兵（i左边，j右边）没有相遇
            while (arr[j] >= base && i < j) { //哨兵j没找到比base小的
' m0 D4 T$ Z/ I                j--;
0 M9 J* @: i/ c! r$ Q! y( V/ s            }
            while (arr <= base && i < j) { //哨兵i没找到比base大的
0 Q* K+ L' m1 y' c* [5 F3 ?                i++;
( q+ e7 u' ?. T# l+ s6 y            }
9 |0 s9 R/ f" M, T0 u, D            if (i < j) { //如果满足条件则交换
                int temp = arr;
                arr = arr[j];
; \, Y* z# V4 F4 e5 k  P4 C8 V                arr[j] = temp;
            }
& ]1 B7 e% m, Z' b9 a

        }
% `. X! r4 H# i* R# q        //最后将基准为与i和j相等位置的数字交换
        arr[begin] = arr;
        arr = base;
        quickSort(arr, begin, i - 1); //递归调用左半数组
        quickSort(arr, i + 1, end); //递归调用右半数组

4 |* z" g0 `  ~
    }
: t3 s& F3 K9 `: T6 }. w

* t" h/ A! Z( _0 s    //快排序降序
    public static void quickSortDescending(int[] arr, int begin, int end) {
        if (begin > end) { //结束条件
. p+ W3 X- U  w            return;
        }
4 }! w; h2 B* i3 t        int base = arr[begin];
: M0 f# U4 v. U4 K9 k2 O5 q+ I1 ~        int i = begin, j = end;
( m/ k* M6 ]* f4 Z1 L' p        while (i < j) { // 两个哨兵（i左边，j右边）没有相遇
            while (arr[j] <= base && i < j) { //哨兵j没找到比base大的
                j--;
            }
7 v& [# y& B0 o7 w+ R9 ]2 N1 n0 _# @            while (arr >= base && i < j) { //哨兵i没找到比base小的
                i++;
            }
+ c, G- |- g" @            if (i < j) { //如果满足条件则交换
5 r; ?' X& u. t9 o                int temp = arr;
8 R% j( X; {% d, y: S                arr = arr[j];
, l; D) |; h' `% b  L                arr[j] = temp;
- L( c3 `% l1 J3 o. P, g            }
7 f) W7 N; R! o8 d2 U" v2 ~6 N: [

: W% d9 n1 ?8 x! ?        }
        //最后将基准为与i和j相等位置的数字交换
5 J. k5 l6 C3 l$ v9 v        arr[begin] = arr;
        arr = base;
        quickSortDescending(arr, begin, i - 1); //递归调用左半数组
" J; s( x4 i6 z, D* E" j        quickSortDescending(arr, i + 1, end); //递归调用右半数组

# p" g8 z! B* N) X7 y  |
8 u8 ]; |. f3 m    }
3 W- c, n8 C: ^, f  \# o: d4 z7 D

}
1 h: }8 t" d2 @: b% \9 a+ f0 Q4 v0 K1
# u# L; \1 J- i) X2
$ `7 P5 n$ y% {. ^6 d2 p" p3
( v( N2 D, Y. R! p( o: i4
+ E0 P; [; V3 @  H, O5
6
7
7 ]% i/ G5 a+ K8
- |4 ^  k% Y5 h9
/ G  K8 x, D  ?3 P( J& U. t10
# e0 k5 D5 m$ N  {! V11
12
7 q* Z9 t2 s& R$ ^6 _13
+ |; G; H! W" Z0 h% c& v6 \# s14
15
* P. k3 h7 Z) b! ]1 {% E16
17
18
19
20
21
22
23
8 h. z3 y3 X8 N& R& J% B24
  i3 a6 F# t- y& p6 ]6 E, ?  S& E25
26
27
28
+ A, c4 u& Z# D29
30
) j4 T% \7 U% c. g+ Z31
* ~2 f7 [" p' `9 M' [32
- ]% G; C% Q  H9 ]( z1 {, |( }33
34
4 R1 g$ r3 J# S: S, V% O35
36
( G# y! H* D& ]( y- U3 Q: S- d37
* ~/ u6 L2 G5 s( U2 k/ ^: @38
5 [" k  a- w" g. b3 Y1 M- T39
40
, R/ q% D, L( O  L0 m3 Q41
42
43
1 w2 ?( }/ n. a& n' r) `44
45
46
- s! A$ _! k; F* K' U' S( K: x47
, k! d; r- f% Y48
. ^$ ^- K/ Q% |0 E49
50
6 {3 z# ?& \& H# h% g1 H51
* ?. P, F  p. y( u52
, o% A- ]1 U: J; K  Y$ R+ y53
4 a$ |+ i* k" J9 a# B54
* C4 W7 i, T+ t$ D55
56
4 C, }: \7 B: {5 T( n+ {3 X57
. a1 |* B4 x1 ?. k( H. s: `* }58
59
60
, h2 U1 o& w3 y61
62
- X+ F' P2 P2 A* j1 q' t63
% e$ U  R, R8 h9 }64
65
66
# y9 \4 P+ m0 a9 V0 d; B67
; n4 A' H5 a3 I1 O68
69
70
$ w8 O/ n% Q" R  _) B6 P# @) x) B8 b71
72
73
/ q) T. H9 d" h5 N! r! K5 Z3 e% V0 U74
& x8 o6 Q' y# P; I( p6 _75
7 {7 Y# N2 |2 }; I9 @( B8 J76
% x* q& n4 ~! N) m77
78
79
# B/ ]1 w4 j( h5 s; }80
81
7 w5 X6 h7 _5 l82
2 \. p5 |& }+ f# Q83
* |" _9 h" {: D! S9 m/ p" c' Z( k84
85
86
, q& W* \/ J% f/ s- q* ]3 V87
88
89
+ }" s4 K* b" w; w90
" s( k" b( H1 F91
直接选择排序
0 B; {5 O- O2 B7 }1 v简单解释：
数组分为已排序部分（前面）和待排序序列（后面）
( K1 l0 A( Y4 v1 t3 V. c4 R第一次肯定所有的数都是待排序的
从待排序的序列中找到最大或最小的那个元素，放到前面的已排序部分，然后一直找，不断缩小待排序的范围，直到所有的数都是已排序的了
0 \/ k: P! J+ l- z  l( K
# W$ x8 S% P2 L/ x5 X
/ v, n3 E7 z! {  y; u, \7 N" S2 g" e
) ^# Z6 S/ @" j


% B& K; A+ V0 E4 ~( [" S/ Q完整代码：
5 e* P( _# j! l& B. f

$ `% {  \; y; {: s5 R( r+ Tpackage com.keafmd.Sequence;
, h1 a( d1 W9 m

/**
  u; s- J7 ~& K6 l * Keafmd
*
) v% S. j; ~# H * @ClassName: SelectSort
* @Description: 选择排序
$ d9 c: a3 o3 K * @author: 牛哄哄的柯南
* @date: 2021-06-24 10:33
7 C" e+ E0 a% l+ l9 K  X, ^ */
public class SelectSort {


. V8 P4 c- ~4 V4 z; a' N/ t9 l. j    //直接选择排序
: N& p: g( M$ b7 m) e5 {: P    public static void selectSort(int[] arr, boolean ascending) {
/ W- n; g5 n/ t        for (int i = 0; i < arr.length; i++) {
            int m = i; //最小值或最小值的下标
            for (int j = i + 1; j < arr.length; j++) {
. {! U" ]+ L$ x. h5 b# a                if (ascending ? arr[j] < arr[m] : arr[j] > arr[m]) {
                    m = j; //找到待排序的数中最小或最大的那个数，记录下标
0 e( G9 Y8 X( M* j) F  j                }


6 x' G) h3 q( p3 i: X) R            }
0 r9 b* h' z: Q& W1 `            //交换位置
            int temp = arr;
  S4 k5 k1 l. L& r            arr = arr[m];
            arr[m] = temp;
' d3 U) e3 H7 i" I' B' O0 H  i

        }
    }
( s! o7 u# M+ n* O2 J

    public static void selectSort(int[] arr) {
        selectSort(arr, true);
    }
}
" {; g; s& p1 t" C: Z0 m) T; g4 q1
2
- }- B1 |& n7 _( P3
4
5
6
7
) J7 l& `  s& A1 V; E, C; q7 }8
9
1 X% D% V8 u/ F5 Q- t: @& |10
11
12
1 ]% Y$ i; |+ D# U13
, E1 g  ^" {. I) a, Q6 L0 H# u% W14
15
16
17
18
$ }6 U% [, t/ a, v4 m. S$ S19
20
; j+ X5 F0 ~9 v. _# [21
22
, o3 C; b5 \" v% S; P, L, b$ R23
. z7 I1 R* i/ r! _* k2 ~24
25
26
$ L8 l0 H+ ]/ S" L6 ?4 I27
! e3 k) J, T- H" O8 t2 b28
% p/ q0 x! C' ~, G" h29
% }+ m  n+ B. I/ o5 F' D; z3 z30
; |: p1 ]: s6 s6 o' T: }31
9 Z/ y) I3 N6 S# j- f32
7 y' U5 f( w; u0 w' p" |33
34
堆排序
7 B* g) j+ X0 f+ @先理解下大顶堆和小顶堆，看图
- w6 C9 h' @9 d5 ?5 h) M8 f! A' u大顶堆，双亲结点的值比每一个孩子结点的值都要大。根结点值最大
. X' b0 t: x/ G9 b) R: A小顶堆，双亲结点的值比每一个孩子结点的值都要小。根结点值最小

4 J  m7 i; }+ @* ^8 I
& G- J9 n' H+ ^; i& l

简单解释：
构建好大顶堆或小顶堆结构，这样最上面的就是最大值或最小值，那么我们取出堆顶元素，然后重新构建结构，一直取，一直重新构建，那么最后达到排序的效果了。

& r0 R0 f4 ?* \6 }

2 `1 e  A$ x0 U9 g& s9 o% d+ {5 Q
. ^* R: g% |! d7 V3 Q  H/ k- Z
! ?  Q1 m& p" I. Y
7 h" l+ J" B/ i完整代码：


: E0 B+ i1 J# C6 Cpackage com.keafmd.Sequence;


- z5 F* k# L6 Z7 e$ o/**
* Keafmd
*
% V& X: z2 m+ Z$ p * @ClassName: HeapSort
* L$ h# I) R& u5 P5 Q" y! { * @Description: 堆排序
# T. M1 U! y' M. O * @author: 牛哄哄的柯南
* @date: 2021-06-24 10:34
6 x" j/ C4 J3 w$ U* C% f  H; n */
public class HeapSort {
7 A4 \9 h6 s/ t6 m
& P% A( s+ {* [- E' I
    //堆排序
' Z( ^; L/ l4 J: _    public static void heapSort(int[] arr) {
        //对传入的数组进行建立堆，这里默认建立大顶堆，进行升序排列
        heapSort(arr, true);
    }
) T3 C5 ?* N7 y- q

, U2 t7 i3 m. i4 Z' J9 {) i* Y- U7 O    public static void heapSort(int[] arr, boolean maxheap) {
! b- E  k9 m/ E; J* P0 s

        //1.构建大顶堆
& a/ p: y2 Z  h2 a$ Q        for (int i = arr.length / 2 - 1; i >= 0; i--) {
            //从第一个非叶子结点从下至上，从右至左调整结构
            sift(arr, i, arr.length , maxheap);
        }

, S) M- k' r( }( q
+ E0 y  `9 {! R$ P! b2 I' n        //2.调整堆结构+交换堆顶元素与末尾元素
        for (int j = arr.length - 1; j > 0; j--) {


            //现在的数组第一个就是根结点，最小值所在，进行交换，把它放到最右边
( r% {9 w6 `9 p' n            int temp = arr[j];
            arr[j] = arr[0];
$ h# d1 R  {! N, k! W            arr[0] = temp;


* Z  g6 Z" Z; t- S. G6 k' ~            //重新建立堆
- ?8 O1 P( t9 Z& ~$ H) h            sift(arr, 0, j , maxheap); //重新对堆进行调整
        }
( e$ v4 [9 L$ g" J7 p. ]( x    }

2 V; C9 v3 ]: n3 }  u
/ t. {, N! Y' K' t7 D    //建立堆的方法
    /**
$ A6 r  y9 \0 ?# R3 ^$ ?     * 私有方法，只允许被堆排序调用
     *
     * @param arr     要排序数组
     * @param parent  当前的双亲节点
     * @param len     数组长度
     * @param maxheap 是否建立大顶堆
6 B- e1 S  e0 T7 Z4 v2 K/ k$ M     */
) `" Y1 T2 N6 @. |" V    private static void sift(int[] arr, int parent, int len, boolean maxheap) {
: A. t. c6 J+ W1 l8 m
" ~# S6 r& h# R/ b4 ]5 V3 S
9 M4 u1 K+ f: Y7 w' o  ?        int value = arr[parent]; //先取出当前元素i
9 a8 o/ s# r; e/ b% \4 K
0 k( n8 \/ p3 s% G
  n! P% M$ R# ^6 L. Q        for (int child = 2 * parent + 1; child < len; child = child * 2 + 1) { //从parent结点的左子结点开始，也就是2*parent+1处开始

; d+ F7 U$ S( ?  T5 c$ f9 o
% |" @' B! x  R0 k! r- C. U, J7 ]6 s            if (child+1 < len && (maxheap ? arr[child] < arr[child + 1] : arr[child] > arr[child + 1])) { //如果左子结点小于右子结点，child指向右子结点
' Q1 W& C( Q7 t. W5 ]* `/ d                child++; //右孩子如果比左孩子大，我们就将现在的孩子换到右孩子
& |  Z' R* N  ]/ @            }


- l' i8 F) m2 {4 I6 t+ g, {7 J            //判断是否符合大顶堆的特性， 如果右孩子大于双亲，自然左孩子也大于双亲，符合
. V  e; z. s$ a5 ?# N. z# \1 T; e            //如果子节点大于父节点，将子节点值赋给父节点（不用进行交换)
8 k7 z3 [1 y9 _3 n2 `            if (maxheap ? value < arr[child] : value > arr[child]) {
7 ?; ^) ?% G( L5 i! S8 L2 R                arr[parent]=arr[child];
                parent = child;
            }
            else {//如果不是，说明已经符合我们的要求了。
% z6 z: T8 _  r! K' p" h8 g                break;
" y* M% A6 F! Z# I/ B( e+ e            }
" d! A* Z8 F9 l+ v3 v        }
( L. y& o  u! F        arr[parent] =value; //将value值放到最终的位置

' K3 f7 I8 s1 F6 B) m( U4 t
7 {$ w, k7 W/ o! J
7 J5 i3 n0 L! U6 l# Y
    }
  F) z4 x, t3 u3 u

}
: X2 _7 r( a! q( k! ]) n1
" l  ?6 W. g9 b2
3
4
5
6
7
8
7 m0 Q! b% m: `7 P9
10
11
  H, V- B9 }5 H, ?12
9 u- l/ Z( H+ \: P! M- g6 Y13
14
15
- e# r1 H+ h, l' c16
) u. S- y' B$ r8 I6 T. U! d17
; H5 k, z, J0 y) u* P18
5 E6 y) r& P6 v$ I19
' ]- _1 p' Z! y- j7 e: ?" g20
21
/ S8 [# [9 |" g: x! f( f4 y22
& f9 e* {0 s# Q9 ]  S; N23
24
5 \3 W6 J+ ^! Q25
5 X- v& Z& g" q8 S" R/ S5 K9 p6 |' w26
6 O* X# n7 d9 Q( ?27
$ M0 e( m: ?% F$ q: H28
29
30
0 e+ t! @9 R: g* y/ }6 r; @- P3 M31
; n+ P. R: ^$ s32
# ?* C/ u) G- `+ n$ v1 K3 S33
' ?% ^7 e& @+ y. \7 p: l4 K7 n+ S34
+ h3 e& z, N! K2 m35
. u9 E( z3 c, F9 |# I+ a/ ~36
  S' ?  G  e; g; d: C9 i, g- U37
38
7 {! D& O8 Y" I5 v" w0 e, ?/ _39
40
( h* o2 p8 V' j  C/ s41
$ F- y, Y  l5 }) x! ]% O42
* V, e* k1 x; {" g9 D43
44
45
) Y. E# N) n( z46
, O. j7 x0 ?" F5 z3 R# U47
1 j: z* e: p8 h48
* l: d; d/ n7 ^- \0 ~8 q& j49
50
1 H+ ]* Y9 o# \1 E8 ]3 o& V/ x51
52
$ y: b# H7 S- O5 A0 ^; \; X53
) t' t  v! Y% }0 y: ]' N1 c: N/ A54
55
56
57
1 L/ n" _( X) d58
: N7 w1 R6 n6 |1 c7 p' d% g59
60
6 c5 a' v# V' V7 e  C61
62
63
' g% V, X& q5 O* k64
65
" E, }; S3 ]% d, F66
67
68
69
, l" C& ^# o4 _. c. A* h70
71
72
1 r. Y. ^5 k5 G- d73
74
归并排序
0 Z1 n* @% x: c3 Z& |, _6 X" C' f简单解释：
该算法是采用分治法，把数组不断分割，直至成为单个元素，然后比较再合并（合并的过程就是两部分分别从头开始比较，取出最小或最大元素的放到新的区域内，继续取两部分中最大或最小的元素，直到这两部分合并完，最后所有的都合并完，最后形成完整的有序序列）
3 S  }) }: P8 T

2 }" _  K4 f! a: q' ?. x8 l
) f& a% A6 U6 m. k0 B
5 j, Q  V4 ^2 B! H5 P4 c

8 Q' S6 J" w( g) R- v; v完整代码：
, k3 V4 d2 R6 F$ g- B7 Z" S
- U- [1 ?6 ]& i
- j; p. Y/ v: {9 W. `0 S* X( Tpackage com.keafmd.Sequence;
( [9 E2 ~+ `' Z7 N9 F# [

/**
* Keafmd
*
* @ClassName: MergeSort
* @Description: 归并排序
5 R: o/ E: M0 o. Y! s+ k6 i * @author: 牛哄哄的柯南
/ T* T' \; }: `7 ^9 U2 S3 y: g * @date: 2021-06-24 10:35
*/
public class MergeSort {


' k6 a1 a8 L+ }% e" j    //归并排序
    public static void mergeSort(int []arr ,boolean ascending){
        int[] temp = new int[arr.length]; //在排序前，先建好一个长度等于原数组长度的临时数组，避免递归中频繁开辟空间
        mergeSort(arr,0,arr.length-1,temp,ascending);
* i8 l2 Y5 j6 s/ M1 p    }
0 z3 E( M, T2 n, H$ j    public static void mergeSort(int []arr){
3 C+ ^' ~8 s  y% F! K) r; m        mergeSort(arr,true);
, \* S2 _2 o% U2 X    }


& t+ B9 B8 U- z1 a6 g' K) \    /**
     *
% ^; l. Z1 w9 m, ~- z5 O  ]     * @param arr 传入的数组
     * @param left 当前子数组的起始下标
+ |$ }( ~) h( O! p  n/ D9 J6 c     * @param right 当前子数组的结束下标
     * @param temp 拷贝暂存数组
     */
' @4 r/ [  \7 R/ e0 o) H* Z    public static void mergeSort(int []arr,int left,int right,int[] temp,boolean ascending){
/ V  B: K! V1 s        if(left<right){ //这里是递归结束的条件，我们是对半分，那当left==right的时候肯定大家都是只有一个元素了。


            //对半分，比如总长度是10，left=0，right=9，mid=4确实是中间分了，0~4，5~9
* o$ N2 e4 g8 x5 @' m% C            //当长度9，left=0，right=8，mid=4，0~4，5~8
            int mid = left + (right-left)/2; // 防止越界的写法
4 U. [8 e: }4 w, b, y            //int mid = (left+right)/2;


" f% S7 |5 Z  w; k" L            mergeSort(arr,left,mid,temp,ascending); //左边归并排序，使得左子序列有序
            mergeSort(arr,mid+1,right,temp,ascending); //右边归并排序，使得右子序列有序

- G8 ]$ D3 Z& O& z: h
2 l1 p) g: N9 P" r            merge(arr,left,mid,right,temp,ascending); //将两个有序子数组合并操作
: _3 v4 x6 S; Z: |        }
    }
* @6 o, p6 [7 C! m

; I! I1 x9 p' N& R1 s    private static void merge(int[] arr,int left,int mid,int right,int[] temp,boolean ascending){
        int i = left; //左序列起始下标
! \) T- x" {  G. _5 J, N$ X/ L        int j = mid+1; //右序列起始下标
7 w8 w5 y( X/ ^        int t = 0; //临时数组指针
        while(i<=mid&&j<=right){
            if(ascending?arr<arr[j]:arr>arr[j]){ //比较两个序列第一个元素谁小，谁小先拷贝谁到temp，然后对应子序列下标加1
                temp[t++] = arr[i++];
% ^. k; k8 L$ l2 X            }else {
7 u6 p& d1 V8 v                temp[t++] = arr[j++];
* s+ z6 x0 w' Q3 N- k/ M4 J- Q5 N3 d            }
        }
# w5 R* E: i: u3 v3 x* @! Y
, {% n) k0 I/ q& W" r+ `: a
        while(i<=mid){ //将左边剩余元素填充进temp中——左序列有一些数总是比右边的大的数
            temp[t++] = arr[i++];
        }

* R1 S2 R" `+ w1 a0 ^6 c% |
. y& C+ T' R+ f        while(j<=right){ //将右序列剩余元素填充进temp中——右序列有一些数总是比左边的大的数
! [1 S5 ~5 H. g4 ?            temp[t++] = arr[j++];
        }

' B8 T+ x- w3 [* M6 h
) q4 B% K/ p& K) Z! {4 w        t = 0;


9 I, z$ n6 U, H, ?2 T$ E        //将temp中的元素全部拷贝到原数组中
! `: u; e$ c  a4 M        while(left<=right){
/ u( f( Z6 E& v* e2 V( W3 U* v6 s            arr[left++] = temp[t++];
! z  \( u8 y5 L, j        }
+ R$ j3 p& [) R' [
8 N0 i* m/ L* d' V* q% K4 [! H9 l
1 j4 K% s+ m" u2 Y% ^    }


8 n3 i6 y3 G  v5 {}
) j( K/ \0 t$ b1 q/ G1
3 S, u' v3 G. t# ?4 W2
3
4
5
6
7
9 l+ u- f1 ~3 Q( m8
5 [3 |; w# t, r- o  Q/ l% L* R9
; h5 g- S8 L% y; Z2 N) p10
5 z! y1 M1 O7 Q5 p, M11
12
' i+ z. p" T# Z13
6 Z6 z) F# p3 ?( I" D' w  [9 T) h14
4 O; Q# A* x" `! j6 f$ K& w15
16
17
18
19
" w3 j8 f" G% I- T$ L( h20
( B$ [8 @" \3 _21
/ H4 m- |1 r& T# g% h8 g+ x  o22
23
24
. _3 i: C2 N* ]3 d! |# s25
26
! k% @& C& D! B' v! R27
28
0 D2 h' n0 O- l) E* K) c  g29
30
0 B) c5 T+ T5 _$ y31
32
3 G2 K1 ~2 g" v33
34
35
36
& n4 }2 T: A3 S4 d$ E. H37
7 [; H0 C. Y+ c38
39
40
41
& x4 q% A. b! g1 a42
& u" Q  o, t- F1 A43
44
45
46
47
4 o: q( b# A$ H! z0 v3 D! `) ~48
8 w% ~' ?% f* e49
/ d7 ^3 A) y, j& ?/ z$ [50
, N/ H8 l7 E8 X, a51
52
2 `1 B0 v' h+ Y53
3 I! B) V. A3 }- h7 p3 {; ?54
" _0 A: k8 O( g: ^5 a55
1 y' n+ o" }5 {/ [2 I56
; V' Z1 y& }4 V- s, e57
58
59
60
61
( m7 i% O7 D0 x0 b) F62
9 b! X# H7 Z& r3 n63
64
# u9 @( n5 J  J) X0 o: @65
66
$ T) ]0 v6 w* g/ e3 C67
( S$ [  Y4 I$ y' v' X4 q; x: h68
69
$ t- m2 n  p$ ^2 e$ j' O) Z/ X70
71
72
73
7 R- u* X/ P6 k* P7 b" I6 c插入排序
) d/ T, [9 X: b( d: \+ |简单解释：
, R3 b  ^5 k8 S- Y  U0 g4 p. t最简单的理解就是打地主时我们拿到牌后的整理过程，从第二个牌（假设我们拿起来这个牌开始比较）开始，（说下升序）从后往前比较如果比前面的那个牌小，就把牌往后移动，直到找到一个合适的位置（这个位置的前面的那个牌不比这个要放下的牌大）就把这个牌放到这个位置，慢慢的前面的部分变得有序，直至全部有序即可。
! V# v& l% j% v/ Z

& m1 q/ g0 L5 N! x
5 |; _# b1 p, R


7 h) c' q& C' {! D% I' ~完整代码：
: {' C+ j5 C$ |$ I- O* Q  M
, p. u) \1 a  P; G$ J, {' Y, U
+ L& [. l  w1 ^" a4 Z: ^9 ]* xpackage com.keafmd.Sequence;
) N3 s3 i1 E$ O. n( I2 ?% [& r

/**
3 M7 t9 X3 }" U+ ?/ \$ y7 f/ q7 D * Keafmd
*
* @ClassName: StraghtInsertSort
. Y* J! x# f+ B5 O) q * @Description: 插入排序
* @author: 牛哄哄的柯南
* @date: 2021-06-24 10:36
*/
public class StraghtInsertSort {
    //插入排序
    public static void straghtInsertSort(int[] arr) {
        straghtInsertSort(arr, true);//默认进行升序
    }
6 M. g9 r, f) P1 j
4 r: u- g6 q8 F: i
  P/ P/ e: ^2 S7 j# H# J3 ~. g$ F    public static void straghtInsertSort(int[] arr, boolean ascending) {


        for (int i = 1; i < arr.length; i++) {
            int temp = arr;
            int j=0; //这就是那个合适的位置
            for (j = i - 1; j >= 0 && (ascending ? temp < arr[j] : temp > arr[j]); j--) {
                arr[j + 1] = arr[j];
            }
7 b6 d) _1 ~, }: A            //把牌放下，为啥是j+1，
            //是因为上面的循环遍历到不符合情况的时候 j是合适的位置的前面的那个数的位置
            //有点拗口，但是就是这个意思，看图方便理解下
            arr[j + 1] = temp;
. Z, q" u4 F. \) o7 \% f, ]
5 t- Z: b0 d1 X! L8 Q

7 D( n( `! x- J  }$ T" r4 }, S- d
$ R( E/ R+ U7 y1 N5 Q0 m6 W        }
' U( _* D# Q( P

1 r) _& {6 S+ }4 j0 |. J. G    }
/ @" D4 |# h6 V0 b. K8 `}
  `# d$ }) T  n# W+ O1
2
3
. ~! _* U+ l4 G9 Y. I7 F4
- ?  @7 T  z2 c$ x) D5
& Z* F5 u. Q: L" f0 {3 x6
0 W8 x6 w7 ]0 z7
8
9
10
# Y- a/ X4 Y! z5 l11
12
13
14
15
16
17
18
19
0 @3 }+ J1 @4 }* x; [4 u- Q20
21
22
23
* M  C7 {- b% B. P' C. z24
25
26
7 `+ R  c1 E) Z3 v( z* o# F27
28
0 T6 C* J2 i9 i9 N& u# G  l29
( g; z' O6 d( C7 N* a1 A8 V30
31
32
, f. O2 K% j3 Y: K9 V+ V33
: c) l+ Z; ^- K" u; L- {' `34
+ \1 Z9 c$ e" u2 k; [+ W希尔排序
简单解释：
7 C) U  k  B4 P3 L0 q0 \希尔排序是插入排序的改进版，我们理解一个叫做下标差的的东西，也就是下面那个图中的增量d，初始下标差为arr.length/2，然后继续/2，对在同一下标差（相当于把这几个数单独拿出来了）的若干个数进行插入排序即可。


3 c! s; N& `& Z+ Z9 ?

& ]4 r5 ?4 _7 s" V
* I+ S. q1 j9 ~8 ^: L
- L" Q* V( }: ?8 y; f1 U# B完整代码：


package com.keafmd.Sequence;
/ S5 [& x$ ^* p0 \2 h( r4 ~

! @# m9 [- |* S/**
* Keafmd
( P& V. G' ~- h2 _0 w# w( M7 w *
  I# ?9 ]) R* Z5 Y2 r' x- X * @ClassName: ShellSort
9 X0 ?! t: d) Y  f7 |  P; q * @Description: 希尔排序
* @author: 牛哄哄的柯南
* @date: 2021-06-24 10:39
; _' ^" S4 e, e7 U" X */
% x* b# X$ Y. X4 ?public class ShellSort {


    public static void shellSort(int[] arr) {
7 s% Z* z7 M6 m1 b/ H! o( C        shellSort(arr,true);
    }
+ e( g5 [+ A8 x1 z$ D
1 _2 H" t1 n$ p3 }1 Z! L) _6 [
    public static void shellSort(int[] arr,boolean ascending) {

) |8 L* _4 Z+ F' P2 H
" P0 d, \( ~. d' `" o7 {4 s        for(int d = arr.length/2;d>0;d/=2){

9 \3 r" L$ I- b' v
            for(int i=d;i< arr.length;i++){
  z  r6 d! g" F, i* D8 D+ L                int temp = arr;
                int j=0;
; I9 e6 w( ?# K5 _                for(j=i-d;j>=0&&(ascending?temp<arr[j]:temp>arr[j]);j-=d){
                    arr[j+d]=arr[j];
" h: A# G' j& {2 k                }
                arr[j+d] = temp;
            }
- I+ W9 M8 J' Y        }


    }
: B+ S- f: G  ]2 L& f( q% ~5 x! w}
1
# j7 g" U8 T$ m% P7 S2
3
4
& J0 q' X: _) R5
0 B' L) B! S  O6
/ H& }5 v" n& N6 [7
8
: l7 G3 Z4 ~/ n0 E' g8 q# K: u) l9
8 W8 k3 k; ~' x6 d' \$ C1 R10
* n& H' y7 _2 P+ Y11
12
! y4 m% G  V3 K  S  j13
14
/ N* t* u) p# w. l( T15
16
3 y- m" N1 i. j, l1 e+ {17
2 b, _) |* |0 z# ~& N% h18
19
6 v2 [8 @0 w8 |+ I3 L20
5 g3 j8 \' d8 U, }% ?( i; V21
22
# t2 Z' L% w7 ~5 [+ F8 k3 X23
24
25
26
27
  Y3 N5 i6 m( u! }) x28
29
" U$ L6 _6 f9 C( v30
3 p% W: W, _* v/ n31
32
计数排序
$ q& T1 q2 W$ o9 ~; y9 P简单解释：
这个排序算法看名字也很好理解，就是就是额外找个数组来计数，然后在这个数组从小到大或从大到小把数取出来即可。

  L$ U3 @+ `  t7 ~( z  \1 q



& k$ v+ J1 X8 ?/ Z1 p
完整代码：
/ X4 P2 a( B# [$ A& O5 }

- Z& @. T9 l! N0 H9 \' wpackage com.keafmd.Sequence;
$ J& x9 \( }* q/ G
; s9 J& d6 u9 n4 [! S) [8 M( A1 X
, I- n; N% L; k7 E8 p/**
: h# G! A3 t/ d * Keafmd
9 R/ R% H" T0 J *
4 y$ D: z, X& R1 |4 q9 o * @ClassName: CountSort
* @Description: 计数排序
* @author: 牛哄哄的柯南
1 w( v% w. S( K9 Z * @date: 2021-06-24 11:31
' X0 _( Z2 }) G# u7 ^! A */
" j+ f& c1 W) @, Kpublic class CountSort {
. T3 g) X/ P+ Z/ d1 S
' U, {. |/ B2 i, r+ x7 F2 H" O
' ]: h! {0 |, J9 A- n2 B0 H    public static void countSort(int[]arr){
        countSort(arr,true);
    }
* u( j4 @/ h) Q6 X- q: E
/ ]# C  ^& o& l0 [; E$ {$ q0 E
! Z4 g" F$ o! G* @* I    public static void countSort(int[]arr,boolean ascending){
        int d,min=arr[0],max=arr[0];
# o; i: W, E! d7 C+ |" h1 ~7 R
8 G4 E% i( z4 g5 M$ c( h' S0 W
        //找出最大、最小值
7 Y) K9 r5 i+ n6 k6 r        for(int i=0;i< arr.length;i++){
$ B  Y/ O; j5 `5 u3 F9 @  O            if(arr<min){
                min =arr;
            }
* U* R- `0 W3 H' C# S6 @9 A, y) k            if(arr>max){
- Q+ j' y8 g% z+ x& o- k                max = arr;
3 h. L! ?: o. `! P& d            }
        }


7 u1 C2 u7 R6 Z8 L1 F/ m        //建立一个用于计数的数组
        d = min;
        int[] count_map = new int[max-min+1];
        for(int i=0;i< arr.length;i++){
6 n, J' W0 v) Q9 f6 v            count_map[arr-d]++;
8 D( b/ [8 B6 z( w$ ]3 H) J5 _        }


# x/ F" A5 V; a+ }; E        int k =0;
! E1 I  ?( Y3 l8 v% I        if(ascending){
            for(int i=0;i< arr.length;){
/ M& B4 T3 k6 O) x; q8 x5 H& B                if(count_map[k]>0){
                    arr = k+d;
: ]! e$ R3 }8 `' }                    i++;
+ U2 W9 N" u/ @8 {: e                    count_map[k]--;
                }else
                    k++;
            }
        }else {
3 C) q0 f9 `# {9 s% m            for(int i=arr.length-1;i>=0;){
0 T6 ]4 w3 h4 H# F& [                if(count_map[k]>0){
. z! I  O. M& u3 D                    arr = k+d;
( R/ g, D2 w" i/ Q                    i--;
" z: z; n; N. O6 a$ g, F6 K5 j                    count_map[k]--;
( y( ^, u9 J' \0 N9 u                }else
4 D7 d# r( K+ S                    k++;
            }
9 k, u& a2 w/ f! Z. b        }

4 x1 {: T/ |1 ]& j! B# u+ v9 X
, e5 a2 G5 Y- |; [    }
- K) y9 I, e# Q- J}
* v7 H) I+ _9 D7 U5 q0 @: f1
; O8 B0 M7 ~/ `/ u9 t; |! m2
3
4
5
" Z4 d; W& v7 {9 a6
7
8
3 ~  r; ~) C9 L, K  z! U9
7 A& ?2 t: F8 z' a10
* z" A! [* ]( h7 E0 p/ ^  A11
12
$ a3 B, J. h3 D* e/ K13
  s4 m3 X/ g5 D  g. P14
15
16
) v- Y5 X$ N$ r17
18
19
20
21
22
# v/ s  m2 z9 ^# A23
24
. A' c3 E" h9 }6 j# [6 H, ?5 K25
26
1 W) w. U) K# n27
7 \2 u5 U% l7 A8 P3 v$ O28
29
; K5 g8 b) \+ L$ @, W) k- m( ]30
* e" P- p. Q! U! x. w31
. B: C* c, e8 ]32
2 q  E7 N3 T9 L5 H7 C) Z33
' b' c$ c" k' l1 [- }) e, d34
# d8 }; S5 T$ h% _% `" \35
36
37
  }; O$ j" i# ~38
39
40
41
42
43
" Y! F' S% |9 a0 {! u44
- }: y9 q( O- z45
$ u. ^3 j+ X. k4 H46
47
48
49
50
2 @9 W; o0 r: H$ i3 q: p- d51
, x) s1 c. o4 ~* l4 }# b52
7 b8 }; A" _, z3 t4 f53
4 E# R% Q' y4 `0 b: {54
55
3 r# B& u$ Q7 ]$ f56
. V% g& |( g0 A- e. [' y2 p57
; ~5 h8 A4 Q- |6 h: [& t% ~58
& A. }) ~$ j$ O2 A( r59
桶排序
简单解释：
5 K, t+ ^8 H. a  [0 r1 [  u- m' a就是把一个数组分成几个桶（其实是几个区间，从小到大或从大到小的几个区间）装，然后让每个桶（区间）有序，然后取出来放一起就可以了，相当于把几个有序的段拿出来放一起，自然还是有序的，当然需要是按照区间的顺序拿了。
/ ?/ l. m9 U7 k
& `8 ]9 h# v2 h

4 A  n  ^8 D' @, y, g1 R% a
! X! E/ T' Q- h
5 y+ Q0 m: r6 v
+ `7 K  P- Z: o+ l; E$ k3 \, R1 }完整代码：
/ e8 Y$ L9 b7 }- y9 i8 P

package com.keafmd.Sequence;

+ t+ g" k/ o3 C5 o0 L
2 Z1 ?$ X: I9 p1 b- `3 K+ Eimport java.util.ArrayList;
9 |2 [3 A6 u5 _- o8 iimport java.util.Collections;


/**
" G8 h/ Q: ?7 S& V4 V6 l * Keafmd
: q/ L) e, t5 l* j *
9 t9 N2 e1 ]2 G8 X# C2 Q * @ClassName: BucketSort
* @Description: 桶排序
+ I7 q7 H8 m" P& F * @author: 牛哄哄的柯南
1 D2 y: C8 b- y  X0 _4 n * @date: 2021-06-24 13:32
*/
, |# x- N* O! v' S# m5 Upublic class BucketSort {
. r: J5 P& y+ d6 c  n
' {. g' z- h: L, [) i
! q, \: I4 \0 j$ h( _    public static void bucketSort(int[] arr){
, p4 D/ v; b) K4 ?, A        bucketSort(arr,true);
/ v% Q2 }0 t! m. Q# y; z1 z% c8 e7 x    }

3 J- ?  y$ _0 a$ s% G; \
    public static void bucketSort(int[] arr,boolean ascending){
        if(arr==null||arr.length==0){
            return;
        }
        //计算最大值与最小值
" Q( l' f0 k- {; ~4 R& n; w" N        int max = Integer.MIN_VALUE;
% x' v9 N( k0 }3 b9 y        int min = Integer.MAX_VALUE;
% m& {. i" @' l1 J8 L" C6 ?6 C" \        for(int i=0;i<arr.length;i++){
$ V# t! C  K9 k6 _( P            max = Math.max(arr,max);
            min = Math.min(arr,min);
; D9 ^6 s$ k: ?9 k        }
+ x2 m; r8 l  T; k

9 w# z4 P1 R+ `- m0 |        //计算桶的数量
8 Q) Q0 u& w/ k6 L1 d$ k* \        int bucketNUm = (max-min)/ arr.length+1;
        ArrayList<ArrayList<Integer>> bucketArr = new ArrayList<>(bucketNUm);
        for(int i=0;i<bucketNUm;i++){
. {/ H/ H7 r! Y: w5 S" n7 D            bucketArr.add(new ArrayList<>());
; ~* `) A7 Y8 k, T: m        }


        //将每个元素放入桶中
        for(int i=0;i<arr.length;i++){
            int num = (arr-min)/ (arr.length);
            bucketArr.get(num).add(arr);
. K& x) x% Z2 j; W! H& G+ n# x        }
- n3 P- r# M& L$ t5 l! o" i
  V- h  D2 ~8 S% r
1 _! B- o9 R4 ~        //对每个桶进行排序
! t; h( ?* z" L' Y6 _. m        for (int i = 0; i < bucketArr.size(); i++) {
            //用系统的排序，速度肯定没话说
7 `! {* J( s8 f6 [8 c8 U7 G            Collections.sort(bucketArr.get(i));
        }
2 q/ U' w# ?$ P3 Q! y; |& d

8 W" Q( g) v5 H9 |4 y        //将桶中元素赋值到原序列
        int index;
, K* x+ n% d0 t5 Z1 j# H        if(ascending){
            index=0;
: R2 R: o$ B0 E/ v3 L& s        }else{
            index=arr.length-1;
        }


        for(int i=0;i<bucketArr.size();i++){
            for(int j= 0;j<bucketArr.get(i).size();j++){
6 A  W2 {. S5 v4 k$ ]+ y4 s- f- D                arr[index] = bucketArr.get(i).get(j);
                if(ascending){
                    index++;
1 I& r0 {# g  G* f% U8 a                }else{
) Q6 N5 S* d( T5 o! _                    index--;
! {4 M; n9 o  y  K5 _; e                }
            }


, C7 V- d/ n2 F4 B1 M% X        }


! E+ M$ ^" O2 g0 a8 ~1 K; f    }
5 V- Q/ J4 c. ]0 y}
* C1 A4 m! |2 a: c+ [1
2
2 f3 o4 k/ W( W5 G) S6 E3
4
5
6
7
8 \: K7 T4 p( J1 p7 p# H8
9 d" |: h& N6 v% n. b3 N9 }* U9
: ?+ o7 q. o( k10
11
( i, @! u- }5 `/ `2 v12
13
14
2 R/ @+ u/ ~  B8 b15
7 l- ]- C. M! V3 R( K16
17
18
19
, y" l4 g) N* z* |( R- p% S* b# {20
21
22
23
) k* s2 I% X+ Y( M& e24
25
26
27
, ^4 `/ d+ J" C# O% ]& J! k28
29
) ^4 Z; t  e0 d' x8 P: d/ b& F; O& h30
- n; |: q/ S4 H1 ]% [31
32
  K7 m* u$ |  W% A' p33
5 w: l  u3 [6 S' N& y& }7 N0 t34
* B% `2 ~! I& k$ k4 |% v$ D7 b35
36
37
" o5 N0 L1 Q& f" o! X38
39
3 Y/ i7 P" V6 Q. ]40
& k) L+ Z6 g( V41
42
43
44
+ b& k. f7 Z- C# H2 f# H' \1 ?45
7 y) j+ I3 S. V: E, @46
( @4 T. e0 B% B3 `47
48
/ S" |9 M% b1 E, C* d# B" Y49
" B" F  T: O1 v50
) }  x' V- P* ?+ ^( ~9 ?4 |51
52
) q+ ^4 v, w& B: m& i$ o8 Z53
( s6 e% g! e- T! N7 `54
55
' Q& S. u# e! a56
57
8 S0 I. g+ ]5 _' I; ]: O5 D58
3 i# ~$ n8 B3 j8 R- A( M59
8 G- j  m- n' d4 `60
61
6 A/ D& r1 \: ]3 H62
. o4 M1 y9 }" J4 O  q3 J* T( b63
) _$ D  s" @6 [. y# c( b64
65
- N4 j3 [  [; H( B: y" m7 a66
67
1 q3 w: t. @2 @6 `  d. ?68
) H" l8 J4 z9 J$ {69
( G/ {1 D# Z" |: x( j70
4 O$ }* |" o2 J( B5 r% A3 \71
72
基数排序
7 T# l! R. @* T6 H& }2 ~简单解释：
首先说一下，我发现好多人写的基数排序只能排序正整数，其实只要处理下就可以排序含有负数的了，就是我们排序前先把所有的数整体变大（就是减上最小的负数，也就是加了），都变成正数，然后排序好之后，在减下来（加上最小的负数，也就减了）就好了。
  R5 y9 z! q, F基数排序就是按数位排序可分为LSD（从最低位[也就是个位]开始排序）和MSD（从最高位开始排序），下面写的事LSD基数排序。
基数排序就是把数按位考虑，让后我们一位数只能是[0，9]，就是我们在考虑某位（个位、百位· · ·）的时候就只看这个位的数，放到在[0，9]相应的位置，然后顺序取出，最后再按其它位这样操作（上面说了要不从低位开始到高位，要不就是从高位到低位）
* c. f4 W( R  N& ]
, \# d: T7 y' G8 Z

- E0 U# R1 `- M, m  c( n
% s7 M/ e; C$ p9 L$ N, e4 v% c

8 F2 y4 J- R0 `- C完整代码：
: b, B6 ^) a* j! }2 U  u
# p, s* n  f; V
package com.keafmd.Sequence;
0 d, s4 r% ~" n1 }/ i
( D- B& y9 P; r" S  s# ], L0 G
% r, V& B6 [0 t- X4 _/**
* Keafmd
*
* @ClassName: RadixSort
* @Description: 基数排序
* @author: 牛哄哄的柯南
# N- S) M/ r% _" j! G" Z5 a) c9 j * @date: 2021-06-24 14:32
*/
public class RadixSort {
    public static void radixSort(int[] arr){
        radixSort(arr,true);
    }
    public static void radixSort(int[]arr,boolean ascending){
        int max = Integer.MIN_VALUE;
        int min = Integer.MAX_VALUE;
        //求出最大值、最小值
2 @5 T2 k# h  Z: o/ z) s        for (int i = 0; i < arr.length; i++) {
; \! y* F! u% s4 _2 R. i3 p  [            max = Math.max(max, arr);
            min = Math.min(min, arr);
' T2 U% m; g  e1 [. ?        }
        if (min<0) {        //如果最小值小于0，那么把每个数都减去最小值，这样可以保证最小的数是0
            for (int i = 0; i < arr.length; i++) {
                arr -= min;
            }
3 C+ Y( t' Q' P1 S            max -= min; //max也要处理！
        }
        //很巧妙求出最大的数有多少位
        int maxLength = (max+"").length();
        int[][] bucket = new int[10][arr.length]; //一个二维数组，一维代表0到9，二维存放符合数
' ^+ N. y1 M0 i, P5 H2 y& Z        int[] bucketElementCount = new int[10]; // 用于记录0到9某位存在数字的个数
        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;
9 b1 h* j0 F- [/ ]8 m' r                bucket[value][bucketElementCount[value]] = arr[j];
                bucketElementCount[value]++;
            }

' c2 h+ \4 d9 L" C& G) K8 S
/ h1 d8 i3 K% k. C            //升序
  i) g- P. ^( q2 u" e7 L            if(ascending) {
                int index = 0;
                //从左到右，从下到上取出每个数
                for (int j = 0; j < bucketElementCount.length; j++) {
                    if (bucketElementCount[j] != 0) {
. z1 |6 j9 ?, e- ?2 U                        for (int k = 0; k < bucketElementCount[j]; k++) {
; i0 \0 E4 c2 W' L                            arr[index] = bucket[j][k];
                            index++;
8 e! Z: f- b4 x0 S, _                        }
7 W8 N9 H2 A& Z& J- N1 e                    }
$ v# @$ o( I' Z$ Q- L4 d                    bucketElementCount[j] = 0;
+ M1 ~! G+ n! X! B" T$ w                }
            }else { // 降序
                int index=0;
                //从右到左，从下到上取出每个数
                for (int j = bucketElementCount.length-1; j >=0; j--) {
                    if (bucketElementCount[j] != 0) {
% M3 z/ d% E. O; x- F1 ]' Z                        for (int k = 0; k <bucketElementCount[j]; k++) {
                            arr[index] = bucket[j][k];
& c7 A. F7 [: I6 U4 y( J1 G4 r                            index++;
                        }
                    }
' Q& i" Q5 ]3 d% i- G                    bucketElementCount[j] = 0;
                }
2 I9 O/ a6 z0 d; ]+ ]            }


; ~! y0 S* k2 w! s6 b
3 {+ t; r" W8 u7 d* P7 |
            /*for (int i1 = 0; i1 < arr.length; i1++) {
5 g2 D5 N/ \6 u: H- V9 H5 v                System.out.print(arr[i1]+" ");
4 H6 ?5 _8 \: }+ C4 Q0 o            }
) |4 U" ?" {6 X0 d  R2 U            System.out.println();*/






7 c+ P, \# m, ]        }
        if (min<0){
            for (int i = 0; i < arr.length ; i++) {
1 H3 b$ B! E% j, ^# Z5 s9 i% W                arr += min;
            }
" E+ ^% `9 B6 J/ O5 Q: [, _        }
% z" g) m1 b- ?* _

' J! ^1 q5 d: ?+ ^3 e  @    }
, J5 x( N4 J; A& T}
  Z/ q) a7 t6 A9 ~+ u5 t& V8 P+ u1
2
3
9 V$ ?  z0 U2 t9 G4
5
: o1 r  m3 a5 r( d+ |6
7
1 N3 a8 G! w1 }& C8 ^8
9
10
$ j. \5 T* K# z+ s11
1 D! P- m1 m" Q+ f/ G' m12
13
  z; a( ~+ l- Y1 @; C& |" ^14
' C+ \% j& \' U: O2 N5 G9 \" X6 i; m, \1 q15
6 H/ ^" A# r3 O  ]" A( C16
' T3 |( y2 S. t, |% G6 \17
18
19
. l  a, E% |$ T+ \20
# z+ f! o4 z* v: t, l3 ~7 i' f" m21
22
23
24
3 P9 \; I8 G6 W& K5 R" ]3 `( `25
26
) `. [6 E% Y* |. e1 O27
28
+ O0 E3 e) v' k+ Z7 O29
) H+ j" i/ b; i  Q1 t6 }- V30
31
32
33
, }8 T& z* Q6 |, G1 _  d34
/ Y: x- ]( `0 n35
' |3 C' j& j- x! z, l7 i( k36
( x& W" F: }' |37
+ k. z" _3 {/ D+ _38
& V3 y  I  t+ s( K& k39
6 @& }4 h2 K; P) X, H5 r6 e40
41
42
43
44
45
! G9 @7 X( S! h1 h% u46
3 O7 s6 g' _' V47
48
49
50
$ @% N, X: \% j4 T4 ]- _51
52
53
54
55
( `* M7 `! x( a' v2 Q& J56
' i- V$ b) U( M" D- c6 D6 P5 a57
+ v8 {0 l1 ?3 h7 y1 R6 A58
( U2 [( N: a9 U) l4 h, @59
60
61
62
63
: ~/ P# d1 H0 H4 R$ X% `64
0 e2 C" ^* B1 M' _8 H9 C9 h65
66
67
68
1 Q( \# y, g7 z" r+ l5 O1 d69
' c% h6 h2 \# Q# [/ }# c' a70
$ M# }! @9 O# y( d5 m9 J2 Y* X71
. i* k- l( L! I+ b- v72
8 M" L5 g) E# K  {: C/ [5 `) t, ^73
74
75
76
77
9 O3 s, s- M' c  x" @$ w" I& b78
79
/ T! ?+ Z* [  Z9 q! s$ y0 _- r80
$ o7 A! n# h! y81
2 c; |3 i- a4 g) B4 t$ K82
83
完整测试类
package com.keafmd.Sequence;
7 V& f' I, i( `/ f
5 A2 R6 Y$ ^- f2 `8 q( L- S3 T7 J
import java.util.*;
import java.util.stream.IntStream;
import java.util.stream.Stream;
9 C1 Q7 [4 Q" ^' }8 H0 W

" z2 ]$ ^# G# v/ X+ z2 x; F2 U/**
- J/ h& |; Y9 o4 s8 P3 s+ V4 m * Keafmd
*
1 x/ q- u) [" D5 A2 h& [2 ] * @ClassName: Sort
* @Description: 十大排序算法测试类
/ h# ?& }: ~/ V5 Y8 l9 n * @author: 牛哄哄的柯南
+ X# C0 K' L, h& g/ t; ]2 R * @date: 2021-06-16 21:27
*/
public class Sort {

2 |, e! S* m& j8 }
/ r) u4 G) i  ]& g' F
1 z5 t$ y+ g6 K! }$ z
% R3 e+ t% B- g: @" m0 F: k    public static void main(String[] args) {
0 T1 @. ^- B) _" b
6 ?$ f2 V4 H  p! B" b& T( H
        int[] nums = {12, 4, 25, 47, 58, 34, 25, 9, 99, 26, 1, -13, 162, 10093, -66, -1};
" G2 S* p6 h4 W8 W7 j$ k% ]//        int[] nums = {12, 43,56,42,26,11};
7 s- j* I2 v8 `6 D8 l        int[] temparr;
7 w) i! U4 s1 X" p8 V) J" ]

( k$ Y% p3 b8 X/ \* p% P        //利用系统Collections.sort方法进行对比


  ^8 O3 i$ `& |! E$ ~/ q- s. n        //将int数组转换为Integer数组
        //1、先将int数组转换为数值流
        temparr = nums.clone();
        IntStream stream = Arrays.stream(temparr);
        //2、流中的元素全部装箱，转换为流 ---->int转为Integer
8 l7 b5 x. S/ m& {        Stream<Integer> integerStream = stream.boxed();
        //3、将流转换为数组
9 p6 w3 s2 J9 U        Integer[] integers = integerStream.toArray(Integer[]::new);
        //把数组转为List
        List<Integer> tempList = new ArrayList<>(Arrays.asList(integers));
6 l  }$ s- ?0 A& h        //使用Collections.sort()排序
        System.out.println("使用系统的Collections.sort()的对比:");

. X! S9 v+ v! @- l
        //Collections.sort
" T% {4 W5 L7 |; p- ^) R8 V/ V% q( c        Collections.sort(tempList, new Comparator<Integer>() {
2 s0 }  Q$ W: b8 L+ K            @Override
( b5 h% a; @+ g% e            public int compare(Integer o1, Integer o2) {
                return o1-o2;
                //return o2-o1;
            }
  A8 J* s; A9 m  Y        });

3 l5 h  a( x& `/ _
        //tempList.sort 也可以排序
       /* tempList.sort(new Comparator<Integer>() {
            @Override
$ x: {. |4 ?; ]# I7 ~. c0 x            public int compare(Integer o1, Integer o2) {
8 b  l" d" r7 ?/ r+ h                //return o1-o2;
                return o2-o1;
9 ]  B1 ?$ p% m4 v! W. K, T            }
        });*/


        //遍历输出结果
8 d- `) u$ E3 E3 y        for (Integer integer : tempList) {
8 s! g# H9 \$ I$ N' m            System.out.print(integer+" ");
        }


& Q5 T2 P5 [6 ^        System.out.println();

4 q$ u) [# @* S4 Q  ^$ l' G
. c% c) O' E: _# h* R* t1 A# ]        //测试冒泡排序
8 d8 U* K4 b2 O        System.out.println("测试冒泡排序:");
        temparr = nums.clone();


        BubbleSort.bubbleSort(temparr);

' P  G. g6 d, i: n0 }6 J. F
, M# K: T9 D7 X6 D2 t- ?        //降序
, x/ W+ _  R' f7 ^        //BubbleSort.bubbleSort(temparr,false);
* K0 E# {0 C) s1 |) S  ^1 d& X4 `
- R, [! ^( E8 o3 R2 v
6 p7 [% z% c/ f" e. Q        for (int i = 0; i < temparr.length; i++) {
1 V* {# l, A, K( t            System.out.print(temparr + " ");
6 r. W! k8 k1 d( g1 J0 X        }
2 w1 U; s+ S2 l: G% d" @4 c/ [" S        System.out.println();

: {6 _8 g6 B2 a( R
+ x6 \, S' q" y# a; H3 n- U) j$ m( @        //测试快速排序
        System.out.println("测试快速排序:");
  M+ @- A" W, ]* O" B( t/ T        temparr = nums.clone();
/ w, r2 g4 H6 o        QuickSort.quickSort(temparr);
. ^$ n: m5 I# n6 M+ P- s8 ?        //QuickSort.quickSort(temparr,false);
        for (int i = 0; i < temparr.length; i++) {
7 G" [  [# j- ~: y* Y- ~            System.out.print(temparr + " ");
        }
        System.out.println();


9 J: |$ t" o$ u9 c* W. E        //测试直接选择排序
        System.out.println("测试直接选择排序:");
        temparr = nums.clone();
        SelectSort.selectSort(temparr);
& T+ q+ u+ c1 q& h6 r% ~        //SelectSort.selectSort(temparr,false);
% l: Y  z" O2 a7 c& s, z        for (int i = 0; i < temparr.length; i++) {
: ?8 d$ M9 k- r% z3 Y            System.out.print(temparr + " ");
        }
        System.out.println();


        //测试堆排序
        System.out.println("测试堆排序:");
+ ?# w: l, V# |% }1 s2 e9 x9 z        temparr = nums.clone();
        HeapSort.heapSort(temparr);
( S' g$ c& `& b* N        //HeapSort.heapSort(temparr,false);
        for (int i = 0; i < temparr.length; i++) {
            System.out.print(temparr + " ");
        }
' a5 L' C' ~8 d' ^4 U* }        System.out.println();
+ M7 @' G- |! {+ ]: B* W
. Q7 G) e6 ?- k
. \- L; A& B, ^6 e6 _, n& |        //测试归并排序
        System.out.println("测试归并排序:");
        temparr = nums.clone();
, b' G% i& E) u0 |7 h        MergeSort.mergeSort(temparr);
3 J& I; S) g% O1 m* |        //MergeSort.mergeSort(temparr,false);
  \6 _( r+ @2 o( ?        for (int i = 0; i < temparr.length; i++) {
            System.out.print(temparr + " ");
- Z/ b& g7 U7 J: b. p        }
        System.out.println();


; d- i, Q5 k* p0 V+ k5 c$ @: ^        //测试插入排序
2 a5 I) Z" `1 x4 T8 b. i8 A, p2 f, P        System.out.println("测试插入排序:");
        temparr = nums.clone();
        StraghtInsertSort.straghtInsertSort(temparr);
0 m+ q5 |7 x* W! {        //StraghtInsertSort.straghtInsertSort(temparr,false);
        for (int i = 0; i < temparr.length; i++) {
% P7 b9 d, F" [: M5 ~% [. p            System.out.print(temparr + " ");
: J+ V3 ^' u. N8 q        }
        System.out.println();




  N+ [7 z+ m' V        //测试希尔排序
  q! }/ Z3 |9 o  B$ i1 Y  ~        System.out.println("测试希尔排序:");
        temparr = nums.clone();
        ShellSort.shellSort(temparr);
        //ShellSort.shellSort(temparr,false);
        for (int i = 0; i < temparr.length; i++) {
            System.out.print(temparr + " ");
7 W* H* d! K* _        }
        System.out.println();
# p. u& D# ^3 O+ I+ O

4 U. v* W( h: \% o

        //测试计数排序
        System.out.println("测试计数排序:");
7 @* W) V: v+ l- F; P        temparr = nums.clone();
        CountSort.countSort(temparr);
        //CountSort.countSort(temparr,false);
+ b2 Y! m% f, W8 o" b! F, k) j" S        for (int i = 0; i < temparr.length; i++) {
            System.out.print(temparr + " ");
        }
+ T; c2 y: R9 T/ s  `' B        System.out.println();




# k0 |* W/ {5 t0 O- N% A: r        //测试桶排序
6 |  n0 W0 R. e0 U  _* X        System.out.println("测试桶排序:");
3 l4 E8 H; q( a  L        temparr = nums.clone();
0 y) k/ c  f: s7 Z9 }7 V+ ?        BucketSort.bucketSort(temparr);
        //BucketSort.bucketSort(temparr,false);
        for (int i = 0; i < temparr.length; i++) {
            System.out.print(temparr + " ");
! ?8 E- ]+ v2 |1 N" ?3 D' o        }
        System.out.println();
! Z2 I2 O6 H* [& b0 o
+ r2 {5 L# o. @5 Q- ^; n3 y9 O  c1 L
        //测试基数排序
        System.out.println("测试基数排序:");
        temparr = nums.clone();
, O9 Y7 N/ {' x2 S1 H7 W, h+ q        RadixSort.radixSort(temparr);
% z+ B, H3 R3 R        //RadixSort.radixSort(temparr,false);
        for (int i = 0; i < temparr.length; i++) {
            System.out.print(temparr + " ");
        }
6 a  M- |5 c6 n        System.out.println();
4 V; T4 c/ _" T) g4 x
) i5 Y0 ?7 v3 z: _7 V' V8 w) O
    }

" {3 C7 M1 L- F( Q8 f1 w
# d& H& Z' m! K  w}
: f5 w8 ]  x: Z5 \4 F0 e1
2
9 v* L4 b6 O: ?8 |5 i6 w3
: c/ z, Q2 |8 q4
5 ~' E' y( M# @: s, b4 Y8 u6 G5
6
' L" z( D) r8 S7
8
$ D/ _3 y7 x7 {; x, C9
) T- t. K7 ]" Z1 e! }- ^+ U10
11
; ~( z# m$ b% f. P' V) v12
7 C- e0 J5 f: T3 |# N8 Z: K5 G# A  B13
+ u# V, ~# L/ S! {  F9 k  S14
15
% n$ T# R3 ]3 l4 k  I; f2 I16
( p/ @; x" E& o8 u17
" Q, l0 U1 a0 D, }+ o) A5 v% R- b, p18
7 B; G% F6 x) `, f* C  z3 K19
1 O3 L! R, H2 j; O8 Q: h7 {! E20
21
22
23
24
7 Q. K6 m! X9 ~9 T/ K9 T4 B25
26
27
* I3 @6 l0 Q# `28
, I4 X0 p/ Z, B3 h29
30
31
32
33
. x% ^6 T  ~8 B2 ?! H34
35
3 y% B( @( z$ C! n3 @) a& ~36
2 z+ P3 B% {2 D  {  Z1 r37
38
- p0 N2 w1 U9 k0 n& f39
) U- Q: }' x8 o7 a& g40
. p0 }1 \+ m: Q2 t/ t41
6 _5 _! N% D, v! H42
43
44
45
46
6 a7 J' @$ i" h* c47
48
49
1 r! A2 ?$ O! S# B1 e$ d7 N50
$ v/ M. w/ s6 F9 s2 L, t2 v51
' R6 d3 ~6 C" `7 J4 K52
53
54
55
2 u$ U7 q. s  L/ O; i  h& Y56
+ D8 i8 D) J$ U0 _* t) T57
* {" q/ S- \5 a1 W8 p) ]1 U58
59
9 U7 p- n# z% F; K0 S, Q8 {% B60
61
62
" M  ^. C- D8 X8 }4 w1 L, @4 z% ?6 p+ J63
64
( Z* b, Z/ \& j- K9 w  J65
66
8 S- ^5 R! Z* ^% B67
* F. t) j& e; x( G1 C68
: @0 u5 ~3 {, b1 k4 k0 _69
70
, K; [8 k& C& y$ t4 G71
72
73
. d/ W; a3 r1 x  p: Q74
75
; f/ f% F: h) a) l: [  W! P76
77
78
: B9 ?! ]  S$ ?) ]; J2 ]& B79
$ E2 K+ f$ {1 O! e! @80
8 i: R0 J/ g6 f: o( U5 ~: }3 ~2 t' _81
82
( U, u2 ]% g5 L; h3 U$ N) q83
7 f  ~. G8 `! R9 U' J& F84
85
86
87
88
4 x0 `! h) B. a/ t5 A5 C% u89
- W* _  X7 p9 @. `/ g6 |" p  Z  z90
91
92
93
: X. J. D( H3 l3 T94
% q  ]8 S2 r9 x- W95
% z, v7 c* ]: Z" K8 k) r2 W96
' v& x2 u  g) ]# f) E( B97
: u7 Z+ j5 B9 H! v98
99
100
101
" d  p* q, ^( Q! M2 e6 z102
2 ~1 y& H1 |# w/ a103
9 z' B" B' m, z! u1 ]- `104
105
106
, ?9 W- O: c& y* a% H& T107
108
* J0 N2 ?" d; G, b( ~9 O109
* J* {# `" I( l3 s- G1 b3 x110
111
112
. M- P5 U" K- M" n113
9 a" Y! Q+ @* b# e% z114
' T9 Q% W, e. p* r# {% g115
116
117
; L2 ?, M. b. W118
% n# c6 b0 r0 g119
120
121
9 v1 h3 N& c# k8 \9 x0 G# U122
123
, W/ J0 m5 Y0 B124
( F2 x7 S( c; r$ G- R6 H125
126
127
128
129
+ K4 t( k1 k+ L; [8 U130
7 q* q" D8 q8 g( ~131
132
" p7 \5 A7 [! B% N5 y0 ]133
134
2 w( C. N* g, t+ E6 V& t, a6 v2 c' ^135
136
137
& m7 ?$ X% V7 i# ?5 b0 ^1 _138
139
140
& D9 ~8 I$ V/ E) P: Z- m+ L+ D141
5 f; ~" r! u4 r* E* c2 w142
143
144
145
3 @0 I7 ]: J; T- K4 m146
147
( U9 L, T% S: O% X* w148
149
: m* O7 ?/ O) a3 G) e. I+ m( \150
151
" H1 ~# I, }6 b152
" [: j7 i- C1 p' F: S$ r3 o153
! o3 m- X  m+ ?, d, M154
, c  Q7 m8 r- ~155
156
2 Y) V* z3 c6 P* _157
158
6 d. J8 f# q, k% @159
160
161
162
4 z" N# P5 H* G% [& z: C163
164
/ L% n% `$ E5 C2 e3 a$ F165
+ P! {: b9 a. v: `% J- L/ k$ l166
& I! a. w  O* E# v; y+ k' k167
168
4 _" N$ U. Z; [169
170
171
172
173
8 V: ?* i0 E0 P6 p8 r每天进步一点点！
不进则退！

% x4 S. I  n: \8 k: E( @1 U2 T
版权声明：
! ]% c, P6 t% c3 d1 A, z原创博主：牛哄哄的柯南
博主原文链接：https://keafmd.blog.csdn.net/
————————————————
7 s. v: S; `$ A5 ?! A版权声明：本文为CSDN博主「牛哄哄的柯南」的原创文章，遵循CC 4.0 BY-SA版权协议，转载请附上原文出处链接及本声明。
原文链接：https://blog.csdn.net/weixin_43883917/article/details/118193663


$ X6 v3 Y+ C( q0 V

1051373629

每天进步一点点！
  P/ r! x) s0 l; [8 D' S: P% M' h