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

杨利霞

4 n; _8 l1 u- p) K5 }经典十大排序算法（含升序降序，基数排序含负数排序）【Java版完整代码】【建议收藏系列】
; @7 {5 t, D( k7 v' t经典十大排序算法【Java版完整代码】
" B" m' L7 D; N( }, n写在前面的话
. a3 @& t: A$ N8 l十大排序算法对比
1 u! U/ {) {% O/ J% Z- J: ?冒泡排序
6 `- B  T! Z% g7 f; ?4 |快速排序
0 ]3 }' o, ~1 u: Y3 G直接选择排序
堆排序
: C5 Y2 h& U" P' t归并排序
插入排序
希尔排序
9 ]% @5 ?, F3 u* I; \# V计数排序
* ~+ d. s  ~- x  b2 z$ _" V桶排序
基数排序
完整测试类
! `" E" m+ A) Q- R7 Y写在前面的话
       虽然已经有很多人总结过这十大排序算法，优秀的文章也不少，但是Java完整版的好像不多，还存在某些文章代码存在错误的情况，同时也为了自己练手，决定把所有的写一遍巩固下，同时也真诚的希望阅读到这篇文章的小伙伴们可以自己去从头敲一遍，不要粘贴复制！希望我的文章对你有所帮助，每天进步一点点！！！
7 `  C4 y) t1 ?; B) M" k' |" m
7 f; ~% a  x1 l& p/ x' Q5 R" ^
       我用通俗的理解写下对算法的解释，对某个算法的运行过程不是很理解的话或者想看比较官方的解释的话，单独搜索某个算法，看几篇不同的解释，就可以有自己的理解了，这里我主要展示代码以及进行通俗的解释！整起来，再强调一次，一定要自己敲一遍，这样才能理解的更深刻！
3 q- r5 J0 A, t/ t, W
5 v! ^, f& m9 N+ L: s6 q
+ X% f. _! V3 I/ X( H十大排序算法对比

6 c0 M' q+ n1 U8 s
" ^& x5 u6 @5 z1 K+ k& d# Z- X
- y4 T, |7 U3 \7 t
关于最后一列的稳定性，我稍微解释下，例如对序列：1 2 4 2 6 排序，序列中存在两个2，如果我们把这两个2标记上（让他俩不同），排序之后，前面的2还在前面，那么就称这种排序是稳定的，反之不稳定。


冒泡排序
简单解释：
4 ?1 ]/ _: H/ Q2 T       原理就如算法名字一样，就像水中的气泡一样，每次我都把最大的或最小的放到最后面，这样总共需要n-1趟即可完成排序，这就是第一层循环，第二次循环就是遍历未被固定的那些数（理解成数组左边的数，因为每层循环都会把最大或最小的数升到最右边固定起来，下次就不遍历这些数了），两层循环遍历结束后，所有的数就排好序了。
9 h3 o/ X0 U3 N4 z5 T( p) O2 i. b       两层循环所以冒泡排序算法的时间复杂度是O(n 2 n^{2}n
2
; }, J8 \$ f, d% _& j. I )，是一个非常高的时间复杂度，我在下面的代码进行了优化，加了一个标志位，如果上一次循环未发生交换，就说明已经是有序的了，就不继续下去了，反之继续进行下一轮。


# S$ p) C$ b8 t* E9 T* ]
7 R' P* M. Q7 j# O; p
) [9 W) M, u5 j) b, D, i
) N* ^/ `3 K* U7 h
本文的图片来源网络，仅用于大家学习，侵权联系删除！（下同）
) G8 P% y) n+ Q9 E6 T7 A
* [) `4 Z: \4 U# b* c5 p3 L3 s
完整代码：


# C" b2 w! ]- F0 \! Q# _/ ^/ v7 `0 Opackage com.keafmd.Sequence;
3 f3 y0 C7 R; |8 {( K1 }

/**
* Keafmd
*
* @ClassName: BubbleSort
5 A5 Q6 v2 d# V* x# q) [ * @Description: 冒泡排序
* @author: 牛哄哄的柯南
) k: g+ P8 v  B; Q+ v2 e  s7 b( b * @date: 2021-06-24 10:31
; R8 p7 O3 P  l8 F, Y" f */
6 Z& f! y( f& _- Y( q/ Ppublic class BubbleSort {
0 B( i1 p& m8 n
, Y' x0 ^0 |& T# L! j
    //冒泡排序
4 T0 \% R4 O% ~- I" }" e( _2 b    public static void bubbleSort(int[] arr, boolean ascending) { //exchange标志表示为升序排序还是降序排序
5 D; O) N* ?3 a6 s8 ]4 ?8 ?
8 g4 y: Z7 [% S9 k" ~  q: q
: m( O7 c& ]) Z. ?3 G        boolean flag = true; //加一个标志位，记录上一次是否发生了交换，如果是，我们则进行下一轮，如果没有，说明已经冒泡好了
, e0 `, j) _" d4 o: t" [+ }

, z5 _3 d  t: t3 A$ j+ N* {: C9 [        for (int i = 1; i < arr.length && flag; i++) { //控制次数，第几趟排序，只需要n-1趟，有交换时进行，只有flag=false就说明上一次一个元素都没有进行交换

) S& P% w2 n8 J. `& z
            /*System.out.print("第"+i+"次遍历：");
            for (int i1 : arr) {
                System.out.print(i1+" ");
            }
            System.out.println();*/
1 o) d" A3 T# m% x$ |# t, a
8 `. T8 c# v& |9 Y) {
! _  z2 \5 n! ?+ z% C+ L1 u8 P! G            flag = false; //假定未交换


- U# {) N( P/ M1 j; D            for (int j = 0; j < arr.length - i; j++) {


# i* g+ A8 V5 p& `: F6 [                if (ascending ? arr[j] > arr[j + 1] : arr[j] < arr[j + 1]) { //控制升序还是降序
6 {6 q7 C. y  U% |8 W  M3 r2 {                    int temp = arr[j];
                    arr[j] = arr[j + 1];
  |' D3 K, t8 ~$ c& ]. x4 Q                    arr[j + 1] = temp;
                    flag = true;
                }

6 Q) n/ z' {3 u
            }
        }
! K( c; T. a! F1 K  N    }
" m( h. Q0 I, e* O

1 A' \9 n% a4 @6 ]5 \    //冒泡排序 -- 默认不传参升序
9 s: k' f  {" A. c0 M    public static void bubbleSort(int[] arr) {
) S  u6 F/ y3 y! v0 D        bubbleSort(arr, true);
    }
}
1
! P7 W5 B" a& a5 z0 T/ g  P0 m2
3
4
( E2 Q6 \$ X) z( B7 k1 w5
% R! m$ V4 q% b# i$ B6
$ {  X9 Y3 k$ m, a* O, g7 H7
& L; G* Q* O- h8 A( {8
0 D& A. U9 Q6 y! M* u, z' U. `9
, V/ D, w7 k1 G10
' k1 [6 a" d) k7 B: s! ]" A. T11
7 l  u0 t% X. ?0 {+ D+ q/ S12
& v. _5 z  K" [3 i0 A( g13
4 s* C- [! {* [( L14
15
16
17
18
; h* X$ G4 A0 }19
20
21
# r  S% K+ H4 p1 m/ N  J22
23
24
25
) M: a! r7 B0 T2 [6 d  I$ h8 @26
27
: z% B. Y0 q$ r) B4 y! Q28
; e6 w! e% u' r; b6 ^5 m29
30
31
32
33
34
" F- k0 }, V6 C- F% }35
* v. _& t! c3 e; J# ?4 Q36
0 H% C# p! V. v+ E! D. F' w37
7 u2 D4 L: ^  @/ |! U/ w0 S) L: E38
39
3 z# r0 F# D. E* C# K0 }2 _4 Q1 O40
7 G) z' c3 x& t: }41
& p8 e; o9 ^7 }  X' x42
43
44
. Z8 N& g2 ]( M4 g45
  O" T/ b8 L) D  ]测试代码：
. h! N& K; e: h5 \3 u7 p/ f. ]
9 o8 O: [3 d7 j0 }  @% x7 Q
升序排序（从小到大）


9 Q& j& C  x8 spackage com.keafmd.Sequence;
- z: {% `' O" E& T5 ]; R' S

  Y" [# y& k7 i% b6 x1 L' aimport java.util.*;
import java.util.stream.IntStream;
import java.util.stream.Stream;


9 V8 E; b* q, G2 ~0 {  `$ t/**
' B7 k* `3 q' E( h3 l * Keafmd
# v( b# i/ g: p  D *
$ g( {2 F- d$ u+ m) m. p" Z * @ClassName: Sort
* @Description: 十大排序算法
: Y) P& ]3 Q5 S+ @, G * @author: 牛哄哄的柯南
6 l& p: m" R8 h1 F& A5 q/ v1 y * @date: 2021-06-16 21:27
*/
- m% r# J. T% ?6 N) Spublic class Sort {
) e# W1 `0 j. d& u, \, r% b    public static void main(String[] args) {

* E, Z* |+ z+ T8 o
        int[] nums = {12, 4, 25, 47, 58, 34, 25, 9, 99, 26, 1, -13, 162, 10093, -66, -1};
5 Y+ K, @0 O4 y  g- `; j        int[] temparr;

: S, l" W) W9 D7 A1 z
, r8 E# s  \3 T; ~5 [1 v0 ~        //测试冒泡排序
        System.out.println("测试冒泡排序:");
        temparr = nums.clone();
        BubbleSort.bubbleSort(temparr);
0 j  a! r: D( B( r        //逆序排序
        //BubbleSort.bubbleSort(temparr,false);
        for (int i = 0; i < temparr.length; i++) {
* f4 s' K! H8 J7 x            System.out.print(temparr + " ");
+ G# \6 j1 j* z) E7 m5 t        }
        System.out.println();
) @; z: J- V+ x7 R

    }
}
. B$ p% d8 ~- ^3 S) v1
2
9 h7 u7 t, x' y( W- {, ?- }' O3
4
5
7 v$ W4 A! m/ q" Y& g+ _+ R  Z, E7 H6
0 S- I. J0 N6 H* A) M1 K7
8
9
10
' f/ j  ?( U# @9 ?2 i" C11
7 W# q( J5 y1 r12
13
14
15
16
17
18
) ~/ y$ _, B) w# r8 g, U2 g+ f19
20
6 U6 O3 Q1 y) N7 L6 }- v21
9 A8 o8 j2 E( K# M22
23
24
/ R0 m7 D2 K6 T. n4 {" v% @7 g& ~25
% H8 E5 Y8 e! P26
27
3 z- ?! S9 J# L28
29
30
31
6 n0 T9 o- I1 G/ ^; x! R32
33
运行结果：


9 J; ]  K$ X- @) j$ Z测试冒泡排序:
-66 -13 -1 1 4 9 12 25 25 26 34 47 58 99 162 10093
1
2
降序排序（从大到小）


3 d6 x6 h' v' u$ C/ [//测试冒泡排序
System.out.println("测试冒泡排序:");
1 Z5 n8 }$ @% X& K& R, h% Ctemparr = nums.clone();
BubbleSort.bubbleSort(temparr,false);
for (int i = 0; i < temparr.length; i++) {
; v+ U- Q) b( t    System.out.print(temparr + " ");
}
System.out.println();
1
2
7 v4 I& A0 a$ P3 I3
% B- t  V! p, f4
5
5 B% N* H" G  M5 O6
7
% e. m, W. H  V  ^1 C8
运行结果：


测试冒泡排序:
7 }2 L# M) h7 y* V/ k6 P' f: G10093 162 99 58 47 34 26 25 25 12 9 4 1 -1 -13 -66
5 H: ]* u% ~5 Z& i0 D1
2
下面几个算法的测试也就是换了下类名和方法名（换成相应的排序算法），如果想降序就在数组后面传个false即可。我就不一一复制了，我在最下面给出含所有算法的测试类，需要的自取即可。
2 E4 r: M. ^( s( ~$ h

快速排序
简单解释：
+ O" E" T% G/ C- L( t9 G) \快速排序就是每次找一个基点（第一个元素），然后两个哨兵，一个从最前面往后走，一个从最后面往前面走，如果后面那个哨兵找到了一个比基点大的数停下来，前面那个哨兵找到比基点大的数停下来，然后交换两个哨兵找到的数，如果找不到最后两个哨兵就会碰到一起就结束，最后交换基点和哨兵相遇的地方的元素，然后就将一个序列分为比基点小的一部分和比基点大的一部分，然后递归左半部分和右半部分，最后的结果就是有序的了。

4 {0 h/ c9 J  b( S- I



: x9 ^( u) I$ F1 }
完整代码：
. c9 q* M& n: j" L2 I8 t. C$ c
' g$ Z5 w. B% g2 v, e: P: j+ p
package com.keafmd.Sequence;

7 I* B$ z# ?' x9 Q
/**
; H" W. E  D) W * Keafmd
& M4 K: A: ^0 R *
6 N/ j5 a8 y/ K* w! h3 B: D * @ClassName: QuickSort
* @Description: 快速排序
* @author: 牛哄哄的柯南
) m8 |# m9 h: v/ C * @date: 2021-06-24 10:32
# k6 a+ U1 y5 J9 {$ s. V, D */
/ ?3 H" C& N" V1 i( s# z: b: jpublic class QuickSort {

' L7 U; j( _1 h+ X
4 t8 b4 \; ?  x    //快速排序
% i) S% E9 d6 ~, H0 _    public static void quickSort(int[] arr) {
        quickSort(arr, true);
    }

, f9 c% `9 @5 j, \
$ b6 u4 d9 r, K8 l* g2 R, f    public static void quickSort(int[] arr, boolean ascending) {
& Y3 f- `  ?2 H; D( t        if (ascending) {
            quickSort(arr, 0, arr.length - 1, true);
& `# e7 m% w7 e1 D9 @        } else {
3 p1 f% s# U5 _8 Z6 Q. P. w            quickSort(arr, 0, arr.length - 1, false);
        }
& {. y( j8 {' l$ n7 g  m1 y    }


    public static void quickSort(int[] arr, int begin, int end, boolean ascending) {
6 _; |3 F3 j* [        if (ascending)
            quickSort(arr, begin, end);
        else
4 [8 p9 w1 w' ^8 q$ D$ v! {            quickSortDescending(arr, begin, end);
9 ~, b7 ?# m1 G! v. {) q    }
+ Z( D# @7 y' w2 _! j

    //快排序升序 -- 默认
    public static void quickSort(int[] arr, int begin, int end) {
        if (begin > end) { //结束条件
            return;
        }
4 c' U' h: i* N4 V) p6 s. G" O0 ]0 f        int base = arr[begin];
5 E, ?4 J. Q8 c& R3 F* V; h        int i = begin, j = end;
        while (i < j) { // 两个哨兵（i左边，j右边）没有相遇
            while (arr[j] >= base && i < j) { //哨兵j没找到比base小的
                j--;
# R5 P5 k# S# u* M! t) I; O5 d2 {            }
            while (arr <= base && i < j) { //哨兵i没找到比base大的
- h- W5 e7 G/ u8 D' i7 m) v9 G                i++;
( Q, K  d; D& |( H- z            }
            if (i < j) { //如果满足条件则交换
                int temp = arr;
$ q6 h/ p" L# r# Z  o9 T                arr = arr[j];
                arr[j] = temp;
, T9 e8 @6 D. g( c. z            }


  d6 n* d. v- W' g; V9 B        }
        //最后将基准为与i和j相等位置的数字交换
2 {# h. P. q; D4 X        arr[begin] = arr;
        arr = base;
2 P8 B. i: u" S! w        quickSort(arr, begin, i - 1); //递归调用左半数组
. ~9 F6 p' e! P( p        quickSort(arr, i + 1, end); //递归调用右半数组
) e5 b* X/ T- A) L" P" k3 p
' n0 z4 q7 J. v4 ^# ^5 `1 g3 G' M
- c! x( n: u8 o9 F    }

2 e) |& O7 b# v3 M. k6 r# s
( ~8 @9 R4 M. p/ ~9 ]; x+ @! S    //快排序降序
    public static void quickSortDescending(int[] arr, int begin, int end) {
2 t5 T# x( p6 @2 C8 V: j, x        if (begin > end) { //结束条件
            return;
; W3 F  u1 K! G% v2 z5 ]* J        }
        int base = arr[begin];
        int i = begin, j = end;
8 X. o1 ^' H1 B3 q        while (i < j) { // 两个哨兵（i左边，j右边）没有相遇
            while (arr[j] <= base && i < j) { //哨兵j没找到比base大的
/ J# T, ^3 y6 A$ W                j--;
% ]7 R4 f) U2 w            }
            while (arr >= base && i < j) { //哨兵i没找到比base小的
3 m  `3 Z5 b' k$ I3 G' n8 W$ J                i++;
            }
% n( ^: T" [( M* a1 n) A            if (i < j) { //如果满足条件则交换
                int temp = arr;
                arr = arr[j];
                arr[j] = temp;
& x7 ^: \4 Y% G; D" }            }
8 t0 v6 }) P6 W# ?: U* u5 b
( E7 Q# r8 d" y7 L# T6 d
2 [9 C) c) A* L+ Q/ o3 H5 u( _        }
, c( w) V, H4 E# X        //最后将基准为与i和j相等位置的数字交换
: {9 r! s2 v4 H# u        arr[begin] = arr;
/ ^/ {5 f; ^  D' x        arr = base;
        quickSortDescending(arr, begin, i - 1); //递归调用左半数组
! @4 K. V/ n( X& ]        quickSortDescending(arr, i + 1, end); //递归调用右半数组
% Y4 ~4 a$ |! Z. k
% ?2 A+ n" {' F
1 }7 U. G0 H' v+ p$ G: _    }
1 T7 Z' s$ {1 E6 ?
; N" `, A0 c0 z5 X: X
% y& C8 l) b0 |7 f) U. O}
1
3 Y* i7 x3 ?& A2
0 k% }; B( S6 N9 O& o- q! t3
4
5
5 z0 U) Y5 Q( Q$ @" [: Q( ~6
7
8
$ B0 w, O) M$ v6 C& Z, D9
5 t) v9 K  ]" F8 y6 V3 C10
/ s7 ^$ X$ L2 R) E8 d0 |& |5 o11
12
13
) a6 P3 U; n" K2 u1 n6 \8 P2 m14
15
16
17
* u% y# T0 ^  @9 f6 x" D* X+ V! I18
19
20
21
22
4 Z: z! c! v; h4 J, q23
# p/ q+ U4 S6 \" u- b4 ^" L24
25
26
27
28
/ T; Z, e$ ?. `7 Y6 ?) O8 F6 g29
5 y6 [* R: _2 J6 E30
& r% a" {$ x8 m6 v31
32
33
6 c- s7 a% [) P# Z# Z4 Q0 C& P34
: t3 x3 F# g, O  T3 I" c35
" \. Q0 j; U' T0 E  I36
37
" R+ `1 h! |: F+ ^  E4 G38
39
40
41
( ~8 F: k- M* b  D! y7 {. G( w42
9 l0 D- G! G4 J4 v: C3 M, p43
6 \% T- A$ {6 m$ t" u; _# S: J44
; Z3 G' v, z" s, Q1 z0 L45
9 Q3 A6 e6 f3 F, R$ r5 k46
47
48
49
50
51
52
4 s8 v9 w" D: ~53
54
55
56
57
58
59
60
8 e+ h% O& v- V- H% O0 ]' K0 S61
8 P: J1 g  M4 U3 E  E62
. `6 Z; ]! u4 k! X5 ^- a' f63
, c1 [; E$ @, @0 D2 e' X5 H. Y64
& U+ L4 Y0 _5 U* {* U65
8 N. V0 S. g/ ]8 S66
67
# T9 p5 H# m$ e" S; ^5 n7 t( |68
69
70
71
( Y. U' q" ?! m2 I1 y5 X1 O# y72
# c1 J; O! ~+ `73
5 o/ h' U$ F5 B- ~74
75
( V! g& |7 K, e; P, N76
5 ]; O. h7 q. K, J, {# c77
) ?% q' F' `# j9 ~78
79
6 v( \/ \% J& j# |- g# e- ]80
81
( _2 \6 ~$ G) s' d" |) a82
83
84
. d  v3 w% n& y. _) i85
: z9 Y, L* L; o/ P) B# ~86
87
88
89
3 j' P& X6 R& z9 a% p90
91
4 G, K/ n) A# L& a5 B- z直接选择排序
! s4 ^! q$ J( A# e% J( Y! a简单解释：
# D- m' M* C3 w! D4 I1 Y数组分为已排序部分（前面）和待排序序列（后面）
第一次肯定所有的数都是待排序的
从待排序的序列中找到最大或最小的那个元素，放到前面的已排序部分，然后一直找，不断缩小待排序的范围，直到所有的数都是已排序的了

0 O  n2 J0 Y4 n, k. \8 x8 D

2 s" p( I# c3 C! L/ A) V
7 g) E5 b0 G/ Y$ Q
! n" N. [, v3 A; f* g
完整代码：


7 w0 z% M+ C- L; y% mpackage com.keafmd.Sequence;

6 L/ E2 L/ E. Z+ z6 p
8 s( e, b, b+ t; G% [. k& ?1 p+ r/**
* Keafmd
" v" \! x! u; S *
( Y9 ?4 K" k. M) I3 J5 d& v! a * @ClassName: SelectSort
* @Description: 选择排序
, k. S1 `( }8 p * @author: 牛哄哄的柯南
* @date: 2021-06-24 10:33
*/
$ V3 B. w6 @) ypublic class SelectSort {
) v% N: e% o) m$ [  k
$ J. R5 `1 K) {% Z- U
( v5 _3 q  c4 K1 r2 u% P, t    //直接选择排序
# A% l$ U7 l, i7 {8 p; C    public static void selectSort(int[] arr, boolean ascending) {
& n) @: X2 p* x7 F. j        for (int i = 0; i < arr.length; i++) {
            int m = i; //最小值或最小值的下标
5 i# X+ z) e( e* K9 E& C            for (int j = i + 1; j < arr.length; j++) {
/ L& v. u: i: M# k# L' T                if (ascending ? arr[j] < arr[m] : arr[j] > arr[m]) {
                    m = j; //找到待排序的数中最小或最大的那个数，记录下标
$ i1 R- a2 j: h  ]                }

" l# j& G! y3 ~, K3 q% [/ e" M
/ F! a5 _  O, x4 |            }
            //交换位置
            int temp = arr;
6 H/ e. ]- \4 n: ^# ?            arr = arr[m];
            arr[m] = temp;
8 `9 U1 p6 W8 ?
( ^+ k# |  d9 X. b; V/ F9 C7 P
        }
    }

+ Q, S* M# M+ z7 z# Z# b4 X  c) e
4 B, k% u! n: h' A2 }2 z    public static void selectSort(int[] arr) {
        selectSort(arr, true);
    }
6 W; `5 R4 e! r5 i1 C+ e" L. N+ s8 }}
/ `2 K! k4 u& i6 F& W1
2
3
4
5
6
7
8
9
$ n/ h& F3 d- O' k3 [2 M10
0 l, }/ a; I5 {11
12
0 B3 B6 F- x. d4 H' v# c13
14
$ q$ ^& A' _  _15
( |' E8 L. C8 V# @+ d16
8 q: s9 T4 Q4 r. \7 T8 a17
18
19
& U2 ~  x; |9 z" L+ s6 Q, [20
21
3 i7 C1 D# I9 T22
/ v5 R, x5 W# E3 g5 ~( Y, L23
24
25
4 Z5 i! ~; F. d6 l1 |! F% e' ^26
3 L8 K  ~2 x; {7 N27
/ Z0 o9 H/ r7 L28
7 P! w, u4 y+ ~& \3 ?! y29
- n# y+ X3 w( X9 P! O8 G30
  t8 M  ^8 w0 F9 t8 Y31
32
33
34
. U6 G( I" _! o+ }堆排序
5 h+ g) k0 |5 E% G先理解下大顶堆和小顶堆，看图
大顶堆，双亲结点的值比每一个孩子结点的值都要大。根结点值最大
小顶堆，双亲结点的值比每一个孩子结点的值都要小。根结点值最小
/ }- g) }( ?6 q
( y8 y7 E& z. h1 ?

7 J8 o6 e( ?" B: G$ v
简单解释：
: j; E2 u7 b0 }4 T构建好大顶堆或小顶堆结构，这样最上面的就是最大值或最小值，那么我们取出堆顶元素，然后重新构建结构，一直取，一直重新构建，那么最后达到排序的效果了。

% M. n- h! I1 b* \% K, C
  V- q9 S0 d( q
  z& k0 F" a$ E/ N


完整代码：

, u3 @9 F0 C3 x; L
3 w0 y8 _+ r# W' }3 Epackage com.keafmd.Sequence;
# y. Y" s5 O, I2 H5 ^# k3 K
! q2 g& U+ K1 x# J( D! [3 ?' S9 N
8 I7 {2 e. I' ]/**
! n8 s! G2 v  ?; ? * Keafmd
*
' Y' A/ t. o9 W( K  w" a$ |6 ]3 u& z * @ClassName: HeapSort
; l( q2 j# x0 u* R' z: d! H/ ` * @Description: 堆排序
* @author: 牛哄哄的柯南
# Z3 M) k& i; q- c) j  W * @date: 2021-06-24 10:34
' ?2 m* X6 u( R2 F) y4 {; w */
% u. D3 Z' E3 e6 Y8 H$ spublic class HeapSort {

, j$ o0 ]" c* R& R" ], [) @8 O
    //堆排序
  f) Y' _$ B3 z1 ^) z, A% y    public static void heapSort(int[] arr) {
7 O5 D+ s& u3 ?* ]  _: }" ?        //对传入的数组进行建立堆，这里默认建立大顶堆，进行升序排列
$ b$ a$ z  W0 L% T7 ^$ H- V) y        heapSort(arr, true);
    }
8 n" q9 n* A9 J. E' C

    public static void heapSort(int[] arr, boolean maxheap) {

1 F% X" M, V/ e" Q6 ^5 S: E) ?" @1 N6 `
6 Z+ O$ a$ _& V3 ^' {        //1.构建大顶堆
2 U1 H7 D  c- v7 x        for (int i = arr.length / 2 - 1; i >= 0; i--) {
) n, w7 l9 v/ K$ B            //从第一个非叶子结点从下至上，从右至左调整结构
% `  T5 Y7 H1 s' M( y2 Q            sift(arr, i, arr.length , maxheap);
7 K7 T, j3 H6 ~( T        }
6 O  n  v) s+ L/ h% H

/ y0 L, w: a1 G        //2.调整堆结构+交换堆顶元素与末尾元素
        for (int j = arr.length - 1; j > 0; j--) {
: k+ a. V2 z' M( n2 M0 E
& F3 H5 G8 \: s3 o
* }; U8 I9 M' K$ t            //现在的数组第一个就是根结点，最小值所在，进行交换，把它放到最右边
            int temp = arr[j];
            arr[j] = arr[0];
. m  [! K$ ]& a            arr[0] = temp;
/ k6 Y9 F/ v: G4 b8 b( _
+ s  \3 C) K1 _0 [! F% `
            //重新建立堆
$ I* y8 D5 ~4 `  ^) ^- u7 m! S# F            sift(arr, 0, j , maxheap); //重新对堆进行调整
        }
    }

5 j% [2 O: f; x& b3 F- b# v
1 K, w- _7 |# o# K" e+ U& ]    //建立堆的方法
# J% j; L: X/ ^    /**
# t: a* ^7 ~: f8 }# c% t     * 私有方法，只允许被堆排序调用
     *
, q2 @' P6 ^" h# J( G7 Q     * @param arr     要排序数组
     * @param parent  当前的双亲节点
     * @param len     数组长度
& D$ D5 c# a, ?" f5 M     * @param maxheap 是否建立大顶堆
* l" ~$ o4 J! }; @( l$ I; v  h9 U     */
$ P- a3 |0 e( A- _    private static void sift(int[] arr, int parent, int len, boolean maxheap) {

+ N% ]8 K$ }$ k
        int value = arr[parent]; //先取出当前元素i
' N4 J% m$ [+ }, S! E* }

        for (int child = 2 * parent + 1; child < len; child = child * 2 + 1) { //从parent结点的左子结点开始，也就是2*parent+1处开始
9 Y8 S1 ]; {, R7 [5 q
0 J' s; N  ^- k7 ^2 ~
            if (child+1 < len && (maxheap ? arr[child] < arr[child + 1] : arr[child] > arr[child + 1])) { //如果左子结点小于右子结点，child指向右子结点
2 o8 K% Z2 E/ {, N1 j: z  C. v8 R                child++; //右孩子如果比左孩子大，我们就将现在的孩子换到右孩子
            }
( D8 P) z& [: j/ b) }

            //判断是否符合大顶堆的特性， 如果右孩子大于双亲，自然左孩子也大于双亲，符合
: w, i8 F8 [( Z+ Z% R2 k            //如果子节点大于父节点，将子节点值赋给父节点（不用进行交换)
) o( r% G+ B' W+ ?( C            if (maxheap ? value < arr[child] : value > arr[child]) {
                arr[parent]=arr[child];
                parent = child;
, N2 `7 j4 X3 Q( s! l3 O            }
/ P; |* k7 G" r8 G- y0 ^" b            else {//如果不是，说明已经符合我们的要求了。
, {- l! N2 i/ c. O/ d& `                break;
. ^2 C6 o% W; W& J2 V% _            }
        }
6 X, F" R( v" Y. f8 {# `2 d; M# `        arr[parent] =value; //将value值放到最终的位置

; `% R3 q$ i4 O6 l7 e
( h: b' }5 T7 D4 j( @
) w+ P" `1 C7 i8 w2 m: U/ A8 z* P
    }

& l1 [. X8 G: R  \
}
1
* {- K) p: P; l2
3
' F3 T1 X- D4 b8 |8 L4
& z% R" g+ @- n2 A6 y5
6
7
8
4 q/ [+ l1 w+ A$ K# r# l( f& o9
10
. v& X/ J$ S0 N4 t11
& T) |5 ~1 n! i* D% A/ R) G12
6 ?# J6 U9 E4 {1 Y' `, X2 D13
14
15
8 z8 M& f9 \( L2 {2 K  \, X" j3 C16
17
18
19
5 [8 ]* t+ z5 J* c4 ~* G20
21
22
23
24
25
! b9 @' F- C0 W6 j% i26
% J4 T7 B+ v. G# _3 \+ {4 l9 K27
4 Q) k' B) y; p) K; ?1 `28
29
- m/ `+ j9 d  I! Z. w# V3 i& _# v; z30
5 M- B: ~7 j" y% X31
32
- v6 a5 x  x* S! _1 k' E8 \* Y9 z33
. S  R# L4 {" l9 ~34
35
4 W; \2 C/ _( K, ^* d2 i36
37
5 I7 T/ H0 X, g# E  U( @" C38
: R5 \* X# f1 x( Q39
: Z- O" h/ w1 M  t40
) W3 E0 T( _: Z# D9 ^- j# Z, F3 O41
42
8 P5 h& M% }6 u, q1 I6 N43
" u7 V5 ~" T1 P/ F' n44
+ n' G& ?4 f: O2 r( ]! q45
. |5 {0 E- X/ b  a46
1 G$ W9 G, L  E  J' Q47
48
& X* i8 d7 X6 T. `49
50
4 S# d6 n' w6 u7 a  D7 I51
, R0 h3 b. V7 W# Y$ L) y( W7 i52
3 D9 T1 t# @% b* _53
0 M5 T- X& D$ D; {54
55
. v' q& N  m/ y$ b8 y56
+ C- N9 I# p! g( o2 `' ?% m& ~57
2 O* d0 N. |/ ~7 M: K* K58
59
6 Q+ ?. _$ N0 s' i60
61
1 ~9 V# l; u' |) D3 t+ v/ D" |62
63
64
65
5 O8 P) H4 K4 E& U# [66
67
68
69
3 f8 Y7 o# h1 {9 P2 [% }70
71
* E0 q7 {. a4 i5 P+ e72
73
74
归并排序
5 a( B6 j; S3 a% i" }: @3 [" }简单解释：
该算法是采用分治法，把数组不断分割，直至成为单个元素，然后比较再合并（合并的过程就是两部分分别从头开始比较，取出最小或最大元素的放到新的区域内，继续取两部分中最大或最小的元素，直到这两部分合并完，最后所有的都合并完，最后形成完整的有序序列）

, u2 R. _4 G1 P* L6 ]
5 ]: b# F$ \# @
- e6 p( n/ X% l% n( d* k0 t! w3 k4 X

/ ]2 {5 A. T  H, _  q2 n
5 h; \0 J6 J/ s1 E完整代码：
1 @, R0 A' K" h! G& k

package com.keafmd.Sequence;

/ S) v( r3 ~9 Q% r+ d# o
/**
* Keafmd
7 @2 M$ N. J8 T2 t1 R *
; ]0 d  i) Q7 }( u( b' Y3 X! p * @ClassName: MergeSort
3 E/ j4 A3 i$ a2 e$ _' i# U: {; J; r * @Description: 归并排序
; s8 N+ C7 u3 x9 [ * @author: 牛哄哄的柯南
5 U6 F1 g( A4 v. H; ? * @date: 2021-06-24 10:35
0 }  ~3 n7 v( L6 ^, [. {1 u */
public class MergeSort {

7 s5 B0 e- g( {  R: m3 U% l
    //归并排序
    public static void mergeSort(int []arr ,boolean ascending){
1 O' K. m  r& w# d        int[] temp = new int[arr.length]; //在排序前，先建好一个长度等于原数组长度的临时数组，避免递归中频繁开辟空间
( \! n5 ?2 T& v, |: L) p' Y8 T  Z8 g        mergeSort(arr,0,arr.length-1,temp,ascending);
2 [$ _* W. r  ?( H$ N; d6 e# I9 g    }
    public static void mergeSort(int []arr){
        mergeSort(arr,true);
0 f% F* G* Q1 W6 t4 g    }


4 L' a* r4 |& F& N# O# N    /**
     *
) |1 f4 a9 X, j4 t5 K* _% L     * @param arr 传入的数组
     * @param left 当前子数组的起始下标
& Y$ U& P3 G  O. H' F     * @param right 当前子数组的结束下标
7 t) ~9 S) ~8 R: F3 v/ u     * @param temp 拷贝暂存数组
     */
    public static void mergeSort(int []arr,int left,int right,int[] temp,boolean ascending){
        if(left<right){ //这里是递归结束的条件，我们是对半分，那当left==right的时候肯定大家都是只有一个元素了。


% i$ k% R: g7 j. F& F( d) |2 R            //对半分，比如总长度是10，left=0，right=9，mid=4确实是中间分了，0~4，5~9
            //当长度9，left=0，right=8，mid=4，0~4，5~8
            int mid = left + (right-left)/2; // 防止越界的写法
            //int mid = (left+right)/2;


6 t1 K! f% s8 ?, e            mergeSort(arr,left,mid,temp,ascending); //左边归并排序，使得左子序列有序
            mergeSort(arr,mid+1,right,temp,ascending); //右边归并排序，使得右子序列有序

- v' a0 t  b) ~4 h7 \6 f+ a* I6 k
            merge(arr,left,mid,right,temp,ascending); //将两个有序子数组合并操作
        }
- P2 W* J/ |; K& a. L6 m: }" I    }
2 z4 q0 ~8 v( {& I

# A8 R4 F4 L4 \' i    private static void merge(int[] arr,int left,int mid,int right,int[] temp,boolean ascending){
        int i = left; //左序列起始下标
        int j = mid+1; //右序列起始下标
4 w- q9 E1 \* b# d+ p6 Y        int t = 0; //临时数组指针
/ H  Y& j' ~$ M* d" {* G) s        while(i<=mid&&j<=right){
            if(ascending?arr<arr[j]:arr>arr[j]){ //比较两个序列第一个元素谁小，谁小先拷贝谁到temp，然后对应子序列下标加1
                temp[t++] = arr[i++];
            }else {
                temp[t++] = arr[j++];
8 a" }) n+ }0 h) c* |* x' g            }
        }
1 V. |& u, W( u
; E+ _/ q+ p( ~; ~5 r* C0 }6 P
: `8 K8 D% Q' q& J& N! J' w        while(i<=mid){ //将左边剩余元素填充进temp中——左序列有一些数总是比右边的大的数
; w: c, `0 ]& H" x* e, q            temp[t++] = arr[i++];
4 _# O4 A# r  i0 J8 a. w  G        }
* x5 t9 K1 J2 x- J+ n9 b

        while(j<=right){ //将右序列剩余元素填充进temp中——右序列有一些数总是比左边的大的数
            temp[t++] = arr[j++];
, u2 H. P3 t! ^/ e        }
$ P$ a9 W. F+ l' b1 U4 ^

0 H' o: C, o" {5 r4 {3 x        t = 0;
/ v/ B3 c* ?/ |: F4 J# [; \# Y

        //将temp中的元素全部拷贝到原数组中
9 O# J- p/ t2 j1 z- b0 q9 ?        while(left<=right){
: n9 X* O; J- F            arr[left++] = temp[t++];
        }
8 t# E! z8 O$ L+ E* K
- i( l3 C' ]  Q3 |* `9 Y6 V+ C* w
7 w5 q8 ^' B9 G, i) G- x- O    }
. I& t9 F, f- ~9 O% C" Q' _0 V7 y
. P$ ?1 D9 Z0 D
}
1
' v& w6 w2 F0 B+ y9 X- a/ E) \2
3
% z1 g* i, A8 \4 e6 ~4
8 ^- K7 n5 g% _, m, [. u5
6 [/ K- n# n" l6
: u% N0 _4 U4 o# V3 o( t7
8
7 h5 d; q* Z( n$ @* v$ |' A9
8 F4 \. ~9 S8 Y( o( M) A$ ?10
11
12
# y- o, ^* s. H/ f' ^$ @$ r8 ^13
! A+ T1 B) g7 \- w3 d1 x14
; K) m/ M4 a  F  Y" d. o# ^* P+ h% P$ w15
$ W* P3 n  d8 P$ r2 E/ m+ U4 k& }16
17
3 @! ^2 u- D! N% c) M% |18
. z# k4 a1 W. o& t1 o19
2 t: z: |; y) P5 j3 v$ W20
' X/ E) _' L) ^0 `% v- o( z% @' |5 \21
22
23
4 p/ e0 d* X1 O, d) Q3 `) l+ {- A24
( F1 n/ A  q7 N25
26
- b9 j  d% v3 L27
28
29
30
& a/ M" ~7 Y% k! u$ B31
1 j" e4 T& v' k+ K0 |4 Y! c" n7 `32
33
34
. w. Q5 I' w* d35
36
' h5 m, C$ H, i37
38
39
; v, x  Q: \! o: M. ]3 [- V40
1 ~0 `# |/ G3 y( }41
42
43
44
$ i: _7 I6 z) d; w45
9 F( r, G7 }& t4 t8 v46
' I  ]1 O# g5 c/ `7 U) M47
3 J6 t* B. h; A! X& m9 z2 A8 B48
49
+ Q$ c7 Q; j8 k! e, I50
3 N5 U/ C5 H$ J  M5 ]9 l51
6 f8 S& K1 n1 X9 V52
* l- G7 J0 A9 N0 Q/ `53
# o6 x6 t, j0 O, r' y  A; P54
% [. F9 m: R2 p! f# N; g, v55
0 n$ A( v8 F$ e# X56
6 a& F5 y5 d9 J* k& n/ z# H57
58
& X& V0 w0 N  b7 z* X- Y2 D* I7 d59
60
61
62
$ S, g( C. c2 R8 X: a8 ?+ w63
1 Y. U5 r) d3 g0 B# n64
2 z, Q% u3 C6 v5 i+ g) B65
66
# @* b/ \* M# Y1 j$ V' U! `! C67
68
69
8 }- N% G) D8 P" f1 R+ h7 t2 O% j70
71
72
1 n9 T5 c" Z  j73
插入排序
简单解释：
- Y: {( {; Z1 F7 s* a" L  p最简单的理解就是打地主时我们拿到牌后的整理过程，从第二个牌（假设我们拿起来这个牌开始比较）开始，（说下升序）从后往前比较如果比前面的那个牌小，就把牌往后移动，直到找到一个合适的位置（这个位置的前面的那个牌不比这个要放下的牌大）就把这个牌放到这个位置，慢慢的前面的部分变得有序，直至全部有序即可。




9 Z" P" ~& ?4 I* v  k8 Y
2 ]! \3 ~/ `( p8 E7 f
完整代码：
' R# |* I# w  V' D
3 H( l: y' h3 g! @, @
package com.keafmd.Sequence;
! u3 k9 v2 L9 O- S4 M9 L& R

: O8 H8 H4 r) d7 j% c" f$ h/**
: \" Y5 t$ L; q$ f8 H * Keafmd
) m) l7 m' u* f7 l *
* @ClassName: StraghtInsertSort
* @Description: 插入排序
* @author: 牛哄哄的柯南
$ X% z5 D3 ~0 o9 k" y7 d * @date: 2021-06-24 10:36
& j  t: o* i1 L3 n# i+ ^ */
public class StraghtInsertSort {
    //插入排序
, F  h. h6 R% P* @/ |5 H% U    public static void straghtInsertSort(int[] arr) {
        straghtInsertSort(arr, true);//默认进行升序
    }
# \+ S% y$ H7 D: @. a
; r5 X1 j$ M0 A
8 s2 _+ X, Y, e( o    public static void straghtInsertSort(int[] arr, boolean ascending) {
& T& d4 o+ j. I3 E7 {! z; l# V

3 `4 D( I9 i6 ?/ ~- E8 q        for (int i = 1; i < arr.length; i++) {
            int temp = arr;
            int j=0; //这就是那个合适的位置
* Q" V! m4 G6 ]# V8 J            for (j = i - 1; j >= 0 && (ascending ? temp < arr[j] : temp > arr[j]); j--) {
0 |+ I; u8 w1 O, O2 o) I" v                arr[j + 1] = arr[j];
$ S: b. e' b  ]( _0 w7 w            }
            //把牌放下，为啥是j+1，
            //是因为上面的循环遍历到不符合情况的时候 j是合适的位置的前面的那个数的位置
* Z, n' a6 z/ O2 e            //有点拗口，但是就是这个意思，看图方便理解下
            arr[j + 1] = temp;


) f* `) r' P9 d# i( l  K4 C

        }
7 v  \/ G, U4 p6 z
. r6 ~# a5 k  v3 A& K
    }
7 K% t& v# F* T}
4 \0 O. H8 K0 c5 l4 d' u1
- q5 F- t- v8 o3 I- Y6 k& g2
3
$ `( X3 a3 ~! q  S. {1 p$ Y2 M8 o4
5
6
7
8
9
6 m% i8 A/ u, ~6 Y10
11
3 v4 Q9 y0 ^/ A+ S: }) n12
13
14
15
16
17
18
19
20
21
8 f. L3 K2 x8 c3 ?6 p' o$ G- C$ h* h22
23
# h6 C& H' f6 j2 s; e+ J1 \: {* s24
* M3 d, x  `! f" U8 Z9 {. M25
26
27
# r; s) `) N& E; y$ \' X28
/ |* B. f" g7 a29
+ _6 k; ]# O" |* X& ?30
31
32
33
/ w( ]* T+ p5 d; A2 r; A  e34
希尔排序
  E: n' k" W) S4 s% X9 Q简单解释：
1 R2 O& l2 H3 w9 ^希尔排序是插入排序的改进版，我们理解一个叫做下标差的的东西，也就是下面那个图中的增量d，初始下标差为arr.length/2，然后继续/2，对在同一下标差（相当于把这几个数单独拿出来了）的若干个数进行插入排序即可。
4 O) G4 U' Z1 G9 y& Z: w2 {% @
; q+ Y1 [+ J  V  F+ ^" x1 Q
5 S: U% u' d1 \4 D7 U  m$ p7 a



6 o, v1 D3 e7 s完整代码：

# B' p- n/ o5 ]* p" ~6 ^7 o
0 B: H, \. X8 s5 U+ X+ R: |package com.keafmd.Sequence;


/**
; E: u/ {) O: H; A; U  X% O% U * Keafmd
*
. l- ^! \5 t, u9 T  ] * @ClassName: ShellSort
* @Description: 希尔排序
* x& b) y4 d+ w( W- {* a! J * @author: 牛哄哄的柯南
5 B: m; e8 g$ \9 n( Z, q * @date: 2021-06-24 10:39
! k$ K% I- m; F' E( |( E */
public class ShellSort {
2 L' t/ {. h9 Z" r' R4 W: I0 l
# L8 Q  F0 f) v; i
    public static void shellSort(int[] arr) {
        shellSort(arr,true);
    }

+ X0 h! x/ L& m, f$ C& L8 W
  I' y. Y( _3 O/ m) m) x    public static void shellSort(int[] arr,boolean ascending) {
# H* Z/ p' i4 h, h8 }
: |4 o* F7 u3 o
        for(int d = arr.length/2;d>0;d/=2){


% ^/ v7 Z9 n$ m            for(int i=d;i< arr.length;i++){
                int temp = arr;
5 i- R& Q' x/ t5 q                int j=0;
                for(j=i-d;j>=0&&(ascending?temp<arr[j]:temp>arr[j]);j-=d){
                    arr[j+d]=arr[j];
7 [+ W2 S$ ~/ k) _& J                }
" G9 c4 W& s4 F1 e8 r                arr[j+d] = temp;
            }
# U7 B! p& {, a# |5 [        }
- Z+ P* A/ H, v- o4 s9 l! [

    }
& ]! X3 M- t( d* f" Z( I- x" e}
1
2
9 {0 [4 a7 d  x3
) L$ k! F4 b/ V, _8 t! b  J/ O" Q4
5
$ e# Q( I$ u# J7 B' Q! G7 [) l3 M6
7
8
9
10
11
1 X6 K, ]6 {  y5 K& c" C12
13
14
15
+ m- B: x" @0 m; b! O  _6 p16
17
18
( V, u, K# q) P1 B  r2 v2 V19
20
21
5 y* @2 `/ N+ a" x: G22
$ }' `, ^1 N. s7 Q( [! k. e# o) n23
24
25
26
& h  C+ P; r: G% ^2 e8 `+ X; w+ [7 i27
28
29
  H" J% Q( K/ f9 b) K* l30
31
32
计数排序
简单解释：
. ^* Z2 }, x* O: O* c这个排序算法看名字也很好理解，就是就是额外找个数组来计数，然后在这个数组从小到大或从大到小把数取出来即可。

0 x% @- h$ |$ U* [4 x


9 o6 ]; X) q7 V# n6 i7 B

完整代码：

. Z: O6 D4 A3 k, e
package com.keafmd.Sequence;
, X4 e! f  w4 F  h) C) v# P

/**
* Keafmd
! h& L/ \$ j4 q- W6 J2 c6 v* ~ *
$ k  G0 o; A8 \4 M$ J * @ClassName: CountSort
5 X- n6 x. c9 v1 S8 e * @Description: 计数排序
* @author: 牛哄哄的柯南
, l3 b" p# J1 P7 I * @date: 2021-06-24 11:31
1 m' U9 f8 F& M6 B3 ~  E! }$ `! V */
0 v$ o9 e/ o9 Z- v$ y  ]$ A3 ]public class CountSort {
  J0 }+ Y: ~1 T2 F! G8 n; ^
3 d, @$ b2 H: U4 L0 G" F, C
: B& j3 I  b( H0 P    public static void countSort(int[]arr){
; X0 t( \- w0 ?1 `; X! q  X        countSort(arr,true);
) W# _# ~4 X" r- S4 X$ e8 E1 A    }

: Y! L4 j$ {8 Y
    public static void countSort(int[]arr,boolean ascending){
7 Y- j2 K7 C  ~+ @5 w        int d,min=arr[0],max=arr[0];

* h6 Y7 A' [; c. {# `8 G6 g  L0 v5 p
8 |' L3 g( d! T; E        //找出最大、最小值
. a6 \* b5 p. Y0 }        for(int i=0;i< arr.length;i++){
. S; j% F; U4 c* p) ]% y            if(arr<min){
                min =arr;
            }
            if(arr>max){
                max = arr;
: |6 q+ O# A8 C* C# N, L* ]            }
        }

7 ^9 R- }! g" ?4 B/ r9 a
        //建立一个用于计数的数组
        d = min;
        int[] count_map = new int[max-min+1];
8 A9 H6 S2 \1 c9 t$ w/ M        for(int i=0;i< arr.length;i++){
            count_map[arr-d]++;
0 x9 d8 l5 e0 [6 U6 R5 n        }
/ y) `% F2 X# x

8 c9 _  y  c$ l6 y- B' f        int k =0;
* v1 o7 Q2 p3 P9 _7 [% t        if(ascending){
' D; f' Q) e4 u2 k, Y            for(int i=0;i< arr.length;){
6 G1 {0 J- H9 q0 Z7 O) q+ q' o! y9 q2 t                if(count_map[k]>0){
/ P  ]; [4 E) t                    arr = k+d;
                    i++;
                    count_map[k]--;
                }else
                    k++;
            }
1 O- L! h9 m) e+ Q, n9 L        }else {
            for(int i=arr.length-1;i>=0;){
                if(count_map[k]>0){
8 @4 ^6 _4 W5 v) Q  v                    arr = k+d;
8 n, F6 M% m* \1 V. I' `; k+ S                    i--;
5 |- @$ p! q3 Y1 S# m( s                    count_map[k]--;
                }else
5 r! e4 D: ?' u4 j+ p. m- F3 N                    k++;
            }
- U+ I* J: M2 ~' n; `        }


    }
}
1
/ ^; n3 ~/ i" `, N2
8 w' U5 M3 W9 f3
3 K: F. i4 o5 U4
5 y; j( T$ G, P7 e% f5
" @# ^4 ^' n$ v$ e2 X2 v6
7
/ D. N5 a1 ]9 B' Y3 V% s5 L8
2 S( E* n% T: y5 g( F( R) y! ~9
/ F0 W& U2 ~; E10
11
3 i( u+ S' k, ]% V3 x; }12
13
5 _& W2 h7 ?) [+ j2 G+ E9 H14
) m) y: E/ ]3 I8 _; y1 D15
+ u0 i- g/ m: Z8 ]$ y3 D0 c16
1 {9 Y- Y/ P) l17
18
$ _+ ~  Y/ q+ P8 X% Y, ^19
20
21
22
23
! O5 h/ J7 `# m3 O$ l, o24
25
5 F  {" c  F1 Q& x3 A26
6 d- B. {  [! Z" i8 O- ^27
28
29
30
/ W2 ?1 w) U8 d- i31
32
! K5 S, o4 {: ]: m/ b1 Q; T' p! i33
5 }6 z$ [" @. _- s" @34
2 F5 F) p2 u, a8 B7 k9 e& |) F- o( o35
36
' Y; f( m0 l: C- X8 D9 ~4 P37
38
39
40
41
' K$ S5 U8 F) ]+ s9 j  s2 j7 A% O$ J1 h42
43
  }! i+ O% X: Y% P' U44
45
9 O+ U& h- ~  E  x* b1 Y$ o46
47
8 j" H9 r6 k  s0 w+ b. B2 S0 h48
# J) N% b8 K% _/ G# a49
1 U6 v2 W. N/ \50
51
8 j$ P% t: q, J1 F52
) v* a+ v0 b) h+ {' e53
54
55
' i* G, c8 `& B3 N# v56
57
58
* O. J/ [/ ^% h" Z: I59
2 x* L5 G, _" v7 d桶排序
# ~& d( c" i" q7 d  T# B简单解释：
就是把一个数组分成几个桶（其实是几个区间，从小到大或从大到小的几个区间）装，然后让每个桶（区间）有序，然后取出来放一起就可以了，相当于把几个有序的段拿出来放一起，自然还是有序的，当然需要是按照区间的顺序拿了。

0 f4 E9 V& B% H& r8 H3 l+ h5 T

% l* s# t# D& I: G' d
  |0 l6 |2 u9 ~- k' k
' F; {4 u6 O" ~/ b! [/ X3 F
完整代码：
2 D1 J6 V1 B, U* B* \3 q
, H1 N( E' P: \4 Z, ^7 `9 y- |
0 k, V( h$ \" \6 jpackage com.keafmd.Sequence;
6 }+ \* `6 v! O

- C7 i; ~" m4 ]' X. q# kimport java.util.ArrayList;
: L9 |+ t4 G. \% C* V; aimport java.util.Collections;
& t) {( S7 `2 K- p. ]
6 {; y& X; n& c4 y( a
/**
* Keafmd
% T2 h# a6 q9 ^9 W% } *
. t# S. q: h- [& K/ ]( u * @ClassName: BucketSort
+ E+ g7 S4 U* f6 S! W0 L * @Description: 桶排序
+ s6 h5 w" I. d# _: f2 ~ * @author: 牛哄哄的柯南
* @date: 2021-06-24 13:32
*/
public class BucketSort {


% t2 }9 u: h* Q* u    public static void bucketSort(int[] arr){
        bucketSort(arr,true);
    }
" e: S5 T% m2 a; D7 c

, x9 }1 y0 l9 Z7 Q% c+ k    public static void bucketSort(int[] arr,boolean ascending){
        if(arr==null||arr.length==0){
1 d9 F3 w' p& i4 ]- X            return;
        }
0 E( I. \+ |  c% e        //计算最大值与最小值
6 S* b8 _5 ]1 M; y: n        int max = Integer.MIN_VALUE;
        int min = Integer.MAX_VALUE;
        for(int i=0;i<arr.length;i++){
/ i6 F" C" {9 F9 A& o            max = Math.max(arr,max);
& C" K/ E5 Z7 [            min = Math.min(arr,min);
        }
7 I4 A: {$ Z# p& o/ L" j$ l- k' q0 `
5 Z) ~0 W' d3 K$ k7 T) C( ]( c
        //计算桶的数量
3 z# \3 e# S* {5 S        int bucketNUm = (max-min)/ arr.length+1;
        ArrayList<ArrayList<Integer>> bucketArr = new ArrayList<>(bucketNUm);
        for(int i=0;i<bucketNUm;i++){
7 B6 @. M9 M% O8 Z3 `# v& e# c0 R            bucketArr.add(new ArrayList<>());
        }

  Q6 e1 T! ?+ V1 \8 M2 y, A
; E& k; I" x  v0 m' X( N        //将每个元素放入桶中
4 x+ a  |6 ]8 [+ ?5 C6 C& w2 A        for(int i=0;i<arr.length;i++){
) I4 T& z' B9 Q            int num = (arr-min)/ (arr.length);
0 k- N% I- |& F. h            bucketArr.get(num).add(arr);
  q: {* o: R2 W# y' I        }


        //对每个桶进行排序
$ n8 u% E; J/ U        for (int i = 0; i < bucketArr.size(); i++) {
2 y3 A; d7 [. h" ?            //用系统的排序，速度肯定没话说
4 Q# L+ F  B7 L; a5 m            Collections.sort(bucketArr.get(i));
6 F$ s" H" J% B9 s: ]: A        }


9 p1 c: h) [3 H        //将桶中元素赋值到原序列
" M) o5 L) F( ]9 u' j+ \        int index;
        if(ascending){
            index=0;
        }else{
& U0 p& J& B0 M! y            index=arr.length-1;
        }

1 p# V# {2 E3 G) g: e$ ]
' S) _  S2 E% |9 r        for(int i=0;i<bucketArr.size();i++){
" w2 n4 M; z6 h; M# E/ z            for(int j= 0;j<bucketArr.get(i).size();j++){
                arr[index] = bucketArr.get(i).get(j);
' L. l: P+ I1 ~! ^3 b& ^7 u, x8 S                if(ascending){
                    index++;
$ e" v, d7 E4 F                }else{
) q/ s5 K1 {3 b                    index--;
+ {1 ~- I- S! ]0 T& Q                }
" I' d, J0 @1 c; R& m            }
* N% J9 X; o: [

        }


( ~3 v4 r1 M: v1 C    }
}
8 ^8 }) Y6 q% O% p5 X7 w% {0 s* J1
2
2 u# W& F0 Z4 q. \* o4 d3
3 ]( S! R- Q) a  D% I4
7 t  A" s! c7 n9 r/ m7 H) @3 g: c5
+ ?" B9 Z& m0 C) Y" @( u5 F# z6
# Q4 r; u* P8 P1 F5 U* ]6 j/ G& P7
8
6 ?" Z+ o& B' M5 C2 m3 ?( p9
10
11
4 z4 H4 S2 C8 y12
) X3 t/ w! Y3 B  {5 D3 l/ k+ N( N13
* U) o; a2 k' I% d; v) J" d! X  M14
. Q% p& |: j+ r5 a! K15
( q2 P" Q) L- `% ^/ }  l16
" l# X3 B. w5 {: s, \, D+ g; L& q% K, h17
& u0 \# J8 z+ ^18
9 Y- j4 l# ^+ R) g19
20
21
8 R! S" r8 @( C# M2 P; S+ |: k; {22
23
24
( R1 N/ l/ |' D) k25
26
# Q$ K* K1 P# a) Y3 A: h27
- s5 e& B# O# V5 |& j28
; w6 u6 p/ P! a( T5 t$ F  P) D2 y29
5 k* c; ?8 \! y8 ^30
7 A4 @+ T  H8 I+ P9 t31
32
33
34
& i7 J  c) I7 [2 O7 P35
- O' x1 K! a. R0 g) L( F2 @36
37
38
39
) ]4 T8 x, a" J) N7 X40
41
42
43
7 b4 G5 ]( I9 V' ]) d44
+ }3 e+ X4 N: S$ N7 |45
0 n$ W2 o; H$ I, ~" D46
47
- D3 o- d/ u  B4 O. F48
49
50
51
52
53
54
7 @0 L* P7 f) x$ p, W9 \1 H. g; w55
56
57
% |6 u% Q4 {2 `& P# V1 N5 U58
59
! W) E) f9 S" u1 K7 |, w- {' D60
* b6 \7 H! e! k61
62
63
2 ~: c( B1 ^- J& p* k64
; ~9 v7 {5 k7 c3 {# k  a3 }9 y65
66
67
3 [* H% N% t4 C68
5 `$ [- Z6 Z7 M0 j3 ]! g69
6 ]' o7 w- U% c8 p/ d$ S70
4 p2 v; ?# ~7 j9 n; |" O2 S71
72
基数排序
' r* Z  J9 O8 m0 b: S简单解释：
% a5 R4 z/ K0 L' i$ X: K首先说一下，我发现好多人写的基数排序只能排序正整数，其实只要处理下就可以排序含有负数的了，就是我们排序前先把所有的数整体变大（就是减上最小的负数，也就是加了），都变成正数，然后排序好之后，在减下来（加上最小的负数，也就减了）就好了。
基数排序就是按数位排序可分为LSD（从最低位[也就是个位]开始排序）和MSD（从最高位开始排序），下面写的事LSD基数排序。
/ K' o* V+ N( B基数排序就是把数按位考虑，让后我们一位数只能是[0，9]，就是我们在考虑某位（个位、百位· · ·）的时候就只看这个位的数，放到在[0，9]相应的位置，然后顺序取出，最后再按其它位这样操作（上面说了要不从低位开始到高位，要不就是从高位到低位）
9 b( a. [- x" e  h

% G; ~7 }$ {, e4 ^) Y) ~- e! W& R4 `
7 w. S( }1 `  ]* ]& [
# x4 _, X8 X0 R/ [5 y1 D
$ g9 h  T, M/ V+ d
完整代码：

$ r8 m+ d6 e6 t
* l9 v4 b/ Y! q$ f, dpackage com.keafmd.Sequence;


0 E+ N) P8 J0 C/**
* Keafmd
*
8 E% O( y! m, O$ }( v( T8 ` * @ClassName: RadixSort
; B: z* I* q9 O" p( n * @Description: 基数排序
* @author: 牛哄哄的柯南
* @date: 2021-06-24 14:32
  u; |3 k; @/ K) i( R# w8 l */
0 g: q2 B/ l5 y$ w& X7 N* M0 k8 ~: h! fpublic class RadixSort {
    public static void radixSort(int[] arr){
% r6 {& }8 v9 z  b        radixSort(arr,true);
1 m6 b# g. z9 y- ?2 R. P    }
/ ^6 m6 ^4 o& _( g* C    public static void radixSort(int[]arr,boolean ascending){
% y7 h: N  X& Q' a2 M3 i7 {        int max = Integer.MIN_VALUE;
        int min = Integer.MAX_VALUE;
        //求出最大值、最小值
4 B8 |2 X. G) n        for (int i = 0; i < arr.length; i++) {
            max = Math.max(max, arr);
; U# |6 ]! N# ?5 A6 \            min = Math.min(min, arr);
% H1 a; R( S6 M. X        }
. v0 R% }6 G$ `# I        if (min<0) {        //如果最小值小于0，那么把每个数都减去最小值，这样可以保证最小的数是0
: l; ?# P+ R3 z/ J            for (int i = 0; i < arr.length; i++) {
  D7 k$ W! C; Q% _+ ^) |: u                arr -= min;
            }
            max -= min; //max也要处理！
        }
# @: V( r1 G4 B        //很巧妙求出最大的数有多少位
7 N5 B+ {# [- ^8 }" o) ?; F% X        int maxLength = (max+"").length();
        int[][] bucket = new int[10][arr.length]; //一个二维数组，一维代表0到9，二维存放符合数
        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++) {
) O+ K+ e! ]. d0 f  Z                int value = arr[j]/n % 10;
4 l( f0 l' `" M& p1 A2 J                bucket[value][bucketElementCount[value]] = arr[j];
: o+ i$ K$ F, P0 S5 H# G( P% _                bucketElementCount[value]++;
            }
: a& w0 D7 [/ X7 c# T
( l2 ?0 W6 V6 f$ x
            //升序
            if(ascending) {
+ R+ z% o8 g' [- y2 Y                int index = 0;
                //从左到右，从下到上取出每个数
+ j& \8 D& A0 ^& i                for (int j = 0; j < bucketElementCount.length; j++) {
  A6 ~! ~* _" G; o& Z' Y& Y5 [                    if (bucketElementCount[j] != 0) {
                        for (int k = 0; k < bucketElementCount[j]; k++) {
  d, _. M: u# p8 U/ u: e                            arr[index] = bucket[j][k];
                            index++;
, @, q2 X3 Z" ~                        }
; [7 l! _+ O: o, @: {                    }
                    bucketElementCount[j] = 0;
                }
            }else { // 降序
                int index=0;
) w- q1 B5 M% v; C& r0 m4 d                //从右到左，从下到上取出每个数
) s- i* B0 G- g1 X                for (int j = bucketElementCount.length-1; j >=0; j--) {
                    if (bucketElementCount[j] != 0) {
                        for (int k = 0; k <bucketElementCount[j]; k++) {
& t' M3 M  T& z                            arr[index] = bucket[j][k];
" M4 A. C7 t% d+ y                            index++;
                        }
                    }
$ o: v( ~4 ^, ]0 c% j/ b5 Z                    bucketElementCount[j] = 0;
# W9 N/ J& h! M" w# @, X6 a8 M! Y0 }. Z# ]                }
            }
9 H2 m  l  n% x) p
2 L& _$ O& f5 B& ^- g
# {& V$ @2 s4 E8 k

( @' W. W$ |9 b  t3 V$ `# b3 g# Z            /*for (int i1 = 0; i1 < arr.length; i1++) {
  c8 J) u8 Y9 {7 M8 r                System.out.print(arr[i1]+" ");
" d  u  {) m3 W            }
5 r" d  A& R! {, p. k            System.out.println();*/
. N2 H6 g8 s8 ]# s) m- y
: X& h1 }# b/ D4 e7 q7 e

/ z! W- t. `: O$ y
8 ?1 f- i7 h3 s6 {
* i; \% Z0 [: e! v' B" [
        }
        if (min<0){
, w1 X  A& _- Q. i7 v            for (int i = 0; i < arr.length ; i++) {
9 K+ _# K6 k6 p- O                arr += min;
" E) ]6 F$ j+ e+ e  ^            }
1 x3 y" I7 f' i: `8 q3 j0 v        }

) |7 F1 c5 K' j) |$ D2 i9 r5 P( m
    }
/ m! J" k/ d& M$ w; G2 v}
1
2
4 G6 k2 v: h2 Z# W+ t9 Y3
4
+ U/ ]5 l# M; r5
4 E( K1 N; {; _& g/ g1 G6
7
9 L; B' y& p( n/ s( q7 M  @8
! k. Q4 y* K' C8 M9
10
11
12
2 m! e, t# ^5 @13
14
2 k- T/ V; \* h+ c15
8 m& G# V; T9 `' B" t$ }16
( V( E4 F: N3 o  o5 B17
18
19
# W( I5 L  }2 j1 M20
2 A/ w+ }9 \# x5 ?% X7 |8 Z21
! S( |: }( ~. v- c) ?/ Z22
23
$ N) \+ w1 u. K5 Q+ _# A& T  ?24
25
+ ^" y1 r0 A2 Y/ a  q3 P26
27
28
6 }+ _; x% G; U( A4 z29
$ z) z/ k# u, U  ]8 i7 a4 C7 H30
31
7 _# }9 I. `$ D% Y9 N3 |" q32
& [7 Y: u  q6 o( z. @2 c  K33
8 h+ G$ r7 C2 ?6 k& B34
35
36
37
38
39
40
5 p9 `6 V% M0 s7 ~2 K$ X( M* ?! k41
42
43
44
45
46
! k0 H0 q" v; r/ K  ]) e47
: x7 c$ ~) t) R9 S* l/ P, m48
* s- j$ c  G  ~49
50
51
! g, `! q+ F+ x/ o- a52
# f, y# p1 A- X! o  T) i" F7 R4 u53
54
- }7 ^- Y( M# V" X- V0 _) _55
56
57
58
59
60
61
' A3 }8 {* t7 R4 V" L62
63
64
9 i& @- d( K. {! }9 x8 d. B65
! `% H1 L; M* q8 g& l2 `+ m& a' ]66
67
68
; n5 u' a1 O9 i* V+ s) T, s- {69
70
71
3 D# E/ z' y5 D* X72
73
7 Q; y+ c* `: U# t7 w: m+ c74
75
76
3 C% Q* E" o8 _2 }7 h( b77
78
% U7 q; p7 ]2 W# P5 A+ r  V79
( \* H" J- ?) K80
9 X) B9 P4 |+ E81
3 i6 ~9 V+ ^5 [" \82
; z/ b0 y7 [, h$ F. ]4 D" s83
完整测试类
package com.keafmd.Sequence;
- T: K: D1 {, y( q+ @
/ @2 ]' Y) i( n5 Y  o
+ s4 h" j, c' Aimport java.util.*;
  Q$ K  U# U! \& s. e1 V" himport java.util.stream.IntStream;
import java.util.stream.Stream;
* t; |' k  e, G4 U& [" \& I1 r# t: ^

/**
3 I1 T# g# u$ N( q * Keafmd
*
* @ClassName: Sort
; C# m% X+ O4 m  k2 _) g* T * @Description: 十大排序算法测试类
* @author: 牛哄哄的柯南
* @date: 2021-06-16 21:27
) V3 ]$ a! n- I( u: ]+ X# K */
public class Sort {

" P' A# f* B& O' p2 H/ ?

  f5 a$ F+ L6 |+ x* z7 P. ^- ^- `
    public static void main(String[] args) {

* m) d# G2 i7 b6 l. U& x, {
        int[] nums = {12, 4, 25, 47, 58, 34, 25, 9, 99, 26, 1, -13, 162, 10093, -66, -1};
& n. A0 N  U( G5 Z//        int[] nums = {12, 43,56,42,26,11};
$ p$ e* W* x: A6 \2 F. g        int[] temparr;
6 K' l# c/ M. L6 w

        //利用系统Collections.sort方法进行对比
5 D: \& J4 l+ S% v) B9 L  \" x
- ]( ~0 o6 s0 `* X" ^" K
; y7 N) ]/ U: L# p8 n7 E, O* C% t        //将int数组转换为Integer数组
& ^. R8 |! }2 E& \& f        //1、先将int数组转换为数值流
        temparr = nums.clone();
) {% A0 \3 z# V- @9 G        IntStream stream = Arrays.stream(temparr);
& u) W! h! I; u, w2 u" V- q        //2、流中的元素全部装箱，转换为流 ---->int转为Integer
        Stream<Integer> integerStream = stream.boxed();
        //3、将流转换为数组
0 E! O* P. Q9 I* Q        Integer[] integers = integerStream.toArray(Integer[]::new);
        //把数组转为List
- w) s4 B& i% K) Z& h7 ]9 C        List<Integer> tempList = new ArrayList<>(Arrays.asList(integers));
        //使用Collections.sort()排序
% W7 ~' p; |# j        System.out.println("使用系统的Collections.sort()的对比:");


        //Collections.sort
" c5 v0 o, x  f/ i- d        Collections.sort(tempList, new Comparator<Integer>() {
            @Override
/ I. e( p7 i  y! j" k            public int compare(Integer o1, Integer o2) {
# T! l: a3 [  X                return o1-o2;
                //return o2-o1;
# j( C' `1 Y9 _            }
6 n% v+ V8 c. B' A        });
$ W6 Y% I+ U4 @  I! d1 C

5 f1 a% A+ v0 w  L        //tempList.sort 也可以排序
       /* tempList.sort(new Comparator<Integer>() {
            @Override
            public int compare(Integer o1, Integer o2) {
& a6 j' Z+ Q, Z/ Q2 J                //return o1-o2;
* P, h' D" d5 R# g                return o2-o1;
            }
        });*/

4 Z" L  q, y3 t& z
        //遍历输出结果
        for (Integer integer : tempList) {
            System.out.print(integer+" ");
        }
# Y0 m+ y2 z3 r7 D% e) P9 K
$ Z; t+ r5 a  i( t0 Y
- w0 s7 Z& y! N0 G: n1 P        System.out.println();
: _3 P% H% A) Y3 J, V
& d( N  B& ?; J* b1 D) n. q
        //测试冒泡排序
1 r  A8 C+ w6 @. Y) x+ b' I! t) Y        System.out.println("测试冒泡排序:");
        temparr = nums.clone();
: A; t: T0 p) G; v

- ~7 a% [+ X* L: u( V        BubbleSort.bubbleSort(temparr);


        //降序
! Q- s2 S, I! o* o, i        //BubbleSort.bubbleSort(temparr,false);

; i7 D6 L6 j$ o# C7 I& J" M8 h5 q
        for (int i = 0; i < temparr.length; i++) {
' P8 v, H) a( |  Z            System.out.print(temparr + " ");
# m! c2 J) B3 f' O" ~: A/ u' D        }
        System.out.println();


        //测试快速排序
        System.out.println("测试快速排序:");
        temparr = nums.clone();
        QuickSort.quickSort(temparr);
! L. ^, r: t3 w) v        //QuickSort.quickSort(temparr,false);
        for (int i = 0; i < temparr.length; i++) {
8 D$ ]: D/ e/ G) ^' C  t3 S            System.out.print(temparr + " ");
. e! p$ `! e# e( Z% d* R        }
! h: _0 [" n2 U        System.out.println();
: U0 o/ Q% y5 ?5 |$ g& |; R3 ^* w+ m

        //测试直接选择排序
        System.out.println("测试直接选择排序:");
        temparr = nums.clone();
+ z/ j/ ]& G: W, G6 C& d6 s        SelectSort.selectSort(temparr);
        //SelectSort.selectSort(temparr,false);
7 v! `- X7 P- G2 L$ d4 \* Q        for (int i = 0; i < temparr.length; i++) {
2 \* E8 g+ `9 V% q! i; G. B            System.out.print(temparr + " ");
        }
        System.out.println();

6 c% `1 ?/ {3 u0 s! }& Y
        //测试堆排序
8 G6 H  o) d$ E- P( F! l+ ?- M        System.out.println("测试堆排序:");
        temparr = nums.clone();
* I0 Z1 |- p4 x" R1 U4 V. @        HeapSort.heapSort(temparr);
9 J. @7 P2 K& p  {- Y: s        //HeapSort.heapSort(temparr,false);
        for (int i = 0; i < temparr.length; i++) {
            System.out.print(temparr + " ");
; N: o5 x. Q" V) h+ c  ~        }
        System.out.println();

& i" t3 x! F6 z) S" f7 v; X8 M
3 ~1 h: H: i# I+ X- J! r        //测试归并排序
7 k: Y. d1 j  d6 D1 p% w& T        System.out.println("测试归并排序:");
- Y$ \( y1 {& L        temparr = nums.clone();
        MergeSort.mergeSort(temparr);
        //MergeSort.mergeSort(temparr,false);
        for (int i = 0; i < temparr.length; i++) {
- @& D3 ^1 K& L  {            System.out.print(temparr + " ");
9 G: o3 A/ n5 @; M        }
+ t: U, E% u* f/ Z. t        System.out.println();
4 U3 u# D# z7 g$ ~/ V

        //测试插入排序
        System.out.println("测试插入排序:");
6 z2 _% q5 F, e5 O        temparr = nums.clone();
        StraghtInsertSort.straghtInsertSort(temparr);
9 b2 ]* a* N5 z& q: u% g; F        //StraghtInsertSort.straghtInsertSort(temparr,false);
* K' U9 _- b6 z/ H        for (int i = 0; i < temparr.length; i++) {
            System.out.print(temparr + " ");
% J$ w; f5 h- P. Q% u, d        }
        System.out.println();
/ f- X- Q. G( P* g/ _
+ f0 z& l3 F% d- x
6 y3 C" y( F. f8 {  P1 h5 j% l

        //测试希尔排序
) O5 \: v3 U* w1 Q        System.out.println("测试希尔排序:");
        temparr = nums.clone();
        ShellSort.shellSort(temparr);
, o! u( e& w& F0 q        //ShellSort.shellSort(temparr,false);
! z/ O; N' J; J; l4 X2 Q' m        for (int i = 0; i < temparr.length; i++) {
            System.out.print(temparr + " ");
        }
+ G6 O( `7 r) R" l6 g5 ^9 s        System.out.println();

& v! |7 d) J# j8 @7 B1 j& o# {
% J+ j$ _. L+ q, c
: D" C# k  n% A$ V3 h$ O% w$ M
, J, L0 j2 H0 H7 |( W        //测试计数排序
# j5 |; J, r7 N" d) ?. S" v7 j$ N        System.out.println("测试计数排序:");
# G% w# J7 U: m: s" i+ A+ ]1 {        temparr = nums.clone();
8 _& r3 x$ R# G        CountSort.countSort(temparr);
+ \& O7 B" ^8 |0 P* g        //CountSort.countSort(temparr,false);
        for (int i = 0; i < temparr.length; i++) {
            System.out.print(temparr + " ");
        }
        System.out.println();
1 B9 Q! k6 e7 L' Y# S0 i

6 `# s3 V" B* o7 h: N1 \# [

        //测试桶排序
( L; l/ t/ \  S8 B% u        System.out.println("测试桶排序:");
        temparr = nums.clone();
7 v' G3 @/ {! [( F, V9 O+ k" M- s8 |        BucketSort.bucketSort(temparr);
        //BucketSort.bucketSort(temparr,false);
% }0 q  ]: h8 ?' O0 {        for (int i = 0; i < temparr.length; i++) {
9 r1 U: U1 \% @; q            System.out.print(temparr + " ");
" D2 o# Y  G8 h        }
        System.out.println();
0 B% [2 `5 g$ O8 n0 \9 b0 G( y8 S

2 Z! x, [  y' U. v        //测试基数排序
( A. x, g/ f; f2 b# D        System.out.println("测试基数排序:");
4 P: ^9 S/ U  O        temparr = nums.clone();
, Q5 y8 |: J( j9 ?! _        RadixSort.radixSort(temparr);
! y* j5 S% _: c8 H" U1 \        //RadixSort.radixSort(temparr,false);
5 Y( I: m1 y# x        for (int i = 0; i < temparr.length; i++) {
            System.out.print(temparr + " ");
        }
9 k) G# R2 g1 n" E' ]' a4 Y7 S+ c$ Z. U        System.out.println();


8 W  }2 ]) i4 B' T    }
8 @) C  H; i  r' h8 f4 s
) t" o' N( E7 V& {
4 H6 U/ L3 P  L) Q  w0 _$ |, d7 r}
1
3 s! N- B' i5 D( {& ^2
3
9 h; R% k& x8 e$ E# L7 W4
( A( N1 S# o$ h1 @/ X& s! ?  n5
" q# O3 l$ r0 _5 f+ F5 C2 E! ^6
! ?4 `3 g+ Y, k$ S  ]7
0 |8 _) M. B* O2 ^# g8
6 c. ^1 z7 r- g1 f9
+ e5 p- B- {" s5 C10
11
$ L0 y. _! d. ^6 }1 |0 F12
' g, `, h& q4 a1 n+ n13
3 N. N; G+ P- p# j4 \5 G- c/ d14
5 q- j5 v9 Y3 b' a0 \# ?- }5 c& j15
16
, _3 R2 N7 j5 n4 @8 \4 U: [  }' K17
18
1 K1 J- j. p- R( B; P* C. y19
: _: j. S" `+ w: r- w20
( l) h2 P, u9 z; m21
6 b7 t* e( O, a" r9 L22
23
24
25
# P; w  C/ @4 m7 @  C, l8 }. W5 S5 m26
27
28
29
; X3 V/ S! Z$ T6 I% ~: n30
3 e- a* l, i  C* M6 R$ B31
+ B4 e+ I5 f$ b" U32
& Q/ w+ Q* {4 v+ ^33
34
35
36
/ L+ K+ o& \) q4 e37
, S9 j# x9 a# Q" \: N4 Q! b38
39
40
5 {6 L4 Q6 ~( N41
42
43
' H" e! a6 Q0 D2 @44
( k5 x7 G/ b5 c# ?; |, X45
# I$ @  u/ n/ R7 A2 _! R/ x46
47
; K6 `% w6 y" e- a) v48
49
50
51
52
+ A" q$ t; L% I2 M5 _1 ]53
- C) B2 V" A1 Y2 Q54
9 }" e: n0 X) b, C5 c: w55
! {8 ?* w. T/ \& h* j3 a56
57
9 D  ?( f2 x& S/ a& w" }' j58
* M9 e3 b2 n" Q59
60
% R! m+ m6 U/ F1 w( N! R61
, [/ g( U1 N6 }, T, O62
63
/ `6 Y: O- }) k' x7 x6 D3 H64
+ ^7 R# R# z. p$ G# f65
6 S* f3 J- T) \9 e* i  C66
3 I* q2 G1 q+ {9 e4 i( M7 C67
68
69
( g  C3 Z: J% l/ p$ Y  U  l; `70
71
, |% d6 Q; }" q4 P! f% g: h* l  B72
73
7 j4 [4 A7 S% T, e% ~- k74
75
76
77
78
4 b) M. V1 H4 V- t* E" G6 _79
80
81
82
" Y: n, y0 Q" m# r8 Y; b. i4 J83
3 J; l1 f0 S3 u84
85
& E7 U6 @# i, m/ @1 D9 V86
87
  X( d/ b, Z& U$ p0 e) s) [88
89
% M5 e& d7 v( B& J8 d90
91
92
93
5 K/ o/ `% o+ F2 _4 J- H; P* E$ u94
4 `" ]. l' C6 Z) F95
96
97
98
9 s' A0 t: c% F# s, R/ s99
100
101
102
103
104
105
106
8 {8 S) b/ B1 M) a3 M, s; F4 Y107
: K3 j" E4 p1 w+ U108
' j2 i2 ~" _' z3 e( ^109
1 |; ?& Z1 V  F+ ?5 O6 F2 j, `) }110
% v6 ^( X7 a7 r, r111
* S$ C+ Q7 b* J112
113
114
115
4 o$ ~+ O* g+ A" w- S116
7 x7 J( Q4 _# [+ |3 W. S9 l117
, j5 K5 d  g4 T( X118
119
! S& E* z) E& R/ T( G, d! c, `! [120
121
0 s, H0 w" e  K3 x( \122
. H" U' V, X( H2 ~" o: y' h123
124
125
126
127
5 r; v8 t9 W* \( J4 Q$ g, \128
  m" }5 d( q% C3 I129
1 O% I* T5 X1 t! g3 m9 J130
# X3 n1 C, {4 g$ k; a+ M* ~$ U" T131
5 J& K" [. Z4 K; I# I/ U" W132
9 f$ O, |) M3 b6 ]* l133
) D( h( V" G6 p4 w134
135
136
137
* P2 E9 Z3 V) m3 A  ]138
139
140
$ T& `' J& Q/ @% }- t141
142
1 \* A. _  B6 x" ?6 |143
: v" Z# Z7 w, y5 }144
145
146
147
  A: d2 g+ r. e% f  F" ^148
& k6 h1 e% O% o- C# |3 F149
9 E* E! M4 C. S/ H150
$ u+ |* \1 B6 C+ j; H; D151
  f4 G' e9 o9 I! y5 J152
9 j2 I1 g4 ]1 \. m& }  a153
154
7 F9 }  Y  p) s155
156
$ v4 W1 Y. N: Y# k. K157
- O# H8 W" e, E& |: `" t7 O7 {' }158
2 H7 e. E! |* I159
160
  {6 _* U0 a9 |  ]  o161
: C; }* |- ], {7 ^" C: y162
163
$ i! F3 f$ ~, K, p; N8 b' G, W164
/ L; f  I* f7 Y2 O; Y; z4 k165
' ~1 j& F2 u4 ^; y+ K  t166
167
% ]) I: r& R  }7 K, n" ^168
4 s; s: k+ h) T- e- D; y5 S6 |; {& X' }169
" [% x5 D; D6 h; g: i$ U170
171
3 I6 `. V# G4 m0 l% d172
4 q: ?: E; _8 J8 v6 ~  \& Z, z2 Q173
每天进步一点点！
# M8 D8 D7 e) @; E$ z" y不进则退！
* @; W4 a8 k8 G8 T, M& j; h

版权声明：
* W' @- N% Q7 i. ?' ^* {原创博主：牛哄哄的柯南
- g% e; o# d# A博主原文链接：https://keafmd.blog.csdn.net/
————————————————
: a2 ~" \0 c4 ~% I版权声明：本文为CSDN博主「牛哄哄的柯南」的原创文章，遵循CC 4.0 BY-SA版权协议，转载请附上原文出处链接及本声明。
原文链接：https://blog.csdn.net/weixin_43883917/article/details/118193663
8 L4 @8 v1 ]6 r0 f

. `0 G9 _/ ^+ m  X- i; Y* a

1051373629

每天进步一点点！
) r1 H  O8 X! X0 M