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

杨利霞

经典十大排序算法（含升序降序，基数排序含负数排序）【Java版完整代码】【建议收藏系列】
1 P7 A% O( e6 m6 f4 f; F经典十大排序算法【Java版完整代码】
写在前面的话
- Y5 F$ M9 `* L十大排序算法对比
冒泡排序
* z, B* M7 U- I! X快速排序
6 Q# D* l9 y$ ~4 t3 t直接选择排序
$ x* e9 p  c& k堆排序
5 k* B+ P' {, d- u4 E归并排序
% S% h' x4 j9 b/ R插入排序
* ^/ j+ h! k1 i) P希尔排序
计数排序
2 n# Q: w3 F$ a5 |  Y: S8 Z# x) x0 b桶排序
2 ?# u7 F) [( h0 v1 R& M基数排序
完整测试类
写在前面的话
6 C9 M. N$ i! T2 t9 ^+ _" Z$ v       虽然已经有很多人总结过这十大排序算法，优秀的文章也不少，但是Java完整版的好像不多，还存在某些文章代码存在错误的情况，同时也为了自己练手，决定把所有的写一遍巩固下，同时也真诚的希望阅读到这篇文章的小伙伴们可以自己去从头敲一遍，不要粘贴复制！希望我的文章对你有所帮助，每天进步一点点！！！
3 Y+ m4 S9 \" [* _
" \6 k( H9 K' T
1 I  g1 A1 d- i( t       我用通俗的理解写下对算法的解释，对某个算法的运行过程不是很理解的话或者想看比较官方的解释的话，单独搜索某个算法，看几篇不同的解释，就可以有自己的理解了，这里我主要展示代码以及进行通俗的解释！整起来，再强调一次，一定要自己敲一遍，这样才能理解的更深刻！


十大排序算法对比

3 z" E( c% C* J

& L: E! I5 d2 Y0 ?- D( S$ a* G: Q
关于最后一列的稳定性，我稍微解释下，例如对序列：1 2 4 2 6 排序，序列中存在两个2，如果我们把这两个2标记上（让他俩不同），排序之后，前面的2还在前面，那么就称这种排序是稳定的，反之不稳定。

; n) E& B/ I: g* B( a( z
冒泡排序
2 ]# Q" A+ L2 R+ P* s! B简单解释：
6 L# t; X9 g4 N4 y3 ~9 Z$ ]6 D. i* u       原理就如算法名字一样，就像水中的气泡一样，每次我都把最大的或最小的放到最后面，这样总共需要n-1趟即可完成排序，这就是第一层循环，第二次循环就是遍历未被固定的那些数（理解成数组左边的数，因为每层循环都会把最大或最小的数升到最右边固定起来，下次就不遍历这些数了），两层循环遍历结束后，所有的数就排好序了。
       两层循环所以冒泡排序算法的时间复杂度是O(n 2 n^{2}n
2
, `5 o. x+ R; B3 @& c- F )，是一个非常高的时间复杂度，我在下面的代码进行了优化，加了一个标志位，如果上一次循环未发生交换，就说明已经是有序的了，就不继续下去了，反之继续进行下一轮。


3 [4 M* J$ j3 C9 P) t. }
- w- @$ g) l6 x5 ^
% y: C( o4 \' |
( T! j4 G6 a+ d; }6 ]9 M
2 C# o! |6 H7 g; \* o' t7 L本文的图片来源网络，仅用于大家学习，侵权联系删除！（下同）


完整代码：
+ I% X9 P* ]# r+ m" U

package com.keafmd.Sequence;
* T, Y! Q5 A0 M! x4 k

: D" Z0 l. n; C5 C) V! M/**
* Keafmd
*
: \6 _7 `8 s0 X * @ClassName: BubbleSort
, z' ?& y. i3 r/ W * @Description: 冒泡排序
8 x" g) k. y. U5 s * @author: 牛哄哄的柯南
* @date: 2021-06-24 10:31
*/
9 G* c# ]3 V4 A: O6 wpublic class BubbleSort {


: |/ I8 \* ]- m+ ?    //冒泡排序
" k* `% L) t+ K: A+ [$ o. [; Y    public static void bubbleSort(int[] arr, boolean ascending) { //exchange标志表示为升序排序还是降序排序
, A! U2 g9 F8 J' A( G3 d1 V% h! n

        boolean flag = true; //加一个标志位，记录上一次是否发生了交换，如果是，我们则进行下一轮，如果没有，说明已经冒泡好了

. y: u) a; `2 H+ t) ^6 k$ G
0 ^% S7 L6 V! f6 Q( [% _5 M        for (int i = 1; i < arr.length && flag; i++) { //控制次数，第几趟排序，只需要n-1趟，有交换时进行，只有flag=false就说明上一次一个元素都没有进行交换
% h" `/ ]+ l& ^. @, Q7 F, O& F+ f
# K- }% {4 X1 ~! w: R& K
            /*System.out.print("第"+i+"次遍历：");
, y2 e7 r2 I# ^& }8 p6 @5 B7 O5 J. N            for (int i1 : arr) {
                System.out.print(i1+" ");
! W9 M5 Z- C8 U* a; O$ |            }
            System.out.println();*/

2 q( X6 _3 I- v: n* d2 U: J' X
            flag = false; //假定未交换
; d. O$ B3 S3 Y  e
. q; {( ?+ h9 \* R- C0 ^% A
            for (int j = 0; j < arr.length - i; j++) {
( d. |; D3 j& D# `" E+ U5 ^' k
7 a7 |& [! J/ G: M0 e" d
                if (ascending ? arr[j] > arr[j + 1] : arr[j] < arr[j + 1]) { //控制升序还是降序
                    int temp = arr[j];
( h" P4 q0 d/ Y# D+ s* e                    arr[j] = arr[j + 1];
                    arr[j + 1] = temp;
                    flag = true;
                }
. e. B- u+ l6 [$ J7 E
2 s. Y- b7 z) `/ k1 v. i
8 V; h# g3 N- m8 Z+ h            }
        }
    }


# b3 q, i! t" w) t% I    //冒泡排序 -- 默认不传参升序
- s( d+ }) u3 R3 U& H    public static void bubbleSort(int[] arr) {
        bubbleSort(arr, true);
7 A6 T; G+ N9 |4 L    }
$ O. B/ M- s& B2 Y- h8 o}
1 ~' R$ E- q4 z) [1
2
3
4
- s& f% a, O& \1 A5 I. ~& L4 i( Z5
) |. U' y0 z& s& A8 D9 r+ ~  t6
7
/ D) ?. p5 O4 a( D4 s, z8
0 t: v1 i1 s6 S% P/ n% d6 ?6 J9
# Z1 [' v8 A* b0 Q9 ~; ]) \10
0 Q: w7 e! D7 T/ x1 Y4 l11
12
13
( c" S( }( n  u! ?7 I8 P14
15
" w+ ]: i$ E! Z- y0 s% H8 H' Q16
+ b# G6 @' H4 t. b) W  [, o( y$ B17
18
19
20
21
: s7 A; ]& ~3 }  v! Z4 P22
23
24
! J2 l+ [! E  p# _; b) {# P25
) {$ T; K) ~4 |7 ~  W# G26
$ N% I* H: c$ w! W2 g' o27
' i6 V1 b4 c" G) A1 ]28
0 ~. |# @- C& c7 ?) h* N. u1 B5 z1 ^29
7 u5 c* H' _% o6 R: \  u7 o1 f* J( u30
: c5 S) M- N6 i1 B31
32
33
34
35
( \' x& d$ s! {  Y2 Q0 c4 F- d8 O36
, ]( F5 R1 W/ r$ p5 I) i5 e37
38
39
40
41
42
43
44
0 b! n# s" N: p45
测试代码：
% _+ ~  W4 `! \2 h7 I

, i- `3 W, F1 F* h升序排序（从小到大）
+ Z1 ]5 e$ L7 A, J0 s% r- y5 n
% I. f  {& e) c. m
, D5 r! q9 ~3 m+ q3 \2 U5 J7 Xpackage com.keafmd.Sequence;
) ?# Y" Z2 [/ v6 }3 y% t9 u/ H

) x% V1 U$ a' c8 \4 Yimport java.util.*;
" `1 d/ W- C/ v1 r9 I# l, J- wimport java.util.stream.IntStream;
import java.util.stream.Stream;

* o/ Q4 c& L  I: L5 W: e4 |3 a  R
0 y4 N  Q& r6 v( T! ]. F2 y/**
* Keafmd
*
* @ClassName: Sort
* @Description: 十大排序算法
* @author: 牛哄哄的柯南
* @date: 2021-06-16 21:27
/ u! W2 [  Z4 P" O, u: P" K */
8 v, y+ j3 m* N$ S% tpublic class Sort {
    public static void main(String[] args) {

: Q2 D4 y# i! c3 d9 B+ [
        int[] nums = {12, 4, 25, 47, 58, 34, 25, 9, 99, 26, 1, -13, 162, 10093, -66, -1};
        int[] temparr;
3 E, |8 u" Q' K1 W6 F! i
* O7 }' D* B, e% O  J/ d, n9 H
        //测试冒泡排序
        System.out.println("测试冒泡排序:");
        temparr = nums.clone();
# @* S8 n* C! Y9 R6 S% C4 t9 W8 ]4 G        BubbleSort.bubbleSort(temparr);
( R' W$ s0 E0 c6 c        //逆序排序
        //BubbleSort.bubbleSort(temparr,false);
1 r: g5 E- q( F        for (int i = 0; i < temparr.length; i++) {
7 U7 h0 `& G+ ]4 }" Q            System.out.print(temparr + " ");
5 t$ D5 \, f0 A. j. ?0 \        }
        System.out.println();

7 z$ n7 }! l9 u3 x/ d
    }
}
1
2 p5 Z& I  ?% `$ A2
3
$ o& Z8 O- W7 e6 ^' s' I) _4
; g( @/ Y) a# c: [7 f9 P5
6
0 A* g4 p7 }; Y1 P1 e6 A7
8
  k1 ^. {, u, X' R9
10
7 {1 c& o4 M9 H11
12
4 s; T, ?% s/ ^/ z) e7 s13
14
; C) B) Q. X; [( L( J# ?6 Q15
16
8 ]& H0 V6 a* X! M1 M$ ~5 |8 Q17
18
8 U7 s4 }  D0 s+ G! o* v19
20
21
22
8 E0 Y0 M8 k+ n0 o! g" ^' O23
24
9 D' w+ A! r. Q! e( n8 v4 L+ R25
26
1 l" g' c% [$ u. P  w/ ]) k27
28
% W2 |& N5 d$ V$ R" B, J6 X9 R29
1 U* A. @& b+ j3 v0 G4 ^& N30
31
& {, p! Q9 {' i4 d9 v+ x1 B32
33
运行结果：
( r! J4 m5 i- |0 S" t$ |
9 i. t4 _- y; s$ S) ^
测试冒泡排序:
-66 -13 -1 1 4 9 12 25 25 26 34 47 58 99 162 10093
9 s8 t* f( \2 w1
$ O) h$ ?0 L) N2
降序排序（从大到小）
. t6 _% y: b5 E9 F2 J0 q" `

//测试冒泡排序
System.out.println("测试冒泡排序:");
temparr = nums.clone();
BubbleSort.bubbleSort(temparr,false);
for (int i = 0; i < temparr.length; i++) {
. G" r6 l# q+ \$ @- W# u# f    System.out.print(temparr + " ");
}
System.out.println();
6 H# A% y$ u8 X! v' z/ W( e4 _6 ?1
2
) Q1 \2 J- }5 }9 V+ c- u! \* Q. D; d3
+ m# w9 r* p/ y0 L9 A* J, K4
& I3 f7 P4 @! h! m% _& r4 y; z5
! B" E: ^* U4 K! G+ T6
7
8
运行结果：

: H  }4 t! R9 L5 x3 c! C( l
测试冒泡排序:
10093 162 99 58 47 34 26 25 25 12 9 4 1 -1 -13 -66
/ V6 I4 P2 \7 b% F( G) z- }1 y1
2
3 o/ ~. s4 v: h* W' Y# w4 Y下面几个算法的测试也就是换了下类名和方法名（换成相应的排序算法），如果想降序就在数组后面传个false即可。我就不一一复制了，我在最下面给出含所有算法的测试类，需要的自取即可。


快速排序
简单解释：
8 |# _7 `+ ?8 _快速排序就是每次找一个基点（第一个元素），然后两个哨兵，一个从最前面往后走，一个从最后面往前面走，如果后面那个哨兵找到了一个比基点大的数停下来，前面那个哨兵找到比基点大的数停下来，然后交换两个哨兵找到的数，如果找不到最后两个哨兵就会碰到一起就结束，最后交换基点和哨兵相遇的地方的元素，然后就将一个序列分为比基点小的一部分和比基点大的一部分，然后递归左半部分和右半部分，最后的结果就是有序的了。


- x% V! r4 j1 q# w/ e6 ?



完整代码：
& J8 v+ ?9 t5 a/ k

package com.keafmd.Sequence;
, G5 W- k0 {" V9 O5 W0 v' _* G) b

6 g4 E3 e* ~" L7 h/**
* Keafmd
*
! V8 w9 J7 f3 x; C. t * @ClassName: QuickSort
* @Description: 快速排序
* ?4 a7 }$ p- ?. y * @author: 牛哄哄的柯南
  y7 G' T% c: K1 q; V" s4 O& m * @date: 2021-06-24 10:32
! l7 c- J. {* ^6 k  K */
public class QuickSort {
- c/ u7 i, L' W6 Y& ]$ Q5 W) V, C
7 j$ _. o- a# Z
+ k1 E+ K$ ?5 x  B    //快速排序
    public static void quickSort(int[] arr) {
        quickSort(arr, true);
    }
  \. Z7 g( i! q+ {7 c9 a: W* f

+ o0 i3 J/ w+ h- }    public static void quickSort(int[] arr, boolean ascending) {
* E( W$ Q% a+ ?4 C. n) x/ J6 r; S        if (ascending) {
            quickSort(arr, 0, arr.length - 1, true);
        } else {
            quickSort(arr, 0, arr.length - 1, false);
4 Y) |$ c/ V' n+ ~5 V        }
    }
, x  ~7 }) c. l" {

$ Q0 P" T2 c4 E. X- M. p9 Z    public static void quickSort(int[] arr, int begin, int end, boolean ascending) {
" n, G$ L1 O7 ^        if (ascending)
" ]( M3 ]; s' m2 p: k4 K* e            quickSort(arr, begin, end);
9 v6 B0 @2 }7 H  L/ v) b. p        else
1 k7 r2 O3 Y7 G3 |5 Q: i: `8 j            quickSortDescending(arr, begin, end);
    }
) w* c3 C9 h, B  X

    //快排序升序 -- 默认
7 p6 B* s9 N" H* U2 u6 y# u    public static void quickSort(int[] arr, int begin, int end) {
$ `5 k# W+ P. T& _9 P        if (begin > end) { //结束条件
6 H" }; y( _0 X4 o. ?# Z* s# K1 d! C" b            return;
* x+ L# k0 c. x4 j, n+ q* b        }
* z' S. W- B. _: W, G        int base = arr[begin];
7 h1 V- |' H* _5 P, F1 \# d        int i = begin, j = end;
        while (i < j) { // 两个哨兵（i左边，j右边）没有相遇
9 P1 @' U4 X2 r6 }2 c6 A0 j) _2 b            while (arr[j] >= base && i < j) { //哨兵j没找到比base小的
                j--;
            }
" S& f7 `4 @& K+ X            while (arr <= base && i < j) { //哨兵i没找到比base大的
                i++;
4 E9 l1 }# U3 H* m6 Y0 j; |& p            }
3 E& C9 ]6 e: d# G: H- N            if (i < j) { //如果满足条件则交换
0 F7 h. e6 W& }/ v- q6 D7 K                int temp = arr;
; ]9 @* W% L3 ?+ c  ?2 T+ Z4 \                arr = arr[j];
                arr[j] = temp;
            }


        }
        //最后将基准为与i和j相等位置的数字交换
1 \8 ~) j& J  e3 U; e- t7 R$ U  u        arr[begin] = arr;
; z1 L& ^0 G/ d* b; Q: B9 y  c        arr = base;
        quickSort(arr, begin, i - 1); //递归调用左半数组
( ]# d& B' L- U6 b        quickSort(arr, i + 1, end); //递归调用右半数组
% C6 m0 {# L2 T% k

    }
/ L2 {3 r2 x4 \! ~! C' r
7 h" ]6 z7 y) P/ D9 c
* L7 b% w/ h% A: |3 ~    //快排序降序
3 ^7 u) E: P0 B& h    public static void quickSortDescending(int[] arr, int begin, int end) {
7 G* e9 M; m6 s; Q+ P        if (begin > end) { //结束条件
            return;
$ u# g" t! C7 j* [. R        }
        int base = arr[begin];
, F8 U* N+ N2 F6 B        int i = begin, j = end;
, ?0 e) [) E. A8 F% @        while (i < j) { // 两个哨兵（i左边，j右边）没有相遇
4 F1 @" X2 o5 d% _            while (arr[j] <= base && i < j) { //哨兵j没找到比base大的
( \; b) i0 z8 L3 \$ b* ]) A                j--;
/ j- h9 `5 j) g7 N+ T0 Q& d            }
: r4 }2 Z5 r1 a7 a1 T  E            while (arr >= base && i < j) { //哨兵i没找到比base小的
2 m* B" |! p% y! n5 q2 e( P% ~% L                i++;
- Z' t) m. w9 p5 Z6 @            }
# e- r# e; P& B2 N5 _. X; e( V; B            if (i < j) { //如果满足条件则交换
                int temp = arr;
$ T& E2 g6 R8 T/ N4 Q. M% s                arr = arr[j];
' v3 G9 x" s8 K0 \! m7 G3 k                arr[j] = temp;
            }

  `4 N5 X" Y5 K, U1 A
% d% D& U/ Y. L3 f) v% w        }
        //最后将基准为与i和j相等位置的数字交换
        arr[begin] = arr;
        arr = base;
6 b. _3 X! P/ |4 g$ [- b        quickSortDescending(arr, begin, i - 1); //递归调用左半数组
        quickSortDescending(arr, i + 1, end); //递归调用右半数组

0 E' d) @/ U5 z% Z7 |# w2 u% I8 H
, E+ \' P3 M, U8 b, a0 \    }


3 g& V+ @8 V9 q1 [& a6 v}
1
2 x# t5 G8 l; `4 G3 e3 G7 M7 q& G2
4 e3 l; F- x0 R( m7 g+ e2 ^- C3
4
5
* {4 o- A, J2 D) L6
# s+ D; `2 w8 E7
8
) O% ?% f! @: `& p4 w; ]8 \0 r9
10
11
9 J( z" y( u  j12
13
- t4 z# I6 O+ n- G14
15
16
17
18
. c' y  j$ Z8 B+ `$ ]19
20
  |6 X" O" N# y: \/ D% f21
( ~6 v: V/ w9 h( B22
23
24
25
, J8 \& t% b4 H3 K26
27
& K4 ]7 |6 A2 v: m9 Q# E28
9 G4 ^) R4 [' m. M0 l29
30
3 _, A2 k0 Q# q  f0 d$ S31
32
33
34
9 c0 s5 ^& R  z35
36
! p+ s( l. \4 G& x1 Z4 I37
38
39
40
, u: Z4 u0 o" Q8 |9 o41
) c7 ^4 C# B  {# H1 W4 a, A42
0 g* b) b* p0 R) e+ Q43
' Q* J- i. {0 N/ P  n6 s% l44
) }. J) u9 w$ A+ O9 i' G7 I# i! e45
: J  z+ F/ P) z- O46
& F4 a( Y+ q! ?0 N5 P47
; H5 a5 u+ A. [1 l; G! b% ]48
49
50
( S, V, K0 E* L0 j6 i- m3 z51
) ~- S+ ]  @# q$ L% s6 H1 j! @52
- t6 w- \6 `0 v( T# ?2 x9 I53
& \: O% m  e: t, D: f4 m- X54
55
; N. T' [# Z, i- A" a% G- ?56
57
1 q: B/ J* M& }  a+ C; I, ^* t8 p58
59
) T( h" X2 K5 w7 V- `  N60
4 y0 {" [) x: Q3 S61
% l" b' [+ H+ g+ I4 J1 p( v/ e0 g62
63
) H3 j  g7 M) y  d- |8 v. f9 b64
65
$ y1 |% o5 E: @3 T$ _6 }7 Z2 S66
67
' h0 `5 N, A# J: S) Z68
69
1 T8 Z& W4 K# k: e9 t70
, f$ ?* T4 ]' C5 @1 G5 u! G6 v9 Z71
7 o, h* v" j* _72
73
$ P7 ^4 Q' S. q- _: g74
75
. [! |- ?# O$ e5 s76
77
78
79
80
  h; g+ b7 z! b: f2 t0 }! i81
82
83
84
0 Y9 h. C3 D% e) T( z9 A85
86
87
88
89
$ v! y- {+ Q- x% P90
/ v5 `% w$ H2 R6 m4 Q91
直接选择排序
3 z  `2 s( e- h; g简单解释：
数组分为已排序部分（前面）和待排序序列（后面）
+ e' V% w1 f. A6 G3 N第一次肯定所有的数都是待排序的
  w* e. Z! O- @1 A$ e. r. t" n从待排序的序列中找到最大或最小的那个元素，放到前面的已排序部分，然后一直找，不断缩小待排序的范围，直到所有的数都是已排序的了
0 {& C( M% t7 z- x. H
( g: Z( G+ i0 O+ Y
/ L! _$ M3 Y6 X4 v' w% e
: M" ~' ^8 q" }

8 q, l( W( f2 s! u4 a
9 b# _  z4 v4 v% s* z2 f& Z" k( |完整代码：
+ l7 F& G. ]: C! U% a: @$ d1 ]0 _
0 H: K4 d+ y$ V2 l9 w  e
1 z& y8 @. b; c7 w, Cpackage com.keafmd.Sequence;


) c* J& X# v8 R# y' H( \9 d/ h! a* w3 ]/**
* Keafmd
*
1 X4 g; L! _% r) b( H * @ClassName: SelectSort
* @Description: 选择排序
* @author: 牛哄哄的柯南
8 \& `0 J* K$ A5 \/ S * @date: 2021-06-24 10:33
*/
1 }+ A, H% ?0 U2 Y+ x1 U8 Xpublic class SelectSort {
# S: J' Q. h  e3 G% p: W( F

/ v1 }- L2 i7 v    //直接选择排序
    public static void selectSort(int[] arr, boolean ascending) {
        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; //找到待排序的数中最小或最大的那个数，记录下标
; Y+ _3 C# o: a7 k; @% b                }
# I2 M" ]# Q9 T

            }
            //交换位置
            int temp = arr;
" n* G3 h7 k% [2 `% O; F& f            arr = arr[m];
            arr[m] = temp;

; |& c9 d) _" m3 r# V
        }
% m9 b+ Y7 \% I, n; d    }

2 ^' _6 t6 D; p: D3 d: x4 y) ~
4 v; _0 P: t( a$ \4 x    public static void selectSort(int[] arr) {
        selectSort(arr, true);
* X- i1 p0 Z: W# p    }
. B, n& V  A% `6 b}
1
2 o% ~: p% O2 W' W& i3 P2
# i( W8 ?9 [4 \3 f3
5 y! g% r' \7 T# L4
5
6
7
' x& v0 F2 a7 j2 ~; n8
9
! Q6 h$ [; u# _2 R+ N# W" V10
/ |; x/ c* J2 s- t/ K, U( K  p, ~11
6 P5 |. U+ c& T% X- R: s12
13
" v, g0 Y1 g, K& Z0 W- H14
0 |; G8 L" N3 F15
' Z2 Z2 N* z* r- T( j16
" }2 j/ P7 Z9 D5 C, H17
0 d- M5 Z5 g* {18
19
20
) _; D% {- r2 S/ l21
9 J; N/ z+ \& @/ C1 T& F22
  [: L# w+ M: ^- E' m+ r' H  X9 A. D23
) T5 J; G0 d4 `! E3 R3 h3 ~+ [9 y24
& p" d$ @7 ^( K1 [$ O5 H/ l6 t2 I25
26
3 t# h, a; @2 z: Q+ y27
7 }9 W/ G2 B5 I; a3 u- G; ~0 X28
29
30
31
1 d# y) t- R6 p4 {32
4 G1 }, K1 s- ?& C33
34
0 h5 F: y- i" l7 r, z, f3 n, W! k堆排序
先理解下大顶堆和小顶堆，看图
大顶堆，双亲结点的值比每一个孩子结点的值都要大。根结点值最大
  m; C; |" G4 d3 U" G" W- v( k小顶堆，双亲结点的值比每一个孩子结点的值都要小。根结点值最小
. i0 t- {5 f8 W4 o
; B( X! w! j9 r) T- L% P
3 g% B  z9 d) a& G4 }& `# `

简单解释：
. b9 X4 _8 |5 L1 U5 G构建好大顶堆或小顶堆结构，这样最上面的就是最大值或最小值，那么我们取出堆顶元素，然后重新构建结构，一直取，一直重新构建，那么最后达到排序的效果了。

/ q# J# }; ]; Z: T( f: Q& F
2 f2 C2 k" }, s; [


" B* \: D/ m4 W% \3 o9 B
完整代码：
+ O5 X+ `3 }$ v" e: j' I, b& v
* C) h9 ]/ E/ p1 P6 s
package com.keafmd.Sequence;


/**
2 d+ u( o; A: }( |0 M * Keafmd
*
* @ClassName: HeapSort
* @Description: 堆排序
* @author: 牛哄哄的柯南
* @date: 2021-06-24 10:34
*/
# a, `8 t, B$ wpublic class HeapSort {


    //堆排序
0 I$ Q/ |( g9 Z1 R' s/ V3 z, J    public static void heapSort(int[] arr) {
+ L1 ]' y2 ^3 O        //对传入的数组进行建立堆，这里默认建立大顶堆，进行升序排列
( W; I; H: _9 [& `: j8 \        heapSort(arr, true);
+ y# c0 D) U. r    }

9 M9 U- g7 P* ?$ w
    public static void heapSort(int[] arr, boolean maxheap) {


  M; e# l7 j3 o8 k0 l        //1.构建大顶堆
        for (int i = arr.length / 2 - 1; i >= 0; i--) {
            //从第一个非叶子结点从下至上，从右至左调整结构
6 p9 _" A5 r2 M            sift(arr, i, arr.length , maxheap);
" L& i- q, v5 j9 x, D        }


        //2.调整堆结构+交换堆顶元素与末尾元素
        for (int j = arr.length - 1; j > 0; j--) {
* c. S) _% b: {0 A6 r" v

2 d: v7 J- f& t( R4 K            //现在的数组第一个就是根结点，最小值所在，进行交换，把它放到最右边
            int temp = arr[j];
            arr[j] = arr[0];
5 ]5 H4 m, |/ D7 }1 @  u& U( b/ h            arr[0] = temp;
) U1 T- V. l9 o' `
/ z9 T# C# `  ]% ]
            //重新建立堆
            sift(arr, 0, j , maxheap); //重新对堆进行调整
  ^: ]* Q' m5 A# Q% G        }
: b4 `# X# w+ [1 n* v    }


$ `* C+ c# M0 P# A8 V) S8 H0 s    //建立堆的方法
    /**
     * 私有方法，只允许被堆排序调用
! I- k: c2 h6 N% W$ V2 y     *
/ x) J5 q6 C  L1 E% r     * @param arr     要排序数组
9 Q9 |5 W+ j6 P9 I) b8 W! H  ?     * @param parent  当前的双亲节点
4 B) O, N2 Y* N  p4 Q     * @param len     数组长度
     * @param maxheap 是否建立大顶堆
     */
+ L# U% p7 L3 F7 D8 `    private static void sift(int[] arr, int parent, int len, boolean maxheap) {


! F7 l* V- r# J: ?* r) q        int value = arr[parent]; //先取出当前元素i


$ u5 q8 E, _( V  B6 m1 L        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指向右子结点
                child++; //右孩子如果比左孩子大，我们就将现在的孩子换到右孩子
            }
4 @7 s, H; \. L# N  h$ [
5 V4 k% H: r  `; k) E; R
! f  Z/ s6 Q; `0 |+ o            //判断是否符合大顶堆的特性， 如果右孩子大于双亲，自然左孩子也大于双亲，符合
            //如果子节点大于父节点，将子节点值赋给父节点（不用进行交换)
& K* M7 Z; T8 M. n" X. v& z            if (maxheap ? value < arr[child] : value > arr[child]) {
                arr[parent]=arr[child];
, F: {7 F3 i$ F( F! P. I2 t6 E                parent = child;
' `* p8 |- H, \+ [" g$ z7 V            }
            else {//如果不是，说明已经符合我们的要求了。
                break;
            }
        }
        arr[parent] =value; //将value值放到最终的位置
$ k) v  ~8 [$ D5 i) I4 d0 R6 u: a/ ^
$ t# N7 F+ l) D) |2 L% X
, u! F. ?; R/ B8 ]
% i$ t( a$ {: B8 T
    }
: e4 E& I) h) u7 E* r! L5 T
9 o+ L. ~+ u$ Y3 M2 `" O0 O) z
+ H1 w& J: e7 O. P, Y}
  E. F8 T* f3 E) B$ C/ w1
2
3
8 E/ k8 V; [9 ~4
, z9 M& {/ o4 j" l; i/ h5
0 w( W3 {; }' l0 y, D6
: v0 t# a1 w. K3 w) L7
6 r8 T, y" P. q8
9
10
11
12
. |% h" ~. i5 [7 V! T2 B4 \' G; p13
14
. K) H, h$ z" {! E15
16
17
18
19
20
  |1 ^# g# @9 x* @1 t( w7 J/ R21
) q! J: Q7 l* U6 X) [( U22
23
24
. \  @* M, R' J; X- m% }25
* F0 v& b( i, B9 V/ ~6 n7 S26
27
28
29
7 j% z+ S+ i6 [5 |1 V$ a( x30
/ x$ H0 a9 `# u6 _1 U% a+ R* q31
32
0 j; S. n# }$ m; I9 J3 c33
, C3 x- G( m0 o! v: v. N34
3 C2 }" w5 H3 y9 }6 s0 e" d2 q35
36
37
38
# S& D8 B# L- l1 P% \39
40
, Z+ \' P9 }% i) v. q% j6 e41
* G$ s0 J1 }; {+ H' ?42
7 Q% J/ D/ H6 E5 ]- R43
44
1 |  j7 y* C! H# z1 e45
1 n  R- g3 h3 w4 _* @1 d46
47
48
$ I; |* O8 r# l4 a  ~( v* i; [49
50
51
0 i- _$ q0 h9 n: n52
53
6 a2 k' U' e$ p7 @7 |54
& D( G7 z$ \* u# ~+ q55
56
! C7 Y  \- X4 U& z% }57
: c* N) H# ]5 F, q' |& [58
6 G$ X% L& w0 N7 G! P: z' c59
% F% \& W, s% N/ P* t# d( F! N4 `60
61
# Y; ~1 w4 |1 S$ @0 z* m62
/ K) {; J% s: w/ ]63
64
' t& s9 e7 `. f, h' D6 ?/ h65
66
67
68
69
: w2 d7 X, H- N! [5 |0 N6 W70
: _9 w, F. F8 |71
72
, j. k$ m' q5 k# [- b73
( {5 }. ]2 \9 u+ C' i+ w74
归并排序
简单解释：
% B$ a6 B. T2 E8 t- X" k该算法是采用分治法，把数组不断分割，直至成为单个元素，然后比较再合并（合并的过程就是两部分分别从头开始比较，取出最小或最大元素的放到新的区域内，继续取两部分中最大或最小的元素，直到这两部分合并完，最后所有的都合并完，最后形成完整的有序序列）
0 T: P9 Y( I7 u- S# P



' n* x( g* {& b/ c5 c* E- p

完整代码：

9 M+ y5 V  D" o3 a
package com.keafmd.Sequence;
! ^7 P$ _) ]! f7 J9 Q

/**
( y8 \6 Q8 Y0 i! y! L * Keafmd
*
5 Z- f+ O# @* s2 b8 H5 x, H * @ClassName: MergeSort
* @Description: 归并排序
; U* P* p! T- w  T * @author: 牛哄哄的柯南
+ v& z2 C7 q/ l; w! I; C5 r * @date: 2021-06-24 10:35
*/
public class MergeSort {
! w7 \( \5 e7 I

    //归并排序
    public static void mergeSort(int []arr ,boolean ascending){
        int[] temp = new int[arr.length]; //在排序前，先建好一个长度等于原数组长度的临时数组，避免递归中频繁开辟空间
        mergeSort(arr,0,arr.length-1,temp,ascending);
    }
: T$ X* p, o- a1 [, G: Y    public static void mergeSort(int []arr){
        mergeSort(arr,true);
/ ^. Y: q8 g, [% I, [    }


    /**
/ ^0 R% t+ S% W! B; A/ H     *
" _% a4 ?5 U: T/ G7 n0 }  C     * @param arr 传入的数组
5 w1 u) r; N5 F, D$ d" C: Q     * @param left 当前子数组的起始下标
4 S+ z3 i$ f4 s0 r: r8 r% y     * @param right 当前子数组的结束下标
     * @param temp 拷贝暂存数组
     */
    public static void mergeSort(int []arr,int left,int right,int[] temp,boolean ascending){
$ E, h; F) E  o  T        if(left<right){ //这里是递归结束的条件，我们是对半分，那当left==right的时候肯定大家都是只有一个元素了。


            //对半分，比如总长度是10，left=0，right=9，mid=4确实是中间分了，0~4，5~9
            //当长度9，left=0，right=8，mid=4，0~4，5~8
. Z* g; z7 D( m+ ~2 r# D+ E  i            int mid = left + (right-left)/2; // 防止越界的写法
            //int mid = (left+right)/2;
0 a! U. c2 |2 W( O$ V

            mergeSort(arr,left,mid,temp,ascending); //左边归并排序，使得左子序列有序
1 w- @# W& F; J) x$ E            mergeSort(arr,mid+1,right,temp,ascending); //右边归并排序，使得右子序列有序
5 L8 R$ M# H, F( i- V  G6 \# X1 A9 p

            merge(arr,left,mid,right,temp,ascending); //将两个有序子数组合并操作
1 V7 \0 i, Q% [+ t        }
( n* k  j9 C4 F1 S    }


3 F7 ]7 E4 l. D* o3 Q0 ^    private static void merge(int[] arr,int left,int mid,int right,int[] temp,boolean ascending){
% i7 R- E2 _. I* v5 f        int i = left; //左序列起始下标
3 [* S( j7 x  M5 Y5 B& J        int j = mid+1; //右序列起始下标
) }4 @! F4 P3 e3 S$ K        int t = 0; //临时数组指针
$ _/ S0 K5 `2 }9 X6 p  ^        while(i<=mid&&j<=right){
& c" L! k" L- K( u            if(ascending?arr<arr[j]:arr>arr[j]){ //比较两个序列第一个元素谁小，谁小先拷贝谁到temp，然后对应子序列下标加1
: K. V# _, j- B$ V. y( g                temp[t++] = arr[i++];
  A& F/ a: d# O' S            }else {
& q  \" ?. N4 \( M) A3 \                temp[t++] = arr[j++];
            }
7 Z& q3 B# G, M6 i0 S: X        }


2 @/ w! S0 I4 a7 a4 N& Z3 S        while(i<=mid){ //将左边剩余元素填充进temp中——左序列有一些数总是比右边的大的数
/ Q" n5 {! {, ^' M, A- n            temp[t++] = arr[i++];
        }
" \, R% I+ c7 H3 h

        while(j<=right){ //将右序列剩余元素填充进temp中——右序列有一些数总是比左边的大的数
            temp[t++] = arr[j++];
2 o) l' [& {) B" t6 }! P* p        }


4 D+ [9 C0 u6 r7 w# {        t = 0;


        //将temp中的元素全部拷贝到原数组中
2 s/ M. J7 {0 e4 }/ o        while(left<=right){
2 S4 q$ S: N3 |1 z5 `/ p; n            arr[left++] = temp[t++];
        }


    }


}
1
2
+ q0 M' B  V& j( R& f, I3
6 F1 s5 C! {; \1 f8 B* T8 [4
5
6
2 @4 A2 `: R8 Y- ?, }# {+ J7
0 \) k: i, i, n# W! z7 e$ ^8
# k4 M. T; h% @  v9
" \5 d5 ]( m8 h% \! v# s' o5 `, l10
11
12
  C: D  o: B( ?" ^% T( u13
14
15
16
17
18
  {" c- r- E" `19
% C5 v- i( @) b( K+ m20
21
  e& F( A( w! o% [$ B$ ^22
4 r! {! L& I/ F& w23
24
25
4 c1 Q# u" [6 s26
* S, R- [" l. u' V27
- Z2 d  A$ q$ t) w28
29
30
31
32
% m( T2 z& v* ~( O* ~! L! ]. D33
& `# {) K: Q1 [8 r6 c& J0 ~34
35
( W2 m5 |9 H% ]+ @; r$ Y36
37
2 [% [2 x# _1 j$ t38
1 x0 d, Y+ E5 @. }, Y39
7 J# G+ j" r# q! a4 I0 E( J40
# P1 c  r! _' r41
1 _% w$ h" @% P42
43
44
; ?( L6 b6 m3 [9 T2 E3 K0 t; F( `45
46
47
) _& A, J5 q2 }' |48
49
4 P9 A/ B- ]5 g. f+ _7 }50
51
52
+ g* z6 g  |" X* D% I# M6 J7 _53
# v4 s# }% N+ y7 f& B54
55
56
* N8 Y% j6 H! O* [: z* F6 U57
- T3 T7 h3 t+ T2 X9 w  M58
59
" D6 N& Q1 m  p, L+ P" J4 i5 p, h60
) {8 \$ m7 a4 b1 E61
1 d$ i$ V$ W! J5 c( T& I3 }% h' O62
; ]3 N& S* [3 C, |63
+ ]4 d' W* F" S! h3 v3 j* n+ q/ k% Y64
+ [- P  \) V7 c# O7 y65
66
3 @# R6 Q5 w6 A! g5 w& q67
$ Z7 m! C" B8 F. e9 H68
0 V0 \3 K/ k( g/ |9 K7 `69
8 H: t- D, A: Z6 s70
71
5 C4 ~4 x4 G& _, N9 y& _" O72
6 H0 K4 T" E5 C73
插入排序
简单解释：
9 [0 {! ~; ^' a1 P4 F最简单的理解就是打地主时我们拿到牌后的整理过程，从第二个牌（假设我们拿起来这个牌开始比较）开始，（说下升序）从后往前比较如果比前面的那个牌小，就把牌往后移动，直到找到一个合适的位置（这个位置的前面的那个牌不比这个要放下的牌大）就把这个牌放到这个位置，慢慢的前面的部分变得有序，直至全部有序即可。
& V+ L* E& O# V" d8 Z
5 X& N) Z% v% i1 H# D4 I4 M! S8 M
6 r) O/ N$ J) t* H" A0 h2 l% \
  M$ N* [/ V' P% _

6 L' j5 @0 v4 r+ E3 u9 X) ?' g
3 A$ n& D' ^3 Y" p3 W# H完整代码：


package com.keafmd.Sequence;
7 g8 {6 K3 J# }% M" d0 L
, g. o4 ]1 i. b& J  d0 J
/**
2 [1 X5 T: O+ |3 i3 ?; } * Keafmd
*
; H7 o( K! R2 D * @ClassName: StraghtInsertSort
! w1 f* C. I. l- q' X6 @1 q9 M * @Description: 插入排序
  n  F1 m0 z$ T/ H+ d6 x8 t& u * @author: 牛哄哄的柯南
* @date: 2021-06-24 10:36
8 d1 M3 v9 j- a# j; v: @. X7 F */
public class StraghtInsertSort {
. S2 v- [- Z. F1 @+ |  a" _    //插入排序
    public static void straghtInsertSort(int[] arr) {
        straghtInsertSort(arr, true);//默认进行升序
    }
) d8 B/ F4 |: i: q0 y

3 ~9 @( V& I# v3 [. w/ k( ?    public static void straghtInsertSort(int[] arr, boolean ascending) {

  \5 J! V: a! M6 `9 C7 I3 x6 a
' E2 n5 T6 r4 j0 s( Y        for (int i = 1; i < arr.length; i++) {
/ |' k1 D2 M7 D  @& J            int temp = arr;
& A" I$ {' b8 ^4 `0 Q5 K' p            int j=0; //这就是那个合适的位置
            for (j = i - 1; j >= 0 && (ascending ? temp < arr[j] : temp > arr[j]); j--) {
# ^  x5 p! G$ t2 e% X) V# q$ r                arr[j + 1] = arr[j];
8 ^# `$ [  Y! d3 W* J0 `            }
            //把牌放下，为啥是j+1，
            //是因为上面的循环遍历到不符合情况的时候 j是合适的位置的前面的那个数的位置
( u$ q) b4 k) D# J# c            //有点拗口，但是就是这个意思，看图方便理解下
- ^, ^$ ?  d, a2 ]            arr[j + 1] = temp;
8 Y+ v' v! R* T

& Q: o" ^: Q. w  s- [
3 f; h" O2 \- ]* K+ \# Q; i
: ]- u, K* l8 d/ J        }

7 @5 g( E+ n5 E  n0 J6 e
    }
}
1
3 N# @7 z3 T' z% m" f2
* G0 `5 I6 ]/ p3 K3
" S0 U9 l' E4 Z/ M% H4
5
6
7
8
! h2 C7 S7 w2 ^' x0 O9
10
& b" ^- W! f. o. a' U11
- \8 Y) W& s4 w' c12
13
7 ~9 u& U; A8 a3 g- N! h! l14
. B# U: P$ [4 w9 K4 O' e/ }/ i  J1 ^15
3 ?- T: k9 S. i- J# {16
* v/ i% {$ q( @  n17
18
/ P) L0 }4 Q4 v1 x; I- `' i$ b19
20
1 `6 @% W" @: R# }/ L21
22
23
( y5 h3 E0 K) e0 B. b( E4 s- V4 C24
25
26
27
28
29
$ g# r  D; J# L' O( O8 j30
! ]" X4 f. d4 L2 y' G* v31
9 B5 V+ _* O7 M- B4 w32
33
34
希尔排序
简单解释：
" @$ k9 e7 |7 P+ V, O: P希尔排序是插入排序的改进版，我们理解一个叫做下标差的的东西，也就是下面那个图中的增量d，初始下标差为arr.length/2，然后继续/2，对在同一下标差（相当于把这几个数单独拿出来了）的若干个数进行插入排序即可。

( v- K; Q7 W* }


/ O2 e! {: u' }, U& W3 v9 O% @
4 k2 A3 [4 z+ Q6 N
! F) J9 ~) u* B) n; z完整代码：
0 v6 }1 J% W8 t3 h: [5 U! t
/ ~/ [/ d  Y% \
) i" Z" E- O- C3 h- f. z. O7 Ypackage com.keafmd.Sequence;
! ^1 C( [& _2 D# H. i( y: E6 D

9 x. F' M' u/ o' W/**
* Keafmd
) i* k) w" k2 b! }: }! ]* [; a. `6 N *
* @ClassName: ShellSort
* @Description: 希尔排序
7 b9 _1 W, D. }4 V * @author: 牛哄哄的柯南
* @date: 2021-06-24 10:39
*/
public class ShellSort {


) `: u* z: s$ \9 {5 r6 k( L. K    public static void shellSort(int[] arr) {
, e+ s# @) `4 z$ ]2 o! v        shellSort(arr,true);
    }

: g0 [2 x" |7 E( N) H6 ^+ i
) I% s( i4 ~# y+ F2 Y$ }    public static void shellSort(int[] arr,boolean ascending) {


$ m9 y1 i2 `# b% @$ k        for(int d = arr.length/2;d>0;d/=2){
' F( t! ^/ ?" C4 f8 Q) k1 z5 f) F

8 s6 o1 T3 _  e. S+ R! h7 a8 @            for(int i=d;i< arr.length;i++){
                int temp = arr;
                int j=0;
  R9 Q6 b2 [6 L! E; m                for(j=i-d;j>=0&&(ascending?temp<arr[j]:temp>arr[j]);j-=d){
$ F  v3 o9 e& `5 s8 r7 J% s                    arr[j+d]=arr[j];
5 n0 N4 ?. p8 H8 G                }
                arr[j+d] = temp;
9 _' f2 W  b* P/ }5 G' z" X            }
        }
% F% H1 g. u! D4 b( [7 P* K4 k

    }
0 e6 ]  o% {/ p7 b8 s}
1
2
' w# ^" F0 p6 T/ [" v8 y2 S8 }3
$ ?) |5 y& V7 b" B4 I& Y( f; c4
' |( v' @1 j: T$ P$ ?5 z5
6
0 S# E8 h6 y' Y1 @2 p" q- K% I1 `3 L9 F7
8
7 F/ M$ }% u: Z9 y, n% x9
10
11
' g; Y7 `" `. z: m0 y3 h2 n7 h12
13
  M, R0 ~/ H+ C14
2 f4 Q+ _& g$ \; ?0 N; y3 E; T15
' D# ?) t* d/ M16
/ F: n; Y( s; B8 J17
" T7 r4 E, q* I& x, a+ n18
19
20
) p- ]( r% i3 @+ Q7 y21
22
, i8 J$ w# a  ?1 g23
4 Z7 N+ h' U) S6 \; Y24
9 Q$ y+ n7 L7 `7 q. B1 Q9 U25
8 {6 t" A3 E8 a! ?6 b! T: [/ u26
27
' K9 f3 z( o7 ?8 C4 E$ w28
" o% g! j4 `" U29
# P) B  m) Q$ p9 i6 n30
7 o- {0 }' x! o  X( Y* N, B31
32
计数排序
简单解释：
这个排序算法看名字也很好理解，就是就是额外找个数组来计数，然后在这个数组从小到大或从大到小把数取出来即可。
1 N+ C9 {9 }* A* k. f2 n" @

2 K, M( [, d- r& n$ Z
9 z+ i7 I' G4 T0 P

7 H" L. m4 @; X$ m; Y
4 ^# l/ s/ R- ]- F5 H# ~完整代码：
- a  Y6 B( I( j' e5 g- k

package com.keafmd.Sequence;
. L" c) z7 V8 Q8 Z; C9 x

4 e3 S3 |7 `$ v6 r4 ?. l/ Q/**
* Keafmd
*
1 D; z: A" H2 Q7 C4 U( K * @ClassName: CountSort
* @Description: 计数排序
4 w7 D! ]" P% T. n' H% n, C) R * @author: 牛哄哄的柯南
* @date: 2021-06-24 11:31
*/
public class CountSort {
# C! w: s3 N' |$ w: H
% V* \# ]- x# t; ?  F! Y
! f9 X9 f6 |# w& z, f    public static void countSort(int[]arr){
        countSort(arr,true);
  n8 F" C2 e9 q% a) t    }


    public static void countSort(int[]arr,boolean ascending){
7 S% S) L$ @0 Y+ S9 }; |$ }        int d,min=arr[0],max=arr[0];

" _+ p7 s; w8 S" e$ P
* x  V+ D" e9 L/ x: B6 U6 W        //找出最大、最小值
        for(int i=0;i< arr.length;i++){
8 O# `  I+ W" f! C  |9 l7 E* Q, Y! O            if(arr<min){
9 [8 p, E& u. o9 Y' v                min =arr;
            }
            if(arr>max){
                max = arr;
            }
        }

  H8 G1 b% v' I) t7 p
        //建立一个用于计数的数组
        d = min;
        int[] count_map = new int[max-min+1];
% e$ d7 C! W8 u7 L) X* \. Y        for(int i=0;i< arr.length;i++){
* w3 ^3 G/ |$ X$ k: z4 @            count_map[arr-d]++;
        }
2 G2 f3 ~$ I8 o. Y% H2 l& G) X% u

0 `( K( w0 N( V/ Q0 W4 P! L        int k =0;
        if(ascending){
            for(int i=0;i< arr.length;){
                if(count_map[k]>0){
                    arr = k+d;
                    i++;
                    count_map[k]--;
                }else
                    k++;
            }
        }else {
6 ], |9 E. g9 Q! }4 M3 X% t9 T! O            for(int i=arr.length-1;i>=0;){
                if(count_map[k]>0){
                    arr = k+d;
                    i--;
                    count_map[k]--;
2 l4 q$ U" d5 K                }else
                    k++;
            }
        }
+ D1 `  o; Z, J4 s  v5 e  I: B

    }
}
7 Z* b; S* a  ~4 S1
2
0 T8 p1 K  p8 G& A3
4
3 {& P+ `6 X/ p* j% H5
6
) C4 V  O- M. t  P7
8
3 M7 n- D: l$ i9
10
11
12
13
14
15
, ]* S! f% c# L- V# U9 R9 C16
17
( W: ^0 T3 a9 a$ E6 L18
19
( [. ]# a, W2 j; |9 N2 ~20
8 ?4 Z/ R9 t; k0 _2 s, \. N, Y; J21
22
23
24
25
26
& W8 i3 V- C, z! t* ]27
6 |$ M7 {( B2 p  S0 P# A28
, z1 C! @2 Z' _8 [( D- [2 Y; r) V29
* A+ G! C; e5 M- z% ?( H, r30
& q$ Z4 o$ W! f- X1 k! Q: Y6 f31
$ K* C3 l' V0 \$ H0 w4 D7 q32
33
34
35
36
9 u6 O1 x4 @- D. f# z8 A37
38
39
# n0 \4 j- R1 D0 Z! p40
41
42
43
44
45
" L3 w2 j- e2 c, w/ u9 J+ o' M- `46
& ~- n1 L: z) O1 E9 [1 j47
48
49
50
+ F3 S% {5 @' [$ y$ Y51
1 u; J# L5 H9 e& v8 q+ S  ]3 U6 [52
53
54
55
  f0 Q1 p3 q) ^( m! @2 V9 m" O5 C56
- M' r% t* |, h0 V+ h: z5 f/ ^57
58
59
" d! A/ O/ Y3 E# ~" Y9 V& n8 @/ @桶排序
' Q  A# k+ l* K6 n# j3 Y9 W! C简单解释：
' Q/ `; w9 f" W& D就是把一个数组分成几个桶（其实是几个区间，从小到大或从大到小的几个区间）装，然后让每个桶（区间）有序，然后取出来放一起就可以了，相当于把几个有序的段拿出来放一起，自然还是有序的，当然需要是按照区间的顺序拿了。


1 C+ w) T5 ?0 D% q) L
2 E) P) z6 C+ p: `( h8 k9 _" g

  a2 S# C/ N' \9 X5 c$ a. c/ l
完整代码：
! r* v& }0 d. {( j
! U: o% ~9 {7 P7 u& `4 h+ {- B# M: ]
. q: c) I) k! U8 Z2 tpackage com.keafmd.Sequence;
4 V- X2 g- T% |# x) o' {7 `

& g$ d5 U7 v2 ~& Himport java.util.ArrayList;
import java.util.Collections;
) b- B9 n, i# u

/**
* Keafmd
. ^7 u9 ]4 H: ~' x" Q *
7 l2 Q2 A7 A2 O. A1 N2 D1 M$ E! a * @ClassName: BucketSort
0 y; ]; L, ^4 G2 T3 [0 e  |) N * @Description: 桶排序
* @author: 牛哄哄的柯南
5 ^8 G; `0 B  r * @date: 2021-06-24 13:32
*/
( h1 ~( L' U' O8 [6 jpublic class BucketSort {

" N& I+ D9 A4 y
( i% \3 j7 r; Z' q    public static void bucketSort(int[] arr){
        bucketSort(arr,true);
    }
9 F/ e) ?% _+ Y, s; s( L
1 L& y: w, S+ U1 a' g
    public static void bucketSort(int[] arr,boolean ascending){
        if(arr==null||arr.length==0){
. u- @9 e- T: {1 C            return;
# u- p( G+ @1 f        }
' h% Z( k3 t0 m' ]9 U, B: K: I  q) _        //计算最大值与最小值
        int max = Integer.MIN_VALUE;
3 y3 q6 |5 b" r" D        int min = Integer.MAX_VALUE;
        for(int i=0;i<arr.length;i++){
            max = Math.max(arr,max);
            min = Math.min(arr,min);
        }


. w% x; w- s, z: f- G+ |- A        //计算桶的数量
        int bucketNUm = (max-min)/ arr.length+1;
        ArrayList<ArrayList<Integer>> bucketArr = new ArrayList<>(bucketNUm);
8 t4 W0 ]3 d, o' R$ r7 k5 Q        for(int i=0;i<bucketNUm;i++){
8 A- T( \' h1 C2 J: }            bucketArr.add(new ArrayList<>());
        }
0 L' q8 {/ f0 b$ S, _/ q6 X' C
) r& ^! \. a' q" H# U; u' M& r' C
        //将每个元素放入桶中
, S% F: Z% M' S        for(int i=0;i<arr.length;i++){
            int num = (arr-min)/ (arr.length);
            bucketArr.get(num).add(arr);
! `, ?- I# j8 X8 j: r: @9 }        }


/ k: k/ ~0 U' `        //对每个桶进行排序
3 T3 k! ?- H8 |0 J# b        for (int i = 0; i < bucketArr.size(); i++) {
+ [9 F$ |7 b* Y! V8 ?( C            //用系统的排序，速度肯定没话说
0 l+ v6 Y3 a; w9 I3 L            Collections.sort(bucketArr.get(i));
+ S4 _4 I  ^3 O* m) U$ t5 U0 i; D        }


        //将桶中元素赋值到原序列
        int index;
# Y* g0 v- V5 e        if(ascending){
            index=0;
        }else{
' G3 B3 k# u+ Q; K            index=arr.length-1;
/ n4 Q( ]" p% E' o# \) P  s        }
1 g' ]! q2 l6 n! O: J
! Z/ ]9 x: h" m0 Y& M
* R* \! I6 _. u1 q        for(int i=0;i<bucketArr.size();i++){
( J( B2 M4 a+ P0 k            for(int j= 0;j<bucketArr.get(i).size();j++){
                arr[index] = bucketArr.get(i).get(j);
                if(ascending){
                    index++;
3 q; S/ i1 c% s8 E# G. O                }else{
3 T! C0 Z6 O" s& R0 z                    index--;
                }
" e  T- B  k9 b" V2 O; B0 U  d: ]            }


        }
0 f2 E% ~. o+ \% O8 t
5 d. r* F  ]0 q4 I
    }
; H7 }+ S. C. C. X}
8 f) W8 Q, D  [1
! m: F9 ^, W( {2
& @( G) p0 M) s& V0 z6 b/ @% f; ^, x3
4
5
6
1 @2 X3 H" j3 `/ n7 @1 p7
$ H" l0 `7 S+ R2 L5 A7 o2 x: }8
# j  z4 q9 T, i/ u3 H: W- {9
10
11
12
13
14
15
16
! A+ ^' z. _9 z17
18
19
20
4 N; ~5 O: i. v( G- A  G9 l1 v21
22
23
2 E8 {1 A7 g( C5 Z5 h8 p% B' Q24
4 N* Y; T! v+ V, {: K4 q25
" F2 G6 ~6 {, W( d* q- _# }7 p  Z8 p26
% ]6 F$ M/ h" s  o27
3 x" q1 P) P' ^( e- W28
29
8 `( E; H* a: `% e30
31
) r$ s3 R; z5 Q. I! X; l, i+ Q32
33
1 w  C% ^) ^% W* m% @+ x" Q/ K34
# W' [  }, A9 L35
& H/ I- @+ O6 k/ D: j! y36
37
( E/ h# Y( N4 g, k1 X38
" Y7 h6 f+ n2 {9 `39
5 _% k% d4 e/ L- A, m5 {40
% x2 t; B/ ^! Y2 ~! o# Z0 @) ?41
  T1 i8 e- w5 i2 h, W42
9 r' \) T; h7 Q8 d& Y8 `43
44
4 }3 p& D* |4 G+ v6 u- t45
; K$ z) C( b4 |1 a0 I  R46
47
48
: Q# X  e1 i% _( B49
50
51
52
53
- _0 f# @9 H4 m: L54
55
56
57
58
59
% t5 O9 H! @- B% ~6 o$ l60
$ `# i( n* |- b; E0 t0 f) s. p61
62
63
, X- F7 k. m# @0 U- E7 j( W64
' J, h" y  f, D" ?65
66
. i9 ~( j& {' g' R; l; n* r4 k67
68
" O( q+ u* A7 v2 j69
7 H# Z5 D9 g+ L4 d4 r1 y70
71
4 S, r3 M- ]6 \& e/ ~/ W72
0 Z; ~( l7 Z" c  |& T0 k基数排序
简单解释：
首先说一下，我发现好多人写的基数排序只能排序正整数，其实只要处理下就可以排序含有负数的了，就是我们排序前先把所有的数整体变大（就是减上最小的负数，也就是加了），都变成正数，然后排序好之后，在减下来（加上最小的负数，也就减了）就好了。
基数排序就是按数位排序可分为LSD（从最低位[也就是个位]开始排序）和MSD（从最高位开始排序），下面写的事LSD基数排序。
3 |7 A4 y3 Y# W基数排序就是把数按位考虑，让后我们一位数只能是[0，9]，就是我们在考虑某位（个位、百位· · ·）的时候就只看这个位的数，放到在[0，9]相应的位置，然后顺序取出，最后再按其它位这样操作（上面说了要不从低位开始到高位，要不就是从高位到低位）
& y8 ?' n: E: T* }6 {


  ^/ h; `) U1 I6 ?" ?


完整代码：


package com.keafmd.Sequence;
% v3 _, R6 @. Z$ T1 H% D" y. q) E
  G# f7 g6 ]+ G) D/ ~
/**
$ m4 V  X. n& I  m9 i * Keafmd
1 f' v) s6 Q  P, o# {( B0 T% ? *
* @ClassName: RadixSort
* @Description: 基数排序
% O* F+ T4 d" T * @author: 牛哄哄的柯南
6 Q- S6 W1 Y4 A9 t6 t. ` * @date: 2021-06-24 14:32
*/
: i" q' |2 B  Q6 ]; n& bpublic class RadixSort {
/ ]7 Q, K! J  o  T. t* j    public static void radixSort(int[] arr){
9 W, ]' H0 `0 D+ p* w$ X0 s, }        radixSort(arr,true);
    }
4 Y- d- K5 E$ |! N: ]    public static void radixSort(int[]arr,boolean ascending){
        int max = Integer.MIN_VALUE;
        int min = Integer.MAX_VALUE;
        //求出最大值、最小值
/ J; ~% M; `% m2 j, k; B5 a  R5 |- J        for (int i = 0; i < arr.length; i++) {
            max = Math.max(max, arr);
  \0 F+ S& G3 n9 I3 M! j& A& G            min = Math.min(min, arr);
        }
* u2 n" `1 k# {/ h1 ^7 h, d        if (min<0) {        //如果最小值小于0，那么把每个数都减去最小值，这样可以保证最小的数是0
            for (int i = 0; i < arr.length; i++) {
                arr -= min;
            }
+ J5 `, k3 T" N$ O. j: s+ l            max -= min; //max也要处理！
" b* \6 \& ^% |7 E        }
# M. u) s4 R8 v& A        //很巧妙求出最大的数有多少位
3 J5 ~! g# m' O: b8 ]        int maxLength = (max+"").length();
, [8 [7 f7 K4 y6 D- U/ Z7 o        int[][] bucket = new int[10][arr.length]; //一个二维数组，一维代表0到9，二维存放符合数
0 i; x9 X0 d( q3 X        int[] bucketElementCount = new int[10]; // 用于记录0到9某位存在数字的个数
        for (int i = 0 ,n = 1 ; i < maxLength ; i++,n*=10) { //个位 十位 百位 这样遍历
            for (int j = 0; j < arr.length ; j++) {
6 n" P, o. H- V" n                int value = arr[j]/n % 10;
                bucket[value][bucketElementCount[value]] = arr[j];
                bucketElementCount[value]++;
            }

0 z6 |. c4 i  i& P2 d
            //升序
1 Y8 H% }  T- }' R' D            if(ascending) {
: k9 Y1 u$ ^; }; O2 n                int index = 0;
                //从左到右，从下到上取出每个数
  g: w  W8 w% ?2 B4 j1 L" U0 K                for (int j = 0; j < bucketElementCount.length; j++) {
; F6 u' J! ^6 v4 L3 h7 e                    if (bucketElementCount[j] != 0) {
                        for (int k = 0; k < bucketElementCount[j]; k++) {
4 N; n4 x2 @0 C/ P" k                            arr[index] = bucket[j][k];
                            index++;
                        }
                    }
                    bucketElementCount[j] = 0;
* j! `. M& ?- h" \8 t8 I1 u7 _* b                }
            }else { // 降序
3 J- Q- O4 b( d  V' c+ _                int index=0;
                //从右到左，从下到上取出每个数
                for (int j = bucketElementCount.length-1; j >=0; j--) {
$ b! ?* y7 m& {4 v" }                    if (bucketElementCount[j] != 0) {
                        for (int k = 0; k <bucketElementCount[j]; k++) {
                            arr[index] = bucket[j][k];
                            index++;
9 a' J6 T( e  f                        }
& n2 `6 W  _% @! L9 o& U- N6 p+ P                    }
                    bucketElementCount[j] = 0;
                }
            }
" L7 f3 y$ u* M3 l" p2 s
8 J5 ^' A' q: k  h  ~
  c$ d* e8 J# S+ x, p

/ ~3 d: J  ?8 K- T1 G: E, c; f5 `            /*for (int i1 = 0; i1 < arr.length; i1++) {
                System.out.print(arr[i1]+" ");
& s5 G: ~0 X6 Z* @/ }2 q6 ]            }
            System.out.println();*/
2 q1 A. [8 E5 N! v, t




0 Y$ F. H" b8 U4 T* x) y/ ?" R( O
        }
$ D& ]" w; T' z* @% j        if (min<0){
            for (int i = 0; i < arr.length ; i++) {
                arr += min;
* d, m" l$ J9 X: }0 v2 f  `            }
        }

* _  B* D7 ]7 p; H+ z
0 D+ _$ _! u7 {! a    }
/ k8 q$ |0 p# K8 p6 w4 Y2 v) i) }}
1
2 l5 g7 c) }8 j* v* q2
5 H# V" T# C  V# {4 A- E3
4
5
, G6 L, U$ C. e& S; @, q" P6
5 c7 W: h/ R$ b5 P7
$ C- W+ I) B  G4 S4 e2 c* y5 u8
9
7 ^. V# A0 U$ `10
, _/ a8 W$ u4 ?5 x( g" n* Z1 ~11
+ m  W* P4 g& Z3 e12
13
3 X+ `' n3 {' T9 b, ?14
: h9 u+ c1 s( N( x15
5 X* C4 E, R  h, N16
17
18
19
20
, Y1 }7 v1 n# D& e4 P2 Y21
22
( K3 D% h! Y* \, F2 Q% M3 \, M23
24
/ c$ T# o2 T/ ^25
26
5 K. x/ F3 H" k* n6 T/ r27
  F$ N0 l( g" M5 `3 ]9 ^28
29
% k- W" N2 S+ G30
31
1 n( p/ i3 f, j32
9 Y. ~8 X# N! P/ u6 I) {7 j1 s33
2 m. j$ K5 R% P34
35
36
37
38
% c0 B4 N3 ~. [8 U4 \3 |39
; v& s% \5 ^% s: Q1 J40
$ M% n! _1 R& n1 h; Y41
42
0 T# r) j1 z4 N) q+ g! T/ o43
44
45
% S- _0 e3 D! [% M. ^$ \46
47
48
49
" [' F7 |. I- G$ V2 a6 R6 j0 a50
51
3 i! b3 b2 ?; S! ]5 b4 o. X0 R+ N52
53
4 k( h( n0 z7 D% T4 G54
55
56
- s, I4 i( l/ [57
58
+ K, N8 E5 p% Z  E6 S  n  h59
4 d9 J- K" B+ l; n/ c: m60
61
62
63
64
$ L( k+ Y. G0 c! i/ i5 X65
9 p& m9 G1 h7 p1 L6 E. S66
67
9 J9 x! ], C6 q0 O" q. [! B8 o68
: D- Q% n8 ~; Q2 k2 ^, m8 b69
70
71
- H! L+ J% ~4 `( e  C72
73
74
! ~2 }+ \4 K  \( P; r75
76
: _3 t  p! L1 W0 }6 p& }2 X77
% m8 Z0 n: c) \5 d* p  k78
79
80
0 H4 B' z; q' O# Z! ]" j8 z81
82
83
* W0 m  {5 \6 p7 t5 O完整测试类
package com.keafmd.Sequence;
. s3 @4 N+ k0 O0 ]. ^/ J
) ~2 r7 L% T& p% s
import java.util.*;
import java.util.stream.IntStream;
7 ^  d$ b+ m* L" T2 Zimport java.util.stream.Stream;

1 Z" V1 M: }+ b, \- o: x" W
/**
2 J2 d/ L# y+ l9 `; U7 v, c * Keafmd
*
* @ClassName: Sort
7 R% Q) g" A" H5 ?  [ * @Description: 十大排序算法测试类
! o# e. o( U( w5 q; ]: _: y * @author: 牛哄哄的柯南
* @date: 2021-06-16 21:27
*/
public class Sort {



$ w1 K" Y4 M9 ]( _) s: b4 R% X
# T* l, [8 _" y3 g$ b! ^( [    public static void main(String[] args) {
8 s; f+ E* ]4 e7 A# i8 W! L( s
% w; |  \7 Q/ [! U$ z1 z
        int[] nums = {12, 4, 25, 47, 58, 34, 25, 9, 99, 26, 1, -13, 162, 10093, -66, -1};
8 a6 Q) X4 c, `* Q1 R  ?//        int[] nums = {12, 43,56,42,26,11};
        int[] temparr;
1 G7 ~. `6 c9 x4 Y' Q: }1 D

: O/ k2 n- w2 v. O6 I        //利用系统Collections.sort方法进行对比
) `% M8 p4 ?% e& G. ?1 k
* t' [4 I6 y2 ^/ V$ S
        //将int数组转换为Integer数组
        //1、先将int数组转换为数值流
        temparr = nums.clone();
" [, C: A; k( e& E2 I        IntStream stream = Arrays.stream(temparr);
        //2、流中的元素全部装箱，转换为流 ---->int转为Integer
        Stream<Integer> integerStream = stream.boxed();
        //3、将流转换为数组
        Integer[] integers = integerStream.toArray(Integer[]::new);
        //把数组转为List
$ m& M6 y5 a  q& O9 c2 r9 ^1 u/ u        List<Integer> tempList = new ArrayList<>(Arrays.asList(integers));
. h$ h' O2 s& l9 b# H( c7 y        //使用Collections.sort()排序
        System.out.println("使用系统的Collections.sort()的对比:");
! e) ^0 Q8 C9 u$ H9 N2 k
! |. ^( [' H4 @9 g) m
8 Q, l- f6 E. H2 Y" n+ W        //Collections.sort
$ `' A/ q7 {! @# R4 s9 O        Collections.sort(tempList, new Comparator<Integer>() {
            @Override
! I2 z" G2 F  W            public int compare(Integer o1, Integer o2) {
$ z% C% `0 S2 N6 U6 @                return o1-o2;
' ^0 _% O7 N: ]                //return o2-o1;
% c4 n" j; N/ X+ O. S            }
& I7 |% L/ I: L! d% p- v& l# f, H9 L        });

$ g9 L' i. P$ T! Z' ~; ?
  U5 L9 Q& h( {4 H1 O! H        //tempList.sort 也可以排序
, u7 f/ g) r2 B4 j1 U; l       /* tempList.sort(new Comparator<Integer>() {
' R9 ^  p* l8 H2 Y# K3 t            @Override
            public int compare(Integer o1, Integer o2) {
4 a( f7 ?' K! g                //return o1-o2;
                return o2-o1;
            }
# U* t5 ~1 |; D: c* I, W! s        });*/

! D* N$ V8 P7 z- e8 C7 m$ L
9 c) _4 a, @& L" l        //遍历输出结果
        for (Integer integer : tempList) {
9 G) `' z* _2 l6 {  u* D7 Q            System.out.print(integer+" ");
        }
6 S' t# p. ?; @7 W: ~
- [9 w$ a8 h1 o/ ?+ I3 e6 {' w
1 S  V/ g. c: U" i5 N- K# H0 a        System.out.println();


        //测试冒泡排序
        System.out.println("测试冒泡排序:");
        temparr = nums.clone();
2 }+ @1 l- z6 q* @  S" F$ d

        BubbleSort.bubbleSort(temparr);

9 o1 |' j6 w# @/ j. u9 i; i
        //降序
        //BubbleSort.bubbleSort(temparr,false);


) r: {9 c. P7 U# \" j0 G        for (int i = 0; i < temparr.length; i++) {
            System.out.print(temparr + " ");
        }
        System.out.println();


        //测试快速排序
        System.out.println("测试快速排序:");
, y6 n3 w0 I# E3 {* A9 S        temparr = nums.clone();
& W' {% Y: K: B, Z- J0 ^) P0 ^        QuickSort.quickSort(temparr);
& Q* W0 R4 i- p5 j) T, m0 u        //QuickSort.quickSort(temparr,false);
# v; ]' W  j( _! [1 c        for (int i = 0; i < temparr.length; i++) {
            System.out.print(temparr + " ");
1 C: B9 V9 O& A- u* M        }
, |5 ?$ {0 E% H) M% n: n2 b3 d( L        System.out.println();


        //测试直接选择排序
2 `8 W% @4 }: j; D        System.out.println("测试直接选择排序:");
- N5 X: b, j4 @' H( v        temparr = nums.clone();
  J# V+ C8 `# g1 v- @        SelectSort.selectSort(temparr);
        //SelectSort.selectSort(temparr,false);
8 A0 s: E! i& t4 N+ R+ ?1 e0 F        for (int i = 0; i < temparr.length; i++) {
            System.out.print(temparr + " ");
4 i3 u3 L" P1 H* x: Z/ m" T5 A        }
: \( t$ ^) a& J1 L        System.out.println();


& S3 w  p. V0 D2 Y# p9 H" i1 I        //测试堆排序
        System.out.println("测试堆排序:");
        temparr = nums.clone();
        HeapSort.heapSort(temparr);
/ F. W6 R# N% p0 i/ f/ y$ o        //HeapSort.heapSort(temparr,false);
/ U. A) O2 n! E- s# y5 }9 y- t        for (int i = 0; i < temparr.length; i++) {
            System.out.print(temparr + " ");
* W/ ]% H7 F* u/ t& m: x        }
! e7 o3 j7 R& L: l5 ?        System.out.println();

1 t0 G: _5 f1 p" o. r. ?3 o
, b) ]' r% q8 b0 a( j, f  P$ R        //测试归并排序
2 C( t0 M6 K+ y* O, j        System.out.println("测试归并排序:");
$ a& X0 {- }, `. Z) @7 {; p, v2 @        temparr = nums.clone();
, m# M$ F/ o4 Q) p! h! g* u        MergeSort.mergeSort(temparr);
9 a; Z: o8 k. h5 L2 z        //MergeSort.mergeSort(temparr,false);
        for (int i = 0; i < temparr.length; i++) {
6 D& L2 @! ^- C; c' I' y            System.out.print(temparr + " ");
        }
        System.out.println();


3 S% ^6 `4 E0 P) O4 f        //测试插入排序
4 V4 B7 |9 k8 r, g, ?  q        System.out.println("测试插入排序:");
        temparr = nums.clone();
) w3 f& b9 {! [1 R  G  ^. E! H        StraghtInsertSort.straghtInsertSort(temparr);
        //StraghtInsertSort.straghtInsertSort(temparr,false);
3 l* {# L! [. f$ H! D        for (int i = 0; i < temparr.length; i++) {
: o% ?) `( g1 B0 M% ?8 S. Z& ~            System.out.print(temparr + " ");
. v$ O& C$ Z- s; V$ Z% J        }
        System.out.println();
1 U& f' t5 g7 O* V( h! W


5 I% t+ k7 ?9 W
        //测试希尔排序
        System.out.println("测试希尔排序:");
; _' h: q& u3 P        temparr = nums.clone();
        ShellSort.shellSort(temparr);
( j; M. K9 N# Y3 U5 m7 W        //ShellSort.shellSort(temparr,false);
% |2 t2 {7 N0 t1 n        for (int i = 0; i < temparr.length; i++) {
            System.out.print(temparr + " ");
        }
        System.out.println();
3 J% c! s3 A4 J
9 B6 r% L% a0 z
9 ^9 q( }8 z4 q7 ^# V1 n
& R: P1 i8 F5 k. q
        //测试计数排序
* a" E4 \9 x/ |  j) b! U% r        System.out.println("测试计数排序:");
1 c. b/ x& a; }7 S+ C  h' v        temparr = nums.clone();
        CountSort.countSort(temparr);
8 K& q- O: B8 ~, u+ z" A9 T5 F        //CountSort.countSort(temparr,false);
' X7 f' [1 Y2 Q4 U9 n( o; K        for (int i = 0; i < temparr.length; i++) {
& d: P& d! z) a            System.out.print(temparr + " ");
        }
" s' T" h( \9 X4 `6 h: P+ Y( n/ @        System.out.println();
4 C% o2 I) I" w


# j7 O8 n% c, f% }; u
        //测试桶排序
) d3 o& R# J' S, C* H/ g        System.out.println("测试桶排序:");
8 f  {. `) w4 X- Q8 c        temparr = nums.clone();
5 `1 ?7 @' c' R        BucketSort.bucketSort(temparr);
1 b% p- g+ a! t$ M        //BucketSort.bucketSort(temparr,false);
$ `. N( K' f1 \5 L( f        for (int i = 0; i < temparr.length; i++) {
, `6 m  e9 k! y. z7 i0 ^9 I            System.out.print(temparr + " ");
% D2 j/ d9 z: A+ Y& J. x" b        }
9 M: r/ e" Q$ j6 d( z" g+ M        System.out.println();

; Q% M) Y6 Z* V! ^
- g9 q3 w. }- V: \9 Q5 B9 S  @        //测试基数排序
: B+ u4 {2 W  }        System.out.println("测试基数排序:");
9 A' B- S  s! \) Q% ^( n; m7 F        temparr = nums.clone();
        RadixSort.radixSort(temparr);
1 |% m! Q" L: ^1 H- u7 L        //RadixSort.radixSort(temparr,false);
6 v% F- ~; C- Q& d3 |        for (int i = 0; i < temparr.length; i++) {
            System.out.print(temparr + " ");
        }
$ Q+ [$ _0 |. i' H# x; {4 u        System.out.println();
/ C( ^4 e" ?! I# L6 H  s- m+ d
0 n% a- B9 z! X/ W9 @- \) s* I
    }
% ]. O$ {, S5 e( e9 Z

}
1
2
3
4
5
6
0 }& g* |1 H; ]" D4 G6 C7
8
( `7 x7 e6 G2 T4 D9
4 V! i  E# y6 K" B0 v10
+ D; f% z5 F) t6 S11
12
13
" `5 ^" x; q+ E14
15
/ @2 g7 W  c0 B4 k16
17
, ?3 L/ L" b9 N$ d3 T9 \" @- h18
! N7 V. q/ p- v* c% ]. W2 a19
20
& R7 |* i7 I+ T! c0 O# k% E21
22
& w9 m; x; F- D) e( Q23
24
: j* f, R, |0 Z: U4 @2 F' }8 q25
: C( Q( i( D/ e, `6 O0 l26
27
28
29
30
! P5 R' D- Z) n2 {* ^8 X31
; ~. p! O, v1 @$ M32
33
+ k1 z6 l1 @  b6 U0 P34
. x3 a& G9 t/ w# i35
" m1 _2 z" T* C36
37
# S0 H- G& E" Y6 h4 ]" G6 J38
$ U( V) t( r$ T0 H: S0 X39
40
  d* b- j% ?) g, c0 y* a& T41
42
43
9 X6 |7 ^. c. t9 f44
45
46
9 ^/ O9 G- N( l, |2 y$ C47
48
3 d" c9 W6 S. d& c49
50
. P4 z- C7 c) S, @/ Z51
52
53
54
5 A% {7 c- L/ M8 o8 O" Y7 N55
56
57
58
3 i) G8 w1 B4 L  }/ _# Y59
60
: b- Z* c9 W8 U8 a61
5 |# G. b3 ~9 r! F9 N; I% \62
  {! C9 \9 o; d& q63
64
65
66
5 F  L" \8 g. o) @6 E67
. x5 j- Z( ]  C68
69
( `" g" B$ q$ j6 x70
8 V. l2 c2 ~8 b- w71
5 \, d# n* B( k& h+ x# s' Y. E72
4 W* G( q' S% ?0 `4 g! |73
- W% J$ b# I! i; |5 l, S( r* u74
1 ?; G- t# I6 _8 b+ w75
5 D7 {# X+ f8 Q% t2 h76
4 d2 O; h( Q0 X77
78
79
: e/ W( {8 H: G3 x: @80
- m7 o) E/ @0 |; R3 P0 T81
& w  H: K  L  L& i& _# Z82
83
6 {  t+ C- A. i84
85
! h0 T, o" u( _5 a1 m8 g3 q86
2 ~1 `2 O$ C' Q+ `' E87
88
9 n  U6 H7 B* t/ z89
90
3 j' H  s+ ]5 q( J/ p1 P9 a91
4 v" J* _9 b( g* f3 h* u92
: K6 o5 u1 O9 U' A/ x. X* Y7 D5 ?7 k93
! e: w& j$ m; I& X8 K94
" r) O6 V, `$ l7 J4 J' F5 O/ F95
96
0 E7 q- Q9 H$ J7 l97
# q$ E. n( C$ v* d0 O4 l1 n9 o98
: d; N+ z5 h' S! Y3 I7 q. n99
100
101
4 E5 g9 [9 O9 u1 v% W1 L: N102
103
! S  p/ q+ {) h+ ^6 u! l104
9 m( X& F1 E" e- R0 [2 h105
106
! [& F* l* ~7 L( v/ _107
* j) }6 Y  k8 ?108
  g8 X5 B) N0 `" e3 Z109
110
111
/ y, y# {9 d/ d  G% j( G112
113
7 \$ i: X- |9 F! @/ y" z114
115
1 W! U* }& Y9 p0 _116
117
8 o" T. l6 a; t0 z, a3 O0 p118
$ ~0 H4 R8 l/ N1 Q% Q# ?6 N119
120
5 P1 W. ]% }2 z3 y; N4 |121
122
123
! P% @9 c* o$ u4 P2 J6 U124
$ k( V4 {0 N& x; ~125
% P: _3 f& p6 Q9 k' ~) \5 C126
127
128
7 h8 Q7 V$ P  t' f+ p129
8 o) i1 Y9 h# I5 q130
131
& p- V3 J0 D, l# m- s132
133
134
/ z% x* n* M2 [- a- \" b135
136
137
138
139
0 P* K/ ^/ p  L* d  B5 ^7 \3 H140
141
142
143
# [3 b* L  Z  _( t: @144
' k- g5 i4 u9 P; D145
, r5 r* _  }- v% s146
147
148
149
150
151
- b# e* _9 y' V% G1 e# ^% X152
. i3 _. T" }1 ?* U; ]153
154
155
! x6 o% N6 y5 a- ?/ ?) |" w8 a4 s156
% {7 \5 N% S* p5 ?4 E" G+ d157
158
2 Y9 h9 L4 _7 X; U) D6 C; T159
+ x3 j- ?, v  C160
% R+ q# v# I: y7 x( C  f1 ?161
162
; A2 T+ Y$ Y, s- z# g163
164
165
166
167
168
! G( F: X  d, x8 E2 n9 @169
* {# a& T% m/ d, n$ o% T/ x170
171
, z+ A$ d  w; X5 ]% i7 K" P* d$ X, Y# v172
/ L7 q4 _- O, u6 X173
每天进步一点点！
# ~8 D; w( H' F4 u不进则退！
7 ~+ V7 c; X$ l

& C6 x% L; j# }! a0 t, F版权声明：
: y! [  w* l0 f% v& C: I( b# `原创博主：牛哄哄的柯南
  v4 ]/ m4 c7 F, m$ U博主原文链接：https://keafmd.blog.csdn.net/
3 k( Q- K: k: _3 g# W1 o- a————————————————
) C4 K: n3 d4 Z" K( R5 S版权声明：本文为CSDN博主「牛哄哄的柯南」的原创文章，遵循CC 4.0 BY-SA版权协议，转载请附上原文出处链接及本声明。
原文链接：https://blog.csdn.net/weixin_43883917/article/details/118193663
  `' e+ }+ j2 T" a+ C3 O- j
1 T3 U' a. [) w/ r0 h

1051373629

每天进步一点点！