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

杨利霞

经典十大排序算法（含升序降序，基数排序含负数排序）【Java版完整代码】【建议收藏系列】
' _' [, b- m; W经典十大排序算法【Java版完整代码】
写在前面的话
十大排序算法对比
冒泡排序
5 G- x4 |$ s5 v$ n快速排序
直接选择排序
堆排序
! E) ]& j) U! ?& O, R9 j归并排序
0 S% v' i/ c- n( w/ b* H插入排序
6 O  Y2 L+ m* k希尔排序
计数排序
桶排序
基数排序
3 \) i+ `7 q2 u" s完整测试类
写在前面的话
! A2 `0 h/ a3 C) J4 P       虽然已经有很多人总结过这十大排序算法，优秀的文章也不少，但是Java完整版的好像不多，还存在某些文章代码存在错误的情况，同时也为了自己练手，决定把所有的写一遍巩固下，同时也真诚的希望阅读到这篇文章的小伙伴们可以自己去从头敲一遍，不要粘贴复制！希望我的文章对你有所帮助，每天进步一点点！！！
' I/ m7 J! j0 f* G: M

       我用通俗的理解写下对算法的解释，对某个算法的运行过程不是很理解的话或者想看比较官方的解释的话，单独搜索某个算法，看几篇不同的解释，就可以有自己的理解了，这里我主要展示代码以及进行通俗的解释！整起来，再强调一次，一定要自己敲一遍，这样才能理解的更深刻！
! w6 Y6 @- z: @
; a; t* O. P& f4 i  y6 [! \
: _, \/ k$ r+ Y5 {十大排序算法对比




0 k# ]0 ^0 i" E" d% H关于最后一列的稳定性，我稍微解释下，例如对序列：1 2 4 2 6 排序，序列中存在两个2，如果我们把这两个2标记上（让他俩不同），排序之后，前面的2还在前面，那么就称这种排序是稳定的，反之不稳定。
! d& D6 @- W2 P2 [; Z. t6 B

冒泡排序
% u1 R5 P- C% F3 S0 B1 \简单解释：
7 c6 U3 I4 s6 {$ f# t       原理就如算法名字一样，就像水中的气泡一样，每次我都把最大的或最小的放到最后面，这样总共需要n-1趟即可完成排序，这就是第一层循环，第二次循环就是遍历未被固定的那些数（理解成数组左边的数，因为每层循环都会把最大或最小的数升到最右边固定起来，下次就不遍历这些数了），两层循环遍历结束后，所有的数就排好序了。
       两层循环所以冒泡排序算法的时间复杂度是O(n 2 n^{2}n
: v) [9 r$ U0 a( A! b7 ^2
)，是一个非常高的时间复杂度，我在下面的代码进行了优化，加了一个标志位，如果上一次循环未发生交换，就说明已经是有序的了，就不继续下去了，反之继续进行下一轮。

7 @$ N% ^; l- A, Q+ R2 M3 [

# O+ Q3 o& D/ c# j: l' i. L


本文的图片来源网络，仅用于大家学习，侵权联系删除！（下同）


完整代码：

+ @+ G& a5 e. z6 v7 s) i5 W; V& o
! P$ i# H# E+ v# {5 q/ upackage com.keafmd.Sequence;


" X" ]4 r5 C; ]% X/**
3 m. l7 \' b; R * Keafmd
1 x4 L$ O3 a# Y6 _8 |* E *
* @ClassName: BubbleSort
* @Description: 冒泡排序
* @author: 牛哄哄的柯南
" f0 f! S0 s, \: G * @date: 2021-06-24 10:31
*/
public class BubbleSort {
' R: E+ Q1 j2 S, U. g
7 K* }5 Z$ c( q0 V
    //冒泡排序
    public static void bubbleSort(int[] arr, boolean ascending) { //exchange标志表示为升序排序还是降序排序


4 \+ e9 p; v( l3 _& ~        boolean flag = true; //加一个标志位，记录上一次是否发生了交换，如果是，我们则进行下一轮，如果没有，说明已经冒泡好了
5 ^4 H4 w9 M5 |# w/ A2 U7 W

        for (int i = 1; i < arr.length && flag; i++) { //控制次数，第几趟排序，只需要n-1趟，有交换时进行，只有flag=false就说明上一次一个元素都没有进行交换
+ G7 R) G  H- i1 C0 I
' @( J0 I4 o, _0 w# S9 q
            /*System.out.print("第"+i+"次遍历：");
9 I4 f, w8 _: f; b4 k! S            for (int i1 : arr) {
                System.out.print(i1+" ");
            }
2 _* q$ C6 G4 h3 Z* q            System.out.println();*/


- G- @" a" G! e+ L            flag = false; //假定未交换
' x* O6 E6 G& e! r; S
5 p% c& O9 U4 Q$ i1 [
            for (int j = 0; j < arr.length - i; j++) {
+ x  a# B4 t9 u8 k

                if (ascending ? arr[j] > arr[j + 1] : arr[j] < arr[j + 1]) { //控制升序还是降序
                    int temp = arr[j];
                    arr[j] = arr[j + 1];
( E1 m0 g0 O* t& R/ N                    arr[j + 1] = temp;
6 t& [6 R9 w  ?$ \                    flag = true;
, e6 _% v& p7 v% E8 q                }
% j4 M! B! z1 \/ ~, O8 g" a, D
: l: j5 l  f# O4 ~0 p
            }
9 u, s; o3 D1 a/ ^" q        }
    }
- M1 Q* A6 h: C

3 }$ l! Y5 j8 ^, p% _. Z    //冒泡排序 -- 默认不传参升序
4 b7 m1 l$ u; b7 [- p9 B5 P- [    public static void bubbleSort(int[] arr) {
% Z$ f4 b* C7 B* z6 Q5 M& F        bubbleSort(arr, true);
    }
+ r/ h* K4 C2 e1 X' x5 B}
/ `. W8 D/ a* a$ {6 \( t1
# V% ^2 F+ D+ Y9 B7 x0 H/ X1 ?2
) T/ I/ N3 b0 H3
4
; J/ a! q- \/ \" `3 o1 b8 L7 i5
) \7 [  C! l# {' j& m8 a- |- Q6
7
. S! Q) l: {! c3 Z8 g" O" b7 J8
  h& H- H# j+ Q9
1 y! l3 ^+ @8 u* H+ ~8 a10
$ N' N+ U, l$ r/ I11
12
& M# u% W& B1 W, H  }13
14
! e& P1 u8 |  I4 H' b1 j15
8 }1 A0 @( g* w8 l16
17
" _: y7 R" U, r2 P4 g18
19
20
21
22
: g' v& c  J- [9 @  {. j23
) `) P/ W" l+ A9 c24
25
26
+ Y1 W0 g; G8 g# c- \# t+ U" R27
1 [4 P8 [0 z. Z. x0 A4 C  U28
. u6 \1 C# r8 M' h29
30
' H# `9 a6 Q$ J; x31
9 B$ G  `: I+ G( x32
33
34
35
36
+ c, S) P( A! O1 n3 l37
38
39
/ U8 |0 v4 E$ C8 A7 ~  Q( n; z40
6 e( i9 Y) K, M' Q3 s41
42
43
44
45
测试代码：
" H9 t& X  }- [* p- H& J! T6 K
* w) B( L2 C. `0 c3 M5 v, d; R" h
升序排序（从小到大）


. t" y" D$ P' t, W; V; `' spackage com.keafmd.Sequence;
+ z8 a% V9 Q' ]/ @8 P

import java.util.*;
3 r+ W8 E* F, r# s2 e1 p" U/ o7 eimport java.util.stream.IntStream;
6 {0 r7 B/ b8 h: Timport java.util.stream.Stream;

  Y% f) [. A# }1 A4 |1 Z5 b
/**
* Keafmd
. m" C! R- T/ L7 y+ S *
1 b! z: c' O' d * @ClassName: Sort
9 J6 l0 z1 A# p8 |' B8 ~- s * @Description: 十大排序算法
* @author: 牛哄哄的柯南
* @date: 2021-06-16 21:27
. C; E- Y" T  c  E) A5 c7 ] */
; _! f/ w2 S, B" H) H* h6 ~public class Sort {
3 M; q# n, {1 ~    public static void main(String[] args) {


        int[] nums = {12, 4, 25, 47, 58, 34, 25, 9, 99, 26, 1, -13, 162, 10093, -66, -1};
% e1 L5 Q" w4 s3 m) \. G; P        int[] temparr;

; Y1 P/ f4 u* J! g8 t8 \
: C, w8 K  V7 N0 M, _# p+ ^3 V        //测试冒泡排序
        System.out.println("测试冒泡排序:");
        temparr = nums.clone();
' P; v5 v5 t/ E( D        BubbleSort.bubbleSort(temparr);
" l- L" u" v$ ^3 Y+ f0 S        //逆序排序
        //BubbleSort.bubbleSort(temparr,false);
- n/ }) H' P9 k% w        for (int i = 0; i < temparr.length; i++) {
            System.out.print(temparr + " ");
        }
) L9 k1 m/ O9 k        System.out.println();

" a3 B. A8 z+ w! \, G. f3 B
! d, G- P  Y$ h! G5 G    }
}
+ j8 b# T# v1 Y& ^# L* _1
2
# U6 e) j  H, E, A) z& p3
- r" g' T4 V$ R' \0 r/ a7 C" f4
2 W+ }/ _8 T  ~. J8 {* `0 R' K5
6
: n; z1 y4 m- l7 [) H8 c7
8
9
10
0 j7 ^7 q/ U/ z9 D& v2 ?9 I7 |11
12
& I7 m! X" g5 \5 f13
, Z+ h  j2 B% a3 J/ V9 M+ l3 g14
15
16
17
* L# J, V8 Z7 y2 s: f* Q18
19
: ^$ I. h/ v3 g" r20
( g! _" h' ~2 z3 x2 b1 Q( A21
22
# z+ H% }+ `" A( |: U% @23
2 I$ D' }. Z- a0 ?9 J3 A24
6 E( k& Z. l5 V" c5 v25
26
27
- u6 W" g" T. U9 M# |1 {1 }9 b28
! c: {0 [' Q( f( F+ ^1 X& I4 B% }29
0 T2 b) P% u/ p1 R  x30
31
5 v' x* u7 U' G. d4 n# D2 X32
2 ]% K1 o4 u2 S! g% n" T; p) _5 ?33
: e! B9 I3 L" d2 \! {+ f7 N% Y- E运行结果：

8 @8 h8 S# F6 Y* d, I- g+ ]
$ Y# ^0 B, h# l4 @; c测试冒泡排序:
1 k6 j, N7 \7 t% y& L$ E-66 -13 -1 1 4 9 12 25 25 26 34 47 58 99 162 10093
1
  a! r  c( x+ E! h1 R: ?6 p9 h& g' @  u2
* K7 r( W4 W( j% X1 r8 ]降序排序（从大到小）
* d% A& u' N' U; L1 T0 x4 c# N

$ R6 F0 G! j- L# }  x//测试冒泡排序
System.out.println("测试冒泡排序:");
8 P% _. A" n" u. ^" |& H; ytemparr = nums.clone();
BubbleSort.bubbleSort(temparr,false);
8 N3 x) a( A) h, N5 `+ Pfor (int i = 0; i < temparr.length; i++) {
    System.out.print(temparr + " ");
}
System.out.println();
1
2
3
4
( E4 @6 D6 ~5 N( a+ S5
6
# N( N+ h  X3 N) J6 L/ x7
2 Y# a6 z; x6 U1 ]* _0 L8
运行结果：

0 l  s( x6 l% t
测试冒泡排序:
10093 162 99 58 47 34 26 25 25 12 9 4 1 -1 -13 -66
9 @$ c0 u. I# V' u" T+ q, N1
7 F3 J" h; N5 A  w( n! I. _+ g2
  n  T/ G: N* F+ m" N下面几个算法的测试也就是换了下类名和方法名（换成相应的排序算法），如果想降序就在数组后面传个false即可。我就不一一复制了，我在最下面给出含所有算法的测试类，需要的自取即可。

  \& ?8 _) M0 G8 Y) v
1 w; j4 v+ b, h, l快速排序
简单解释：
快速排序就是每次找一个基点（第一个元素），然后两个哨兵，一个从最前面往后走，一个从最后面往前面走，如果后面那个哨兵找到了一个比基点大的数停下来，前面那个哨兵找到比基点大的数停下来，然后交换两个哨兵找到的数，如果找不到最后两个哨兵就会碰到一起就结束，最后交换基点和哨兵相遇的地方的元素，然后就将一个序列分为比基点小的一部分和比基点大的一部分，然后递归左半部分和右半部分，最后的结果就是有序的了。
1 c* S$ ~, d  A* W2 \* L) m
: ]  B* ?6 m- e  k
5 ]2 E" v* ^8 ^2 C  E0 ?  ?# W% w" h
: A4 h" Y7 |! t3 E

( L9 N& s, K! K! n. }& C
6 D" v( u' k; l; O0 ]# ?完整代码：


2 k. I% `" A# b! Qpackage com.keafmd.Sequence;
, I* I6 Y' K" D! r" i/ n/ L; y

/**
2 p& H+ S. y' _/ r1 q * Keafmd
*
4 i; Z" b2 f* W5 E8 O * @ClassName: QuickSort
* @Description: 快速排序
7 \$ M, p( d$ [ * @author: 牛哄哄的柯南
* @date: 2021-06-24 10:32
' o7 H: a  m9 p. ]' |8 R4 U3 F */
) y& H' U0 ^) Q) F& J+ S+ npublic class QuickSort {
2 J, V* ~4 O: j7 \5 G

    //快速排序
( V) B9 p# u6 ^7 h4 o- J: `+ T    public static void quickSort(int[] arr) {
        quickSort(arr, true);
    }


    public static void quickSort(int[] arr, boolean ascending) {
4 T. _0 k0 y5 q$ v        if (ascending) {
            quickSort(arr, 0, arr.length - 1, true);
& V, e- ^, s1 f7 p9 P' L        } else {
            quickSort(arr, 0, arr.length - 1, false);
. o' M6 a7 n- b3 j& P; }& I, j5 Z# {        }
    }


    public static void quickSort(int[] arr, int begin, int end, boolean ascending) {
        if (ascending)
! K! c# ?+ U' k( E4 s3 P! |7 T            quickSort(arr, begin, end);
        else
" K: W" R) }& }% x/ l! d            quickSortDescending(arr, begin, end);
4 M$ q$ a4 F: v$ w1 F" b7 e    }
% V) H( ]% r5 k# \
  z8 l" b3 u8 r! `# g
    //快排序升序 -- 默认
% o, X- ~& B' s7 R* G    public static void quickSort(int[] arr, int begin, int end) {
: F$ G. Q+ D3 o6 ?        if (begin > end) { //结束条件
8 G7 `- T# m8 N9 Z6 w" s3 n            return;
        }
        int base = arr[begin];
: R: B+ ]! l- L        int i = begin, j = end;
8 G; r5 U6 D: `. f6 k9 W( |        while (i < j) { // 两个哨兵（i左边，j右边）没有相遇
            while (arr[j] >= base && i < j) { //哨兵j没找到比base小的
                j--;
            }
            while (arr <= base && i < j) { //哨兵i没找到比base大的
% b1 z, e  s; H% X# B                i++;
            }
            if (i < j) { //如果满足条件则交换
                int temp = arr;
$ Q) z; X3 P) q. u3 n) N$ B                arr = arr[j];
                arr[j] = temp;
            }
7 W5 M! f( D# H- c, j
# @& J' g0 A8 ~5 Z3 p
        }
        //最后将基准为与i和j相等位置的数字交换
3 I# a: _$ `7 ^0 S4 @$ w( m        arr[begin] = arr;
        arr = base;
( w3 c* d: R# g# V1 Z+ D- {* t. i* y* ?; `        quickSort(arr, begin, i - 1); //递归调用左半数组
        quickSort(arr, i + 1, end); //递归调用右半数组
* W' [- u) B  R! }/ b
  @; u" s* S3 [' ^+ `) Z
$ ]1 S: L  }6 {. X' r$ ?    }

( q9 D$ `/ P" g3 i" o. _* o
    //快排序降序
# L+ p7 h9 S( A" f* J4 I$ U    public static void quickSortDescending(int[] arr, int begin, int end) {
        if (begin > end) { //结束条件
9 P' U- }  d$ v, w4 C- o0 y            return;
        }
" R( a6 e* h6 H. e. ~        int base = arr[begin];
! n3 T  o+ z  ~: x# G        int i = begin, j = end;
        while (i < j) { // 两个哨兵（i左边，j右边）没有相遇
& |; f' g6 ]! V            while (arr[j] <= base && i < j) { //哨兵j没找到比base大的
" f! D  m  \5 N! u# Y: V( G2 e0 v" d( [                j--;
6 V3 _' h. e/ r$ _3 Z            }
, {- [7 j0 d- r" [            while (arr >= base && i < j) { //哨兵i没找到比base小的
                i++;
9 B8 y4 ^8 ^9 r; W            }
            if (i < j) { //如果满足条件则交换
2 [* {; \& n, T& z7 J                int temp = arr;
                arr = arr[j];
                arr[j] = temp;
            }
4 |# A  z; J5 @+ [
9 y" J( U( V# J9 I: e& S" r' V- }
* Z5 t" m9 u$ {        }
        //最后将基准为与i和j相等位置的数字交换
        arr[begin] = arr;
& O: R% ]! F$ q1 }8 M: t! ^. n        arr = base;
5 v2 H. m  x3 T6 `: Y4 [  l        quickSortDescending(arr, begin, i - 1); //递归调用左半数组
, |" Q8 z# {" ]- ~        quickSortDescending(arr, i + 1, end); //递归调用右半数组
5 |9 X& Q9 \( T# m1 {- |+ J6 H; Y, f

    }
0 k4 l) H+ r' V7 T7 E; C7 G
. M' M4 ~: Q7 X( |3 b
: v0 V9 @2 m) l# V! `}
1
2
. F% f5 l) {$ R+ b1 |8 f) F3
1 \1 P% V" e4 ?: O3 L, M4
5
  H- S/ R, q2 K6
2 N# D2 ?3 _  Y) D6 ~2 k7
8
0 O: [* w2 j- E% u2 `7 y9 F9 r/ S9
10
, `% j# U2 o) Y4 j11
12
13
14
3 N; V- p, J/ N7 a15
16
17
18
8 c9 j% b9 S9 _, S9 D6 ~9 U19
20
21
$ L; W& U( I' {7 N8 I22
& _1 ]* P4 H# T0 a; m23
6 h9 l3 s* d3 V) c, S24
! a. Q6 [7 A+ P. J* i+ m; r25
" ?3 q" v; F5 T( X+ K% ^/ M26
: b7 D! b4 O# l' J# @! @! D( g1 N27
28
# I) k/ O) p( M6 `. N6 D6 O9 F: |29
30
0 O( e1 D' v- w/ m31
& g  D. e- y) S! r. U6 G; F32
33
34
9 O) J( e2 y$ k% a: A35
36
37
38
# x7 B1 N! L& l) R' G  e39
: A' x" o7 A$ Q- |40
41
- @- k7 D" {' k( t+ u42
: y' S& o& b. \/ O' o! }; z& I43
- l, j( b$ h7 c' d5 o44
8 L, K2 ]0 `4 h& P/ X" P2 q$ w45
; B- g% b7 p; B9 o6 V; S% a% y46
47
48
& F5 t  X& n; J3 ]$ C3 @5 r49
50
51
$ _- a% O1 K) m( ]* G( R9 B52
53
& t# T6 n: y0 Z3 i( \" R4 q54
55
56
; }2 A+ x7 p6 F! \2 h) A0 J3 n57
58
9 {, q+ t# ]" ?# ~59
60
. p  j& M5 n( V9 |& P; |61
62
+ ^  B' j$ z) X9 ]& C63
; W% r" J; S, n! ^64
65
. u/ z& s* A: G& E* A66
67
; e1 B3 g3 T4 b$ c% ?$ I68
69
70
$ |8 d( l" V+ R, d$ S; w71
72
5 u+ r4 h5 `0 A0 j7 N  L/ {+ Z73
74
$ C/ |4 j" j: f) L6 q# C75
76
77
& T; Z: R5 Q& w78
% J/ b/ A- l( m& H" N" I79
80
" e1 l8 j4 r  J% H! s) @( t81
2 S/ p' c# j0 l0 p82
1 b4 h, I, j8 U* ^3 W) H3 J83
' w+ S, g/ o7 T: x6 V, n  K84
; @0 t, }* X+ `$ h0 B. b85
86
3 R+ e8 w$ k$ c; c" S2 Z87
3 E4 _- j# e; ?& Y88
89
9 a. Q. k/ X" Y: |90
5 b6 g& a4 D' A$ H' Q' W' l9 z91
直接选择排序
简单解释：
数组分为已排序部分（前面）和待排序序列（后面）
5 L7 L1 s0 L9 y2 p1 Q. J5 P* R, R第一次肯定所有的数都是待排序的
& h; Q5 X$ G+ M$ @$ Z& U+ k+ s从待排序的序列中找到最大或最小的那个元素，放到前面的已排序部分，然后一直找，不断缩小待排序的范围，直到所有的数都是已排序的了
$ E# V% k, h) S. d1 N% ^4 i
% m- F3 |$ Q* K% U7 w3 _8 `
4 F5 {4 O) R0 x' J( M; z% K1 ^


, r# u' P* n0 g, P5 F+ f
完整代码：


7 {' X  e# \6 e3 ]8 fpackage com.keafmd.Sequence;
2 W5 T6 b5 ^) R9 u% a- v2 {
4 I: ?' l7 ]" B/ W& ?0 v
/**
5 m" R0 P9 i" c6 c9 C* h2 ^+ s( v * Keafmd
+ z5 G4 z! t( F: B *
& W8 I: c; y0 _ * @ClassName: SelectSort
* @Description: 选择排序
2 T% P  c$ E3 @6 f' i4 t  ? * @author: 牛哄哄的柯南
* @date: 2021-06-24 10:33
*/
4 r: d0 V7 w3 W# ]- w$ ppublic class SelectSort {
( B  A9 G, J! L  V8 a, }9 O
$ D/ J2 C' K' u+ M" c
) b0 ?1 T4 B- M6 ]( r5 L2 ?    //直接选择排序
    public static void selectSort(int[] arr, boolean ascending) {
/ b- j: b& E# q! K% `        for (int i = 0; i < arr.length; i++) {
            int m = i; //最小值或最小值的下标
            for (int j = i + 1; j < arr.length; j++) {
+ ?0 F$ V/ |- T7 u                if (ascending ? arr[j] < arr[m] : arr[j] > arr[m]) {
                    m = j; //找到待排序的数中最小或最大的那个数，记录下标
/ p" [  ]1 v2 u  Q* N; @, d                }

$ E& h  s0 e# t5 D4 W' q" Y3 f
+ m1 g8 V4 [. Y$ K# V            }
            //交换位置
            int temp = arr;
            arr = arr[m];
, P- W! I4 p; t$ t) U+ U$ `. ?2 \            arr[m] = temp;
8 f5 J+ @' h/ ?" C. p! A5 J

) C& z+ m$ _6 |2 T3 x  m. n        }
    }

, B8 D/ k  ]  T. P7 [
    public static void selectSort(int[] arr) {
( `) ^* a+ S( T$ }        selectSort(arr, true);
    }
}
" K0 ?; }& v; ~+ b" j1
2
, P% x7 E/ Z$ @9 a; R& ?3
* T% v' }* b6 {5 i4
# a: ]5 h% K5 P' |7 _5
3 v( r( ?8 h; U' b6
7 k+ _  r. B& M5 ?  \7
8
9
10
11
12
# [7 }, l+ y, l' t8 u: U13
7 V0 i9 _9 o1 ?' e& E; Q2 q- |$ x14
15
) B6 y2 s4 G0 A6 ~. Y16
17
% f. Q6 X5 w1 l6 n. R18
19
# H0 I- ~1 Z/ u8 _, |9 C20
21
" n; h7 d, W5 h5 C0 |22
23
24
( V5 a+ H; B5 k5 C- M4 m, s% X25
26
27
28
. g* V* T5 A: r29
6 g3 P" B5 y4 A9 b* e9 X3 d+ v* \  |30
31
32
+ T! q- h) a3 ]8 e& H33
34
堆排序
先理解下大顶堆和小顶堆，看图
大顶堆，双亲结点的值比每一个孩子结点的值都要大。根结点值最大
9 O; @9 \3 ]) m, s2 U, C8 u小顶堆，双亲结点的值比每一个孩子结点的值都要小。根结点值最小

& d# Q3 @! {- A( Q5 ^

$ `! e# P8 d9 O% N* i8 `
简单解释：
构建好大顶堆或小顶堆结构，这样最上面的就是最大值或最小值，那么我们取出堆顶元素，然后重新构建结构，一直取，一直重新构建，那么最后达到排序的效果了。

; \, G2 H* k# ], Z
9 C. X! X0 S6 J* o3 x" _% f
; E% q% F4 p8 M. h/ y

/ o( B/ U; R/ ]4 O7 V3 h1 K
- J4 x% M! k. f; }3 S* w完整代码：
) q; z; H( @) U, r$ z

package com.keafmd.Sequence;
/ d4 b' W4 {8 O) y9 s

/**
* Keafmd
$ N! C9 E$ m; t0 _) F *
) O9 F& l/ U1 m * @ClassName: HeapSort
  ]4 _4 O/ n; J: p. i0 `. X6 } * @Description: 堆排序
- W* i& c) O6 ~* s, D2 q * @author: 牛哄哄的柯南
* @date: 2021-06-24 10:34
*/
0 }" J, s/ m5 Q1 w# z1 @6 w" Lpublic class HeapSort {
' j! \4 F  I# R

    //堆排序
    public static void heapSort(int[] arr) {
        //对传入的数组进行建立堆，这里默认建立大顶堆，进行升序排列
' l1 K/ x: O! }        heapSort(arr, true);
+ S2 U2 t# o. h8 Z% B! R8 Z% R; |0 r    }
2 b$ g* p. L5 Z1 a6 A
0 s: M5 q7 R: P/ x
    public static void heapSort(int[] arr, boolean maxheap) {

% B3 l& V& Y4 m7 A6 i; I
. R$ r1 y- t0 s" h* a2 W( @        //1.构建大顶堆
        for (int i = arr.length / 2 - 1; i >= 0; i--) {
5 n8 n3 s* b3 Y4 V" \% g            //从第一个非叶子结点从下至上，从右至左调整结构
            sift(arr, i, arr.length , maxheap);
/ z# @+ H* |% F3 V' e; L        }


        //2.调整堆结构+交换堆顶元素与末尾元素
        for (int j = arr.length - 1; j > 0; j--) {


            //现在的数组第一个就是根结点，最小值所在，进行交换，把它放到最右边
# X" n& H8 `6 s8 y            int temp = arr[j];
            arr[j] = arr[0];
. B" v! R% S# Y) ]2 X% y" _            arr[0] = temp;


6 p4 u) K2 x' M+ m            //重新建立堆
+ L4 B; `) P9 E) w; c: e: w            sift(arr, 0, j , maxheap); //重新对堆进行调整
; G" H# S& K6 g        }
: R( {& W5 Z: \, A2 O7 B    }
3 K: R( H/ N4 O5 Q4 u+ F

: }: y; w# O4 D    //建立堆的方法
# O' Y! `5 a3 C0 X    /**
     * 私有方法，只允许被堆排序调用
9 ]% h+ @6 t1 J' {, ]( Q     *
     * @param arr     要排序数组
' p9 `" \4 z1 n+ Q6 o+ R4 K, }     * @param parent  当前的双亲节点
  b; v4 m$ x3 `5 {( M3 E3 Y     * @param len     数组长度
     * @param maxheap 是否建立大顶堆
- q- O' g% m5 v" J' C/ }     */
    private static void sift(int[] arr, int parent, int len, boolean maxheap) {


8 ~/ E( Y! L0 y1 O& J" u9 x        int value = arr[parent]; //先取出当前元素i
8 X6 L! B3 G8 A

+ x  ~" T) [; t$ Z( [, R5 o7 L        for (int child = 2 * parent + 1; child < len; child = child * 2 + 1) { //从parent结点的左子结点开始，也就是2*parent+1处开始
& _7 U$ |! ^3 x( q$ V7 T

            if (child+1 < len && (maxheap ? arr[child] < arr[child + 1] : arr[child] > arr[child + 1])) { //如果左子结点小于右子结点，child指向右子结点
* j1 U5 m( Y1 h$ e8 r                child++; //右孩子如果比左孩子大，我们就将现在的孩子换到右孩子
) z7 A( M2 D" `0 Y0 R            }


            //判断是否符合大顶堆的特性， 如果右孩子大于双亲，自然左孩子也大于双亲，符合
            //如果子节点大于父节点，将子节点值赋给父节点（不用进行交换)
            if (maxheap ? value < arr[child] : value > arr[child]) {
                arr[parent]=arr[child];
6 }0 `  B, H) J5 q9 S7 i                parent = child;
            }
( }% E2 U& c5 }: d            else {//如果不是，说明已经符合我们的要求了。
                break;
            }
& I# ^2 u  |2 a* g        }
        arr[parent] =value; //将value值放到最终的位置
& G3 {. N6 i' \( U1 K

8 U) K3 Q( n; C  J' }0 r/ F  h6 w% k, H# P

    }
% q" e' |9 c# B
6 a) A! `6 E; N- h. c  }0 G* L
}
8 @% \9 ]3 h: n) h" B' S0 H& o5 H% F1
2
3
4
5
( i4 H4 c- q) Z* p$ j5 y$ U+ b5 B) _/ p6
! n! ^  X9 n7 c* b! K/ S3 o7
" }# D* {0 m1 C. z6 C# t8
, i+ w8 j6 @9 m1 W) \9
( M3 l; Q$ ]7 y& g* q' m10
+ A& B# i  @; ]7 c' {11
% w1 w+ Z! n1 S7 U, w! T12
13
14
, d" J/ L4 w, J$ w: F% h15
16
17
) s9 |/ E; [( s1 j18
19
3 L! Q( `4 q$ e; i2 X! a8 q/ D20
21
! I/ _2 `+ {; |+ C% k22
23
24
2 S5 E. m* Y. ^. j3 D25
26
, P/ S. G/ C, X$ S& m( k* z27
28
6 a* o7 T: k" t, p: B29
4 n7 a- u9 Z. ?, [  H2 V) v30
1 |  b2 [: a% m( E1 P& M6 L31
4 `# I3 ^! N) ^1 D. R" M32
" [7 `: s# I* M' O2 k8 {- ^33
( v% s3 ~; y4 [7 J- b2 g4 S% d34
35
36
" m! l3 a9 p) V+ I: R) ]7 V" f37
. [1 e7 E& `" [; ~3 q38
39
# T' J* k4 m: t& d2 |& S. {40
41
42
+ h, S1 a+ Z9 }' L% P! t43
7 J8 F, D. D* E2 }2 T* j44
! d5 R* Y7 k6 \, F1 Y6 b1 Z( p1 C. k45
* @2 p. s. U" s; J  s46
7 n0 q/ h' }* A3 N/ C1 J47
48
5 w  R$ u, v5 S! e: [2 E* ~2 T2 |7 D% a49
50
- z5 D1 {- G8 G- q; [( {5 O/ u# f51
% r2 g* q9 X9 Q8 K0 z52
) _+ C2 a* j- O- |+ t53
% k! Z8 M* ], G2 {6 X; S5 G54
' O& r% d. R  `" B1 _  ~55
8 `. I( m: i' \. |. `& |+ p$ r56
57
& r! l+ s1 K) J7 S58
& k4 O0 U4 g* m59
60
& o5 u- G5 |# }' F" U4 H61
62
63
$ S+ J5 E# r1 |/ w7 o4 I* Q- _7 o% W9 z64
65
66
2 V4 E/ q5 \( e' g67
0 P/ @0 @: o$ |9 |; K; P68
' Z3 r4 I# e$ T4 T" T& [6 Z69
70
9 _& _7 @3 g, h% [$ N71
3 B& f) s: T+ }! t4 R# `72
73
$ H2 D/ b. t* v9 Q. S( V74
' a5 J( k7 O+ k3 L归并排序
简单解释：
8 |" O" w% F: K' R/ T, }' B该算法是采用分治法，把数组不断分割，直至成为单个元素，然后比较再合并（合并的过程就是两部分分别从头开始比较，取出最小或最大元素的放到新的区域内，继续取两部分中最大或最小的元素，直到这两部分合并完，最后所有的都合并完，最后形成完整的有序序列）



$ x% U; {7 N" v, i9 N2 q

, R, @% q: }2 }# S9 N8 [
' @/ c, K7 q$ I; W完整代码：


package com.keafmd.Sequence;


/**
( B! n4 ^& n, C4 {0 R% K  i2 g * Keafmd
*
* @ClassName: MergeSort
1 H, Z' F1 k+ G0 c$ E. l! H1 I * @Description: 归并排序
* @author: 牛哄哄的柯南
* @date: 2021-06-24 10:35
: U" Z6 e" D  t) Q$ s */
# y/ ?3 N; R- _, upublic class MergeSort {
+ t4 O+ f2 f( [, h# m1 a% W
, d6 [" e* E- S% B, `% C
" E- {" H9 S  H) W$ r    //归并排序
: e2 C) P6 ~6 C: y, o! I    public static void mergeSort(int []arr ,boolean ascending){
        int[] temp = new int[arr.length]; //在排序前，先建好一个长度等于原数组长度的临时数组，避免递归中频繁开辟空间
        mergeSort(arr,0,arr.length-1,temp,ascending);
    }
7 o' F' @7 M& h* C6 w7 k    public static void mergeSort(int []arr){
        mergeSort(arr,true);
    }
! f8 V8 @- |. P7 ?: Y/ w6 I
  u) V3 k- _8 ~5 R
    /**
     *
; T+ B0 r  G* `2 y8 r! ]     * @param arr 传入的数组
$ O0 z, ?! a  C( m# j1 ^( u1 w4 Z     * @param left 当前子数组的起始下标
+ @( Q9 p6 s* X; S9 Q( B     * @param right 当前子数组的结束下标
! `- N4 ?: k; I6 Z( g- }     * @param temp 拷贝暂存数组
     */
    public static void mergeSort(int []arr,int left,int right,int[] temp,boolean ascending){
+ F3 I% j% a6 J& V: O        if(left<right){ //这里是递归结束的条件，我们是对半分，那当left==right的时候肯定大家都是只有一个元素了。
$ D( L* a( S0 Y
5 e' u9 S5 |* Y1 B& q2 Q3 Q
            //对半分，比如总长度是10，left=0，right=9，mid=4确实是中间分了，0~4，5~9
            //当长度9，left=0，right=8，mid=4，0~4，5~8
            int mid = left + (right-left)/2; // 防止越界的写法
5 [" L2 K4 r5 b( |, @) N; J2 V            //int mid = (left+right)/2;
/ {/ |% q# M: X. ], u  C
% I+ |, t' M3 H
            mergeSort(arr,left,mid,temp,ascending); //左边归并排序，使得左子序列有序
9 b5 i: z1 e5 }            mergeSort(arr,mid+1,right,temp,ascending); //右边归并排序，使得右子序列有序
6 ?' o7 |4 k2 {- i# a

            merge(arr,left,mid,right,temp,ascending); //将两个有序子数组合并操作
4 i9 D, \' _- _* M4 y        }
    }


+ H- s+ k  `6 y0 M" h    private static void merge(int[] arr,int left,int mid,int right,int[] temp,boolean ascending){
4 K' [* w+ n8 Y, q$ V. \  U        int i = left; //左序列起始下标
& y7 ~  W3 @1 D' \        int j = mid+1; //右序列起始下标
        int t = 0; //临时数组指针
: a3 Y; Q) l* `7 |. E        while(i<=mid&&j<=right){
            if(ascending?arr<arr[j]:arr>arr[j]){ //比较两个序列第一个元素谁小，谁小先拷贝谁到temp，然后对应子序列下标加1
                temp[t++] = arr[i++];
/ m( v4 ^# V  \: y            }else {
$ G" `# R* S# G                temp[t++] = arr[j++];
            }
        }
! J0 n& m5 A& w0 F! ?& A
$ {& A% x8 y" g
        while(i<=mid){ //将左边剩余元素填充进temp中——左序列有一些数总是比右边的大的数
$ i" j; ^; g5 b            temp[t++] = arr[i++];
) b  P$ R( i5 n( c. Q        }
8 M/ r( g+ X  N
3 z- G, s% B3 b
        while(j<=right){ //将右序列剩余元素填充进temp中——右序列有一些数总是比左边的大的数
9 f( |2 |# I0 g' x            temp[t++] = arr[j++];
        }
9 Y7 L6 ^+ W7 O; L2 N

        t = 0;
# O: ?; v3 n/ t, J

        //将temp中的元素全部拷贝到原数组中
        while(left<=right){
. D% P: _2 s/ ~/ r( N2 K6 z) x+ O            arr[left++] = temp[t++];
        }
9 U% r9 G7 {) P. W0 ?+ K5 @, u

' k6 B! e1 Q: \0 I! w7 m    }

' x2 j; U# U% Z
}
5 ~7 I6 `; V7 {0 s0 s1
* L$ _* {( B' A; v2
3
7 M; U' D) {$ Q5 R0 E: g4
5
+ ], p6 R" T3 n6 V* ~6
( T2 U# Z5 }$ p0 |8 d7
8
9
9 J$ R  J9 ^4 i7 J3 x$ y10
11
$ V1 Q1 Z( R# D4 h+ O8 t12
+ C/ V0 f' h; S, p; u: i- u13
! X# V  h% ~5 u. O14
7 }- ]  A& u5 t5 N15
16
6 G( Y1 i$ ^  ^* i& U  B17
18
19
20
21
22
% v7 e9 z0 `1 w$ J! f+ U23
& M3 u1 H' r; Y2 m24
25
  X4 ?& G5 t9 r5 C7 ]5 L26
27
28
) y/ N$ }4 Z  I& C29
30
31
32
& ^0 `: I1 y7 g3 W2 J- k: M2 D33
) D8 L  ~3 Y+ X$ N; m8 _1 e: e34
+ M4 Q% N* s* D* G; Z35
36
37
38
39
40
41
42
43
44
8 V. B. L' s0 Q6 l' j45
46
47
6 `0 t( c& b/ o+ Y2 F8 C$ d6 o$ R/ a48
49
50
  H! o* X- q+ e, O7 s+ X51
52
% m) n/ X/ D9 N. _  o53
54
55
3 B8 ]! |; _8 P+ H; \" ]; M( h56
57
58
59
60
+ k& w5 }" j# X3 B. V9 G61
; n6 Y1 H; D) I' \; ?) @62
2 t- X( J" N% H' j' [63
4 \3 m* `! P$ W9 M64
. y, X4 X6 g1 @6 z65
66
67
68
69
6 a- T  G) j& V! I9 @70
71
72
73
插入排序
简单解释：
0 J: I$ c  _# L  X# V最简单的理解就是打地主时我们拿到牌后的整理过程，从第二个牌（假设我们拿起来这个牌开始比较）开始，（说下升序）从后往前比较如果比前面的那个牌小，就把牌往后移动，直到找到一个合适的位置（这个位置的前面的那个牌不比这个要放下的牌大）就把这个牌放到这个位置，慢慢的前面的部分变得有序，直至全部有序即可。
# o2 H9 G# `% _2 _& `! N( W
0 @& f; K. d( t3 w3 @! g
+ c! ~  I* o( V4 E! a* ]! A
( d9 Z3 Y' Y. q; s


完整代码：

. K6 q7 Y+ H: a% W
1 i- G/ O3 q  A1 y3 J2 b0 c  J9 `& ypackage com.keafmd.Sequence;

0 ?% P5 ?, r) b+ n* I
/**
5 v! U$ ^' K" v# n * Keafmd
4 K2 t* ?/ F/ N *
* @ClassName: StraghtInsertSort
* @Description: 插入排序
* @author: 牛哄哄的柯南
* @date: 2021-06-24 10:36
1 w) R3 n, w: E/ }/ W */
public class StraghtInsertSort {
    //插入排序
    public static void straghtInsertSort(int[] arr) {
; U, |) n8 Q: s        straghtInsertSort(arr, true);//默认进行升序
    }
5 z, C2 q5 \/ i& p% x( A6 i8 j

    public static void straghtInsertSort(int[] arr, boolean ascending) {


9 p9 X3 I" i4 X1 _/ L  I4 H3 N        for (int i = 1; i < arr.length; i++) {
            int temp = arr;
            int j=0; //这就是那个合适的位置
$ M: p3 Y5 [. y3 T* L; \            for (j = i - 1; j >= 0 && (ascending ? temp < arr[j] : temp > arr[j]); j--) {
! a. N4 p/ v6 j& W. B1 y! B, d                arr[j + 1] = arr[j];
            }
. Y  N- V' c& o% ?            //把牌放下，为啥是j+1，
            //是因为上面的循环遍历到不符合情况的时候 j是合适的位置的前面的那个数的位置
            //有点拗口，但是就是这个意思，看图方便理解下
$ ]3 s( d) ~8 b) J$ n8 y, t            arr[j + 1] = temp;


/ U9 Z0 `* ~) o0 _# z
: r  P, d8 w- `  a9 n. M8 a( N
        }

" Q. x$ m" j  e# q9 D
    }
}
1
2
3
- ~7 t* \  v9 ?% I5 F) o: g+ c4
5
6
: p6 u" r* J! V" B7 j7
4 _$ K/ D! s2 e$ R6 d( a. J! d( |8
  m3 D" ?' d& Z+ j5 y9
10
9 w* t4 ]- Z6 L  E! p11
12
13
- P8 _  m" v; C, M% U% f% e14
: l3 O# c& [1 z& |( x& p5 M15
16
17
5 B& \1 v% N, y+ H18
6 w4 L$ ^1 ]9 n19
8 `: R" d+ ~# V5 X) v$ T20
, R9 j& l9 K9 N) r# y0 A+ k+ B21
22
23
24
9 }( ?4 l! l- c25
: S8 c' S: }7 H* \9 M+ a* E3 d# B1 a$ F26
* M' m0 P" J$ Z$ \& ~27
28
29
30
31
+ _- a8 y! ^; S: ^3 M1 Z32
7 t% A8 Y, L( l+ q( j9 \  z! U33
" w; ?4 y) \( ?# J& J34
希尔排序
简单解释：
- J( `% A5 P/ u8 E希尔排序是插入排序的改进版，我们理解一个叫做下标差的的东西，也就是下面那个图中的增量d，初始下标差为arr.length/2，然后继续/2，对在同一下标差（相当于把这几个数单独拿出来了）的若干个数进行插入排序即可。
; S( X7 ~. z7 ~1 v( ?) I4 @


' c' ?0 a6 Z2 c' A9 J
2 z3 ~% H) F5 F" }+ a# s$ b) B

( P. j1 W- U2 O完整代码：
# N; q% m5 Q/ c: b
! x2 b  r2 B/ R, E, O" h) G  o
2 I# R# v  v: \: xpackage com.keafmd.Sequence;


9 g  r7 v; f( M  _/ [: z6 A% C/**
* Keafmd
*
) y3 y2 f  l4 C% n7 u * @ClassName: ShellSort
% R* z! ?. ]) j8 b5 |( p& l * @Description: 希尔排序
# {* E6 r: w7 g- y% t; I% { * @author: 牛哄哄的柯南
* @date: 2021-06-24 10:39
*/
2 P. b9 A, |0 v" c* ipublic class ShellSort {


    public static void shellSort(int[] arr) {
# S, G) B. |! ?6 C( O6 N2 E2 Q# q7 L        shellSort(arr,true);
    }

) n4 R2 g2 U9 v+ J- a
' L0 H5 ?; a2 U) X' j/ b* C    public static void shellSort(int[] arr,boolean ascending) {
: h9 B9 P- v! d5 z! c. Z* j5 v
8 ~* l6 U  r: L# Z" N! o7 _& ]7 U
6 n" ?: i3 N$ R- a. U        for(int d = arr.length/2;d>0;d/=2){
& ^  _4 V) P% L9 w
, L4 i5 w! Y5 D) g
            for(int i=d;i< arr.length;i++){
                int temp = arr;
1 V8 e+ F+ ?! P4 M; G. E                int j=0;
                for(j=i-d;j>=0&&(ascending?temp<arr[j]:temp>arr[j]);j-=d){
: v: o, e& k4 Z4 E: Z                    arr[j+d]=arr[j];
. r( A- j* q8 \, E                }
+ _8 k/ N0 d# Y( u- @( M                arr[j+d] = temp;
            }
6 G2 _! l0 x1 d, A. y, e: o        }

3 S4 |3 F2 D% I. F3 G$ J
5 a. W7 K! w) k9 Z; ~$ p- W  k    }
}
5 k/ L8 @- F0 \2 b' ^  C* E1
2
3
4
5
, L1 x! L9 o' O* V1 z7 ?) K+ [6
5 M8 c/ C: F. ]1 Y7 I! v: m7
! b! c$ l& N) g  P8
0 n+ u; c' x2 Z+ O$ ]* _9
2 e2 J- `" I$ f1 R* x5 P10
11
5 o. x0 u( u4 t* |12
3 A. U: V1 Z# C5 @) O13
14
15
16
17
6 R1 [% V+ }2 j18
# q- f6 f, p9 P# U  c19
% Z/ Q1 \6 Q" m9 i1 _20
21
! B" J& N3 s8 o! b22
1 O! U6 {+ }7 n, `# A5 b4 {23
) r) X) V, }4 w) R24
6 ^3 m- ~7 f) D' `25
) e2 S! u4 n* Y' V% O5 E26
27
& ^0 m0 I3 G" C! [5 P28
29
30
31
; y  A& w$ N/ x  j$ {- ?32
计数排序
简单解释：
) e! R6 D* i  |8 a4 _这个排序算法看名字也很好理解，就是就是额外找个数组来计数，然后在这个数组从小到大或从大到小把数取出来即可。


% i9 k" g. W0 D$ z4 n, b* Y
. w/ Z* P9 `# L8 {
3 `8 M2 V% ?1 a( K- C+ l/ n
3 ^4 Y0 D$ j) Q
/ \3 {5 z4 K' E' H/ W& V完整代码：


/ a7 {7 u4 r4 P% ]8 r  V* Ppackage com.keafmd.Sequence;


& K( n9 E  k9 ~$ |. v( l4 y* P8 ?/**
* Keafmd
/ y1 ^8 `5 J9 _/ I7 A, L0 ] *
' [% {! {. G; ~3 y' M! K5 |0 h * @ClassName: CountSort
7 d; J' D7 r7 v" U" h * @Description: 计数排序
/ v# c6 [' h9 m) u" ` * @author: 牛哄哄的柯南
* @date: 2021-06-24 11:31
*/
/ e5 I2 v& c7 c: i, Z0 |public class CountSort {

  a* `4 I7 s! R, B7 y$ f8 D' f
    public static void countSort(int[]arr){
! E- ]' ]- O! Y        countSort(arr,true);
    }
) h: U$ t" u$ U, h. w4 _

    public static void countSort(int[]arr,boolean ascending){
        int d,min=arr[0],max=arr[0];
  X* D$ Q, Z* o8 u! }# f7 G
. d- R) s+ e" q: n4 }$ @
9 k' _# c" g7 P+ ]        //找出最大、最小值
        for(int i=0;i< arr.length;i++){
' c$ `, I; h+ o) }$ }. j: T            if(arr<min){
                min =arr;
            }
            if(arr>max){
# |' f7 y0 m/ a$ x                max = arr;
            }
        }
+ ?0 k* J1 g6 D# z1 d

        //建立一个用于计数的数组
) Y) r$ P3 k8 ~9 K6 u! J        d = min;
        int[] count_map = new int[max-min+1];
- _2 W. R- n* O& ?        for(int i=0;i< arr.length;i++){
            count_map[arr-d]++;
        }
" g& p: ^/ v, z* x8 F

        int k =0;
+ s' k" E1 L/ g6 a3 M        if(ascending){
& ?! L1 k+ L" l" g. ?            for(int i=0;i< arr.length;){
/ x: _3 N' |0 D( L. N                if(count_map[k]>0){
8 s& W% R! j! o; v                    arr = k+d;
2 T% h0 ?+ @, E6 w                    i++;
- L/ |. w) c. J8 c9 A                    count_map[k]--;
                }else
                    k++;
            }
        }else {
# e8 I3 ^! s' ]& y5 k            for(int i=arr.length-1;i>=0;){
- U+ s+ Y. _2 l4 [' ^. Y                if(count_map[k]>0){
                    arr = k+d;
$ G) D6 [) E2 p, b) p3 k                    i--;
! X* Y* m/ ~$ p# w: ~                    count_map[k]--;
' ]* ^& P4 \9 S, c8 O( M                }else
                    k++;
& Y/ _+ N8 Y8 t5 b% f            }
+ H5 u, D/ i0 N2 l& ]/ @8 ?$ Q        }
; \& ~8 l+ M! d: y
  ~" n: U6 F" ^) W! `1 L
9 ^: [/ r2 s* U2 u- T& K: h    }
}
, l2 x3 {5 J& A( H1
2
3
' P9 _. G0 z( \# ]8 G4
5
: Q2 E8 k$ U; H7 o6
7
8
6 y! |" q' O" p7 C1 p4 l+ O9
10
& f/ k& H" j# W. b. A# ^3 H5 S11
12
13
# r( F/ ~/ k( s7 y) V14
15
- D, U8 [* |+ A16
17
18
19
20
0 D; X, Y8 b( O% F( a21
22
23
, F' s$ b" _; @24
25
26
27
3 q+ x0 h  ^6 x5 q. a28
29
30
31
32
33
34
" V3 T2 o$ m# m/ n+ ^35
( P+ w. p% t5 p/ L: n36
  m+ N: ]  }6 ]5 k37
. l4 ]4 r4 k  o5 P3 g38
39
40
41
42
43
2 N& X9 C' A9 ?5 ~44
45
/ H+ Y  Y& S* A' q; h' F46
47
. I$ R* }) M' a. d+ V48
49
50
51
, M' y$ s% D) F: E0 j52
53
54
# S0 b8 }9 D; L* O! n0 z55
& f) W; w3 O6 j; F56
; E6 S' ]7 ]. [% J& ]57
# ^! e# A( b/ V- v, H58
3 C4 |7 W" _+ K, X8 z59
桶排序
' \4 _7 J5 `' v9 s+ K, w简单解释：
就是把一个数组分成几个桶（其实是几个区间，从小到大或从大到小的几个区间）装，然后让每个桶（区间）有序，然后取出来放一起就可以了，相当于把几个有序的段拿出来放一起，自然还是有序的，当然需要是按照区间的顺序拿了。

9 ?2 V7 ?9 S$ o" d0 k: j
. B5 k/ I& H# Z
5 `8 Q$ s7 M. V5 e& _
0 Q' ?7 h: y% T% m
0 S7 R& H! V) M+ F% D" w7 }
) N% c+ z; J. k: X+ d3 q完整代码：


# V/ F* a; H, Tpackage com.keafmd.Sequence;


* Y0 I5 {* O; _, }. Yimport java.util.ArrayList;
import java.util.Collections;


/**
8 x7 r3 [  {) W( R( v3 j7 y" f * Keafmd
*
* @ClassName: BucketSort
* @Description: 桶排序
* @author: 牛哄哄的柯南
8 a% h9 U6 ^8 Q6 K# C/ x2 K2 T * @date: 2021-06-24 13:32
# C  ^, u: S. B* P */
* d$ W3 k- X  b2 L: z2 Ipublic class BucketSort {
- m1 U: p& l2 T. f! }
9 b% ^  f& j+ D2 ^) e
% _" j/ a1 x- |' Y    public static void bucketSort(int[] arr){
        bucketSort(arr,true);
) y/ C7 a2 _6 w    }

/ w& q( F1 `! F# I! d+ c- w; @6 V1 h
    public static void bucketSort(int[] arr,boolean ascending){
        if(arr==null||arr.length==0){
" ~1 W+ k8 f: Y/ E) M( z' H* t            return;
6 e. k6 H" I9 S7 I* @        }
5 N: N; d& D  Z        //计算最大值与最小值
: h& ]) c1 c3 P: q1 l  K  x5 }+ c        int max = Integer.MIN_VALUE;
  y$ y# s, J' {7 q' v        int min = Integer.MAX_VALUE;
        for(int i=0;i<arr.length;i++){
; \# Z3 g6 S0 L5 v, z1 A* `            max = Math.max(arr,max);
9 |6 o; N; l( @' S2 I5 M3 {            min = Math.min(arr,min);
        }


        //计算桶的数量
$ O; X& l& Y# y7 m9 m; S4 F5 k        int bucketNUm = (max-min)/ arr.length+1;
        ArrayList<ArrayList<Integer>> bucketArr = new ArrayList<>(bucketNUm);
2 T6 D6 E, q# l: G) q. ^2 U, V        for(int i=0;i<bucketNUm;i++){
            bucketArr.add(new ArrayList<>());
, R% G7 {& B) w1 E% u& P) _        }

4 h3 _0 B* ?/ P5 a% R+ [" ~
        //将每个元素放入桶中
        for(int i=0;i<arr.length;i++){
& B/ T4 Y& S- s4 X: [& h            int num = (arr-min)/ (arr.length);
            bucketArr.get(num).add(arr);
        }
5 l8 t( ^  e; X) ~  j

        //对每个桶进行排序
        for (int i = 0; i < bucketArr.size(); i++) {
. I4 |$ }; Z" X  R! x! m/ l            //用系统的排序，速度肯定没话说
            Collections.sort(bucketArr.get(i));
        }

0 n! \6 W; g2 C6 m, D
  j! _8 G( m6 }2 }        //将桶中元素赋值到原序列
/ C/ _8 ^0 u2 `) L- m* f        int index;
        if(ascending){
            index=0;
        }else{
            index=arr.length-1;
        }


1 ?& M4 M  `: g/ O4 H" n8 f        for(int i=0;i<bucketArr.size();i++){
9 A% T3 X; g/ O! k( O0 m            for(int j= 0;j<bucketArr.get(i).size();j++){
                arr[index] = bucketArr.get(i).get(j);
                if(ascending){
                    index++;
9 g2 Q0 {- X$ p: e( ~                }else{
5 O4 q9 x( \9 q$ C% d                    index--;
                }
            }
) O) b1 t% ]6 D$ y1 ?  y
- d( I2 a: {& Q- h) m/ U
        }

6 \/ F$ L1 ]/ R
+ g4 V) w; `/ P2 \7 i    }
}
1
- {+ v5 U+ f5 Y2 F! ?8 U/ h2
3
8 ], |# x# P$ ]' P# Z4
- X- Q- t% Z% i/ ~; _3 b5
; R) D% `; N! e6 B6
" j  n& n% H# H$ R0 G7
3 ^0 C* i! B' @; R3 P1 B1 ^8
* d8 T4 U  T4 |9
10
. t( t& S; x9 H  ?$ A. K  k" |11
" ]6 [" o# r  z" {+ I, V12
13
+ ~" l& z7 }3 E6 B  ]( y2 k1 X14
$ B+ t" ]6 h/ U4 m/ z" F- Z7 _* ^15
16
0 h1 A2 H* |; @# ~5 s17
18
' I+ Z! T% n  M+ Y! H$ f7 t1 t+ s19
20
7 E+ f5 O; F3 M  U21
22
: K+ f: s5 o& A9 B8 K2 h23
24
4 i! w! Z9 Q3 U25
26
* Y& ]5 |  q* N/ b27
4 v3 J, M2 |* O28
0 X: O% P0 |& `0 d29
" z) ~* d5 w+ s$ Z30
31
: v+ Y* y/ P: d2 @; v4 b32
33
34
35
36
37
) g+ R" ]9 b! h4 U3 p' L* V2 c38
- j9 ~, y; w3 f1 i9 R39
; q% `* r1 T! N- }; O; ^$ D40
5 }( P1 R( ~% n" W41
42
43
44
& @  ^6 Q$ n4 t/ Y3 ?& E! o45
46
3 ?" h. }: V- [( E47
- Q$ O4 g0 [* `( i$ I48
3 m1 O2 U4 V8 X. `49
* m2 z2 V; `7 D( u' n50
51
. H) T4 p5 u; r' f6 K52
2 Z3 J4 }; Z) X2 n. }53
54
, e" u' S* E7 ~7 [& h; A# R0 ~55
4 _+ E9 A0 Y) B, z56
57
1 O! x! @  u3 E0 S# c# R: F58
59
1 {1 @0 a- A5 b* j* N. p* N60
5 u7 m; P, t5 _61
62
% ^; q; r' z0 Z9 T4 U7 f6 C63
64
) W* y: G- z( V0 t  d65
, q) ^$ b* t* D- F& ^) x66
; w! I( v- |, u: U67
# H4 k# N5 J6 D& \) N68
; u& O- [. [8 t69
70
71
72
+ G2 \0 s, D. M2 i* J' y基数排序
简单解释：
9 ^/ Z3 x- C. q6 x# F- v' Q. _% w首先说一下，我发现好多人写的基数排序只能排序正整数，其实只要处理下就可以排序含有负数的了，就是我们排序前先把所有的数整体变大（就是减上最小的负数，也就是加了），都变成正数，然后排序好之后，在减下来（加上最小的负数，也就减了）就好了。
基数排序就是按数位排序可分为LSD（从最低位[也就是个位]开始排序）和MSD（从最高位开始排序），下面写的事LSD基数排序。
* Q0 {( x% B3 o, w8 R6 {& h% r基数排序就是把数按位考虑，让后我们一位数只能是[0，9]，就是我们在考虑某位（个位、百位· · ·）的时候就只看这个位的数，放到在[0，9]相应的位置，然后顺序取出，最后再按其它位这样操作（上面说了要不从低位开始到高位，要不就是从高位到低位）

; g( V* d+ Y  p# J& C) u8 B5 f

! _# U% o8 _! u; w' j
) Y+ a7 J  e2 ^) O8 T

7 W/ V, l0 ?2 h/ u; Y完整代码：
) Z4 w' x8 \. s
" Y/ v0 l9 @5 X6 s
2 z5 W) X) i! x+ O8 jpackage com.keafmd.Sequence;
4 m( P0 j/ ?& h& O

% l. ^: q( q2 ?$ e/**
* Keafmd
*
* @ClassName: RadixSort
* @Description: 基数排序
* @author: 牛哄哄的柯南
* @date: 2021-06-24 14:32
+ t/ Z* `1 P1 o0 G5 b) [) H */
public class RadixSort {
! D% z1 L: N/ A& L8 \    public static void radixSort(int[] arr){
8 J1 b$ A* O; a3 O' M( U- c        radixSort(arr,true);
; Y* M4 N! G! G, \% @    }
& W: I2 c9 b8 ?    public static void radixSort(int[]arr,boolean ascending){
        int max = Integer.MIN_VALUE;
        int min = Integer.MAX_VALUE;
        //求出最大值、最小值
        for (int i = 0; i < arr.length; i++) {
            max = Math.max(max, arr);
( O% Z: u3 E4 b$ t& @5 u            min = Math.min(min, arr);
. j1 t) ]4 O/ Q: u& k        }
. O4 h! r8 W8 p        if (min<0) {        //如果最小值小于0，那么把每个数都减去最小值，这样可以保证最小的数是0
            for (int i = 0; i < arr.length; i++) {
: r4 e( x! C! s                arr -= min;
            }
4 G6 z& }: c/ ^7 W% l3 S            max -= min; //max也要处理！
" |2 ?3 u4 Q9 {        }
# H" B8 I- G+ g. M7 f        //很巧妙求出最大的数有多少位
        int maxLength = (max+"").length();
        int[][] bucket = new int[10][arr.length]; //一个二维数组，一维代表0到9，二维存放符合数
% R: B. h- E. q7 O# w6 m        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++) {
# s" ?7 p$ S7 h8 O0 t                int value = arr[j]/n % 10;
4 d5 J, ^# h" l$ n) s                bucket[value][bucketElementCount[value]] = arr[j];
                bucketElementCount[value]++;
            }

) P; H  i; g9 t2 v4 o3 s# x3 n) b5 T
" R8 h. Z$ l' I' h5 v! |, B            //升序
            if(ascending) {
                int index = 0;
                //从左到右，从下到上取出每个数
  S1 i" |3 K& w, i  {2 o3 G                for (int j = 0; j < bucketElementCount.length; j++) {
                    if (bucketElementCount[j] != 0) {
                        for (int k = 0; k < bucketElementCount[j]; k++) {
0 ^5 d3 |: n0 [6 |9 E                            arr[index] = bucket[j][k];
                            index++;
                        }
/ q! t  X! b" Q4 v: U9 g                    }
: O9 O$ u. t8 u3 o                    bucketElementCount[j] = 0;
% x/ z2 U; s: C: s& \                }
            }else { // 降序
                int index=0;
                //从右到左，从下到上取出每个数
8 L! R' w) w; }$ r& }+ @                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];
3 i! m" L1 e. ^8 a$ b: w                            index++;
) `2 N& y* G; Y                        }
                    }
                    bucketElementCount[j] = 0;
                }
            }




            /*for (int i1 = 0; i1 < arr.length; i1++) {
                System.out.print(arr[i1]+" ");
            }
" v6 G# t9 L7 P0 b5 _" }  V: E/ H            System.out.println();*/
) ^# c# q, B) w

2 c' N( B7 w' y2 i
1 t, r; e) H) |: w8 D7 ^4 }


$ ^; B9 @7 P6 D/ B; Z        }
( l- F6 t* W" }$ `- k        if (min<0){
( t, Z8 k0 y5 D            for (int i = 0; i < arr.length ; i++) {
: ^$ |* t( j' D" a! o                arr += min;
8 z) J/ H. z) j/ F# ^5 M- U4 R  ~            }
        }
& y7 E) W/ m0 o3 V% J' X) U5 P. }$ |

9 m% @8 e$ p" E9 u* d# t3 T    }
# g/ w. o' _& k. ]  C2 S}
5 q  D2 G. {9 O1
2
; C! W1 z0 K0 S8 ]& Q; l3
4
5
# q( Z5 z; j  r4 ]! R9 y6
7
7 {, R5 z, V" y- L$ d. ?8
9
10
11
. E4 S" A$ @9 `- T% s! o12
' |& {* h3 R1 a+ s! E13
14
15
% @- \4 a; i. W- B. z* \16
% P8 \+ p8 a$ `  k8 M9 e17
1 T  M" @2 W1 S) |/ G7 |/ I18
19
8 Y# d, v8 o5 A# a20
21
22
23
$ q% v% Q1 }3 w/ l3 c; W24
' k- t' |/ X9 K3 I2 N  D- _25
5 D' `" G$ E7 w* s) u4 h, P26
27
28
! O. X, y  N2 k( {29
4 E. H5 p6 X$ F- z, `30
31
" L( ?# ~9 S# l, l& j0 K32
33
2 c- X8 t/ o( [" g+ [4 m$ J34
35
36
' G$ l( Y8 \( d% @6 f7 A& X37
38
8 p! p8 q4 t2 M& N$ q$ q: n" w% B39
$ v: l; K) K4 X9 j% b+ p40
41
9 v9 p2 z  z' v42
43
44
# p1 L9 c2 ^, W6 ~* i; P; e$ W45
% y8 l' y! |) V8 R4 T/ h46
0 u/ u+ `/ K/ Y! I+ I/ P0 ]47
48
49
50
51
4 Q1 r  m! K6 W52
% j$ \4 u4 v4 B8 _53
; c$ m3 M; E$ E54
6 p' K- g4 Y/ L! E- b55
7 @& U" [1 `  J2 H' R: a56
0 C% u0 h- Q/ v5 B* a% Q8 Y57
58
) u8 q6 a) s1 |0 u3 g  O& q59
# C' Z+ `5 @& a+ g60
61
62
' k7 c4 S- d/ v& a  k! d63
64
* O" [' V( S1 {4 p! V+ E9 R65
66
67
68
" p4 a6 j3 q, U3 o0 V69
70
71
72
7 {- i& g% p& G0 I/ t2 u+ k4 L& I73
! R+ r( [, m  U74
4 O9 {  {. o* ~$ r; m75
76
77
78
! ]: z' D8 v( U79
80
81
! j, k+ H& Z, {0 e2 Q82
4 I& l' E: B7 X) q7 \5 v83
完整测试类
0 W9 r- R+ z9 z7 k7 [4 Fpackage com.keafmd.Sequence;

3 e2 [6 h9 C0 `) O+ P0 S% J
import java.util.*;
! T$ T# \: S$ G/ J" [import java.util.stream.IntStream;
! L( g; I4 G7 o# ?) \import java.util.stream.Stream;
2 J/ M- v; o3 {. Q* q$ [5 {

/ Y& K9 ~7 X5 M/**
3 S# F8 T3 f. z$ C4 s' j0 G' Q * Keafmd
/ I6 A; F/ D1 B4 _, [( ]4 t *
* @ClassName: Sort
8 O+ c1 g/ L! `! P) r; B * @Description: 十大排序算法测试类
* @author: 牛哄哄的柯南
/ }& G/ R* V1 g) Y; J% V! V6 I * @date: 2021-06-16 21:27
*/
public class Sort {

  a: \$ h, f' F  A$ }, R0 b
- o! Y+ I1 Y! T  ~4 S4 Q5 K8 i

( ~* @4 c! d: @1 D3 H    public static void main(String[] args) {


% m: V( \5 W/ ^4 r, p: E1 S6 k        int[] nums = {12, 4, 25, 47, 58, 34, 25, 9, 99, 26, 1, -13, 162, 10093, -66, -1};
* e% w2 x* e0 J: X( D//        int[] nums = {12, 43,56,42,26,11};
4 y" m6 m* n0 c0 W3 [. s; w        int[] temparr;
/ k. B; B0 E4 Y) _$ F( ?

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

- V0 b9 v4 }8 {' }6 M! S7 K
        //将int数组转换为Integer数组
        //1、先将int数组转换为数值流
        temparr = nums.clone();
        IntStream stream = Arrays.stream(temparr);
        //2、流中的元素全部装箱，转换为流 ---->int转为Integer
        Stream<Integer> integerStream = stream.boxed();
8 N% q( l: ~* C9 I. ^8 P, `& C        //3、将流转换为数组
        Integer[] integers = integerStream.toArray(Integer[]::new);
        //把数组转为List
. K2 d' M. G4 F2 f# f        List<Integer> tempList = new ArrayList<>(Arrays.asList(integers));
        //使用Collections.sort()排序
        System.out.println("使用系统的Collections.sort()的对比:");

$ T- n! f6 a2 _
" ]/ ]6 F& D, I        //Collections.sort
3 J% d( T4 m) G' M        Collections.sort(tempList, new Comparator<Integer>() {
$ N/ C7 {! ~- f. z$ m  _            @Override
            public int compare(Integer o1, Integer o2) {
                return o1-o2;
                //return o2-o1;
" ]4 K' _) o- R7 K# R            }
        });


        //tempList.sort 也可以排序
- \1 o/ W5 G* X$ l! a$ n       /* tempList.sort(new Comparator<Integer>() {
            @Override
( }4 j" b! B2 ~2 V9 [+ |; n" @% U, u            public int compare(Integer o1, Integer o2) {
6 o) N) j; B" s% P* T" d* I                //return o1-o2;
                return o2-o1;
            }
        });*/

( ?) l2 n( a. d
7 M7 Q5 x% m4 k        //遍历输出结果
        for (Integer integer : tempList) {
            System.out.print(integer+" ");
( P) `$ i/ ^5 [6 G# A4 v- m        }

% p# Q: X0 i1 U; F/ O
5 w+ \4 o4 C9 V9 }, O, |        System.out.println();
: L* ^; a- z4 ?4 M

        //测试冒泡排序
) `* E: ^2 a- f+ r. d' i9 Q        System.out.println("测试冒泡排序:");
( }. i# R7 ~4 w$ Q# V1 s8 |        temparr = nums.clone();
. d( _  Z, Q2 ~9 v3 p9 D* k; f6 e
  _8 K; v. z, V- O9 I: j
+ V, W- \; \0 W0 ]$ Y        BubbleSort.bubbleSort(temparr);
& Y1 E% _; l0 l1 N* J
" h- Y5 x7 u7 W
9 u5 {* P) {3 J' W. a7 ~        //降序
# c$ B! L' D; x. x# J  ~        //BubbleSort.bubbleSort(temparr,false);


" l% t, c3 y" L9 }3 b6 ^( X        for (int i = 0; i < temparr.length; i++) {
9 C7 L& p7 Q) c! [; b  D( r0 Q* Q            System.out.print(temparr + " ");
        }
        System.out.println();
+ e/ |5 H! B2 |/ J3 S

/ h$ J! i! Z$ X4 V/ Q        //测试快速排序
6 x( H- K: ]5 A9 V3 ]8 I; Z6 z        System.out.println("测试快速排序:");
        temparr = nums.clone();
* w$ ?- W) Z/ s) K        QuickSort.quickSort(temparr);
        //QuickSort.quickSort(temparr,false);
3 Z; F7 t! ?* n. d        for (int i = 0; i < temparr.length; i++) {
            System.out.print(temparr + " ");
, Z. W$ Q4 J# b        }
' {, t4 b' ?6 I0 F- q* ~        System.out.println();
' @2 f2 A' O! {% v, p& ~

" c0 f! |+ D" M1 K9 }4 T        //测试直接选择排序
2 b; T3 M1 ]0 |6 S        System.out.println("测试直接选择排序:");
        temparr = nums.clone();
, T4 S; E) y! P( Y$ R% W        SelectSort.selectSort(temparr);
* S- s) n4 H, U- V3 y1 a% f        //SelectSort.selectSort(temparr,false);
3 ]- h! [8 r+ s4 D. ?3 \) ]        for (int i = 0; i < temparr.length; i++) {
7 o& W, @, I! W% r% X, }3 B9 t9 \            System.out.print(temparr + " ");
        }
        System.out.println();
+ H( q, {! D$ c# c
' l; E, X! Q( {8 Z4 E+ d& Y/ C. |. z
        //测试堆排序
( }( K4 q% h# T- G        System.out.println("测试堆排序:");
) t# L, \* K  }0 A4 i* e        temparr = nums.clone();
        HeapSort.heapSort(temparr);
        //HeapSort.heapSort(temparr,false);
1 o# q9 U+ X- @0 n# _- V& S        for (int i = 0; i < temparr.length; i++) {
4 q6 N9 Y  b$ b' D! r( ~            System.out.print(temparr + " ");
2 f; Z5 ~+ ]# F1 u- h  h; t        }
        System.out.println();
# ~7 U: C- L0 f% }( a$ Q
( [  A. \/ i. E) B% T* F
        //测试归并排序
6 n, i8 o6 K$ v9 H. b        System.out.println("测试归并排序:");
        temparr = nums.clone();
4 L; L; B4 k+ E/ x- ]* s& ?        MergeSort.mergeSort(temparr);
        //MergeSort.mergeSort(temparr,false);
        for (int i = 0; i < temparr.length; i++) {
            System.out.print(temparr + " ");
$ Y3 P: ?# t$ b        }
        System.out.println();
# v' K  ]  I, ~2 h# u& O

' E4 A( t/ P; [* U0 z& q        //测试插入排序
+ O& M' P. @& j$ Y0 p/ x        System.out.println("测试插入排序:");
        temparr = nums.clone();
1 T' h0 Q( M" v$ E        StraghtInsertSort.straghtInsertSort(temparr);
! [& H% e2 F0 Y! C) w* C, z$ T5 B. {0 Z        //StraghtInsertSort.straghtInsertSort(temparr,false);
        for (int i = 0; i < temparr.length; i++) {
            System.out.print(temparr + " ");
8 |1 d& l3 r( k6 c4 k; [# q        }
4 E9 N: p' c! b. [6 R1 P        System.out.println();

3 a, D# \. |7 J


5 m7 w& K! U3 e2 N2 |$ J! f# V        //测试希尔排序
- `3 n6 A$ I7 c        System.out.println("测试希尔排序:");
        temparr = nums.clone();
8 U( W) @: R9 X4 i$ U5 h0 E        ShellSort.shellSort(temparr);
        //ShellSort.shellSort(temparr,false);
        for (int i = 0; i < temparr.length; i++) {
            System.out.print(temparr + " ");
        }
9 w  x" E* P5 O0 j( ~$ r# r        System.out.println();


9 k5 A5 T6 }* x4 c/ q3 z
, T$ i- r/ W; B
( l( o6 }" Q1 E+ u) G$ h7 d4 U$ Q        //测试计数排序
        System.out.println("测试计数排序:");
9 A0 p6 ~6 U! Y0 g5 m8 \0 p8 E        temparr = nums.clone();
        CountSort.countSort(temparr);
$ C* }5 q+ C  Z( z        //CountSort.countSort(temparr,false);
3 l9 M" ^8 U$ N( x& e5 Y: k        for (int i = 0; i < temparr.length; i++) {
            System.out.print(temparr + " ");
        }
9 j: {3 }0 Y  q7 o  [        System.out.println();
) |" y: v, J. q$ b- T) T

8 g, d& k0 i  m/ D
' b" L. ]: F- G6 ~; L
" Q8 d/ n0 N7 R" K0 q        //测试桶排序
        System.out.println("测试桶排序:");
        temparr = nums.clone();
" _, r( Z: r6 P" |8 o        BucketSort.bucketSort(temparr);
" n" c# w5 ~: f6 M        //BucketSort.bucketSort(temparr,false);
        for (int i = 0; i < temparr.length; i++) {
+ w! Q6 g$ I+ Z$ i, @! Y) _# y            System.out.print(temparr + " ");
        }
        System.out.println();
. k; q6 w6 @! H) H
/ H* @# K+ c. p3 E
        //测试基数排序
2 p2 G* E$ ?. i, K6 U        System.out.println("测试基数排序:");
        temparr = nums.clone();
1 F+ u" {6 x" J. E% a        RadixSort.radixSort(temparr);
0 a8 N1 s' }2 ~3 P3 H9 X        //RadixSort.radixSort(temparr,false);
" s( T  h. O  f0 W- C        for (int i = 0; i < temparr.length; i++) {
            System.out.print(temparr + " ");
        }
        System.out.println();

# J: X$ Q+ o. H8 U( z( O
    }


3 W! G+ t, p% }) R; P1 l% |; Q}
1
7 I# T9 X1 w3 \9 J; w2
3
$ [' P4 _- e3 Q$ o# ]4
/ ]( S- u! W9 e0 t* a9 o! C; N- h5
8 F  M3 p4 M0 q! Y; ~6
/ O- v; h/ i. m: h. w. m7
- i) P8 R( a3 u7 N, q9 v$ Q8
4 B6 L0 J" G4 i7 H: x4 B3 S# ~; o( \9
5 j; E% j; s4 J) h- ?" L10
# `, b- q" ~7 e: I. g4 e11
0 K% h8 P4 A: |5 v12
' W1 E: z7 Q& D4 R3 e# A8 p13
) P/ g6 f/ Y) y; Q8 i14
15
0 q  }8 X: O! ]' ^( m# ~16
17
18
# h! C7 V4 |% S- v0 U" ~19
20
21
2 e1 f& O4 M6 E$ E7 c  V0 @22
% J4 U& p! t2 u2 W8 ^23
/ Y% C# R- D) x5 k( y5 T0 d24
25
' N  v: ]9 t8 X9 U2 o26
27
# ?! B' T. r( f28
* D3 z" A( c: C& B/ E3 _, f/ @; B1 M29
30
31
32
* d6 D9 E6 [2 R8 Q/ S. z" Q33
34
( S6 h+ l% R( i1 H8 J! N35
+ H- }) F# _& S& z1 c$ z& N36
37
38
39
: h* _+ n6 [: `$ R40
4 Y( V' G0 [- L, C41
$ {" `) l4 S" u2 }8 a) m" v, ]42
43
5 a4 V4 I! W7 o+ q4 h$ u44
45
$ W( T$ i0 G; O46
; k. X* F+ f0 E' ?, E5 @47
$ b0 N! J7 [% a! D6 R, \7 d: H$ `48
49
50
8 K  d' Y1 _2 h+ T/ m& A  |51
52
( R- M& {% C0 Y' O. q53
: b9 I2 D! ?: V: V9 a54
55
2 N: {6 K! Q# I' W/ T. T56
57
4 C2 U) s3 x2 g- V; t" Y0 O; w58
59
60
61
62
63
64
65
1 V# k. a! N9 m/ L4 h, c66
67
' q( y7 T+ I' l) j* \. p* i* [$ Y3 p68
" g5 I, Q8 b( w2 B- Q/ f69
6 g; S: Q% l2 Z# x9 C/ g70
71
7 B7 J) v3 H2 S1 l* C& d72
73
% [+ j9 [& }1 L3 |& \! h: ^  G, O74
75
76
5 C! N( i! L( X, u! i% _77
78
79
80
81
82
% t" i5 k- v/ t, p6 |5 `( ^' E83
' _( z# j2 b* ^8 n  h84
85
8 X+ L9 H! l2 \' G; O% d86
87
88
89
90
91
. B1 @2 z. o% q5 _4 _92
# B7 A8 W8 [* g1 ?  n93
2 b6 T" A+ m1 o. W, y4 `94
4 {" o3 f) E$ V7 P8 x, R95
96
5 u! r  _1 E- f  [  R# V97
9 @8 O# \9 X3 j1 n98
99
& A4 b8 y: V5 ~6 J- M+ y; i/ r' R100
101
( \0 w7 O- n, j5 g# Y; _! ^102
6 l  O4 }9 B$ `8 g* [103
7 h1 Y1 {4 c* M) Z& z104
105
, u1 B0 z1 Y# ]) I0 D1 e6 Y106
107
; \4 F: H) W3 d; j+ X108
109
110
3 Q* z9 q, [% }% K" P: O0 L111
112
2 w; m: t, q* L: ~; ]113
' m8 @' z# E# t( p# O114
& a( a' J! B  q1 F115
116
117
8 D3 Q4 [3 l( Y118
4 X4 C% {' C$ X' r119
120
& r' a7 @( b4 B* {; A# B121
122
123
8 f$ c  M. v2 A4 v4 c# n9 m3 d- r124
6 I3 z  F8 q3 K; k& H125
; ^7 ^+ Q2 M3 |+ z% y" \3 E126
% `2 p# g8 L% w/ ?$ N127
128
129
130
131
: Q( M" ^3 E9 `) T9 S1 A132
/ a7 M0 A' j5 i0 F133
134
) z. ~9 v* m8 {135
136
137
138
, u2 Z! F# i  d* w8 ?139
# D0 c2 I0 L6 m' c140
141
142
; O* Z, ]2 M  X143
+ j3 p8 z! R- T8 r& W) @, `144
145
/ ?! l9 s1 A$ g146
& Z0 R: Q3 {9 Y: A0 d  R: F+ w- I147
148
0 X  S' \2 h* @+ E) ^; L$ t% g# O149
150
, N# L% Z# u) }6 j3 g151
152
153
154
7 u9 O* {! l( q) d4 }* L1 C: V155
156
( r; I8 a- s' O% J157
158
159
160
161
162
163
* D! A, N: p9 }( k. T164
4 [4 a5 p  H# X7 j165
166
3 ]& M8 F& y* F# T( l( I3 B9 g. Y167
2 Q; l/ D7 n2 `# b7 L9 V& f5 d168
169
4 G( C$ n5 y5 w170
% P- n7 m3 O# ]& P- j& W171
172
173
6 U: q) K# \3 Z# r: Y每天进步一点点！
不进则退！
- v7 Y/ \4 `4 ?

5 e! e& L8 ]# D& [$ m: v" {版权声明：
原创博主：牛哄哄的柯南
7 `- U5 K" e3 x3 z2 Y- t$ l博主原文链接：https://keafmd.blog.csdn.net/
8 q' v6 P: c/ f————————————————
( ]3 a% h9 ?2 ~0 y% {! {  s2 j% V2 N版权声明：本文为CSDN博主「牛哄哄的柯南」的原创文章，遵循CC 4.0 BY-SA版权协议，转载请附上原文出处链接及本声明。
  s( u; n; [5 g( y2 Q9 y4 A原文链接：https://blog.csdn.net/weixin_43883917/article/details/118193663
+ @4 H* k7 W2 p& F: p
9 a6 I8 m  q; |
7 `2 Q9 w; Z, W6 p6 R3 C

1051373629

每天进步一点点！