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

杨利霞

经典十大排序算法（含升序降序，基数排序含负数排序）【Java版完整代码】【建议收藏系列】
0 d/ @- P/ y, t  H, D, R经典十大排序算法【Java版完整代码】
* y* @" @: Y* J5 a) c写在前面的话
6 V2 \7 O' h" J" n* x; a2 m  V6 x, E; @十大排序算法对比
冒泡排序
快速排序
直接选择排序
堆排序
归并排序
6 \9 _/ ~: V: ?3 U插入排序
希尔排序
( D( f+ s% C7 _$ O计数排序
桶排序
基数排序
完整测试类
& D3 h/ `) B% G写在前面的话
! z; I3 g7 ^% C1 l8 a' Z: y8 k       虽然已经有很多人总结过这十大排序算法，优秀的文章也不少，但是Java完整版的好像不多，还存在某些文章代码存在错误的情况，同时也为了自己练手，决定把所有的写一遍巩固下，同时也真诚的希望阅读到这篇文章的小伙伴们可以自己去从头敲一遍，不要粘贴复制！希望我的文章对你有所帮助，每天进步一点点！！！

; }' x+ L9 K3 A" K: `' D! y0 @
       我用通俗的理解写下对算法的解释，对某个算法的运行过程不是很理解的话或者想看比较官方的解释的话，单独搜索某个算法，看几篇不同的解释，就可以有自己的理解了，这里我主要展示代码以及进行通俗的解释！整起来，再强调一次，一定要自己敲一遍，这样才能理解的更深刻！
% p% Y8 |- z' Y  e

十大排序算法对比
0 r+ j# j8 w, C$ b. r
0 T, H5 h2 k* ~3 |
! M6 S! X8 q6 n. U
- U% Z5 W( S# y$ N
/ R5 W# y3 J& Q关于最后一列的稳定性，我稍微解释下，例如对序列：1 2 4 2 6 排序，序列中存在两个2，如果我们把这两个2标记上（让他俩不同），排序之后，前面的2还在前面，那么就称这种排序是稳定的，反之不稳定。
( M" C& G, H( C
. V8 \* K" c. L6 h$ T: V
( Q, L! V9 `5 F9 O' B冒泡排序
- R4 b  b, s! Q2 D简单解释：
       原理就如算法名字一样，就像水中的气泡一样，每次我都把最大的或最小的放到最后面，这样总共需要n-1趟即可完成排序，这就是第一层循环，第二次循环就是遍历未被固定的那些数（理解成数组左边的数，因为每层循环都会把最大或最小的数升到最右边固定起来，下次就不遍历这些数了），两层循环遍历结束后，所有的数就排好序了。
* F: V" |1 P; v& c4 L$ Q       两层循环所以冒泡排序算法的时间复杂度是O(n 2 n^{2}n
2
)，是一个非常高的时间复杂度，我在下面的代码进行了优化，加了一个标志位，如果上一次循环未发生交换，就说明已经是有序的了，就不继续下去了，反之继续进行下一轮。
* Z: g( }' @! v- w+ N( U


. F* `  }/ W; ~' f3 q$ G3 v

' d' u4 `5 J3 ^6 N/ z
本文的图片来源网络，仅用于大家学习，侵权联系删除！（下同）
$ L8 a4 h, r, n) Z# C; `
$ Z+ m* m9 y' j; q0 W) B4 H- k
  b/ i4 H" _4 Q6 J- r( v/ W完整代码：
6 j/ x% q9 o- Q9 {

package com.keafmd.Sequence;
) _5 V. D/ }8 `4 m1 @

/**
* Keafmd
) s! L- T. u( M; ]; t  G *
# E2 U* ^' n! q/ n" @7 f * @ClassName: BubbleSort
* @Description: 冒泡排序
5 ]0 Q. _, q9 v1 K" o6 v& u * @author: 牛哄哄的柯南
* @date: 2021-06-24 10:31
; U6 y$ Q5 `. F' ?0 J */
4 s, m* ]9 ]8 `: ~8 x1 Spublic class BubbleSort {
% W6 f& @7 [% \; i: G

" W) X2 ~0 {; W' \    //冒泡排序
    public static void bubbleSort(int[] arr, boolean ascending) { //exchange标志表示为升序排序还是降序排序
) D  o7 Z& _2 F6 ]2 w7 T# z

- H# x) ]- F8 ?6 g        boolean flag = true; //加一个标志位，记录上一次是否发生了交换，如果是，我们则进行下一轮，如果没有，说明已经冒泡好了
2 I6 S) t$ ?+ y7 v; {& G

1 G) W! ^4 V3 I3 H# o: ~        for (int i = 1; i < arr.length && flag; i++) { //控制次数，第几趟排序，只需要n-1趟，有交换时进行，只有flag=false就说明上一次一个元素都没有进行交换


6 }* T& T8 |" o2 Z1 n% o            /*System.out.print("第"+i+"次遍历：");
            for (int i1 : arr) {
. ]2 V3 A# ]7 d# p1 C; O" V* z                System.out.print(i1+" ");
            }
            System.out.println();*/
- N5 O! C  N3 K. a

            flag = false; //假定未交换

. l& e# A' F) H# Z4 P
" k! P* [5 k' g            for (int j = 0; j < arr.length - i; j++) {
# i2 S( A* Q/ s# H# d

, [. q) w: Y  E1 @6 _- J                if (ascending ? arr[j] > arr[j + 1] : arr[j] < arr[j + 1]) { //控制升序还是降序
: d- ?7 n. K, b                    int temp = arr[j];
5 D. x- ]- L6 T, J7 ^$ \                    arr[j] = arr[j + 1];
                    arr[j + 1] = temp;
                    flag = true;
2 z& `0 V$ G/ N$ T5 t                }
3 F7 w- p5 m6 j/ q% x0 n
) t& _* a/ ]; j- c+ z( \
            }
# h' w1 X4 R. L! D' J$ I6 q" t" W        }
    }
! \% W4 c  U$ ~% @

    //冒泡排序 -- 默认不传参升序
8 t& U$ `; N5 B+ y9 P# _# v0 h    public static void bubbleSort(int[] arr) {
        bubbleSort(arr, true);
    }
}
1
2 S4 m7 y$ f7 }, n2
* `, R& ~: A- E7 A3
4
5
# g7 v6 H* B4 n7 D# @6
) T6 u' O9 l! M8 W# S7
2 W* p8 ~% h  J( D; G2 \/ G, A2 K) m8
1 T5 i; w% E* l9
10
& w" W$ X3 B' _% ]9 A11
+ \# c# T1 W2 D! N& M; ?! k, A* o12
13
' E2 B# T- \$ n/ Q$ s, J14
15
; f+ Y) i" K1 ?6 m2 v4 }16
4 p4 A" f) {6 D17
% T5 Q+ B. o$ `: p' M/ W5 U/ n18
3 d" K4 m1 ^1 K* F/ {4 l7 L19
* f2 Q4 k) s  t8 `: `( `20
$ `) H. s; p6 D% B. E& J21
22
! W4 M3 B  f2 Y4 W! j1 K& \# r23
24
25
26
27
28
# u3 ]7 I0 I! m' y! e! V) _29
, D7 t3 a/ t: U( t30
9 j" K$ p8 C  T6 o# W31
* Q. {8 H9 j, U5 S' ^32
33
! q! M6 h! X0 @  e# s/ T. b34
: J. Q& N* M5 a/ ^; ~) H: P35
7 L& i4 a. E8 J  ^. C- d36
37
38
39
40
5 ]1 ?2 u- @; I5 Z41
" J) z$ n% c4 u8 X. ^/ a+ c42
; M; u. e" R# K/ o1 a6 f43
1 `- q" i* |5 w$ n  G2 i# [44
45
7 Q; N/ a# f+ t7 P+ O测试代码：
& A7 s8 J+ m/ w+ e( `5 v
. C+ a8 n0 u# m8 p/ @
升序排序（从小到大）

, z% d  j/ H6 q3 ^* E& E
7 y3 D2 @% e: `0 z. x! bpackage com.keafmd.Sequence;

0 G1 W! p$ W8 c! {3 Z9 j6 v
import java.util.*;
* n& P- z) @! G* ^: vimport java.util.stream.IntStream;
import java.util.stream.Stream;
2 ~3 |1 Q4 \+ R1 \$ l: A4 `
4 S. o! m. D% ?3 l0 U
/**
* Keafmd
*
* @ClassName: Sort
* @Description: 十大排序算法
$ W1 ^2 P3 [3 Y( f# d) n * @author: 牛哄哄的柯南
* @date: 2021-06-16 21:27
*/
7 A: B* X2 Q5 E5 j0 u0 Ipublic class Sort {
, A  G( }, z3 J- T/ S" v    public static void main(String[] args) {

. y4 V! n1 X' q7 i4 X
        int[] nums = {12, 4, 25, 47, 58, 34, 25, 9, 99, 26, 1, -13, 162, 10093, -66, -1};
" I' }8 z, ^+ m" y8 R& r! o        int[] temparr;

! p9 I$ {% ~0 X
" _# C0 k2 p1 F' t* u4 t; {& M4 P        //测试冒泡排序
        System.out.println("测试冒泡排序:");
9 b# y; d4 J8 e        temparr = nums.clone();
        BubbleSort.bubbleSort(temparr);
        //逆序排序
- @* `7 f4 A- c# ^9 d        //BubbleSort.bubbleSort(temparr,false);
        for (int i = 0; i < temparr.length; i++) {
            System.out.print(temparr + " ");
2 @8 C4 r: G  D        }
, v9 W. p$ l- Q" b8 |( o        System.out.println();
$ M3 A$ Q6 O; C: b3 z9 y( E

( n" J% y' F  f- i) A    }
}
7 ]- k5 K5 ?( W2 p( C1
% u$ z/ c2 u. q% y& [; [2
3
2 @6 w3 }3 _5 S4 l4
! w) a- ^0 G( q5 p% U5
6
7
% P* S1 ?% l2 {6 ^2 }8
9
' ~- x+ N, I9 n7 ~) x10
" H/ O; ^! L  f4 y) x# r7 {( C11
12
13
14
+ A. m. A; Z* I) J5 G8 d" k15
16
/ A; }" J+ u$ G/ X17
. n$ j; i+ c8 D" K; `0 s6 q18
19
20
21
( h4 P- M, F3 f- D22
23
24
9 |& P7 d! p' O25
26
27
8 `( h7 N: }. Y& v' r' Y3 Z0 ]28
( u' ~. Z+ h6 b8 A2 y29
8 M3 O7 o. s: d! E  z3 `) H30
31
32
3 B' ]4 C. i" Z2 [  b+ {* ]1 l33
" u" x. K. l& [1 ^0 B运行结果：


测试冒泡排序:
-66 -13 -1 1 4 9 12 25 25 26 34 47 58 99 162 10093
! G$ j1 B5 D' j) h1
2
# W- k, V7 q* [( X$ B! l降序排序（从大到小）

& z8 A; E0 E- }1 ]. h9 |
! S8 J( `% V+ T. q//测试冒泡排序
System.out.println("测试冒泡排序:");
8 t9 C& U# w5 u/ J% d. Ptemparr = nums.clone();
BubbleSort.bubbleSort(temparr,false);
+ x/ o' i# ?2 k4 ^+ p  }for (int i = 0; i < temparr.length; i++) {
& Z* `3 A. L1 ]    System.out.print(temparr + " ");
}
! c5 Y5 v1 J7 W8 N; z5 sSystem.out.println();
1
2
8 @: M) w0 p% `: E0 y- ?3
4
5
6
7
8
运行结果：

2 H: H5 S1 Z$ k5 O8 ~6 a
2 {6 J+ f, t. i1 _0 _测试冒泡排序:
$ v; F$ J! v4 x; m! M: V9 f& B$ N& R10093 162 99 58 47 34 26 25 25 12 9 4 1 -1 -13 -66
$ m- |5 ?" i3 i! _. k* N1
2
( M0 `3 @3 c& h$ D0 T: ?下面几个算法的测试也就是换了下类名和方法名（换成相应的排序算法），如果想降序就在数组后面传个false即可。我就不一一复制了，我在最下面给出含所有算法的测试类，需要的自取即可。
# T3 i, C8 a6 _
6 s  c- t2 W/ F5 y, v, c& _$ n
' Y5 ~/ z# {" m2 V: j) v快速排序
# l( s/ ]$ d) k  }简单解释：
2 `# N( P$ i# I% s  C0 S快速排序就是每次找一个基点（第一个元素），然后两个哨兵，一个从最前面往后走，一个从最后面往前面走，如果后面那个哨兵找到了一个比基点大的数停下来，前面那个哨兵找到比基点大的数停下来，然后交换两个哨兵找到的数，如果找不到最后两个哨兵就会碰到一起就结束，最后交换基点和哨兵相遇的地方的元素，然后就将一个序列分为比基点小的一部分和比基点大的一部分，然后递归左半部分和右半部分，最后的结果就是有序的了。

: Y) H1 p! v( h6 s9 S, N6 c
' k: [. m  }; B0 G* ]
, Y' k" e4 _' x
/ B; T* _+ Y0 v, l$ z! \
: ?4 I/ d' R0 }  Y* S
3 _5 G4 z! D/ o( @6 C完整代码：
/ u% A( ^" |3 S: h. m0 ~# S
' Y7 ]3 k8 R/ }! Z* F
3 G* |1 w$ P' }package com.keafmd.Sequence;
5 t- ]* ^8 k( q5 R
1 Y1 Y. @6 s& Z7 X
/**
$ x  E; N3 n$ K8 \ * Keafmd
*
- d6 E2 o: g/ s* I * @ClassName: QuickSort
# Y! B! [- c1 Z' B4 M! \ * @Description: 快速排序
& [$ i2 v3 o6 _, i( g' s * @author: 牛哄哄的柯南
* @date: 2021-06-24 10:32
*/
3 v  @( h# R$ r: d% tpublic class QuickSort {
8 i' I1 o: |5 [* H
% S7 s; g3 h7 Y
" N. h: W+ U6 Y) f% S    //快速排序
0 G5 W% d4 k$ N2 c: k/ P9 s( D    public static void quickSort(int[] arr) {
        quickSort(arr, true);
    }


: ~: E, B2 d. ^. u6 `0 N& A3 |, u" f# w0 O    public static void quickSort(int[] arr, boolean ascending) {
        if (ascending) {
* P4 X: H$ E/ \/ V* l            quickSort(arr, 0, arr.length - 1, true);
        } else {
, i- F5 ~5 D7 ?5 P+ I! \            quickSort(arr, 0, arr.length - 1, false);
        }
0 h5 k3 h8 l' M7 L1 `    }
+ n6 @3 t( T9 U
. V  m  [6 q% V$ S
    public static void quickSort(int[] arr, int begin, int end, boolean ascending) {
  [2 d5 H2 O% x2 `+ p$ F9 M) a5 K        if (ascending)
            quickSort(arr, begin, end);
' S0 j) D. O0 ]4 r+ Y& I        else
% f+ r% x! I# S            quickSortDescending(arr, begin, end);
! X% i0 c' x% {: b$ y    }
' x9 J' A) N5 a. y

    //快排序升序 -- 默认
    public static void quickSort(int[] arr, int begin, int end) {
# N* I0 X* H' ~4 ^# a        if (begin > end) { //结束条件
) e, N+ J1 s4 \# J) o* ~# d* e, \3 @            return;
4 B$ G7 V5 n0 D' X/ W        }
        int base = arr[begin];
. l& ~3 k5 b6 w/ A9 e3 a7 I        int i = begin, j = end;
        while (i < j) { // 两个哨兵（i左边，j右边）没有相遇
            while (arr[j] >= base && i < j) { //哨兵j没找到比base小的
                j--;
2 a- h# ]4 t$ f) N- Q            }
# W6 [! n( W- c. J8 I2 E, q! Q            while (arr <= base && i < j) { //哨兵i没找到比base大的
                i++;
$ R- n6 i$ m' R9 t7 X            }
            if (i < j) { //如果满足条件则交换
                int temp = arr;
                arr = arr[j];
/ t' Y" k+ N' f2 _2 x: e) U/ ?9 _                arr[j] = temp;
            }
$ H, a. @/ T, X
* k  f; h" P$ j% Z4 W
        }
        //最后将基准为与i和j相等位置的数字交换
        arr[begin] = arr;
        arr = base;
& X- ]* r  B' N7 ~        quickSort(arr, begin, i - 1); //递归调用左半数组
1 Y6 T3 H4 r0 @8 ~3 i6 B7 C        quickSort(arr, i + 1, end); //递归调用右半数组


+ M- ]& t3 S5 D. g8 [+ B( T/ z    }


    //快排序降序
    public static void quickSortDescending(int[] arr, int begin, int end) {
        if (begin > end) { //结束条件
            return;
7 g8 A( c' Z- I+ }        }
        int base = arr[begin];
& n: d* @' }; |7 |4 M+ m  Z        int i = begin, j = end;
        while (i < j) { // 两个哨兵（i左边，j右边）没有相遇
# X+ t  |, `: D            while (arr[j] <= base && i < j) { //哨兵j没找到比base大的
7 k) |  _1 s$ E5 ^; c* W                j--;
            }
            while (arr >= base && i < j) { //哨兵i没找到比base小的
                i++;
            }
            if (i < j) { //如果满足条件则交换
3 }  N% \3 p6 R7 D                int temp = arr;
                arr = arr[j];
- o- @& h& u6 X6 ^% H5 e9 l                arr[j] = temp;
            }


        }
( t! y" ~0 _0 ?7 g! E% P6 i/ n        //最后将基准为与i和j相等位置的数字交换
        arr[begin] = arr;
        arr = base;
* j% u  U# H6 M& x$ }8 Y        quickSortDescending(arr, begin, i - 1); //递归调用左半数组
$ j" I2 {# G1 c6 O# H, ?        quickSortDescending(arr, i + 1, end); //递归调用右半数组

$ k/ \. v& \: z0 Q4 U$ ~! Y9 O* i, \
* S6 [( L5 {2 d. Y4 m% i4 N6 _0 I    }

, d5 e. C) g6 o% r4 A" N
2 U+ w6 ^" s: O0 }; w}
, n+ G8 V& M/ |1
" x2 K! i! ?' F* Q1 `' A2 T% B+ b: ^2
3
4
- s1 M: `8 X. ^5
6
7
8
9
10
' I7 j4 K* o; L% f& c11
  o8 ]+ G6 j9 U9 O12
13
! l0 \$ e8 u' g4 K% j2 F# \' k14
15
/ o" Q. y5 L7 O/ p+ Y16
17
- D. I) e+ P+ z# i9 e5 g18
) J! ?$ H7 ?8 _19
$ o! B. H* ^5 ]4 Y8 U8 x20
- N1 M* l' T( C6 Q$ x6 B21
* p: @) k! H5 F) G8 M7 G6 |+ @22
23
24
$ C2 I9 l6 k7 r9 }8 T25
26
27
28
- f* \- M. }  Q7 a29
30
31
/ R+ B# Z  n2 V32
33
34
35
( Y+ j6 h0 X  t, r6 Y  Z36
37
38
39
  S5 C- p4 u/ E0 U3 _! p40
/ e0 e  _" S3 W5 a  v7 N! E( n41
- N7 V* @. Q0 I/ _  L0 B+ K) M42
43
  T/ J% {+ F$ N8 g44
: E5 B4 ]. p2 m45
46
47
48
49
50
) t3 K0 i$ ?1 N7 M% t51
52
53
7 q9 l! Z4 {' c" `" z54
* P3 c; Z( P" s3 o0 m+ ?55
56
9 X; H7 t* m& p! u) S+ J57
58
59
2 r6 N! `% Y; a0 z60
61
62
63
9 i2 w7 B) i4 S! \- Y- ?" N64
( g+ }' w2 U/ J5 ^) E' ?65
, p' V! |" V) k9 }. I4 g. Q66
# i8 T( ], e7 e67
68
$ `- n' W$ m2 ~9 X  l4 T69
8 f2 e9 e6 s. {0 q. F70
71
" ^9 G3 t- E% x0 k  \! ?2 [2 Q2 [  p$ N! B, c72
73
74
75
/ D) u# y0 ~* Y8 V0 m3 O76
77
" j$ j' J/ L6 z/ W8 ]78
79
80
81
82
83
" ]1 b! Y2 h" c- V84
. r; q) j  Y+ a( g" a3 R85
86
87
  V9 [  U6 m+ Z1 W( M88
# F3 E/ @3 x/ i" Z9 O89
90
91
直接选择排序
简单解释：
4 H/ d" F. ^0 Q# K: }数组分为已排序部分（前面）和待排序序列（后面）
; H/ e7 t' [. @8 L/ ?$ {+ ?第一次肯定所有的数都是待排序的
从待排序的序列中找到最大或最小的那个元素，放到前面的已排序部分，然后一直找，不断缩小待排序的范围，直到所有的数都是已排序的了
+ ?9 j8 [; S9 K$ h. C
. J! L' u2 U* S0 D
3 y! u2 {! p2 L2 E/ n
( j% P7 @! ?) B! F8 m4 |0 I& Y
3 r# f1 _% F% D1 e* |6 L4 x' U

- L) i6 S. W% K4 b( V3 M完整代码：


package com.keafmd.Sequence;
! g/ C9 f6 r" Z

/**
1 r9 f! d# t' m. h * Keafmd
+ B& ], e6 R, j2 C *
) ]5 b" }3 M# ? * @ClassName: SelectSort
1 f3 w7 f' A! ^4 N0 {% q * @Description: 选择排序
* @author: 牛哄哄的柯南
/ d5 |& z: I" f6 `; z7 a * @date: 2021-06-24 10:33
! Y1 h' G  N: u# e. ?5 q6 o9 x# k */
+ `. @( X8 D0 }8 B4 U, Y2 ~public class SelectSort {
$ M0 ]2 E6 O* ]7 @

, b+ a' ?2 w; |# R    //直接选择排序
8 e* a$ h* K; e    public static void selectSort(int[] arr, boolean ascending) {
# v; d  x, u+ o        for (int i = 0; i < arr.length; i++) {
  o. B( A4 y0 o( \7 J) C( i            int m = i; //最小值或最小值的下标
            for (int j = i + 1; j < arr.length; j++) {
( e1 s# ~* @1 X3 {; K                if (ascending ? arr[j] < arr[m] : arr[j] > arr[m]) {
                    m = j; //找到待排序的数中最小或最大的那个数，记录下标
                }
6 L9 s, V# V7 R. W3 y  ^
! H: B) T" v" S* ^4 ~8 O, M
            }
# t$ R' I/ }4 Y& l            //交换位置
            int temp = arr;
            arr = arr[m];
            arr[m] = temp;
5 B6 K( m) |, U: U3 }7 H% O7 A

        }
1 G) |' L" e. {+ W    }


2 j0 a0 C; ]$ c3 @    public static void selectSort(int[] arr) {
/ Q, i( Q1 h7 p0 J" y3 `, \        selectSort(arr, true);
    }
2 t3 l7 e8 C: `( }* M+ C+ O}
3 k: k! t2 ]! Z" E0 S; ~- W1
2
3
4
: o9 ]7 Q9 r  l% t- F5
6 _& i% ?$ C% q4 \; o0 @6
, X7 p# k7 B' {/ B7 e2 X( n7
8
' s( R( g# P' b# ^9
10
11
0 T: Q& x, E0 f12
13
14
/ {* k" E0 q/ O15
/ d3 K+ v. W* }) E- m& \: h4 D- q16
17
18
% W" @2 a+ x- n3 _1 ?' W9 ~19
20
2 B: I/ b) W( u  G7 t1 Y21
22
23
8 d7 c( Y; q6 h+ B; I4 q: \24
25
' Z* y. b. u3 p4 f6 [8 i26
( m* g( D7 l7 ~& E27
3 x" B5 m; ]$ i3 A5 c3 b, X28
29
30
1 h/ G. A# Z2 X8 a31
$ i. ~) M: {: j7 z; ?32
33
. m0 c: r, t7 n( _# a34
堆排序
5 N5 h" B/ q7 g1 @. [3 a+ ]先理解下大顶堆和小顶堆，看图
0 p1 S& ~% G. Y+ U( s4 O. n大顶堆，双亲结点的值比每一个孩子结点的值都要大。根结点值最大
小顶堆，双亲结点的值比每一个孩子结点的值都要小。根结点值最小

( W& N1 y, ]1 v0 L4 B) q
) K# z9 t( F  f7 R( N- }
$ n% g% x. b0 Q* u
简单解释：
* X' q1 S7 D2 l1 E" f$ j/ s8 Q3 m构建好大顶堆或小顶堆结构，这样最上面的就是最大值或最小值，那么我们取出堆顶元素，然后重新构建结构，一直取，一直重新构建，那么最后达到排序的效果了。
5 u% y* I3 }' V; {- f/ d
: B0 ^9 z3 f9 C, z' j( t




, \5 b2 g8 [- x( u' T完整代码：
" E$ _/ Z9 x/ K: r2 G8 r8 Z6 ^

package com.keafmd.Sequence;
, l. J8 i4 L1 R8 C
7 e, k) n; R, ~
/**
! \% v3 ?4 p/ h; g- R * Keafmd
*
. D9 D/ b* C& c& G) I" L5 c * @ClassName: HeapSort
* @Description: 堆排序
( O& h5 Y- x' F4 S3 ] * @author: 牛哄哄的柯南
* @date: 2021-06-24 10:34
*/
public class HeapSort {


& a. v6 Z. j3 p9 a2 ^3 b! ?4 h    //堆排序
3 J% L# ?& l' v# I0 p' l6 z1 w    public static void heapSort(int[] arr) {
        //对传入的数组进行建立堆，这里默认建立大顶堆，进行升序排列
) s# h5 b5 {6 z' S- R+ M& `2 {        heapSort(arr, true);
    }

4 v( D6 D  J* T4 Y; x  m
    public static void heapSort(int[] arr, boolean maxheap) {
- U0 e  v& t3 H" b3 j2 _
" |+ m4 s  S& I  n* V
        //1.构建大顶堆
        for (int i = arr.length / 2 - 1; i >= 0; i--) {
; g  c  L" N# Z0 s/ v- Z* U! e: b" V            //从第一个非叶子结点从下至上，从右至左调整结构
' A) Z1 m4 \. X, Q. `! W            sift(arr, i, arr.length , maxheap);
/ N+ |/ Y. b$ o        }
$ P3 c, A/ I" |# {1 r
. R1 Y; H; \6 L- e
; F0 _0 {7 L( l/ s5 K9 C        //2.调整堆结构+交换堆顶元素与末尾元素
0 z1 Q5 k7 B0 M$ d1 U) g8 z7 D/ d        for (int j = arr.length - 1; j > 0; j--) {
1 Y1 h. K5 Y0 ]3 \
; B3 k# j1 B% U4 K7 S# H& ?
4 I& P& u9 @& s+ R, [            //现在的数组第一个就是根结点，最小值所在，进行交换，把它放到最右边
            int temp = arr[j];
) @1 t8 f' H5 s& l            arr[j] = arr[0];
7 O( D# D1 a* p            arr[0] = temp;

% k1 f/ V* M1 c
! N; Q; Q% b0 B- q9 z, C9 y            //重新建立堆
' }- _& M' n& @            sift(arr, 0, j , maxheap); //重新对堆进行调整
2 F. a6 Z4 W/ r: H0 F        }
    }
! S: t4 O, \; E) h+ k7 R

    //建立堆的方法
    /**
/ `% ?0 s# N- Q9 l# Z     * 私有方法，只允许被堆排序调用
7 m5 P, N& h+ w9 ~) @     *
1 G3 b5 q$ {/ r7 t+ c) f0 a' p     * @param arr     要排序数组
     * @param parent  当前的双亲节点
     * @param len     数组长度
     * @param maxheap 是否建立大顶堆
     */
& h% V3 e7 o' a% b# M/ t- H    private static void sift(int[] arr, int parent, int len, boolean maxheap) {


6 C  m  {- g1 |. b4 W6 l: }9 s        int value = arr[parent]; //先取出当前元素i
9 @; v; \' P0 b4 K* a
+ r. G# C& U/ Y# D9 ^, m
        for (int child = 2 * parent + 1; child < len; child = child * 2 + 1) { //从parent结点的左子结点开始，也就是2*parent+1处开始


            if (child+1 < len && (maxheap ? arr[child] < arr[child + 1] : arr[child] > arr[child + 1])) { //如果左子结点小于右子结点，child指向右子结点
+ t, {& z. B/ a/ J- J                child++; //右孩子如果比左孩子大，我们就将现在的孩子换到右孩子
3 q( S6 I+ Q  v5 d            }
& G, B3 p* t3 B: q1 q$ c+ Q% ~
* g+ ?1 _. y! {0 g
4 g+ T$ A( `3 i- D4 l            //判断是否符合大顶堆的特性， 如果右孩子大于双亲，自然左孩子也大于双亲，符合
            //如果子节点大于父节点，将子节点值赋给父节点（不用进行交换)
            if (maxheap ? value < arr[child] : value > arr[child]) {
                arr[parent]=arr[child];
' S9 F  m4 A! }3 r' }/ B                parent = child;
            }
7 Z" U6 S. m5 T            else {//如果不是，说明已经符合我们的要求了。
( F; P4 e- _* r1 u                break;
            }
        }
, X! \  b* U1 h0 w        arr[parent] =value; //将value值放到最终的位置
, [% O; ~. E  E
5 C8 H$ Y3 {# m6 v" D
& R1 F- N& R, q# L7 V* L

7 N& G8 T" n# r3 W: X4 g8 j# i    }


}
% t' N  c3 _1 q+ c' Z1
$ K3 ~4 x/ e' y# Z- o2
3
4
5
$ u; H2 h5 a: V. C6
5 d5 h6 ^3 ^" H3 F/ S0 Q7
8
4 o% n. \* E' g7 c1 Y9
10
- {- n" h- _5 X" B2 M11
12
13
14
15
* M0 \" P; N8 A. G9 t  h  G16
17
18
19
20
; W% ^' h  G3 R! U4 \* X3 f" e8 _21
22
* V% m  j# D# s& l23
  Y/ i2 R! Y8 ~  F5 y! c+ {24
25
2 S6 s9 L( j* W: j0 o" Z9 k26
27
# v) A" [, [" _8 q28
' r  i+ H( v( q* k( T. q29
  B/ k; W$ ?/ p30
31
( ?# n$ D% s& [) X2 B9 d+ H7 r32
+ {8 h/ u% Q2 I$ {8 C  c33
34
35
: _# n3 R2 ~4 s8 k$ o' B( H/ l, C36
6 U4 f: [9 p* ?37
; s2 e% e( @' m3 F38
39
40
* |  p2 i! K' n6 R* y# T41
42
! s% E2 e; ~  O1 o" @43
44
45
6 V% ~- w: I1 \7 }- c  E46
3 M' R1 Z, Q: n& b/ N( ~) o47
7 v2 ]8 x" M9 J5 S4 \* q48
4 I7 F3 H; t. ^' M( N4 c49
50
  s! \4 i0 y8 Q( y* i51
52
& X# l; |* Q4 {53
54
* _* L* D( ?& A# ]- c! I55
1 U" ^7 j0 I" _* }56
1 I/ Q/ ]+ \/ }) {  I1 Q7 Y5 h8 A57
58
59
60
9 ?  n" o) }8 U* F3 f61
# W/ B( {4 t* c62
63
64
+ j" I- S& V4 Y$ i, r5 M) P65
66
0 `) u9 k+ ?% L8 l67
68
6 e7 L9 P- g5 c, N/ T0 }% S$ m69
70
71
72
8 h# m4 g* S( L. f1 _/ ?9 }, N73
, y( O5 Q$ v/ g4 t6 y  c9 ^8 b5 l/ r74
# _& o# a4 {- c归并排序
简单解释：
该算法是采用分治法，把数组不断分割，直至成为单个元素，然后比较再合并（合并的过程就是两部分分别从头开始比较，取出最小或最大元素的放到新的区域内，继续取两部分中最大或最小的元素，直到这两部分合并完，最后所有的都合并完，最后形成完整的有序序列）

0 t0 f! i( X* [8 Y, G2 Z$ j* t

+ ^- p, H4 Z2 B
0 ]. G! R$ `) C& m3 P
* b# e- _4 E( H) |
" x. Z$ W' i+ R4 o# C完整代码：
0 w* |& D: c2 J* m& b; [7 _5 M

# R% f- r+ B. Bpackage com.keafmd.Sequence;
) H' z- ^$ e0 d3 r  D* A- I( ^4 P
- R% U/ \7 k" _- b2 b) Q* {
/**
' C; w6 x. Z; a9 c" @ * Keafmd
*
  s+ p7 G  ~; L$ O * @ClassName: MergeSort
0 }6 X& L' o0 r1 v  N# g0 V/ M * @Description: 归并排序
4 }) z3 z7 A+ x1 q/ `/ j) x * @author: 牛哄哄的柯南
* @date: 2021-06-24 10:35
*/
+ Y1 Q3 p9 \( P5 p# d. fpublic class MergeSort {
0 I& e# E- T* O$ R. Y0 r. ^5 p) d# E$ M

    //归并排序
    public static void mergeSort(int []arr ,boolean ascending){
2 d. c6 N2 q$ F/ \6 g: d4 T/ m8 m; ]        int[] temp = new int[arr.length]; //在排序前，先建好一个长度等于原数组长度的临时数组，避免递归中频繁开辟空间
: C( y" `! W! t  n3 G        mergeSort(arr,0,arr.length-1,temp,ascending);
; r/ F! ?" Z! z/ y  K6 _    }
% d7 V  s; O0 \0 C- a. a1 {4 n    public static void mergeSort(int []arr){
        mergeSort(arr,true);
& F4 A7 Z$ T6 H    }
. A% y. ~7 z8 `$ {& h+ h

, G: i2 Z; J2 O% `% F    /**
     *
     * @param arr 传入的数组
( h3 D. L. p- f/ ^     * @param left 当前子数组的起始下标
     * @param right 当前子数组的结束下标
8 k- I. F, _& `     * @param temp 拷贝暂存数组
     */
7 c4 g  o( f# j1 n5 u. I    public static void mergeSort(int []arr,int left,int right,int[] temp,boolean ascending){
( U5 {  A( q( h( w) t. c; m        if(left<right){ //这里是递归结束的条件，我们是对半分，那当left==right的时候肯定大家都是只有一个元素了。


            //对半分，比如总长度是10，left=0，right=9，mid=4确实是中间分了，0~4，5~9
1 p; ~/ ^/ X: W            //当长度9，left=0，right=8，mid=4，0~4，5~8
            int mid = left + (right-left)/2; // 防止越界的写法
            //int mid = (left+right)/2;

7 X- p2 e" N' P3 T8 b* E8 s
0 ~, S; [1 ?9 Y$ J$ U; [            mergeSort(arr,left,mid,temp,ascending); //左边归并排序，使得左子序列有序
            mergeSort(arr,mid+1,right,temp,ascending); //右边归并排序，使得右子序列有序


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

& l7 {2 c! q; l5 e5 j
* Z# [  c" Q& z5 e    private static void merge(int[] arr,int left,int mid,int right,int[] temp,boolean ascending){
# Q' E( N- F, D$ `, w9 E- b        int i = left; //左序列起始下标
" p0 O/ u: H" p3 d        int j = mid+1; //右序列起始下标
        int t = 0; //临时数组指针
        while(i<=mid&&j<=right){
$ D  c( X9 |. x! k. a1 N5 e            if(ascending?arr<arr[j]:arr>arr[j]){ //比较两个序列第一个元素谁小，谁小先拷贝谁到temp，然后对应子序列下标加1
) c+ L! s; \# w, _                temp[t++] = arr[i++];
( R, @2 [4 `# u; i; H4 q            }else {
                temp[t++] = arr[j++];
, M* w* ~& ^$ t! N/ O- j" e8 ?            }
7 C& y" o, W: y7 U% u3 w- o) |        }
2 w( O$ y% R- @# ?
3 k6 T( E) W8 O& X* I/ \! B/ g
) U+ Z" v) k4 V; P! d3 q; o* C& n. P        while(i<=mid){ //将左边剩余元素填充进temp中——左序列有一些数总是比右边的大的数
/ F& F0 A' c/ b) g! ?! f            temp[t++] = arr[i++];
        }


. Q0 t8 P4 B  v0 P" s        while(j<=right){ //将右序列剩余元素填充进temp中——右序列有一些数总是比左边的大的数
            temp[t++] = arr[j++];
        }
3 v) y8 P7 @! p
# j# [6 b2 K, R' Q
        t = 0;
: Z8 e2 m! w6 w! R# e
# a1 f; n4 D* l: B: ?
        //将temp中的元素全部拷贝到原数组中
        while(left<=right){
$ W7 M) ^9 R+ W; M            arr[left++] = temp[t++];
        }
# y! r" e" A0 E0 g8 e/ B
6 a, Z4 B  ~- w
    }


" h1 P. t4 H% T6 I$ v7 k& _: ?. m}
1
7 z4 A  Y2 ?7 T  }, X2
. ~0 l" ?0 |. x5 O6 D9 C3
) g7 A' ^" `7 R, m1 R4
5
7 Z  p1 s; H5 C6 Q7 r6
7
8
9
$ K, X' |- e/ ~; J10
, T- k4 ]% o: T6 f11
12
' u/ K3 G0 _' ~, f13
14
15
6 e8 L6 j" x; B# }4 a" y0 x16
17
% q- F  [$ \7 m18
! E2 ~. n# q9 L: v! c  a19
20
21
! r1 K' G* }" o- u22
23
5 L( a7 ~8 D6 s  G$ d7 I$ Z24
25
26
27
! r* D+ R  b+ K7 ]; V# o28
29
30
0 P3 `+ U8 B2 U9 \' Y0 e! ?31
" I9 l; G! p+ h) f& Z32
5 c' p/ ]: O0 E, q) u2 }5 n33
34
+ {% g% I% d; H6 d- w& B9 b- P35
1 A( E9 h2 k3 o, |  g' X" U1 i% ]36
37
- i: C  T1 t. L38
+ P( \" Z4 ], I! F* }% y- t9 i39
8 w9 [' }9 V) e9 `4 H' p+ M1 _  F, U40
" ?3 H* b( s7 Q0 B3 |' X6 E: {2 z& K9 f9 w41
42
) s: [/ k% \5 d5 X# c9 P* o43
44
$ J9 `) y& s6 k# Q0 ^45
46
6 W6 A! ^' V4 V. e47
  |8 Y  u! y$ F) _48
49
- N, T! Y( s8 ?/ m50
51
; T6 t+ V4 L6 U52
7 m! [) C4 \6 {, T53
54
( C9 S, r0 `8 U( `  ^) M* U, V# d55
56
57
$ _/ b) ]& y; J# y' O1 e+ a58
: D1 r. u1 d4 f; W* u59
) K# B5 X. r% z2 U) ^: m; ~60
61
62
1 v' I: E% F1 T0 G5 z63
) s0 s2 c0 V0 l* u3 x; k+ M64
9 ]- [/ J! K3 S65
: F& e) |1 }" z- ^66
) `4 s8 [7 S7 ~8 Y3 i/ d3 e$ v/ ]67
) Y8 |: p5 p6 H+ g3 b68
69
2 L. ], X' G4 F* ]0 C$ a70
% t) ^7 S8 x- j71
) b/ c% [8 Z; q72
73
1 [' z; ~- {" G7 L插入排序
7 Y5 A7 i# r1 j: }) R7 j简单解释：
4 e6 x/ `; }" A/ r* B最简单的理解就是打地主时我们拿到牌后的整理过程，从第二个牌（假设我们拿起来这个牌开始比较）开始，（说下升序）从后往前比较如果比前面的那个牌小，就把牌往后移动，直到找到一个合适的位置（这个位置的前面的那个牌不比这个要放下的牌大）就把这个牌放到这个位置，慢慢的前面的部分变得有序，直至全部有序即可。
$ W) k; F* N: Y- s1 H" W



* i+ w8 v. p  R/ \, r% {; R( s
, M! t0 c6 Y) |! ~- E. ?! c0 w
; u/ N+ @6 ]8 o/ i- k) Z7 F完整代码：
  r/ o' C: R/ J. l& I

package com.keafmd.Sequence;
. c! s; F/ C/ Z  i
& U  r1 K: G& x4 d
9 ?/ k: g# v6 @) L7 f7 K/**
" [4 w- {9 @0 i * Keafmd
& Y2 E+ d7 @# k! ~$ {2 ]% T' V* P. y *
* @ClassName: StraghtInsertSort
* @Description: 插入排序
0 W! w; B; u5 n& w * @author: 牛哄哄的柯南
0 c) m( ~/ |/ s * @date: 2021-06-24 10:36
*/
7 o" e4 F1 U' Rpublic class StraghtInsertSort {
    //插入排序
- I5 |4 y4 t1 r: y) _: I    public static void straghtInsertSort(int[] arr) {
        straghtInsertSort(arr, true);//默认进行升序
" ^- G  l. |; y6 J  j    }
( K/ J. e: v! A  B5 B
, _  O, K& X4 Y" u( ?' ]
    public static void straghtInsertSort(int[] arr, boolean ascending) {

* Z1 g7 N" \! G6 U
        for (int i = 1; i < arr.length; i++) {
            int temp = arr;
            int j=0; //这就是那个合适的位置
            for (j = i - 1; j >= 0 && (ascending ? temp < arr[j] : temp > arr[j]); j--) {
# d) q* v/ m  N4 d% D- U( W                arr[j + 1] = arr[j];
2 G2 J5 x7 O) g# j! \+ h            }
            //把牌放下，为啥是j+1，
/ i8 u: `) k2 b            //是因为上面的循环遍历到不符合情况的时候 j是合适的位置的前面的那个数的位置
9 j# |" z& H1 s) {8 d: [            //有点拗口，但是就是这个意思，看图方便理解下
            arr[j + 1] = temp;


8 i" Z# l5 N6 H( [

        }

1 m6 a) w" ^- }9 U- C  v4 i
- \: u- J( D$ Z$ E    }
}
$ a; [; p8 Y$ q9 A: n1
2
3
4
* K5 B) @  W- r- o5
6
7
8
9
10
7 |2 P8 ~; A- K11
# t/ D5 e' p# v# b12
  i9 q  s1 W% ~, _9 U13
14
9 t. _6 Q4 T# N; w/ R15
16
- R' o  j& F7 {; [3 `# W% b+ U- T17
7 ^- R* B( r( a; u3 Y9 N" m9 _/ P, z18
19
20
# ^: Z" _8 e0 z1 Q, Q21
5 |& D$ r9 Z8 [$ q2 j1 b22
' Q. Q5 [0 g; ]* V& m23
24
% S. K$ I' h; M8 f- i% z' V' g5 R25
26
27
28
1 U: A6 I- H( t: h29
3 ]' {! u8 A; |) p% i4 `' y30
8 O- B* V7 X3 v# @& m) E: t" x31
2 e3 a4 J1 O  M* ?. M% T% @32
+ @4 l+ {; _1 l$ |6 ^+ ]* Q33
7 E& K- [! Z3 Q( a34
希尔排序
1 k" y# O4 l" T' s7 j简单解释：
- j$ ^3 Z8 W) i希尔排序是插入排序的改进版，我们理解一个叫做下标差的的东西，也就是下面那个图中的增量d，初始下标差为arr.length/2，然后继续/2，对在同一下标差（相当于把这几个数单独拿出来了）的若干个数进行插入排序即可。



" }" W0 f1 n8 _/ C. ]2 f3 \
: R4 C. C4 ?0 s# m- {9 b

' b+ a1 K: P, m0 C: E7 Q& A2 |5 q9 c完整代码：

9 ~6 i6 U2 @, W# \4 k- y
- ]7 E3 e) h. Z" b' B; F) K$ Lpackage com.keafmd.Sequence;


/**
$ J' r8 }0 t2 F. a5 [ * Keafmd
+ H- S# R+ w2 W *
6 b7 D+ U0 L4 ]$ J * @ClassName: ShellSort
* X+ _/ H9 m$ S* u6 X3 A * @Description: 希尔排序
! N5 z( d) O! h1 ` * @author: 牛哄哄的柯南
4 Q+ Q; F8 y3 I; o0 K0 K * @date: 2021-06-24 10:39
9 l( l1 p1 W% M! A( D */
7 J6 k# s7 E9 I, J4 Vpublic class ShellSort {
. z9 H% V6 b1 ~2 {; |( N
7 z$ a( A( e- F
+ H: l: z% R1 V/ }# L- c& l2 ~7 |    public static void shellSort(int[] arr) {
: Y% f4 e/ m2 C# i: ^; H        shellSort(arr,true);
    }
: @0 M9 ^# A- g5 J0 X

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

, Y: ]* J# `: K$ F% q. {. \7 P
0 L9 J9 U5 F4 L4 H        for(int d = arr.length/2;d>0;d/=2){


            for(int i=d;i< arr.length;i++){
4 n( ^- Z- p/ Y: {1 _9 ~+ Z                int temp = arr;
                int j=0;
, q- O- Q: C$ ^                for(j=i-d;j>=0&&(ascending?temp<arr[j]:temp>arr[j]);j-=d){
                    arr[j+d]=arr[j];
                }
5 p3 f& m% ~; Y  d                arr[j+d] = temp;
            }
        }


    }
}
, s  f7 O8 {4 P7 U: J1
' o5 r( W! [! A2
3
4
5 n7 K4 i% X7 G9 {: E8 y, r" \, ?5
) c4 a' w; ~& V* ~+ g( T# j8 s6
7
" `3 k7 O8 o  [" q- m# m( R+ r5 Q8
- O3 R3 k' @& J: j7 D7 Q9
10
11
12
  {7 l; s% _8 |" C4 t13
, z% b9 f$ p1 ?, ]8 s6 m8 f14
1 U. F: O* B6 v1 ?15
. o5 l0 r7 [& h  K% O; Z16
17
7 n- O# }1 q# X5 e& I% K: W+ A18
19
/ V/ j# O" {9 `20
! g  \7 n$ m" [21
22
2 t' g9 \! ]2 u  y1 n23
24
* c+ X, W) E) ?: j/ Q5 g# B' [25
! V1 Y6 n- d- D5 k, p26
27
6 p+ G& \2 L7 A& Z/ z3 F! W28
/ M9 L4 L) T: @/ R/ d, q29
30
  b& l* O$ p" N31
4 K2 O! d6 P9 K32
8 c. b2 d9 {" [9 K# [% ^* |计数排序
简单解释：
这个排序算法看名字也很好理解，就是就是额外找个数组来计数，然后在这个数组从小到大或从大到小把数取出来即可。

; z4 M% {& r/ Y3 f& `4 |
* q2 k/ T. K# @! k  U5 w, m

+ q8 J+ J* o+ i6 O2 J4 J

6 E: h8 M$ x, d" Z完整代码：
- D6 D$ @4 o2 r5 A/ s
; ^# L, [+ [: T7 J( w
. L. [$ D8 V& ?& {/ B, l: bpackage com.keafmd.Sequence;
2 ?0 x- b+ j  m) u4 B! m

% a3 ^$ z9 t) k) E) D/**
4 E3 W3 L' r, P, Y0 Z2 e2 U5 P. \8 d' L * Keafmd
*
3 Z0 r" ~% u$ X8 n% t7 p6 R& J; _ * @ClassName: CountSort
. s" R# o9 A# }% O * @Description: 计数排序
* @author: 牛哄哄的柯南
* @date: 2021-06-24 11:31
*/
3 [" G: E/ Z9 }) npublic class CountSort {

' S+ C" @# \- i. Z. ]! e; b
" w( z, }. c: m. M1 A8 v; [    public static void countSort(int[]arr){
+ ?) T5 ]# t9 u% M: f5 K6 {        countSort(arr,true);
) {+ T( R" s, _/ u    }


: [6 {, b3 ]2 E    public static void countSort(int[]arr,boolean ascending){
        int d,min=arr[0],max=arr[0];
" ?0 ^" i) }, o

        //找出最大、最小值
        for(int i=0;i< arr.length;i++){
. I" P2 c! U4 A! ^" H            if(arr<min){
                min =arr;
4 l9 k1 m9 h5 u. A2 @            }
            if(arr>max){
; Z2 r( e% n2 X& Z9 T! R                max = arr;
            }
        }
: u9 V; W! y* T) N# t

        //建立一个用于计数的数组
. w2 U2 r& }1 A7 ^! |        d = min;
+ \. U9 y0 ]/ f/ s- P        int[] count_map = new int[max-min+1];
( ~2 s1 V7 k5 O, q- L) u8 c+ U        for(int i=0;i< arr.length;i++){
5 O0 E( r, h$ v' F+ J            count_map[arr-d]++;
        }


1 y5 D+ C$ ?5 {+ ^* H        int k =0;
# w/ t% P7 i% A7 y8 |' `  ?9 P        if(ascending){
            for(int i=0;i< arr.length;){
7 l" R5 m+ z4 k$ x                if(count_map[k]>0){
                    arr = k+d;
                    i++;
                    count_map[k]--;
% l2 y, a: c& A: s& t                }else
                    k++;
! p; z0 J: t! V) }! _# C$ d8 e- G' B            }
        }else {
* g* G! n3 |( e            for(int i=arr.length-1;i>=0;){
1 C0 |% r. C9 F6 M( b# f' Q                if(count_map[k]>0){
                    arr = k+d;
, s$ U; k$ Q: \4 v0 d                    i--;
3 f( i% z& I& \# y- U6 S; v                    count_map[k]--;
                }else
                    k++;
            }
        }


" b/ Y$ v7 U: p' L. _( N    }
}
) Q* w7 N7 \; x1
' ?/ v( u0 b" \! X: J% s9 j2
3
4
5
; q" l) t! S6 s6
( ?6 r! i0 y2 ^% i8 h: z7
8
9
10
* s2 ^; ]- |) G! M2 \( G( M: I11
12
13
14
3 [0 }6 m% r2 m4 f, Y4 T15
16
17
18
6 O4 A# ]3 j9 s19
2 S3 I5 E! r/ W  S  L) s$ E( r20
" V. u5 S/ A( b' F5 L6 `21
22
7 e5 ^4 u2 h) D; E# T7 n+ {23
% j2 |6 E8 |4 X4 i9 M3 m, l# V$ Q24
- I9 ]* ], n0 ]$ A5 g; i0 @25
26
27
28
& E3 @  Y: j) K( K29
30
31
32
33
$ f! d7 I2 j7 S  O9 o7 B$ u7 c4 a34
35
36
37
: _+ k. ]" @$ L4 ?5 f  E" k$ A; o38
39
40
5 U" }* S1 \# E' k- Z& E41
4 C, X, `+ y) }7 [1 B42
# `" x% g# A6 N3 Z, P8 d/ e43
; I  ^/ q3 @% |- S3 N* U. B5 }44
9 t: ~6 Y) A$ Y8 t( I45
46
47
& C: G0 g, j* a  a48
- d5 |! [. P  M5 H- D0 @2 ?7 E" M49
, H- ?5 P. b" N1 F9 l9 j; e50
0 x# W! Y1 H+ L" B/ z& ~51
52
53
54
8 B0 y  [+ ]9 J6 ?! n1 t% S$ ?2 |4 r4 c( @55
$ B" ~) c: ~5 ^1 U56
/ K: c; b0 G. b3 Y$ h, [3 p57
58
! f$ K6 j7 N1 X$ v59
桶排序
3 U- G, ~5 L$ Q& @- N' n  l, W简单解释：
& B5 t, [8 e/ }# B3 |% }0 |0 \( p- {就是把一个数组分成几个桶（其实是几个区间，从小到大或从大到小的几个区间）装，然后让每个桶（区间）有序，然后取出来放一起就可以了，相当于把几个有序的段拿出来放一起，自然还是有序的，当然需要是按照区间的顺序拿了。

! I7 x" ]* L- G" a0 v! r
( b; X9 i$ I' z- q: m4 A( z6 V$ @



完整代码：

# O8 K% l0 a- S/ i$ O
  E( {: Z' M6 M/ F4 Qpackage com.keafmd.Sequence;
% s8 y: n6 B- a+ o# T

) U: V+ q; g7 simport java.util.ArrayList;
import java.util.Collections;
) b( R5 Z: K+ b0 L
3 ]3 S& x/ k. ~7 x# E
/**
* Keafmd
*
* @ClassName: BucketSort
* @Description: 桶排序
- m8 c% l+ H0 O' W * @author: 牛哄哄的柯南
* @date: 2021-06-24 13:32
*/
public class BucketSort {

1 K- F% ]2 g/ H+ m$ p3 y0 d( l! B
    public static void bucketSort(int[] arr){
# X6 O+ q2 g; _+ ^2 D        bucketSort(arr,true);
3 a# h$ X; {& l; I6 ]* d    }


6 m+ i+ }/ y% C/ D    public static void bucketSort(int[] arr,boolean ascending){
        if(arr==null||arr.length==0){
$ U% f) D- v. U5 N, d* c$ A            return;
( B5 V/ \, O* M+ ~4 t, T        }
8 w& G/ ^+ Z1 B* p        //计算最大值与最小值
        int max = Integer.MIN_VALUE;
+ ~2 c* b4 z4 Z3 J& ~* N        int min = Integer.MAX_VALUE;
        for(int i=0;i<arr.length;i++){
            max = Math.max(arr,max);
  A7 G- K- i0 c  G            min = Math.min(arr,min);
/ y8 P+ K9 S  f: h0 y        }

3 v1 W8 W) A% K- @) Q- ~0 t/ k
        //计算桶的数量
: B2 m/ j  d7 o        int bucketNUm = (max-min)/ arr.length+1;
        ArrayList<ArrayList<Integer>> bucketArr = new ArrayList<>(bucketNUm);
) S% W, s, s9 C. Y: x7 K+ X        for(int i=0;i<bucketNUm;i++){
! E% k$ q8 U- I1 r2 y$ {$ w0 d            bucketArr.add(new ArrayList<>());
! V! M4 z2 ]/ \3 p        }
& ]4 v* T. ~" i# K& U6 O

        //将每个元素放入桶中
+ X2 E! m5 J4 `: b6 [& W( q6 n        for(int i=0;i<arr.length;i++){
            int num = (arr-min)/ (arr.length);
            bucketArr.get(num).add(arr);
        }


! W% s: i% I( z6 N! r2 ]1 w2 Q& P        //对每个桶进行排序
        for (int i = 0; i < bucketArr.size(); i++) {
            //用系统的排序，速度肯定没话说
# R9 }8 y+ B6 D* Q) u4 {            Collections.sort(bucketArr.get(i));
        }

, b1 C9 C: k! x8 g; F' y4 l1 {% f
        //将桶中元素赋值到原序列
; S* L* K. |7 ^. t$ O& p: }) A        int index;
        if(ascending){
            index=0;
2 B& B: o' L5 G) c4 S5 z        }else{
            index=arr.length-1;
( N$ S$ }2 e. l        }
$ k  h. ?4 ]9 L' l" b
* Z( m# o3 g1 U. e& d
! K) Q& |# L& z        for(int i=0;i<bucketArr.size();i++){
            for(int j= 0;j<bucketArr.get(i).size();j++){
% u) C$ t# ]" S. i% U' k. @                arr[index] = bucketArr.get(i).get(j);
2 T* f3 g! h- Q' b2 v                if(ascending){
                    index++;
6 t( {- \# y: Z                }else{
                    index--;
& y  K. G3 w# d& k+ ~2 C                }
7 y8 u4 Q! w  o$ n# V/ e% q' `- d            }
1 t  j, w# p5 n' U1 ~" s

3 h/ J2 Z# y, f) |        }

" U, j, l( z  w! G1 `3 O4 U
    }
2 _9 D: Z- V- O/ Q2 }% [}
. C. y0 a2 c  r9 Y( G7 [1
: U5 `( ~" K& X: t' I6 d2
3
; K/ ]' _7 Z% I( h8 x* G- g" C+ _4
0 d  f" }( H- [5
6
7
- g& g5 X9 ^7 G5 |- P* J- ]8
9
10
$ T4 V; d$ ^: G; {1 _8 O6 h11
12
13
) Q; V! R1 d( ^3 H14
- O' z4 @7 {5 k& u& X- s15
/ J9 Q) o: E: r$ r6 t2 C, z" ^' r- p16
17
18
19
20
0 W4 n% u* Q% p8 V8 @21
! @0 J# a5 E& l% A22
- Z+ W1 f0 R, A$ l* \23
24
; c: W5 B! p7 u5 k9 l" m25
& \& D: s7 k+ R- e3 T26
/ {* x! O& K( z. c. x/ s. E0 u27
28
2 T, ~; X1 _( G! J5 a29
; P7 ~8 ?# _! u30
* @0 d$ K1 l9 x- e31
32
33
34
% d$ o: ?  E! U! s4 W35
3 X- V9 ~& }1 v! Y0 v36
3 Q) {2 s! O3 J5 Z37
) N. a$ W4 o9 N2 B' E% Y38
39
; B, T0 i* x2 Z( @: _2 [9 a40
41
) @, r+ R2 Y9 g0 _  `8 F/ T2 n42
# [" Y+ D) Q5 u; U7 C* B# t" K/ Y43
1 \' Z5 v- Z. G' t% Y% `44
45
2 y8 l1 ]! p, Z$ }+ D" Y46
47
48
; T+ E3 M  T1 e, F49
50
51
7 N6 j, W* b6 c0 I' c52
% A9 J' k: ~# V) T53
5 O, z5 F0 d2 o- W  p54
55
56
4 c1 l& p+ q/ s5 b9 v4 \7 [' K57
# F: r7 J) m4 u58
59
. m: x+ C9 E, ~' C; G60
  V- t& A' w9 n1 l) O6 m5 U61
1 g5 @0 P' P! j* d# J- y/ E1 U62
9 t: H% r# p: X63
! y! A9 K5 H/ t4 ?/ z: y( r  @64
65
66
& {- P; Y" [* n/ Z2 s/ u' Q3 x67
68
) Y) _' Q7 o' s" F# w4 o2 J5 z69
70
71
$ z  I% _' m& l6 ^  E; r# w72
: ]& g. ~. N  ^- {- g9 @基数排序
简单解释：
首先说一下，我发现好多人写的基数排序只能排序正整数，其实只要处理下就可以排序含有负数的了，就是我们排序前先把所有的数整体变大（就是减上最小的负数，也就是加了），都变成正数，然后排序好之后，在减下来（加上最小的负数，也就减了）就好了。
' `/ R7 U. }2 D0 F+ @基数排序就是按数位排序可分为LSD（从最低位[也就是个位]开始排序）和MSD（从最高位开始排序），下面写的事LSD基数排序。
8 L% P* r2 U' M0 s! c  F基数排序就是把数按位考虑，让后我们一位数只能是[0，9]，就是我们在考虑某位（个位、百位· · ·）的时候就只看这个位的数，放到在[0，9]相应的位置，然后顺序取出，最后再按其它位这样操作（上面说了要不从低位开始到高位，要不就是从高位到低位）
* B, o. M5 V  N4 `7 ^+ B
- K9 K+ t  T( Y! Q7 o

; h) \( S( x8 D( K5 P( V# s
$ z+ u2 n- i3 O7 v6 T9 @
8 c3 N. i( F4 z3 s% M
完整代码：

! E+ |$ h$ m5 m
6 t8 ?- t% c3 K( _8 i$ g* Jpackage com.keafmd.Sequence;

+ P8 T0 t! G2 `, s3 Y0 C6 a
/**
8 w2 ?) c/ _: `3 `& ]2 P* ~; g * Keafmd
*
* @ClassName: RadixSort
' F- g3 u" Z; ?. A* z% w * @Description: 基数排序
" T5 s% A! c- r4 ^% S: D( j. Y * @author: 牛哄哄的柯南
* @date: 2021-06-24 14:32
*/
public class RadixSort {
- B% r( K+ x" K    public static void radixSort(int[] arr){
        radixSort(arr,true);
5 g/ `& Y7 W) G1 {& c& z    }
    public static void radixSort(int[]arr,boolean ascending){
        int max = Integer.MIN_VALUE;
        int min = Integer.MAX_VALUE;
        //求出最大值、最小值
        for (int i = 0; i < arr.length; i++) {
            max = Math.max(max, arr);
4 m! I( m$ T5 Q1 r            min = Math.min(min, arr);
7 P& j" d, D7 h& \        }
        if (min<0) {        //如果最小值小于0，那么把每个数都减去最小值，这样可以保证最小的数是0
2 W5 R  B& `/ [2 }* a5 b/ L            for (int i = 0; i < arr.length; i++) {
$ t8 C( M5 R/ D" @% O" y                arr -= min;
            }
            max -= min; //max也要处理！
        }
        //很巧妙求出最大的数有多少位
        int maxLength = (max+"").length();
6 U& C; x9 ?0 p( W        int[][] bucket = new int[10][arr.length]; //一个二维数组，一维代表0到9，二维存放符合数
8 [* E6 Q4 G) B) m0 Y        int[] bucketElementCount = new int[10]; // 用于记录0到9某位存在数字的个数
- ~4 v3 u# E3 h7 j' m) x        for (int i = 0 ,n = 1 ; i < maxLength ; i++,n*=10) { //个位 十位 百位 这样遍历
8 z+ n& F  `$ h4 c+ g: V' z: z. ~            for (int j = 0; j < arr.length ; j++) {
                int value = arr[j]/n % 10;
                bucket[value][bucketElementCount[value]] = arr[j];
9 E% U) j( x; b- T  q: d                bucketElementCount[value]++;
) `! M2 ]* m2 L* Y! X$ a! ]            }

9 }. }- L( j+ O' z
2 ^* R2 i1 d4 h/ Q6 v            //升序
            if(ascending) {
6 t5 r) f/ i& e- P) }4 \                int index = 0;
3 O  z+ o* e+ i. Y. C& u                //从左到右，从下到上取出每个数
                for (int j = 0; j < bucketElementCount.length; j++) {
                    if (bucketElementCount[j] != 0) {
; T1 [# u" j+ r3 I% }9 l' h. V6 e                        for (int k = 0; k < bucketElementCount[j]; k++) {
                            arr[index] = bucket[j][k];
                            index++;
, J& E: |5 d: |$ d$ j% W! ]                        }
                    }
: z3 b' @; m" M1 y6 J0 H* T; a                    bucketElementCount[j] = 0;
8 z! ~* B2 u* f  S& j" e& ^                }
/ K1 L  j/ i$ L9 J& N            }else { // 降序
                int index=0;
% X) U: G6 n: b( p# o" T% F0 A$ x                //从右到左，从下到上取出每个数
                for (int j = bucketElementCount.length-1; j >=0; j--) {
2 d& h# j* S2 I& J2 ?                    if (bucketElementCount[j] != 0) {
- \- }1 r, ]4 F# i                        for (int k = 0; k <bucketElementCount[j]; k++) {
                            arr[index] = bucket[j][k];
2 M4 b* i) b1 n5 R4 n- `* m5 D                            index++;
                        }
                    }
6 B9 F. l- M' ]2 y; n! s7 e                    bucketElementCount[j] = 0;
% W! S( T9 `$ J' z! r                }
! s& B: y' P5 W" N5 n0 |6 V( j            }



1 ~. s+ K8 e0 y& }
            /*for (int i1 = 0; i1 < arr.length; i1++) {
                System.out.print(arr[i1]+" ");
            }
            System.out.println();*/
7 U3 Z* o+ P6 M# T! ]
4 B$ ~) p4 E: K" n



0 @" C# M/ @2 d& _7 K
8 Z! M3 V2 [# ~/ F) B        }
        if (min<0){
            for (int i = 0; i < arr.length ; i++) {
3 h/ R& @! Q$ M7 k7 H2 O5 r; H                arr += min;
            }
        }
% V, i) c3 ]' [% u. ]( H4 d
$ `8 d1 C. R5 M
5 G- A- r- Q% n, a; f( X; Y    }
2 v! V; J1 h4 l0 ]}
1
, J+ h8 k1 J% D3 B) b2
. \# F6 z+ Z2 ~3
+ u/ W( D1 B9 \4
8 h' b* k' _5 ~" z; u5
6
7
8
9
10
# ^$ g6 u9 f3 u& d2 t9 ]% p11
12
13
8 O: b- r  q$ a6 ~; i14
15
16
  L, e- U& S, O  m17
3 R# {' @3 o+ F0 O18
4 J0 v$ t) D( m19
20
21
6 \$ z2 `# b  R, X1 c" J$ J22
2 `6 p  D! X  j" {2 ]23
24
5 ?+ W: ~, ]" T25
/ ^( _* W8 {6 N+ L: y26
6 t+ t3 o/ {5 ]3 _27
28
; S! m0 c1 ^9 D7 n29
30
31
* B- B6 S) U$ B& w# l32
33
. }' e/ z0 R6 y4 M- {; W34
35
36
37
# [: y# z& e: \) [+ D" g38
39
40
: |4 c) S$ P: H- K% R' _& w" S' i41
/ ~; f9 B  Y2 P% F, b42
5 c  G5 n! r, N8 D' q' j# Z43
, K( B% m. |4 I+ b' w' @& D44
. K; H# o0 |- }1 ~8 |0 U4 E6 h3 @45
46
47
48
8 o& i5 Z6 W$ u1 B/ A, s49
50
51
52
53
54
. G$ Q. T6 C5 R. E9 g55
56
$ T7 _3 e4 y/ T/ G, O57
58
. N/ F- Q9 K. l, L9 F59
60
. e- {! ~) |& k61
! }8 c2 J) \  o2 U- M+ {% c62
63
- u3 u5 [2 X+ g# c' }9 Y5 |6 J64
65
* S4 l  y0 O( x' n1 V66
4 I, }* r% F5 D$ h67
68
69
70
71
# w1 `/ N. y: }72
73
74
! V1 ]% T* I8 s/ s2 M75
76
77
8 ?" [+ |7 i; p8 V% ~+ ]  T78
7 M4 @" b0 k- J' K9 r4 \79
) H9 s8 n) m! h6 J80
2 ]/ B* z& ^6 w2 s81
82
83
完整测试类
package com.keafmd.Sequence;

0 m/ Y( i' r, T2 N
$ a/ ^% J$ G9 }+ \0 G) j* iimport java.util.*;
import java.util.stream.IntStream;
( V9 W& ?# x4 V  l; e  |import java.util.stream.Stream;
# O$ R+ Q" U0 T) N- V2 r9 j$ V
# p. u7 {2 B! a  T  v0 `; x6 j
! R2 T3 \' @9 k9 _2 U/**
* Keafmd
*
) j5 ~  O2 O2 n1 e5 ~ * @ClassName: Sort
, r, r# O8 c: K( G * @Description: 十大排序算法测试类
1 k7 c( D# j; O* l: [+ o" I * @author: 牛哄哄的柯南
* g9 K$ [" n9 n; C: `+ U+ c * @date: 2021-06-16 21:27
$ w& U! h; ^, u3 C */
public class Sort {

6 b6 C  Z* i6 t7 n; Q$ `# u
7 k3 L+ n; E3 b# i  j# |

    public static void main(String[] args) {
- b1 l- F0 }) C8 \; S" D
  }$ f1 p4 g9 U3 _
$ ^2 H: c  `% a! Q1 e- r, }0 J        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};
$ N; g" D! H" g5 C( o5 n        int[] temparr;


# n" p5 {8 H9 Q# a5 y2 w        //利用系统Collections.sort方法进行对比

% ^5 k/ a& M& t
        //将int数组转换为Integer数组
6 a, t7 ^- u# E- j1 ^        //1、先将int数组转换为数值流
1 m( P4 k5 J3 N6 A' W        temparr = nums.clone();
        IntStream stream = Arrays.stream(temparr);
        //2、流中的元素全部装箱，转换为流 ---->int转为Integer
        Stream<Integer> integerStream = stream.boxed();
        //3、将流转换为数组
        Integer[] integers = integerStream.toArray(Integer[]::new);
        //把数组转为List
  L1 b. Q6 }8 N& @        List<Integer> tempList = new ArrayList<>(Arrays.asList(integers));
        //使用Collections.sort()排序
3 \! x  b% Q8 |4 q        System.out.println("使用系统的Collections.sort()的对比:");

0 d7 V0 I4 r- \) _
1 c' o2 _5 [$ J) o8 A        //Collections.sort
& e: r# ]) f5 o) c" r        Collections.sort(tempList, new Comparator<Integer>() {
, B+ G) B9 X  R$ T% I* O            @Override
( f! H  y% m$ r4 J: m( r1 l            public int compare(Integer o1, Integer o2) {
2 `) C0 ^9 j( P8 I- F                return o1-o2;
                //return o2-o1;
            }
0 a6 ^3 I/ k( Y        });


( k% o" v6 |6 X; ?        //tempList.sort 也可以排序
2 O% e; ~# _( Y+ @8 ?" X       /* tempList.sort(new Comparator<Integer>() {
- U& k  C# k/ D2 Q$ \! ?* {            @Override
            public int compare(Integer o1, Integer o2) {
' Z1 C4 d8 h) C" c! ?                //return o1-o2;
                return o2-o1;
6 w! Q9 D3 W1 E4 p2 W            }
- A- L$ W% C, P1 |) {        });*/

; Z6 r* V1 u% g6 g
        //遍历输出结果
1 |" `7 K1 H" Z- _8 M+ ]8 q        for (Integer integer : tempList) {
            System.out.print(integer+" ");
        }
4 W% r6 U: {( s$ T, `

        System.out.println();
( T: _" q1 \: t2 c0 N1 D+ N( z
$ T" M6 C/ w8 X7 h9 n* J
        //测试冒泡排序
        System.out.println("测试冒泡排序:");
        temparr = nums.clone();
5 p( F2 u+ }" D' A+ F
/ H- t) P7 H, u" c; b
) s. {: i& L7 {        BubbleSort.bubbleSort(temparr);


: v0 ^2 p4 w3 q        //降序
        //BubbleSort.bubbleSort(temparr,false);
# e1 Y! f+ y; J# [( ]- V: ?$ u3 ~
7 Y0 l3 O3 n( Y( Z( F; s7 i# g
4 l6 u$ V' {5 l7 T8 H  }        for (int i = 0; i < temparr.length; i++) {
            System.out.print(temparr + " ");
        }
' |' B6 [) U5 Q+ B" P/ T$ D; M. O        System.out.println();


        //测试快速排序
1 ^. `% {2 ~/ {, D/ I: B6 ~5 y3 e        System.out.println("测试快速排序:");
1 B$ F5 T0 d; r8 t        temparr = nums.clone();
        QuickSort.quickSort(temparr);
4 b2 N; m1 ^+ o& |        //QuickSort.quickSort(temparr,false);
8 Q( X  o$ R+ R& J) W        for (int i = 0; i < temparr.length; i++) {
( q, D  M2 N1 h            System.out.print(temparr + " ");
        }
- U0 V) R5 p( w6 o+ g        System.out.println();


0 r- r. T& C4 z' s. a2 e1 W        //测试直接选择排序
        System.out.println("测试直接选择排序:");
+ @, F; I# D/ Y4 q0 M8 C3 M        temparr = nums.clone();
& ~6 p% O$ s% N7 Z5 q        SelectSort.selectSort(temparr);
# T0 I' N8 v0 B  [3 ^        //SelectSort.selectSort(temparr,false);
        for (int i = 0; i < temparr.length; i++) {
            System.out.print(temparr + " ");
        }
" }# A* |: n9 o& {# N        System.out.println();
( J5 J: i6 j4 c5 n( ]

' u" ?: U, S/ F        //测试堆排序
, ?0 a& s/ J8 s* ]& W# X        System.out.println("测试堆排序:");
        temparr = nums.clone();
; S2 l; F6 k: g; u" Z2 D        HeapSort.heapSort(temparr);
        //HeapSort.heapSort(temparr,false);
        for (int i = 0; i < temparr.length; i++) {
+ D; y* ]; A. Y+ U( o            System.out.print(temparr + " ");
        }
        System.out.println();
' o" o1 T' a" W5 f7 }

        //测试归并排序
5 O, \. Y; O+ z5 r0 N7 d0 Z- b        System.out.println("测试归并排序:");
$ ]1 S+ _* Y7 U4 V. t        temparr = nums.clone();
        MergeSort.mergeSort(temparr);
        //MergeSort.mergeSort(temparr,false);
        for (int i = 0; i < temparr.length; i++) {
/ V5 |" T1 @1 e) O, u' m            System.out.print(temparr + " ");
        }
0 c7 k  U. }; o  v        System.out.println();
7 P3 `. X; N5 A

& G$ \8 J$ z) k7 r/ ]+ v        //测试插入排序
        System.out.println("测试插入排序:");
2 g% P) `! h' z. `* e! t8 b        temparr = nums.clone();
        StraghtInsertSort.straghtInsertSort(temparr);
- M5 k+ E! l1 A  S, Y; Y        //StraghtInsertSort.straghtInsertSort(temparr,false);
        for (int i = 0; i < temparr.length; i++) {
            System.out.print(temparr + " ");
        }
. N2 F+ X  Q' C* G- B' x+ y7 \3 [2 N        System.out.println();
. Z/ h4 S0 ?$ k


5 k6 V: p5 x' C9 d2 [4 {
" n' L& O* K4 e9 t9 }7 G        //测试希尔排序
        System.out.println("测试希尔排序:");
' q' F' S8 r% r6 O3 T. f2 S# V        temparr = nums.clone();
        ShellSort.shellSort(temparr);
4 }& T# L* p1 x2 `& p        //ShellSort.shellSort(temparr,false);
1 p) B1 A! a3 t( g. H& l- J        for (int i = 0; i < temparr.length; i++) {
            System.out.print(temparr + " ");
        }
3 T- b; s) w) v8 g/ ]( Q0 g        System.out.println();

" D% e' l! y" J( _0 I$ R
" n6 ^" }; W1 B- k% I, [

" C+ p  N. @0 R* r& C        //测试计数排序
        System.out.println("测试计数排序:");
& G, u2 L6 r# a- n        temparr = nums.clone();
) `) x: B8 F" s8 h8 _! J  |        CountSort.countSort(temparr);
9 I  d1 X( p0 C- o7 g  s4 I  C        //CountSort.countSort(temparr,false);
        for (int i = 0; i < temparr.length; i++) {
            System.out.print(temparr + " ");
8 G4 X4 ^) F" V* @! y        }
+ U% _! E# @9 c; x! h        System.out.println();

1 B" C5 P6 {  T! A* R( u  ]


5 i+ n* w9 v# i, \        //测试桶排序
        System.out.println("测试桶排序:");
        temparr = nums.clone();
        BucketSort.bucketSort(temparr);
        //BucketSort.bucketSort(temparr,false);
9 a* R9 C# t8 o6 C        for (int i = 0; i < temparr.length; i++) {
' V4 z* x6 B) }, r, q            System.out.print(temparr + " ");
        }
        System.out.println();
9 Y7 B3 L' O8 Z) ?" I

2 m( e/ U! H% k0 E8 x$ }        //测试基数排序
' I! v& s4 F1 n9 j/ {; q: f. F        System.out.println("测试基数排序:");
        temparr = nums.clone();
        RadixSort.radixSort(temparr);
        //RadixSort.radixSort(temparr,false);
  J! {- h6 T% c! G6 n        for (int i = 0; i < temparr.length; i++) {
6 r* ~9 p& ]- ^: z            System.out.print(temparr + " ");
        }
        System.out.println();


    }
" e/ Z% j+ I/ C4 W: U8 P) ?# B
( I/ S! o: W& m1 |9 o" X
$ ~# }+ I& m- g2 W) f9 X}
1
, R4 \" H1 A, L2 W2 o2
7 k7 J% P' K) e( E$ _. |3
4
2 S: E. E* V6 W% X: l2 s" S2 o5
" S) k& e  f) f4 O- ~) V8 `, @* H6
7
8
9 _6 E2 J$ }) h- K1 h$ F" I$ ]9
* S1 W  Y# N" F+ n% c10
; i; [0 \) t- c# ]" P& E11
12
13
14
15
16
17
18
19
20
21
22
23
5 V/ a1 |5 S% ?8 v* N) C* B24
& o% k  D/ V8 V# b  X& ~25
26
* |3 _7 M: l9 \: ], h% f5 r27
28
29
30
31
( J( h( \; f/ K. I# P3 H% G$ m) `32
33
34
35
36
8 n' S1 \* b& }! D- d( U+ a& f: |37
38
39
9 {# b) C) X. h/ O# C1 Q, Q40
41
42
43
5 V, R3 Q3 o8 l7 y44
45
$ A& K1 c' G) {46
9 i0 ~" ~5 G" d5 Q47
! r- }3 p9 {' Y! t8 L* A! \48
49
50
51
+ x9 n6 k4 x2 R/ Z  X' O. o52
3 z: r- N4 }* a+ T$ P53
54
: P( j% M! j# k55
56
57
2 ]5 `, c* ]3 B+ G* e! a+ F$ `58
59
/ S: U' i" G) T% s' l, A8 O60
2 L5 e) J( V+ f# r61
- i) S$ z# V! N5 t9 J# a) S* m62
63
' `1 G7 q8 a3 t$ a' S7 o# G, ]64
/ q$ |' j2 c0 }* e* q/ J9 p65
66
67
68
0 y3 ~; Z4 u9 j  X' D$ f2 ^69
70
71
72
) p5 `5 v( q4 f$ d1 j  @/ M' \6 U73
: K) g% E' y9 G+ n  ]74
9 `0 ~0 N$ w0 b75
8 M2 V+ C) i- s$ ?& b: n% b1 X8 r76
77
78
: ^2 ]+ w6 q9 R1 E0 {2 }9 ~79
' e7 X. C1 |; Z2 F80
0 J" k% o: @$ W0 \9 {( J7 x81
82
, O; h. O# {  l1 N- J/ j. Z# m2 Z. I83
% M2 b  ^5 d* b2 a$ f84
85
86
. q. w' _+ g8 h4 |87
88
6 j6 }$ d( w' r% e4 V: P89
90
91
92
93
94
95
96
8 `! a# E5 ^/ Q7 V7 ?2 ~6 j# b  W97
98
99
100
101
102
103
104
105
1 J7 M$ C: b" s9 V4 X* Y106
107
108
109
  E0 j- q2 ~6 H4 G; @' }2 \. z110
111
4 l4 F; ^/ |( X3 O8 F. k: g112
3 U* K. R7 B+ f. d# {* r113
114
115
+ K( U! |7 C9 d4 q116
117
118
: o) u7 p7 {1 T& m- o; B# N119
120
* ]# o% m  s7 @1 D+ q, d121
9 x+ Q2 w: t4 D! i122
% @; D2 d7 h, Y# }' J123
124
125
1 D0 h& z) ]& O1 m126
$ `2 W! q, M5 s9 X( E/ W# x127
4 _. G6 H# u: ]8 s$ E% I128
129
130
1 O* ?1 s& I6 K* @9 W- x4 ~7 C0 V131
132
/ T" F+ [7 j" @7 {. {/ j/ t133
134
4 g& g3 z  c) C0 S135
7 f7 f2 A. i! ]- b136
( k+ l. d8 h  C9 z137
- t0 N7 w6 B3 p  {138
139
140
141
7 k4 J! {" f* ?, Z) s& r* @142
143
144
5 w* o' o: \/ p- [. l145
7 _4 v# L% p1 P7 K% ?146
147
- K& Z) l" d# T148
! t0 p- U- v. Z& i149
150
, k/ _; B6 j- a+ y) R* D# m151
0 D7 ^% E5 B; O3 e152
2 D! N+ _6 T4 w8 e' @1 s153
154
- ?0 |+ n. M+ E. E$ t155
) f5 c& g) R* |, U4 S* q156
1 H' D2 K1 v5 D4 j157
158
& Y: D# i: M' G159
4 M7 O  i3 J& ^8 O160
! z9 v" i' i0 L4 h161
162
0 L& y/ H0 l6 o& F% l: `$ I$ P/ o% }163
1 ]4 X, J. f0 I4 H" o; |% ]4 A% z- Q164
165
5 E2 z9 E. X" {! U2 Y6 O166
167
# p0 w: b1 b2 _2 U1 A5 B/ a168
2 ]1 @; B8 W! B3 U& c% K  T0 O169
170
171
5 ]( m' Q9 P7 E" q1 y172
173
+ T) i& K! J1 C! g' H+ u, `3 z; a1 a每天进步一点点！
不进则退！
0 t: q8 r& A" `

( h2 q0 H0 u' i9 T版权声明：
- k! i) u, f+ }. b) Z4 T原创博主：牛哄哄的柯南
博主原文链接：https://keafmd.blog.csdn.net/
————————————————
: h7 m1 p) q. j5 E/ t8 E( [版权声明：本文为CSDN博主「牛哄哄的柯南」的原创文章，遵循CC 4.0 BY-SA版权协议，转载请附上原文出处链接及本声明。
原文链接：https://blog.csdn.net/weixin_43883917/article/details/118193663

1051373629

每天进步一点点！
! I6 ?9 ^; R; R0 ^