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

杨利霞

经典十大排序算法（含升序降序，基数排序含负数排序）【Java版完整代码】【建议收藏系列】
) g) |* s3 t/ k经典十大排序算法【Java版完整代码】
) k7 D& C5 a: m( }* ?; k2 h) S写在前面的话
& u8 v; v6 l& s  K& B' B十大排序算法对比
冒泡排序
快速排序
直接选择排序
堆排序
归并排序
- R( K+ @' _; _) g! p插入排序
希尔排序
& t* U! a/ E' Q) n- {计数排序
桶排序
5 _2 j3 i$ ]6 \; S7 o  e- q2 B基数排序
& y2 ?% F: t7 ^! h2 J1 Y完整测试类
/ f, O3 f/ y" f" G+ L' j$ U4 d) i写在前面的话
1 Y/ W8 ], }5 P! s* v6 V2 Q- A       虽然已经有很多人总结过这十大排序算法，优秀的文章也不少，但是Java完整版的好像不多，还存在某些文章代码存在错误的情况，同时也为了自己练手，决定把所有的写一遍巩固下，同时也真诚的希望阅读到这篇文章的小伙伴们可以自己去从头敲一遍，不要粘贴复制！希望我的文章对你有所帮助，每天进步一点点！！！


9 n4 E! l; w! h       我用通俗的理解写下对算法的解释，对某个算法的运行过程不是很理解的话或者想看比较官方的解释的话，单独搜索某个算法，看几篇不同的解释，就可以有自己的理解了，这里我主要展示代码以及进行通俗的解释！整起来，再强调一次，一定要自己敲一遍，这样才能理解的更深刻！

3 b0 X/ I: e! h( u  c( g& b& n) q! {
十大排序算法对比


& r3 K) c2 l' [8 E+ s8 Z6 z

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


$ a9 `- J% C0 s6 a$ }+ J冒泡排序
简单解释：
) R/ E1 q9 w* v) G# H% f       原理就如算法名字一样，就像水中的气泡一样，每次我都把最大的或最小的放到最后面，这样总共需要n-1趟即可完成排序，这就是第一层循环，第二次循环就是遍历未被固定的那些数（理解成数组左边的数，因为每层循环都会把最大或最小的数升到最右边固定起来，下次就不遍历这些数了），两层循环遍历结束后，所有的数就排好序了。
       两层循环所以冒泡排序算法的时间复杂度是O(n 2 n^{2}n
; t) ~2 ]2 e+ i3 }; s/ F( L3 x2
; F( f: t( s6 n+ X2 p )，是一个非常高的时间复杂度，我在下面的代码进行了优化，加了一个标志位，如果上一次循环未发生交换，就说明已经是有序的了，就不继续下去了，反之继续进行下一轮。


! n2 T. }0 v% Q; {
* R) x3 y; U+ e9 G
% R/ k! c! J* T0 U$ k4 s6 I1 f) x
* A: v' t( t' h! }* [1 O
本文的图片来源网络，仅用于大家学习，侵权联系删除！（下同）


# N7 ]1 H, {1 q# i/ L完整代码：


9 N4 d, k1 W/ l" l- }- S2 ?package com.keafmd.Sequence;


/**
* Keafmd
" m$ x% }8 c6 {% _0 } *
) ], a7 x& w" y2 C * @ClassName: BubbleSort
* @Description: 冒泡排序
9 Q/ c' W4 M+ @3 _9 E$ T  l * @author: 牛哄哄的柯南
* @date: 2021-06-24 10:31
*/
- [5 `6 o% P& I) K% x8 L& t4 Jpublic class BubbleSort {

2 A! P) G' W% n& j& x% a
3 }4 I( E) s) i" K! Z  x    //冒泡排序
$ l' Z. I6 t5 v( r6 W. u* s* j+ s7 K    public static void bubbleSort(int[] arr, boolean ascending) { //exchange标志表示为升序排序还是降序排序

1 f% e+ n  m$ A4 z6 x4 K. ?
        boolean flag = true; //加一个标志位，记录上一次是否发生了交换，如果是，我们则进行下一轮，如果没有，说明已经冒泡好了

& ~6 v2 t$ i4 s1 b. v
$ y0 {# s2 ^6 M; ^  \        for (int i = 1; i < arr.length && flag; i++) { //控制次数，第几趟排序，只需要n-1趟，有交换时进行，只有flag=false就说明上一次一个元素都没有进行交换


            /*System.out.print("第"+i+"次遍历：");
            for (int i1 : arr) {
. i/ ?1 G6 ~( k( {( |* Z) a. E2 I                System.out.print(i1+" ");
4 X7 i- T' V7 K5 K            }
            System.out.println();*/

5 p- Y7 p( }" W
" w7 i: C) r2 |7 P" v( F            flag = false; //假定未交换

* N- E3 s5 G& P$ O7 T/ v& _
. E2 _# L& u  ]# M0 n! D- z& W            for (int j = 0; j < arr.length - i; j++) {

3 o' Z5 @& {3 y$ F( W
                if (ascending ? arr[j] > arr[j + 1] : arr[j] < arr[j + 1]) { //控制升序还是降序
% }! w$ z8 L& K; d                    int temp = arr[j];
                    arr[j] = arr[j + 1];
                    arr[j + 1] = temp;
% C* v4 d4 C; P' N* [                    flag = true;
+ X$ @8 L% V  k2 C5 ]                }

6 Q) Z  ?9 X- I) S' N  X7 B
) G$ b( |0 i; m* J; d, V; K/ L/ J            }
1 g5 t( h9 g  Y+ u0 _1 J        }
8 s% a# Z* j% t7 m; k" D/ Q    }
7 E: G( ^5 i2 N8 C7 G

1 N3 \5 r' l" W, l6 m$ `    //冒泡排序 -- 默认不传参升序
    public static void bubbleSort(int[] arr) {
        bubbleSort(arr, true);
0 w" s* [. [; b# u' k+ }    }
+ i0 J3 ^4 k* @}
1
2
+ [$ g. E9 K7 l5 v- o3
# v4 ]5 b$ S/ P: B4
' M0 O/ F! N' R, T' W3 m, t5
6
7
8
4 D4 o* s. g) z7 s' o9
1 H1 v' T; m0 d. B( r2 y. C. r8 e10
11
12
13
9 [$ z1 S4 `& }% d$ f" z9 x14
, P% |/ S, B$ t' L9 z15
, x* C- A0 }' n  k16
+ p' T9 ^) g1 ]17
18
$ a- v. x: G; f% A5 ]$ X5 j2 n19
20
! B" f0 \- S" U! n4 r! r3 b7 ~21
22
23
  ?- l% y" d1 Y4 Z24
25
6 i, r. f, c/ |3 c, O26
27
& u8 \" k7 z" w0 n1 G+ H$ |& _28
29
/ y/ n& v, o$ K5 J8 Z30
31
32
33
( O$ q9 x9 n3 o, D2 P- a9 e* d  z34
- Z; X/ D! o0 ]6 b! e, H35
36
37
# f0 ^; n1 C7 b2 c6 K0 n+ W38
39
1 y( e( [2 r7 x; Q" ~40
41
8 O6 j# C. U: w/ _42
) Z' ]0 X6 ?) b. a4 O7 x! p2 w43
44
* x, A: \7 ?6 F' ~. ~1 r45
测试代码：
1 {. ^! |5 K( \* Z
9 f/ R2 `, v$ F3 Q$ z# m
升序排序（从小到大）


package com.keafmd.Sequence;


1 b6 H9 D0 H% A; _" Aimport java.util.*;
8 `# ~6 X9 O/ V. Q; dimport java.util.stream.IntStream;
import java.util.stream.Stream;
4 O7 s) E7 H' T3 h; E9 s

/**
" i8 x, t- f) O2 k! v' T- n4 q: m: w * Keafmd
*
; ~; O5 t; L1 C2 K * @ClassName: Sort
/ G! j( r' G) [5 E, p+ S0 f * @Description: 十大排序算法
* @author: 牛哄哄的柯南
* @date: 2021-06-16 21:27
! m" ?+ c5 i& ]4 \  z4 X  e */
public class Sort {
- {8 d& I7 s9 J# m    public static void main(String[] args) {
1 P+ Y# z( {: G) j5 k
: e0 J. y- H2 z% E( r" T, P; N
8 @+ h( R$ J+ @6 `. ]        int[] nums = {12, 4, 25, 47, 58, 34, 25, 9, 99, 26, 1, -13, 162, 10093, -66, -1};
        int[] temparr;
' `, Q* b$ x  A! a
" _! L. t3 p. {+ r1 U8 `
        //测试冒泡排序
8 T/ u- J, i2 U" b+ H        System.out.println("测试冒泡排序:");
7 O! \- U2 R2 m1 v        temparr = nums.clone();
        BubbleSort.bubbleSort(temparr);
        //逆序排序
        //BubbleSort.bubbleSort(temparr,false);
( Q- e2 [8 i% ^, W5 \0 d  ~# w1 V+ B        for (int i = 0; i < temparr.length; i++) {
% G1 M4 s/ d& y! S3 T$ U7 N            System.out.print(temparr + " ");
        }
9 P& O: Z  f, f# }. W1 J        System.out.println();


    }
- ^: Q$ P# s. `3 V. t4 G2 i+ p$ U}
* I. k8 @3 Z5 |1
2 n+ a( w" a) k4 p- N) [2
2 l$ S6 {( P2 R3
2 I1 r; S4 A* O  a" s4
5
6
/ y/ V8 d  |# ^; M2 u3 i7
8
9
10
11
12
, N3 k( T: t6 _/ q( E$ Y$ ^13
2 k. |  _6 n. i4 `% V14
/ ^# N( }3 |8 B; z9 C; g15
16
, h2 E9 G6 n- D3 T* B17
. H8 f) O: H! ^3 q4 X) }6 E18
19
( K  }5 C$ P1 t! k& w/ e20
9 ?7 s, @! |: _4 V3 p/ y21
22
23
4 P$ ^( t& o( a3 x; l24
  W, J+ O3 i% @% f) a. z25
26
& ?2 v' I- e1 ~% W27
28
29
( ?# D% ?1 p, [) X5 x30
% R% i, z% G0 \  j. L; Y31
7 i2 G6 t. ^. b8 m32
33
运行结果：

% M9 \& w# d2 V! O8 u+ q7 I/ x
6 ]. r  }9 S" k: _+ b测试冒泡排序:
" B% Q% I$ F) I4 \) ?; G, A6 U-66 -13 -1 1 4 9 12 25 25 26 34 47 58 99 162 10093
1
1 S. Y/ X/ f$ y2
( F+ z  N. f1 d& V- G降序排序（从大到小）
* T% z4 U' U0 z! m( O* J

//测试冒泡排序
0 u# r  P; F! {! P, @1 T  fSystem.out.println("测试冒泡排序:");
temparr = nums.clone();
) k% w0 J2 |# OBubbleSort.bubbleSort(temparr,false);
7 b& Q0 J' z8 S8 B0 D8 ]9 P' `for (int i = 0; i < temparr.length; i++) {
    System.out.print(temparr + " ");
3 Z4 J. V; |8 l2 t}
System.out.println();
1
& E% ?& D& F& F; q2
3
4
5
6
7
8
; Y7 A" y+ e6 K$ i运行结果：
# n2 T6 ?" u) \$ `2 @
* W) ~/ n4 I1 V2 b
5 N6 C0 [1 u/ X9 w测试冒泡排序:
10093 162 99 58 47 34 26 25 25 12 9 4 1 -1 -13 -66
' \0 g+ F6 n2 S, ^5 r9 T" d1
9 F8 q  e' W0 x) z2
: b% X) f* e+ @! g" r9 X下面几个算法的测试也就是换了下类名和方法名（换成相应的排序算法），如果想降序就在数组后面传个false即可。我就不一一复制了，我在最下面给出含所有算法的测试类，需要的自取即可。


% h2 r$ u+ A; w3 M' d" \# I快速排序
简单解释：
快速排序就是每次找一个基点（第一个元素），然后两个哨兵，一个从最前面往后走，一个从最后面往前面走，如果后面那个哨兵找到了一个比基点大的数停下来，前面那个哨兵找到比基点大的数停下来，然后交换两个哨兵找到的数，如果找不到最后两个哨兵就会碰到一起就结束，最后交换基点和哨兵相遇的地方的元素，然后就将一个序列分为比基点小的一部分和比基点大的一部分，然后递归左半部分和右半部分，最后的结果就是有序的了。

' i9 U% p+ F! P) z% i: y
2 v$ i5 b; n* t6 H- u- d
) V# J( Z; B9 z* m. ]3 K

, n! r8 D6 A' |2 M) k0 q
' U' S: X( L6 o  L6 A0 P完整代码：


package com.keafmd.Sequence;

! Z8 J# a+ a% ]; A, W, \
/**
* Keafmd
*
8 y! b+ R3 J: G2 ?9 d; s% E * @ClassName: QuickSort
: \/ ?' g1 z' I- ] * @Description: 快速排序
* @author: 牛哄哄的柯南
6 Q/ |- U5 `# d# p, c% }% x * @date: 2021-06-24 10:32
- C: w3 [; x0 C4 V2 G4 d: | */
public class QuickSort {
: J" _( ]( X. s6 a( }. m3 z1 S4 h

    //快速排序
6 o- q$ `6 s. L1 |    public static void quickSort(int[] arr) {
        quickSort(arr, true);
, J; I' T# O; G& K- t    }


0 }- Y/ }6 @2 Y6 a. b" |) k    public static void quickSort(int[] arr, boolean ascending) {
        if (ascending) {
            quickSort(arr, 0, arr.length - 1, true);
        } else {
            quickSort(arr, 0, arr.length - 1, false);
$ G7 T5 w4 x; D2 v# P4 ~, I        }
    }

9 n% w! w5 G' V
    public static void quickSort(int[] arr, int begin, int end, boolean ascending) {
: v1 s+ K# o; E& t        if (ascending)
3 N; x  v5 t' b0 _5 T- A            quickSort(arr, begin, end);
" h  q. R. s/ G        else
0 c: v. [1 D4 l            quickSortDescending(arr, begin, end);
    }

: U/ b$ B; E4 u% _* n9 o
, r8 C$ B& ?' a2 d2 M6 }    //快排序升序 -- 默认
    public static void quickSort(int[] arr, int begin, int end) {
  p& I" A* f- h) P3 M* I: r        if (begin > end) { //结束条件
            return;
, ^7 f) U" t; p4 Q% i        }
# n9 S; n2 G5 l% K2 c! V        int base = arr[begin];
        int i = begin, j = end;
3 R' h2 e0 a. M9 D1 r        while (i < j) { // 两个哨兵（i左边，j右边）没有相遇
            while (arr[j] >= base && i < j) { //哨兵j没找到比base小的
                j--;
$ `% F0 Q7 H8 ?            }
8 u4 H8 C4 M! P2 Y8 B            while (arr <= base && i < j) { //哨兵i没找到比base大的
! D+ d5 z+ z) ~  V0 J6 W  q) b                i++;
            }
            if (i < j) { //如果满足条件则交换
                int temp = arr;
4 M1 f( M1 J: f" V4 _0 J                arr = arr[j];
1 ]: E/ A. }/ C& U$ R; q9 ]5 l7 G9 f                arr[j] = temp;
+ w* `6 k5 R" a6 i            }

, a: I, o+ D  V" [
& a. |4 L; k. J0 A2 o: r! u  }        }
. v7 D+ m' |$ B" W( B1 \: v        //最后将基准为与i和j相等位置的数字交换
        arr[begin] = arr;
+ F  o, |, w  Z, R* C        arr = base;
! F8 t# h4 W  n+ q3 t        quickSort(arr, begin, i - 1); //递归调用左半数组
        quickSort(arr, i + 1, end); //递归调用右半数组

. n7 _- c! d4 b
- C0 K' j6 G: `- A% J" Z. Y    }

" q6 y; x. \2 I
1 x5 L+ v$ A: `    //快排序降序
5 O2 N. P  a5 }8 K- e' ]* j    public static void quickSortDescending(int[] arr, int begin, int end) {
        if (begin > end) { //结束条件
            return;
        }
        int base = arr[begin];
        int i = begin, j = end;
        while (i < j) { // 两个哨兵（i左边，j右边）没有相遇
! D0 F$ A% [: F* ]0 B& f            while (arr[j] <= base && i < j) { //哨兵j没找到比base大的
                j--;
3 @, E7 t! X2 }- N* U$ v            }
# t  Q# S$ ?! I) f1 {            while (arr >= base && i < j) { //哨兵i没找到比base小的
                i++;
            }
& L$ u0 a+ C8 u! D% a! _            if (i < j) { //如果满足条件则交换
7 O9 S$ l2 A4 A4 T& z5 \2 ^                int temp = arr;
                arr = arr[j];
3 g/ J1 s* T; V! _. ^                arr[j] = temp;
            }

' m: S" D5 U0 ^
        }
# @% L* [) E0 d/ _1 ^        //最后将基准为与i和j相等位置的数字交换
4 Z. q  C3 d/ |" q        arr[begin] = arr;
        arr = base;
        quickSortDescending(arr, begin, i - 1); //递归调用左半数组
        quickSortDescending(arr, i + 1, end); //递归调用右半数组
6 c# K6 y2 u- l' |9 t. N  U% F: u6 F

    }
8 P* `( {9 V3 d# @5 h0 Y. p8 {5 C
' n1 D* ^/ W7 c: ?
: v4 K! }$ I2 v/ j7 n}
1
2 U/ y, C+ c7 ]' }! g2
* s) ]; r$ z- Z' B$ k. |6 `7 z/ R3
: D. y2 h, x8 _4
5 @/ s$ V2 N+ w" ^# T+ b9 |5
6
7
3 P2 F1 _4 i9 l2 s6 }8
# B# I. k$ B; e2 U9
10
11
$ V" C: M5 C, h2 Z' U$ o4 `  b" c- h12
13
14
15
' P- f# O9 M, V  Q! ]' {9 j6 x16
0 V. _$ d. F" q% ~$ D3 L+ t17
+ s4 M* v4 D' [* ]+ M0 R3 F18
19
20
21
& \- h% Z1 j+ E/ s7 O22
' u1 k9 m$ a$ _3 |. Q. O( z' D23
24
25
26
8 M! V8 Z! [; Z# ]; h  \- Y  ]+ S27
28
% ~8 r$ N( W4 ?) K6 Z) h. b29
30
( v- l' Z* J& s# D; l31
32
4 p: X) A4 k3 j+ |33
0 E9 z2 D% U! L* p34
35
36
37
# e% B/ r8 ~) Y! v) i) u+ F6 ~# ~38
39
40
# t: o8 [1 T. t+ J41
42
! Q. ]9 @/ s- I& @5 @  Q6 P& q43
4 [$ v, y/ R: a, d1 C44
45
46
) }; Z* _7 i2 z# l% c47
, d# X: g7 \: l8 w2 e48
* x* c. [; r  I' V  q, T- z4 ^49
50
* N$ y5 b0 c, ?% _$ [* @* j* e51
52
" G7 B# E9 g& ~' |3 Q7 g53
8 v# c0 {  l( G# D0 q! _( T54
- Z1 ?" p  ~, D- q; G55
+ B* E( V8 S% G7 e# g0 k" M9 B7 i: X7 P56
! J" x' K4 Y" h; `, y1 F) f57
8 X1 R8 A3 A9 X7 }( n2 {! @58
0 A2 L& Z5 e# d4 k1 k' x2 Q- ~1 Q59
60
$ a0 L  @) i$ P( j  f61
62
63
64
65
7 n8 H' {5 J5 W0 _66
67
) C# ^/ U3 m$ K% P68
2 c) ?  g' q, @, I+ P$ V3 ]69
" K% P7 b7 T" Z, v70
71
72
73
" w& M  D  x8 p. i/ \74
75
& I5 P0 |2 v( R; V76
+ B- n, Q: E  C, x+ ~77
78
/ l3 t- Y$ ~) A7 A79
* p2 o' r5 B( @: `( J4 w. m80
, Y$ |- C" K; b4 a* _8 f, t( h. v% b81
/ U4 x2 n( x# V% \$ E. ]& r82
/ W) T# ]' e1 J# D( i" e83
84
& _, W- G1 X; y! ~: y85
86
: a5 ^# s  M: j3 |8 }+ f- t87
88
89
90
91
直接选择排序
: {, k7 X, W  }7 M" y简单解释：
! {/ J+ j& c1 u% d  v4 D数组分为已排序部分（前面）和待排序序列（后面）
第一次肯定所有的数都是待排序的
从待排序的序列中找到最大或最小的那个元素，放到前面的已排序部分，然后一直找，不断缩小待排序的范围，直到所有的数都是已排序的了


$ R. F5 H$ [# s; c( ?$ a: a: A, b


: `: q; d3 }: ?3 T
% {$ G  {  v0 ]" Z3 M8 Z完整代码：


3 z( X1 z/ @6 i, j- N0 g$ y' A/ Ppackage com.keafmd.Sequence;

+ {$ ^& j4 n' e! r( o( f9 t
/**
* Keafmd
6 d, ]" V  b, J: S( c( z *
* @ClassName: SelectSort
: Y) }6 t* n9 u1 v4 I3 b" f * @Description: 选择排序
* @author: 牛哄哄的柯南
5 ]- ?, Z& @/ g$ y2 }) w) o * @date: 2021-06-24 10:33
: E/ E( k/ S2 `2 m5 D */
9 Z4 d) ]( X/ J/ Rpublic class SelectSort {
% `' ?5 O" |+ o5 E0 W
# ?; s4 e- Y" j
! y& m: w, P0 q% _3 j0 T$ z    //直接选择排序
    public static void selectSort(int[] arr, boolean ascending) {
& b, m- X: R4 @        for (int i = 0; i < arr.length; i++) {
            int m = i; //最小值或最小值的下标
0 N4 j+ y  O' r2 K            for (int j = i + 1; j < arr.length; j++) {
                if (ascending ? arr[j] < arr[m] : arr[j] > arr[m]) {
                    m = j; //找到待排序的数中最小或最大的那个数，记录下标
                }
( D1 k' K) f! D  [% I$ N% C/ H1 `
% a5 L; T0 P  z1 T) M6 D
+ |) v4 p6 ]0 X0 e            }
, B; c8 p+ {7 F7 Y  n            //交换位置
            int temp = arr;
            arr = arr[m];
: k) ^! S5 l. w9 V            arr[m] = temp;


, ^% A% u8 ~+ o0 ~        }
# G" g8 \  C# G- {! |3 M) j/ J8 |    }


    public static void selectSort(int[] arr) {
" X% w8 w5 x. G4 B& Q        selectSort(arr, true);
7 R) J) g) G3 u    }
}
1
2
3
# F! }8 Y* Z- F4 e% W# \' ^4
$ Q, l" M; G/ k! F" S8 q5
! ?  p* C0 `! N! U6
7
8
9
  B: q7 ~. i) ?3 x; l, {10
11
12
13
14
15
16
17
0 h/ k( V' r; \% O& R& C: T# G18
: ]( j& G  }4 T' Z% z: q19
9 J, J  M* F: c3 Q# |20
) b- m0 r$ f7 r0 R- Z& m) W) [21
: T5 D( g9 q2 q22
  a0 O* m; d( p/ @8 k7 N. A8 O23
/ r6 \9 {; ?( V( j. `; X9 @$ A# r24
& X3 F6 _: [6 {! X0 V25
26
# \5 f0 z4 T  V. P; Y27
* P4 n% I( {$ w$ q28
29
30
31
32
33
34
堆排序
先理解下大顶堆和小顶堆，看图
大顶堆，双亲结点的值比每一个孩子结点的值都要大。根结点值最大
小顶堆，双亲结点的值比每一个孩子结点的值都要小。根结点值最小
: b1 a! o+ _. V: }5 t# S
" c6 C' ]0 r% C& Z

1 U0 t( U7 A; ]4 J
简单解释：
+ d1 A$ c' {" r0 r" q8 C构建好大顶堆或小顶堆结构，这样最上面的就是最大值或最小值，那么我们取出堆顶元素，然后重新构建结构，一直取，一直重新构建，那么最后达到排序的效果了。
4 i4 `; {( [6 V  N



* O4 f9 R9 P- h3 a

. ]) ^3 `% G( ~' f& h完整代码：


$ M/ Y6 k. a. Z+ B, r8 f/ o% ppackage com.keafmd.Sequence;


/**
: f! @: ^, G0 D, A7 t0 u& s! r  V2 X * Keafmd
*
1 g* u- T: O  ]- x! s+ w8 N  b * @ClassName: HeapSort
" Y; `& z8 M# d6 F * @Description: 堆排序
* @author: 牛哄哄的柯南
* @date: 2021-06-24 10:34
*/
public class HeapSort {


2 c0 l3 j5 k8 h- D; M( r) U    //堆排序
' N1 K5 D% t: q, n: n    public static void heapSort(int[] arr) {
# g" d2 c5 E4 R& s' m        //对传入的数组进行建立堆，这里默认建立大顶堆，进行升序排列
        heapSort(arr, true);
    }
, z# _! F* L* @! L& ~$ J
; I* F# F2 Q6 Z' V7 U% y
* |2 o0 M( {9 Y( d) J! T: m* |    public static void heapSort(int[] arr, boolean maxheap) {

5 q% P% r5 k4 @: ]# _
7 c- q8 J1 i2 l: z/ x' ?& a        //1.构建大顶堆
  x( ^# V0 m: W! r        for (int i = arr.length / 2 - 1; i >= 0; i--) {
            //从第一个非叶子结点从下至上，从右至左调整结构
0 w  D+ V# ?6 d7 [' ?            sift(arr, i, arr.length , maxheap);
        }
7 x# d6 R  S7 ~2 R  G

        //2.调整堆结构+交换堆顶元素与末尾元素
" [4 m; `, D, t/ h" O: \        for (int j = arr.length - 1; j > 0; j--) {
( |2 o" z8 N9 C! a0 Z# J& V  x' u$ L
$ R, E* r, W# G& @) p/ U7 ?
            //现在的数组第一个就是根结点，最小值所在，进行交换，把它放到最右边
6 [$ Z3 S- v- [1 g9 g$ V) n            int temp = arr[j];
            arr[j] = arr[0];
            arr[0] = temp;
" W' {! L# Z- t. k( C
% M) g$ g2 g# A% W# S  e
            //重新建立堆
2 O+ S- a; N7 i& `+ E& q  n# A: l            sift(arr, 0, j , maxheap); //重新对堆进行调整
        }
, q  c$ j! o/ L3 m    }

! c$ o! a8 u, _. n2 M9 M
    //建立堆的方法
    /**
+ N  m% |4 Y0 m( ~; q     * 私有方法，只允许被堆排序调用
* g6 B- V! g3 s: u     *
: C; l4 Z2 ~/ B     * @param arr     要排序数组
     * @param parent  当前的双亲节点
     * @param len     数组长度
     * @param maxheap 是否建立大顶堆
     */
) L, \% ?" |+ v4 f: M; S- H    private static void sift(int[] arr, int parent, int len, boolean maxheap) {


. c" B7 T9 F7 [4 n3 t- f2 m& B        int value = arr[parent]; //先取出当前元素i


6 r2 r! ^6 g' Q$ a$ s  ~  C        for (int child = 2 * parent + 1; child < len; child = child * 2 + 1) { //从parent结点的左子结点开始，也就是2*parent+1处开始
2 _) O! D4 G; z. e

6 Y; d' y. P! {1 o            if (child+1 < len && (maxheap ? arr[child] < arr[child + 1] : arr[child] > arr[child + 1])) { //如果左子结点小于右子结点，child指向右子结点
                child++; //右孩子如果比左孩子大，我们就将现在的孩子换到右孩子
3 F' f7 v; ?9 [8 e( m            }


6 g" s/ K/ H# J- S$ n, h- n) A            //判断是否符合大顶堆的特性， 如果右孩子大于双亲，自然左孩子也大于双亲，符合
            //如果子节点大于父节点，将子节点值赋给父节点（不用进行交换)
+ s1 u- M! K5 ]" w' W            if (maxheap ? value < arr[child] : value > arr[child]) {
                arr[parent]=arr[child];
                parent = child;
            }
            else {//如果不是，说明已经符合我们的要求了。
/ p* a+ N: i" V; |2 G7 i                break;
            }
$ c' c1 |7 G) G        }
) k0 Q, u3 J* Y. e/ m        arr[parent] =value; //将value值放到最终的位置
% C( k5 [( ]' c1 E
1 d& u! G$ c8 u( H& j. l. j% B

; `! b6 f9 D1 U, w& Q& e; g8 G
) m) a6 i$ i- Y# w    }


  Z3 s3 k7 m3 J: j4 D}
7 s4 q. v* ^% f' t' U+ P1
2
5 @- W1 c: W* l1 |! v9 V! s: R3 C& Q3
4
. l2 ]# l" M* a6 K5
+ s' M# N" }1 G% M0 _2 p/ J3 C( u7 N6
+ ^' N, b9 m; ~8 X3 o' S: l4 e7
, v% Y0 F  T" U! L3 M% K8
1 p, \+ P% Z0 R; \; L9
10
1 \% x+ {: ~2 g11
12
' K) f  s1 h0 {/ Y# F13
+ c+ N# X2 S# T14
15
! }( Y" E% s: ?% }16
6 |4 ]7 t; _& X  T! U: `17
4 B# p$ V3 H! E0 G8 z& K18
# [4 E+ i& U" A4 a19
6 R9 I2 K/ G) o20
21
, E  Y1 w4 K* ^$ R0 L, e* k- G22
. o3 L3 ]' A, k% K23
24
25
26
27
28
29
30
$ J, x' W9 }) G$ j31
. ^  H3 a6 u# I. y32
2 N) {6 d0 X& F- Z/ H' [33
34
35
36
# D0 S7 N# ]$ S0 x) D: ?0 R37
- N1 [0 @5 G1 R" @2 o7 y38
39
  Z4 @, d, L- |# j1 y' d40
- O. \9 ?1 m& P41
42
! q7 g9 E9 n6 C6 _. ?! i! k43
44
* E6 Y' l: S! ]$ V+ p7 v. E45
% \  f: Q5 J3 ?: R- M6 H) N6 j* u46
4 }  c/ T) U7 o3 k47
% K0 |& I: v3 p; j  H! q2 h: o& F48
4 E3 g' D6 l$ `5 [- G49
9 G9 F7 W  U" m# ^3 l$ Y0 h* R50
51
52
53
9 {5 K$ t2 Z) W' ]! Q54
55
56
/ w1 D! y4 e) c4 C: R57
8 P0 }6 c  I( i# B2 j58
% D6 f( D2 I' {0 z9 Q# }! Y59
# E1 t6 ^5 ~" c8 {0 ]2 K60
61
' F5 {' K0 ~$ C- @  P( \62
, `$ Y' u% k0 v' U7 g* \) v. M63
: m, ~: m) j( U/ r' a1 D64
65
66
) w0 s$ N: K% x) o; r67
( g! b6 f! e1 ]% j: e68
% H  L; ]) l# n) A% \4 M% K% u69
9 z3 D$ `! q; S6 [70
! p/ C# ^) C* l1 }: U71
3 g: {7 n7 ?. o- F+ y0 j72
1 C. g3 J' R) r5 A6 w' c73
74
归并排序
简单解释：
! c' K+ X) q0 u" b# R6 G该算法是采用分治法，把数组不断分割，直至成为单个元素，然后比较再合并（合并的过程就是两部分分别从头开始比较，取出最小或最大元素的放到新的区域内，继续取两部分中最大或最小的元素，直到这两部分合并完，最后所有的都合并完，最后形成完整的有序序列）
4 }; N$ a+ H4 z( n) @1 }( A# ?
" Z. ^; M2 e5 K, k, B
6 H* K5 A4 k+ p  G7 O
6 |, i  p: K- G& t5 K8 K


完整代码：
9 ?+ Z3 B1 H- |& V2 [8 r

package com.keafmd.Sequence;
( M# p" o% v( L, c/ \9 r2 X& |! }

8 p) C0 {: C/ |2 h/**
: O6 W; ?- C3 W, e5 | * Keafmd
*
' A  y+ _! ~# J, I * @ClassName: MergeSort
* @Description: 归并排序
8 V6 `6 a/ P$ I1 N+ z4 ]% X * @author: 牛哄哄的柯南
' o9 s5 C& U" D( j% V * @date: 2021-06-24 10:35
( v# B. \9 I% T8 L1 b) ^6 d */
public class MergeSort {
2 `% X6 T/ b( u- G

    //归并排序
    public static void mergeSort(int []arr ,boolean ascending){
        int[] temp = new int[arr.length]; //在排序前，先建好一个长度等于原数组长度的临时数组，避免递归中频繁开辟空间
7 U# j, P4 r" e. @  K        mergeSort(arr,0,arr.length-1,temp,ascending);
. Y8 ^9 q3 e3 o. ^: ^    }
    public static void mergeSort(int []arr){
, X+ ]+ V2 |3 }6 m# B% F# l        mergeSort(arr,true);
    }


0 r" w2 c' T, J' c0 K4 L    /**
     *
     * @param arr 传入的数组
" W) M+ a3 v: V- \+ p8 x     * @param left 当前子数组的起始下标
     * @param right 当前子数组的结束下标
     * @param temp 拷贝暂存数组
& [# d  H- H: I" I; W# ^# }1 j     */
# H3 v) U6 L: j9 {' H0 c) Y# R    public static void mergeSort(int []arr,int left,int right,int[] temp,boolean ascending){
- [( h) r/ h& p1 c+ S+ f" Q2 q" k& \        if(left<right){ //这里是递归结束的条件，我们是对半分，那当left==right的时候肯定大家都是只有一个元素了。
: i' X) w# m/ i8 q* s4 i' @5 |+ r

% A  O9 H2 J: |' @0 I4 a" z            //对半分，比如总长度是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; // 防止越界的写法
            //int mid = (left+right)/2;
9 e3 ^0 W. u" J- m+ u( a
' H* R9 i4 g% r
7 S! P( O; u5 k: |* ]# ~/ Q* [+ J            mergeSort(arr,left,mid,temp,ascending); //左边归并排序，使得左子序列有序
            mergeSort(arr,mid+1,right,temp,ascending); //右边归并排序，使得右子序列有序
* K8 K7 C5 \/ K' {

            merge(arr,left,mid,right,temp,ascending); //将两个有序子数组合并操作
5 q9 j5 J' y3 O; x        }
    }
6 q' C/ k; v( |% g; v1 q% @3 Q
0 Y4 T9 T& \1 G
    private static void merge(int[] arr,int left,int mid,int right,int[] temp,boolean ascending){
        int i = left; //左序列起始下标
( U% G, _7 z2 I: }5 [        int j = mid+1; //右序列起始下标
        int t = 0; //临时数组指针
9 p* r  ^1 V) I/ a) _        while(i<=mid&&j<=right){
            if(ascending?arr<arr[j]:arr>arr[j]){ //比较两个序列第一个元素谁小，谁小先拷贝谁到temp，然后对应子序列下标加1
2 O: k# t- ~1 i9 B5 R                temp[t++] = arr[i++];
! B* d- Q" {( u: I* e            }else {
                temp[t++] = arr[j++];
, B% u( e- n7 \' N            }
# }8 e) i8 g$ C: T4 M" ^. p        }


3 b. A6 Z# h$ `        while(i<=mid){ //将左边剩余元素填充进temp中——左序列有一些数总是比右边的大的数
) y- k# K" n& [2 p: Y3 H/ j            temp[t++] = arr[i++];
        }
" t' Q5 @7 D7 p3 ]# z/ n

$ G! A, J: B0 U% h% D. i        while(j<=right){ //将右序列剩余元素填充进temp中——右序列有一些数总是比左边的大的数
            temp[t++] = arr[j++];
0 l+ S+ N, V3 K        }
4 c: t( g( c0 }% g: [; I4 f0 O

- }/ k; n5 J8 `: `8 K        t = 0;
) h* B% _# C+ [) E7 l# N
/ B  |2 I' f: ?3 L0 R/ T# A; |6 R
        //将temp中的元素全部拷贝到原数组中
        while(left<=right){
. X. B; s) h4 g4 m2 U            arr[left++] = temp[t++];
        }

. v/ Q4 L3 n. y' ~1 v' z' C
. ~3 Q$ \; O- @    }
6 S, s; _" N$ m% ]0 P" W% p% w* G$ D

0 C/ ?! o9 t: V2 ~$ c}
1
- l- x  o) y$ s( F& d5 K. t  L9 u2
, e; ~) g  D+ B+ U" V3
! F( `5 a3 h' b- l4
5
6
7
" H3 V, c5 b5 \& _8
9
0 z3 S/ Z6 |0 x! p! q8 v9 D; ]: t10
11
12
13
14
% _# E  s/ b! w15
16
17
18
. R  R" Z' D3 Q( D9 j7 @7 u: U0 \19
/ t% J; r3 C. n* |20
2 c. r$ E- t; k: I1 \. m& x; K! y21
22
5 r3 C2 A) Z2 d, q3 q23
24
25
( L" \. C) G' q/ @, l( W! A* E26
3 v+ w# `6 O) @. y27
28
29
30
31
32
33
34
0 F4 x! \. L- F+ J6 W$ }7 U35
4 L4 v1 D" q, E: I: i+ C; d; u8 o36
37
38
39
40
41
42
) R8 K. N4 l6 O3 b6 A/ W: @" A43
44
/ r3 e! y  R) I& m5 k% {6 a* P45
46
47
0 j4 |1 I3 r* k7 m9 T48
0 j$ K. g5 k% v- o49
50
51
! k& c/ u: _* l) `  s9 [3 d! K52
( |' B% O1 A! g  Y- a" I* A+ E53
" D& m+ y1 T, G- K: i/ @+ ^54
55
+ D! K$ l4 l4 `0 i56
/ t& k6 E5 M7 _3 b( f57
6 r$ K# E; S0 j0 H* D1 V. z58
( O. w- A. V# c: a* B+ N4 w6 T59
9 ^; ^5 L; b5 g8 g3 ~60
: ], {6 z( o6 V5 X9 C9 i61
4 K  E% D! @+ @9 P+ S* ?62
9 Z. r) g# k; n+ |- T3 o63
64
- U/ \, k% j" k9 T( Y" ~. O65
66
  i& L; i$ j; c; \2 ~' H67
68
69
' b1 `4 s' ]8 K5 _70
71
72
73
插入排序
简单解释：
. x  r- Z" X1 X2 t5 n# A最简单的理解就是打地主时我们拿到牌后的整理过程，从第二个牌（假设我们拿起来这个牌开始比较）开始，（说下升序）从后往前比较如果比前面的那个牌小，就把牌往后移动，直到找到一个合适的位置（这个位置的前面的那个牌不比这个要放下的牌大）就把这个牌放到这个位置，慢慢的前面的部分变得有序，直至全部有序即可。

+ y7 W+ C" g6 q! S4 X/ {2 E
/ N  t" k# w& j2 T" w
: t1 `$ o, C1 D: m4 Y) h. M' G

5 M% @8 i0 i( i$ [/ e4 E9 @
完整代码：
' q" w9 [- q9 t% }+ I+ f6 c
% u6 W4 ~' Q) f4 \! X/ [2 P/ c
- H# X( S& |( O' a: g5 U+ kpackage com.keafmd.Sequence;


1 h3 g+ Z# _9 @' D/**
- z7 @+ l! b0 n* e- J1 \ * Keafmd
*
* @ClassName: StraghtInsertSort
* @Description: 插入排序
* @author: 牛哄哄的柯南
+ ?2 F' j6 G* M- d9 B: y8 H * @date: 2021-06-24 10:36
*/
5 E. q) o6 I2 F0 }" w7 D; Q2 i5 Ppublic class StraghtInsertSort {
+ h! H: b2 S; w3 s( S6 }, k    //插入排序
8 {; `& R- t2 b/ |# Y    public static void straghtInsertSort(int[] arr) {
/ ?: f$ N2 [9 d9 g$ _        straghtInsertSort(arr, true);//默认进行升序
5 t0 p/ x* A5 Y( {% H    }

% C: R8 s5 Z( h7 Y5 n
    public static void straghtInsertSort(int[] arr, boolean ascending) {

5 v* A* R2 R+ P# ~: y
. T; A4 R& E# A. ?7 q# x9 ?; y        for (int i = 1; i < arr.length; i++) {
# j8 R. c# T& }' o% Z            int temp = arr;
6 x9 E8 ?# `1 ]. g% A/ @            int j=0; //这就是那个合适的位置
# }# D1 C8 Y. O, A5 R" o  M            for (j = i - 1; j >= 0 && (ascending ? temp < arr[j] : temp > arr[j]); j--) {
4 V5 ]2 c6 Y$ y& x8 `% U, X, E                arr[j + 1] = arr[j];
% [2 P2 o9 w+ m7 j            }
* W0 |8 n4 z2 R5 P+ K0 x+ a6 p            //把牌放下，为啥是j+1，
0 `' A/ X* T% J/ m" ^            //是因为上面的循环遍历到不符合情况的时候 j是合适的位置的前面的那个数的位置
            //有点拗口，但是就是这个意思，看图方便理解下
            arr[j + 1] = temp;
5 J9 H6 |- [0 X5 C4 C: W' T
- v+ j6 g) K5 h8 ~5 _, Y& Y
& g) M* J3 I' Q- ]4 a4 C

        }
+ l# k) o! ?/ g
5 E* \6 i- ^: O- z1 H" ^
    }
}
1
  n; L( P3 D5 T; b2
. {9 v  ~! R$ {9 w* y, R# ~3
4
6 ]& t' i& L9 w0 v  t) l( Q5
6
; [: g8 b' n9 y) ~! u  m7
8
9
10
- O2 u0 d  s. m) B3 H11
. w& f# z. J* n& B" X* Q12
- H; D6 x' F3 c8 G+ F" J: Q- n* X13
( g, ]9 ~* R+ n2 m, E# K14
$ }9 o! W. \5 Q: ^$ G/ L6 ], D! H15
8 k. f& t* ?9 n  X# I, t0 Y16
9 X0 R5 h& F. L17
& r+ F* F! E5 x; L, p8 N+ g18
; {4 \( ]% y9 H6 q( P0 u19
20
21
: k, [3 l, I8 I" o0 ]" w22
$ Q, e5 z- z& o0 b23
24
" Y  L& d, W! @+ w5 x& I25
26
3 H. I5 f6 G. x. ?0 p6 y9 S! o27
28
9 Z2 c5 T* M2 n) l( F' u* ]! [8 R29
1 j5 C4 A4 k* m6 f' H/ N" ^7 N30
31
! @' ?7 D$ m! K: v$ J- u6 x32
33
34
希尔排序
# k$ p) ~$ g" C/ S3 f; H简单解释：
希尔排序是插入排序的改进版，我们理解一个叫做下标差的的东西，也就是下面那个图中的增量d，初始下标差为arr.length/2，然后继续/2，对在同一下标差（相当于把这几个数单独拿出来了）的若干个数进行插入排序即可。

8 ]- b( {, g% }0 W, A4 }) \) b
0 G. g" W! x3 k
/ T, ^3 E1 F7 c; N3 ]5 h' v/ d, J
0 D) K2 o5 O4 N& d

, t* E/ _! n1 [! f) N完整代码：

5 s& D/ W: U4 @5 Z+ t6 P  Q# A
5 X) L& f& q: X, epackage com.keafmd.Sequence;


* I# u) r! i& i2 @8 P4 G! [- G: u" S) U/**
" X3 D: M  ?& u2 m * Keafmd
1 c- Q. c! |% f( o *
" D7 `. C* m, C" o$ D' T * @ClassName: ShellSort
; x% Q4 J$ j/ f4 {" U! V8 p+ `8 [ * @Description: 希尔排序
2 J/ m# M3 K4 g1 R# @ * @author: 牛哄哄的柯南
( G$ W) _* {- \! K- W" i * @date: 2021-06-24 10:39
2 o" ?9 E& q3 C+ M! @& @ */
public class ShellSort {
8 L. B3 {1 z, |& Z$ e+ S0 N6 c
  z7 B2 I) n2 _/ l0 v5 h& I: _, e" {
    public static void shellSort(int[] arr) {
        shellSort(arr,true);
+ N0 ]  c5 S  s- d3 ~0 [( {+ H    }


    public static void shellSort(int[] arr,boolean ascending) {
1 {# D# n' M# F* j/ V3 `6 V
( z6 A9 ?+ G8 d+ @% `
        for(int d = arr.length/2;d>0;d/=2){


            for(int i=d;i< arr.length;i++){
                int temp = arr;
1 a* B" W: c2 T) g                int j=0;
$ Z5 s$ n# Z$ H1 U: r& P5 j) n) E5 u$ i, X                for(j=i-d;j>=0&&(ascending?temp<arr[j]:temp>arr[j]);j-=d){
                    arr[j+d]=arr[j];
8 o6 s$ \. X  g$ {                }
8 N# j; g  d- P9 Y: ~# d9 y2 k                arr[j+d] = temp;
+ u6 ~; f' z4 O! N/ a3 \: C4 _8 c; r            }
        }
/ ~# Y; e! i8 d- a2 U( R

' t+ j6 D- Z7 H1 O9 P    }
}
; g8 H" D4 }6 v4 J' r* y; w+ q, S9 i1
2
) N4 w5 T* ^- d  [3
4
5
" V9 {3 ~) h7 b# R4 l, }/ `6
5 N3 w' @% m. r/ q! @& f$ j7
1 i3 N, n/ f: o. R- B+ o* D1 k8
  Y& X4 _( S- N9
0 Q) h3 T5 l+ t7 x- d- G10
11
12
2 R0 N5 `2 U" J: v" {3 N# V- V13
, e* r9 ]4 ]0 `* @14
15
16
" D. j8 O' u% L  i0 d0 A' S17
# h+ n7 y  I! t, Y18
% B( P7 w& F* M4 |) L2 R3 X: f# f19
  I+ z0 M, h  C7 N2 i0 |20
+ E3 f) h' k) M! w6 k21
22
23
24
2 D/ S) E; F' [7 d25
26
- I9 ^$ ~) o' b: v7 ^27
28
. _1 k# v- y& N# C1 ]$ M29
30
/ f; W: T! }* ]8 ^* a  v, q31
32
! K+ e! C7 i) j! g/ L- q计数排序
* Y4 o. ?! n; G9 k简单解释：
* Y. d3 ~3 n. Z. b3 F这个排序算法看名字也很好理解，就是就是额外找个数组来计数，然后在这个数组从小到大或从大到小把数取出来即可。



/ o  P" @9 a/ i! g: }2 X


+ _6 K7 m  w' v, W  H) i2 H完整代码：


package com.keafmd.Sequence;
( p/ t, o% L  u: D( y/ z$ m0 d

6 T4 l+ X8 J. t/**
' `( M2 b4 S) E6 N5 b * Keafmd
* s3 Y  l1 K- j9 Z+ C9 X *
* @ClassName: CountSort
! p+ t) l: A3 e5 w1 k# [ * @Description: 计数排序
& K7 N% }# m/ l9 A3 s/ [& e * @author: 牛哄哄的柯南
* @date: 2021-06-24 11:31
*/
) o' t9 a% H1 {( f& fpublic class CountSort {

: I* h" ?1 C, t2 B9 D
* q, u8 v2 z, P* ^4 z- ^0 D+ O' R    public static void countSort(int[]arr){
        countSort(arr,true);
    }
/ D; w; ~1 f1 ]4 C1 \

  r; W% W+ N7 ^6 o  C! u    public static void countSort(int[]arr,boolean ascending){
% G  g, T4 W! J( x        int d,min=arr[0],max=arr[0];


/ a: n  T1 _# v( v" f) k8 H: B6 J; l$ n        //找出最大、最小值
        for(int i=0;i< arr.length;i++){
            if(arr<min){
( `, O0 w. B. e: _/ W2 i                min =arr;
            }
/ x8 [( \/ P4 w            if(arr>max){
                max = arr;
            }
        }


/ z. R7 B% [+ m        //建立一个用于计数的数组
% J- x+ m( R5 [        d = min;
        int[] count_map = new int[max-min+1];
        for(int i=0;i< arr.length;i++){
$ p7 }$ L( D6 n9 |            count_map[arr-d]++;
) o1 p: Y+ N" m/ D9 v; }) c        }


6 Z2 C) \. u$ _* x, S4 f- X- c" P        int k =0;
, i  K- C- l6 L' d        if(ascending){
. Z% v8 Z( A/ ^            for(int i=0;i< arr.length;){
                if(count_map[k]>0){
                    arr = k+d;
1 p4 A. K  w2 k8 A) H9 _/ k; @+ P5 A                    i++;
( T: A8 C7 u! {" @                    count_map[k]--;
                }else
1 [1 N" Q8 b8 Y# w+ {                    k++;
6 O3 z( f) v- Q            }
        }else {
            for(int i=arr.length-1;i>=0;){
                if(count_map[k]>0){
                    arr = k+d;
                    i--;
                    count_map[k]--;
                }else
' [/ K" I: w9 i" T  A( w                    k++;
& z! d# P2 j0 N% m5 K3 K            }
        }
8 e# I( B' N; C& d6 d
+ R3 [- l/ r% W; r6 X! X% S
    }
}
1
1 Y7 {  M. e# w: Q! M$ _2
  k* s  X6 D  ^. ]( h6 [. `3
5 P+ c% d! _' o0 F4
( D- H3 ?) H: @7 _" s6 j- }5
6
7
8 {' ^1 H7 u. ?, H$ E: L+ X! l8
9
( t0 l" H) I4 B. E$ [2 h10
# J% K" w* }& ], i, X$ ^7 \8 y( J11
  k& a1 h/ B3 A3 V+ w; F4 l& ^12
1 r  q$ Y- l# W: i13
14
7 Q: C+ r& k, I, @; y15
4 q& Z0 X- |1 M& [( F16
4 f, o" J2 o, O9 W17
$ c+ N5 r/ P) Z& @18
19
$ e1 r5 |% v* v2 b: e* t* t0 s6 q20
21
22
4 O5 p4 t9 w2 I* i3 c  @- {23
24
' ]1 ?& z8 V1 X- c, \$ a4 D25
26
27
28
29
30
9 j  G6 T* Z6 n' ]31
6 i9 @( t* z! ~. U# v6 I0 q& `32
- E$ z5 l  \/ x0 B: c5 H1 `2 \33
) G: G  R) ~. p7 M0 _/ ?34
' c* I; y2 V: T+ ^4 E1 V1 T35
7 b- d5 U9 i2 f. k5 T36
/ d  w% T9 e$ \6 H37
38
# U) K0 z$ I" |' o- v/ h  S39
- \# |& d- o: v% O: ]: Z40
41
42
2 R& t+ f% x5 D; p& Q. ~9 t# @43
44
2 z4 J# R1 }5 t45
46
0 Q, x, U. L0 x( G$ t47
48
% q4 z% E) |& e1 e49
9 }* J, Q" p& }  [50
51
52
/ g+ c: [: `2 P9 A7 L# r7 x53
8 R2 Z; h: _0 E4 h9 ^54
55
56
7 x1 m. {; ^4 p57
58
0 N4 R7 M- l1 G4 Q$ _59
桶排序
( Y4 p' M8 G* W0 C简单解释：
* K0 b$ N* g1 L2 L- G9 ~就是把一个数组分成几个桶（其实是几个区间，从小到大或从大到小的几个区间）装，然后让每个桶（区间）有序，然后取出来放一起就可以了，相当于把几个有序的段拿出来放一起，自然还是有序的，当然需要是按照区间的顺序拿了。
0 O  Z9 t# d$ h# S
  D0 W0 c. T" y  K+ w( p' [

" x0 ?5 A( N/ K( c! z2 ~* Z
* K0 _4 X$ d4 V# E* Q

完整代码：

" b* h5 S6 Z% Y# A, ?
package com.keafmd.Sequence;


import java.util.ArrayList;
6 f/ C- }8 M9 F- Himport java.util.Collections;

+ d5 Z* a$ \7 b. E3 n5 Q
/**
* Keafmd
  `! n2 p  t1 @* v* a( k *
* @ClassName: BucketSort
* @Description: 桶排序
# a3 \) w1 K- e' {" h* K& h/ } * @author: 牛哄哄的柯南
* @date: 2021-06-24 13:32
3 X- c9 \2 U: w1 q1 j */
public class BucketSort {

: `4 o$ d& `/ b) _5 C
7 B0 K5 p. n7 O& H% a- W    public static void bucketSort(int[] arr){
        bucketSort(arr,true);
% o' l& D' [$ `  M2 e) x* ^    }


    public static void bucketSort(int[] arr,boolean ascending){
        if(arr==null||arr.length==0){
            return;
        }
9 c! n# r1 S3 L- Y        //计算最大值与最小值
        int max = Integer.MIN_VALUE;
1 ~$ X9 b6 A" y3 J) [        int min = Integer.MAX_VALUE;
        for(int i=0;i<arr.length;i++){
            max = Math.max(arr,max);
            min = Math.min(arr,min);
' U" n9 D% v) H) N: i7 G( ?        }
( \: c' v, j4 f, E

1 b6 T* b- y- D* ~+ `        //计算桶的数量
9 `' u8 w0 y7 q- P. T1 K        int bucketNUm = (max-min)/ arr.length+1;
        ArrayList<ArrayList<Integer>> bucketArr = new ArrayList<>(bucketNUm);
        for(int i=0;i<bucketNUm;i++){
( f$ t, }0 y0 m$ h1 u6 W            bucketArr.add(new ArrayList<>());
        }


1 }# M6 ^- M' s  w        //将每个元素放入桶中
        for(int i=0;i<arr.length;i++){
            int num = (arr-min)/ (arr.length);
1 Z; i, ?% ~4 @2 p& V( B            bucketArr.get(num).add(arr);
        }
5 Q+ V4 _  @( w- W- v. [
% G( d; p8 ]2 a  h! U7 C# F! I% d& P
; ~! Q+ R% y" O6 V) j        //对每个桶进行排序
        for (int i = 0; i < bucketArr.size(); i++) {
' {3 n2 f* D) [. g' R% d            //用系统的排序，速度肯定没话说
            Collections.sort(bucketArr.get(i));
0 g+ T. h/ l& z" m& {        }
0 I7 L: Q+ n/ ^2 `# Y
' q: H1 D1 G: t5 a/ S( H+ C
        //将桶中元素赋值到原序列
        int index;
        if(ascending){
            index=0;
2 Z. }  G5 p; e9 B  w( b5 m        }else{
/ C1 S5 \% l/ F( C            index=arr.length-1;
8 K2 `" G' I% z7 I6 M1 R" ?, q        }


        for(int i=0;i<bucketArr.size();i++){
) p6 K3 K9 Q5 a0 Z0 H  P. B            for(int j= 0;j<bucketArr.get(i).size();j++){
$ ]; W8 ^. P% b6 u7 S7 k( C' }                arr[index] = bucketArr.get(i).get(j);
                if(ascending){
: s/ l* L9 T0 E# u6 h$ K                    index++;
+ F) n% ]3 @* V4 D( _$ F6 K, s                }else{
                    index--;
+ Q9 j2 o! s7 C( j2 A                }
" b7 T2 T# f3 _/ g# Y1 P+ H            }


' h! s$ r& Y5 S* Z$ X. A3 }        }


    }
}
" _$ i7 Z3 o% H( R7 i1
2
$ H, B: v% I! ?: j4 k3
4
  P. `5 h$ z/ N, z5
6
2 v9 A/ q0 d2 U5 |7
3 g0 j6 D! s" Z4 ^8
9
10
% k6 I- s* {4 J, D( S9 ~3 R6 L" b11
12
13
14
15
16
2 D  r" |" \* a. |17
: g6 {5 |' n% C18
19
20
6 H7 q  `/ t' v# }' @* M2 t" C/ N  I+ X1 P21
22
23
7 }  ^$ `; h+ l24
; `1 J: Z; ~! d9 d/ ]25
5 t# y, V* t" j7 `( O! U* N26
27
28
0 O9 l& m0 d4 {' ^29
30
; L6 d& W" h1 v( q/ O1 P  j31
32
1 L# b0 f6 |' H7 S33
34
3 R9 k& s" a  v7 @, j35
) W9 }% B0 V$ u) S$ M0 A4 f; m1 Z36
37
38
39
6 z2 a" K& J) `3 w, ?40
41
9 u/ S; c6 D: R4 A5 M42
43
44
4 M6 U- c0 }: n3 w% Y: m+ o0 a45
) Q9 |! ^' Q" S% |( E5 o; {( v46
5 ~5 Z$ c. q6 \47
48
& \+ f7 E+ m3 m! M8 e49
; H% r7 _* Z3 Z. E0 l3 F50
51
0 e% k: t  R3 g; Z52
, n2 a; ~! G1 H: u. ~53
54
: W, r2 n0 j4 H6 C. a- z* e55
56
57
: d. K2 e5 L% r) x" Y58
59
, x" m* ^6 h* D60
61
62
# G( ]: V' H0 }2 x1 D5 \63
8 _0 h+ @1 O' C& V6 u, ^64
6 [/ }6 H  d  @& j; y65
' D: m' `) o6 o. a6 {66
6 I+ Q7 o6 H8 e# i+ f8 ?" l67
: L, y* d& N0 Q* t68
69
' {2 u% m+ v3 \3 J70
. }  j" o3 X' ]; P1 A71
: g& v( B$ a& m& v  R+ J7 }; Z72
: ~* I! f5 W( f. f" R4 r9 B基数排序
. @  \5 u1 M2 Q1 k7 f简单解释：
4 q) h/ Q" P7 u; n- F* k首先说一下，我发现好多人写的基数排序只能排序正整数，其实只要处理下就可以排序含有负数的了，就是我们排序前先把所有的数整体变大（就是减上最小的负数，也就是加了），都变成正数，然后排序好之后，在减下来（加上最小的负数，也就减了）就好了。
基数排序就是按数位排序可分为LSD（从最低位[也就是个位]开始排序）和MSD（从最高位开始排序），下面写的事LSD基数排序。
基数排序就是把数按位考虑，让后我们一位数只能是[0，9]，就是我们在考虑某位（个位、百位· · ·）的时候就只看这个位的数，放到在[0，9]相应的位置，然后顺序取出，最后再按其它位这样操作（上面说了要不从低位开始到高位，要不就是从高位到低位）
& H+ ?: |. d, z: @) q! j' }$ E

& {# F$ E8 C9 z( \' t$ b$ s! u


- w4 w' z, c+ |# W8 B$ O, E; w
% X" D- G$ u# u: \7 l/ \& B: t' Y完整代码：

2 L; b' p9 c9 f5 n
, F0 J! K! @7 g2 }8 j1 Y3 g$ ?, r' gpackage com.keafmd.Sequence;


/**
; J8 i0 N* p* @! p * Keafmd
*
- [' o2 C/ F/ q. D * @ClassName: RadixSort
2 L4 _( v$ k$ m" Z * @Description: 基数排序
* @author: 牛哄哄的柯南
* @date: 2021-06-24 14:32
8 o/ Y; z$ C" c! Z) g */
8 B: y9 k! B, ]# X! g+ Rpublic class RadixSort {
0 q0 W, g6 N6 d" ^/ S    public static void radixSort(int[] arr){
        radixSort(arr,true);
+ V3 P5 O* l& ?% k& N$ z+ E    }
    public static void radixSort(int[]arr,boolean ascending){
        int max = Integer.MIN_VALUE;
        int min = Integer.MAX_VALUE;
        //求出最大值、最小值
( C6 l) c, ^' ]9 r$ D        for (int i = 0; i < arr.length; i++) {
2 q' H3 n0 L" t! c- y; [            max = Math.max(max, arr);
            min = Math.min(min, arr);
  a1 |. y3 N- l7 R. q2 B' Y        }
) ~+ n5 j) }# V+ q        if (min<0) {        //如果最小值小于0，那么把每个数都减去最小值，这样可以保证最小的数是0
            for (int i = 0; i < arr.length; i++) {
                arr -= min;
            }
            max -= min; //max也要处理！
        }
4 d* y6 s8 z+ ]  u; V        //很巧妙求出最大的数有多少位
6 s; L) ?2 R: T1 S        int maxLength = (max+"").length();
        int[][] bucket = new int[10][arr.length]; //一个二维数组，一维代表0到9，二维存放符合数
- Q, y8 x1 i* [' {6 a2 T! U; i        int[] bucketElementCount = new int[10]; // 用于记录0到9某位存在数字的个数
8 H+ {, Q: G1 r  ~        for (int i = 0 ,n = 1 ; i < maxLength ; i++,n*=10) { //个位 十位 百位 这样遍历
            for (int j = 0; j < arr.length ; j++) {
; n8 f% e- A2 a                int value = arr[j]/n % 10;
                bucket[value][bucketElementCount[value]] = arr[j];
                bucketElementCount[value]++;
1 k! `2 F; f! ?- Z! {; {2 z, J            }
5 [/ W2 ~9 O" k5 Y
7 ~5 `' t( K0 y
/ I' d. O2 M9 L* M5 f* n            //升序
            if(ascending) {
7 P+ Z) J5 O( ?) w; `2 c/ c                int index = 0;
                //从左到右，从下到上取出每个数
) V# m& T( _+ R* }2 Q                for (int j = 0; j < bucketElementCount.length; j++) {
                    if (bucketElementCount[j] != 0) {
                        for (int k = 0; k < bucketElementCount[j]; k++) {
                            arr[index] = bucket[j][k];
7 X7 h+ y& l( i* _, O+ S                            index++;
                        }
# e& Y% _' O  ~4 O7 }* B( R                    }
                    bucketElementCount[j] = 0;
$ H; q; v/ M& S/ w" ~                }
            }else { // 降序
/ h) [- X/ [% Q, c  C4 V                int index=0;
' \. T' [1 k/ s4 y0 _                //从右到左，从下到上取出每个数
                for (int j = bucketElementCount.length-1; j >=0; j--) {
                    if (bucketElementCount[j] != 0) {
$ [! B4 \) D1 q                        for (int k = 0; k <bucketElementCount[j]; k++) {
; Y% x! Q+ a$ V% N4 M, x# V                            arr[index] = bucket[j][k];
% @: {$ U7 |. t  @/ a8 u: A/ _                            index++;
$ k! r5 \( A6 T$ w                        }
                    }
: m1 Q0 \% J- M. d  P$ T+ W                    bucketElementCount[j] = 0;
% Q1 H- w7 `, }2 J: d$ O/ G                }
            }
( J) J$ x8 n& L! W
/ A! d5 e* |; r; b
- h8 r- {" O# F& Y# H4 [
# U  U$ p2 i' P! f9 B, A. r
            /*for (int i1 = 0; i1 < arr.length; i1++) {
                System.out.print(arr[i1]+" ");
; E1 E1 d6 Y, u+ X$ a            }
            System.out.println();*/



2 [8 i" u9 y. Q* I


* Y6 `7 z2 i: E& W1 R4 [$ s        }
% o9 |& A+ \5 X6 B* k: ]: ?        if (min<0){
            for (int i = 0; i < arr.length ; i++) {
; Q1 ]; z9 i, C& l6 y5 E) R( M                arr += min;
            }
        }


% j- z/ a+ s! j    }
}
1
2
3
2 ]2 u& e3 a/ y" Q) }! _; H4
* \$ j7 B" b8 A; W5
! d  u0 j" m& o3 X6
: y6 A$ Q6 h1 |( N0 L5 Z7
8
9
10
# u. Z: E- G9 y/ F# T11
12
13
14
15
5 B* X. Q; y( k+ R  X16
17
18
19
8 Q, ^6 V% v3 d5 h20
7 p  j! B/ Z& D/ R9 x' K21
# H0 f6 |0 \& k: |3 @22
23
4 n1 e5 T: a3 R. b  n9 }' ~1 J24
" L) V! Y  E( _! T  r+ z25
26
, Z0 o2 P0 {9 d# k2 Q! m27
28
( b  z3 M4 K6 ?* @0 b1 s3 r$ t29
9 W1 @. q9 e" a/ p' [7 s* M  K9 e30
6 }0 `6 L3 \7 ^  Q0 N$ s  v) S31
32
33
34
35
36
37
38
  O/ R" d6 W  B' V8 N( c39
. p  v' m' Q. |' r6 ]  P3 p) \$ w40
: u# n2 Y1 q- E- Q41
3 A) E; t3 O9 G/ R; ?, O+ f! z42
43
44
& h" _( v1 p" k8 G45
( B$ \+ G, ?& y  \0 F46
& W6 F) U/ C5 J1 w* z( ~: x6 k6 g47
$ V6 M/ R( z4 o3 R1 k" {; S48
+ Z, f, ^: ?0 S9 r% H. b* Y  L49
. J+ U. U  v1 d# v/ ?3 U50
51
7 w. D' O2 u" v) H9 x3 e2 n; o52
53
54
55
56
; [- Z+ y& L. B57
58
( ^( v( }: D1 W7 T2 ?  l59
60
61
62
63
64
65
66
67
5 Z! ~9 z3 b; i0 i, f. R. y68
69
" Y8 B% {' x) A4 O70
; p- T6 a$ N6 V. h# j4 ?8 S! b71
72
+ G4 ?7 M- l% G( V9 K73
74
. z, V* s5 r- z& d/ [75
* B8 I2 g% L/ {& Z76
77
) T: l5 F, S- b* c78
79
80
# U2 f2 N! m/ Z9 o8 v81
- u3 |6 }% L  W5 p82
83
( s  I. C( }3 \1 h9 ~完整测试类
package com.keafmd.Sequence;
* \, D7 P$ j0 l+ e, q
  X% \4 X( r& W: h) L9 D6 I
import java.util.*;
import java.util.stream.IntStream;
! b7 o6 q& }8 h& ximport java.util.stream.Stream;


/**
* Keafmd
*
0 K, w5 }7 k. N; v * @ClassName: Sort
! c& F+ e0 i2 F  s6 D7 q6 I9 i * @Description: 十大排序算法测试类
* @author: 牛哄哄的柯南
* @date: 2021-06-16 21:27
*/
& ]* E+ P, B: _+ ^6 }' R- a) vpublic class Sort {


: q9 z* g5 \* o! {
" C7 X" a- p9 n: P% L7 b
    public static void main(String[] args) {


, y; B. c) p$ D7 g" `/ H+ d) y        int[] nums = {12, 4, 25, 47, 58, 34, 25, 9, 99, 26, 1, -13, 162, 10093, -66, -1};
3 Z" B# J9 B  f* S; [0 N0 L//        int[] nums = {12, 43,56,42,26,11};
$ I5 b+ y- K! g- |$ n        int[] temparr;

3 M' j$ \* R+ L( A& ?9 y( G
        //利用系统Collections.sort方法进行对比


$ S* ~8 s1 k- y. h        //将int数组转换为Integer数组
        //1、先将int数组转换为数值流
        temparr = nums.clone();
        IntStream stream = Arrays.stream(temparr);
        //2、流中的元素全部装箱，转换为流 ---->int转为Integer
; Y& Z: b; f5 o) Y6 W' ]        Stream<Integer> integerStream = stream.boxed();
) c2 h: @2 f) u' ]        //3、将流转换为数组
        Integer[] integers = integerStream.toArray(Integer[]::new);
5 @3 F3 w* ?- v* `7 j2 ~        //把数组转为List
        List<Integer> tempList = new ArrayList<>(Arrays.asList(integers));
8 j, b: `* ~1 O$ u$ L$ `# b        //使用Collections.sort()排序
        System.out.println("使用系统的Collections.sort()的对比:");
4 U9 X2 [/ ?) Q6 a. c/ |1 S

        //Collections.sort
        Collections.sort(tempList, new Comparator<Integer>() {
            @Override
            public int compare(Integer o1, Integer o2) {
                return o1-o2;
- D4 V: {# @( w( h8 p                //return o2-o1;
! C& R, s& v8 t            }
        });

, o9 i# i6 g! P7 [( J6 C
4 Z' P3 A5 K+ @6 G4 t3 p) y# E; F: [        //tempList.sort 也可以排序
       /* tempList.sort(new Comparator<Integer>() {
/ b0 g( g2 p7 q) o. |4 G* h* w            @Override
: [: X  Y8 ^/ K1 b& I) D            public int compare(Integer o1, Integer o2) {
                //return o1-o2;
" A+ t( a/ p: X* Q                return o2-o1;
  m  q$ N% @7 x  r( U            }
0 ?3 v+ s+ X; g$ v        });*/
9 ?1 X% T+ a8 P9 b0 r% Q5 e2 m

7 G" ?- o" ~' z  p  k$ V        //遍历输出结果
        for (Integer integer : tempList) {
$ k+ n4 }4 u, s/ l; |            System.out.print(integer+" ");
  F) R) b) b; f6 d# h5 I        }


0 E# }" C" ]0 H7 f7 [# Z# Y        System.out.println();
7 {: h$ G+ \0 j  T; K( {

5 G. k' P% w- C/ M* c, ?& _        //测试冒泡排序
+ I& _+ ?3 m+ N1 J: x$ g- T        System.out.println("测试冒泡排序:");
/ }3 M6 I* o* E" R        temparr = nums.clone();
0 t; N. }/ m7 |/ n0 f
5 K  n: W) k0 S
        BubbleSort.bubbleSort(temparr);
, s- I6 [4 z6 Q/ c+ t  S. M- V

        //降序
  M' I( |5 V6 D* c4 i* u9 q+ O2 h        //BubbleSort.bubbleSort(temparr,false);
5 y/ L9 @" Q, P/ M5 F4 t9 V

+ W, F0 K8 p6 M& M, k        for (int i = 0; i < temparr.length; i++) {
            System.out.print(temparr + " ");
% ^" V9 ~2 ?' ^( |2 R% p        }
        System.out.println();
  [/ I  ^' @+ S# Y2 x

        //测试快速排序
        System.out.println("测试快速排序:");
9 W9 G. C5 S4 P7 d) t. g+ K. c8 U        temparr = nums.clone();
/ o: V5 v/ R# E) D        QuickSort.quickSort(temparr);
        //QuickSort.quickSort(temparr,false);
        for (int i = 0; i < temparr.length; i++) {
            System.out.print(temparr + " ");
        }
7 z( i+ C, _7 S; f- ?# N/ h( |        System.out.println();
0 S" s% l' {, {. @, ^

) q0 y$ |8 H& ^8 L  [  k$ I        //测试直接选择排序
        System.out.println("测试直接选择排序:");
. f; e/ o$ [; v4 b, A+ U        temparr = nums.clone();
0 k) L2 F; y0 |, [: Z        SelectSort.selectSort(temparr);
        //SelectSort.selectSort(temparr,false);
        for (int i = 0; i < temparr.length; i++) {
            System.out.print(temparr + " ");
4 }) N8 X! B1 U; ^1 c        }
        System.out.println();
5 D& ?3 q' M4 J- l) ^
1 [7 E4 c% f4 H5 r2 Q" a3 y
: i. d& r# |" z6 F4 J        //测试堆排序
        System.out.println("测试堆排序:");
        temparr = nums.clone();
0 c$ ]! k2 T7 T0 \! T        HeapSort.heapSort(temparr);
$ u% r3 o& l6 w        //HeapSort.heapSort(temparr,false);
        for (int i = 0; i < temparr.length; i++) {
            System.out.print(temparr + " ");
& A" E2 R+ ~0 ^7 m0 y7 c        }
        System.out.println();
: ~. G# @: R- v: }
. c5 U, P6 E5 e8 P
        //测试归并排序
        System.out.println("测试归并排序:");
        temparr = nums.clone();
        MergeSort.mergeSort(temparr);
$ q8 J8 Y: L  T0 V& F& _2 {# E; `        //MergeSort.mergeSort(temparr,false);
        for (int i = 0; i < temparr.length; i++) {
            System.out.print(temparr + " ");
        }
% S9 E: z3 ~4 ?6 l        System.out.println();


        //测试插入排序
# m6 Z' ~1 h) g* U0 o        System.out.println("测试插入排序:");
        temparr = nums.clone();
        StraghtInsertSort.straghtInsertSort(temparr);
% [3 O6 M5 j0 z  h+ Q5 f8 [        //StraghtInsertSort.straghtInsertSort(temparr,false);
        for (int i = 0; i < temparr.length; i++) {
            System.out.print(temparr + " ");
. X+ ^+ W0 a1 v% B1 n" u: Y* l        }
        System.out.println();
% A# z  M/ ]- q6 Y; F9 ^

/ a9 @9 B  V7 m
7 T( E0 [6 u+ ]
9 r  g0 ~, I7 ]: N- v. ~! O        //测试希尔排序
        System.out.println("测试希尔排序:");
. l7 a4 t3 |2 u  G& w3 h6 E0 \        temparr = nums.clone();
% I" N. M1 Z* M2 K        ShellSort.shellSort(temparr);
& v( e$ t- m* F# P        //ShellSort.shellSort(temparr,false);
        for (int i = 0; i < temparr.length; i++) {
            System.out.print(temparr + " ");
        }
        System.out.println();

8 g9 _$ q8 u  a2 j
( H  i: a4 C% G5 Z: c2 \9 P

        //测试计数排序
' W) ~4 ?0 Z+ Y7 H        System.out.println("测试计数排序:");
        temparr = nums.clone();
0 k3 M  H0 M8 ^3 l3 q        CountSort.countSort(temparr);
3 Z0 k+ v7 A) k% h' j, D0 j        //CountSort.countSort(temparr,false);
: Z3 _; G% Q/ K3 R        for (int i = 0; i < temparr.length; i++) {
            System.out.print(temparr + " ");
! j6 z+ V* R" W% G* }- G% [# x( p        }
        System.out.println();

& A1 x# N8 C: L9 Y! U
* d3 v# X8 e9 F6 Q! }& d
  K; [5 r/ U7 M8 f# S$ l
: r; }; I( a! v3 l3 T        //测试桶排序
2 |. n9 w: t2 b        System.out.println("测试桶排序:");
        temparr = nums.clone();
        BucketSort.bucketSort(temparr);
        //BucketSort.bucketSort(temparr,false);
  B9 q' W, R3 i4 D        for (int i = 0; i < temparr.length; i++) {
            System.out.print(temparr + " ");
        }
        System.out.println();
3 R( L7 y4 u* ^5 E' i

        //测试基数排序
/ p' z- \  ~( v3 }' ^        System.out.println("测试基数排序:");
5 g# G9 T- d% d. t) v0 |        temparr = nums.clone();
: w' i2 {- q. r        RadixSort.radixSort(temparr);
) i7 v+ h: g5 c$ W  }- m        //RadixSort.radixSort(temparr,false);
        for (int i = 0; i < temparr.length; i++) {
            System.out.print(temparr + " ");
        }
        System.out.println();
7 R% S1 X/ p0 e# T

    }


3 }' H4 e7 G1 M9 o}
1
0 `2 y" Y7 b* J$ }' l% U, o2
3
6 G/ ^0 c! r3 s& _" @7 ?6 q4
+ S& R( S; U, `( {5
6
2 ?3 K2 m4 Z/ N8 c& I. |7
8
* g* b# L; u* q. D7 G9
: M  c$ A" X& I" d* B' d) e- s1 a4 @10
0 D! l% ~6 G& j& K3 }( V11
12
5 D2 @' X+ L7 q# Q' X+ _13
& e; M  r# i& h  ]9 k% G& i14
15
4 w# |- @8 J) p6 n8 F( h' H16
9 e' B/ O/ T3 @# _& |$ p17
1 R2 P! F4 o  ?. W8 J/ R7 z7 }18
/ x4 \/ c& S, e; p4 |" l2 L. u19
" ~& C) P1 `. d; R20
0 J  X9 f, X+ u$ y: d! c! Q( G21
22
23
24
  }) p% o$ S, R& R. g: y! `25
26
27
  b4 ^  a  _# O& {( x) f7 r28
29
30
( l2 }+ {$ E1 C31
32
: j6 j+ t! @! Q& D- p33
! @: G, q2 x# W6 d" C1 D34
1 a9 k' C' x! y& d35
36
0 S  S0 s+ l  G: ]) n8 D. R37
38
39
40
41
" i7 ^, C6 g* u" T42
43
: _( P: z" {) f  F# y1 c( b44
45
46
47
( a) i2 o2 W( A3 c# w/ G( k48
49
50
) s1 y% m% O, _( Z51
: B4 Z4 ~( j2 p& I1 R52
! m0 ]$ H0 h& D7 i+ ]: F53
! C7 E" M1 \9 B$ f" n: @3 g; Y54
# O( A' z8 M0 i, Z" I55
4 v6 w; X# I% n/ O* f- s( s  p+ l56
9 ?$ S" a* g; x  N57
/ t) ^0 Y  [% \* b58
, q3 R& S5 j3 A# E0 \59
60
61
62
63
64
9 O9 [+ p6 y! ~1 A7 d65
66
. Y9 S' I! h& ~2 x/ V67
68
8 h5 b$ W6 [7 ~0 m69
. i: j# s, L$ ]70
71
72
73
2 d+ h7 }9 _; S/ u; W74
( v" _: y6 Q/ T9 Y75
- g- d# }0 C2 _1 z, F76
2 l6 d9 [; E! X; M' h0 @77
78
79
80
7 g- L6 z/ H6 K3 e6 {3 v1 t( V! A81
+ t; @# s- ~% n6 S- [82
83
84
7 {' G" x5 S  I3 P8 N0 |" K85
86
- y( w4 l' o1 j$ L5 q3 o. a87
% z/ W0 A6 D6 ]! o3 m( a88
89
90
91
  u2 F) d& K0 ^% N! y2 h  U92
93
94
95
' y+ y! d8 d$ t0 p) E% r" ~96
" s+ D. }! S+ t& p- @, ]97
98
99
- x* G) [- f0 o100
6 C/ s! \: v0 N, ]* e101
102
103
104
2 |; L/ o+ u7 I2 m% s105
106
/ j, W$ n8 c" [) x7 Q# }* g107
4 M1 x/ k- ^% A' S) I: M108
109
110
111
112
113
( A; `) x! Z0 Z% b9 g114
115
116
117
' }% M/ c+ {6 r: J0 B6 t118
6 I  U2 c. ~; W6 h+ n) L: @119
120
121
122
123
6 l, {5 R0 J1 O/ s4 M% m124
- [7 O; U! M8 F) f+ j- n125
6 i3 l2 c' p4 f8 g" B3 b+ i126
127
8 R. X, A8 x$ x: k; C4 p128
129
130
' L  U# |) g- ?- J6 ?# P! d4 l9 l5 Y" a0 j131
132
133
134
135
136
- \; U7 _% j; ~6 Z9 j137
138
2 {( L6 u1 A+ `( g139
; n* x$ E/ ]4 |$ ]/ F" X140
$ A2 i! e4 |9 \! w, w5 E" v141
+ r. e) A7 ?0 d+ q3 V0 }142
143
# Z& _/ `. ~0 U9 }9 |  m( D144
+ p- _* a% B- p145
9 @5 B: N. E' }0 z: ]6 N, r3 X146
3 Y# e( G- L* m# H" z, q1 f9 c! Q147
148
, j, [( u- W% B" I149
% }: R. J  n& E9 k7 e3 C9 Q150
* ?7 E; O% M/ a7 |6 E; u151
152
153
4 j* P" n+ g. q% ~% _154
/ `1 i* A9 W. w3 ~2 q$ \) _, d155
! G$ Z( G, t. X4 S# ~156
4 Y2 P  k# b( l& Y; F$ m( W157
$ U8 }* |+ Y, w0 D  N158
159
  N, {( k) i6 s4 X! L# M9 [160
) Y. L2 W( Q) q6 A' t7 P161
& P/ C3 `; p7 D: F$ l162
163
164
1 o5 f6 n7 q% B- |% d% ~/ \! t0 h165
1 T$ C& v) R2 |5 r1 E166
# O. ]0 h: p' V* c: F: q167
- ~+ w: v9 q6 w4 e. G$ X168
169
170
171
( V. t* J& U+ T! l2 F172
173
每天进步一点点！
( a8 g: D3 J5 t. S& H  Q+ w不进则退！


. T% x1 t- ^1 i; }! |- U版权声明：
* ^4 @* G  ~/ {原创博主：牛哄哄的柯南
: m7 W8 r) m1 a" l- M博主原文链接：https://keafmd.blog.csdn.net/
————————————————
版权声明：本文为CSDN博主「牛哄哄的柯南」的原创文章，遵循CC 4.0 BY-SA版权协议，转载请附上原文出处链接及本声明。
) U; U! t+ S" P原文链接：https://blog.csdn.net/weixin_43883917/article/details/118193663
4 {2 ^, t: z& L$ }9 |' m8 s
# s3 e7 c  j8 t& x% a$ x

1051373629

每天进步一点点！
4 R$ Y9 _  a- I8 X6 l  P! I/ i$ l+ f