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

杨利霞

经典十大排序算法（含升序降序，基数排序含负数排序）【Java版完整代码】【建议收藏系列】
4 }# ^# }. L- o* ?经典十大排序算法【Java版完整代码】
4 L0 h3 F6 N2 l2 M写在前面的话
十大排序算法对比
/ o4 M0 k- Y6 x# {冒泡排序
3 E! \  k8 T" X( X快速排序
直接选择排序
, r" q$ @9 Z, i2 X* L- k堆排序
归并排序
! r% S# l" C8 a. V$ [9 h插入排序
' w; e4 X# B$ a$ c. \希尔排序
! p' N( Q3 C, u* S. y; |( t计数排序
! R# O  i. X  I8 F  {+ r) T桶排序
基数排序
完整测试类
写在前面的话
9 y' ]6 p& e9 J" j# w       虽然已经有很多人总结过这十大排序算法，优秀的文章也不少，但是Java完整版的好像不多，还存在某些文章代码存在错误的情况，同时也为了自己练手，决定把所有的写一遍巩固下，同时也真诚的希望阅读到这篇文章的小伙伴们可以自己去从头敲一遍，不要粘贴复制！希望我的文章对你有所帮助，每天进步一点点！！！


       我用通俗的理解写下对算法的解释，对某个算法的运行过程不是很理解的话或者想看比较官方的解释的话，单独搜索某个算法，看几篇不同的解释，就可以有自己的理解了，这里我主要展示代码以及进行通俗的解释！整起来，再强调一次，一定要自己敲一遍，这样才能理解的更深刻！
; a* v+ v' F' T9 ~. q- w
3 D/ S  {' W4 f/ N5 @
十大排序算法对比
1 z& g- g0 e) f0 t: u
( N, x! J/ b7 S) p5 @' Q& C
' j  Y% M# W& t( l+ a% b
$ p3 a/ f) c- N5 f1 j5 F4 E. k8 b
. s, C+ j( }$ G/ G+ c0 `! C7 I- O8 T$ Z关于最后一列的稳定性，我稍微解释下，例如对序列：1 2 4 2 6 排序，序列中存在两个2，如果我们把这两个2标记上（让他俩不同），排序之后，前面的2还在前面，那么就称这种排序是稳定的，反之不稳定。


5 w; g$ L" o% ^* v! D/ {$ x# T2 M冒泡排序
" _1 }8 N# ^/ g5 T) R简单解释：
* ]# l/ A' r& c       原理就如算法名字一样，就像水中的气泡一样，每次我都把最大的或最小的放到最后面，这样总共需要n-1趟即可完成排序，这就是第一层循环，第二次循环就是遍历未被固定的那些数（理解成数组左边的数，因为每层循环都会把最大或最小的数升到最右边固定起来，下次就不遍历这些数了），两层循环遍历结束后，所有的数就排好序了。
$ n7 e1 c  U0 e$ X$ y6 f       两层循环所以冒泡排序算法的时间复杂度是O(n 2 n^{2}n
2
# z9 H* ~( t0 f5 W2 ? )，是一个非常高的时间复杂度，我在下面的代码进行了优化，加了一个标志位，如果上一次循环未发生交换，就说明已经是有序的了，就不继续下去了，反之继续进行下一轮。
# |. I$ u4 ^0 [8 G7 J' E" f
; q& {9 K* H2 ]; i7 s( Z) s7 p
" y! l% v1 |% s

; l6 ~3 ?6 h% B2 f: o
1 j3 `: U5 D# M7 \  C; m& c
本文的图片来源网络，仅用于大家学习，侵权联系删除！（下同）

6 K# G9 F+ j3 r& j% I7 O* }
完整代码：

. Z' X, W1 t# |
package com.keafmd.Sequence;
0 P5 z+ A  T; d( H7 e
$ K3 b3 c  N% Z+ z- x$ L& n
/**
* Keafmd
4 P) t* S' N& k; O- Z. y, c' r *
( p! P9 s: M* `' m& V2 ^) F. |! N * @ClassName: BubbleSort
* @Description: 冒泡排序
, B; F# x* Z9 n; q * @author: 牛哄哄的柯南
* @date: 2021-06-24 10:31
; Q/ ?* `! L) G/ r */
# k# m7 d# j! \4 t+ p8 Ppublic class BubbleSort {
, T. D; t8 n" w) ?

    //冒泡排序
    public static void bubbleSort(int[] arr, boolean ascending) { //exchange标志表示为升序排序还是降序排序
" B0 a. Q8 v1 n/ z% I1 k  f

        boolean flag = true; //加一个标志位，记录上一次是否发生了交换，如果是，我们则进行下一轮，如果没有，说明已经冒泡好了
6 v4 Y  F# o" Z( W  z+ B) t
6 Q  p4 J/ `: a1 O+ z6 S( j  c
" m* o! {# }" y. x. r! X        for (int i = 1; i < arr.length && flag; i++) { //控制次数，第几趟排序，只需要n-1趟，有交换时进行，只有flag=false就说明上一次一个元素都没有进行交换
9 Y: [# `0 |  v. [7 c6 q

; P, h: W  W# V  L; Y2 X/ S            /*System.out.print("第"+i+"次遍历：");
            for (int i1 : arr) {
) G: ?1 q3 Y" K3 I                System.out.print(i1+" ");
. t& u/ C* {5 z5 G# _& f            }
            System.out.println();*/
1 d" O5 R7 a+ k
* P. ^* U: B& h' E
            flag = false; //假定未交换
) V8 ]# p9 \5 e& S5 U7 w+ W9 p: B, Y

            for (int j = 0; j < arr.length - i; j++) {

( n1 f% A* K: @* g
                if (ascending ? arr[j] > arr[j + 1] : arr[j] < arr[j + 1]) { //控制升序还是降序
                    int temp = arr[j];
( X9 I/ p4 c3 o; p7 m- e                    arr[j] = arr[j + 1];
                    arr[j + 1] = temp;
2 j  ~- h* b( F& A1 C: C: C                    flag = true;
/ y) G, F% B% ^2 S' G" I                }
( A6 x) J: a5 k9 L

            }
        }
    }
! C: U) X0 E- ~! e1 o* F. t
: s, D+ G  f8 }2 z6 A, H
    //冒泡排序 -- 默认不传参升序
    public static void bubbleSort(int[] arr) {
        bubbleSort(arr, true);
' w* f! D1 {' [0 \3 `" u9 F    }
}
1
4 S# t* M% P$ F6 Y7 `2
3
4
/ a' s9 O/ S) H. X5
6
7
- G! m- H' X9 J! w9 V1 \8
: u7 v: Y* K7 Z. [, n9
- b/ O$ V5 V# f10
2 Z& H* Z# w% N+ }# s( w( g6 f' B  i/ W11
- m9 u5 X( n5 W. t# z, U& _12
; Y- Y7 p5 N9 m# X" M% z13
: S4 e0 Z+ M. L; l7 z. F, g( |6 R14
% L' d5 H9 N" w3 L( t: _/ s15
16
17
18
; ~6 q$ p# Z  V9 n4 a" i" E19
20
21
& t% y9 c6 l$ F% {22
2 U% B: L! |3 p6 }5 R23
24
25
5 ^/ e8 h7 J4 _26
27
28
29
30
31
9 Z% z1 k+ Q% W2 E32
1 Q7 ]# X/ O9 g9 {1 L- L" S6 c33
. E: s/ c, N6 J2 X* ~, p$ F) E34
35
/ ~. F) |. V3 ~6 E" |36
37
6 L! x  w# D; K% U. h" E# {38
39
! w3 \! X5 @7 F) X* U+ R0 I8 ]40
41
42
43
44
$ O' t1 ~0 k! K1 W45
6 L: V% u, A" f8 l5 W测试代码：
" j4 c$ O  R, R7 Y) V, D) f

) S  u& e4 C) P5 {% q( G9 U9 j升序排序（从小到大）
3 f2 s- K' f8 Y. J% A# ]0 u

' a$ m( w/ U# J* I" ]$ K! Lpackage com.keafmd.Sequence;
8 T( p* T! E1 I( c8 Y( `+ Q7 I1 j
1 S* ~5 |; b; t2 q5 ^% a
import java.util.*;
import java.util.stream.IntStream;
# s8 T& s8 ]6 }9 U9 ~, A8 x6 ~import java.util.stream.Stream;


/**
' [2 u! G- C; V  p) C! |3 s0 ? * Keafmd
/ e5 ^. l6 w& _! B. d, F *
* @ClassName: Sort
0 S" `5 n) I6 |6 ]5 o * @Description: 十大排序算法
* @author: 牛哄哄的柯南
6 {  C7 B( a: D0 ? * @date: 2021-06-16 21:27
- ~4 o7 I, v- g+ f5 H" | */
public class Sort {
    public static void main(String[] args) {
0 Q; |4 q1 r, L

: a/ x; d* V8 \3 ]        int[] nums = {12, 4, 25, 47, 58, 34, 25, 9, 99, 26, 1, -13, 162, 10093, -66, -1};
4 q1 |2 x/ Q( K) h6 m        int[] temparr;
/ j) |3 o: s- U" r) W

        //测试冒泡排序
7 Q) `% _- T# J+ y        System.out.println("测试冒泡排序:");
  q  r2 d. }# I% M$ g        temparr = nums.clone();
) N" D; `/ T, c! s: a( i        BubbleSort.bubbleSort(temparr);
, C2 y0 ?$ b+ w( C( N+ U; N        //逆序排序
        //BubbleSort.bubbleSort(temparr,false);
        for (int i = 0; i < temparr.length; i++) {
( O4 n- t( Q# R# L+ I            System.out.print(temparr + " ");
' ]! t3 L. t1 g: q% z# ^% O- e) j        }
        System.out.println();
3 K' a$ V& I* K& \2 y7 x8 d

1 D; @& R% o. |. q( I# e! y    }
6 o* R1 M5 ~; p# u/ c: X% D$ f, `}
: E, X$ O0 Y; I9 x1
1 n# j/ r. N) }1 e2
. i. o7 z' b1 Z; F7 P4 Y& f+ ?, @3
4
9 L" R- T; w2 x4 E( h5
" u8 q: y, Y' u: N$ `6
3 H/ `2 N0 ?4 B7
" S: ~# ]2 F0 }5 f, E: B8
. T6 s7 V# i  T$ e9
10
11
2 v) E" d1 _) ~( Z$ n# y. i, m12
4 G- R6 y. q. W$ j13
9 f4 \2 H- O8 ?& f; e9 E14
15
- }4 h# R+ E1 |6 N4 [9 p1 s16
17
18
19
( w. @3 J7 p# h) a20
5 X8 a& N0 N2 G21
22
" L9 f7 b9 p& m! [6 ]23
24
& M. F& M: V" `2 C; `, f25
" p3 [' t6 z2 A& c2 @26
! @8 w9 p" K7 Z$ z2 J' u4 P$ P27
28
29
7 c! X; ^; L4 q. P6 U7 E! _) g30
31
. I, V4 ^$ I" q  f32
& [2 b) N8 ], U6 m33
运行结果：

: T" A/ F/ t, M  x
/ ]6 p+ \# k1 e6 n' c3 l测试冒泡排序:
8 r$ r6 m/ e0 [: p+ o7 h  }-66 -13 -1 1 4 9 12 25 25 26 34 47 58 99 162 10093
1
2
5 J+ \! g$ D0 J0 }6 p+ q* o降序排序（从大到小）
3 Z! h# g) ~, G/ ~

9 K+ s# D+ V7 I% r//测试冒泡排序
8 d/ n* C, V9 ^% U& U2 rSystem.out.println("测试冒泡排序:");
temparr = nums.clone();
8 [9 B/ [3 Y, C4 T" z6 h9 PBubbleSort.bubbleSort(temparr,false);
for (int i = 0; i < temparr.length; i++) {
    System.out.print(temparr + " ");
}
1 g: }; z+ y; ?/ F' D# C# CSystem.out.println();
+ y8 n- A( Q+ }' A% W% k" s1
8 y  f5 O) a& M1 m. f2
$ x; Y" n2 Q; _: D& l3
. P1 u! k4 X: e( N3 X! `3 P" Y4 ^4
% B* T9 K# ?7 x- R. N9 _' ]5
( P% V+ O: U- S6
+ m# t" b7 B3 k2 u7 _! \$ S! G8 X7
. T7 H7 m9 q% W* N0 z3 A8 B& X8
运行结果：
4 |2 L+ v1 D3 y6 c4 \3 h/ o
, K  g8 }; w" s
测试冒泡排序:
9 `6 s3 _# S; [1 y. [) M& W2 y10093 162 99 58 47 34 26 25 25 12 9 4 1 -1 -13 -66
+ z( y3 |; e  g$ l1 g" B. u. r1
2
下面几个算法的测试也就是换了下类名和方法名（换成相应的排序算法），如果想降序就在数组后面传个false即可。我就不一一复制了，我在最下面给出含所有算法的测试类，需要的自取即可。
" ^5 x, U" t, a+ b- G' h
3 h- i# C. Y) g
快速排序
简单解释：
, p+ t% x9 B7 M快速排序就是每次找一个基点（第一个元素），然后两个哨兵，一个从最前面往后走，一个从最后面往前面走，如果后面那个哨兵找到了一个比基点大的数停下来，前面那个哨兵找到比基点大的数停下来，然后交换两个哨兵找到的数，如果找不到最后两个哨兵就会碰到一起就结束，最后交换基点和哨兵相遇的地方的元素，然后就将一个序列分为比基点小的一部分和比基点大的一部分，然后递归左半部分和右半部分，最后的结果就是有序的了。


* E" y& {+ n$ H
9 ^. B, {* r* q8 I9 n7 Y- L4 t
5 h6 W7 D. S8 {: B( K

完整代码：

; z2 b# r% Q$ j7 w. {0 Y% w
% \. e, }. ?3 E5 T9 Bpackage com.keafmd.Sequence;

' x$ K& ]) L; `1 D% t! W9 r
/**
* Keafmd
' |, X6 a1 L: T *
4 \4 \4 L; |3 c' i  o * @ClassName: QuickSort
% c4 N% }, i0 I+ S * @Description: 快速排序
* @author: 牛哄哄的柯南
* @date: 2021-06-24 10:32
& O  t8 J/ G3 A# f& y" z */
7 {# K5 u! v$ k- k1 e5 ?public class QuickSort {
* b8 o9 `6 {, H( S1 S/ K
) \0 j. O: E, S8 I9 H+ _) R  Y1 g" L
    //快速排序
    public static void quickSort(int[] arr) {
        quickSort(arr, true);
0 P% _9 V. }. S5 P! X    }


' p1 S. e$ b2 }  }' T8 Y    public static void quickSort(int[] arr, boolean ascending) {
- h! s  k' J# r& U1 G! M6 x% i        if (ascending) {
            quickSort(arr, 0, arr.length - 1, true);
# R9 V. U6 r; f& i        } else {
            quickSort(arr, 0, arr.length - 1, false);
        }
    }
+ K( J, @8 G. A( W

# @* R8 w2 N6 q! L; B: x5 F    public static void quickSort(int[] arr, int begin, int end, boolean ascending) {
- j: K9 E( h" d& b        if (ascending)
            quickSort(arr, begin, end);
! K5 }6 I& {6 H6 k8 _        else
            quickSortDescending(arr, begin, end);
4 R; H+ h: o( @3 k' p% Z7 E    }


* {5 d5 U* g1 G, N    //快排序升序 -- 默认
    public static void quickSort(int[] arr, int begin, int end) {
  n2 v8 s, d0 O  u: I0 X        if (begin > end) { //结束条件
/ j; s  }; S% h            return;
% b6 ]; J2 H( u6 S: j- G- t4 Q" d        }
        int base = arr[begin];
        int i = begin, j = end;
. I, S$ }+ Y0 n% ^0 i) G- b0 S        while (i < j) { // 两个哨兵（i左边，j右边）没有相遇
            while (arr[j] >= base && i < j) { //哨兵j没找到比base小的
                j--;
            }
            while (arr <= base && i < j) { //哨兵i没找到比base大的
                i++;
5 ^; `+ E2 N/ |6 L: t, W            }
0 c4 e7 L4 a1 b+ e9 U- z1 t            if (i < j) { //如果满足条件则交换
; F3 \; g- [! X                int temp = arr;
                arr = arr[j];
                arr[j] = temp;
- g7 p) P( ?3 ]8 Z$ q/ J            }
; D  X) J( G& C% |) g

        }
! O3 W6 F) v# g7 u' V" R$ p8 b8 M        //最后将基准为与i和j相等位置的数字交换
        arr[begin] = arr;
9 `- Q1 t' E/ @* a        arr = base;
        quickSort(arr, begin, i - 1); //递归调用左半数组
5 ]' D& m5 E  u' F: l/ v5 \' t        quickSort(arr, i + 1, end); //递归调用右半数组


    }

5 g0 A: X% n$ V9 G6 R. {- P) C7 k0 ^. \
7 q# b6 c# \; v9 O2 R% J( ]    //快排序降序
    public static void quickSortDescending(int[] arr, int begin, int end) {
9 s( y  Y- C( D4 f0 l7 ]9 y2 ?        if (begin > end) { //结束条件
+ F1 W- I" F2 V            return;
# k3 j8 |. \& z4 S5 t. z" I4 k; P        }
        int base = arr[begin];
        int i = begin, j = end;
# n( D5 N+ K- ?- C        while (i < j) { // 两个哨兵（i左边，j右边）没有相遇
            while (arr[j] <= base && i < j) { //哨兵j没找到比base大的
4 W/ A3 x* T4 R4 j                j--;
            }
            while (arr >= base && i < j) { //哨兵i没找到比base小的
                i++;
            }
            if (i < j) { //如果满足条件则交换
                int temp = arr;
6 ]8 k$ ?- n$ U/ G( U                arr = arr[j];
                arr[j] = temp;
            }

7 s6 W; a- B; z# ^/ Y( Y
        }
        //最后将基准为与i和j相等位置的数字交换
4 O; T  K" [$ a' i) S6 ~5 S! w        arr[begin] = arr;
# i- _0 V- }* D9 D2 b        arr = base;
        quickSortDescending(arr, begin, i - 1); //递归调用左半数组
        quickSortDescending(arr, i + 1, end); //递归调用右半数组
2 Y5 L: q; d. T* S

: _# `! d- L7 l% c& w5 ~    }
/ C! _% p) k2 w3 s7 I

& `, c, O) q! p/ X% L}
1
, T' T" X7 }/ ?* P9 u4 V% z2
3
9 a' U: \: z! ~) l5 Y3 {4
5
6
" ^2 x: ~0 H& P8 p3 i$ ~7
8
; A/ z5 s& h' G5 R; x3 z+ H9
' @0 b' m8 l0 v5 G10
11
12
3 d* ~' H9 I. j, L13
- j# X; N, b6 u+ `# |: N6 R14
8 g6 @/ g5 }+ ]6 _6 V15
% C0 Z. ?6 d: n( o/ c16
17
18
. j! v1 C8 U$ J# N1 Q19
$ [( S2 ~* R/ q  d) Y20
21
1 J( I6 W; M  F22
23
& ^$ k  W, n5 {- v1 ?( x24
25
26
27
28
9 ?; o/ S, X& e( L, m1 R29
30
31
32
0 H# a" n$ d( W0 f, j3 g0 d33
! g3 A0 Y- y. M. ~+ S34
35
2 w* |0 q# c1 }3 ]36
" b6 \1 u0 {2 {" m( `37
38
+ }1 n- N& |# l1 \. E39
40
41
42
43
44
7 Q/ `) ]1 r# n45
46
1 `1 Y; j% t9 V1 d1 D, O* E5 n5 {3 V47
* B* _' c* q; N$ c7 r8 N+ h3 z3 K48
49
50
5 Z0 m+ P; I' D( u: m) x51
52
! D0 A3 A: `5 s53
. N: O, Z$ p3 Y6 [" u( d54
' F: G( L: n* j% Z55
56
; U  p6 m1 j2 h5 h9 e57
58
) T8 U% s4 f  K, J, R* A# j59
; N$ Y4 @) F# ]1 r1 X$ D! `( i60
61
  G" H0 u3 r/ X62
$ `$ r0 u3 h/ \63
64
65
66
67
68
69
# i- l& q. V# T. e: J70
71
# S5 D# |- a" a/ {! Y" X72
73
0 c& U1 e3 k. M3 H4 p74
* u$ W, Q3 W/ E1 `5 o! _/ V9 }& H75
76
6 P" E+ f2 o3 j% a7 r4 }9 n77
& C  R: c  b) C$ z7 ]78
79
: F8 l/ w$ I, O! o% r; N) U. P80
& @* Y6 y+ L; \  ~81
+ _( m- v2 z: E* S: s82
3 `* q) S( H9 I% t6 S7 G83
5 n, A; c/ h# D" s84
85
' u" S0 p6 y; s0 u/ |7 K86
87
88
89
7 i% Z2 ?! b$ \. F90
0 C* r% f# |8 \, H, b91
7 p: {) L* O. ~6 P直接选择排序
2 S$ R# z$ L! H0 Z% r简单解释：
数组分为已排序部分（前面）和待排序序列（后面）
第一次肯定所有的数都是待排序的
从待排序的序列中找到最大或最小的那个元素，放到前面的已排序部分，然后一直找，不断缩小待排序的范围，直到所有的数都是已排序的了
  j1 z4 V/ ]* l3 F# @" w: L

3 s- e+ V6 G: ~9 l. v. R2 _% b
  K1 `3 G9 v4 @$ k: z0 K7 {+ k7 I+ `

3 \! u% U0 T9 [7 o, y  W) }( E
完整代码：

; U5 S' Q' l! Q' ]
& H. k. R; u5 z: `( Q' d. o/ l: J& Ypackage com.keafmd.Sequence;
8 S+ i" p3 V; T% V" k
% h: r5 ]6 Y3 g  L, N0 B
/**
' T# k- N+ X- u, ]& a; r * Keafmd
6 q0 m5 O, |$ A$ u7 s7 I8 V7 G *
* @ClassName: SelectSort
% Q4 f: s( D% F * @Description: 选择排序
* @author: 牛哄哄的柯南
5 v% b" H- u/ @$ q% I4 \$ G: O * @date: 2021-06-24 10:33
4 Z3 w$ r1 _' [* y( L7 | */
public class SelectSort {

5 }* P5 o9 j/ P6 [, X
* r( \6 z/ `  q8 |    //直接选择排序
: [1 p2 c' d7 h& ^5 _0 f    public static void selectSort(int[] arr, boolean ascending) {
2 J( l: q  v: P% n3 R        for (int i = 0; i < arr.length; i++) {
            int m = i; //最小值或最小值的下标
            for (int j = i + 1; j < arr.length; j++) {
                if (ascending ? arr[j] < arr[m] : arr[j] > arr[m]) {
                    m = j; //找到待排序的数中最小或最大的那个数，记录下标
$ d' ^9 I% H' {$ ~' v                }

. a1 E  K+ w  T3 E' \$ v' B% J
8 d! v2 a& F) V9 Q, L' X            }
2 `# A( F) X; @0 ]            //交换位置
            int temp = arr;
- h" S) X( O% k) b. J7 j/ {% Y            arr = arr[m];
; H* r( D! x# U9 |( [2 b            arr[m] = temp;


        }
; Z) H. S1 ^: H2 }! v4 Z    }
% c/ \  a5 j7 O0 i! m4 N

4 l* N3 {9 v/ q2 }1 @    public static void selectSort(int[] arr) {
# Y  M0 F  g) Z        selectSort(arr, true);
    }
1 ~% Q- k% [* w0 ?/ ?: a2 b}
1
; B: }2 \% H8 X& |2
6 m3 u+ J/ w2 C- z/ w  i  p7 A5 l3
) c, Y& p% z  \" L2 c. T4
5
- J1 }+ d3 S, s5 \8 i1 S. s6
4 A: |  v' E2 F5 z" X7
8 p! u0 Z+ V1 t" t8
+ e8 Z% N9 ^8 L0 o( T# E) ^7 J9
: e, k( e; `1 [. o5 N10
11
12
2 [& G4 o) a1 z( d! }13
14
15
6 t( W( l2 Y: A9 E# x3 {5 L16
, P0 g) E" F+ r  v/ `6 n% @% d& V. q17
18
( b; {' `# X( n. G4 ^19
; n3 j6 s5 t" o6 ?: B3 s20
" O# j1 J: }; `1 l# S3 {, {) @21
6 d' w. @2 {' A22
23
24
' k! P* h) Z' c2 A6 E1 z25
26
3 U: o5 v% ]! j  p5 c$ X27
28
$ Z1 |% O/ e7 s: W% w' I  N29
30
31
32
33
34
$ n% S$ ]3 L! w* A* e堆排序
4 |/ O# O5 Y; C' @3 L7 R先理解下大顶堆和小顶堆，看图
大顶堆，双亲结点的值比每一个孩子结点的值都要大。根结点值最大
. ?" u0 P' W' L3 ?. d( f小顶堆，双亲结点的值比每一个孩子结点的值都要小。根结点值最小
# R2 i4 |$ T2 P# z( O) s



' L& Y$ k/ C& @) N/ x) F简单解释：
构建好大顶堆或小顶堆结构，这样最上面的就是最大值或最小值，那么我们取出堆顶元素，然后重新构建结构，一直取，一直重新构建，那么最后达到排序的效果了。

: N9 {  U# M7 z. U* r% ]8 [


1 A$ J* a* L; b, z9 c$ M2 C

+ a1 k" V! `3 i  X3 N* g( E完整代码：
7 |: |1 i8 M4 i4 n. m( ~
/ o- |. m% F0 T  U1 c. ^" Q
) `5 R/ O  N+ h1 s1 Mpackage com.keafmd.Sequence;


/**
' ?" E7 S; [" r! |  H. Z* n# I2 E$ S * Keafmd
*
4 N" P8 B6 {$ H+ i* H * @ClassName: HeapSort
* @Description: 堆排序
* @author: 牛哄哄的柯南
* @date: 2021-06-24 10:34
*/
public class HeapSort {

" w% ^# |  T& I/ e& o: F! f
% ^$ `8 [7 v9 Z# e# L    //堆排序
+ Y8 z- d: }% v" ^& C! v4 Z/ m    public static void heapSort(int[] arr) {
        //对传入的数组进行建立堆，这里默认建立大顶堆，进行升序排列
        heapSort(arr, true);
; }2 N; X# q" C  F    }


( @; D% X! f/ |% Y4 _    public static void heapSort(int[] arr, boolean maxheap) {


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

4 O0 K! c  u3 G* k4 B
        //2.调整堆结构+交换堆顶元素与末尾元素
3 i/ m& T( ~+ o        for (int j = arr.length - 1; j > 0; j--) {
* B& h  F  R/ n% y0 X1 m. `$ j
- t: {' V4 S5 T* E; [
' c3 M% Z1 ~( d            //现在的数组第一个就是根结点，最小值所在，进行交换，把它放到最右边
$ v$ v8 V2 q. Q' e  h+ K/ q            int temp = arr[j];
            arr[j] = arr[0];
4 Z1 S; A# B, g6 p* d            arr[0] = temp;
5 L* x4 N9 ?! B+ B4 P, T/ A. U+ B
, D  ?; J0 x: \; y
2 F! ]7 B" D3 q# i$ ~            //重新建立堆
            sift(arr, 0, j , maxheap); //重新对堆进行调整
        }
    }

. W- o8 i& F. f3 B
/ L5 S6 v" {$ ^5 S    //建立堆的方法
    /**
     * 私有方法，只允许被堆排序调用
7 }; R4 y# I7 `( l4 m$ E     *
     * @param arr     要排序数组
* X1 i7 D- K" X3 \     * @param parent  当前的双亲节点
     * @param len     数组长度
     * @param maxheap 是否建立大顶堆
     */
    private static void sift(int[] arr, int parent, int len, boolean maxheap) {
3 w- B! J1 h, [# Q- B* p8 A5 W
( }$ s3 ?* s5 i$ M
        int value = arr[parent]; //先取出当前元素i


1 X3 q6 o& D8 t        for (int child = 2 * parent + 1; child < len; child = child * 2 + 1) { //从parent结点的左子结点开始，也就是2*parent+1处开始
9 N% c9 W1 H, ?  h

+ t5 B: ~& Y) g: ^4 h! X; s. u" N" R            if (child+1 < len && (maxheap ? arr[child] < arr[child + 1] : arr[child] > arr[child + 1])) { //如果左子结点小于右子结点，child指向右子结点
                child++; //右孩子如果比左孩子大，我们就将现在的孩子换到右孩子
, l9 p2 K3 v3 E' L. r1 t) c/ P( e            }
. O  a" b: D+ w  [9 F; D; J1 S

. R( l' m; f: f2 Q1 _# Q            //判断是否符合大顶堆的特性， 如果右孩子大于双亲，自然左孩子也大于双亲，符合
# O& P  a/ [4 p2 X, K6 g* W            //如果子节点大于父节点，将子节点值赋给父节点（不用进行交换)
            if (maxheap ? value < arr[child] : value > arr[child]) {
( W0 b% \7 X! J5 n$ c                arr[parent]=arr[child];
+ Y" R& X, B9 \7 k  p                parent = child;
            }
/ t8 |! H+ B1 J8 Y3 j" C, q2 }# m            else {//如果不是，说明已经符合我们的要求了。
                break;
            }
        }
; R/ H8 ?7 v6 `2 K. L        arr[parent] =value; //将value值放到最终的位置

. [1 D* {- d: u5 M0 ?' S7 x: ?

; D) m3 g1 {3 j( Q4 u
    }
$ p4 W  c$ A4 Q. Y, a1 U
2 o, k$ r7 ~6 z# m" a
3 Y8 W# F2 i1 Y3 p% \}
1
2
3
4
5
6
7
8
9
! H0 l% O( r2 h10
11
7 D8 @& L( p# H$ b12
13
! A0 X( l" G, \" J4 ]: `1 Y) M14
15
16
17
* P) F- u- h& W) T% Y) \2 `6 _18
& ~5 K& z, e: r* D7 ~" m; T& F  u19
, m  W" Q6 d% n" g20
21
/ e. o3 p4 U3 ~$ ~% i. A% c% @22
23
24
5 k; _0 W4 ], {5 O; b+ ], q- c25
26
, h: f7 y% J8 W% g, u4 Y- F27
% l7 O' a  i; b3 X* K2 L28
29
30
31
( |, Q8 r: p7 F$ ]32
33
! y$ B% t5 j  u7 _' w# ~9 g34
35
36
7 I6 p- V$ z8 {) [$ m9 g6 K37
; x# t6 {( T1 h. N" r, k& ?* ?; t38
' I: h' q% \# d4 z# k39
40
0 ~; C! q" A* @: J8 k5 E41
42
43
44
45
" u* N  A6 m4 O& f$ v( s46
47
5 @- c2 W! Y. N8 i& B* ?48
49
50
, Q/ G0 D! _" L. C6 S51
52
8 s% \4 a1 O# ]0 |53
( |. t& r1 a8 A+ H54
' z* y: v+ X0 {55
56
3 T  v: ~$ B2 |0 q9 Q57
5 ?& F7 `6 a* n7 n- |# c58
3 E6 W5 s: y2 P0 v5 L) \4 F59
60
% A' `# }6 ~3 ~3 ?+ \) e# x61
62
) s: e; h* N" x- o63
64
65
66
& O9 r7 I  m# _' S67
68
69
70
71
72
8 E! ~& {% v6 T' Z- B5 d0 [$ E73
74
归并排序
简单解释：
) P) Y. C/ E* H  y# e; r该算法是采用分治法，把数组不断分割，直至成为单个元素，然后比较再合并（合并的过程就是两部分分别从头开始比较，取出最小或最大元素的放到新的区域内，继续取两部分中最大或最小的元素，直到这两部分合并完，最后所有的都合并完，最后形成完整的有序序列）
: }+ D8 b$ X' h( E


1 a: @( \* m/ H

4 G2 t! M; M1 L4 U; B; J) t
完整代码：
* J- @/ _9 Y" k6 m# C
1 F! T8 A1 e4 Y
) N  O" ~7 L% B# b4 q7 Zpackage com.keafmd.Sequence;
. g! |+ ]6 v7 W% A
+ D3 T, m, X; I" j- _! f9 I
/**
* Keafmd
*
. V6 B, \2 X& N  o( R4 k5 a * @ClassName: MergeSort
7 k9 T. B5 t$ S * @Description: 归并排序
* @author: 牛哄哄的柯南
* @date: 2021-06-24 10:35
2 p  H: u6 b# P) d: H */
, S0 t1 M- W7 M1 D9 p% R8 ?( c& Kpublic class MergeSort {


, d/ x0 [; U6 ?0 ]    //归并排序
" t# w6 K/ A5 p' F% d    public static void mergeSort(int []arr ,boolean ascending){
6 V/ ]9 C5 C4 y5 Z        int[] temp = new int[arr.length]; //在排序前，先建好一个长度等于原数组长度的临时数组，避免递归中频繁开辟空间
! _5 L2 |5 j* N. O        mergeSort(arr,0,arr.length-1,temp,ascending);
    }
5 Q1 F" P; f( x    public static void mergeSort(int []arr){
! s2 L  }: q1 X' B        mergeSort(arr,true);
    }

- [+ I& z4 z* ^" f* A# o
$ E' {0 \0 s. h% l    /**
8 _+ n) q. b$ {& d* |     *
% l8 j& w0 D7 ?6 t     * @param arr 传入的数组
     * @param left 当前子数组的起始下标
     * @param right 当前子数组的结束下标
     * @param temp 拷贝暂存数组
. d- m. a  H- A, L' d* Z+ y- G- }% G9 k     */
    public static void mergeSort(int []arr,int left,int right,int[] temp,boolean ascending){
% ~) f$ S  S4 ]' f8 J! C% k        if(left<right){ //这里是递归结束的条件，我们是对半分，那当left==right的时候肯定大家都是只有一个元素了。

! G! K% g  o. D5 _7 R
            //对半分，比如总长度是10，left=0，right=9，mid=4确实是中间分了，0~4，5~9
            //当长度9，left=0，right=8，mid=4，0~4，5~8
# N( ^' N/ @% c7 F            int mid = left + (right-left)/2; // 防止越界的写法
$ m8 g, i/ M2 u6 g            //int mid = (left+right)/2;
# m5 y6 E# c' e' l6 k) R

5 `) z1 B+ W% Z1 ^$ l            mergeSort(arr,left,mid,temp,ascending); //左边归并排序，使得左子序列有序
            mergeSort(arr,mid+1,right,temp,ascending); //右边归并排序，使得右子序列有序
1 \2 Z& S. M* T( I. P( p9 c

$ z& q" b& [* d) R; N            merge(arr,left,mid,right,temp,ascending); //将两个有序子数组合并操作
        }
    }

) e9 U  D- w0 Q. K. Z8 ^7 z
6 n5 P4 V* }1 H0 W/ j: G    private static void merge(int[] arr,int left,int mid,int right,int[] temp,boolean ascending){
        int i = left; //左序列起始下标
: s' b8 Q& i/ E- ?8 R6 W  V2 P        int j = mid+1; //右序列起始下标
        int t = 0; //临时数组指针
+ I  D4 H  F3 b/ l        while(i<=mid&&j<=right){
: E. j( y5 \) @7 }) R- {( B8 _8 Y            if(ascending?arr<arr[j]:arr>arr[j]){ //比较两个序列第一个元素谁小，谁小先拷贝谁到temp，然后对应子序列下标加1
8 E! ?# v+ ~5 U                temp[t++] = arr[i++];
            }else {
                temp[t++] = arr[j++];
            }
        }
% {; P( P, b2 ^' j4 \
, F& ~1 S7 l# Z* A9 c
        while(i<=mid){ //将左边剩余元素填充进temp中——左序列有一些数总是比右边的大的数
) P. u# ^0 W/ L2 Q: h            temp[t++] = arr[i++];
8 N0 F9 v. L( A! u        }

2 V0 F" ?6 G3 w( K5 K1 C
1 {8 b% o" D% z        while(j<=right){ //将右序列剩余元素填充进temp中——右序列有一些数总是比左边的大的数
            temp[t++] = arr[j++];
        }
/ x4 j, ^  ~) y4 u6 x) l( O# C
0 ?4 Z$ D! X" X+ h
        t = 0;


# _' P5 Z& e1 i8 V/ _# C6 n. |0 c        //将temp中的元素全部拷贝到原数组中
        while(left<=right){
            arr[left++] = temp[t++];
* ?- }( C: g5 w1 v2 k# R        }
% B+ {# z* r" v0 a# t
: R, h* u/ D* Z! u
4 @3 ^6 C2 L4 q    }
3 G4 B; \2 A2 J2 X
* a, t" Z9 w/ w( t" J  K
' f4 W9 f1 V, V}
% g. M1 t  f7 k4 z( `1
2
3
4
% V! I' T* I3 |5 p$ g4 d' K5
. U! e! N6 h4 w/ |" a6
$ R: }0 E7 \) }1 Y; G7
; Y2 N3 ~; {. z6 {8
, s, @4 `' i3 H. |6 j9
$ N+ t% Z* Q# T1 h  z1 ^10
# P8 e3 q) H' Y/ Q2 k4 e( M& i$ F11
12
13
& b" D7 X% ^) C) P7 F# _9 m14
15
16
  N) P, F5 m: _17
( C8 `: g% J2 O. e; P- Y5 k9 n5 H18
19
20
5 x+ `7 ]$ f& d5 k1 c3 a& t21
6 X. l+ l! s$ w. S22
23
24
25
26
3 h+ u6 k' q6 n4 X4 n$ J27
28
5 x9 y7 S2 y4 \# W29
30
; p: W! P0 i& a1 M6 y3 U31
4 C6 N+ d5 m' Z* [  f8 ]32
33
' z! P" R- d* L8 O# h8 `8 a  V7 K34
35
36
5 R5 |: W* m0 h- x: O. `  i+ U3 H37
, ?' y8 f  h4 A/ i& x9 m- V38
' Z5 \7 S& y) ^7 x1 s39
40
4 G7 [. H8 N9 H2 T; A; a41
9 L# U6 x% c' {; Q( a42
43
) y" w9 }2 ]: Q44
45
0 s1 H! X3 j5 e$ ^+ B3 `2 \46
5 L6 t9 G' k9 v, r; N$ x5 _47
3 N1 ^$ ~, G  [  B. b2 g5 ~! h2 j48
5 J9 x5 J9 m+ {# q; t! k5 F7 W2 Z49
2 H0 e2 Q& {: i50
51
& K; {: p0 C, s4 y0 g52
53
6 M# T' x1 O5 x: {* y* B  A4 r7 e54
0 r& s& b7 L2 m3 h3 `55
56
+ d# `4 n6 ]$ N4 o  ~! E4 @/ D  N57
58
59
60
1 \% }9 e/ j$ [61
62
/ L# E9 r- V+ d: g  Y63
64
8 @% w3 z0 ], z4 K, g8 I65
; R3 o4 k: U/ g6 e/ v2 D  F66
67
0 L+ W2 E  L& O/ U1 O! {: p/ ]68
69
70
2 A, y0 T. M+ ~" ^71
72
3 v8 a- @  d' F- f73
% N# t! h, z% S3 [6 x* \! H插入排序
简单解释：
; |$ [2 q( r2 q( n. h2 \6 u最简单的理解就是打地主时我们拿到牌后的整理过程，从第二个牌（假设我们拿起来这个牌开始比较）开始，（说下升序）从后往前比较如果比前面的那个牌小，就把牌往后移动，直到找到一个合适的位置（这个位置的前面的那个牌不比这个要放下的牌大）就把这个牌放到这个位置，慢慢的前面的部分变得有序，直至全部有序即可。
9 W9 J' O$ x/ k. X
$ K2 W, S3 l( ~




" O1 _- D$ J. @& n% C! F完整代码：
& s! T# J/ p1 H8 k- Q
( K- l1 [2 l$ a6 W6 ?
# c4 |4 L% ~; t% U' u" W, Dpackage com.keafmd.Sequence;

8 J6 [& l" m' r
/**
7 s9 {/ ]8 ?& r( e7 m * Keafmd
+ Z' {5 }* P* e4 \! f) v  t6 P, t *
* @ClassName: StraghtInsertSort
) y! Q6 g& {! i, I1 G/ `& E( M& q * @Description: 插入排序
2 X! J7 G' k  G+ U3 @5 P * @author: 牛哄哄的柯南
* @date: 2021-06-24 10:36
& w, C8 c' d: L5 E& O3 R */
; T  a- z2 L! a9 R$ B3 ipublic class StraghtInsertSort {
    //插入排序
    public static void straghtInsertSort(int[] arr) {
3 F0 a, Y) ?* t; x        straghtInsertSort(arr, true);//默认进行升序
    }

8 C6 L2 q9 T3 A' d
) l2 t* O' I2 @, ^) w0 i+ S    public static void straghtInsertSort(int[] arr, boolean ascending) {

+ d9 S; k) B/ t3 r  C  k8 K
        for (int i = 1; i < arr.length; i++) {
            int temp = arr;
9 c, U! V* [" D- `6 e            int j=0; //这就是那个合适的位置
            for (j = i - 1; j >= 0 && (ascending ? temp < arr[j] : temp > arr[j]); j--) {
                arr[j + 1] = arr[j];
. g5 P( d; l, J7 n( \; L7 s            }
$ r8 T: u2 f  M1 `& V0 F            //把牌放下，为啥是j+1，
            //是因为上面的循环遍历到不符合情况的时候 j是合适的位置的前面的那个数的位置
            //有点拗口，但是就是这个意思，看图方便理解下
& V5 m. I& x4 v* J+ |            arr[j + 1] = temp;

9 [1 B# }. X$ {) `) B6 {- A4 h2 X; p


        }

) d6 j% v+ d6 ~2 @# D9 R
    }
$ u& n' K8 L' z# H. K}
1
2
1 x% }6 o7 g" [8 C8 D( V3
4
5
6
7
  m' _+ P5 _; h2 h) }" x8
9
5 y# e$ ?- C0 R5 K+ b. u+ l10
  P0 F4 C2 ?' F) `2 y9 \' u11
- G* }4 d- L/ i0 \12
13
14
6 s" \6 W" v$ a: ]# M# B! Y15
16
17
18
4 F6 a" ?( I& U3 r! L- ^% F# U, T19
20
: Y& H$ p; g3 m% v# k) H21
22
23
/ n5 V+ L+ Q9 X" o7 j& H24
1 t. y6 B/ n& D& ]0 \0 U/ l+ A25
3 _+ J# \; ]% T! Q7 P1 Z# j26
& D3 x' O& y' S1 M27
) Y3 ~, h* b8 j/ b& z3 D& K- `28
  r4 y; k: z7 B' ]* z, |& P1 W29
30
4 S/ G/ a9 D; O) ^31
32
$ F3 e: S# K* z( q33
3 u3 K8 d* i0 [1 m) {% s5 z34
7 d; W. s  L8 I0 @3 e/ J希尔排序
, X3 K* A6 j, A. C. Y简单解释：
% o1 C  u; o# N# c希尔排序是插入排序的改进版，我们理解一个叫做下标差的的东西，也就是下面那个图中的增量d，初始下标差为arr.length/2，然后继续/2，对在同一下标差（相当于把这几个数单独拿出来了）的若干个数进行插入排序即可。


# x; ^; ?' U1 c# h* P

6 m2 \  |# G3 ]1 W* }: |' ]0 e: @

完整代码：

& A6 G% }9 N* a6 b
package com.keafmd.Sequence;
7 I9 q# b8 m7 U2 t( P2 l- `
+ n2 o, w$ d: @( l! u" I
1 ^; ^. l- n. c/ `+ a2 A$ M2 o% d/**
, d3 c% L% F: Y * Keafmd
*
* @ClassName: ShellSort
# g+ p6 x5 |, [" \) k3 w9 u * @Description: 希尔排序
* @author: 牛哄哄的柯南
* @date: 2021-06-24 10:39
*/
public class ShellSort {


  [+ J! M. ^  X7 R5 B3 o    public static void shellSort(int[] arr) {
% R5 N% Z/ R6 t  A6 y9 Y/ ]4 Y        shellSort(arr,true);
    }

7 Q' e$ Q8 w0 @! d4 H' O) d7 [
6 m% F) ?/ y8 L6 k; K! u    public static void shellSort(int[] arr,boolean ascending) {

- K) ]1 {5 P8 v& O2 Q
        for(int d = arr.length/2;d>0;d/=2){

& Q2 o% y) E& X
. v" m0 U! `# u1 @            for(int i=d;i< arr.length;i++){
                int temp = arr;
                int j=0;
* F0 e( c; W4 q                for(j=i-d;j>=0&&(ascending?temp<arr[j]:temp>arr[j]);j-=d){
5 `" i( V4 R% k$ o' f) `5 L5 _                    arr[j+d]=arr[j];
                }
/ r+ ~+ V, a. f$ h/ _' g                arr[j+d] = temp;
8 [9 p; B) |2 y- d. [2 T            }
        }


    }
7 E! a9 r* D5 D& u' @0 i" Y}
# p+ J" @: `5 G3 |1
, P$ o4 F6 w1 ^7 a2
3
4
5
6
7
* b/ M0 W) r6 L2 ~" ]7 R8
9
10
11
12
" g% B8 d  z5 D$ `( g7 C13
14
15
16
17
* K# T5 y$ `6 k' E4 @! ~1 v! W18
& ?9 ~7 Q! a$ a* N7 J- \' E19
2 b- r0 I, S; f5 O  O$ Q20
: P, }% P% C0 S( _9 H3 ]21
; j4 j2 F' O/ y, z  O! Z22
23
24
25
: h& |$ v3 [0 E26
& _, q% s! O/ ?, g0 T27
# M2 v5 q; i( R0 y0 y. A28
, M* O5 o) Y  V29
30
9 `) `$ L& |$ H6 Y0 U9 C31
32
计数排序
" G, c. r) r+ ]6 _简单解释：
这个排序算法看名字也很好理解，就是就是额外找个数组来计数，然后在这个数组从小到大或从大到小把数取出来即可。
3 i6 E/ S% u  i3 Z% N7 ~. y: x/ S

1 X+ f! G# u2 [9 j( ]) o8 |3 j


+ {0 |8 h# F& t
. u7 }: L- F0 v/ {# `完整代码：


- G- k% o2 ?2 y9 d6 fpackage com.keafmd.Sequence;

& M+ z$ G8 F# z+ l' u
/**
1 h/ V. ~7 i) t. |+ E  r. U * Keafmd
3 k/ m8 N2 ^8 m8 S  t) Z *
* @ClassName: CountSort
  H- \7 t+ C+ ^& ]: s- A0 k& z8 [ * @Description: 计数排序
( S( g! O$ C1 {' y * @author: 牛哄哄的柯南
* @date: 2021-06-24 11:31
( D9 Q  `, f1 |4 W( z& [2 e */
) |4 e* t! S0 R5 _$ O' [0 zpublic class CountSort {

& v; L) B( u- @  C
' B8 ]8 C& k; k0 w    public static void countSort(int[]arr){
        countSort(arr,true);
# E% M: O$ j4 k5 t    }
3 R9 q! Q' e3 I
6 \* F6 Z* S! s6 z; _' @
* [# L- F" W7 `! L1 [9 o    public static void countSort(int[]arr,boolean ascending){
        int d,min=arr[0],max=arr[0];


        //找出最大、最小值
1 _+ d6 L+ p; w+ g0 |( h* a+ m        for(int i=0;i< arr.length;i++){
$ T; P+ d" g( L3 z2 l( U# p            if(arr<min){
9 E+ }4 d* h) Y0 S" l: U& H( [                min =arr;
            }
            if(arr>max){
% A& ?4 |* I# o  ~( }                max = arr;
/ d/ U# t9 r7 f4 x* q) `$ g            }
+ }" F5 q3 P) @9 o4 Y+ c        }

7 I% Q( c- ~, R- K+ v, |5 C
" o  m7 J1 g9 R9 i8 o        //建立一个用于计数的数组
        d = min;
        int[] count_map = new int[max-min+1];
        for(int i=0;i< arr.length;i++){
            count_map[arr-d]++;
( }1 P4 A& Q7 I/ W1 ]9 O        }
7 c8 n. ~2 H" q9 J
0 R. F! X7 K$ @, m1 H7 g; ^5 J5 f
6 `3 O! t. ]+ c, g. \8 W7 s        int k =0;
$ ]; H! y6 L0 p* o) v& G        if(ascending){
8 O7 c# j8 E" K2 d# ~, @' s            for(int i=0;i< arr.length;){
# l0 |7 E% G; A3 X0 j                if(count_map[k]>0){
, b6 e8 a3 T3 m  C2 ]6 `                    arr = k+d;
                    i++;
" Y7 n; L4 w& ]6 y                    count_map[k]--;
                }else
                    k++;
9 T! D: N3 [8 ]$ c: C% K            }
        }else {
& E+ n  L2 W/ {+ p0 @- E            for(int i=arr.length-1;i>=0;){
, ^9 H$ ^  @' c8 E: v                if(count_map[k]>0){
6 w* D+ u' O0 E* S4 R0 z                    arr = k+d;
0 U  t8 D5 T7 h7 s                    i--;
- Z, G; d3 {4 n( K                    count_map[k]--;
                }else
$ j. e8 X8 K) K                    k++;
            }
        }


    }
- C- M! T5 Q/ N% `+ f+ X: E}
1
2
  A- c( D9 h5 S, y) S/ M2 U3
4
5
3 h; ~  t$ s* j7 s! t& ~2 E% u1 u6
7
/ y9 J7 ]. s9 @" z8
. c9 X& ^/ t  M5 v) G9
10
11
- o2 n% I5 F2 H: a# ^% }12
13
4 A! u5 C+ Q/ D( G9 M) ~( a( m14
1 {- s) V4 R# I4 e! B- U  }: ~/ M15
% R/ h1 h2 @" K5 ~* B16
8 L" Z- n: y0 r, X8 l+ _17
) ~* a; N" w. \9 w6 U7 s18
1 _4 g' S4 ?" V2 h+ A$ H: A5 y19
5 N" M; x  @( ]20
21
8 k8 r; c$ L( A& d22
4 B; Q: K- q" s- m23
24
! Q2 J& Y4 H5 k# u25
- C# Q) Z9 [" n! }2 n: k26
3 U* c" ~7 }' a5 H( [27
28
29
30
31
' n2 n1 X7 \" e" @32
! t& ^- D/ ~1 l. Q6 x$ k4 H33
34
35
36
$ f( i. C) D% o; A7 c37
38
+ y4 B, q8 ^5 x  q8 u39
40
' w, K. [& v9 o/ _+ {: U41
42
) d" D/ G8 b4 ]) o% n43
& D0 I" l& u% }( t- m44
45
. N% [- ?( O1 t5 m* N# W$ J46
% Q* U6 |% g8 m, o5 d47
48
& E2 A$ w2 Y/ E! u: e49
& d. ?/ ~) h! a* p7 t$ ^& o  A50
! g( G) R& c! ^; U, H$ s51
/ s/ q9 o2 [5 y0 o52
53
54
, g- w6 `3 e9 x55
& X5 \( V0 m1 T: }/ j) h7 h% y56
. X- ?8 O: b. r* s( ~5 E  r57
' U# H; B+ f' k3 H) m% g$ a% r58
7 e3 J3 B+ A( S3 q2 B+ s' O59
4 F5 k' Y4 P" ]& B. l6 U# r# @) W桶排序
简单解释：
就是把一个数组分成几个桶（其实是几个区间，从小到大或从大到小的几个区间）装，然后让每个桶（区间）有序，然后取出来放一起就可以了，相当于把几个有序的段拿出来放一起，自然还是有序的，当然需要是按照区间的顺序拿了。
* g9 Z0 @8 Y; a
; p" u$ A* u7 O! `" s
$ U, f4 S" p- f7 g: c! Z


1 m. H9 e; {5 E# @
完整代码：
) G2 O9 y7 Y6 Y1 W5 K/ ~
1 k5 n# p' b3 F2 @1 \* u7 r9 F
package com.keafmd.Sequence;

; x- B  b# w" H4 u
import java.util.ArrayList;
1 A* [! x2 F. T( H- I1 R# T1 T& Bimport java.util.Collections;
& ~+ q/ k$ _" P; r4 R# I
! r7 M/ H4 B+ e% O4 }; t! x' o
2 h9 t- {8 w' Q8 x- q' o/**
) k9 n; {) ~; P8 b( ]$ o * Keafmd
*
% ^; U3 B, r0 E: o) S" I  I4 F9 q * @ClassName: BucketSort
* @Description: 桶排序
# S6 ?! T6 g2 R% A5 X1 ]" E * @author: 牛哄哄的柯南
) h" P- [% Q1 W- r$ t * @date: 2021-06-24 13:32
! m4 V$ Z* O; H */
public class BucketSort {
5 |" p4 F, l1 M; ^

2 e# \% }1 O2 p5 Z9 Q+ j    public static void bucketSort(int[] arr){
8 B8 N5 s! a7 b$ y; Q; f- [) z* g        bucketSort(arr,true);
    }

; i& \7 v2 o$ e& `0 [* Y* T8 t4 n
% @& f& {& O0 J; @5 r  w5 G( y    public static void bucketSort(int[] arr,boolean ascending){
% P# q1 `( r* ?        if(arr==null||arr.length==0){
& A2 K' D* \3 Q9 ?5 T            return;
        }
        //计算最大值与最小值
; U7 k- R% ^: r* K        int max = Integer.MIN_VALUE;
' O, Z6 c6 i9 E1 @$ S! U4 J( A        int min = Integer.MAX_VALUE;
! {" q) B3 ^! f        for(int i=0;i<arr.length;i++){
. g& J0 S" E/ I& h; ^            max = Math.max(arr,max);
1 G0 D0 t! F- Y  a! i            min = Math.min(arr,min);
        }

& L  e) [" ]& Q5 J! y
9 Y$ ~4 \0 S  ]/ f/ I" m        //计算桶的数量
7 f5 C1 L5 x$ |( A2 {7 J) i        int bucketNUm = (max-min)/ arr.length+1;
: r8 }8 c2 K  ?( o        ArrayList<ArrayList<Integer>> bucketArr = new ArrayList<>(bucketNUm);
* H, C. B; z7 W$ {/ Q+ x        for(int i=0;i<bucketNUm;i++){
            bucketArr.add(new ArrayList<>());
5 s% N0 T' L; h# M% t: D8 w; J        }

$ t" g; w/ [0 X2 Z6 E3 s- h
        //将每个元素放入桶中
: N( p. y4 e' B* }4 e        for(int i=0;i<arr.length;i++){
* Z' `  @9 ~' z4 m: o5 C            int num = (arr-min)/ (arr.length);
            bucketArr.get(num).add(arr);
; C1 k  N( m- y0 w6 v9 L) p: v- R        }

5 p# M4 ?( K! z9 B5 ^" \$ v; z
        //对每个桶进行排序
        for (int i = 0; i < bucketArr.size(); i++) {
            //用系统的排序，速度肯定没话说
            Collections.sort(bucketArr.get(i));
! F% j$ m. Z$ }' o2 `, {: g3 u* v        }

# q$ s6 t2 r" \
        //将桶中元素赋值到原序列
        int index;
        if(ascending){
            index=0;
4 S: {! O* M8 f% [2 [        }else{
7 z2 t4 ~# X' X- R0 k7 P, F1 r2 X            index=arr.length-1;
        }
0 i4 e; v2 s' ~* l2 V2 g% X3 U4 r

, j9 q$ M/ p6 @% v+ F: F( S' A  x2 G        for(int i=0;i<bucketArr.size();i++){
- A; m4 c6 Y8 w: E% G) G/ Z0 H0 x$ x            for(int j= 0;j<bucketArr.get(i).size();j++){
+ Y! k! ^) r. g( b                arr[index] = bucketArr.get(i).get(j);
                if(ascending){
, y# Q8 }+ ~- L8 i: K! s' F3 a                    index++;
5 z' _: X8 [* b                }else{
                    index--;
0 V0 }0 q; c  }+ D                }
! o' k5 x( Z6 S* |& w* ]: u( b            }
+ R! Q! h% z& v! h; G  ^8 s# P

        }

4 q7 D, ^' Y8 T% s
    }
4 |' l7 Z) q0 G}
! J  f; O7 r5 V& ]: x( U  D3 {1
2
3
4
/ ?% w) p; a! _$ F+ U0 U5
) z- P" y' g* i( S  i8 O: i6
$ D- O9 O4 ?( ~  |: }; F7
8
9
. S& ?, C1 x7 k/ f2 k3 O, M# ^10
11
12
13
14
: d5 h, Y3 y( M3 O: x+ Y; I, z) F15
16
' t+ M& j9 j/ M# P17
3 b: j/ P1 `8 {! u9 I18
19
: m+ P; J5 G" ^" q, _- E5 b- h20
+ V& v" Y  M2 Q  D- k21
22
) m/ o2 t: O3 ?* U) B23
" r0 p. E0 O6 [& m24
* q4 ^* D: z" K% w$ o+ |$ r4 O: a8 {25
26
27
28
2 F/ t3 Q1 w/ O9 g( J: A29
. L5 _5 x" {% c) ^4 f' a' S2 y30
31
32
33
/ o1 m3 }( b7 J$ w3 e* X34
2 f% \2 z0 z- s  \: h6 }35
36
37
38
39
! {5 e5 m. ]3 X; r+ l40
41
$ G) Z5 ?0 e" o) B6 B' ^1 z3 S2 D4 C42
43
! y* Y! h* R: S: W44
: G. n+ z8 `8 s1 g6 }9 m$ d45
; o: }6 Z0 I& _1 n2 C" d7 R0 s& M46
' g  Q  r- t# y# s. E0 \0 Q7 f47
' u1 U6 Z: z3 c- ]! ]48
49
50
) T4 W0 r  \/ p( ^: n2 d! Q% W/ b0 {51
52
; `- _8 J/ ?& g  {53
8 R8 |' ]- s9 Z' U! y54
55
0 Y# h) r& s) v  o# k/ r3 U( J: d56
1 T5 h: g( k7 l57
7 V3 H8 H6 u/ E- P5 Y( K# N58
" C3 F( ^3 {) U6 E! r59
60
61
62
% m1 N4 O; K% I2 w1 ^3 {63
8 s6 Q0 b& H+ l3 `3 T64
! u2 N5 I/ Q/ o: T6 I65
6 @* a! p; z5 ?' Y# i% R66
67
68
69
70
* V3 f* h5 [8 F; u- ]9 D6 D7 r71
72
8 u$ u+ m( V, T基数排序
简单解释：
首先说一下，我发现好多人写的基数排序只能排序正整数，其实只要处理下就可以排序含有负数的了，就是我们排序前先把所有的数整体变大（就是减上最小的负数，也就是加了），都变成正数，然后排序好之后，在减下来（加上最小的负数，也就减了）就好了。
基数排序就是按数位排序可分为LSD（从最低位[也就是个位]开始排序）和MSD（从最高位开始排序），下面写的事LSD基数排序。
7 }2 E; b8 S* v+ t5 r/ L基数排序就是把数按位考虑，让后我们一位数只能是[0，9]，就是我们在考虑某位（个位、百位· · ·）的时候就只看这个位的数，放到在[0，9]相应的位置，然后顺序取出，最后再按其它位这样操作（上面说了要不从低位开始到高位，要不就是从高位到低位）

5 W9 ^9 e2 P! K- B3 o
3 H$ _5 ?5 v! ~1 |. c& [2 Q  j
- G# h1 g& y3 s6 g3 p

& M* T& j; f( `) N2 B
完整代码：

' A. }, d9 @% X8 |+ w  a3 R: e$ H4 N6 _
2 B3 S. E! Q  q6 B0 C" Ypackage com.keafmd.Sequence;

$ c5 r5 o: f) Z6 F0 d
/**
& A1 o/ r' U  _ * Keafmd
*
* @ClassName: RadixSort
- x" ~+ I5 x& h# a * @Description: 基数排序
" x" F# ?8 F, V: r0 S1 ? * @author: 牛哄哄的柯南
* @date: 2021-06-24 14:32
' a8 |5 D; D/ A- [3 e. q  A  X */
public class RadixSort {
, Q( n/ R; U, N5 K" m; |( L4 f. U    public static void radixSort(int[] arr){
( D' w/ A( t9 t, [+ c, H& U$ |        radixSort(arr,true);
! `- q( g7 P+ o% F- a% x    }
    public static void radixSort(int[]arr,boolean ascending){
- Z6 d. ?# _8 F1 m9 s' j        int max = Integer.MIN_VALUE;
        int min = Integer.MAX_VALUE;
        //求出最大值、最小值
        for (int i = 0; i < arr.length; i++) {
            max = Math.max(max, arr);
            min = Math.min(min, arr);
        }
        if (min<0) {        //如果最小值小于0，那么把每个数都减去最小值，这样可以保证最小的数是0
            for (int i = 0; i < arr.length; i++) {
                arr -= min;
5 j( c+ {) V; f            }
            max -= min; //max也要处理！
8 a' d% F/ {( ~! [& k        }
6 E8 _9 h0 h( i! j+ W0 I        //很巧妙求出最大的数有多少位
        int maxLength = (max+"").length();
' K: F6 s1 B7 c$ w3 s4 b        int[][] bucket = new int[10][arr.length]; //一个二维数组，一维代表0到9，二维存放符合数
        int[] bucketElementCount = new int[10]; // 用于记录0到9某位存在数字的个数
9 d" }  `# S/ D' L7 D5 c        for (int i = 0 ,n = 1 ; i < maxLength ; i++,n*=10) { //个位 十位 百位 这样遍历
            for (int j = 0; j < arr.length ; j++) {
8 A1 E7 v' K# b( K                int value = arr[j]/n % 10;
' F) L+ z1 r. z" ]0 l; a) r                bucket[value][bucketElementCount[value]] = arr[j];
                bucketElementCount[value]++;
7 i$ ]9 r7 ]( i            }


            //升序
            if(ascending) {
; o) D2 h" a. n& b& Z1 p5 c, _                int index = 0;
                //从左到右，从下到上取出每个数
# P! g$ c/ P! R9 j8 F6 z" C! g                for (int j = 0; j < bucketElementCount.length; j++) {
3 }9 v2 f1 G9 f8 O# }0 \                    if (bucketElementCount[j] != 0) {
                        for (int k = 0; k < bucketElementCount[j]; k++) {
                            arr[index] = bucket[j][k];
2 r; h: j5 v" S" t* ?6 s0 }9 u                            index++;
                        }
4 N% ]) f6 v) t1 ~                    }
                    bucketElementCount[j] = 0;
3 b0 C; S" J. M. d                }
4 m4 {' ?# @) `/ h) e            }else { // 降序
                int index=0;
                //从右到左，从下到上取出每个数
) w: F, S; u  Q                for (int j = bucketElementCount.length-1; j >=0; j--) {
2 a( A$ g. T  `1 S                    if (bucketElementCount[j] != 0) {
                        for (int k = 0; k <bucketElementCount[j]; k++) {
                            arr[index] = bucket[j][k];
" i& E4 \2 o# P7 u- i                            index++;
$ b1 ~8 d/ e& d                        }
, ^5 n! v" d+ C* @. k) s, @                    }
                    bucketElementCount[j] = 0;
7 {/ Y$ H. ^4 k1 h; ?                }
9 B- C1 Q5 b1 {* ^5 Q5 i. s7 ~            }
% m9 t$ e8 U, m


, ^9 I" Z+ t) P) W! @
            /*for (int i1 = 0; i1 < arr.length; i1++) {
                System.out.print(arr[i1]+" ");
            }
            System.out.println();*/


+ E: k' E4 j4 |
) G8 t0 u" z0 `2 ]* V( g9 d, K


2 X% _- Q3 h+ w* f7 k        }
        if (min<0){
$ K" q( L' f( q* O0 r- ?8 X            for (int i = 0; i < arr.length ; i++) {
                arr += min;
            }
        }

6 q, v, _% \7 W$ E
: @4 u6 i8 ^% o9 s    }
}
. r0 y- i4 E4 E) ^1 r8 n1
2
3
4
5
+ B$ t8 R/ H( E% b7 f0 {6
7
8
9
10
0 Y# Y+ l9 C( c% P11
12
13
14
15
16
17
. D( v; W: C2 I3 m18
5 N# I" Y! Y7 E9 ?9 j19
20
  J: j& Z0 x1 N  q  f) P7 t/ e$ l21
: \7 J6 e+ U; ~9 H  h3 M4 @22
* k# N+ c" C2 _4 v- ?6 ^23
6 Q% ~; e- q8 D0 K. ^% p24
25
1 S5 p, ^! A) v& \- o, d26
27
+ R7 f9 F' C- V( Y& z28
29
30
/ z: }  f8 I/ _& y+ J4 P31
32
33
) l% Z" R# P6 m' ?7 m2 t; \34
35
/ @  N+ L! ^5 _2 S36
* K" O' A0 |# `37
38
& F6 B# T& N4 l39
' K; a/ V' `( H3 ~4 c40
41
; \5 }( i* R+ ~5 ?, y) \# T42
43
44
7 d/ G7 [& p/ F# k  O45
) ?5 x/ b$ W! f3 x7 O) N4 `46
) b& @* L% [$ p9 Y47
: |# k* Q" }+ @# R; q48
6 M2 g! x1 v: W# U49
! ^" F7 r2 Q( }50
51
: g  N8 U5 q: x52
2 R# b# L- r% W$ g1 N53
54
55
" i% d7 J4 `  ?1 \56
57
58
7 }" t! D. V' y: M59
60
61
62
63
64
7 a6 V6 w/ G3 ?( G65
66
67
68
69
70
7 q- E5 `# W! t0 r! Q! z/ Y6 J71
. d0 K. D) h& n- t  `72
73
74
: }+ C( R9 k7 Y. W) a75
76
77
6 h( y/ G1 M7 {8 c. E/ l& f: J8 M78
79
1 L, s) m& y/ @! \/ b# E' R' S) _" d80
% j3 ]. X" z8 V( \81
4 h  `  W! }! y' Y! u82
. s3 E2 @, z, `  U$ q* v83
% z7 D" g- h2 d5 g3 p完整测试类
package com.keafmd.Sequence;


import java.util.*;
import java.util.stream.IntStream;
0 ~5 c# l: j2 x+ i! Yimport java.util.stream.Stream;
5 H" e3 o8 q4 K( I9 U# ?

' \5 `$ T$ V3 F& t4 }$ m/**
* Keafmd
*
' I( _' u" g5 F, s! Y' o * @ClassName: Sort
$ E: w, [& e7 v2 c- B3 h& @( p! N * @Description: 十大排序算法测试类
0 S# Q3 |: z$ w1 z9 y+ k5 W * @author: 牛哄哄的柯南
6 w- F/ U. Z- y8 D2 `- b5 e * @date: 2021-06-16 21:27
*/
( Z7 \$ O& q7 T) A$ gpublic class Sort {
( n) v3 T+ q! I9 u7 y( W

! y$ L5 _3 s0 H! C) U1 z. u1 Q& h
! T/ J- L8 z! G( d% l
% o) K' L5 }* N9 d% u! O- F9 I9 ~    public static void main(String[] args) {


# K  n, Q+ _) q        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};
+ `+ g) p# [" c  F4 [3 z5 A9 _( @        int[] temparr;

5 G' r1 [' B/ X
        //利用系统Collections.sort方法进行对比

: |6 Q5 b' i. V4 F
* e$ k  C" J: r; H        //将int数组转换为Integer数组
        //1、先将int数组转换为数值流
        temparr = nums.clone();
        IntStream stream = Arrays.stream(temparr);
        //2、流中的元素全部装箱，转换为流 ---->int转为Integer
3 c3 w% }4 C8 a) [        Stream<Integer> integerStream = stream.boxed();
0 s  K6 ], q5 r9 `* W        //3、将流转换为数组
        Integer[] integers = integerStream.toArray(Integer[]::new);
        //把数组转为List
8 t8 {8 P& P7 A0 I        List<Integer> tempList = new ArrayList<>(Arrays.asList(integers));
. G$ i" P% L" k1 W        //使用Collections.sort()排序
        System.out.println("使用系统的Collections.sort()的对比:");
0 f7 W- A1 u. q5 u
# h! I9 W' A3 w0 }" ^; I
        //Collections.sort
# @2 D& m' o* ]1 X2 e! D) K. y        Collections.sort(tempList, new Comparator<Integer>() {
            @Override
            public int compare(Integer o1, Integer o2) {
                return o1-o2;
                //return o2-o1;
: ]' [; ]7 e% x2 `# {: a            }
        });


# Q5 p3 l, r. d0 F  w/ E        //tempList.sort 也可以排序
       /* tempList.sort(new Comparator<Integer>() {
            @Override
2 t' Q9 T" H, K3 E: p            public int compare(Integer o1, Integer o2) {
: r1 `5 ~  @3 {                //return o1-o2;
  h8 r" e4 e, w) D/ b. c' C- t/ e9 i) H                return o2-o1;
2 K/ u9 Q' b" c& a            }
        });*/

8 f# \8 L$ W/ k6 Y( ~! J
        //遍历输出结果
- W  c5 C3 `) J. n6 q9 {        for (Integer integer : tempList) {
, ]# o2 `0 d" E1 `9 p" k& U            System.out.print(integer+" ");
9 P* A# F, p( H/ z        }
( z9 ?( A& r( m  q& U+ h6 G/ c
- ?  r8 i, D' v3 S3 ]
        System.out.println();


        //测试冒泡排序
+ N. z6 e" V8 t, C* y! l3 T        System.out.println("测试冒泡排序:");
        temparr = nums.clone();
; G/ Z8 {) {- b1 k& K% T* }1 y

+ L) Y6 c0 ~) C/ y% a) M        BubbleSort.bubbleSort(temparr);
2 a& m" W0 j! r, c+ X1 x* r: D

3 J; q6 K6 R4 s; ^        //降序
7 O! G' \/ r. G- d        //BubbleSort.bubbleSort(temparr,false);
; U4 h) O$ o" ^8 o  D# V! k
) l8 y* n1 ]2 }3 t$ y+ }, A9 r
( ]% Q, O9 H8 l1 s        for (int i = 0; i < temparr.length; i++) {
            System.out.print(temparr + " ");
        }
/ h" q" W2 c" [        System.out.println();
5 q/ Q( b( I9 `5 L3 f2 v' k

        //测试快速排序
; k  a* ]8 b0 k+ n: L3 Z        System.out.println("测试快速排序:");
8 b% n2 ^4 M& l! Z0 S! b        temparr = nums.clone();
        QuickSort.quickSort(temparr);
% j! M. c5 }$ Y  w& [        //QuickSort.quickSort(temparr,false);
        for (int i = 0; i < temparr.length; i++) {
# Q4 X& |4 i  V$ s2 S4 K# P% `            System.out.print(temparr + " ");
        }
        System.out.println();

+ ?) e$ G: k  p
- z& [0 T8 Z% |        //测试直接选择排序
5 H" b5 J: K2 p+ ?) ~* ?        System.out.println("测试直接选择排序:");
' o8 J- X2 W! O- U# V        temparr = nums.clone();
, \2 ^% M0 z) e3 l+ ?) v' `, W        SelectSort.selectSort(temparr);
" _# m( p# m: [3 i  K* |        //SelectSort.selectSort(temparr,false);
        for (int i = 0; i < temparr.length; i++) {
4 \; Q2 o. R3 e- l. p            System.out.print(temparr + " ");
        }
$ L5 Y9 ?9 c' y+ W        System.out.println();
/ `# _6 M4 G; Q, u: _; o$ Y

        //测试堆排序
        System.out.println("测试堆排序:");
        temparr = nums.clone();
4 @- l/ r) e% v8 e        HeapSort.heapSort(temparr);
9 m( ^0 m/ l7 J' T  ]1 ~        //HeapSort.heapSort(temparr,false);
( d5 y0 X0 ?4 g        for (int i = 0; i < temparr.length; i++) {
8 a5 Z/ m; g/ n) ^            System.out.print(temparr + " ");
, o/ r8 w/ E. P2 N0 t% y* w3 J1 U  ?        }
) x5 k3 C. f2 d; v4 u6 [        System.out.println();


        //测试归并排序
+ z* A* J8 m6 A9 h        System.out.println("测试归并排序:");
        temparr = nums.clone();
3 B, ~, m% a- N4 ^4 a  ^        MergeSort.mergeSort(temparr);
0 S1 u9 @9 F- g2 _. f1 x        //MergeSort.mergeSort(temparr,false);
        for (int i = 0; i < temparr.length; i++) {
            System.out.print(temparr + " ");
, p( Z- G( D  ~4 j$ f! r        }
        System.out.println();

  h& ?2 ?+ K4 }; ~8 s- m+ H
" D7 g+ l: k; F4 z6 v        //测试插入排序
9 N5 Y% `2 M9 x. I        System.out.println("测试插入排序:");
        temparr = nums.clone();
5 H* k! Y0 f( v        StraghtInsertSort.straghtInsertSort(temparr);
$ G7 _/ J8 t) S( U        //StraghtInsertSort.straghtInsertSort(temparr,false);
        for (int i = 0; i < temparr.length; i++) {
  I5 R% M. I+ E% n3 M" E2 a; j            System.out.print(temparr + " ");
        }
        System.out.println();

4 o/ X# t" r' t! ~9 B  i, p


- B1 H" K4 @1 x& M        //测试希尔排序
+ `0 J  b  ]8 L& |" i5 P5 X, r        System.out.println("测试希尔排序:");
        temparr = nums.clone();
* d+ X5 c% P, r! L' ]        ShellSort.shellSort(temparr);
  r3 T3 r- q" g& G$ s1 {1 w        //ShellSort.shellSort(temparr,false);
        for (int i = 0; i < temparr.length; i++) {
            System.out.print(temparr + " ");
        }
        System.out.println();
. h% f% f5 R3 @; H9 @
0 q7 E, {, b% w  G& D" S
: c6 l" s* A: h5 o9 E# Y
4 Q3 J" }/ r# U; ~7 I' y7 D1 D
        //测试计数排序
" u: S5 A: l. Z) F        System.out.println("测试计数排序:");
/ |( @" }5 ]; e* u        temparr = nums.clone();
        CountSort.countSort(temparr);
  P/ b4 Q5 B+ T. i        //CountSort.countSort(temparr,false);
( x! |6 j; f/ q        for (int i = 0; i < temparr.length; i++) {
% Z( M7 B0 R3 l( z( J/ @            System.out.print(temparr + " ");
0 u' ]/ [/ s3 o6 n% X        }
        System.out.println();
1 z1 s. X; I' X0 z" J+ Y' {' y0 o

. @/ U- L( t" Z7 Z1 S5 q& C* R; X

+ @  |8 a1 s. @6 U7 ^8 }$ @        //测试桶排序
        System.out.println("测试桶排序:");
) h! a4 p2 T6 b1 K( Q        temparr = nums.clone();
        BucketSort.bucketSort(temparr);
( M8 j# ~/ b8 g5 n% k        //BucketSort.bucketSort(temparr,false);
/ K1 Y/ y: A! k7 g& k        for (int i = 0; i < temparr.length; i++) {
            System.out.print(temparr + " ");
# o( ^! w3 l0 ?# h4 Q        }
$ o* J* \3 \3 {) N        System.out.println();

. y: l  X, @* W% t2 Z% B6 @& |: Y
% e1 K9 z6 x) ?# A5 Z3 f0 h( P$ a        //测试基数排序
2 t7 ]& E) \# |        System.out.println("测试基数排序:");
        temparr = nums.clone();
  E" Z8 y5 F7 X' z0 Y9 \        RadixSort.radixSort(temparr);
        //RadixSort.radixSort(temparr,false);
        for (int i = 0; i < temparr.length; i++) {
            System.out.print(temparr + " ");
8 Z9 p; f7 E" A3 u3 o        }
        System.out.println();


! C- X" g4 c: W* \, ^' ?, ?% _& w    }
; Y% Y3 T* _) P4 Y

1 m, }  j& z1 ^7 P6 x& r}
1
2
! c$ O0 J- V& M' K' T; g3
$ L9 P/ B! ?5 Z8 K# h4
0 n* `8 a6 d/ U/ a5
) q9 ~5 D, ^* z6 m# f6
7
8
9
10
11
12
4 e2 c, w! C( J  [" F" c13
14
2 a4 |! a6 g+ w: n$ {; L2 U- L15
6 B7 U; ?/ r" O7 [) _/ r16
% x9 V" @$ {: q7 x$ }1 t8 J17
18
19
20
21
+ B9 _) G" ]0 q! o" N4 n22
23
24
1 X7 u( A- i! s25
2 _  z! I9 i* o26
* _, i+ s6 s5 i6 @. c27
28
29
0 Y0 H' y' e5 l2 [1 k% E+ M- _) f30
3 p2 A! i# w/ U5 L1 M6 c' a9 G31
32
$ q5 O0 v5 T5 Q+ [6 r" B! y8 ~33
) W+ j( A; P; H( V4 e5 o& h$ Z34
35
36
0 x$ P6 V; D% B- X. [37
38
39
7 ]+ u) U3 W* n, o$ @40
$ E4 a- p$ R. I# [: v5 {41
6 E, h' u  @1 I. M8 v+ O42
43
44
: {. ?7 C0 d; x; X45
46
47
2 t8 Z; W& s9 |48
# g7 F5 q2 Z0 z0 C3 p! D" E5 q* s49
50
51
52
53
" m4 N" v5 Z( A6 m' y54
55
56
3 B9 Y2 H) M9 ~9 W57
58
59
5 g( S$ q/ q, J) V+ j2 b60
61
. l+ }# o, M0 Y9 h( Q62
63
, F1 h9 k# p7 g% P64
$ `" t$ v( h, `0 C65
66
67
68
2 f+ P; b# G  ^/ F69
70
71
72
73
74
$ S7 t" S- Q. o. z9 e75
9 ]& _8 L" E& ?( @76
77
, |/ {* }# J# r: E6 t78
/ O* m( f3 w+ Z6 }5 y7 F79
80
81
82
83
84
0 L* N1 k+ s' Q, Y1 n/ t85
" X1 h& _- N9 I  ?4 T) A; t86
; n& d1 f, z& I. n; L87
$ q: |& R- T7 `8 J0 Y: \" h; G88
89
9 [1 N/ f3 T# c3 L90
% r- V; O- a( T' q91
92
93
94
95
96
) o1 {' |  O) c& d7 K% s97
0 g  j% Q. g/ I$ d' j8 w  k98
99
3 [' s& h! q$ R6 I+ M( p- ]  |( Q* \% E100
101
1 a6 {2 ~( x( M! s+ W102
; h% L, i: V" k9 M' o103
' N, ]5 Y- Q7 e' b& h1 w104
1 _4 R  e3 T$ v; m6 ~2 r: O3 O1 U' p105
106
107
108
/ O+ }2 x1 M4 W, s& D109
% X  p% |9 [0 N- c2 h5 Z110
0 Q$ c% T6 c0 s% P- K' ]6 q111
% q5 @7 {9 U. K- b( h& R112
113
114
115
116
117
' R& r) w9 p( Q0 b' j118
, u" z' N* L1 t- E1 U$ _/ R, _7 J, h) J119
; T' U: p8 m; Y9 n" s( e6 f120
121
122
4 ~. Z, _! ]+ e7 V5 P1 K' d123
124
125
& @6 q- x; @3 y$ x* E$ o126
6 u; W$ m1 \; `, j: a/ F127
128
129
130
131
132
133
  `9 k2 H( u+ d# L& d' l. w134
( F6 |7 }' a7 a135
136
137
) c" w; w# I" o. o) R138
7 ~: e1 z% J% ]139
140
) U- M$ m; v5 b+ Z2 Z, d) r141
142
143
144
0 v9 p" v- R1 Z5 F3 c145
146
147
6 V2 w4 L$ Z" ~  f148
149
150
151
9 Y; C' \( P" ^, C/ W2 N152
153
& Z$ d# h& Y" v154
5 f1 t1 t0 k8 h155
156
8 y( T5 B, B0 f* Q2 J" u157
4 h* Q  F: h3 }. f( Y158
0 x$ p8 m) y# u2 O, v; N159
* Y, q' {$ O1 {2 {1 F3 \160
: f( V( q" l8 J- p, B4 H% D  t161
$ p$ A& {, a/ G; e- Y162
. W6 m9 D% \& {163
! M! d9 {( a6 x5 V" t164
165
166
+ w: |4 x% {  a( v3 X& b+ E% F4 ^167
& M/ b' h3 B; _; Z168
169
+ c& Y4 S. `1 E; `; C( b7 u1 I( ~170
- @6 Y8 j. e! `  [) T, x7 k. g171
( I) V' H3 u0 W172
! D+ f( w' m: u$ C; `6 O- w3 T173
每天进步一点点！
- ^1 H0 T! s; A- o) X% C- S不进则退！
$ g$ x8 z7 Z2 L( x( Z2 X% b4 W/ b  S
' K7 n, Z3 j1 l- u9 B+ T
- r1 o6 @/ g! L版权声明：
& l* o4 ?0 W: o7 b原创博主：牛哄哄的柯南
博主原文链接：https://keafmd.blog.csdn.net/
————————————————
版权声明：本文为CSDN博主「牛哄哄的柯南」的原创文章，遵循CC 4.0 BY-SA版权协议，转载请附上原文出处链接及本声明。
原文链接：https://blog.csdn.net/weixin_43883917/article/details/118193663
- a6 m3 K# M; Q" H# n- x" @
; J( w- I7 i$ I/ ?% C7 L
6 v' P- T& d) d1 x" T( r+ {1 t  X, x

1051373629

每天进步一点点！