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

杨利霞

经典十大排序算法（含升序降序，基数排序含负数排序）【Java版完整代码】【建议收藏系列】
经典十大排序算法【Java版完整代码】
7 ]9 \3 |4 {8 v写在前面的话
. R( ?$ e4 Q+ I0 i) }, d十大排序算法对比
冒泡排序
# Z+ }$ Y; j  k1 P快速排序
直接选择排序
8 {/ q( z; _9 h6 j堆排序
8 L1 |' `: t8 d( O归并排序
插入排序
* v( C& e( `7 L& G6 p( a2 ]希尔排序
计数排序
桶排序
基数排序
完整测试类
7 \) c( ^2 H* l1 Y: @写在前面的话
       虽然已经有很多人总结过这十大排序算法，优秀的文章也不少，但是Java完整版的好像不多，还存在某些文章代码存在错误的情况，同时也为了自己练手，决定把所有的写一遍巩固下，同时也真诚的希望阅读到这篇文章的小伙伴们可以自己去从头敲一遍，不要粘贴复制！希望我的文章对你有所帮助，每天进步一点点！！！
$ s, @& E6 k1 S$ F9 |  h/ w; U7 D3 p
& r; g6 V# {0 M8 x  w
" c% p( Y, a2 C1 |" v/ {8 h5 W% ]       我用通俗的理解写下对算法的解释，对某个算法的运行过程不是很理解的话或者想看比较官方的解释的话，单独搜索某个算法，看几篇不同的解释，就可以有自己的理解了，这里我主要展示代码以及进行通俗的解释！整起来，再强调一次，一定要自己敲一遍，这样才能理解的更深刻！

1 e# `7 @. g  }; s
十大排序算法对比
% a: x/ _) k, c! r, r8 N3 _3 E7 D
' [2 D2 {4 p- K1 [6 @5 T+ o0 u

! ^$ Q9 i6 X; e* U! a( R$ Y
+ J9 U4 S( ]" H( x4 Q/ L6 u3 I关于最后一列的稳定性，我稍微解释下，例如对序列：1 2 4 2 6 排序，序列中存在两个2，如果我们把这两个2标记上（让他俩不同），排序之后，前面的2还在前面，那么就称这种排序是稳定的，反之不稳定。


冒泡排序
7 z( u1 A# V4 R3 M, b8 _简单解释：
       原理就如算法名字一样，就像水中的气泡一样，每次我都把最大的或最小的放到最后面，这样总共需要n-1趟即可完成排序，这就是第一层循环，第二次循环就是遍历未被固定的那些数（理解成数组左边的数，因为每层循环都会把最大或最小的数升到最右边固定起来，下次就不遍历这些数了），两层循环遍历结束后，所有的数就排好序了。
8 G# X+ `, G2 t$ d- ^1 _3 j8 H& t. n       两层循环所以冒泡排序算法的时间复杂度是O(n 2 n^{2}n
/ p! `6 V) a! @2
, H$ M5 s* ]: B8 k: E2 E )，是一个非常高的时间复杂度，我在下面的代码进行了优化，加了一个标志位，如果上一次循环未发生交换，就说明已经是有序的了，就不继续下去了，反之继续进行下一轮。

) t1 ?. T. x1 G6 Z9 S( }& `7 n


" B* l& D4 B0 P- H
3 D( z3 u! c% O7 s" ^+ @5 V
. N" I1 M, s, j8 J* g! |9 D本文的图片来源网络，仅用于大家学习，侵权联系删除！（下同）
$ h+ ?6 B) d/ }
" z) \; H! c6 d5 @$ f. X
# C9 h+ Y6 @9 g5 U6 r完整代码：


% c! |' F, B8 S) g1 Ipackage com.keafmd.Sequence;


/**
5 l9 ~7 l% H0 S  |% ` * Keafmd
/ q) h& w: Z) C' q *
* @ClassName: BubbleSort
* @Description: 冒泡排序
2 n- U1 K; p; C9 f* E: p * @author: 牛哄哄的柯南
8 p! Y# j7 y0 D, I+ K& v * @date: 2021-06-24 10:31
6 T3 E, X7 b2 p" j6 m6 }! l3 A% ]2 T */
public class BubbleSort {
1 P5 ]2 R2 k2 d# v8 W
  @  ?* ~3 F# h7 C% B7 {
3 @0 D7 D. G9 S  y# M3 T+ D) y2 K    //冒泡排序
8 C. A3 h1 G1 |3 v    public static void bubbleSort(int[] arr, boolean ascending) { //exchange标志表示为升序排序还是降序排序
3 K+ Q+ F2 h1 I" P- a$ {
2 L+ I. F' b& ~3 a; A# D* {
        boolean flag = true; //加一个标志位，记录上一次是否发生了交换，如果是，我们则进行下一轮，如果没有，说明已经冒泡好了


4 S! @7 W& s. Y" C        for (int i = 1; i < arr.length && flag; i++) { //控制次数，第几趟排序，只需要n-1趟，有交换时进行，只有flag=false就说明上一次一个元素都没有进行交换
- h' B& Y, _' n$ v4 z7 L0 P

            /*System.out.print("第"+i+"次遍历：");
+ G6 T) l- e" \. Z) C            for (int i1 : arr) {
                System.out.print(i1+" ");
            }
            System.out.println();*/
+ `. l7 O! G. Q6 @' U# G' R. N5 R
5 W7 X+ W* E, x3 W8 ^
2 w2 I0 ~. k- u! [! b            flag = false; //假定未交换
9 V; F' Y* i8 T
9 o2 }4 Y& |' E) a" `9 I2 v& r" H* E
            for (int j = 0; j < arr.length - i; j++) {


# I9 T2 [7 \  Z5 D5 w* Z9 t                if (ascending ? arr[j] > arr[j + 1] : arr[j] < arr[j + 1]) { //控制升序还是降序
3 V8 U/ r1 J, l* U2 i8 s/ [1 X0 J                    int temp = arr[j];
6 j0 O( y3 d8 R4 \                    arr[j] = arr[j + 1];
$ Z% k. ?  b# e+ k5 _( t8 R7 ]7 W                    arr[j + 1] = temp;
                    flag = true;
                }


            }
        }
    }


    //冒泡排序 -- 默认不传参升序
    public static void bubbleSort(int[] arr) {
) F/ w0 K) @- a/ d% x( N        bubbleSort(arr, true);
  i, l& r1 z0 D3 G    }
( Q% K/ l7 ~- Q% y4 n! L}
% ~+ P6 |, D4 l) k+ q; G1
2 t9 ^2 ~! P$ K# H2
/ O; I8 d- @* P7 }4 |3
4
5
6
6 F6 B0 ?0 L9 d( q6 O( X7
8
8 [9 w  U( M7 S3 J* |( b: k9
2 Y9 b) T/ d. O9 f. d' }10
% Q8 q: r9 [8 {11
5 Z$ g. B) q1 B$ B! O! c  F12
" Z# V5 Z$ j/ ^' M' O. N- O13
( a/ w; [/ j8 G/ O( A14
15
16
: |  r3 K8 N; y6 C  n: k) ^17
, e; Q8 a* P5 V9 E  F3 m$ C% a18
19
! F$ U( ?; a5 Y- K' M! _20
21
4 c2 s; |* y  c: \2 Y22
0 Z9 m& D( w7 K5 G; H" {23
24
25
) Y+ {" ?. E4 h. D5 l26
27
28
: f4 ~1 P6 [, v6 y: S29
9 ]% @* t+ Q9 w6 V' I30
31
0 Z1 `, `* T/ D7 p32
- `* g) _" c) |6 V% m) L33
# s. d9 p4 n3 d8 ]' t& T. I7 Y% I34
35
36
* ?, D0 |2 ^# @6 h, j. H37
38
7 N2 ~4 W! j5 }6 C$ n2 ~39
40
41
8 k$ C( }/ A/ q, c- v42
6 B) v5 C. ]1 r" `6 h43
: L5 {6 X3 h2 f- g44
45
测试代码：
# L8 ]1 h1 `; i8 Y

升序排序（从小到大）

& V  u2 M/ r  G. k& p3 K, J% a
- c- M( d; V& R$ T' M8 Z# X" Q/ R/ Hpackage com.keafmd.Sequence;


import java.util.*;
+ w$ b. ~$ @4 `6 N# K  Uimport java.util.stream.IntStream;
& w2 N: \) q4 mimport java.util.stream.Stream;

" p! j8 X( M# m2 ?
* E4 u$ e+ ]7 L; ~, v8 X$ x/**
6 c3 i; A* x8 t" J1 v * Keafmd
! G5 G! H+ c/ e- U4 W& i$ L *
* @ClassName: Sort
* @Description: 十大排序算法
* @author: 牛哄哄的柯南
* @date: 2021-06-16 21:27
! r- F9 h& [- _/ K: z; [ */
public class Sort {
6 s8 c+ {! `0 |) v& W! V    public static void main(String[] args) {
* u8 z9 k- [: r
8 `  k0 A, |: s
% T1 ]5 f3 y% b5 f4 U- n$ J4 C        int[] nums = {12, 4, 25, 47, 58, 34, 25, 9, 99, 26, 1, -13, 162, 10093, -66, -1};
        int[] temparr;
7 A6 s5 @  ]) V2 i. j! e

        //测试冒泡排序
! J& S5 t! j7 x$ N3 q        System.out.println("测试冒泡排序:");
        temparr = nums.clone();
( j6 ^, X( m' v2 `& ]7 P9 G& T        BubbleSort.bubbleSort(temparr);
3 E) f( O7 V. C! N# r1 {5 `* \+ W        //逆序排序
        //BubbleSort.bubbleSort(temparr,false);
        for (int i = 0; i < temparr.length; i++) {
( W' p+ p, N9 H* U/ w& r            System.out.print(temparr + " ");
1 K  u' x3 c) y1 M# {( @" R" N+ M        }
        System.out.println();


. O0 O1 A" J! R  k    }
" G& Z! P" J! q4 ?4 x* j2 Y}
# K* P% l' G# j" V0 A1
2
, V6 h4 O! L7 i+ Q3
4
5
$ L" |4 _: V" ]6
7
8
* ?; K* x/ L; H9
3 i! u4 V8 P  |" ^10
4 c: ~, J: i3 o" P3 ~11
2 t+ b+ F0 g$ E$ q12
13
. v/ [' P( M4 T: r/ t4 O14
/ B6 k1 y, l9 j0 C15
. l+ W4 Z- W5 u0 B7 y16
17
18
19
: F2 M9 C* Y) l20
21
+ C) |2 g9 |1 ?& b; h22
: T0 P  L& f2 U23
& z+ D* d/ s( v! \6 F24
25
* d# O: M1 Z0 |0 Q/ _0 k26
27
28
0 F& |$ D5 F, x6 f& c29
, h. M0 a# i. [" J/ n' m" s30
. S8 D: H/ W- Y7 S. K" R) x: [3 @31
+ U1 w/ f7 X& ~& v32
33
运行结果：

$ l, @. C) a' m0 f. b/ \, A
测试冒泡排序:
5 ~, G* h7 j8 b! o/ A/ z-66 -13 -1 1 4 9 12 25 25 26 34 47 58 99 162 10093
9 u; Z4 F; V* M$ B# t( b# `1
2
5 ^/ K5 b8 i2 ^& d) C降序排序（从大到小）
8 v* [" b/ l) \( s* m
. a; U; K& ^) B6 `$ ^
5 B6 V; R+ z! s0 @, v5 o  {9 O//测试冒泡排序
1 x4 m; |& _2 j. hSystem.out.println("测试冒泡排序:");
temparr = nums.clone();
BubbleSort.bubbleSort(temparr,false);
for (int i = 0; i < temparr.length; i++) {
    System.out.print(temparr + " ");
, e1 ^6 L/ r% m}
8 q. z8 k) X& @9 X; [5 iSystem.out.println();
; }; R4 K8 c- B: O8 ]  y1
6 f. e" x# D/ I2 G) b; u1 ?9 k# z2
' O; p' D( e- q$ H3 m7 J# p3
+ p/ p, U# a: w  S3 [# h4
5
6
7
( w+ c/ T- i- M1 @7 o  M% x8
运行结果：
$ ]& l, [* d3 {$ z( v
3 v7 N  I% J$ d$ H& g: I
0 X, u9 G0 z+ e3 w  n  S7 Y测试冒泡排序:
& i) e6 x+ l' k% w" q10093 162 99 58 47 34 26 25 25 12 9 4 1 -1 -13 -66
5 \9 n$ y6 k" E' k) H9 d# C1
2
2 R8 q! R7 t. m8 Q) I下面几个算法的测试也就是换了下类名和方法名（换成相应的排序算法），如果想降序就在数组后面传个false即可。我就不一一复制了，我在最下面给出含所有算法的测试类，需要的自取即可。
3 @. d% z& q6 M% H6 T( ?
" u  s& d  O4 z5 z
快速排序
/ `2 T1 C3 s, g" t* Q- C* _简单解释：
/ K0 D4 D" K$ F9 @- k快速排序就是每次找一个基点（第一个元素），然后两个哨兵，一个从最前面往后走，一个从最后面往前面走，如果后面那个哨兵找到了一个比基点大的数停下来，前面那个哨兵找到比基点大的数停下来，然后交换两个哨兵找到的数，如果找不到最后两个哨兵就会碰到一起就结束，最后交换基点和哨兵相遇的地方的元素，然后就将一个序列分为比基点小的一部分和比基点大的一部分，然后递归左半部分和右半部分，最后的结果就是有序的了。


8 I6 G! ~7 I( G1 Y9 j


/ N1 ~  j$ S. g' V. f
完整代码：


package com.keafmd.Sequence;

. e% A. D- ~* ?8 s
/**
. b% z  u2 s% ?1 C( x * Keafmd
5 Z% D. v7 ^  I0 x9 b4 r" b *
* @ClassName: QuickSort
- P  i/ i4 u* {/ B * @Description: 快速排序
6 K. M5 ^. C! M) k: C * @author: 牛哄哄的柯南
, M; O& f: X  J6 F * @date: 2021-06-24 10:32
0 h3 a$ v$ X" S0 w- B */
public class QuickSort {
4 }: O/ T& k! T# Y
2 [6 Z2 Q5 H# K1 H6 S9 Y1 i& V1 n. G
* A2 c8 o" H6 G& \1 C. Z7 x    //快速排序
& y6 T( K' H  _    public static void quickSort(int[] arr) {
# h) q- \1 W! S4 n  |9 V) F        quickSort(arr, true);
6 ?4 V2 H# g( q! p    }
! |4 _" X5 o4 O7 ?" W

" i- j" s& P8 @! V) V% H1 n3 O    public static void quickSort(int[] arr, boolean ascending) {
        if (ascending) {
7 W1 o0 @' p! c4 Q. _# z7 i4 }+ w. V            quickSort(arr, 0, arr.length - 1, true);
        } else {
  |; H, p% S  b% C0 D' B            quickSort(arr, 0, arr.length - 1, false);
        }
1 c' y) ?8 j& D    }
% X0 ?# X- t# q% b3 o

4 A9 R+ O4 d6 h+ Z    public static void quickSort(int[] arr, int begin, int end, boolean ascending) {
        if (ascending)
            quickSort(arr, begin, end);
        else
            quickSortDescending(arr, begin, end);
    }
5 D: u* @0 b5 |% M- a' S" q" U) Y
6 Q+ R; f- ?5 \/ H
6 K, j; F+ m9 @7 ~. L    //快排序升序 -- 默认
6 V$ Q; e6 x0 X# {, R! }$ Q) H5 }    public static void quickSort(int[] arr, int begin, int end) {
! _, G6 q# a; s' C) G/ u        if (begin > end) { //结束条件
& W% s7 r9 d8 a+ c( N8 G' ?            return;
        }
        int base = arr[begin];
        int i = begin, j = end;
' c9 @$ w' U+ J& u( a7 q+ h& Q        while (i < j) { // 两个哨兵（i左边，j右边）没有相遇
            while (arr[j] >= base && i < j) { //哨兵j没找到比base小的
& h6 V5 ~1 ?/ G5 y0 m4 ~                j--;
" h1 q6 P6 ^' R            }
            while (arr <= base && i < j) { //哨兵i没找到比base大的
                i++;
  H: Y& D+ B  x/ [3 n# o            }
% `  `% N- k; q* D3 Q            if (i < j) { //如果满足条件则交换
" a' h: p# _1 h                int temp = arr;
                arr = arr[j];
7 W3 X" V# o# j* W                arr[j] = temp;
            }

3 Q, D, p& o, F7 E  ], q1 O
0 w* S( p- N/ K3 r) D7 b) A        }
        //最后将基准为与i和j相等位置的数字交换
# }+ n; s# Y: Q, Z! h  b        arr[begin] = arr;
0 G8 b0 H8 J% L* ~        arr = base;
        quickSort(arr, begin, i - 1); //递归调用左半数组
; n( K) U" J  b1 b        quickSort(arr, i + 1, end); //递归调用右半数组
6 p; z3 X  ], y, z+ @- E6 ~9 G
& ?. z" D2 w% T; X
% r: z  I& \  H% U! d. x    }
7 I* H+ e  ?; \
! J# w- I# C; J
4 y: ~* U) ^( q2 a' g8 D, c    //快排序降序
- o5 I; u* I# f( f" D. t    public static void quickSortDescending(int[] arr, int begin, int end) {
        if (begin > end) { //结束条件
            return;
        }
        int base = arr[begin];
        int i = begin, j = end;
% O8 i% N( K  X/ W( |        while (i < j) { // 两个哨兵（i左边，j右边）没有相遇
) Q, V% S, g1 I4 \- U! B; g            while (arr[j] <= base && i < j) { //哨兵j没找到比base大的
                j--;
            }
            while (arr >= base && i < j) { //哨兵i没找到比base小的
                i++;
+ u$ u7 e* X: J! A            }
            if (i < j) { //如果满足条件则交换
: [1 f$ X8 a3 _5 e6 m6 I; P                int temp = arr;
& V1 g! f7 [, F/ n* L                arr = arr[j];
3 q) b# |, K5 {/ l                arr[j] = temp;
            }


        }
        //最后将基准为与i和j相等位置的数字交换
        arr[begin] = arr;
        arr = base;
3 \7 Y* ?* p/ l7 B        quickSortDescending(arr, begin, i - 1); //递归调用左半数组
        quickSortDescending(arr, i + 1, end); //递归调用右半数组

7 m6 N/ h; ]  c; p3 f1 l6 K
    }
3 c& m2 d- ]& J- ^  s$ s
+ P1 @2 t% y3 ~
}
# `7 ]8 b* ^1 M9 K1
/ u  o5 m2 H: L3 |4 }6 z2
2 g5 A! M$ Z; y1 v( A3 W+ |0 }3
4
3 v+ o& I  @! f8 k5
6
7
8
9
10
9 t/ V/ Z. K4 L$ v9 y9 h$ `) U3 z11
7 I7 d$ |. ]2 ~; `( t8 F0 q6 x, A5 S12
0 S) Z* J5 a/ X& e13
( x4 y1 C# \2 j- _9 n14
15
16
17
18
19
20
/ O$ E4 p* l- w/ n2 u21
/ _" Q$ N( l# [/ u7 v22
4 W: `; i/ V9 L+ o0 G% E- U23
24
25
* L0 _9 D: m; y26
& f' U. B) {& ]4 n27
5 R" G% ?. \8 S7 d  t: C28
0 I! L0 p% s, g29
, R8 I, D8 p( H! ~1 W) y  Z30
31
. ~8 `2 f; b" L- c3 e32
* z, H; j+ S+ y33
34
35
& S9 \- u1 h( h5 a. |" H& w" L36
; {$ R2 n& m; l5 ?) @37
38
/ w8 q; N* `9 L/ E. C$ x) y39
4 e/ h0 E+ G5 T7 ?2 B1 b' R' }2 T8 l8 H40
41
' Q% }" @9 b; u, r" {42
' f' T- w% T6 M* Z43
, m  h( B* G, L2 o. o3 L7 P44
45
46
47
5 Y  l; F* F" `6 E; E" O3 g48
; B' O  D5 \$ A( H3 o$ I$ Q; R49
! E$ U9 M3 D* B  g/ o50
51
52
3 k7 j3 V. @: G( o5 |53
54
* x, {, N( x2 S7 b/ h7 ?8 G9 B5 H55
56
$ m5 P1 H6 ^+ y3 T0 g0 J57
58
' |" e$ d$ `* H: ^- V59
60
61
* K* `) P) L, V. }62
( i3 M9 ]/ Z6 @3 `* J8 R' ^; t0 [( Z63
64
/ K& P  {3 l) Z$ M65
. h) Z. F0 H' Q# E66
; E: ^$ m) O; U! U# m1 R6 L67
4 q: j& d; z0 b, O/ _; K68
69
# i) G* g/ D' e/ p# r70
. O* A3 \# x7 x. z5 w71
6 ~' b' n7 w) A+ Y$ _$ H9 A* l% @72
73
0 h" I, V' k. K$ r* b* ^3 a74
75
' i" z) Z; a7 G( S6 [76
; O5 \( d2 @+ t6 W6 l77
3 N/ j, n6 I1 n. K% N' `+ c78
79
. K+ H  l9 d9 c: R! e80
81
3 ]. t2 _) A" _2 d+ u( J82
83
84
1 R, s0 \9 b- T$ I85
6 K5 v* |  H, ]* M/ }- z4 {& j' G86
87
! Q" j5 s2 m; p& N; H) g3 D) ?  W88
7 f3 V7 M& l0 d0 ?8 |1 W# ]. s89
90
( P5 [& @2 a! v: Y: s& |0 D  b91
直接选择排序
简单解释：
( D. a- }0 `' L. e! T$ v! S9 ?3 ?. N( t数组分为已排序部分（前面）和待排序序列（后面）
8 D. o' Y5 R; \. \# I第一次肯定所有的数都是待排序的
从待排序的序列中找到最大或最小的那个元素，放到前面的已排序部分，然后一直找，不断缩小待排序的范围，直到所有的数都是已排序的了


* h! Y' b5 w( \7 X) O# u; K$ \

! ~1 o! m: Y4 i6 N' |* M

完整代码：


. x# W7 h$ L! V. o8 \package com.keafmd.Sequence;


' Y7 [. r& N' t' Q) r/**
* Keafmd
*
8 s  R( {- Q# w8 ~0 S, S! S: \2 Z * @ClassName: SelectSort
1 A& g* `( a6 u2 {  [ * @Description: 选择排序
+ d5 }3 L1 ~1 E4 h/ _1 y/ w$ E * @author: 牛哄哄的柯南
* @date: 2021-06-24 10:33
8 A7 J* `+ O* j9 [) J */
' M7 J; n% q8 u) v0 M- opublic class SelectSort {
  J* U( n) b* a9 b8 T  I7 o, q

6 V5 m5 d  ^& P& D- q# Y$ I  I    //直接选择排序
0 `( |1 A2 ~5 J6 W! P0 c    public static void selectSort(int[] arr, boolean ascending) {
        for (int i = 0; i < arr.length; i++) {
  P7 ?7 n, @4 ~- C            int m = i; //最小值或最小值的下标
            for (int j = i + 1; j < arr.length; j++) {
                if (ascending ? arr[j] < arr[m] : arr[j] > arr[m]) {
                    m = j; //找到待排序的数中最小或最大的那个数，记录下标
                }


            }
            //交换位置
8 T6 b, }5 m4 g( Z2 p            int temp = arr;
            arr = arr[m];
+ A7 H1 Q9 `" z/ x            arr[m] = temp;
  ?- W, f& e; ^

7 }7 r7 p" E! y$ B        }
% h7 |- y) G8 d1 \$ [    }


    public static void selectSort(int[] arr) {
        selectSort(arr, true);
    }
6 U) s" M" T/ [) z. j}
1
7 @& S) `7 o6 }* }% Z/ S  ^) q2
3
1 E& M+ j+ @) U# {, d4
5
' H: ^1 O7 P3 D: @6
; I3 l1 z" l: ^! x: ~! M8 f$ e: J7
8
9
; D6 {3 ~/ S/ h" a2 `10
11
6 o! b, L* b+ G! @) H! a" k6 q12
13
$ ~# x/ }! T1 J14
15
- ~: S( x4 z# f+ D! j1 w6 H. ?. r16
17
18
19
20
- B3 H$ n  a/ e6 m/ @21
, Q" _# h* [8 b- ^, t3 D22
23
8 x8 V% ?+ k6 S, s. P7 R" B" K24
- A3 C1 Q- r. M4 t5 J5 \' |0 Z25
0 q; d- g8 [/ T! ~3 ?- q7 V& j, ?26
27
. c0 Q' u! \7 ?+ N8 K+ ^6 @: |28
/ C* r7 \1 R( L4 D5 q3 _29
- y# P$ k: z- g+ e30
( `8 ?; U6 _- }1 b9 ^* M- w4 R5 A31
32
33
34
# \$ K4 |% e: q8 r5 g4 {堆排序
先理解下大顶堆和小顶堆，看图
. @' ^/ {/ X4 V* e, t, G* t& Q大顶堆，双亲结点的值比每一个孩子结点的值都要大。根结点值最大
小顶堆，双亲结点的值比每一个孩子结点的值都要小。根结点值最小

3 H& x& x; G7 a4 `9 F( \: ?' D

* s! H. n8 }$ B* H5 Q
2 W' C  e5 q3 L# P# Y* M" R简单解释：
0 K; S# J2 x7 e/ p. O* t构建好大顶堆或小顶堆结构，这样最上面的就是最大值或最小值，那么我们取出堆顶元素，然后重新构建结构，一直取，一直重新构建，那么最后达到排序的效果了。


4 j5 n8 V1 C: Y3 q
" M) }# e5 m+ n9 C
+ I0 G9 B- Q! d" a/ p
4 o( U6 Z+ i4 ~( \
完整代码：


package com.keafmd.Sequence;
* T( q8 ^9 s6 v  U

/**
* Keafmd
*
* _- q! T( `: n' V; v( G. c1 d * @ClassName: HeapSort
6 F' X. c& U+ {, @2 {4 F' ? * @Description: 堆排序
. e: Q9 [. F8 f) t+ P1 }4 m * @author: 牛哄哄的柯南
' b. H4 V( L1 n * @date: 2021-06-24 10:34
*/
' E0 p0 \# {9 K8 e1 a& |public class HeapSort {

. c$ s$ V7 x* S+ i
* X8 x# j5 V& H. f4 P1 J/ t! j! O6 ?    //堆排序
# {1 q3 E0 g. ]( f7 T  {$ V$ Z    public static void heapSort(int[] arr) {
        //对传入的数组进行建立堆，这里默认建立大顶堆，进行升序排列
        heapSort(arr, true);
    }
8 P- K2 ?5 o4 u! J9 N5 t  L

    public static void heapSort(int[] arr, boolean maxheap) {
/ {" C# C) |# J; S0 E' b
" r8 a7 |$ q% |9 i% _" b0 q
        //1.构建大顶堆
        for (int i = arr.length / 2 - 1; i >= 0; i--) {
, A7 z, x" j+ Z            //从第一个非叶子结点从下至上，从右至左调整结构
            sift(arr, i, arr.length , maxheap);
        }

7 X$ v0 P" L3 ~. w
# P1 K! @  M3 L, Q2 L0 R9 H) R0 i+ r        //2.调整堆结构+交换堆顶元素与末尾元素
        for (int j = arr.length - 1; j > 0; j--) {

' h. |+ i7 ?; |$ T# I( \  d
# R8 W- D/ r8 C& V6 w            //现在的数组第一个就是根结点，最小值所在，进行交换，把它放到最右边
. q0 |$ V; N& Q0 J            int temp = arr[j];
% G5 X  l% Z) m' |$ R. S1 X' e; e) J            arr[j] = arr[0];
$ u* k& ^6 S! M% Z0 n6 t9 \4 S            arr[0] = temp;


7 W4 B; [8 R6 W  c, z( D            //重新建立堆
            sift(arr, 0, j , maxheap); //重新对堆进行调整
        }
    }
6 R+ m* {" P/ B1 w! B) J/ d

    //建立堆的方法
    /**
     * 私有方法，只允许被堆排序调用
     *
: `. o9 x5 z4 k& a: h2 B6 H     * @param arr     要排序数组
     * @param parent  当前的双亲节点
     * @param len     数组长度
     * @param maxheap 是否建立大顶堆
     */
0 f6 [+ V# n& P# t& q8 k* N! g    private static void sift(int[] arr, int parent, int len, boolean maxheap) {

, r5 A( n% o: c% O$ Z
: S2 I4 K$ k: b6 u        int value = arr[parent]; //先取出当前元素i
4 r7 g7 Q9 r9 R" }% U7 F
1 r# _, Q7 T- |2 w& W
& k! f& _$ R( P7 N& a) x        for (int child = 2 * parent + 1; child < len; child = child * 2 + 1) { //从parent结点的左子结点开始，也就是2*parent+1处开始

; j3 E6 q$ O7 I" E* i0 L- G0 B+ U
            if (child+1 < len && (maxheap ? arr[child] < arr[child + 1] : arr[child] > arr[child + 1])) { //如果左子结点小于右子结点，child指向右子结点
                child++; //右孩子如果比左孩子大，我们就将现在的孩子换到右孩子
            }
6 a2 v5 S( T3 i# ^

: r% k# T) d+ F            //判断是否符合大顶堆的特性， 如果右孩子大于双亲，自然左孩子也大于双亲，符合
            //如果子节点大于父节点，将子节点值赋给父节点（不用进行交换)
            if (maxheap ? value < arr[child] : value > arr[child]) {
9 O4 f( C: x! V& I5 H6 J                arr[parent]=arr[child];
                parent = child;
7 F4 X. G6 `$ X" |7 g/ l            }
( }' m5 l1 [; D' }" j0 O; h            else {//如果不是，说明已经符合我们的要求了。
3 w2 |. i. e; o6 _& ?* G! c; a  E                break;
            }
: T; A& n4 A, r4 e! w* h        }
9 }+ [& b6 \! @* W( u        arr[parent] =value; //将value值放到最终的位置

% T% f1 G( Z& |+ L1 U0 c) @, F- S8 I


    }
3 ]$ A5 }  \7 O( L' f! g: M
. u* \3 T# [. v$ s" B( z" b4 G) \
% T+ B* o! X8 n/ H! ?}
, _3 e( \/ n# H4 k1
2
3
* h7 a) o# I! c( v. o4
; L9 d* b/ v% Q* C1 O) }5
6
& r, y" |: p) u3 s8 f7
, [8 v8 O* n, K& b6 Z8
9
10
8 ^2 S3 P7 i  b) |9 `9 A11
% m& n- U  T- ]6 x5 R12
: z: w6 @" Y: {. v7 L13
) W6 t3 B9 x: X  R2 r; k& C14
15
; p) y7 ~0 C3 p9 [4 |6 y16
( H. v+ T- @8 t4 C: Z17
# h0 B3 f0 m+ [8 o2 f7 r- q18
19
20
21
6 R1 r* |! r' J2 g1 j' d  R& C22
23
24
  n5 _$ o. y/ z5 x2 Y2 K0 R* \7 Z2 r25
26
27
( Y) b* j6 z* ^2 e" \3 l9 U. t28
( f0 z9 `& y0 J/ W) ^29
30
: c, _0 |( I8 k! w4 P31
9 Y( t9 i; E# y  ]; u  L32
5 n0 o0 A5 S7 U* j6 B: G1 \33
34
0 D# b* K/ n6 z, i+ D9 ^* P; v$ J6 l35
36
37
38
39
40
41
42
43
# M1 T, _1 t/ _/ T. x5 E# b44
( o  u* x1 m) Z5 y1 i: f' N7 }+ N45
46
8 w1 b, T7 S0 Y+ E/ C47
# r8 _. l, |8 g- ]$ m* p1 J# w) u48
- Z0 k; J" P* _) _6 v49
9 Q" N3 G8 \# n7 I50
51
52
53
54
55
56
57
% ?, G: P& ?# C1 I58
& |) L# r  u2 L59
60
61
2 o3 k$ @/ m- e62
63
7 A; l& y- `$ q1 O* F2 G, X4 U/ i64
65
66
4 ]0 ~9 M! A6 \4 K7 O$ i9 D67
68
" `; C' U* q. {% R, _1 D69
70
71
72
4 w% m2 ]3 e; A! ?# z) v73
0 E+ X% a& O: K. N8 s8 f* M74
归并排序
& t* q9 k- S! r% w  E简单解释：
: z* r$ r* k! o2 {5 a7 d该算法是采用分治法，把数组不断分割，直至成为单个元素，然后比较再合并（合并的过程就是两部分分别从头开始比较，取出最小或最大元素的放到新的区域内，继续取两部分中最大或最小的元素，直到这两部分合并完，最后所有的都合并完，最后形成完整的有序序列）

& ~  R3 u; M1 V3 w
- J2 F) c$ _* o3 H. N5 _
% t: a5 l9 t3 O# a  G$ ^7 @7 L
9 \. z0 L  v$ s5 n% n0 X4 A

完整代码：
1 {% D9 q7 x% G. S3 w

5 w  \, T3 ^5 bpackage com.keafmd.Sequence;


. |8 V& _5 y; t* O4 t/**
* Keafmd
*
" T+ D5 L: Y/ B$ p/ m: A8 ? * @ClassName: MergeSort
* @Description: 归并排序
1 l: y5 U3 h8 y% } * @author: 牛哄哄的柯南
* @date: 2021-06-24 10:35
4 p) b. U) [3 u  u5 k+ f */
1 A3 N6 q8 J! U( Q! ~public class MergeSort {

9 C' J0 m( d  f$ Z* v. t; L; [
    //归并排序
    public static void mergeSort(int []arr ,boolean ascending){
        int[] temp = new int[arr.length]; //在排序前，先建好一个长度等于原数组长度的临时数组，避免递归中频繁开辟空间
        mergeSort(arr,0,arr.length-1,temp,ascending);
- i9 x' z$ ]6 {7 N    }
6 N- \) e) ^8 s. ^3 W6 {    public static void mergeSort(int []arr){
        mergeSort(arr,true);
+ |# t) V/ |1 S" G  Z    }

" r% Z  |# N& H  C* y4 x
* |6 J1 _3 R1 d- t! x# ~0 K  W    /**
     *
     * @param arr 传入的数组
9 F) v9 B" G6 T/ ~' H. k1 X  \+ l     * @param left 当前子数组的起始下标
& O6 x1 x; j3 L2 R     * @param right 当前子数组的结束下标
8 k2 b- z7 P+ B, V" j' x, x     * @param temp 拷贝暂存数组
     */
  z8 x; h+ _0 h& c! c9 {    public static void mergeSort(int []arr,int left,int right,int[] temp,boolean ascending){
        if(left<right){ //这里是递归结束的条件，我们是对半分，那当left==right的时候肯定大家都是只有一个元素了。
% J4 n2 m  a% q" z" m* 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; // 防止越界的写法
4 C8 `- Q1 K- W: o            //int mid = (left+right)/2;
( J- n$ s* \" ?2 ^* l9 e

7 W* B* Y4 h' {% r/ t% N, E            mergeSort(arr,left,mid,temp,ascending); //左边归并排序，使得左子序列有序
            mergeSort(arr,mid+1,right,temp,ascending); //右边归并排序，使得右子序列有序
# G, s3 M, p: ^0 s) a2 e
7 r" P( v6 T$ ~. C0 Z
0 i2 a6 ]% x7 C+ Q            merge(arr,left,mid,right,temp,ascending); //将两个有序子数组合并操作
        }
( i& C0 P  J2 n* W! e/ W+ m    }

7 b" l' i' ^0 i3 W3 c6 J
/ @/ m) G) K: v    private static void merge(int[] arr,int left,int mid,int right,int[] temp,boolean ascending){
+ I* R" Z7 S9 R' ]        int i = left; //左序列起始下标
        int j = mid+1; //右序列起始下标
' C2 B7 G! V8 A0 ]6 C        int t = 0; //临时数组指针
1 \/ K4 H, u4 Q  I        while(i<=mid&&j<=right){
            if(ascending?arr<arr[j]:arr>arr[j]){ //比较两个序列第一个元素谁小，谁小先拷贝谁到temp，然后对应子序列下标加1
$ G$ `$ E: T. R6 C6 p                temp[t++] = arr[i++];
( Q. s; y/ t3 D4 |! b" n/ U5 K            }else {
                temp[t++] = arr[j++];
6 \7 N% j) k! M) H            }
        }

( h8 `) O2 j* S$ X# L% {  ?; B
) i$ {* j$ ?' z' ]( j: n        while(i<=mid){ //将左边剩余元素填充进temp中——左序列有一些数总是比右边的大的数
            temp[t++] = arr[i++];
# `, W& S/ U, ~% Z* d& [        }


( h3 E  D6 X) o/ {- e/ q: a2 ~* w9 ^        while(j<=right){ //将右序列剩余元素填充进temp中——右序列有一些数总是比左边的大的数
$ \! `" G; O- k, y! H" K( C. I            temp[t++] = arr[j++];
        }


        t = 0;

: b0 s' Z: C, [% R) _1 @+ }
        //将temp中的元素全部拷贝到原数组中
        while(left<=right){
            arr[left++] = temp[t++];
! O% h+ ~( d7 [        }


+ W7 E: D$ k# A' ?8 w* `; Z    }
/ H, }. ~3 R$ b) b6 o) R
/ i' u* }" m( d1 Q0 p7 k* F
}
1
" @5 ^7 I! P  _# k5 S+ N2
3
9 ~4 r' h' ]7 @% t- p' d0 [+ v; g4
5
7 {# L) o$ l1 s/ X' D6
5 J; `# d& W; c. o5 G+ T7
$ H, f4 J# J# h9 c1 K  {! [! u# D8 V1 B- U8
9
10
11
12
+ ], M2 \) y8 e0 {7 d! K; Z13
14
15
16
) |8 S' `$ P9 C* W+ k" L2 y7 v17
0 C- _! [) C$ i1 |- q" i18
19
20
7 E" ?9 j+ U0 t21
22
2 Z. \" `+ `& P) ?# z23
24
25
3 }1 S, u! m+ t# c+ M# N6 L26
: P' ^8 {7 L# n. {27
28
) p9 K& N/ o; p" ?29
30
31
- N; q4 u# f- C# F8 C2 d32
33
34
0 ^8 u4 Q2 `5 s% i; K35
36
37
" j$ B1 ?6 V" w) E0 u3 p8 _38
39
* p  a! d! Y' N8 G( i40
41
42
43
3 t3 }: I9 `6 N4 g5 X44
45
46
47
  A! D7 ^3 c/ N! t; [  Q, I* p8 N48
6 M; }% |$ B  _7 C' p/ }, ^49
50
( y8 ^2 o; z# @) k  h$ u51
# \* Y" n' M  U2 |- o52
53
0 k; z5 t/ Y+ ], z8 ?54
) S' B4 ~! r/ e" M; j* W55
56
57
58
: e' ?/ |/ {- o6 m59
* s: Q- B  F% r) a60
# W1 W( e( Y8 F  H61
& E4 F- D; Q6 T8 Z62
63
9 Z4 z8 P! b% b1 b64
8 Y2 S# @1 a6 a$ @. }) j% b" |65
3 T- L" q5 j) d9 g3 w& M  M66
2 b, [( Z; k' h: C$ n6 f67
68
69
3 S) h5 ?8 o5 L7 |$ q70
71
72
0 ~# |& v% D8 r% L1 ]. C73
1 q3 h- `7 p$ {, a. ]/ l. M, m插入排序
0 a" X' F9 [; |+ x简单解释：
% ~& s: P: r9 L5 r1 @7 F' F最简单的理解就是打地主时我们拿到牌后的整理过程，从第二个牌（假设我们拿起来这个牌开始比较）开始，（说下升序）从后往前比较如果比前面的那个牌小，就把牌往后移动，直到找到一个合适的位置（这个位置的前面的那个牌不比这个要放下的牌大）就把这个牌放到这个位置，慢慢的前面的部分变得有序，直至全部有序即可。
: I- _# d4 u4 V, L" s% i0 S3 F5 O0 H


1 j: @3 V* n6 j" o
; ?# O; E# L2 [" x+ g/ U6 Y: a  m
" w; X/ B( Z% R
3 l- H& s, }5 A; U, G' _! S( p完整代码：


) ]1 d; {% o4 N" ~0 I/ ?$ Bpackage com.keafmd.Sequence;
% U8 o1 d8 F0 K* Y8 B

" X# t9 C7 j% }0 ~/**
8 b* }$ s: Z& z+ Z9 I8 _& E4 P& e0 l * Keafmd
7 a4 H6 m' Y8 M! [0 [9 l *
* @ClassName: StraghtInsertSort
, ^1 s9 N2 O# ^1 o% q9 h- _ * @Description: 插入排序
: @" Q. ?& B$ c * @author: 牛哄哄的柯南
6 z. f8 F7 E/ q  P& [% ~5 B * @date: 2021-06-24 10:36
( D& n* x6 U5 @; d* l- y4 ?4 F */
public class StraghtInsertSort {
; \8 e4 u( n/ B+ j5 W4 s    //插入排序
0 {8 }+ x8 `% N! d$ E    public static void straghtInsertSort(int[] arr) {
        straghtInsertSort(arr, true);//默认进行升序
; }! a" ?/ o1 P0 P4 r# w    }


. x0 T; M5 q  C' F" o0 ?    public static void straghtInsertSort(int[] arr, boolean ascending) {
) `7 j# ?" x& `  s# _

- }1 h" Z* {- D- u: |        for (int i = 1; i < arr.length; i++) {
! t1 E4 f2 [" k            int temp = arr;
  \# G$ }6 M. a# [  F            int j=0; //这就是那个合适的位置
2 s  x  s  V4 K0 }! v+ Z            for (j = i - 1; j >= 0 && (ascending ? temp < arr[j] : temp > arr[j]); j--) {
                arr[j + 1] = arr[j];
" V; N& v0 f$ b1 R) E            }
5 Z4 _1 \9 R! p7 }5 y  x            //把牌放下，为啥是j+1，
! v8 `) c- U; M5 L            //是因为上面的循环遍历到不符合情况的时候 j是合适的位置的前面的那个数的位置
            //有点拗口，但是就是这个意思，看图方便理解下
            arr[j + 1] = temp;

! D) v% K! f. |' f; \4 q* Q
! `, \9 U5 t. p: X  |+ n
3 o; x, Z. o- I( J6 N. f7 T
& p# Y7 S) L, `9 ?5 q! j        }
* p8 F! a. u4 D) Q

    }
}
5 Z3 Q$ [6 W( ]1
2
& y2 A+ W0 p8 R& s: C' S# i$ d  U3
4
5
6
7
! z( `" ^% \( C- c0 ?" B$ G8
9
10
11
12
13
  i. ?: x2 N  {, t14
15
16
( H. L: n- }. k; U2 V17
1 P. a( q* V, f; h0 P) N0 m18
19
20
. q" N; \6 P& N! t8 B21
22
" C$ O9 @. ]& c2 V! Z1 ?7 }" w' y23
4 X% r) h. A. r  k9 B3 L. x24
( w/ Q* |- J  K2 Q) f25
26
27
9 }% M7 ?) Q, K! C' u7 p/ ~4 f28
( \3 y7 R1 I6 `5 C) j; m29
* Z/ L7 @8 A2 Z& z" Y1 k3 U( }* B30
31
6 z  I& L: f' h: X32
33
# P6 v1 p  g1 e1 {34
希尔排序
简单解释：
2 `% o* Q! E' j% N8 H* h希尔排序是插入排序的改进版，我们理解一个叫做下标差的的东西，也就是下面那个图中的增量d，初始下标差为arr.length/2，然后继续/2，对在同一下标差（相当于把这几个数单独拿出来了）的若干个数进行插入排序即可。
: r  |% ~$ H6 Y9 ?1 l9 h" @' R' I
( a# J/ s% W0 `' l& G
" z- [% X6 {$ H, m
- Q1 O6 C5 Q1 V  W0 s1 ~- R+ Y6 ]

3 k: [) _) X( k1 N
) X* R& I3 B* i! _$ z5 T完整代码：

( m) g$ n$ V( @" u# v& b3 A
package com.keafmd.Sequence;
! Q! ~* Z/ @( o5 @
* W7 l& ~, C- p) ?( V
2 D( C7 `- [# Q4 R9 e1 s$ D  T) N0 w7 ]/**
* Keafmd
*
* @ClassName: ShellSort
* @Description: 希尔排序
* @author: 牛哄哄的柯南
- x% Y5 B) H6 d; u * @date: 2021-06-24 10:39
, z& w( t9 P" d9 f */
) C% w. Y  _% D+ |public class ShellSort {
" j- T# H6 n/ D1 D2 I& y7 `& L1 t4 }
& O& t# o0 u, W- b- G
    public static void shellSort(int[] arr) {
        shellSort(arr,true);
    }


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

1 j# _, ]0 v5 g! @; b1 ~+ u
# C3 f2 P; w: r& h) g( |0 R        for(int d = arr.length/2;d>0;d/=2){


% G. r( d( z: C3 O: r            for(int i=d;i< arr.length;i++){
9 `; _# h0 N4 [5 x+ B3 f+ W! I                int temp = arr;
& F& Q5 w: ]9 U: y+ M% G1 N                int j=0;
                for(j=i-d;j>=0&&(ascending?temp<arr[j]:temp>arr[j]);j-=d){
                    arr[j+d]=arr[j];
                }
                arr[j+d] = temp;
            }
        }
4 Y; @. X$ Z4 L1 J

( E$ J9 X5 C) T    }
}
, T& y) u  N. `1
2
. E! C% b% i/ H% J3
4
( E% \$ B$ a+ \! C, r+ j! L; {5
1 L0 a% Z. O$ m0 A6
7
6 ^+ t3 j: B2 h- g& }! O8
- b, [7 t# z' \. N% R7 E9
10
8 A" r* G8 H( Y$ X! a11
" `5 t. s, T0 o% h" |3 Q12
13
; x! h, {2 J# B5 c/ V14
15
; G- y) B  d1 T" A16
. d9 j2 [3 C" b1 ?17
18
: {( g2 f2 [: {. `( |19
20
9 \6 D8 }  ?6 x8 @21
9 E- O5 G6 ^1 [2 \/ H22
23
24
+ b: G0 k' M2 M$ z8 R& q25
8 @3 l( {. \# p8 d- r# X  N26
27
& E; C3 h/ v1 T0 t8 I  H28
+ ~+ x% A( l4 L% _2 u29
30
31
32
$ a& q) Q( t) G" I( X6 b计数排序
6 V, a. r) i0 h  D, W% P简单解释：
0 Z  U  B/ }! D3 @, U2 |这个排序算法看名字也很好理解，就是就是额外找个数组来计数，然后在这个数组从小到大或从大到小把数取出来即可。

5 I5 u* {3 O0 ^5 t
! ~8 Q) w& V- L3 ?
+ G4 p- Z) f3 v5 C% J
  K* n3 Q5 P* G- @; o; B* a

- `0 y$ h2 Y* D+ k& G2 n完整代码：
* P# V3 j0 ?. R* v' j

. A4 w4 f3 T+ hpackage com.keafmd.Sequence;
, i* U# G) C% Z+ _5 U+ f

; S2 g4 k% L5 K+ A5 S- |/**
/ m& b  P8 a5 V" o1 K * Keafmd
7 w, P! Y. j  B7 q% H. W9 S! T, o *
& @2 b3 f2 T6 c+ A" @ * @ClassName: CountSort
* @Description: 计数排序
8 e* |, y" r9 k' H4 C( K * @author: 牛哄哄的柯南
* @date: 2021-06-24 11:31
& @! d: l$ {2 z6 K3 O */
public class CountSort {


5 ~; t- W5 I- t  f' j    public static void countSort(int[]arr){
        countSort(arr,true);
    }


    public static void countSort(int[]arr,boolean ascending){
        int d,min=arr[0],max=arr[0];
# b, O7 z: Q& a+ F( y0 H0 [5 }0 n5 w
2 J: V4 L0 T4 Z5 l& J
        //找出最大、最小值
: F- Y& v# }  C4 Q        for(int i=0;i< arr.length;i++){
            if(arr<min){
                min =arr;
            }
8 Y% a- x" q" q. K" x  f            if(arr>max){
* E3 A3 `7 W, H0 R                max = arr;
            }
        }
! s1 L2 K; h$ t& H
; G  t! t3 v/ p  S$ L" C
7 G, T) ]; w) C5 J" A        //建立一个用于计数的数组
) q' _8 K9 x% o# {. S        d = min;
        int[] count_map = new int[max-min+1];
3 g; a3 c/ l1 }, g) R        for(int i=0;i< arr.length;i++){
5 X( x# \' F) ?9 \" H3 r            count_map[arr-d]++;
        }

8 r! e$ p8 j" f
. o1 P9 K" A- b! R        int k =0;
) A' M% _9 c4 H9 A7 w" |3 _9 q$ _        if(ascending){
* f, O2 ]. c+ I. n            for(int i=0;i< arr.length;){
  F6 B- p  r3 }8 ^# Q                if(count_map[k]>0){
5 I8 R% H9 H' M/ N                    arr = k+d;
                    i++;
                    count_map[k]--;
0 b- e& k* ~' Q                }else
                    k++;
            }
$ A3 U' U3 l+ a! ^5 ?        }else {
8 g. r+ e! j* {$ z* ?0 l$ O5 V6 o            for(int i=arr.length-1;i>=0;){
; k) R! G  p; G/ |: o/ o. ]' V                if(count_map[k]>0){
                    arr = k+d;
8 s/ R4 \( ~4 s( |                    i--;
                    count_map[k]--;
                }else
) J$ ]. ?. P& Z9 Y" e1 Q+ @1 n8 J. |                    k++;
8 R9 A1 r$ w5 B            }
        }
' J9 w. E6 d" U6 y+ w- ~
+ ]' F0 X9 v& v/ B& \
# v- D4 i7 P4 X/ v" }5 h    }
/ R" V  V& H; c' @# i/ {}
1
2
3
4
5
! U2 ~- `% Z4 u# D! F6
5 x2 O9 `- }  Q6 ]7
8
9
10
11
12
13
: D3 e0 e, i1 b9 h9 n! i  T14
9 `; n4 ^- I0 S+ h& l15
16
3 i0 k- p9 q& m- h0 |; H17
& W; U9 n( E* @; \18
19
' d' j: b# {0 N: R' |3 F( e20
21
# u0 v' w1 B+ R) ]( b* J; q: {  r7 a22
23
24
25
9 _1 u2 n* Y6 f: x- ~* n7 C9 L6 X26
8 j6 [/ H/ p8 x9 F' v. S27
9 K- Q9 {5 K: P' a- E8 [+ k28
, x2 g1 q' _5 t3 g7 q29
0 y) y3 k3 x/ E. Y30
- Q6 j3 T% c' G7 ?31
# `7 I. z! a0 m% J( k* s6 k; [32
33
' g- T' P- U0 L2 H34
% `. g; r2 p8 Q. j& ?$ t# R35
. e2 P% ?9 B4 N! X36
0 F7 X: F* a5 J8 |  K/ m% j) L. Y37
38
' G/ T1 H. m7 }7 D" P39
. T: s* n5 q+ h, B; H% T% t40
41
42
' Z9 `$ H* a0 C! G& `43
44
45
7 y) T6 v8 t: I/ J  J2 A46
47
: X+ ?4 v: V, _48
49
50
" S7 R+ y% ?( i, _% G8 I51
52
8 n+ P' g& e5 l0 D5 Y2 H53
54
  Q" U; y8 l$ F  Q' `55
56
. Z& M: Z9 @7 T. u6 T57
! b$ W, g0 K  H58
1 y6 ]/ k7 |/ ~* C7 A59
+ x1 m& @* x* L( Z! `% D# R8 K桶排序
5 _3 |" I  a; }- k7 g简单解释：
就是把一个数组分成几个桶（其实是几个区间，从小到大或从大到小的几个区间）装，然后让每个桶（区间）有序，然后取出来放一起就可以了，相当于把几个有序的段拿出来放一起，自然还是有序的，当然需要是按照区间的顺序拿了。
, O# ]  M4 g4 D" U7 y! j, T5 P* [

. S9 m+ N3 ^/ z, c" q+ o
1 B8 ?- n. x' W$ d( |


" f7 m' V* k" \3 }完整代码：


* t. p+ i5 I, ?3 }package com.keafmd.Sequence;

) U: ~# w3 Z* k, n
; H1 D. Z1 ^/ K/ R) [0 Mimport java.util.ArrayList;
import java.util.Collections;


4 ^% B6 [1 T3 X  Q5 ^/**
* Keafmd
" _0 \4 ?( i! U. x0 F# A/ ?1 o- H0 } *
/ Z/ o9 S; c! m/ O, h$ p& T" w * @ClassName: BucketSort
' h: L$ \5 h; X2 q2 Y- k5 l * @Description: 桶排序
  Q9 \$ i4 M2 }: e; v% w4 C * @author: 牛哄哄的柯南
* @date: 2021-06-24 13:32
*/
public class BucketSort {


, {! N7 |3 ?" I) h/ B2 [0 |/ C    public static void bucketSort(int[] arr){
        bucketSort(arr,true);
    }

3 \4 W% f$ R$ b' p
4 l0 s, I  \& r' w( h5 U    public static void bucketSort(int[] arr,boolean ascending){
        if(arr==null||arr.length==0){
4 w+ y; z5 U2 v, c2 T0 O            return;
        }
        //计算最大值与最小值
        int max = Integer.MIN_VALUE;
        int min = Integer.MAX_VALUE;
        for(int i=0;i<arr.length;i++){
            max = Math.max(arr,max);
            min = Math.min(arr,min);
! `* Y: x% Y& O        }


        //计算桶的数量
( L& N, W5 W" Y; w/ `4 n        int bucketNUm = (max-min)/ arr.length+1;
1 M; d4 K! ^% C6 R1 a  N) x8 u7 r        ArrayList<ArrayList<Integer>> bucketArr = new ArrayList<>(bucketNUm);
        for(int i=0;i<bucketNUm;i++){
0 a- V' }8 @0 m8 Z            bucketArr.add(new ArrayList<>());
1 C2 x& \2 m) f) R' M        }
2 ?! y4 B  c  k; {( _" G
( U" a. Q% x6 |: q7 t/ r
) i( {. r; d$ i# V        //将每个元素放入桶中
        for(int i=0;i<arr.length;i++){
" V" C9 x8 o5 F3 J            int num = (arr-min)/ (arr.length);
            bucketArr.get(num).add(arr);
        }
/ f" L5 X$ V3 b. v

        //对每个桶进行排序
  f- X1 O9 f, R% G' z        for (int i = 0; i < bucketArr.size(); i++) {
; R0 K7 X+ W% P/ d* y            //用系统的排序，速度肯定没话说
            Collections.sort(bucketArr.get(i));
        }


        //将桶中元素赋值到原序列
7 U9 m* R8 t' l2 P        int index;
7 J* Y, m$ Q, g5 d' q5 U4 s9 ^        if(ascending){
            index=0;
* m* w, C; Y9 w- N. N        }else{
            index=arr.length-1;
        }
; G6 ~6 e3 a1 A* f

        for(int i=0;i<bucketArr.size();i++){
            for(int j= 0;j<bucketArr.get(i).size();j++){
& u6 y: ?' Y) o! A# k7 Y                arr[index] = bucketArr.get(i).get(j);
                if(ascending){
3 B/ t) k5 f( m8 s$ d9 ]9 Q+ R" A                    index++;
/ c2 r' Z! m! b5 r                }else{
$ C+ G. D' L" J, `& Y' h# b3 Q: h                    index--;
                }
            }
4 ?+ _8 K. f1 N0 v' P1 d

        }
4 X* p/ `8 }# X; l

    }
}
1
9 D- d& p3 T: J* y! _, I. G2
3
4
5
9 z. Q- b9 g4 j) m" `/ g5 r+ V7 U6
/ ~- w6 ?. T' g$ K( Y/ b" l7
# \$ w! h, z; D: V* E8
9
0 D( r5 p+ b1 L' b) z4 A" y' d' h$ }10
11
, i& M, ^+ P) y% s12
13
14
! g, N9 P+ k* l15
16
' u2 D: q8 @7 f- V, t0 ]" Q5 V17
18
0 N! l4 C4 V6 _% K$ A7 ~3 K19
" q0 z. i& Q% W$ B0 H. J) ?# E" S20
21
4 c+ x- B% _8 e$ Z3 G7 S" @6 k" ^/ F0 H22
23
24
# O. I8 B: P! s8 o25
9 u' X! e5 k# k( V$ J" X& G26
27
. g7 _  M* Y. c' ^9 g28
! V- }: E  L0 ^5 d: F29
30
3 e3 E( w' a" t9 U% @31
32
* L0 v. n% b1 t1 x' x% k1 [33
0 G1 _8 p0 j$ ?34
35
7 F5 w0 C- y8 k& x! }36
37
! s1 X& W& D! R! g3 h9 C38
39
4 X4 I2 f! ?+ _& j40
1 f2 P. v+ N7 ~; ?7 T41
42
43
  }( r9 f0 g; f" U- m# |44
- ^, j* l/ ~, x. `1 H45
46
47
/ A  d- p: N/ {( h: }% [& Q" ~48
: H( G8 C  K9 V; J' ?49
50
51
52
53
54
: }; h2 B. r' @7 m55
( |( J1 Q. x7 e7 O56
7 w! H% e' E3 i  w& ^/ }: E9 d" I57
58
59
) P$ h) d. ^8 ?4 E. F6 ~: c60
61
6 e% S/ l3 j9 G+ Z62
4 l5 C2 x8 h) k* m63
/ [, K2 A3 ^- @& O  M64
65
66
7 i0 F; P& L& b9 Z- [) J  V67
, {3 R4 D3 K: o7 K+ V- q68
69
70
; q+ \; V6 C8 t' h71
( V7 d; }- F. q8 r: P% |/ R, x72
基数排序
( R. I  r# r& r0 K, B简单解释：
首先说一下，我发现好多人写的基数排序只能排序正整数，其实只要处理下就可以排序含有负数的了，就是我们排序前先把所有的数整体变大（就是减上最小的负数，也就是加了），都变成正数，然后排序好之后，在减下来（加上最小的负数，也就减了）就好了。
基数排序就是按数位排序可分为LSD（从最低位[也就是个位]开始排序）和MSD（从最高位开始排序），下面写的事LSD基数排序。
7 j5 N  Z2 G% z3 E' U基数排序就是把数按位考虑，让后我们一位数只能是[0，9]，就是我们在考虑某位（个位、百位· · ·）的时候就只看这个位的数，放到在[0，9]相应的位置，然后顺序取出，最后再按其它位这样操作（上面说了要不从低位开始到高位，要不就是从高位到低位）




! u4 u& B4 w9 J& J  V8 X6 W
" ~* v/ Y1 p9 @  l9 P" b0 @
完整代码：

9 d3 D# k3 m/ a9 t
$ u3 d7 \7 P4 L" G0 c1 Opackage com.keafmd.Sequence;


8 v; ?. {2 F' J% V/**
5 P' o% w* p' g4 C * Keafmd
6 I9 b4 x, p* j* b; I: {5 Z *
* @ClassName: RadixSort
* @Description: 基数排序
3 a+ F. o4 h9 o8 t- q5 S+ E% K * @author: 牛哄哄的柯南
* @date: 2021-06-24 14:32
% K( G5 {/ {6 b  \0 i */
public class RadixSort {
    public static void radixSort(int[] arr){
( {. P2 Y- e4 I1 z8 J3 W        radixSort(arr,true);
    }
    public static void radixSort(int[]arr,boolean ascending){
        int max = Integer.MIN_VALUE;
9 T" a6 h+ ^' J4 n9 R7 M/ x        int min = Integer.MAX_VALUE;
        //求出最大值、最小值
        for (int i = 0; i < arr.length; i++) {
            max = Math.max(max, arr);
" w+ P& M) E$ v$ g1 W) [, T            min = Math.min(min, arr);
        }
        if (min<0) {        //如果最小值小于0，那么把每个数都减去最小值，这样可以保证最小的数是0
            for (int i = 0; i < arr.length; i++) {
                arr -= min;
6 R- F( `4 A; B7 l            }
1 z2 W7 }: @# Q            max -= min; //max也要处理！
        }
' W9 g' r5 i2 ]% S        //很巧妙求出最大的数有多少位
: D4 b' i' X% l7 W. k        int maxLength = (max+"").length();
        int[][] bucket = new int[10][arr.length]; //一个二维数组，一维代表0到9，二维存放符合数
7 T$ h) p! i% f! b& Y; o* `        int[] bucketElementCount = new int[10]; // 用于记录0到9某位存在数字的个数
        for (int i = 0 ,n = 1 ; i < maxLength ; i++,n*=10) { //个位 十位 百位 这样遍历
            for (int j = 0; j < arr.length ; j++) {
                int value = arr[j]/n % 10;
                bucket[value][bucketElementCount[value]] = arr[j];
0 b  G, j2 I2 u5 S2 S! P, H                bucketElementCount[value]++;
            }
5 A1 M6 i/ L! x" u0 j

! j3 S: }, a: g5 w0 Q1 ?7 b            //升序
& d0 X' [, i' C& \3 S            if(ascending) {
; [& O9 u1 u, t$ R7 K                int index = 0;
7 l5 K- {. m! Z1 Y3 g                //从左到右，从下到上取出每个数
                for (int j = 0; j < bucketElementCount.length; j++) {
                    if (bucketElementCount[j] != 0) {
9 P( x9 p+ c8 [. \                        for (int k = 0; k < bucketElementCount[j]; k++) {
$ a5 R0 [/ i, C% W# h. d, {6 k3 i                            arr[index] = bucket[j][k];
                            index++;
                        }
                    }
                    bucketElementCount[j] = 0;
                }
            }else { // 降序
& T9 \, g9 I2 ~0 u                int index=0;
                //从右到左，从下到上取出每个数
                for (int j = bucketElementCount.length-1; j >=0; j--) {
                    if (bucketElementCount[j] != 0) {
                        for (int k = 0; k <bucketElementCount[j]; k++) {
" s# `! a0 z5 e6 g4 Q( l; `                            arr[index] = bucket[j][k];
                            index++;
# o  e; g8 I1 e4 _9 I. f                        }
) r9 p! E. ?0 `# u- E. y+ ^* n% l                    }
                    bucketElementCount[j] = 0;
: ^- x1 E. G3 M) J                }
            }
- F. M$ p& E% C- r! x$ v
/ q; {& P% P' C- F

2 R. y6 c; l: J
            /*for (int i1 = 0; i1 < arr.length; i1++) {
                System.out.print(arr[i1]+" ");
$ F6 P* D* i$ G# ]0 V" |1 P            }
* |0 T8 @- Z$ `- m' \            System.out.println();*/
8 u2 g( h5 d3 i- P8 W

# X& e5 R7 s! n; _' M7 D: f8 i
( ]" G2 x7 |% ~" \0 V
4 A' {3 U0 C# R  }/ X% G
% ~  L0 D% `; f: P+ a; w* {8 g
        }
# c2 t1 k4 P$ m        if (min<0){
            for (int i = 0; i < arr.length ; i++) {
2 O) d6 Y% G) q. `3 }, e                arr += min;
( l# K6 j/ H9 U( T) ^% p" X            }
        }
; V; M; c% |; \

    }
}
# {7 {1 z1 d: R  U& s( ^1
2
6 ?8 {2 V! |  K7 r8 v3
) Y) |  \) l3 E$ b6 W3 P) E" r4
5
6
( ]' f0 w" T! p6 ]1 N7
8
9
* D- Z- w$ q5 t, ]$ G' v0 S10
11
12
13
14
# q2 h7 k, S1 w  S1 C7 ~2 a15
6 S* d$ J" D# e5 Q16
17
18
19
20
21
22
4 j6 W( \. s% q23
24
( s1 o% \8 J5 U) o# a25
26
" G4 _% s4 L* D8 P27
28
1 [# m* A+ i$ g4 h% {29
! N: H0 _$ F% s- c: v9 p2 f30
2 l! z* ?# \9 Z9 ~6 V31
: j. Y: v3 B) [32
& X+ J- f; B7 K33
34
0 E1 g+ G7 B9 V8 g8 i9 p4 ]1 ^+ P35
36
37
38
" R4 N% K& a! i+ }# N8 z39
40
41
42
43
44
' h- g" ^( c6 B: @$ T9 m45
( \* B5 X# c) b9 J46
47
48
4 k# r# Y3 N1 c- J$ h! \# m9 E5 Y49
50
1 G6 Y* A/ M3 E5 _/ |. T+ T51
' w0 w) N3 n" _  ]1 f# U52
53
- o9 l& O; a" n9 T& K54
! I9 S1 ?( F$ j0 E1 Q55
: q. [7 J7 s5 [$ w2 Z+ H) g% P56
57
58
59
# W* m. k: E+ U/ d& O( X; g  }60
: H$ n  d4 u) N5 [' W: k% S61
62
63
64
65
66
. r) t* p+ q& l1 o( \7 s& O67
3 q$ C2 A2 A$ b. [; K3 j' `68
69
70
, \2 P7 N( e$ G4 }4 J+ |5 G- b5 y71
72
  b( Y6 K& H( i1 }' t73
0 I9 Q9 f/ y& k* s" q1 C74
75
76
9 P/ y' A8 z. e0 A0 K9 Y$ \# ~8 t77
' f' x4 {! Q, }3 s1 ]2 a- z78
79
5 ^# S) e* ?- C* t% K80
81
* t; W% w  J6 q; u) e2 i: y( z  s82
# m. m: E2 b# X8 J8 P83
& U$ [7 [2 a8 @完整测试类
) r; @( Z# r6 O5 j7 ^" xpackage com.keafmd.Sequence;

# n7 }2 ~; E8 c2 p
! ]; O4 y2 m# n$ O9 \; f1 U# V# B+ Nimport java.util.*;
import java.util.stream.IntStream;
import java.util.stream.Stream;

7 F- U1 F7 L7 G" N/ _- h4 K. J- |
/**
5 W3 W& w8 A+ U! w0 e: h * Keafmd
* ]3 a# g- i5 J$ [ *
9 W) P3 I/ X# Y! c+ y8 j  O" N * @ClassName: Sort
- {( Q# u/ A! V+ L- B- q' ~ * @Description: 十大排序算法测试类
* @author: 牛哄哄的柯南
8 \& v1 q1 k3 O8 J * @date: 2021-06-16 21:27
+ K% g2 H' s$ L1 l, n */
public class Sort {

* d# C' Z+ n6 d, _/ K
3 y7 ^3 v. s% ?- x/ S

    public static void main(String[] args) {


        int[] nums = {12, 4, 25, 47, 58, 34, 25, 9, 99, 26, 1, -13, 162, 10093, -66, -1};
//        int[] nums = {12, 43,56,42,26,11};
        int[] temparr;

4 O' b- f- [* S+ R  z/ v( \3 B
/ V& ]# V0 V1 j1 g+ t$ h) K        //利用系统Collections.sort方法进行对比


* ~4 s: i3 X* _3 N/ C1 a        //将int数组转换为Integer数组
% Y$ j2 h/ N! n+ c8 ^        //1、先将int数组转换为数值流
        temparr = nums.clone();
; ~3 m, J6 J' y' F! F% G  W        IntStream stream = Arrays.stream(temparr);
        //2、流中的元素全部装箱，转换为流 ---->int转为Integer
        Stream<Integer> integerStream = stream.boxed();
( \( j: O( R; s# |        //3、将流转换为数组
+ @& K& A  y1 J+ ?( V. x        Integer[] integers = integerStream.toArray(Integer[]::new);
4 n) y* t4 t# s# M5 i        //把数组转为List
$ V$ d  P! Y+ p' z; C        List<Integer> tempList = new ArrayList<>(Arrays.asList(integers));
        //使用Collections.sort()排序
        System.out.println("使用系统的Collections.sort()的对比:");
# u8 B- ]9 u  d6 r1 ]8 G
8 |8 k  s8 J; _6 b8 V
        //Collections.sort
        Collections.sort(tempList, new Comparator<Integer>() {
5 z/ M, o% o5 L            @Override
            public int compare(Integer o1, Integer o2) {
                return o1-o2;
& l/ \" H  f. A9 j/ s                //return o2-o1;
            }
        });

5 @) \, T3 `* }  U
5 s, H$ R4 E) ~( Q/ U: l        //tempList.sort 也可以排序
: K+ r$ k% Q% h" j2 ]! ^! D       /* tempList.sort(new Comparator<Integer>() {
            @Override
            public int compare(Integer o1, Integer o2) {
2 o/ r/ |! }' J0 l$ z                //return o1-o2;
* {4 v5 W) V, @. i* D9 N- @3 o                return o2-o1;
            }
        });*/

# q0 E' C; C2 O
+ L( ?/ A0 Z2 \( \" \! a        //遍历输出结果
, @! r/ p" S3 H/ ~) ^        for (Integer integer : tempList) {
            System.out.print(integer+" ");
        }


& ]8 x. Q  V5 U- ^4 V5 l0 u        System.out.println();
# a- X& F  K- d( ^3 ?1 p2 `

        //测试冒泡排序
- _$ l# Q% u# R' w. p( p. w; K0 |        System.out.println("测试冒泡排序:");
9 [6 b9 B, a5 q" N        temparr = nums.clone();


4 a7 H- S- U2 j- P- R  Z- l        BubbleSort.bubbleSort(temparr);

. z2 g; \/ {: `. P  x8 c( T2 X$ [2 U( I5 a
* L9 _( [, T: U1 ]. D        //降序
        //BubbleSort.bubbleSort(temparr,false);


        for (int i = 0; i < temparr.length; i++) {
4 f0 Z0 B( D( ^! b1 s% h            System.out.print(temparr + " ");
0 j# I6 v! I/ E' ?% s2 R, Z        }
        System.out.println();


0 j( O" k6 O( C/ A2 }  A  f        //测试快速排序
        System.out.println("测试快速排序:");
. r8 @! i/ p$ h# ^  P1 e- y& S) j. y        temparr = nums.clone();
        QuickSort.quickSort(temparr);
, s, S& g7 I  ~5 y: ]" ^        //QuickSort.quickSort(temparr,false);
  [, ?, O. B+ b( B4 M4 }        for (int i = 0; i < temparr.length; i++) {
, `( ?+ Y* N) n- u# A( ?: G            System.out.print(temparr + " ");
) I3 D, M3 n6 k        }
        System.out.println();


  [$ \# u% q4 }: }3 F* I5 }        //测试直接选择排序
        System.out.println("测试直接选择排序:");
        temparr = nums.clone();
6 G; Y8 r$ n& M7 Y6 T7 V        SelectSort.selectSort(temparr);
8 k% ]6 Y* C# Q+ p" O( {6 F        //SelectSort.selectSort(temparr,false);
        for (int i = 0; i < temparr.length; i++) {
" \4 t0 a0 W/ w- p            System.out.print(temparr + " ");
+ |2 @8 M2 W* L% ?2 {9 ?2 \        }
+ J1 O! Z) }0 _3 S( z- \        System.out.println();
: k+ f9 E+ C8 T+ o

; D8 I. t  x+ J$ F" J7 v' S0 |        //测试堆排序
0 o* U" ]5 f7 Y' i" I5 k        System.out.println("测试堆排序:");
        temparr = nums.clone();
7 ^5 f9 x9 k# s; d; h4 B        HeapSort.heapSort(temparr);
        //HeapSort.heapSort(temparr,false);
        for (int i = 0; i < temparr.length; i++) {
            System.out.print(temparr + " ");
        }
' z3 k; J0 ]. N' z        System.out.println();
, j7 _" \, @! L1 b/ u  _
7 X$ \4 S; a" |+ Y) U  G# B
4 b1 m5 a5 Q( _& |        //测试归并排序
5 P* h: e, F& r9 z# c% L2 a4 g        System.out.println("测试归并排序:");
' v1 l* r, w' R0 E+ L- X& r$ f        temparr = nums.clone();
        MergeSort.mergeSort(temparr);
        //MergeSort.mergeSort(temparr,false);
        for (int i = 0; i < temparr.length; i++) {
            System.out.print(temparr + " ");
3 ~; X8 d1 B) w/ P3 c7 x; m$ k        }
& z1 R) z. z0 ~/ }( M. S        System.out.println();
  Z  P5 @5 k$ l5 g4 t$ _( x/ |

8 S2 j, }0 j! S7 ?- \4 @/ L        //测试插入排序
1 z1 U, Y/ r1 F6 `; e5 u' u2 K" n        System.out.println("测试插入排序:");
6 G0 C4 y8 `. e+ N( P        temparr = nums.clone();
        StraghtInsertSort.straghtInsertSort(temparr);
) r( u& G% l& c: v- O. a        //StraghtInsertSort.straghtInsertSort(temparr,false);
        for (int i = 0; i < temparr.length; i++) {
            System.out.print(temparr + " ");
- `# v. t4 U$ ^* q$ I        }
        System.out.println();

4 R/ b& I8 s& I) P


        //测试希尔排序
        System.out.println("测试希尔排序:");
0 o9 t' q3 I% j4 v) Q; m: _4 _8 c        temparr = nums.clone();
- V( d% V. d+ s- F$ P* v$ m4 U% P8 C        ShellSort.shellSort(temparr);
        //ShellSort.shellSort(temparr,false);
% T' j: I1 \: s2 X4 p1 o7 ]        for (int i = 0; i < temparr.length; i++) {
            System.out.print(temparr + " ");
        }
) b" V+ o% `8 M/ c- @        System.out.println();
" n5 o6 N0 A' K  U
( T7 {+ g) Y. P" u" G2 r) C8 q2 \2 e

, q9 c) \6 f/ E' I
# f( y& `; j' Z  {        //测试计数排序
7 ^# f9 g# \( W( u        System.out.println("测试计数排序:");
: V8 y  {: o5 c        temparr = nums.clone();
        CountSort.countSort(temparr);
        //CountSort.countSort(temparr,false);
        for (int i = 0; i < temparr.length; i++) {
" J" x$ j; L3 Y# L5 x' d6 s            System.out.print(temparr + " ");
/ D1 ~; {1 F. X8 `% @# T8 S5 u        }
$ R. i& R) F" x% }        System.out.println();

/ x" @* M( i* P- m, h9 k/ B0 [# P' q7 _7 a


        //测试桶排序
        System.out.println("测试桶排序:");
0 C% [4 C7 n1 J2 X$ {; ~- H* a        temparr = nums.clone();
- z) c& ]* U+ J8 s        BucketSort.bucketSort(temparr);
0 D: h1 u/ y% r, J4 H' w: t# g0 A        //BucketSort.bucketSort(temparr,false);
. i( c! V; O2 M" [$ q  ~3 J        for (int i = 0; i < temparr.length; i++) {
            System.out.print(temparr + " ");
6 E  s2 a8 O8 U( M& V        }
        System.out.println();


        //测试基数排序
        System.out.println("测试基数排序:");
' m' x; e5 }0 p3 }) L; }        temparr = nums.clone();
        RadixSort.radixSort(temparr);
7 \7 Q. Z' P3 v6 P% ], o& ^4 \        //RadixSort.radixSort(temparr,false);
        for (int i = 0; i < temparr.length; i++) {
# e8 e5 t4 I& I% ~- U            System.out.print(temparr + " ");
: i* Z0 P+ g! W% ?" O" b3 V5 d        }
* s0 E: Y1 u2 h+ m) y; z% q        System.out.println();

& b6 p5 {9 `! g
    }
+ h6 C8 _6 C5 B! g

- @6 l' w& n# c}
1
9 k: `5 x- G# p# N* U' o+ ~$ Y2
3
! ?, @' ^1 y- s' I7 f4
) S' \" a: \  T$ [5
1 f/ z+ B5 p3 @9 R# z$ ^6
& E( r2 ~  m) ]& W7
& z! ~( W5 ~& `. W# S6 [$ P/ q$ \# X8
3 [. j9 X& ^* h# T" K6 P0 [; [9
10
: N  ~4 K* [3 b+ S/ h  j11
$ @0 _( [8 s" M! m12
13
  C5 Y' ~, B& G( b' Y$ M8 G14
2 S) O, d7 p, O# U3 Z$ ^3 D# @15
16
17
18
9 l% w& h9 J0 t9 }5 P19
20
" \' Q1 ^0 [# f6 w$ u& g21
: j6 D3 G  R/ j& F: t22
23
24
25
26
" a+ K: a3 }( {) j/ X27
28
& e1 b7 ], L4 n& Z, |( k6 c29
30
3 M( ~5 J) j4 }6 V. q' x. j. E4 n31
  }6 g) R1 M$ A32
33
34
" N8 c* e9 Y% H0 {35
36
37
38
39
9 K2 D/ ^+ v- C# k3 d! D% R1 ]  T40
41
! H8 O# m; A& v& b! I5 }42
" J# y( V9 c6 m/ @43
% ~4 ?! L" ?; m3 @44
5 N, s/ |8 g% `2 X9 m. g45
46
7 `0 Z/ |' v# B: [' ^47
48
3 I- _5 Q' u: W+ P' `: r49
$ F5 t0 ]% q" e9 [( ]50
51
1 z/ H) j$ o( z/ }& c52
! G3 L9 e; k, E( j) p6 c% o* b3 |53
54
55
56
# S: s) ]) s- N4 _. W) m1 o57
* h. _9 H5 c/ j; Q8 {58
59
' J6 V7 m7 I" K, W6 \0 C, t  f60
, T6 K' h+ U8 J7 {& r' J5 r; Z61
% A; K! p' u' U9 ]( J/ N+ ?62
63
64
$ T6 D: X( Y+ a0 L1 x# U65
66
67
' h3 p/ R* a7 Q$ c5 j7 i68
3 L" L* b4 U) u; J5 L+ ~69
70
71
72
0 K( Q- ~2 ]6 _! ^3 J73
1 C: J6 h; X9 @! q# ~74
, R/ j9 P0 \3 y1 w1 ~. G75
76
77
78
79
/ c( V7 `* q' I: c3 [4 N1 \, X80
81
82
; S7 j, m$ L. n+ S0 y: y" Q+ i1 r' p' P83
84
4 e6 ^+ {1 g5 F- F, U% y85
+ @. s- r" v" S. `* E86
; C5 i% ~" v, f$ a87
4 Y1 K4 V" j6 j( C, b# v+ D  I) ~6 \88
89
) G5 ~+ o5 a) y" ^90
91
" j+ M  J& K% m7 m2 |92
) a4 S" V% r  X1 ^, g# P1 T93
8 G) i; d" a! q94
95
96
# ?; K! Z* A9 s# N* Q! F* x" r97
98
/ W- t7 K/ e' `4 Y; s7 P99
100
101
( K% @0 Q9 b, e102
9 n& X3 X; P$ b2 B9 y& q* O103
# b: w& J  X5 O( U( |+ U104
105
, f8 l" @1 n- f, n6 o106
* A# D  s7 y2 \7 }6 r; s! m107
108
& h+ `/ N$ Y$ o) t' U# E109
" ?+ M- c( W3 k9 G110
7 M: b3 j: z+ A6 Q7 Y111
; K) v6 O: u5 ^( C112
113
: f0 c' s/ |  w* K$ p! _: o7 [114
* Y! H7 B4 Y! R115
: z- d/ b& {/ I$ j7 B116
8 ?* B+ d3 l- j117
118
% |+ K* P4 ?& x% K. v119
8 X9 u% T! C" S120
121
122
123
124
; d3 i& @  {. o. r: U+ K. Y125
126
127
% w5 s- r: i3 G2 ~0 a3 C128
3 M3 }. O! ^# @9 W129
' a- G0 E$ a: l& @  o6 ^7 }130
131
. p2 Q/ r9 l; \# C, w; R. }( c132
133
134
0 u, z8 B. w# v0 n1 b- f" Q135
/ t. o+ }+ d: }) ]- I136
137
138
& m; k$ K- r3 H( q9 B4 E139
140
141
4 v3 O! T1 n' k142
143
5 u) y' p; P1 [7 B( G144
145
* k& L6 S% R* O  b; v146
147
148
149
( F* s' J1 l0 v/ b$ O150
( R: i0 E3 U4 t* y$ v7 U8 w151
152
$ l! {7 a8 F5 O9 `+ X: j153
154
) }/ W' w' x6 v: h" `1 H" r! H3 O' ~155
156
157
158
159
160
/ K. ^. G6 L% c# t# e; Z2 s, ?" g161
1 @  v% c# P2 K4 A& `162
163
8 X2 E' G+ O& h+ `8 i# C& c2 x. ]9 }164
165
2 U" z, G/ u) I; [6 I166
7 T# H! l5 c& }  d: H167
168
8 J: J& B2 \# ~6 {/ t, u169
170
, L" H; j8 i' f/ s$ x171
! h! |3 c0 l/ n4 T5 A( D172
173
每天进步一点点！
( `& I; s2 o$ u* w$ ~, U不进则退！
. @  N8 v& ~, C1 Y1 M! U) T
' z+ p$ c4 S* [/ J# @
版权声明：
" h( L9 o" f# G9 j) ?原创博主：牛哄哄的柯南
0 y) H- u5 ^* j3 X* n/ V& I! U博主原文链接：https://keafmd.blog.csdn.net/
: k' S1 g0 A1 ^6 B8 X) r————————————————
版权声明：本文为CSDN博主「牛哄哄的柯南」的原创文章，遵循CC 4.0 BY-SA版权协议，转载请附上原文出处链接及本声明。
2 o; b  ^% v7 N6 z; l原文链接：https://blog.csdn.net/weixin_43883917/article/details/118193663

2 [2 p. Z' X% M, y' |* B
" m: N' G) A- Z$ Y: S9 I

1051373629

每天进步一点点！
/ c* Z) x$ w9 j