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

杨利霞

& A6 _* w" u% W6 S; g1 O: C$ T& l经典十大排序算法（含升序降序，基数排序含负数排序）【Java版完整代码】【建议收藏系列】
经典十大排序算法【Java版完整代码】
写在前面的话
9 e/ P; |8 D1 R- `十大排序算法对比
冒泡排序
* ^+ I2 f* N) J1 Z, r. t! t快速排序
直接选择排序
堆排序
归并排序
插入排序
0 \6 w$ A; A$ G/ ^希尔排序
# l$ H7 P- i) I* S$ C: R2 A计数排序
桶排序
" r6 H' R3 O+ [% m基数排序
完整测试类
写在前面的话
4 T/ o% ]1 h3 M! _( p% c       虽然已经有很多人总结过这十大排序算法，优秀的文章也不少，但是Java完整版的好像不多，还存在某些文章代码存在错误的情况，同时也为了自己练手，决定把所有的写一遍巩固下，同时也真诚的希望阅读到这篇文章的小伙伴们可以自己去从头敲一遍，不要粘贴复制！希望我的文章对你有所帮助，每天进步一点点！！！


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


6 f6 l$ L. P9 j; ^2 i7 u0 ]6 `十大排序算法对比

( T2 @" e( A7 [' Y. n
- o- M% G0 J, C, p( |: b

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

0 @* F8 D% g8 x0 A! n5 \5 V
/ _% F. h' y, u, A9 e" V' q冒泡排序
简单解释：
6 D& b$ N  I' I0 i$ k/ b       原理就如算法名字一样，就像水中的气泡一样，每次我都把最大的或最小的放到最后面，这样总共需要n-1趟即可完成排序，这就是第一层循环，第二次循环就是遍历未被固定的那些数（理解成数组左边的数，因为每层循环都会把最大或最小的数升到最右边固定起来，下次就不遍历这些数了），两层循环遍历结束后，所有的数就排好序了。
+ @3 V4 v+ [! W       两层循环所以冒泡排序算法的时间复杂度是O(n 2 n^{2}n
$ y  s6 k( h7 G' Z" e+ m2
# p9 M$ j7 B: K4 d8 I8 v6 C9 H )，是一个非常高的时间复杂度，我在下面的代码进行了优化，加了一个标志位，如果上一次循环未发生交换，就说明已经是有序的了，就不继续下去了，反之继续进行下一轮。
3 O3 e, d" H$ c$ u7 ?4 Q

- O/ D: S# d3 _. D9 I# {0 X
7 B" B: k$ W' r$ e  E$ q

! s2 B- Q: ^7 N
" t, O4 Z1 b" S* |  L本文的图片来源网络，仅用于大家学习，侵权联系删除！（下同）
( P) Q5 R1 w8 N$ \" t, E1 q

完整代码：


package com.keafmd.Sequence;


" k2 X' X) _+ _0 `0 [/**
* Keafmd
*
* @ClassName: BubbleSort
* @Description: 冒泡排序
* @author: 牛哄哄的柯南
( G( u9 [% @$ @6 N2 P7 `9 ^* \) t * @date: 2021-06-24 10:31
*/
1 A& h: Q* }8 N/ ^# ~" jpublic class BubbleSort {


    //冒泡排序
    public static void bubbleSort(int[] arr, boolean ascending) { //exchange标志表示为升序排序还是降序排序
1 h) a; u/ Z  Y- c% D. U1 D

+ a$ V/ r2 ]& a  t+ }        boolean flag = true; //加一个标志位，记录上一次是否发生了交换，如果是，我们则进行下一轮，如果没有，说明已经冒泡好了
% Q5 u3 d' h2 P' e

1 v% N1 H/ f" f) B        for (int i = 1; i < arr.length && flag; i++) { //控制次数，第几趟排序，只需要n-1趟，有交换时进行，只有flag=false就说明上一次一个元素都没有进行交换

2 J; X, E2 k4 y* `* K- ~' l( Q
8 @8 S! e1 g6 ~) T            /*System.out.print("第"+i+"次遍历：");
            for (int i1 : arr) {
                System.out.print(i1+" ");
0 h( g( S1 V( v            }
            System.out.println();*/

2 f: k2 L, _# g* y3 }4 U6 M3 N
            flag = false; //假定未交换

: b: _; N. b+ d% c3 s
            for (int j = 0; j < arr.length - i; j++) {


) {8 x; X4 |# B+ [/ Y) M/ h: }                if (ascending ? arr[j] > arr[j + 1] : arr[j] < arr[j + 1]) { //控制升序还是降序
* w: f5 T0 l6 H5 P! {                    int temp = arr[j];
  j. t+ X4 p2 t0 q                    arr[j] = arr[j + 1];
! Y7 q8 ^* t5 }5 F2 D                    arr[j + 1] = temp;
  b! L; r4 T% l5 k1 W- ]                    flag = true;
6 E+ q) R& i% C( S6 v$ ?+ ]                }
! k6 Z- P- H+ ?; C
8 Y8 j4 n( `& e% k
            }
+ W1 Q/ a2 a2 m        }
    }
! z4 h0 k- U, W! O% i' e" `

    //冒泡排序 -- 默认不传参升序
    public static void bubbleSort(int[] arr) {
- J6 s1 c# v7 h  l8 X( T        bubbleSort(arr, true);
    }
}
1
2
3 g2 q, O" \3 P7 z/ \2 M$ o3
% ~2 ]! E* v8 x' o' j- {+ R4
5
6
1 w; ]( h6 M" C3 Q* w7
8
9
10
  ?7 E+ n0 D8 m+ ?+ Y5 W11
12
2 p2 m/ K' |7 n' r1 G13
8 b" u! y* H- ?14
3 U9 P/ I- a' R; ~15
: T, |1 n3 T, A+ x- A16
17
: i& r) a% G% p2 ?* {% p6 q18
! E' s  y0 ?& W7 q6 M6 y9 f19
/ f( ^! T& g/ @+ Z6 m20
# ]! L* |; l, V/ O! Q21
22
23
24
! K! Q7 l. j! ~' ?7 F25
4 a3 F9 P+ ?6 ^26
0 q  r" t" f6 W  ^2 ^27
2 M" D* \# G: S. Y, J- d" W28
9 X" v; v% M8 q% e( V" b: C1 ~- ?29
' ^/ M8 A2 n2 r5 j5 J, f30
: e% s5 O: {6 [5 ~31
32
33
34
7 j, _: w' k. K  s- _4 t35
; u$ `! |, O. u, }9 c5 B3 v- f36
37
38
" |7 U: E$ C6 C$ q39
40
41
42
43
) J% ]; @* P- f# o4 |44
7 y1 L) i# [) h; q45
2 L! Y. ?# h1 b4 A测试代码：
& a" P2 N% W8 v0 I5 ^

升序排序（从小到大）
$ r' u8 x+ S( z! O% Y: q" o) x

package com.keafmd.Sequence;
' k: G  a& }" C7 ?
8 a+ k! Q1 R8 A$ G* T
import java.util.*;
( i2 x$ i1 |/ }' a! cimport java.util.stream.IntStream;
import java.util.stream.Stream;

$ b( _* V0 [2 U7 o
/**
8 ?7 c7 z, j2 D/ E * Keafmd
$ O1 x5 m0 C- g4 I( }2 v& t( v) M4 ]9 R *
* @ClassName: Sort
* @Description: 十大排序算法
* @author: 牛哄哄的柯南
* @date: 2021-06-16 21:27
*/
6 T9 Z2 d% y5 F( u+ ~  zpublic class Sort {
    public static void main(String[] args) {


! C" Q" ~" a; [! A" H" i        int[] nums = {12, 4, 25, 47, 58, 34, 25, 9, 99, 26, 1, -13, 162, 10093, -66, -1};
        int[] temparr;
  V3 d3 p$ h* i0 `' o
: @9 N6 H1 {0 r: P0 L1 W! I) }
        //测试冒泡排序
3 V0 y% Y  D7 ?$ I( K% B        System.out.println("测试冒泡排序:");
        temparr = nums.clone();
7 [6 V/ n2 b& U$ R5 P8 [8 k. g' n        BubbleSort.bubbleSort(temparr);
) G1 y. ~( _0 z: U8 ^        //逆序排序
        //BubbleSort.bubbleSort(temparr,false);
; o. o0 M4 X8 [1 q) p5 q- \        for (int i = 0; i < temparr.length; i++) {
            System.out.print(temparr + " ");
; q3 J! R: Q1 N' ?* \# u& a: c        }
; ]; @+ ^2 ~$ o/ s# L        System.out.println();
+ K/ }- t4 A$ \& Y5 M

1 v3 F% C, h' P    }
, e9 y$ u' ~1 H9 x; f: x}
* ~9 v+ O1 M, }3 j7 X1
  x0 b1 r2 t3 B, x( v  U2
3
4
5
6
7
7 s" O/ C2 M! l7 o5 ~8
- e* T: \$ q# n% B9
10
11
12
13
14
8 y2 X9 E) A: T2 x' f15
; }$ K& Q* |; s3 g16
8 M- G: q3 m1 I. S( p- D4 j8 X17
18
& H0 l; w3 b, o" h) z19
20
( |5 p6 C; ^% a! ?5 }- t21
* v6 L) Z- D) w1 j22
23
24
6 ~% ?2 V  @  ?# R, K3 D9 W25
& E- D' O2 Q' v( Z4 `26
27
28
29
  H. H: {1 P: h6 q+ K5 _30
' `/ F' z6 H) n8 v2 ]31
" \4 C" E. q7 X* ]1 F3 G32
33
% A( \1 L0 p8 o+ D0 {  z( @运行结果：
9 R6 |7 G0 ^+ C5 t* _" w( A
2 ]5 u# Y$ ?7 i2 R" |. w% v( `. X
3 X5 h1 k) W# g6 A; X) f; C测试冒泡排序:
-66 -13 -1 1 4 9 12 25 25 26 34 47 58 99 162 10093
/ [1 ?) g! y/ C5 [1
2
. d; d& V2 e( T$ z* @降序排序（从大到小）


//测试冒泡排序
System.out.println("测试冒泡排序:");
temparr = nums.clone();
BubbleSort.bubbleSort(temparr,false);
for (int i = 0; i < temparr.length; i++) {
    System.out.print(temparr + " ");
" {3 |7 }! `( P8 G4 `5 X6 v}
+ z" @& I4 S. m1 CSystem.out.println();
2 Y: K& ^: H* w1
( k# k1 Q# Y' J5 x% u  x- J2
3
6 }& K6 m. A: e! W! V$ D4
5 L4 r! z; M! X5 H# [5
1 b+ E& ~! g4 Y: B1 B9 S6
7
8
运行结果：
( n4 X6 t1 u4 z( e6 z9 z- T
9 M- A' u+ K) I* s' `# F6 L
3 r* X' |1 H5 Q; c& s& k* T2 D测试冒泡排序:
10093 162 99 58 47 34 26 25 25 12 9 4 1 -1 -13 -66
1
2
下面几个算法的测试也就是换了下类名和方法名（换成相应的排序算法），如果想降序就在数组后面传个false即可。我就不一一复制了，我在最下面给出含所有算法的测试类，需要的自取即可。
! S% D  u/ p, m5 X9 o8 ?% v

快速排序
4 k5 U. `: V5 U2 P4 y3 P! c4 t简单解释：
快速排序就是每次找一个基点（第一个元素），然后两个哨兵，一个从最前面往后走，一个从最后面往前面走，如果后面那个哨兵找到了一个比基点大的数停下来，前面那个哨兵找到比基点大的数停下来，然后交换两个哨兵找到的数，如果找不到最后两个哨兵就会碰到一起就结束，最后交换基点和哨兵相遇的地方的元素，然后就将一个序列分为比基点小的一部分和比基点大的一部分，然后递归左半部分和右半部分，最后的结果就是有序的了。

  n# t3 Q: y+ K7 E5 z


# P5 S$ i) p$ m- r! I7 d

8 U2 O' c4 w& M) Z; u' E, _完整代码：

8 |3 C3 f5 }8 |5 S$ d
( W  }( [) y+ a% F7 ]' x7 N5 `# U) cpackage com.keafmd.Sequence;

/ G$ C8 i3 V2 k! i  T! b! k) a
/**
' U  D2 c0 y. [8 l3 B% d* P/ L * Keafmd
5 d1 F0 q% \! d' n8 \# z  x& \ *
* @ClassName: QuickSort
* @Description: 快速排序
* @author: 牛哄哄的柯南
* @date: 2021-06-24 10:32
*/
public class QuickSort {
7 |: H. s. r9 }$ P2 x5 [+ n3 f  d

    //快速排序
" S! T/ W3 A% Z" i& U    public static void quickSort(int[] arr) {
8 L/ }/ R1 X  R) d6 _( ]6 n        quickSort(arr, true);
0 o& z8 r5 q  f$ I: m4 F    }


5 G! b2 A! J4 m) o1 L    public static void quickSort(int[] arr, boolean ascending) {
# \. s. r* L8 K5 I+ e+ \; ]        if (ascending) {
% A3 K7 C1 s! |# T            quickSort(arr, 0, arr.length - 1, true);
8 Z# c# s0 }2 m1 M, O9 D7 V        } else {
            quickSort(arr, 0, arr.length - 1, false);
* z! x  b6 f) D# q8 {4 u7 y* u+ [        }
& N7 d/ _4 R/ n9 e    }

$ X: R- U& I4 E
  P/ z' ]7 w' k: |! Y    public static void quickSort(int[] arr, int begin, int end, boolean ascending) {
4 F! r5 r# j3 [1 @( l; s        if (ascending)
            quickSort(arr, begin, end);
- ~1 s, T8 M$ T, E: D( _# V        else
            quickSortDescending(arr, begin, end);
    }


8 v  j  T7 I8 F* b4 P8 M8 _+ }    //快排序升序 -- 默认
" G! |- M+ q4 P! V1 Z. I/ F: W% F    public static void quickSort(int[] arr, int begin, int end) {
        if (begin > end) { //结束条件
: C5 n' m. k; t0 |, T0 a7 L            return;
        }
        int base = arr[begin];
        int i = begin, j = end;
        while (i < j) { // 两个哨兵（i左边，j右边）没有相遇
            while (arr[j] >= base && i < j) { //哨兵j没找到比base小的
. D* W1 u6 y# ~; |( Z                j--;
            }
            while (arr <= base && i < j) { //哨兵i没找到比base大的
                i++;
            }
* ]8 u* M2 o. ?- q            if (i < j) { //如果满足条件则交换
                int temp = arr;
                arr = arr[j];
  h, K2 [+ c1 c8 [- z' m" z                arr[j] = temp;
2 j: D- `2 G$ q, b  O# j# j            }
0 F/ }0 x( g0 ~$ L6 u
) K4 w6 w3 Y( ~) C+ r1 P
        }
        //最后将基准为与i和j相等位置的数字交换
        arr[begin] = arr;
  S: V4 p' O2 m3 j( E! o7 @        arr = base;
6 t* c3 n; m- C/ [, _        quickSort(arr, begin, i - 1); //递归调用左半数组
9 S( B8 `7 V: |) z, f        quickSort(arr, i + 1, end); //递归调用右半数组

8 r: ?3 d& l2 C; o- k* w0 M5 W
    }
' V9 W) e  D( m4 J
* y6 w, g+ r8 Y& l. ^. m
    //快排序降序
    public static void quickSortDescending(int[] arr, int begin, int end) {
        if (begin > end) { //结束条件
            return;
3 Y" n) V9 k' f( P5 K! V3 S        }
        int base = arr[begin];
        int i = begin, j = end;
( t7 W; G' i# M  U$ T0 z9 D6 m        while (i < j) { // 两个哨兵（i左边，j右边）没有相遇
            while (arr[j] <= base && i < j) { //哨兵j没找到比base大的
6 Y; [$ Z6 v+ }. Y, O+ `* y; Z                j--;
            }
% V0 f+ Z* w7 A# B6 W            while (arr >= base && i < j) { //哨兵i没找到比base小的
                i++;
/ h1 p4 R3 i3 V- ~' O            }
            if (i < j) { //如果满足条件则交换
                int temp = arr;
3 I8 k) l' [! D& c, H                arr = arr[j];
+ L3 ?3 w% U0 |% g( d- {3 B- `& E* t                arr[j] = temp;
            }
: ]0 o8 c6 j9 F: `

- B9 |( \7 g6 g6 q        }
) ~: w2 B0 q8 P* f0 g- ]$ v        //最后将基准为与i和j相等位置的数字交换
        arr[begin] = arr;
5 d, V5 T5 A# a        arr = base;
' \9 ~) Q* H1 h        quickSortDescending(arr, begin, i - 1); //递归调用左半数组
0 w+ L+ N% V' L9 \        quickSortDescending(arr, i + 1, end); //递归调用右半数组
) L4 L& d4 m3 F! Z' c
. d" Y: h4 L# S3 }, |7 j
    }
( V4 E* p- ^- O
  N2 B( j4 z7 q# P: [. i7 i
}
1
# ?* w* B5 ]$ Q% X$ M2
# q! s1 o+ p- V: R# v3
4
5
1 R0 h" R+ I+ S( m: m6
7
% B- z4 _1 j3 V! `# r  r! p' O3 c8
9
10
+ y8 o% o0 K3 P; b7 z0 m11
: S# Q7 v6 W1 v' Y9 h; B6 u, f12
) Z  L7 W% U5 m" X13
, p/ W3 A% J8 U* i! I14
0 o; w( J  E% X# S15
16
2 W  Q( ?/ C, f% \5 p17
0 U  Y# i2 @4 M! r* I1 g18
' h9 q  |. r4 i7 l9 `6 V$ Y19
, x7 H( [) L' A  f' D; R. p8 t8 s20
* I# V# j3 V9 F; C1 W' ^7 h& z; S21
9 w8 U' }5 U9 A22
2 I+ e" e3 ^0 n1 d: W3 Y4 ]% |6 M1 L; I23
# T6 ?$ o7 n- _5 o+ s- G+ @# T24
6 N3 x: Q4 ]( Y/ l& O/ X25
26
27
* i: l6 j, C4 i2 p; O( d28
29
30
8 a3 x4 E$ M. u5 t31
; B( C- |) ?+ C% U# I) K32
33
7 T4 i7 T" H. G4 ?* T2 ~34
% i$ t3 g4 P# v* j8 G6 b/ }! C35
36
% n% ~6 i% M% k- k4 T37
$ t* R. a- y& I38
39
1 ?  `, S  `% n) j40
( {/ `5 V% n! r4 t/ \7 R3 z41
42
43
44
1 c' p' _! k; |% N. ?45
# t% g( G2 p1 c+ v' }# d4 Q46
47
- ^7 P& i$ c1 `8 u# K5 ^48
49
50
% v% t; {) F$ H$ d51
52
% b3 I8 O( h. M5 I, M53
54
; W! s% O8 g+ m8 s4 N55
- ]+ D  O' |( i( y56
57
58
- ]+ h2 E$ |9 w4 H1 S59
60
61
62
+ T+ R0 b+ T/ x& J63
8 f6 Q& q5 k. S- |64
65
66
  i% L0 h! C$ N, n" u9 h67
68
9 K+ m/ T# w) K: `% i- p, A69
70
; \  d- k' w3 L% k% u71
2 Z9 X3 Y, c8 H0 O6 V72
1 ^/ Z% {4 }; ~/ V; P& h73
74
+ |, j0 a2 O2 v- Z; Y0 W* ^# v* F75
76
5 _! O4 E# ]- s! A7 C. L7 l. d77
78
) }1 J1 P' _0 j9 F0 A79
& J1 H1 j" g7 ]: g) [9 {80
3 u9 [' o) a$ ]: T# m& w% G81
+ O& }6 D5 a7 X82
, y/ q/ }' n2 D$ U$ j$ w83
* \! `5 ^# f5 v/ A84
, C1 B8 c$ X% `3 h) k- ~8 e85
86
87
88
89
90
- S5 m: b8 }; U& E91
3 @: H1 X% y3 S' ^直接选择排序
2 A  a1 @& K; ?简单解释：
数组分为已排序部分（前面）和待排序序列（后面）
; X% o; Z, `6 Z. V第一次肯定所有的数都是待排序的
从待排序的序列中找到最大或最小的那个元素，放到前面的已排序部分，然后一直找，不断缩小待排序的范围，直到所有的数都是已排序的了



. J' ?7 S: G! N$ |- n, O$ d
7 b$ M) s. D- A, o  H/ B1 t0 }

完整代码：

$ u2 H1 r4 v9 L& d  Y0 T
6 U9 O! U: F/ dpackage com.keafmd.Sequence;
) Q- s- M: V. ?6 L( _

7 R, B4 N5 u7 p/**
* c, H( x8 M% c- ~# N. H- C2 |1 P * Keafmd
*
4 l4 Y: H/ t/ C% n/ Q' _ * @ClassName: SelectSort
* @Description: 选择排序
3 I) ^$ x! u; u+ \+ H * @author: 牛哄哄的柯南
* @date: 2021-06-24 10:33
2 E: l- s6 }/ ?/ U; \/ T */
public class SelectSort {


    //直接选择排序
    public static void selectSort(int[] arr, boolean ascending) {
" x% h7 R1 ]  f        for (int i = 0; i < arr.length; i++) {
            int m = i; //最小值或最小值的下标
5 p+ d8 ]* j& k( X8 T; S" ^            for (int j = i + 1; j < arr.length; j++) {
. X- `% q7 z1 C; [                if (ascending ? arr[j] < arr[m] : arr[j] > arr[m]) {
                    m = j; //找到待排序的数中最小或最大的那个数，记录下标
                }
$ I! ?0 @3 ^+ N9 x; k

; r) U- j/ Q7 j0 h* c2 H4 G            }
, z5 `  d  y8 ~            //交换位置
! m/ ]+ F7 `: y            int temp = arr;
$ g$ h, u& m- s$ r/ `2 r4 Q$ d6 }            arr = arr[m];
            arr[m] = temp;
' G& q" a+ u' h

+ {. o# P1 K2 Q. X$ L        }
    }

) m% U7 e# [1 w9 A3 }2 w) l, @  b
+ L- u, y. x$ f* i    public static void selectSort(int[] arr) {
        selectSort(arr, true);
- s, P- M, [* v+ ?    }
}
* H# d  e( d5 d; z# X% v) }' o. ~+ o1
2
# V& J" a; u' F, w7 e3
4
5
6
7
3 w/ x- l8 Y& o' B! r! m. ~, ?8
4 p/ C0 G5 N$ @8 g) d5 m* ~9
10
" k4 E6 z1 V1 s11
3 i5 [1 d, \- c* R12
13
# O, m* t. u6 V0 b14
4 P" L5 M. o* r0 R9 ?5 x9 ~15
16
9 R: L; a0 f  H3 j3 y9 P* E: _17
18
. x; c% h/ H7 U& ]6 i+ x19
( u/ V/ V1 X9 u4 w; @- P' |3 j4 n/ b% d20
21
22
23
. G# H; J1 f- v$ F+ d% n24
25
26
, T( _- m# t' V6 C# E27
, `' P4 Z+ B- Z+ f28
9 v) \* Y4 {' k" ?6 P! {, O29
. E0 R4 c/ M( h4 z& w$ v3 A* m30
31
32
33
) T% y! A* U, r+ c34
堆排序
先理解下大顶堆和小顶堆，看图
; {4 K# d' g0 u6 g; j% s/ n大顶堆，双亲结点的值比每一个孩子结点的值都要大。根结点值最大
& Q3 ?1 o. w% w4 U6 Z小顶堆，双亲结点的值比每一个孩子结点的值都要小。根结点值最小

8 V2 f# r) h7 h- N
0 Q5 B# \! Z& |. n& B( v
- H- w; i* u2 [/ Q9 A) I! J
, ]% t5 K5 o* o1 t7 [: _6 i简单解释：
; m4 A/ ~( c- E( L" B5 v构建好大顶堆或小顶堆结构，这样最上面的就是最大值或最小值，那么我们取出堆顶元素，然后重新构建结构，一直取，一直重新构建，那么最后达到排序的效果了。
0 q" V: }$ A* l1 \, N& X
) F( X' B/ _) g% z& d

$ s) n& w  j! D) R  v" L1 A- v; T
" V" m0 b$ O- T0 a, A) k

( i- v& E# w: y3 \$ F& n; f2 @# z完整代码：


! n0 {( G5 J7 j. C1 S3 K+ Ppackage com.keafmd.Sequence;


/**
* Keafmd
: G2 }8 G$ u  Z8 s  i9 W *
* @ClassName: HeapSort
, d! J; |( J' _6 T: ] * @Description: 堆排序
* @author: 牛哄哄的柯南
* @date: 2021-06-24 10:34
*/
public class HeapSort {
0 ^+ f: x. \6 U" L
( w+ L9 t" n! L$ i, ~! @  j$ ]
    //堆排序
4 m7 S7 k/ h& H6 t) l: }" f    public static void heapSort(int[] arr) {
        //对传入的数组进行建立堆，这里默认建立大顶堆，进行升序排列
        heapSort(arr, true);
    }

* z! d7 f3 f6 s1 ?  s
9 M8 c/ C! K; x. Z    public static void heapSort(int[] arr, boolean maxheap) {
0 ?  O; i  R0 V1 w
( a% Y* A$ b5 a% V- \% M
+ Z" T# [- S9 m1 \+ c1 T* U        //1.构建大顶堆
: u( I4 v1 O7 F* z        for (int i = arr.length / 2 - 1; i >= 0; i--) {
" z5 j1 p& z! [  v) o# U# h            //从第一个非叶子结点从下至上，从右至左调整结构
" @& ?& [# b# p3 f4 X            sift(arr, i, arr.length , maxheap);
8 U. T# `6 }6 O        }


        //2.调整堆结构+交换堆顶元素与末尾元素
        for (int j = arr.length - 1; j > 0; j--) {


+ t4 x' M- p( O/ B5 H0 q3 v+ _            //现在的数组第一个就是根结点，最小值所在，进行交换，把它放到最右边
) H) Q; e  e4 t+ H0 o" ]            int temp = arr[j];
            arr[j] = arr[0];
4 i; a! a* V- W6 |0 ^1 G            arr[0] = temp;

# {8 c% W# J8 [- W) w0 W& n
            //重新建立堆
            sift(arr, 0, j , maxheap); //重新对堆进行调整
        }
    }


    //建立堆的方法
    /**
     * 私有方法，只允许被堆排序调用
     *
     * @param arr     要排序数组
6 C8 V4 S  \  b     * @param parent  当前的双亲节点
     * @param len     数组长度
     * @param maxheap 是否建立大顶堆
     */
    private static void sift(int[] arr, int parent, int len, boolean maxheap) {
: x1 ^$ M, w& ~4 l: [

& ]0 j1 S; B# H% t6 ]        int value = arr[parent]; //先取出当前元素i
) m, |- U$ E: a
) N/ j* G+ {  F; P5 l
( D1 ~! G+ A1 U: H* v) Z/ ]! @1 H        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 j& e2 g1 c4 y, S7 O5 A$ r
1 `6 v5 X% g; j% m$ F
' \% n4 y+ y4 a            //判断是否符合大顶堆的特性， 如果右孩子大于双亲，自然左孩子也大于双亲，符合
            //如果子节点大于父节点，将子节点值赋给父节点（不用进行交换)
$ [$ C6 S/ @) p+ _            if (maxheap ? value < arr[child] : value > arr[child]) {
                arr[parent]=arr[child];
; B" N5 r! Y( h/ q                parent = child;
+ D2 x( p) i# ~% X            }
            else {//如果不是，说明已经符合我们的要求了。
& `! L# m5 v$ L  z                break;
6 h! \3 ?" F+ N. ~            }
: e0 F' {! T8 ]3 i# J7 T/ W9 \        }
/ H& s# x# ?( p  g4 {  V        arr[parent] =value; //将value值放到最终的位置

! B' ?1 c! k4 Q- v, ?, V6 f
' L8 A( y8 G- C2 ?6 ]" z4 D

    }


}
1
" s! Q# X' b  S. B6 Q& @2
3
" y2 {2 {- N# `" Y2 k9 y; G4
5
* N. Z8 N3 G, f3 S/ b% H  c6
* n0 I$ Y, M/ R1 y  C7
/ i- C! H1 I4 M6 @. K8
9
10
) p* J$ A# e* h0 V- {6 f0 T( W11
) p1 U  |$ n  q12
13
14
15
16
17
1 t& Q0 ^: m3 T) N+ q, ?5 J8 A2 y9 Q; q18
19
20
6 y, g9 R- N3 E21
22
: P% i" d: j$ D: D" R) ]23
24
25
* V3 ^- _6 N2 O7 L0 w26
2 |9 `- R& F. c( q. Y27
28
29
* p7 I' D6 ]$ a: S! y* X+ N30
. h: T6 d& L* z6 `9 J31
# Q" a, |5 p' \32
; v  x! K& L! ?0 m; Y, w33
* z, n4 U" {& d( s/ y9 D  w34
35
' ^5 m* A. h& p4 |- J" @36
! G) d- I$ I* g  d. I  q9 K37
8 @0 M5 b  e; l( L& v# [% z/ v38
4 ?4 Z$ ]0 ^7 ?5 Q* N4 S9 t* {39
  P! [& U  k. O: Z8 V. k40
41
3 x( l0 l3 N3 ^6 q; \# {42
43
44
45
" i/ ~8 e4 Z, c% H( |46
47
48
; d( f# R2 E. {! B# }49
50
51
' h. n1 k: _5 s3 |( p8 S! V52
53
54
55
56
57
7 A4 h. }( w# m, `& a; `58
59
60
" k2 K+ Q( n( Z2 A1 a+ o+ `1 F/ W61
# r. z4 L# _7 y( C! h/ N$ j* h& |* B3 N8 i62
2 N7 i, K" H1 d3 i63
3 p1 [5 J' F( h* o9 F9 K64
65
66
0 p* \$ w; q) h67
68
& N0 R# |6 ^0 ?69
2 A3 ^) N9 o6 D8 q$ Z70
71
. z, T5 I: }2 I& W72
, [0 f- o8 [2 W, Z) b: ~7 [73
/ I1 c+ i" X8 h+ ~74
2 Z/ K5 ^' n3 a, E; U/ g0 z归并排序
简单解释：
( F- D% d6 n% O7 V- J该算法是采用分治法，把数组不断分割，直至成为单个元素，然后比较再合并（合并的过程就是两部分分别从头开始比较，取出最小或最大元素的放到新的区域内，继续取两部分中最大或最小的元素，直到这两部分合并完，最后所有的都合并完，最后形成完整的有序序列）
( u  ]2 ~# K9 s! z3 T8 x1 b) G
6 k; t9 V7 x" |. z( }
% P7 I" g6 |+ u* _" f
1 k4 F" u5 W$ Z$ i# B0 {# k  L
) G/ i/ o9 K6 ?" c) Q. p# c6 {
8 M2 N- ?, K) F. N4 d% s+ ?! ~
) y8 N; D! @7 M" A8 N完整代码：


( k3 ]7 j, y8 {$ T; Cpackage com.keafmd.Sequence;
" ]8 |2 ~- R) ?5 d  R% c
$ M% D+ D' J" a- }; b. V
$ _0 ]+ S/ {9 {' H' ~) R! p6 `$ @$ v/**
* Keafmd
*
% q9 \3 Q9 a$ a1 H2 Z * @ClassName: MergeSort
* @Description: 归并排序
% R) t' o( l' D$ M * @author: 牛哄哄的柯南
* @date: 2021-06-24 10:35
8 }( p1 @5 x& t  n4 J */
public class MergeSort {
% ~$ g% |4 ~$ N

    //归并排序
) |' q$ @! w- g) u; Y7 M8 d    public static void mergeSort(int []arr ,boolean ascending){
        int[] temp = new int[arr.length]; //在排序前，先建好一个长度等于原数组长度的临时数组，避免递归中频繁开辟空间
7 _+ v" z' T7 D        mergeSort(arr,0,arr.length-1,temp,ascending);
    }
9 Q8 ?/ b+ ~5 r4 p& _; v* r. R9 |    public static void mergeSort(int []arr){
4 a) S# R9 I( @4 t6 D        mergeSort(arr,true);
- }. v( a0 l" L: o% p/ p    }
/ O8 w5 E  m) j% G6 |
& f4 }2 ?4 }1 u
    /**
0 r& Y; U7 Y9 L4 E     *
8 H. f/ X/ ]8 I- B     * @param arr 传入的数组
6 M) g  k% @0 d# w     * @param left 当前子数组的起始下标
     * @param right 当前子数组的结束下标
6 m2 n$ A# v& f. |1 w" B* ]     * @param temp 拷贝暂存数组
+ l4 D7 X7 o  O2 a     */
0 N9 Q+ l5 O* @3 v5 M" b( r    public static void mergeSort(int []arr,int left,int right,int[] temp,boolean ascending){
+ k6 Z, V. @% ^. D3 }        if(left<right){ //这里是递归结束的条件，我们是对半分，那当left==right的时候肯定大家都是只有一个元素了。

% _' G. `' T4 m$ ?6 d
2 V0 q# `9 ^: Q* C3 L            //对半分，比如总长度是10，left=0，right=9，mid=4确实是中间分了，0~4，5~9
3 B' N$ m2 w. X" w0 Q            //当长度9，left=0，right=8，mid=4，0~4，5~8
            int mid = left + (right-left)/2; // 防止越界的写法
, M$ Y& [; @1 z2 W5 ^8 l* J            //int mid = (left+right)/2;
8 n3 ?% N( ]! m
8 N: h7 {0 q3 r1 h0 Z/ v4 {9 ?
            mergeSort(arr,left,mid,temp,ascending); //左边归并排序，使得左子序列有序
) _, O& Y! C; t7 q8 J  F            mergeSort(arr,mid+1,right,temp,ascending); //右边归并排序，使得右子序列有序
% W0 l: V- `+ Z! S, `- A
2 @7 _- ]" k. R
; e. {+ B  M) W; g            merge(arr,left,mid,right,temp,ascending); //将两个有序子数组合并操作
        }
: }. r/ B4 Y& x% E- o+ M& S* g    }

3 n! x. z' o6 f$ G
    private static void merge(int[] arr,int left,int mid,int right,int[] temp,boolean ascending){
. B$ u) y# z3 J$ v8 |2 Z  O4 F2 m9 q        int i = left; //左序列起始下标
        int j = mid+1; //右序列起始下标
6 s3 S9 X3 D9 y; ?1 I' g( l7 O; F        int t = 0; //临时数组指针
        while(i<=mid&&j<=right){
( ?0 _2 n. V2 e0 x3 z3 `% }            if(ascending?arr<arr[j]:arr>arr[j]){ //比较两个序列第一个元素谁小，谁小先拷贝谁到temp，然后对应子序列下标加1
6 @, l9 A2 E8 V0 L- n2 B% F                temp[t++] = arr[i++];
& T/ r3 ?( v) X. A, c1 S            }else {
                temp[t++] = arr[j++];
5 s& a6 U+ p  \            }
5 c2 V* K- E) y" g( |$ V$ ~        }

5 B* Y/ o* {, ]% u. z% h
        while(i<=mid){ //将左边剩余元素填充进temp中——左序列有一些数总是比右边的大的数
            temp[t++] = arr[i++];
        }

5 c2 r  o# H/ s) ^! {
        while(j<=right){ //将右序列剩余元素填充进temp中——右序列有一些数总是比左边的大的数
- d2 h! m+ W/ O; d3 d/ }8 u% X% K            temp[t++] = arr[j++];
        }

- i( C2 O% c$ Y8 ~2 k, p: w" {
        t = 0;

9 F# V. Z. q4 o9 p
  d$ l& `2 D: Y+ S        //将temp中的元素全部拷贝到原数组中
        while(left<=right){
            arr[left++] = temp[t++];
& c! b- t5 S0 t3 P( _9 M' X2 z% m        }


    }


}
1
" U+ `# W: `& o. i( k9 U. `2
! i+ J& i& g- v$ Q8 R3
6 P/ N% c* g; r0 D4
6 G7 @. U8 c( J# S# i5
2 ]: y1 A) P' c7 v8 d9 X6
7
4 e7 D0 c) H' q5 J6 M8 Y* S& }8
9
  e8 M8 {6 {: N) y9 G- s10
11
9 Q/ `2 }8 H; a( _3 ~8 _12
13
14
15
5 i+ a) o" b7 l; w5 b: r0 D- ?16
( F+ f: H8 Z. l4 x* w' P0 T$ I17
1 Y* q% [; w0 j0 M18
19
8 z; ~: y: x+ \" m( H2 r, X/ N20
+ j4 R, ^7 t$ x% X2 \3 {/ f21
22
& V* [3 V# r! Y1 G' T, I  x) I23
24
, z: L5 A3 d6 n- X25
26
27
- a) A+ G# t1 A4 O28
29
30
3 ^& a* }. {! O7 Y5 B31
32
4 Y9 b: u: b' u9 \) ^: v3 n6 B33
34
6 w+ s& {+ x$ f5 n5 l) }4 d% @2 S3 B35
% \8 d* n, O+ u( B5 v$ o& m36
37
38
  ]; ]$ c2 T$ Q4 l39
40
2 A- p8 n7 N+ s41
9 S, c7 {7 h) b5 [  F42
43
44
45
46
47
- ~2 n: n4 ]+ b; z% _. g& J48
49
50
# q8 l, y: n( E% p+ ~/ N# Z51
52
& B" l  H7 x: I! Q  h& K53
1 u  b/ n5 B+ @% m3 ^; Q54
55
56
57
2 O# u. v3 W& Q58
) C3 f0 B: g9 t; K& Z8 I1 E% ^59
. [7 |8 E( f/ i: v60
61
5 F) b' }5 Y; s# `5 p3 i% L- R62
8 Y" a" b6 j  A+ ^) F" m  E9 x# t63
  i% j: ]6 Z" x0 T4 `" C2 p: N64
3 M  I/ P% `. h2 P3 @65
66
67
68
69
4 [6 V/ x4 }- [! M; q70
71
/ @5 e# P" G- C8 T9 E72
9 O8 y& X9 f# P' v" r7 Y1 z! S7 u$ h73
插入排序
! d6 @' B2 B; Q( ^2 {" S: p简单解释：
) u: \4 F0 p) F% x8 }2 x# H最简单的理解就是打地主时我们拿到牌后的整理过程，从第二个牌（假设我们拿起来这个牌开始比较）开始，（说下升序）从后往前比较如果比前面的那个牌小，就把牌往后移动，直到找到一个合适的位置（这个位置的前面的那个牌不比这个要放下的牌大）就把这个牌放到这个位置，慢慢的前面的部分变得有序，直至全部有序即可。




8 R- N( N/ Z- E3 g9 E
$ w& M( l' G0 ?9 k- h/ D/ R( {
完整代码：

: {0 w5 U* d) O' X/ i
package com.keafmd.Sequence;


3 W7 k8 x. p, T7 G/**
* Keafmd
*
* @ClassName: StraghtInsertSort
* @Description: 插入排序
4 ]( i$ u) S3 r, |. Y1 W6 H * @author: 牛哄哄的柯南
* @date: 2021-06-24 10:36
*/
, }& w0 N: L4 ^# ^; ]2 c) w) Ipublic class StraghtInsertSort {
    //插入排序
    public static void straghtInsertSort(int[] arr) {
( e. M; o( g- l9 `6 p! j        straghtInsertSort(arr, true);//默认进行升序
+ {5 }1 p; e& l4 |6 a/ Q    }
- @9 r* a& z* r! d& F
/ Z1 a" m7 ~& S+ S  }
    public static void straghtInsertSort(int[] arr, boolean ascending) {


        for (int i = 1; i < arr.length; i++) {
            int temp = arr;
  Y2 ]4 ^* I! m            int j=0; //这就是那个合适的位置
. A( ?! F1 p; }; |8 l/ }8 P            for (j = i - 1; j >= 0 && (ascending ? temp < arr[j] : temp > arr[j]); j--) {
: l% o" Y0 x  U$ o  B                arr[j + 1] = arr[j];
& D6 s( J* |& G5 I' B) S5 T            }
1 a: l" P6 g: H. n! R) C            //把牌放下，为啥是j+1，
8 T& z5 d9 [- ], P( E; f+ T            //是因为上面的循环遍历到不符合情况的时候 j是合适的位置的前面的那个数的位置
' m" t( c, f' I( e6 f; f            //有点拗口，但是就是这个意思，看图方便理解下
) `6 V$ u, _7 f$ S            arr[j + 1] = temp;


+ O2 i+ k9 D& j# P3 e( ^. z
! k5 G, r- U; k% E0 x# r$ U0 H
- n  M( t! @6 O        }
* y; ^/ O- G! q6 Q

    }
}
6 N/ W% E$ l2 `, U) l, k+ @  y1
; C# A  `+ A, a1 n9 V  o: ^2
$ I/ D9 A$ ]' y, P$ H3
; ^7 d0 M/ J- S0 X' Y6 x4
5
6
% Z. k0 U4 K; I- ~, R1 A" O# x7
  u, `4 n0 F5 ~4 g4 P0 \" N8
0 d% t9 V7 [( I- _0 T$ j" b9
( n" b% S/ U5 h  ?7 c10
11
" M3 N8 T0 Q2 H5 g7 f# X  c12
13
, F  m. M. K8 A' M6 p; {! `14
- E, k+ L+ k, o; d0 l8 b; ^& R9 @15
" R& H# q9 K/ ]! r16
17
18
: V  N' K: ]! ?7 S( N; H  a19
20
21
; V4 K6 Q' m, {( B- G$ l22
2 ]/ |! h  K( A1 a23
/ Z  R* N; E0 T' W24
25
9 u( y; [9 ]  A  y: r26
27
, N" A/ p4 p- a$ W  \  k! U28
29
5 V0 a: j+ ?5 V2 j8 S/ H" z: Q30
1 U+ S5 G" e# Q; a9 ~8 P0 n31
! N: o4 w7 o' \7 i2 ]9 {. ~0 B; h) C32
  i$ o5 n" q2 p, e33
34
/ F9 d7 Q2 c# z# I  o# ]希尔排序
简单解释：
1 a+ S6 T: @3 L2 E2 `( j/ [0 r希尔排序是插入排序的改进版，我们理解一个叫做下标差的的东西，也就是下面那个图中的增量d，初始下标差为arr.length/2，然后继续/2，对在同一下标差（相当于把这几个数单独拿出来了）的若干个数进行插入排序即可。
$ P& P$ j; b4 _0 h+ {0 p8 p
9 |8 K& T8 F* S, C- L
( F! @5 d. S( {/ X% ~4 m
- d4 V3 q! ^5 B4 }% w; y7 L2 _

% B  c1 }- j+ j! S) A$ G8 [
9 W3 L0 T6 B3 Z9 O' H6 t- N完整代码：


package com.keafmd.Sequence;
+ D) z0 r. b" l  |

& Y# q% c2 B* R5 O! U/**
0 U4 @: v0 z( b, ] * Keafmd
5 ~3 G; ?2 f7 F; [3 j7 }' y *
* @ClassName: ShellSort
* @Description: 希尔排序
* @author: 牛哄哄的柯南
* @date: 2021-06-24 10:39
. F9 Y1 H; T3 Q */
. {% C) y4 k. `" d% Fpublic class ShellSort {


    public static void shellSort(int[] arr) {
3 ]7 F, I9 K# g: w1 Z        shellSort(arr,true);
    }
4 k/ C' ]" P% v  R7 B
, c* q0 w2 K, S9 `
    public static void shellSort(int[] arr,boolean ascending) {
- Z& @+ s7 G% Y) k  H
$ `. e+ J+ e  ^- h1 Q
        for(int d = arr.length/2;d>0;d/=2){


            for(int i=d;i< arr.length;i++){
9 f0 w& |7 _6 {( m; R                int temp = arr;
                int j=0;
                for(j=i-d;j>=0&&(ascending?temp<arr[j]:temp>arr[j]);j-=d){
0 ^& G$ ~) G& C& \, |                    arr[j+d]=arr[j];
+ O0 s2 K5 {8 X: d" n                }
! O8 B* U+ {) O                arr[j+d] = temp;
6 O: i- }) _/ _& O2 t, [+ I            }
9 z) g; r$ Y( g, X! y$ V        }


; G( _& N9 C6 y: n( a6 o( Z    }
}
5 ]" J: P- r5 E& S# Q- u0 i1
2
3
4
& m  a# d. u  N5 Q! J2 e! |% V  A5
3 ~( U- z& H8 a6 |0 f6 q: B- W6
' U" D- r% [7 P* G% W. d' D1 i6 y/ U7
/ `6 d" j' z0 f  ?  |$ U7 M, D8
  `& P( w0 W7 T  L1 t1 Z9
10
11
& v; o$ I- ~  {# ~( O12
13
14
* N; e2 _' V2 j) o15
16
: \$ w! k* R4 C) I2 P17
18
& h& T8 s( G: ?* H# T19
20
21
22
23
% s0 E+ H7 t6 l0 ?3 T24
25
26
; G- [. @  ^8 d& f4 @27
28
7 z0 J- t* ^9 }29
30
2 |- V! q5 D8 P: K31
32
0 o# `1 @2 O+ N7 }! \计数排序
- T; Q% ?2 \' G简单解释：
这个排序算法看名字也很好理解，就是就是额外找个数组来计数，然后在这个数组从小到大或从大到小把数取出来即可。
' N2 t+ L; F# L# u: E+ C

7 I, u; \, e9 `8 U. I6 u% ?$ e9 V6 L8 @



完整代码：
8 O/ y9 Y1 |+ F% g

) j% s# }  Y6 n5 i( X' S( q( opackage com.keafmd.Sequence;


/**
3 R, l  ]6 i/ w* n( x * Keafmd
: s% {$ m! O0 A5 K. ?6 I/ K. P! T# g$ U *
* @ClassName: CountSort
* @Description: 计数排序
* @author: 牛哄哄的柯南
* @date: 2021-06-24 11:31
*/
: \; x: p5 O, ^public class CountSort {

1 M8 [% Y$ P6 Y* `& t" h3 w0 S
' w0 B8 x; v# r) ?# O, {    public static void countSort(int[]arr){
        countSort(arr,true);
3 J5 O1 r3 }0 M5 t0 Q    }

' F: ^6 y) B: j, }" ?/ d+ Q
    public static void countSort(int[]arr,boolean ascending){
7 R: i6 K3 I" k4 M3 ^        int d,min=arr[0],max=arr[0];

9 B" v7 u; t" ?# K1 O$ L
        //找出最大、最小值
        for(int i=0;i< arr.length;i++){
1 \8 p7 s& _! `- N3 f6 I            if(arr<min){
                min =arr;
            }
7 i) I5 q+ o9 I! }% C7 y            if(arr>max){
                max = arr;
9 @- ]" _- t  U" M            }
        }

9 o% m' g% e5 g* Q- d0 E9 W6 W( C
& S# D8 i" H! Q8 E1 N        //建立一个用于计数的数组
        d = min;
        int[] count_map = new int[max-min+1];
        for(int i=0;i< arr.length;i++){
1 A2 g. m, B$ a  ]            count_map[arr-d]++;
        }

' `  o) m/ e- {" Z, D
        int k =0;
        if(ascending){
            for(int i=0;i< arr.length;){
+ P* P1 R& t# f# D8 [5 S0 P8 C& ^6 a                if(count_map[k]>0){
                    arr = k+d;
( F3 r/ T. ^+ `0 s+ g                    i++;
7 ^1 [$ u% R' W  @# g                    count_map[k]--;
& `+ E& A5 t6 H                }else
                    k++;
            }
        }else {
4 [1 L1 s  t3 N" E4 e. r8 T            for(int i=arr.length-1;i>=0;){
                if(count_map[k]>0){
                    arr = k+d;
                    i--;
                    count_map[k]--;
                }else
) {6 ?, T' e. T$ n                    k++;
( b; I  s* @0 z1 R            }
" q- ^( S+ m& J" r8 h& n; |8 x3 E5 Z        }
( H! x6 a6 n3 ]3 ^- |/ C
6 g3 @: }) h2 K. V& M  V
    }
}
1
: @" C% [* S" w" K5 @# b# D2
3
4
5
, b7 K4 Q  x; z3 U0 {$ N6
: y  s- d- ^% G0 K  a5 B  _+ s' V7
8
! ^9 Y) e: Q2 t/ x9
10
4 M8 W  V5 s" }% _4 f9 {11
12
& B2 k4 l0 F, r( A$ V8 I4 ]13
14
15
+ S+ X- U- v' g9 `8 N! ?16
* u- i5 u" C1 A2 v17
9 ~4 Y" _* ~( X2 I, a% q18
7 k2 l! ?) g9 r. ^6 I# E19
20
# Q# |% A# |! Q3 o21
4 J- @3 [" o' J22
$ }  J% b; e8 e  Y6 y$ Q; ~23
8 @0 ~* z# i& a8 I24
25
  e( f) i, U4 A26
* l" V1 @: [9 S$ Z5 f- P- n( f27
28
. T4 f) ^) V4 p# y& O6 y9 e29
30
31
9 h; @' y* A- ^* p- u* v3 Y6 x32
# B3 W, a: C" k5 O0 R! D# G33
34
5 E* F  s+ `7 C: l  R9 K. O35
- |7 [/ R, z8 T6 S; {" X36
. S" S4 h  O- l0 m9 y( [37
0 r, }  h# F4 c. `" q, N( D0 X! u38
6 H; _) E( D4 p0 K$ T# L9 s5 S39
40
41
42
43
$ Q- b. ~6 M- B44
45
4 N& j- x2 B. b, ^( K0 a" v46
" d1 y. E" q# U1 u, e47
# Z- H8 h. D& A* e48
49
4 X' S* a! [  }( r( |9 I50
51
52
; f! }" n2 c& |2 Y5 I* M53
, i) E8 `: c; L+ w* z54
$ b" C5 r  l5 p5 g55
56
6 G+ N2 H$ J& O" v1 E$ v, p57
! X3 x. |0 H% i( D58
  _: Z$ ?+ V0 q. h59
桶排序
简单解释：
就是把一个数组分成几个桶（其实是几个区间，从小到大或从大到小的几个区间）装，然后让每个桶（区间）有序，然后取出来放一起就可以了，相当于把几个有序的段拿出来放一起，自然还是有序的，当然需要是按照区间的顺序拿了。

9 F: G8 t4 w! v0 m1 T! ^

. T: _1 G/ q7 n, F6 ]

2 p  c3 @( Y4 b1 b
% |6 r3 v, A! n- W5 U1 F完整代码：

/ n- a; V5 n5 j# n1 q' Y
package com.keafmd.Sequence;
! s6 n& Z* j$ W. I2 U4 e) H6 ^

import java.util.ArrayList;
' k9 v( w) g3 Ximport java.util.Collections;
/ w# w) N0 u, L  q2 M
1 {% h; r) W2 y) p0 A
: ], H. u( Y$ X: ~; V( Z  y; u/**
* Keafmd
*
6 ~, I, Y3 l" p/ l * @ClassName: BucketSort
* V( e" H  C9 V' J7 B9 s. o- f  W * @Description: 桶排序
* @author: 牛哄哄的柯南
* @date: 2021-06-24 13:32
7 l# Q0 w+ D9 U; L* C3 f */
7 X4 V: D# h' I' V5 e! |( qpublic class BucketSort {


    public static void bucketSort(int[] arr){
        bucketSort(arr,true);
    }

+ Y0 B' C7 K% X
+ w- F# N6 I& r( E( V6 j% R    public static void bucketSort(int[] arr,boolean ascending){
        if(arr==null||arr.length==0){
# A4 t6 f& o) |% H            return;
        }
        //计算最大值与最小值
) Y: H9 j+ p5 o9 X4 G        int max = Integer.MIN_VALUE;
; p& F/ }7 [/ R        int min = Integer.MAX_VALUE;
        for(int i=0;i<arr.length;i++){
! z& Z& P0 r4 L  l            max = Math.max(arr,max);
$ b6 w4 M6 }$ C. `% V' l# ^            min = Math.min(arr,min);
: U' J* l" E+ q0 q4 e; F1 u; n9 H        }
; g( j- t. N( S' e- f( @" p, z  `

        //计算桶的数量
3 g7 O9 O; l9 P( V        int bucketNUm = (max-min)/ arr.length+1;
        ArrayList<ArrayList<Integer>> bucketArr = new ArrayList<>(bucketNUm);
) E& q1 S9 L$ i* i. E# l& C. C' \        for(int i=0;i<bucketNUm;i++){
            bucketArr.add(new ArrayList<>());
* Z. [+ q( [# U: F% u        }
) [4 H2 }' ^- R% o' D9 n

* _. \/ K! F1 {% o9 D9 V        //将每个元素放入桶中
4 v# w2 n. r6 F6 H; k7 c- q        for(int i=0;i<arr.length;i++){
4 R: k; g) c5 y6 J! w1 e4 v: B% k            int num = (arr-min)/ (arr.length);
. j3 x! m$ o) {* c' \            bucketArr.get(num).add(arr);
3 w& h* S) C1 `4 g3 X8 P        }


        //对每个桶进行排序
        for (int i = 0; i < bucketArr.size(); i++) {
# o  L. V0 L9 U( i% X            //用系统的排序，速度肯定没话说
            Collections.sort(bucketArr.get(i));
7 h/ C3 K, e3 S5 [( L1 y/ M        }

1 m# s$ i  L4 w* c
        //将桶中元素赋值到原序列
% q! s& ~8 ]% m, b4 d" M* R3 K/ z( d        int index;
        if(ascending){
9 J6 u" t1 y/ I6 h" P. O) G/ i; ]4 T            index=0;
% o$ ~/ n6 o" f        }else{
            index=arr.length-1;
        }
8 o; N" W9 ]! A3 _- b  L! h2 p( N
+ k( X% A0 I6 k5 v
        for(int i=0;i<bucketArr.size();i++){
            for(int j= 0;j<bucketArr.get(i).size();j++){
9 g+ e+ M3 V! s# B& J6 k                arr[index] = bucketArr.get(i).get(j);
3 Y. l/ L$ @8 n$ C( [                if(ascending){
                    index++;
                }else{
                    index--;
                }
& ?+ M9 C1 j6 {$ Y( e0 A; G. R) I            }
% a, N+ ]) l7 q" ?5 K

3 r6 y6 ^+ X8 o8 b- V        }
$ W+ n' n/ Q2 p, h

    }
1 ~" ^0 {  M0 x}
1
2
' l/ |, U" v- Q$ |1 O3
! Y% K2 c  i" B4
5
% C% m! C4 \0 k/ @$ s6
7
4 _. }( c# y7 n" c8
3 h6 x* \$ d+ }1 Y1 ?' ~5 p9
10
' u' R5 O  |2 }- |11
! E, J. i7 U# D( n- j) c1 z9 e12
) d! Z) J2 L3 Y13
14
15
0 L3 m! Q# @; F16
6 O4 m8 {% o! x! e( x17
18
: M4 f% _/ T/ b0 C- j' y% ?3 A( X19
' d4 b7 q) f8 i: n. f1 j4 X20
21
22
23
24
2 m2 S: N) Q/ g4 R25
2 j' `9 R) g$ j5 L26
27
28
& B" d- @& r' }" j' M1 v9 O  p( D29
30
# B. O' {; ^6 X1 I31
+ A' H3 {! ^/ x! q% v32
33
34
0 ?" l# k* H' q% P- S35
36
37
9 x; P1 i  P2 L, ^/ }38
' ~+ `- G$ G! x4 Z" ^39
. C5 c" j  w! e+ c1 H" x3 R8 ^40
41
42
43
+ v8 ]$ m  H, q44
1 f- o! S  `: q* `3 E45
) K( B# A) i9 y46
/ W; ~# Z% C7 [! G; O47
48
. i  O6 _$ Y+ p0 L5 ~3 N) {4 C49
50
51
52
/ J6 m1 n" \' T  P8 D53
! W" {/ H3 _5 _% J54
* X7 W7 s9 P( J- ]' n5 z55
56
! q- Q7 @' P' t" l% M7 L57
58
2 ^3 X+ a5 k1 E/ l# m# ^1 e$ s59
; R: p2 I  j# d0 ^60
, u: C& @/ [% y# @7 M2 A: M5 V) ^61
6 n) c, s8 s( t62
0 M8 Q: J/ V7 f  R6 ^# X63
64
65
66
67
68
3 A7 v* P( w4 [& f: q  M9 s69
1 p" c% t  S; t1 I. B70
71
: m- ~: ^! {; i& W2 T! \! d1 u72
8 d( O% @, U4 F3 ]/ R6 ?基数排序
简单解释：
0 T. A) `) m, D0 A! L首先说一下，我发现好多人写的基数排序只能排序正整数，其实只要处理下就可以排序含有负数的了，就是我们排序前先把所有的数整体变大（就是减上最小的负数，也就是加了），都变成正数，然后排序好之后，在减下来（加上最小的负数，也就减了）就好了。
基数排序就是按数位排序可分为LSD（从最低位[也就是个位]开始排序）和MSD（从最高位开始排序），下面写的事LSD基数排序。
) K8 W4 t+ z- ?1 |5 y) ]基数排序就是把数按位考虑，让后我们一位数只能是[0，9]，就是我们在考虑某位（个位、百位· · ·）的时候就只看这个位的数，放到在[0，9]相应的位置，然后顺序取出，最后再按其它位这样操作（上面说了要不从低位开始到高位，要不就是从高位到低位）

  Q/ z2 U! b5 E$ Z. i, c* j* W




6 X! L( \- Y" ?完整代码：
4 t# d( @1 [. ]: {1 T

package com.keafmd.Sequence;
. m8 k! Y- J  y# b0 d1 M6 G8 P$ P6 D' d) `
7 B# v+ R# D* E
% f" [: I- o2 C( Y0 z/**
2 v  j, H3 b% c( S. }9 h * Keafmd
*
) f; R5 P3 ~7 D" ]1 O+ { * @ClassName: RadixSort
# [7 z8 I0 ?4 i2 j( t * @Description: 基数排序
( B$ t$ ]9 |# C: G' } * @author: 牛哄哄的柯南
- }) {" `" O5 U6 R * @date: 2021-06-24 14:32
% Z3 L& M3 V/ R( Y( b! D */
3 Y- w7 J6 f1 R. vpublic class RadixSort {
" q7 f4 m8 U. n' `* Q$ b    public static void radixSort(int[] arr){
        radixSort(arr,true);
2 @4 w! u( j8 S4 i% S2 M    }
    public static void radixSort(int[]arr,boolean ascending){
        int max = Integer.MIN_VALUE;
' u; z4 j. ]3 Z0 S) g8 Q        int min = Integer.MAX_VALUE;
        //求出最大值、最小值
        for (int i = 0; i < arr.length; i++) {
% Q# l) f# U. N3 \" Y+ x9 i8 m            max = Math.max(max, arr);
! h  V  ?4 p, k, Y            min = Math.min(min, arr);
0 z; p9 p7 C. k        }
        if (min<0) {        //如果最小值小于0，那么把每个数都减去最小值，这样可以保证最小的数是0
            for (int i = 0; i < arr.length; i++) {
                arr -= min;
            }
            max -= min; //max也要处理！
        }
# g9 ?7 p* z: J: q( D8 k        //很巧妙求出最大的数有多少位
        int maxLength = (max+"").length();
        int[][] bucket = new int[10][arr.length]; //一个二维数组，一维代表0到9，二维存放符合数
        int[] bucketElementCount = new int[10]; // 用于记录0到9某位存在数字的个数
9 j' z" q& J  b4 D2 D/ u        for (int i = 0 ,n = 1 ; i < maxLength ; i++,n*=10) { //个位 十位 百位 这样遍历
& u0 z) ^+ z: M; U4 \9 ]; P            for (int j = 0; j < arr.length ; j++) {
7 a% ]% d3 b5 a1 S1 B                int value = arr[j]/n % 10;
. i1 \( Q  s# Z) Z" E# i                bucket[value][bucketElementCount[value]] = arr[j];
. M5 t5 w7 o: X2 R' p. e                bucketElementCount[value]++;
% m  K8 S  J8 u0 o( R: _            }
4 U4 w$ S  ^( k5 P* l
7 P3 J  C( z1 W& u6 R$ m
0 f6 e$ ^& c/ p: f1 [! v( w- n            //升序
            if(ascending) {
/ B- ?3 s4 n- {' l9 s: Q/ j                int index = 0;
. h9 y6 v8 E8 A, }$ X( U                //从左到右，从下到上取出每个数
                for (int j = 0; j < bucketElementCount.length; j++) {
                    if (bucketElementCount[j] != 0) {
+ w7 @0 w0 Z; l                        for (int k = 0; k < bucketElementCount[j]; k++) {
$ n$ A, I( g0 r+ Y' q9 q                            arr[index] = bucket[j][k];
( |! y' y" B# y7 d                            index++;
) c# l+ K1 Z# c- T& v                        }
                    }
! `5 d( e) O" Z, ?! n                    bucketElementCount[j] = 0;
                }
            }else { // 降序
                int index=0;
  ^  h- t  k0 X/ c# j/ _                //从右到左，从下到上取出每个数
                for (int j = bucketElementCount.length-1; j >=0; j--) {
0 R2 \2 ~$ r2 U9 [- I3 q                    if (bucketElementCount[j] != 0) {
0 t/ Z1 Y" q% N3 z* ~                        for (int k = 0; k <bucketElementCount[j]; k++) {
                            arr[index] = bucket[j][k];
                            index++;
                        }
8 a! R6 J( D$ v% _- c/ H1 e                    }
8 G& Y. a5 n4 e& [- G& C                    bucketElementCount[j] = 0;
$ D# X0 M: `( j2 I) B0 M                }
            }
# h: C2 z; u8 ^* }# F) R
) H1 u4 N" m$ S6 X# p


            /*for (int i1 = 0; i1 < arr.length; i1++) {
6 u7 O  W  H: b7 w                System.out.print(arr[i1]+" ");
            }
            System.out.println();*/
7 |! e! w, K/ g  [
/ r  Q1 z# S2 g4 K* I
2 K" Z& {  }8 X; b+ e3 {5 k/ C) F
' c: ?* S4 y# G6 y
1 Y( D% v! z# V7 ~9 {, ^$ f
' |, M+ _- x) I, ]" Q
# `* L  ^  N( o+ a7 d1 U% y        }
        if (min<0){
& ?3 G  a$ `; A: j! ], `            for (int i = 0; i < arr.length ; i++) {
% a7 ?& o+ b- W                arr += min;
            }
$ @. ^* K5 d1 P        }

$ r5 J+ [1 J+ P6 l2 o
& L* z. X) z, M! N* O    }
}
1
( o- K9 q8 W: C1 P2 m. s& q2
3
4
8 r$ G4 ]( W3 J+ G5
6
9 Y4 C+ _5 h6 S6 o, o2 t0 i; Z7
8
9
  D* E: n0 t4 _5 o1 X( R" O! q0 C10
11
9 G' c9 g' `+ ?8 l12
! m! F' C. U9 o  c& W/ ~3 m13
  k- e6 C3 v3 H0 |& o0 a8 w! ~14
8 K" {3 K/ P7 o* c. Z- Y9 \15
3 M2 t3 B/ Z3 {$ m16
. v4 {- N; L0 {- a& ^17
/ f& i5 |' d5 q# [9 C+ x18
19
1 P7 e, ^! V9 W, U. j4 E) S7 X" }# C20
21
22
4 O0 ?# T% C- s% r: K* O23
24
25
26
$ b' v9 D% E# S& w- D- `; P' r27
28
29
: A9 X  [( K! O2 \30
31
9 d. i/ U; \, r' P2 L32
6 M/ G( c: Z6 B# R/ A2 m1 X% w2 k33
2 U- w' f) q5 P. W. q# C4 _34
35
9 b' H! y+ Q7 s& O2 c8 j0 c. Q36
# M( l# k8 N1 \8 U2 X( c37
0 \3 _- R$ r1 n% {8 |, z38
39
40
5 U, e7 K, l1 ]7 N* q* T2 {7 q41
42
0 ?$ Z: o1 z( D8 z# Q43
44
$ W6 ?2 ?- l! _2 v& t- g5 J45
46
% K4 `7 f$ o% K& n' r, |# H; w47
6 e% [% O" L) f) `( [& r48
49
7 a2 Q  f6 e8 j; R50
7 r* c1 |/ @' n9 ^( D# X* f51
& N* O8 E/ H, Z/ ^  y( s3 W52
- ?' w" H2 t0 j$ z8 S; L53
54
9 ]  `0 V% T! S; U0 [' D55
56
* g" [* ^- ]: Q57
58
; e7 f, Q5 _* [# I, w. D8 Z0 ^59
60
61
% ^6 w- {0 h  l! V: k6 u' D62
63
64
( Y  X" ^9 E1 h, P+ c/ N65
66
' N) b; X/ a+ Y- J67
68
# l$ X$ L0 B/ r( x1 I# q69
- m* }+ u. E8 g3 ~# Y' X70
/ r& a( m- W2 T9 P; k71
72
73
74
' \& A- E: l6 H; g6 N& ~  |: C* `75
76
8 X) O$ ?! O% y6 f. w! W1 Y" N( m) e77
) b6 M) z/ {- [: A* g; X! k  X78
" _- p' r0 o. @% R79
. N0 J' d/ \0 c0 z7 w80
; g' B4 a: j+ r( K9 n* G0 j! W% W81
' u( l6 b4 p- N2 G7 x! Z/ H. k; C) [4 S82
# d5 f, f$ m4 k- b  B83
  U4 Y1 x$ A/ V3 m8 m8 X完整测试类
* \/ b9 g5 q4 ?: x/ fpackage com.keafmd.Sequence;
! v2 S: {4 h# \6 K

, z8 |& `& h. {5 A7 M* jimport java.util.*;
import java.util.stream.IntStream;
import java.util.stream.Stream;
, s$ d) {. Y8 G% r) K7 L% q/ _% w

0 [, q0 ?0 d4 k/**
* Keafmd
; _1 d' [) |- l2 d) p4 D *
* @ClassName: Sort
* @Description: 十大排序算法测试类
) C6 w) g& @. t8 h% r4 z: W) m * @author: 牛哄哄的柯南
* @date: 2021-06-16 21:27
; H* L- w. M0 y) W) j */
8 x, ^+ P5 X9 g" kpublic class Sort {
9 x( V1 \8 X# f  C
0 c  ~- q  \# t7 [8 ~% q) A' b/ v


    public static void main(String[] args) {
4 e1 I8 V9 r$ X5 x9 c
3 _# _% E" X1 s; k) ^2 m$ X
  j  a, _# W1 n/ N) }/ @        int[] nums = {12, 4, 25, 47, 58, 34, 25, 9, 99, 26, 1, -13, 162, 10093, -66, -1};
//        int[] nums = {12, 43,56,42,26,11};
        int[] temparr;
$ l6 ^- p( l$ N: e$ |
) s* v% `* c* _  A
        //利用系统Collections.sort方法进行对比

+ `' V6 [2 D  h
        //将int数组转换为Integer数组
        //1、先将int数组转换为数值流
        temparr = nums.clone();
        IntStream stream = Arrays.stream(temparr);
; X+ a6 ?  d: e0 r; Q6 t        //2、流中的元素全部装箱，转换为流 ---->int转为Integer
        Stream<Integer> integerStream = stream.boxed();
" R3 B! ~" u7 a* w. S# e; ^        //3、将流转换为数组
        Integer[] integers = integerStream.toArray(Integer[]::new);
* S3 H* G7 B5 l' c5 L3 @+ Q* U  I        //把数组转为List
        List<Integer> tempList = new ArrayList<>(Arrays.asList(integers));
        //使用Collections.sort()排序
8 J2 Q& ?' V, w( X# W        System.out.println("使用系统的Collections.sort()的对比:");
8 t& R% O6 f& ~

3 z, Z$ `# h# r% D        //Collections.sort
        Collections.sort(tempList, new Comparator<Integer>() {
$ p2 i* t& M8 F' P  M7 C: {            @Override
; j4 D- X5 t+ f3 f$ }& j            public int compare(Integer o1, Integer o2) {
                return o1-o2;
3 x4 ?! T  z$ t& m                //return o2-o1;
            }
9 X* [# t4 T( h% l2 ^' g" B        });


        //tempList.sort 也可以排序
       /* tempList.sort(new Comparator<Integer>() {
( t) R; j  j6 M0 U7 `0 P, }            @Override
! T3 Y! R2 n  V1 I9 b: C9 s& A$ k2 |  q) o            public int compare(Integer o1, Integer o2) {
                //return o1-o2;
; i1 }9 W7 }8 o* c; }; a                return o2-o1;
            }
        });*/
0 i9 S6 Z$ O; Z7 _$ w

        //遍历输出结果
        for (Integer integer : tempList) {
            System.out.print(integer+" ");
0 S7 M4 @  |6 _3 r        }
2 e! g0 |6 h3 s( h9 N$ L
, _* u2 R8 }, a0 n8 s
        System.out.println();


% u/ C% w& q. L& P7 L        //测试冒泡排序
        System.out.println("测试冒泡排序:");
        temparr = nums.clone();


        BubbleSort.bubbleSort(temparr);

7 S* p6 a( J) u
! _* }' [8 Y) u" G9 Q8 i3 i0 e$ S        //降序
        //BubbleSort.bubbleSort(temparr,false);

6 K( G; `$ e% l, N9 @7 s$ ^
        for (int i = 0; i < temparr.length; i++) {
            System.out.print(temparr + " ");
        }
        System.out.println();
- v: u$ }5 ~5 Y
' D; C  t! u5 _% {( m  ]
# ?7 N* ]1 a2 e        //测试快速排序
        System.out.println("测试快速排序:");
* P8 I5 w( s8 V+ V( h8 u. Z        temparr = nums.clone();
* g' j4 a$ Q9 L1 k/ r        QuickSort.quickSort(temparr);
        //QuickSort.quickSort(temparr,false);
        for (int i = 0; i < temparr.length; i++) {
            System.out.print(temparr + " ");
        }
        System.out.println();
; P$ t( ?5 A, Q
$ X( y' y4 R! s5 g& @' y1 L7 w
) A& `$ u( z) b" z6 c4 Z& Q        //测试直接选择排序
* m; Q- t: n) r8 {' D        System.out.println("测试直接选择排序:");
& I: m, ^" Y5 b/ j+ l$ M        temparr = nums.clone();
3 L+ c% J+ f8 H" Q! S1 }# x- l8 ]        SelectSort.selectSort(temparr);
. i# ]7 @% k* [, w# D0 H        //SelectSort.selectSort(temparr,false);
        for (int i = 0; i < temparr.length; i++) {
% ]; L4 H. y+ W( w, \" K            System.out.print(temparr + " ");
# c% F* S. h: n" S  l  ]        }
        System.out.println();

; z( V, G7 t+ z( Z) l! y
& E! P% v- n: p" \' a        //测试堆排序
; p: h+ s) @- q! q: J        System.out.println("测试堆排序:");
        temparr = nums.clone();
        HeapSort.heapSort(temparr);
        //HeapSort.heapSort(temparr,false);
* S- f2 a$ g/ @( ]& D. G        for (int i = 0; i < temparr.length; i++) {
            System.out.print(temparr + " ");
        }
        System.out.println();
5 f6 `9 M& B! |2 ~
% F0 b+ }" e9 V  A0 i! e, Q
        //测试归并排序
        System.out.println("测试归并排序:");
        temparr = nums.clone();
5 e# O  ^( s% u0 ^9 f% q        MergeSort.mergeSort(temparr);
  ?: f1 K9 ]- H        //MergeSort.mergeSort(temparr,false);
        for (int i = 0; i < temparr.length; i++) {
            System.out.print(temparr + " ");
        }
        System.out.println();
$ @7 V9 p5 u+ }# }4 J- ~4 U
6 |! h0 {& V, @! ?+ x3 |* f
        //测试插入排序
: F9 }8 k, v1 m2 c0 j        System.out.println("测试插入排序:");
        temparr = nums.clone();
        StraghtInsertSort.straghtInsertSort(temparr);
        //StraghtInsertSort.straghtInsertSort(temparr,false);
5 S  F) s( j! @. ^. ]        for (int i = 0; i < temparr.length; i++) {
            System.out.print(temparr + " ");
3 K0 B- a, s, _. L" w# }6 |        }
        System.out.println();

6 Q- D' A8 \: c5 Y: `


        //测试希尔排序
( G& V( s/ X# Z* O        System.out.println("测试希尔排序:");
% c+ u1 y9 X4 j. g. v# L5 }( m' j+ j% j        temparr = nums.clone();
        ShellSort.shellSort(temparr);
        //ShellSort.shellSort(temparr,false);
        for (int i = 0; i < temparr.length; i++) {
            System.out.print(temparr + " ");
: e# d4 ^2 Y1 m        }
% i1 r; y+ M: N  t$ J; U3 k6 g! U, m        System.out.println();


8 u" P8 y+ \& h0 \4 f

        //测试计数排序
        System.out.println("测试计数排序:");
$ [; T4 T# y# I$ _        temparr = nums.clone();
3 A- ]! o) `4 V: i9 X! u: [        CountSort.countSort(temparr);
        //CountSort.countSort(temparr,false);
        for (int i = 0; i < temparr.length; i++) {
            System.out.print(temparr + " ");
        }
        System.out.println();

. I# y6 s/ M% c3 V& n
* K" y: @3 M( C: R5 S$ V
' X" q; ^; n/ J2 b7 a0 @
        //测试桶排序
        System.out.println("测试桶排序:");
7 q9 u2 I& a' l        temparr = nums.clone();
        BucketSort.bucketSort(temparr);
+ Q' E$ _7 [' U1 Y. F" o- {        //BucketSort.bucketSort(temparr,false);
        for (int i = 0; i < temparr.length; i++) {
            System.out.print(temparr + " ");
        }
        System.out.println();
" c! r+ ?- H! k& _
3 l/ R4 g! ~- z* U9 {" p/ |
7 D# y" A1 K" M. k& b        //测试基数排序
        System.out.println("测试基数排序:");
        temparr = nums.clone();
) o+ ^' \/ c) Z2 i; N0 M( y% J+ t+ J        RadixSort.radixSort(temparr);
- f4 t, J, e  _9 P4 T) L, y        //RadixSort.radixSort(temparr,false);
        for (int i = 0; i < temparr.length; i++) {
            System.out.print(temparr + " ");
* b6 q! V. b; I& s        }
        System.out.println();


" a: j' }# U; y' `; e* X    }
* D# Z, K* b5 q3 n8 r

}
7 u% ]7 {+ r4 `; f8 b3 @1
8 d$ x' O5 Y) u$ l2
. M8 Y: ^# ]) Z8 E; y; W) g' W3
0 K  x1 w' I' w" V- V4
/ S" G: h/ M- F; N1 w5
6
7
8
9
: n- X0 K1 Q* y10
; x& q- B: N) v; l. U11
12
5 p2 m7 W8 _4 Y7 T1 B* ?  o13
3 `% h% J0 a( R5 ?14
15
" {- ?' `; U5 O" ]6 l& D/ t16
17
, L) |, Y9 Y! O3 o/ R18
7 |' _; c; P4 e" a6 @3 X$ P2 v19
20
) K! b5 g. q2 t, M8 f& X21
: k4 Q# }7 h1 c" ]: g( G22
: [: B& I! C! ]) E2 N& h) K1 s23
$ f' l5 ?, ^, n7 d" }  ~4 ?% G24
; Z) l5 n& Y3 p3 ]+ S! r25
" T" ~$ P7 [% a* i  q4 b3 b26
27
) t+ F8 I* d6 D- }% Z4 j. v28
7 Y! C" A# `) ]1 f+ M29
30
$ Y; ]- a5 m- f+ S" `% M31
! R0 s, }- l$ p9 p32
33
' J2 g$ v/ I9 J& y) z1 O34
# I2 f  M# M; u7 K) X1 i. w' {35
3 E- V! r: i' f% v9 G$ g3 ^36
37
38
39
40
41
42
% A! B6 |. \* ^43
44
% j& Z1 g: l. [  C5 t* a" q4 o45
7 C# c/ x' U3 A8 A' J) J, @46
' K# o. d7 @4 f3 p" I  S$ D47
48
49
50
51
; N( N$ q8 z9 n52
53
54
& Q4 ?, j7 v' v; n. G. S& b2 z! D55
: d, O1 `: p. v6 i" {: L56
  R8 _( y, B0 k! R57
58
59
60
# P3 v- y, X- B: F! F61
62
63
$ ?, M5 h# k7 M+ R64
% l1 l8 w1 {7 ^% S65
2 e9 o+ [* k# g/ m/ X3 F8 f66
67
68
69
70
$ [- u+ `6 [& [71
72
/ G4 l0 g# }! a/ R+ w0 R5 Q" c73
  B6 H0 A6 u% H- ]74
75
76
: E4 H1 X6 X, h% C6 [5 \! N1 \& j3 {77
* X0 N. G: j8 }1 N78
79
80
81
5 N, S& g8 M. A! ^! ?82
83
1 ]3 l3 r0 D9 r2 g) G2 e84
  v3 p+ [# K2 c6 l) M85
3 B# Z" ~; P' I" H86
87
88
5 l5 i: w; ~: d" c0 |  a+ d89
90
6 p( x- R0 r/ Z6 c, V1 \91
92
93
94
5 D3 W' i3 t( R" D2 J7 t. T3 C95
96
97
4 W' I, t; ?0 Y- ^& K: T$ ^98
99
$ Y" T# s. o$ q: M( P4 B) v5 y100
101
1 R( Q+ P  Q, r2 Z/ V4 {/ T102
103
; i, V4 S, A. {. P; A104
. M. S9 X* [8 d# |5 t( B' U9 z105
106
107
# q2 K* A( S( ?, w9 I. U- B! n108
109
110
111
1 }3 s( D! M# [0 D112
113
3 x, z& W( m/ e& G) {, ?114
115
& f7 D- Z( q  E" U! C% c) V9 w- d( n116
$ O$ `7 d/ s) |, W  W117
- Z. Z  G8 Z( n; @118
119
120
121
$ v! i( q; x; N$ |3 l% [. F122
123
: W- \5 _9 e3 v) T124
125
126
127
128
129
130
131
6 h7 {; r1 Q; {. o* {' o132
133
134
2 {; ]" T# c/ y135
2 }9 U( a/ @; K136
137
+ B# t, p( m9 B& d9 M% N" b138
2 E/ N2 r5 \: `' _( L* o" D139
140
141
142
; {( k  K8 `+ z/ o) A3 U143
144
145
146
147
148
149
150
151
' q  L% q8 @2 |0 `$ D$ c6 M+ e) r152
+ ~9 E7 t; ]1 x7 \4 x* w153
154
8 _2 w/ ?; _# D( I0 p155
156
2 F# O! p* B$ W6 n/ P9 `' Q) w157
158
159
160
& ~- U; S1 M  x* W) a161
162
( z. ^* N( x1 E$ K3 K4 {9 S, w163
164
) `2 _- [# S7 E6 k' u) l165
166
! M; H7 v% S+ T5 o: S* D( d167
168
' C4 H9 n: j1 F5 G169
8 G9 D0 `' y& F- {7 f170
- u  P; T1 p, T" H( R171
172
173
每天进步一点点！
, \$ |' X# ~. A, T" x4 @& h" B2 O不进则退！
  l) s, ?9 O0 t, B0 h

版权声明：
2 X( @; J5 V7 P* s+ |- t原创博主：牛哄哄的柯南
博主原文链接：https://keafmd.blog.csdn.net/
————————————————
0 W3 a3 n: h; n" S版权声明：本文为CSDN博主「牛哄哄的柯南」的原创文章，遵循CC 4.0 BY-SA版权协议，转载请附上原文出处链接及本声明。
; q# l: ^# t& M4 O0 q, ?原文链接：https://blog.csdn.net/weixin_43883917/article/details/118193663
" @5 C/ p- V7 d, V
7 A; v- H! H, {. f( R4 z: x# B

1051373629

每天进步一点点！