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

杨利霞

4 q# L) r3 L2 v$ z经典十大排序算法（含升序降序，基数排序含负数排序）【Java版完整代码】【建议收藏系列】
经典十大排序算法【Java版完整代码】
" S. ~$ G3 F, g$ L/ z: O: l写在前面的话
1 Z! L: s/ o) i) r& k* D1 e" K十大排序算法对比
冒泡排序
$ G% p8 D: P0 \: V% I, m快速排序
直接选择排序
1 D# L) Y8 }' A( ~0 G堆排序
归并排序
插入排序
希尔排序
计数排序
桶排序
% @+ W" s% U- I3 ]4 Z4 p基数排序
完整测试类
写在前面的话
1 l2 Y2 h0 @" C5 v( I2 e/ n       虽然已经有很多人总结过这十大排序算法，优秀的文章也不少，但是Java完整版的好像不多，还存在某些文章代码存在错误的情况，同时也为了自己练手，决定把所有的写一遍巩固下，同时也真诚的希望阅读到这篇文章的小伙伴们可以自己去从头敲一遍，不要粘贴复制！希望我的文章对你有所帮助，每天进步一点点！！！


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


# D) `3 k  \% l- o' A十大排序算法对比
, N* i& ?6 l9 i  [
% I+ D1 Z5 B2 _& F/ y2 o$ t" c
, T: X( ~+ K; G$ S; `" c9 B

$ y8 ?' |# q5 N+ ]关于最后一列的稳定性，我稍微解释下，例如对序列：1 2 4 2 6 排序，序列中存在两个2，如果我们把这两个2标记上（让他俩不同），排序之后，前面的2还在前面，那么就称这种排序是稳定的，反之不稳定。
8 m# V! a0 A) h9 f) h' x& A2 t
4 r1 k* W9 f9 E8 [% W
2 e, Z% c" f$ b* W' [5 X冒泡排序
简单解释：
       原理就如算法名字一样，就像水中的气泡一样，每次我都把最大的或最小的放到最后面，这样总共需要n-1趟即可完成排序，这就是第一层循环，第二次循环就是遍历未被固定的那些数（理解成数组左边的数，因为每层循环都会把最大或最小的数升到最右边固定起来，下次就不遍历这些数了），两层循环遍历结束后，所有的数就排好序了。
; ^1 C3 a$ d/ q+ J       两层循环所以冒泡排序算法的时间复杂度是O(n 2 n^{2}n
- p( b7 O1 R# a& N0 e; R8 D. t2
$ v  X6 P; P. z+ ~* Y/ p9 h6 c )，是一个非常高的时间复杂度，我在下面的代码进行了优化，加了一个标志位，如果上一次循环未发生交换，就说明已经是有序的了，就不继续下去了，反之继续进行下一轮。


; N8 ]+ {8 f( Z& @
% G9 W7 B9 w8 C* C. M8 w+ m
" B5 j- s7 X& C- _
' L& C% R7 p; A( k% j5 ], ]2 {2 l
" o) ]6 z! C: G2 e本文的图片来源网络，仅用于大家学习，侵权联系删除！（下同）


完整代码：

: ]1 H+ B$ _* e9 t6 \  e
package com.keafmd.Sequence;


+ H& e) G* o5 [: l! ?" G. h/**
- U& H7 N$ K  y: t3 Y7 G2 V' ] * Keafmd
  X0 q. B# K) d0 j0 n9 [ *
* @ClassName: BubbleSort
* @Description: 冒泡排序
7 r9 i6 N5 N7 Q  Z9 i+ N+ n * @author: 牛哄哄的柯南
3 v' e+ q$ ?7 P5 Q3 V * @date: 2021-06-24 10:31
, z: V# A: Y# g7 [' O */
8 x9 C# |9 Y* k. K! Y5 lpublic class BubbleSort {


    //冒泡排序
1 V+ p. x$ d3 z1 q0 R    public static void bubbleSort(int[] arr, boolean ascending) { //exchange标志表示为升序排序还是降序排序
; O: x5 ?+ g+ J! ?5 [, z+ [- |
4 P9 m& Z' H  M5 |/ e# ]2 b0 c, t
        boolean flag = true; //加一个标志位，记录上一次是否发生了交换，如果是，我们则进行下一轮，如果没有，说明已经冒泡好了


# D; ]  f8 v! G0 u8 s& b        for (int i = 1; i < arr.length && flag; i++) { //控制次数，第几趟排序，只需要n-1趟，有交换时进行，只有flag=false就说明上一次一个元素都没有进行交换

. O) t9 y( h; {3 R3 e' y: ~( J5 {
5 j: F* y/ G, E1 D. ?5 j$ A            /*System.out.print("第"+i+"次遍历：");
            for (int i1 : arr) {
                System.out.print(i1+" ");
, I( r) \, M, z$ O0 b' a5 N- H8 d            }
            System.out.println();*/


            flag = false; //假定未交换

! N+ ?1 m% v$ ]% \
- f% j) r6 f& K" y            for (int j = 0; j < arr.length - i; j++) {


- f6 q, F6 Y) S+ t                if (ascending ? arr[j] > arr[j + 1] : arr[j] < arr[j + 1]) { //控制升序还是降序
. q- u2 L  k. u: `7 @6 [! Y  w% {                    int temp = arr[j];
                    arr[j] = arr[j + 1];
                    arr[j + 1] = temp;
! o$ O  f- {; t7 R1 f                    flag = true;
7 b  [; F( O1 J3 h4 t- P* f                }

3 A5 Z+ C- Z# r, t$ ^
            }
        }
    }

$ k, S# }8 r# g( H* b. j; T* _
    //冒泡排序 -- 默认不传参升序
    public static void bubbleSort(int[] arr) {
  |) C: ]0 P1 I        bubbleSort(arr, true);
    }
}
9 ~- y4 J3 p5 c( h" |! W1
2
3
4
5 k; P1 p. h, X0 f0 |" B( `# O5
6
7
5 Q. @6 z+ V! u: u) U# l6 o  H8
, h7 v; L4 d: u* c2 N" Y8 J9
( M! G0 d0 U! Q; G10
11
12
7 ]- K% v; a8 C! y13
2 w/ F' X. i" `! ], k  m14
15
16
17
& Z) S6 I; N1 {: ~0 }- z4 n+ t- y0 K/ O18
# U! k  H) Z  G; M19
" k- \: i4 ]! q' |  i2 H3 z20
9 I% c! p3 b, `7 ^  f2 z21
22
23
24
$ H' h( z' }2 Z$ ^8 D0 H25
26
27
( A$ ^9 F- J5 q; k) z28
29
3 F6 g' l% {) W$ A30
. }% S& G: Q1 L0 V31
3 S5 I/ ^& @* f( ~) f! h2 i32
33
34
35
36
7 W5 {% ^1 a. v$ K37
! V2 ?, p: ^7 U+ Q& D38
0 ^9 x; t, _. ^$ B39
40
41
42
2 F' t# _0 u" `43
! f! `7 h  F6 p, W! B44
  k: F) @2 V# o+ d; w45
$ K/ T; {5 n* C) ]) t测试代码：
' c$ t; H# h5 q: \
  K' h" q% p7 i( V
. P" V. @5 |$ T" W% F升序排序（从小到大）
" i. r: F$ g* D

package com.keafmd.Sequence;

; x7 \8 i+ V, b5 C2 Y, m' q
import java.util.*;
4 C7 `! |: V# I. Mimport java.util.stream.IntStream;
import java.util.stream.Stream;
. Y) Y/ C0 S* u+ R! J" l) @1 J" }5 y
3 S& T' `5 ~0 Q( ^( y/ }
/**
* Keafmd
3 |3 x1 q% L! |2 u; G; Y; }& H *
* @ClassName: Sort
2 l4 p. v0 j8 p- G9 R. ` * @Description: 十大排序算法
' {. x; h: W: @# {  X2 J; Q * @author: 牛哄哄的柯南
% N+ n0 D0 G, A: a * @date: 2021-06-16 21:27
* p. i6 E7 k* g: c6 Y8 x */
public class Sort {
    public static void main(String[] args) {


        int[] nums = {12, 4, 25, 47, 58, 34, 25, 9, 99, 26, 1, -13, 162, 10093, -66, -1};
        int[] temparr;
" x: c" M9 F. |# `" Q* M/ K

        //测试冒泡排序
$ d1 K7 N# L' K# g# ?        System.out.println("测试冒泡排序:");
# K5 c( D) f7 A& \- ]$ N: k8 f        temparr = nums.clone();
        BubbleSort.bubbleSort(temparr);
        //逆序排序
        //BubbleSort.bubbleSort(temparr,false);
0 [' n. `+ {* g4 B$ u* g: y        for (int i = 0; i < temparr.length; i++) {
4 P  Y4 t% J- P6 z* @* U            System.out.print(temparr + " ");
        }
$ `( k* T' R4 {4 D7 Q        System.out.println();

! R& }$ V6 r/ Y' Q" Q" h
$ x6 s5 X+ T  h. l& w4 O. W5 Y    }
}
6 _3 ?0 _' ^6 W) Z: e% Q, I* l1
2
3
% t; D" |% q! }' n# ^% Z" b2 H% U4
5
6
7
8
' Q: A2 i, Q$ D& v9
2 g7 x, L8 ?( D$ ~10
# ~* q2 M, k* q8 {& Y6 d: x$ i11
12
13
14
15
& \+ M; h! ^( T, F( L. n( \* {3 k- d16
17
# }- R  y4 N( i4 i. s18
( z5 p2 H3 W! e( [19
2 M, y7 h4 Y$ I3 P4 c. P! o20
) M/ Y& c9 N* p: E2 A/ e21
, Q6 ]' E8 @' }( D" S9 I) p' w22
23
/ Y1 X) J! ]0 H3 d/ V' h1 [, b+ [24
25
26
27
0 Y& b1 O5 |) P4 X28
  O1 \  v! w8 a* f( k! H4 h29
30
31
32
2 V5 i5 s; N" Z6 ]2 a/ x( q33
" d- u8 V% D) m6 a2 g8 G运行结果：
9 [) @* X( ~/ L

  F9 q: T% Y" n) ^测试冒泡排序:
-66 -13 -1 1 4 9 12 25 25 26 34 47 58 99 162 10093
1
2
# Z/ ~0 k7 s1 k" x降序排序（从大到小）


//测试冒泡排序
! \; q. P1 u- @# C! d: ySystem.out.println("测试冒泡排序:");
- z0 w$ o( `5 {: ^# [* Y, Wtemparr = nums.clone();
BubbleSort.bubbleSort(temparr,false);
. N2 _) S8 U! R+ ~6 ?; J% Wfor (int i = 0; i < temparr.length; i++) {
& w( P% R3 K3 \& R( a; c    System.out.print(temparr + " ");
}
9 @- t5 s( }, K: wSystem.out.println();
1
2
2 U/ R, V; E# y1 W3
9 J6 Z* d% o$ W. ^/ g4
6 }* }# D& m3 R5 n5
6 t# T% ]  |) C# d. {2 [+ ~9 N6
7
8
运行结果：
' F  ]5 Y7 n. @

测试冒泡排序:
7 K7 p7 J& C7 {) V; x; x10093 162 99 58 47 34 26 25 25 12 9 4 1 -1 -13 -66
1
2
下面几个算法的测试也就是换了下类名和方法名（换成相应的排序算法），如果想降序就在数组后面传个false即可。我就不一一复制了，我在最下面给出含所有算法的测试类，需要的自取即可。
' J) K& S( K' k' V  p/ J

快速排序
5 u" z! v1 e1 r) M' j& I, X$ b简单解释：
4 Y6 T: z- \# f; b+ P快速排序就是每次找一个基点（第一个元素），然后两个哨兵，一个从最前面往后走，一个从最后面往前面走，如果后面那个哨兵找到了一个比基点大的数停下来，前面那个哨兵找到比基点大的数停下来，然后交换两个哨兵找到的数，如果找不到最后两个哨兵就会碰到一起就结束，最后交换基点和哨兵相遇的地方的元素，然后就将一个序列分为比基点小的一部分和比基点大的一部分，然后递归左半部分和右半部分，最后的结果就是有序的了。



9 g! \6 J  O5 c5 {2 T2 V+ Z8 q
% i  b$ T  [& P; ~/ u. f' I
9 d' B& ~! f" ^4 j5 }
( {  F/ I) e$ @3 _/ R5 E完整代码：

" r. _$ [- i9 _8 `! z% P
, P3 Q* r6 u; P: d0 Y2 u' w  k' wpackage com.keafmd.Sequence;
% {* _# h- {6 w0 K) v

/**
  A# P, h1 c1 k * Keafmd
: e5 m1 ?4 L4 a' t+ p6 h: S; S *
* @ClassName: QuickSort
* @Description: 快速排序
* @author: 牛哄哄的柯南
* @date: 2021-06-24 10:32
*/
0 u! h: }6 K3 p' r! K( y0 Lpublic class QuickSort {
% b5 [) x& n8 a' n( ~7 J

    //快速排序
    public static void quickSort(int[] arr) {
0 K+ q, P5 a  r        quickSort(arr, true);
    }
9 E' \1 p" J( q; Z( E) D5 l6 b0 M

    public static void quickSort(int[] arr, boolean ascending) {
        if (ascending) {
            quickSort(arr, 0, arr.length - 1, true);
        } else {
- |3 f6 ?( D! ?5 n: q/ p            quickSort(arr, 0, arr.length - 1, false);
- ~3 S* J# J+ `        }
" B( {. ?0 \' r$ {4 R: \    }


! J* I3 {2 }0 h; ]" a/ o    public static void quickSort(int[] arr, int begin, int end, boolean ascending) {
        if (ascending)
            quickSort(arr, begin, end);
: M/ |& r8 h$ x$ q3 ?8 x        else
            quickSortDescending(arr, begin, end);
    }

" x, h, {) G$ j$ d- K. A% S
    //快排序升序 -- 默认
5 c0 p2 y9 j0 s/ f8 }7 G8 i    public static void quickSort(int[] arr, int begin, int end) {
        if (begin > end) { //结束条件
) q( g1 X% U1 J* s! O0 k! q            return;
        }
: o5 `/ e* G' n0 }- e8 |' M        int base = arr[begin];
: Q" L9 s; s0 D  U        int i = begin, j = end;
        while (i < j) { // 两个哨兵（i左边，j右边）没有相遇
* ^( i- Z( e9 ^4 d! \3 b            while (arr[j] >= base && i < j) { //哨兵j没找到比base小的
/ x: T1 \4 z) N                j--;
            }
0 Y) L& `" _9 s5 K# ~: ?3 F4 i" G. b+ z            while (arr <= base && i < j) { //哨兵i没找到比base大的
                i++;
# B$ D# M0 k3 f/ M+ o! i            }
            if (i < j) { //如果满足条件则交换
                int temp = arr;
5 T% y! K1 L% V# Q( Z                arr = arr[j];
9 x- a: x6 t6 k; G                arr[j] = temp;
            }

/ o: F" n, g/ P9 i
        }
6 F. f8 G; X! }7 h7 s9 ?4 I3 k        //最后将基准为与i和j相等位置的数字交换
6 h9 B4 Y9 T1 u/ Q8 C        arr[begin] = arr;
0 l1 u7 M$ q+ g5 J        arr = base;
        quickSort(arr, begin, i - 1); //递归调用左半数组
        quickSort(arr, i + 1, end); //递归调用右半数组

: X9 A0 N5 |, }7 Y; [7 K
5 u+ [. z1 [2 M( S$ \% K( |    }
; Q7 @; w( H5 F* y/ o+ i2 N; e
2 t5 s' ?2 B9 Z( n
, j6 B" ?2 x4 i5 }- `    //快排序降序
6 W5 l& H' L* d6 Z/ ]/ D9 K    public static void quickSortDescending(int[] arr, int begin, int end) {
        if (begin > end) { //结束条件
# s$ |* g0 G; @/ ?            return;
% N. G/ s5 b/ p; l  P, c/ z4 K4 a1 `        }
& C$ U2 V3 G% a4 @        int base = arr[begin];
        int i = begin, j = end;
        while (i < j) { // 两个哨兵（i左边，j右边）没有相遇
            while (arr[j] <= base && i < j) { //哨兵j没找到比base大的
                j--;
( N: J! `) E2 m6 O. l' R            }
            while (arr >= base && i < j) { //哨兵i没找到比base小的
                i++;
% G/ m& l2 m" v; F, [3 d            }
. J- a' q$ s0 P7 U1 l3 j. I            if (i < j) { //如果满足条件则交换
6 L8 s. \, i& R. p                int temp = arr;
+ N, r/ F; s6 P                arr = arr[j];
1 p) o$ X: `  ~  v, f/ `                arr[j] = temp;
" c. x+ ]' `  _8 z3 c5 ~/ h/ y$ G* ?            }
0 @" }: b+ `4 K" h8 a5 y' @. H, ?

! M- u( S4 A2 ]( l/ [) I1 s6 B        }
' b1 M9 e5 ~! g# p4 H        //最后将基准为与i和j相等位置的数字交换
        arr[begin] = arr;
  Q$ ~* m, Q7 U; _( e        arr = base;
# ^( x% F" p- P/ i, b& D! a# ^        quickSortDescending(arr, begin, i - 1); //递归调用左半数组
        quickSortDescending(arr, i + 1, end); //递归调用右半数组
+ ]1 t" \( J+ d1 ?8 n
5 x! o8 V' S- B/ x
  J: _; W  e) x& e/ K- K    }


}
1
2
3
" X  z+ j# S3 `5 {% }4
1 T" {: n. o( u2 g2 P$ e/ Q5 J5
6
7
: X, c9 K( m$ S* p/ N4 h8
3 K4 ?8 T8 [( m/ N0 H9
, ]  {% |! t. ?7 U' r/ {10
11
+ I: q. D( }+ H! y12
0 Q  _7 T% t+ j+ B1 N13
0 Q2 b/ b3 I7 T- I. L& M: S14
15
16
17
$ p) Y/ l! v8 v/ ~, X$ v- `8 ?) ]2 f18
19
3 O- A* W9 o- o/ E. _20
. V- w# E/ g" N! P21
  t! o2 N  ^8 {3 v& D; v$ B22
, e9 I/ A8 Y4 f* ?: }$ W" q. O23
24
; b) M5 g  [6 R5 B0 \# }& c$ e, X25
8 o; Y, |2 H* W; @  X26
( j% N4 N# Q4 a3 \' ]4 h27
& k1 d+ _% c9 K  `0 m28
29
9 i( f$ p* X6 j6 B* G% Q30
31
32
1 p7 V/ R- U3 n) F9 y" \33
34
& h  R% I- b( y) q+ Q$ w" T) D! ?35
  }4 m/ x/ h# S# }5 O" R  S& V: E6 u4 `36
% e1 x& o+ Q1 T37
/ v% O4 [( x/ U38
39
40
41
42
0 Z& j7 ]. K. C& r; i" g43
44
8 c- U9 M/ V$ U4 w$ J45
+ X) G+ x2 j" i- r# R' ], ?0 s% o) Z46
7 b' r$ ?9 U; j  A" L47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
8 R- e" n+ n. W. \; P8 u4 X62
63
- S  `" j5 x% }- M' R6 g' O) W64
! K0 k$ j& I0 ?/ `1 u5 k65
  |6 Y  {2 ]! T$ w6 o66
67
68
69
( e! M6 C3 K9 ^, h. z70
71
8 z5 r; `/ q, T+ x/ O( H& q72
, g! h( m! t# U- _# U73
, N/ i6 W: U9 ?. _7 h; z74
75
$ D$ D0 N6 }  o# Q1 Y5 L4 ]76
! `3 U: d/ o4 z2 V77
78
. V5 c, u% k0 I( p/ K) }9 N4 B9 I, u79
1 w" J  U8 q# g  e% |6 Q! N80
81
9 m0 p6 G6 C1 Q) H( v# V82
+ K5 a, y# e+ E0 w# S  A83
84
85
86
87
88
89
2 b5 F) q& `- Q9 s; @1 g* E90
/ Q% J+ @" C) U/ q& V/ A* _91
0 F8 B/ B* Q6 Z1 [/ T' Q直接选择排序
/ C% T: R9 I/ B) F9 F  o  c简单解释：
数组分为已排序部分（前面）和待排序序列（后面）
- Q, v# K7 U! S( M, B1 u. W, @% z第一次肯定所有的数都是待排序的
& C! M/ j5 J7 [- N  Y5 n' Z* C2 z从待排序的序列中找到最大或最小的那个元素，放到前面的已排序部分，然后一直找，不断缩小待排序的范围，直到所有的数都是已排序的了


8 X: N4 e0 m# }" D


5 i& d9 m4 q/ H; o! _$ D: {1 a2 |
完整代码：
, ~  u+ L9 ^6 \/ s7 Q
( M" I0 R0 a* j1 u5 d: q0 k0 |
8 D% |7 Z- j$ B7 C' }) Gpackage com.keafmd.Sequence;


% ^. P5 v1 `6 k% c: D7 }% m/**
* Keafmd
*
8 o5 X: U: S& S5 X. i * @ClassName: SelectSort
* @Description: 选择排序
* @author: 牛哄哄的柯南
* @date: 2021-06-24 10:33
2 u, Y- D& w+ N5 [3 r */
public class SelectSort {
" l. `  s* n! u$ m2 K! u

; }, V" Z# d$ i    //直接选择排序
    public static void selectSort(int[] arr, boolean ascending) {
# I  I: z$ d7 e( S        for (int i = 0; i < arr.length; i++) {
( [' m3 r5 M& e- ?! ~            int m = i; //最小值或最小值的下标
7 o5 i, T: w, g2 r9 _            for (int j = i + 1; j < arr.length; j++) {
/ u4 S% Q6 G- a; t' G                if (ascending ? arr[j] < arr[m] : arr[j] > arr[m]) {
                    m = j; //找到待排序的数中最小或最大的那个数，记录下标
                }
5 ], T1 E1 N2 {
5 Z. c0 A& H: D# g4 G
            }
            //交换位置
1 Z5 m& h) H* I            int temp = arr;
  O: Q. E" M7 |7 v            arr = arr[m];
7 q2 H* e. n( F# S% T            arr[m] = temp;


        }
    }
5 z8 Z1 n4 ?9 v" {: ]5 u) Y

    public static void selectSort(int[] arr) {
        selectSort(arr, true);
    }
}
1
2
3
& O# N. q8 a& s+ f% Z: b4
& f6 U% U' I. u. y" p+ m5
6
/ T2 T1 T- u0 u5 n$ p7
8
7 I9 N6 P* q/ Y+ n: C$ J+ \! a) b9
$ R7 H8 c8 w7 S) b4 |10
* @' w: m/ z! q5 ^# A- ~11
12
13
14
15
16
17
; ?- W/ m& c  \0 t0 v5 A  I18
) D9 H3 T) E/ s0 q+ c9 W* [! X19
20
( z$ \, B: I2 T1 r21
22
; L% ?; j, M6 K! P: u23
24
25
26
2 l& g" u3 Q- @4 p, Q$ l* b% h27
28
/ }  B# |/ K4 Y( W0 s; f29
30
: [0 f9 x' r9 L) {$ k31
32
33
34
& J" R* t8 Z) [4 U堆排序
0 B' e/ M" I# n/ u% m; b  x先理解下大顶堆和小顶堆，看图
大顶堆，双亲结点的值比每一个孩子结点的值都要大。根结点值最大
3 N5 N! Y/ p, b0 {/ C8 F小顶堆，双亲结点的值比每一个孩子结点的值都要小。根结点值最小

5 V9 _3 P6 R  Q5 P


# i, |; |( D$ K% h简单解释：
构建好大顶堆或小顶堆结构，这样最上面的就是最大值或最小值，那么我们取出堆顶元素，然后重新构建结构，一直取，一直重新构建，那么最后达到排序的效果了。
3 `4 Q( R7 ?+ k

+ s/ R3 e6 F0 |  y) g1 q+ L



$ N% l. A8 I5 ]+ ^9 n! A完整代码：
$ _0 U! Q! ]1 _/ O! i! |
& ]: T! O$ s- m
, r) e9 |- _% U" ^3 {8 `' l8 mpackage com.keafmd.Sequence;
7 L( q3 u6 u3 v4 F

/**
* Keafmd
*
1 g1 ~. I, f) Y4 e8 U1 ]" ? * @ClassName: HeapSort
* @Description: 堆排序
* @author: 牛哄哄的柯南
! T1 ^/ }. J3 j- f$ } * @date: 2021-06-24 10:34
*/
public class HeapSort {

& c) k. u. E# C( _/ T  \
, z7 M+ K8 k# T    //堆排序
6 Z& G6 A3 x2 f- R$ \    public static void heapSort(int[] arr) {
6 Y5 g, y7 B; X/ M. V: h2 m) y        //对传入的数组进行建立堆，这里默认建立大顶堆，进行升序排列
        heapSort(arr, true);
    }

/ f* U! C' n3 n' g/ ^
5 N2 j9 T, L6 [4 e    public static void heapSort(int[] arr, boolean maxheap) {
, I. ]  ~! N& Q, t
8 B# I8 F  g: n5 s3 z" G7 K5 V
        //1.构建大顶堆
        for (int i = arr.length / 2 - 1; i >= 0; i--) {
            //从第一个非叶子结点从下至上，从右至左调整结构
& Q4 P+ ^4 G* [' J" D            sift(arr, i, arr.length , maxheap);
- r3 {4 ]. h* C% V/ I# {        }


        //2.调整堆结构+交换堆顶元素与末尾元素
0 ^8 x: J! C/ k2 I) G  I        for (int j = arr.length - 1; j > 0; j--) {
& U; s5 j6 z) b* r# Y; ~

! ]# @% P9 u+ d3 A7 h& ^& F            //现在的数组第一个就是根结点，最小值所在，进行交换，把它放到最右边
* p" b3 Z. K( l) A+ M            int temp = arr[j];
            arr[j] = arr[0];
+ d. J7 w1 B# l3 @' {* n. G            arr[0] = temp;
- ?! ^) @7 t- \& R8 z( T" [( b% @

            //重新建立堆
            sift(arr, 0, j , maxheap); //重新对堆进行调整
        }
    }

2 Y* }0 G- @- I5 [& A, i6 s7 P
    //建立堆的方法
1 S( m8 G8 k8 z( u+ d, Y% Y    /**
     * 私有方法，只允许被堆排序调用
$ x7 S7 j+ H1 S% i1 ^6 f3 e! s7 q! g' c/ z     *
, u; u0 f1 c! t. h     * @param arr     要排序数组
" o9 S6 O& D! \     * @param parent  当前的双亲节点
6 U$ e* W' e: I; h6 \     * @param len     数组长度
     * @param maxheap 是否建立大顶堆
! R; \) G% n2 X4 j; j6 M& c     */
" y* j4 X( W0 s% m$ H    private static void sift(int[] arr, int parent, int len, boolean maxheap) {
) l* T5 _. f/ I# c) Q, p

        int value = arr[parent]; //先取出当前元素i

. V/ ^8 q$ j4 m& j8 Y# h, T3 Z
3 q' |; G, z2 }2 }* R        for (int child = 2 * parent + 1; child < len; child = child * 2 + 1) { //从parent结点的左子结点开始，也就是2*parent+1处开始

8 G# G) P: e6 W8 ?6 v3 K$ A
0 y4 v' p+ K4 W3 l# H* N            if (child+1 < len && (maxheap ? arr[child] < arr[child + 1] : arr[child] > arr[child + 1])) { //如果左子结点小于右子结点，child指向右子结点
/ R' x. q+ |  x5 Q                child++; //右孩子如果比左孩子大，我们就将现在的孩子换到右孩子
5 t* P4 b! p7 C1 m$ l            }


            //判断是否符合大顶堆的特性， 如果右孩子大于双亲，自然左孩子也大于双亲，符合
            //如果子节点大于父节点，将子节点值赋给父节点（不用进行交换)
            if (maxheap ? value < arr[child] : value > arr[child]) {
' g0 N; A: E% W: B                arr[parent]=arr[child];
0 R  e* ?/ K  W                parent = child;
0 @1 n" w( ]& i& W            }
            else {//如果不是，说明已经符合我们的要求了。
6 p3 A8 s) ?% ]) p2 ?( K/ ?# C                break;
            }
) `7 `0 I3 N: P! {& H1 Q+ G- P. G        }
        arr[parent] =value; //将value值放到最终的位置
" j" a0 V& g% d1 q! {1 M


( ?) n& _& R0 K) O( l& ?' f
" E/ `( C/ V( ]  I3 ]4 R+ v- J+ _    }

8 x7 ?+ P1 |5 X0 S8 Q
* `( f5 a+ G# o/ R3 k, @}
! i% V: a/ U4 u% P; v) @/ |1
2
3
4
5
& ]) N) _. o4 B/ T: a0 b) K. S6
7
8
0 f  i5 h1 U% i2 N9
10
. Q/ |, X* Q1 o5 F/ D11
8 q0 [) T$ [: ]12
+ ?( h$ b- t( H2 r& f- {( q13
14
* \8 d8 v* h. o1 T* o15
7 Q* y$ K8 k6 C4 T+ k16
17
" @2 \) b) M5 c1 ~18
19
  b+ F2 P0 e1 ^( w- T9 T4 P; U20
21
4 O; q) o9 Q" e( Z/ n22
23
. s' d* \2 P1 x2 n24
25
26
( [0 l( p1 q8 a27
28
& m4 v9 I: `  N, B* S, T9 d29
2 b% z! C: o/ @30
31
2 M1 G4 n, ]. H8 z, g) D; k32
33
34
* V1 q, w" l; j& L35
4 O0 b8 }8 r: F& N. ?36
37
38
+ H; a2 @. P. V  D2 s39
- ~3 y+ E+ {' {) Q  p& {# X7 X40
41
9 D9 }% t4 Z& {) c/ o/ Z  V" S1 I42
9 K" H2 u* h0 @/ r43
44
$ I7 z) [4 g9 s" v/ u2 }45
46
+ v4 o- Q3 j7 o! }5 Q47
1 f- E) @) t: Y6 K( _3 |" V, O48
49
50
# s/ f  \7 [# ?) o51
52
1 Q6 D* i# D- _/ U53
+ U$ @! ^0 M4 T3 j6 P# v54
55
56
57
5 m- c5 n  c$ `- Z58
59
7 o, T  s5 K. X/ Q0 M60
! T$ C% |) h4 u& H+ H" g6 p# e61
62
63
! C: _, X9 h/ d3 s1 u+ B64
65
# E2 h9 v( f  [( y6 R% Y5 v66
67
/ Y' [* o3 I! y1 T! Z* p68
; K( I) O5 l4 }4 R) X) S69
& h6 M1 q0 Y# J2 O70
2 H# W- c2 a. ^& z1 s/ w" i# n71
72
2 H% ]. X8 k$ h7 P: F# G73
7 q6 g/ |5 U+ E+ u74
归并排序
  S9 g& X4 j* |4 m简单解释：
该算法是采用分治法，把数组不断分割，直至成为单个元素，然后比较再合并（合并的过程就是两部分分别从头开始比较，取出最小或最大元素的放到新的区域内，继续取两部分中最大或最小的元素，直到这两部分合并完，最后所有的都合并完，最后形成完整的有序序列）
4 p$ K$ ?: T2 a% n( f  v

0 \; q5 o! @7 P8 q
. A, u& s, r( I: R$ u
4 Q$ @  I% Q; p/ }9 z2 u3 v
. r+ p+ B# A" X; I
完整代码：
8 `( m6 v* x& [" {8 h' p

package com.keafmd.Sequence;

6 O$ l. V  X1 U7 K
0 g4 K# X* e. l+ t/**
* Keafmd
*
* @ClassName: MergeSort
; A& s/ U, Z% P& ]7 j: Z: [ * @Description: 归并排序
. O2 |  e$ `* F * @author: 牛哄哄的柯南
- n' I& |9 t  y6 | * @date: 2021-06-24 10:35
*/
public class MergeSort {
1 p4 Z3 m. e# W' t( c% @5 N1 p
: }$ [" z- m/ f  f1 `
+ T6 S. F5 y$ l/ m# e" K$ |    //归并排序
    public static void mergeSort(int []arr ,boolean ascending){
/ l4 @0 w' W: [/ i7 \        int[] temp = new int[arr.length]; //在排序前，先建好一个长度等于原数组长度的临时数组，避免递归中频繁开辟空间
        mergeSort(arr,0,arr.length-1,temp,ascending);
% k! ]# f) d4 s( `. {    }
# w1 h1 c* q% u2 ~3 I    public static void mergeSort(int []arr){
0 X+ j7 ~# g2 [' y" x        mergeSort(arr,true);
" \  o/ q" g3 R4 h; l8 k! l5 m    }

4 \% `4 s" n8 S# ^2 W! v
    /**
     *
% ^; \% ]1 c/ V) ^/ B     * @param arr 传入的数组
     * @param left 当前子数组的起始下标
1 H6 u1 d/ t- V* l; }/ o7 T     * @param right 当前子数组的结束下标
1 K% \! r. W+ s4 |     * @param temp 拷贝暂存数组
" B! J; |7 Z1 A  A5 G! ?+ f& B     */
. H$ q; E7 a7 [4 q+ y0 h    public static void mergeSort(int []arr,int left,int right,int[] temp,boolean ascending){
        if(left<right){ //这里是递归结束的条件，我们是对半分，那当left==right的时候肯定大家都是只有一个元素了。

/ q7 j" v6 y* M  c
            //对半分，比如总长度是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 J) j1 M8 v# C, d  m! H

8 X1 Y5 W: v# D" w' r- S            mergeSort(arr,left,mid,temp,ascending); //左边归并排序，使得左子序列有序
( N1 l4 [1 F% ]0 R' S$ v  i4 _2 }: U            mergeSort(arr,mid+1,right,temp,ascending); //右边归并排序，使得右子序列有序

8 ?# G1 d, N8 e5 c
: ?# p4 ~  f- o& e, I" s            merge(arr,left,mid,right,temp,ascending); //将两个有序子数组合并操作
        }
, m6 s# D% O- P    }
9 [0 ?9 w8 N8 J  {

    private static void merge(int[] arr,int left,int mid,int right,int[] temp,boolean ascending){
2 C4 a1 W6 I& k        int i = left; //左序列起始下标
1 {4 B) K; R# k/ b( M$ I9 Q" L        int j = mid+1; //右序列起始下标
5 a2 H* V  r) T7 z( d3 @) e        int t = 0; //临时数组指针
" p- V; l# V# w7 u1 r  U4 n+ m1 ~        while(i<=mid&&j<=right){
            if(ascending?arr<arr[j]:arr>arr[j]){ //比较两个序列第一个元素谁小，谁小先拷贝谁到temp，然后对应子序列下标加1
! v5 r% F3 x6 e; i* Y2 r                temp[t++] = arr[i++];
2 E: _9 H0 t' A& r3 o$ m            }else {
                temp[t++] = arr[j++];
" f; J6 [6 g. g$ N3 v# m0 m$ `            }
+ |% L  [. [$ B1 h        }

+ |# a  v; A* V1 U# {4 a
& D: G! o" H+ a  K        while(i<=mid){ //将左边剩余元素填充进temp中——左序列有一些数总是比右边的大的数
            temp[t++] = arr[i++];
        }
% e$ b1 h# p2 M

' q, g  [* l- \/ o1 @3 u        while(j<=right){ //将右序列剩余元素填充进temp中——右序列有一些数总是比左边的大的数
3 u9 `. W* w6 R7 a* h            temp[t++] = arr[j++];
! `' B2 R' p, k1 P% I8 \; O        }

+ S1 P$ y9 V& F+ k
        t = 0;
7 [0 R5 S3 X4 B$ s
7 |8 e& e, ~' O
        //将temp中的元素全部拷贝到原数组中
3 s% R9 t0 j! \: l6 C9 O+ t' J        while(left<=right){
            arr[left++] = temp[t++];
9 m8 K6 A( B- J        }
, `! Z, [9 Z; ?5 B3 h
- P5 B, v' C5 x8 d3 |9 s( u
* n" `- A# I% X5 ?" k; j! B. b* d( S    }
6 y. H$ Q5 s* _- C/ K/ N

" k& K" i$ j4 H0 b5 Y% h+ ~}
1
4 G5 t3 ~# z! S# @, m5 f! ^9 D8 w2
3
  R% }0 k* m, k% X8 g4
8 |) ~1 u  A2 l( h5
6
7
. ~% x% j; @1 J8
9
10
* b! f& a8 u' _: x, R% ^* i. K11
7 i7 }& K- ~6 A" Q12
13
14
9 o. d- a$ S! ^: W15
, k8 C  E! d7 ?  i# q2 {16
0 L$ ]# A( R7 w, v0 D# K: B17
18
# ?6 }: d+ u& O# p- Y6 f9 f19
20
: Y0 U: O" ]9 `+ x21
22
23
) X; j7 V5 k0 T" y4 m! Q24
25
26
27
# E5 z. Y$ o  _1 z28
29
30
) t( [: [( R; T! r31
32
" ?* J9 r# ~+ M- N7 h' N7 X) t33
/ M" y, b+ d5 d: d7 w7 m, Q34
9 l7 A1 {7 Z8 ?0 x# u1 m- [( j35
6 n. t2 T, B; E3 ?36
37
) O9 F" O7 Q. x/ Q# r1 D# ?* s4 Y0 U4 m7 t6 M38
. o; g6 s, v# e9 [39
' o5 _/ {4 e% n" A6 F, e# X40
41
42
43
44
4 q3 L7 `9 n1 ]& e4 U45
9 ]; B- L; w2 u, M; R3 E46
7 u% b, V# K1 r; c0 v9 I47
7 S' G  }2 f4 h5 X7 z" c' f) G48
# x* q) \" O1 l4 H1 l6 [2 L% v49
50
51
  y* o. c2 Y  f$ L4 |$ p52
53
54
55
# {) Y% C# s1 E2 l- X, I56
" L6 e' l( S) E9 T& p4 T57
/ J2 q$ G" n% @/ W58
59
- b0 O6 d0 j+ r" o; `60
0 G( w4 f2 J: V( A6 o4 u- w61
62
! d- |; A' X2 J. S. X3 W! \63
# M& O$ t, O" w. k$ B64
65
66
67
68
69
70
71
72
) y' R7 K1 Q' z( ?: h+ R% q73
插入排序
简单解释：
" `' ]' V/ {* q6 J& L& e最简单的理解就是打地主时我们拿到牌后的整理过程，从第二个牌（假设我们拿起来这个牌开始比较）开始，（说下升序）从后往前比较如果比前面的那个牌小，就把牌往后移动，直到找到一个合适的位置（这个位置的前面的那个牌不比这个要放下的牌大）就把这个牌放到这个位置，慢慢的前面的部分变得有序，直至全部有序即可。
2 z* l5 Y$ T, U$ u0 U3 n


: J+ I9 i+ @9 A" I. A
6 s1 j+ B  t- W2 z+ J

# _: K* S  g* b/ G0 r% [9 D完整代码：
0 J$ f, ?- k- {# I( @
5 {; I+ E% B, x! J$ \( U% w) H
4 c2 p0 U' i5 Q+ S8 Q/ npackage com.keafmd.Sequence;

/ w9 @- }$ u% r3 J! v& n
! }, g' h; Y7 |/**
* Keafmd
( x& j: u$ c8 u *
* @ClassName: StraghtInsertSort
* @Description: 插入排序
8 J" m, c$ Y" p9 j * @author: 牛哄哄的柯南
* @date: 2021-06-24 10:36
*/
public class StraghtInsertSort {
4 t* @9 z5 }1 c) R5 d8 g) M9 @% @    //插入排序
    public static void straghtInsertSort(int[] arr) {
: g( b& o7 }+ ^" n8 a: R' D        straghtInsertSort(arr, true);//默认进行升序
    }
! [' W# h; O2 }2 ~
# K. @8 A1 C5 M8 H; L' F
. k" p9 L/ _4 c    public static void straghtInsertSort(int[] arr, boolean ascending) {

( ~* S& v8 @' Q8 u
% \5 J8 P. Y: w0 y# c+ i+ i% F        for (int i = 1; i < arr.length; i++) {
            int temp = arr;
            int j=0; //这就是那个合适的位置
            for (j = i - 1; j >= 0 && (ascending ? temp < arr[j] : temp > arr[j]); j--) {
4 X- C/ p4 E# r5 `. w, L                arr[j + 1] = arr[j];
% T0 Y0 e4 f0 }- t( f$ U( k5 |            }
0 t& o9 f/ y) e. I% ]2 y* o# }            //把牌放下，为啥是j+1，
            //是因为上面的循环遍历到不符合情况的时候 j是合适的位置的前面的那个数的位置
* N" i% }6 ]* w) S3 s            //有点拗口，但是就是这个意思，看图方便理解下
            arr[j + 1] = temp;
1 C# n( w- M" P9 v5 j0 _
& C7 A+ L; `2 _) u# D
0 V; T# y6 ?( M4 s* D$ D

  ?/ h* t. j. ^# W2 d" V& D; K: b        }

) m; [! k; x) w+ p
% v& f2 S1 G! m7 b2 A    }
}
4 w) x! r% |/ B6 ~. f5 H; P1
2
3
3 ~* W; k  I* n) v% F' `: b. N; _4
5
6
7
8
9
10
11
12
13
) w. J$ y9 c  q14
8 w! h& B% u$ {; P) ^15
; f% B% U* t% Y( q$ \* W16
' l* P& ]: x2 N17
, {+ I4 ~3 }% b18
$ |) M- y9 v0 o! W7 z+ n- y8 V19
* t- X, a8 k! f3 j3 t20
! }  `. {* U/ V  a* z' Q" ?21
5 g/ W( q1 H3 Z% w  q22
2 n" L# f, q+ T6 [23
24
25
* j( b$ [! {! E  Q& U3 [26
27
28
8 D+ H7 d7 w1 l! ^6 q5 V$ b29
30
3 J& R% H) U7 k  F  d3 n2 y4 F31
6 H+ I7 F' b# M5 ~5 C32
2 c& e% Z) E* z- c7 e. {33
34
9 P) ?) @! R4 x: z0 s希尔排序
' o. b# ~) E, o. W3 Y* ~简单解释：
) U- s$ _: e6 Y, L, T希尔排序是插入排序的改进版，我们理解一个叫做下标差的的东西，也就是下面那个图中的增量d，初始下标差为arr.length/2，然后继续/2，对在同一下标差（相当于把这几个数单独拿出来了）的若干个数进行插入排序即可。
0 G  B: H9 c3 s% p


. O/ T# k4 F! K! |' A6 y) L$ n2 M
  Z8 y. |% M# y! N  {9 n

完整代码：
% F  Z0 K! Q# T- [( N
3 c: ^; K; `! \! R4 f$ M
0 R; @* r# R, w7 A! P6 y- epackage com.keafmd.Sequence;

% O/ m, [6 Z& Z4 u# N
5 h  B' A0 \4 @* @! h& O8 m/**
* Keafmd
*
* @ClassName: ShellSort
/ d# T2 A7 \4 [$ c * @Description: 希尔排序
! z+ _4 h  E% R: L) v9 t! h( [ * @author: 牛哄哄的柯南
) h! ^- L' C) l: ^% V8 c * @date: 2021-06-24 10:39
*/
public class ShellSort {


    public static void shellSort(int[] arr) {
. |3 s% K- v- V8 ]% }7 a, W        shellSort(arr,true);
+ U1 ~& d, W5 \& A  f5 z: L    }
( R0 c( Y  ~- v& v3 B+ r
+ I4 k$ s- `+ ~" N
7 R2 R1 S: C! ?3 e/ R    public static void shellSort(int[] arr,boolean ascending) {
$ _; I" f) B$ Y- K; E( x2 {  r
9 j* v' l5 }- C9 H# _
        for(int d = arr.length/2;d>0;d/=2){

/ @8 N5 j8 q$ ]$ ?6 a1 U
( e! e1 \: Z9 v9 k- I2 F" m            for(int i=d;i< arr.length;i++){
                int temp = arr;
5 H8 z+ n$ `- O2 u1 J" T                int j=0;
                for(j=i-d;j>=0&&(ascending?temp<arr[j]:temp>arr[j]);j-=d){
; @7 g% _8 a( L5 D7 H: P) s) f# z                    arr[j+d]=arr[j];
4 q. G: ]* ~* E2 Z" K6 W                }
                arr[j+d] = temp;
            }
        }
6 ^) O) J) N/ @
0 S( d6 u  \& Y: C" j
    }
}
5 N4 h. R* Y! h" r9 o& Y& u1
+ @+ X4 C( E% N! f1 d9 ~. x7 a2
, F' Z) J6 T- A9 S9 q3
4
8 \5 i7 D" j9 D" U5
. c( s7 F3 B  N; r; x2 a9 O8 z! \- n6
" @! _3 u$ ]- ]# m7
8
9
10
9 f6 @" p3 N2 }$ I) ?11
12
, n  {, q( w( ]13
4 L! N: p' f- l" j$ j" h14
15
16
17
18
- A) L( r) H% h- C+ ~  s( U0 a5 ?7 W19
20
+ j' B! S, U- l  V( z0 S$ y) _8 E21
8 G0 M$ O$ Z' D( d1 R% A! `22
23
24
25
26
: A2 d! R$ J6 q/ y& d27
  ^4 U. w$ O0 o. v; G! W/ i28
29
. ^2 ^& R, k7 C9 r  t30
! s& W% Y: o; r+ V6 D# _; d1 u31
1 j( R& B" _, Y/ l( {' A! ]32
计数排序
  D, r! O$ O( G6 H7 ]简单解释：
* O$ e) K0 `- O/ X" C这个排序算法看名字也很好理解，就是就是额外找个数组来计数，然后在这个数组从小到大或从大到小把数取出来即可。
) w; i# Q: r) R1 S/ q( o. U


: W2 ~& G9 |4 ]) ?1 }


6 A( ^: H( ]2 ]8 n9 b9 x完整代码：
/ l6 M+ x0 ]1 E& s' x1 P
( S8 H; T4 v5 A! e) g8 P  v
2 \1 T" y4 G4 |9 B9 O5 \  ^! Ypackage com.keafmd.Sequence;
+ S0 J; _3 ^& y
# k2 d/ o+ s* R; i0 z6 P8 q5 V4 _: g) W; U
/**
* Keafmd
1 Z4 ~8 q! J* E9 m4 C$ p- p *
* m. Y: F% `; o9 B: g. I5 N3 x * @ClassName: CountSort
% d: w: U+ ]# m5 p' i" g * @Description: 计数排序
8 V5 p8 a" K. v; w+ U" N * @author: 牛哄哄的柯南
; {/ K! C: L2 c3 g( p) _8 e * @date: 2021-06-24 11:31
*/
  M6 H( T1 X# @7 Q3 ]! J" dpublic class CountSort {
8 ]# @4 p- C+ g' J' n: M% Q8 u

    public static void countSort(int[]arr){
        countSort(arr,true);
# f5 X9 t: r) S# e5 G    }
8 c8 N9 o; P, v% F  f( @

    public static void countSort(int[]arr,boolean ascending){
        int d,min=arr[0],max=arr[0];


        //找出最大、最小值
        for(int i=0;i< arr.length;i++){
8 z/ z# S, h& O            if(arr<min){
: o& H8 X* p# Q  N3 ~                min =arr;
            }
6 Z8 G  B4 g' R- n' A+ }2 W            if(arr>max){
                max = arr;
2 F) P2 Y, P. {5 j5 n6 j1 w            }
& }. S$ j+ \; b& d- @5 {5 }( {        }
' m" U9 `- ~0 D* L; i; q$ @
) R4 \% e! T+ W- q! \7 v3 ?3 f
- e$ c" G- K1 q. i        //建立一个用于计数的数组
        d = min;
3 l# k/ l3 G1 B8 R8 J! U8 h        int[] count_map = new int[max-min+1];
        for(int i=0;i< arr.length;i++){
: O: d, j  }  @            count_map[arr-d]++;
* p$ W+ Q! F8 `0 d% ~2 V6 `! V$ m        }

) u* r- B! r& [4 J! S( ?7 c  b
        int k =0;
        if(ascending){
2 {# m- Z% K! j5 n8 X. ^            for(int i=0;i< arr.length;){
                if(count_map[k]>0){
; r) m2 ]9 r/ n9 v* w1 F0 ?                    arr = k+d;
                    i++;
9 g9 j/ ?+ y0 j3 W3 |) P0 G                    count_map[k]--;
1 r, m1 M! @8 [) i7 x                }else
' ^" I4 U9 x" O9 }3 n2 Y+ B& k                    k++;
            }
        }else {
4 H+ H0 c% K7 \            for(int i=arr.length-1;i>=0;){
; N4 o) l+ o+ \4 Q4 z: G  ~                if(count_map[k]>0){
! T8 [9 \4 z- w' t& t                    arr = k+d;
& ]/ `" G2 b1 K9 P                    i--;
) k; ]- Q/ [* e" k3 Q                    count_map[k]--;
                }else
* P) n4 D4 j: f/ V) G+ E                    k++;
/ {5 S6 N5 N% Z. v            }
+ ~2 q$ y' I, F        }
% ?+ U" i4 z$ u5 X  ]4 T1 j6 Q
0 {/ V5 E, G3 d
& A/ ]4 S  W+ |/ b: Z; J2 \/ D, y    }
}
  l) s; v% [# \& I1 S: H& e3 i1
2
3
4
( c& I. F0 z% ^+ c, ]) m9 Q+ {5
6
7
8
& U4 [( b4 W3 Q6 |8 D7 ^9
10
11
12
, {9 z! ^* C5 h13
5 a( E, R; g% y+ _& [, {4 j% |14
15
16
1 d6 |! q2 H) v1 ^6 a17
18
0 U# V$ I* l7 q5 z0 o! j2 D, [19
) S. m1 P5 g6 n/ i* `20
21
22
23
8 [2 V' O. y0 Z& p! I1 ^24
1 Y2 N3 R" ~9 {% [* ^! X25
& G, O" E# x! m; ~* ^& S/ g. J# _" I4 p26
) s. l7 s  n% S& B1 i27
28
29
30
# ?* r$ l( i# U  S( \: C: |6 O31
32
33
34
35
36
37
38
7 d" ]! f- |0 b& r9 w39
. X* p* t) D4 \, \5 A+ _40
41
' A% b4 H! \) W, c42
9 x" ~# {3 x  c/ i43
44
& @, L' |  T" l) q7 O45
46
47
  o6 `: N' P' t& U( ~5 E48
49
50
51
* F: Y, t8 w  q+ B% K8 O1 b/ ]52
) R4 D9 w) S; @' h# ]3 f2 z53
+ M. O6 R7 u: b' f/ h5 ]+ a9 G54
55
56
57
5 ^4 f% W) _6 ^& F& N! p( |0 d: z58
59
' v3 g; V2 W5 b0 J* W桶排序
4 D  s9 [( Y$ ?/ I5 V* T2 _! {简单解释：
, @' Q. ^$ I* `就是把一个数组分成几个桶（其实是几个区间，从小到大或从大到小的几个区间）装，然后让每个桶（区间）有序，然后取出来放一起就可以了，相当于把几个有序的段拿出来放一起，自然还是有序的，当然需要是按照区间的顺序拿了。

( ~) s) R5 m1 U- d
# t: _" ]9 {% K, T! N* F( e

* G1 X+ I7 M. ^: _& U6 X; a; T  Y( P
* t# ~3 p/ b8 ?( B
完整代码：


package com.keafmd.Sequence;

6 A4 W0 }; G& _0 Y6 q
import java.util.ArrayList;
# _7 q- b: P0 `, \import java.util.Collections;

4 u, \% T8 O0 V1 o! ~2 F3 t
/**
* Keafmd
*
* @ClassName: BucketSort
- n  o' L0 o. I+ N! B8 C( s * @Description: 桶排序
* K8 J" Y( w; F2 [4 j/ O$ O  ], | * @author: 牛哄哄的柯南
* @date: 2021-06-24 13:32
*/
, _9 @) t" ^9 e( v2 lpublic class BucketSort {

* w/ E' D5 N0 R: S9 `- r
    public static void bucketSort(int[] arr){
        bucketSort(arr,true);
    }
: s) {8 D+ D1 P: V0 O7 [
& d! K3 ^8 f8 P: i
6 V- _' [2 F+ H3 `) f# I    public static void bucketSort(int[] arr,boolean ascending){
, y3 i" a+ X& A+ U) n1 }        if(arr==null||arr.length==0){
            return;
2 Y5 w4 k( L, n0 r* |3 F5 I        }
7 ~" q6 b7 m. K: W! a% {- D& `        //计算最大值与最小值
8 {3 G+ a) Q3 p( @2 f1 f  ~7 ~+ d        int max = Integer.MIN_VALUE;
- E5 N7 r' N# g$ q6 }+ p        int min = Integer.MAX_VALUE;
        for(int i=0;i<arr.length;i++){
            max = Math.max(arr,max);
            min = Math.min(arr,min);
        }
( t3 H- G8 F# [& r+ R

        //计算桶的数量
& s1 y* ]' Q3 c4 C  z        int bucketNUm = (max-min)/ arr.length+1;
8 o3 i4 D$ ?/ p7 a4 v( b        ArrayList<ArrayList<Integer>> bucketArr = new ArrayList<>(bucketNUm);
  B1 T  A+ w! [        for(int i=0;i<bucketNUm;i++){
, D1 m- G3 K% {            bucketArr.add(new ArrayList<>());
- g- D7 t8 p8 k$ f! r        }


        //将每个元素放入桶中
9 h+ H0 i: x2 ~' @- P8 s        for(int i=0;i<arr.length;i++){
) L; }9 i0 ~) g: \! o+ A% d            int num = (arr-min)/ (arr.length);
9 Y( Q: t5 m) I7 v+ r7 h            bucketArr.get(num).add(arr);
        }
9 {2 [8 |. i+ Y2 r
* h9 {; M5 M( ?& y' p
+ f  m4 t" x5 C1 F+ T        //对每个桶进行排序
% U! ^! b3 G5 k7 a6 Z) P/ O. ^7 Q' k# W        for (int i = 0; i < bucketArr.size(); i++) {
% y7 H/ k& V9 d$ h. S            //用系统的排序，速度肯定没话说
# p# ]9 `% _! T! b- ]' y8 U/ y            Collections.sort(bucketArr.get(i));
" a8 i, b2 s8 p  m  g        }
8 _/ X+ l& U# N% ?; S* |

; q' Q. a+ w0 }" g: I% |        //将桶中元素赋值到原序列
        int index;
5 W* Z3 M8 `7 ?9 r        if(ascending){
            index=0;
' d3 K! j  p* D8 x/ P/ F        }else{
            index=arr.length-1;
        }
  J; B5 H/ D7 K2 c5 q1 U

, z: d4 {" @" d  L" R        for(int i=0;i<bucketArr.size();i++){
% l' [3 G  f, O* \; d# d1 `$ L            for(int j= 0;j<bucketArr.get(i).size();j++){
4 C! A* T2 p* m6 C7 D* Y! I                arr[index] = bucketArr.get(i).get(j);
( d  I3 I# Z' ~- j# I* F/ y5 h                if(ascending){
- Z1 R8 A1 p+ _: c! G% Y                    index++;
                }else{
: G" R  Y1 |& a/ i1 a8 y4 d                    index--;
                }
) u# J: G' U+ O* X            }
1 ~4 C. o4 ]2 O% j+ r. c6 k% ~

4 C: e  L( f9 ?$ j6 [% y1 z& d1 M+ G        }
8 q" U+ p: ]6 o" B5 _% Q% P

    }
9 u. q- M: |" i% Q, ]  g}
1
/ h. d; j4 @. k6 [2
3
4
0 A2 z9 G% g+ m1 J3 g/ o4 r5
6
! W- M2 T* @0 u; ]( @7
7 Q' Q: J! K2 a( F, M  }8
9
10
11
! X6 M; K1 L1 r7 t12
13
. e$ N0 x7 g$ V) K5 M% f& v9 z6 z14
# Q' U8 @2 I8 |4 O; q5 P15
16
- c- C5 d# ~+ I( I& u. e% M17
. n/ s1 s9 a+ Y. n18
19
20
21
$ \0 x1 x8 I* e+ y0 F) x22
23
24
/ H3 c$ J# |) j2 s; q25
26
27
28
29
30
31
32
33
34
# y' i" N: I# q  w! }, X35
36
37
38
  p  A* N, c0 X6 v2 R5 p39
  t+ P& q6 C$ {# v- ]  R& d( t9 `40
; B' F) U' O7 S6 Z) t41
42
43
/ W$ z/ c/ a8 p1 J& d( z: `44
4 `) f: u4 j8 B, A+ i  h45
46
47
5 B' _0 E& Q+ s: w" R0 y* {48
: a+ A+ h! O5 U" |" v+ @# O49
50
8 g( A$ R% D# ^0 X+ _51
52
+ w# K7 `! Z; O53
54
55
$ p. m- _5 X1 h56
8 p- K3 e" w8 G4 V: P+ A8 O: ]0 [57
1 b1 X1 K% c' b) w1 @- D* [" C7 f( `58
59
5 i7 M/ k2 l' x% _! z( }; \& Z60
) }- t# j/ a- ]9 W- ~3 M: x61
. s; J/ S2 s- u62
63
" p+ A$ C' q! g- d64
65
66
' p& B6 R8 C! ^7 B, u67
68
1 B6 g, c6 N3 m8 Z+ W" X4 ~4 _69
5 n1 i, V! [4 v( o" F6 `$ |70
71
72
0 Y" n, r+ ]  x5 ?基数排序
# l. \( N3 M6 V* j, d% s简单解释：
首先说一下，我发现好多人写的基数排序只能排序正整数，其实只要处理下就可以排序含有负数的了，就是我们排序前先把所有的数整体变大（就是减上最小的负数，也就是加了），都变成正数，然后排序好之后，在减下来（加上最小的负数，也就减了）就好了。
2 w) k: V. i# T. d1 M0 c  V基数排序就是按数位排序可分为LSD（从最低位[也就是个位]开始排序）和MSD（从最高位开始排序），下面写的事LSD基数排序。
基数排序就是把数按位考虑，让后我们一位数只能是[0，9]，就是我们在考虑某位（个位、百位· · ·）的时候就只看这个位的数，放到在[0，9]相应的位置，然后顺序取出，最后再按其它位这样操作（上面说了要不从低位开始到高位，要不就是从高位到低位）
$ g! O9 p4 y8 ~+ Z- Q  O

/ R2 I9 K) q3 _% W7 a9 Q
3 P5 d9 L% i! P9 q  ~
1 N: N9 n) B! C

5 J7 ]  G' Q0 V: T" U完整代码：
* m5 [. s3 t5 [* T6 x
9 T* s0 l/ Q& H: z; S
3 [+ {) l* Y# epackage com.keafmd.Sequence;
. n& L% L. F6 d1 W$ J
" C3 L, v% \- ]8 Y% m* S! v
/**
* Keafmd
3 S9 w! t! f0 j2 t! [ *
* @ClassName: RadixSort
# ~+ h* i6 n" B0 p8 ~( ^ * @Description: 基数排序
# s& K4 E8 f5 B! U5 d * @author: 牛哄哄的柯南
9 d( @# z/ U1 q% @. `" O( U8 F1 m" n * @date: 2021-06-24 14:32
*/
public class RadixSort {
. V6 g/ }7 g! G    public static void radixSort(int[] arr){
        radixSort(arr,true);
    }
6 I6 d8 q+ c2 c5 m% R    public static void radixSort(int[]arr,boolean ascending){
        int max = Integer.MIN_VALUE;
& U0 z* h  y# m/ N+ s4 g        int min = Integer.MAX_VALUE;
        //求出最大值、最小值
        for (int i = 0; i < arr.length; i++) {
3 b0 Q2 s- e' s$ {# Z            max = Math.max(max, arr);
            min = Math.min(min, arr);
        }
        if (min<0) {        //如果最小值小于0，那么把每个数都减去最小值，这样可以保证最小的数是0
: R( `' q4 W' P, U+ h6 J            for (int i = 0; i < arr.length; i++) {
' N% g' |+ X8 w! Z- y                arr -= min;
            }
6 r$ b+ H1 u0 w" T6 M" f            max -= min; //max也要处理！
. A/ p" s* C4 f9 T3 o+ @& \        }
. d5 T# f' @, [0 J' C  ~        //很巧妙求出最大的数有多少位
        int maxLength = (max+"").length();
" b; V% C. m) k2 v$ O; B" Q        int[][] bucket = new int[10][arr.length]; //一个二维数组，一维代表0到9，二维存放符合数
+ i* m7 }0 J. H* R1 Z6 N7 u        int[] bucketElementCount = new int[10]; // 用于记录0到9某位存在数字的个数
7 q: z* F% b) S: K        for (int i = 0 ,n = 1 ; i < maxLength ; i++,n*=10) { //个位 十位 百位 这样遍历
            for (int j = 0; j < arr.length ; j++) {
& T4 v0 o8 w' v+ q8 t" q4 l                int value = arr[j]/n % 10;
  r! a) V8 G2 K3 l0 z0 _                bucket[value][bucketElementCount[value]] = arr[j];
                bucketElementCount[value]++;
            }
+ l8 r) ^. m8 Q* Q  d" ]) g6 g

$ ]% `0 B- C( d$ M, t1 z            //升序
            if(ascending) {
9 I1 @0 ?6 `; @0 I4 W0 N                int index = 0;
: d) t+ ]9 W- w                //从左到右，从下到上取出每个数
                for (int j = 0; j < bucketElementCount.length; j++) {
                    if (bucketElementCount[j] != 0) {
! X& k  w( Q4 h1 a                        for (int k = 0; k < bucketElementCount[j]; k++) {
                            arr[index] = bucket[j][k];
                            index++;
0 ]3 }' v  `/ A5 {! R                        }
                    }
                    bucketElementCount[j] = 0;
                }
            }else { // 降序
0 S, t4 A7 r. S6 x6 b                int index=0;
: f' j' e9 Y2 h1 R                //从右到左，从下到上取出每个数
                for (int j = bucketElementCount.length-1; j >=0; j--) {
                    if (bucketElementCount[j] != 0) {
                        for (int k = 0; k <bucketElementCount[j]; k++) {
, p9 p" ^/ Z* {0 R# d                            arr[index] = bucket[j][k];
                            index++;
                        }
                    }
; X- I1 w% }' o5 q. H) r1 B                    bucketElementCount[j] = 0;
$ i1 P1 i& K( m' h! Z3 d- [! S                }
            }


2 w- i9 h" _: i6 g* v
6 M5 |* N5 V0 H. ~
            /*for (int i1 = 0; i1 < arr.length; i1++) {
                System.out.print(arr[i1]+" ");
6 O; _" w2 g$ `5 \0 u/ @            }
            System.out.println();*/
  }6 r! @$ r4 |6 I- }$ Q3 x3 w6 M

, `+ V1 g" a+ S" f

- U$ _8 N4 R" @( o8 \
& E- U- k" W) {& M# `6 U/ E
        }
        if (min<0){
( U5 C' u. u& M- v( c# _: j. H" r            for (int i = 0; i < arr.length ; i++) {
( k) N4 _6 H6 u) X( z" J  ]. ~                arr += min;
            }
        }
& g. m! a6 f: c# U( i, q

$ [$ k' v6 h! c0 \: [+ w0 P& w    }
( x( K& c2 @" A2 w}
3 T0 e$ n2 \: k1 n& x% c' m, L2 w1
2
+ O) \& I! p- q! G/ r1 ~3
4
5
- U& Z4 j3 r5 G7 E6
6 }; P/ P! X& t! I2 M7
8
4 y  ~; g. w5 o" j; v, Z9
10
11
12
13
' I, O: A' I. t8 n) I; \- F14
15
16
17
3 b4 Y( N$ a, H6 C3 u; [9 Z18
" T8 U* n4 @( [. s  Q8 ^19
20
. o( m1 G! Z5 M21
5 C. x* I, m( p5 ~$ {$ R22
: V4 R- o0 V1 y5 f( \8 p5 n, ?- w; V23
: `7 i: h$ p, O0 P24
9 J9 l4 G, f. c) h  b8 ^2 ~25
' N9 q( n$ [& d* T* W' @26
27
" x- w. ~/ y7 s' R5 R28
" ]: C/ _' {3 o  R29
# o7 B2 ^: h7 d+ L0 Y5 m1 j& V5 e2 R. N30
8 }0 `4 u3 v8 s4 W3 g) \31
32
33
( k7 y, M2 [0 S34
$ }, g; R: M6 W; r1 F8 U35
0 }0 Q$ A2 l  ^1 E1 T7 d36
7 ~: o. o% V  \/ h37
/ E! `$ Z" h1 h' k38
39
) Q" ?, M- {, S6 L+ s9 \40
/ _  [6 g2 V4 A, Q41
42
43
8 Y( O: U' _8 r+ F4 r9 ^4 i0 M2 ^% X44
45
3 A/ Y" M  s* I6 u& v9 h' N2 l. D46
. i5 t& k( ?; y, ]- q47
( R8 f, g& l3 y' A4 U% T3 ?48
5 Q( F3 H( @) s% Q# U49
" D2 E$ ^- |- n. o4 \0 I& N# a50
51
' l# ^: ]& x% ?" K1 f6 n! t52
) j+ y$ R9 h; n% _6 f53
54
$ s2 D0 ?7 q/ p& `# q; w& ~7 j55
56
57
+ V/ A" O, C; b% L2 |7 D3 y58
59
3 H! B) J2 ~0 J0 r60
- T' n( M* B; \1 A/ @7 y, T4 J61
62
63
64
65
2 S- h/ D3 t, X66
67
% G# n  f# B+ b! M- K, \- f" Y# U68
69
) K9 H9 N4 b- G70
71
, L0 k$ i$ p% n2 G) n% O& C72
" l7 r. O( B* Z8 V73
# p5 [: e$ t1 b  R8 f74
1 H6 m, s+ ?. s% v' F75
76
77
+ F6 h# s5 q/ h! M) F78
; R' [) ?. @/ R8 T9 q# q79
80
81
3 |( l' B4 H& Z' F) C3 M' S( @) n82
83
完整测试类
# |4 T+ `- b) V6 |! w5 D, Gpackage com.keafmd.Sequence;
4 ?6 i8 f# N# |8 Z

import java.util.*;
import java.util.stream.IntStream;
import java.util.stream.Stream;

) c8 _  k2 a4 D
. |* N  B1 H! z- d. m' R/**
, x- }, K4 p2 b% z * Keafmd
8 g9 p( Q# O' J, d *
* @ClassName: Sort
* @Description: 十大排序算法测试类
* @author: 牛哄哄的柯南
7 J$ x2 I, n) ]& w0 O8 E * @date: 2021-06-16 21:27
% X( S2 W( }/ V8 W  Q) ]& | */
public class Sort {
+ s2 U* ?. ]: K7 f2 w* ]3 X



    public static void main(String[] args) {
0 U1 C! q& Z' x1 j/ ^

        int[] nums = {12, 4, 25, 47, 58, 34, 25, 9, 99, 26, 1, -13, 162, 10093, -66, -1};
//        int[] nums = {12, 43,56,42,26,11};
        int[] temparr;
. c) V8 k5 K- i8 X* n6 U
. Y% U+ y- C8 ^" X' l9 E7 v6 v
        //利用系统Collections.sort方法进行对比
) o! S4 ^! y1 X6 C' V2 L5 F

9 ?& ^( `: N: v2 r' M) Z$ {* _+ X        //将int数组转换为Integer数组
% t0 _3 w# \0 s        //1、先将int数组转换为数值流
8 ^/ j( P) j" A, g2 S3 N        temparr = nums.clone();
        IntStream stream = Arrays.stream(temparr);
        //2、流中的元素全部装箱，转换为流 ---->int转为Integer
( Y2 S8 [/ L' @! l1 `4 O6 H' ~2 I        Stream<Integer> integerStream = stream.boxed();
" K" r0 P! |0 Y* t& O# c        //3、将流转换为数组
        Integer[] integers = integerStream.toArray(Integer[]::new);
        //把数组转为List
  l" d& k4 i# J/ h% ^2 Q5 Q) ~        List<Integer> tempList = new ArrayList<>(Arrays.asList(integers));
2 ?/ m0 r0 F+ f  }        //使用Collections.sort()排序
5 @5 S6 Z7 s, y        System.out.println("使用系统的Collections.sort()的对比:");
3 S$ s4 [2 p, q5 p8 z" f$ u: ~
9 }4 F5 g3 Z& o. h  E8 D. b
        //Collections.sort
        Collections.sort(tempList, new Comparator<Integer>() {
            @Override
            public int compare(Integer o1, Integer o2) {
                return o1-o2;
$ V# W* D/ |7 d/ t" [                //return o2-o1;
            }
        });
8 Q0 C6 i, j3 f% I% [

* d# i3 _0 |* }' |( n6 T        //tempList.sort 也可以排序
       /* tempList.sort(new Comparator<Integer>() {
            @Override
            public int compare(Integer o1, Integer o2) {
8 R) j% Z7 ~$ r/ U                //return o1-o2;
8 S* q5 ?8 |+ F' Z( Z  K                return o2-o1;
            }
        });*/
! B- d# n# P* [( e$ y9 {* \' e
# t3 p- s' J4 |6 E9 b
        //遍历输出结果
1 e$ n7 d( y3 _- [! A" T        for (Integer integer : tempList) {
            System.out.print(integer+" ");
+ s* D0 Z8 W6 }( I        }
& p( G- g8 V9 u6 C+ l6 {
& \  m$ Y$ V) C8 q; J4 e
        System.out.println();
$ W, \, V: a: h* C
6 ?0 ~* o4 _3 `% V' Y: Z
8 ~- v1 e& \  P: c5 j: x  p0 e        //测试冒泡排序
0 P1 O+ }  A- B4 b% H5 }3 f        System.out.println("测试冒泡排序:");
4 Z* _) a5 {7 a2 @        temparr = nums.clone();
8 t$ K9 h2 W  x% B9 i
& K6 Q0 u- b6 C: m9 Y
        BubbleSort.bubbleSort(temparr);
! {; E6 e. A4 v% R$ n$ L# W- H
( Y) k" I+ F3 O1 z9 P7 Z
2 b' s7 v9 b3 U, X, a        //降序
0 h8 E, N( z; z& G2 a+ c9 Q        //BubbleSort.bubbleSort(temparr,false);

" D/ @( s/ P& _; [
        for (int i = 0; i < temparr.length; i++) {
! u8 B2 U) v6 m            System.out.print(temparr + " ");
        }
2 [* a# v8 q& f4 N: D7 q        System.out.println();

% k, O! w/ o, z9 ~/ P0 ?2 d! l
* ?% w; e) r$ Q/ e$ u        //测试快速排序
7 h6 W5 I( n, y( |9 |        System.out.println("测试快速排序:");
+ k9 K- m1 o" w* o8 A1 [        temparr = nums.clone();
        QuickSort.quickSort(temparr);
  L; O* i) M/ t) J' E8 }: T3 k        //QuickSort.quickSort(temparr,false);
        for (int i = 0; i < temparr.length; i++) {
" {$ S3 m- l. A- Y  f, U- t: |' s            System.out.print(temparr + " ");
6 v6 H% E% E* C( ^; L* W- V4 s        }
. [: P) c! h. [2 {- L        System.out.println();


        //测试直接选择排序
5 j. T! u6 H5 I% f        System.out.println("测试直接选择排序:");
        temparr = nums.clone();
        SelectSort.selectSort(temparr);
* V9 I$ \# y7 ^, U1 m( `) V- G        //SelectSort.selectSort(temparr,false);
        for (int i = 0; i < temparr.length; i++) {
            System.out.print(temparr + " ");
2 }8 H' B' @& ]% }1 ]        }
        System.out.println();
; I! Q$ A  e5 o* K; W0 z

; I3 h9 ?# ], F5 x) l+ R2 ~8 u        //测试堆排序
4 p5 W3 d; }7 R" ]2 o/ {        System.out.println("测试堆排序:");
5 `. L# x; [6 e; T$ x: A: L9 H, ~        temparr = nums.clone();
# T$ u6 t. N4 k+ Y4 n3 y  ^$ N8 ~        HeapSort.heapSort(temparr);
        //HeapSort.heapSort(temparr,false);
5 |6 T& m7 a! E% ?8 M, S        for (int i = 0; i < temparr.length; i++) {
* b6 ~) N( N  d( U            System.out.print(temparr + " ");
        }
% J) C2 V, z1 ~/ l* w8 b8 W        System.out.println();


        //测试归并排序
9 @9 B: `5 d0 J/ h7 R        System.out.println("测试归并排序:");
        temparr = nums.clone();
% f, u$ @1 U3 {        MergeSort.mergeSort(temparr);
  }8 A# v% x3 D        //MergeSort.mergeSort(temparr,false);
        for (int i = 0; i < temparr.length; i++) {
) k0 y2 S3 G2 b9 S- j$ X            System.out.print(temparr + " ");
6 c. s" o2 g; ]* B: b7 Q) o        }
        System.out.println();
' P9 H' z; O! K
2 {5 l8 }0 B" N7 A. D% t, M
        //测试插入排序
        System.out.println("测试插入排序:");
        temparr = nums.clone();
$ C1 o" b6 E, D2 B% g1 z/ o' t$ D1 R        StraghtInsertSort.straghtInsertSort(temparr);
" ?+ r6 q; @, R$ y4 Y        //StraghtInsertSort.straghtInsertSort(temparr,false);
        for (int i = 0; i < temparr.length; i++) {
& ^; M9 v% q7 A! T3 i            System.out.print(temparr + " ");
: e4 `5 t2 x* s/ K8 C  J. x! {        }
1 E: `% _1 y: i0 o        System.out.println();

) q& M% r+ r3 ^, P! H


        //测试希尔排序
        System.out.println("测试希尔排序:");
        temparr = nums.clone();
2 V! U0 L% C; }) {% r% _" F        ShellSort.shellSort(temparr);
        //ShellSort.shellSort(temparr,false);
9 F" R2 G0 x  ^6 D( N        for (int i = 0; i < temparr.length; i++) {
$ [$ d3 p, H  z4 L& Y" ~  f            System.out.print(temparr + " ");
        }
" A- W; c/ V; ~8 j/ }" C* ]        System.out.println();

$ y5 I. X  G2 Q$ t7 n! L) m

! @1 d( a- d6 w4 _. O
        //测试计数排序
) w" {! |7 `7 c1 ]        System.out.println("测试计数排序:");
        temparr = nums.clone();
        CountSort.countSort(temparr);
        //CountSort.countSort(temparr,false);
6 a4 r3 C7 e- y4 ~        for (int i = 0; i < temparr.length; i++) {
            System.out.print(temparr + " ");
% m( n# [$ O! _2 g: ?, ?* Z, v1 }        }
2 J; t, I$ u& l2 v) t/ H) E2 G        System.out.println();

. t8 L3 P" a4 J: U3 B


- v. s' K- n, p# ?0 L2 u8 C  f        //测试桶排序
, h& J# i- @% P* D; {1 {8 E        System.out.println("测试桶排序:");
, U6 e9 q( M1 H* E6 p3 S        temparr = nums.clone();
        BucketSort.bucketSort(temparr);
1 l$ h/ y9 |; ?1 g/ B+ V        //BucketSort.bucketSort(temparr,false);
        for (int i = 0; i < temparr.length; i++) {
# f6 e! M/ r+ M7 s" r% ?            System.out.print(temparr + " ");
        }
        System.out.println();
# q' f$ d$ M2 k* a4 n9 l
8 x* J0 z+ i% b* b/ o4 A
2 }8 W7 h, p! `# H9 c7 s        //测试基数排序
3 `7 F7 W/ Y( Q4 p5 }# e2 ]  [        System.out.println("测试基数排序:");
        temparr = nums.clone();
        RadixSort.radixSort(temparr);
        //RadixSort.radixSort(temparr,false);
        for (int i = 0; i < temparr.length; i++) {
$ W# H  w+ p) ~& F" ?            System.out.print(temparr + " ");
        }
        System.out.println();
3 @! r0 }. f  W1 m' s

  H; w- I  C1 x* B' R4 k: v) s    }

" A4 g$ |, [3 e
}
) w) o1 j% ?9 K) \) ?: i) d9 r1
& V5 h5 j+ r+ o& a) _. F! T2
( t& h/ p& S' O3
1 [/ x/ H+ f) r) R4
9 |: c5 g1 C" ]* Q9 {" J9 j5
, B1 x5 Y6 s& M7 _: b, ]! G/ I6
+ Z( V: A, I* z% [6 a. M7
) B$ E/ f) P. s& B3 H8
9
10
11
$ H  ^; V# O& b. Z0 x12
13
14
15
* h% S3 L/ P# W2 P16
9 e, H! v- ~0 U( l% r/ d  k17
18
19
$ w0 l. J: e, U: m2 D3 O% i20
21
22
$ m2 ?8 E6 a% N, A) z- Q: [23
24
25
26
: d) s  `/ `4 c1 t27
4 D$ r+ p. ]7 [28
# M8 e0 r! }7 K  G+ m! c. _  ]9 I29
9 o* W2 H( G9 o0 \5 C0 @30
31
32
33
34
35
& n# {. d/ g3 |# d2 E9 K36
37
38
! o/ R/ v8 l. r& M- |- F4 e39
40
41
42
( p7 H1 ]6 k; j* V9 r8 z43
8 w- s, G5 v; j0 E  z44
2 J# T+ p3 l3 ~: e& ]45
+ Z+ r$ T7 X( E46
# d1 k$ a: E) W47
8 S! ?/ i6 p9 {8 E48
" l& x' [1 C9 b8 L" i49
50
' |1 R( j, U$ c( {) l  _51
8 A- Q7 p. l) w! B52
7 Y$ \) E: q7 d/ ?53
" z6 O6 N  ^( m3 S; l" _54
. T; }, F6 a( p  p" T, Z55
56
0 I% C: u: k6 z57
, p/ x, _! e$ R, c* s2 _# D58
59
, h; O" s- X" [4 l( i3 y60
61
1 c- t# N4 D% i3 M+ V62
* w/ W6 ]. J& p2 ^* W$ K4 [3 B63
, s, x1 l9 `! x64
65
66
67
) n7 k. C3 t3 r4 H) J- y68
/ f# p+ q1 ?4 J) I' `. y69
70
71
" e" {- P1 X9 _72
1 y9 Z# L- x! v, n. h# G" t73
& o. f0 h8 a/ {' }* z" c. j74
$ U9 \% p( o/ L. c$ w75
76
3 U" W* L9 I) s9 Y$ o77
5 d6 \7 }7 M- ~: o+ _, k+ A78
. n& M3 U  ~* J1 R; p79
80
* T- f9 C9 `) w9 j81
82
83
  A2 `: ]4 q- P9 H4 O* a84
85
86
! Z& b. F, `7 I7 x; J87
* I; {& Q: x1 w) V# ~! T" }88
1 m7 |5 F) M8 b8 t5 F89
90
91
92
! T" s( {. l6 ]) s* ?0 D93
94
! ]: T2 D- z$ T' _1 n95
96
4 R( p! o: \1 g! m0 c97
98
9 o+ z/ q- R9 q: _( a7 S& g99
. d: g5 Y8 Z5 T100
101
: ]' p2 w( S' i4 @) L102
2 ?. g5 z" n- I/ ^3 n6 S# {5 d103
8 U8 C7 U4 M3 o1 h$ c104
, S. M& R2 k7 x# Q8 Q  x5 n% A105
106
& [$ [4 C) a( l# a107
108
* N/ j! j# D7 ]2 b0 X! w9 V, ^109
$ v' c$ g  t0 H5 t110
111
112
) U% H2 O9 G) `  E+ j8 r- G( v113
114
115
116
117
4 b; d$ F7 C2 Z4 O! `118
119
120
+ l, h. A  ?4 H# J: P9 C% y* N121
122
4 O! s' m* U* k123
124
125
/ c" v3 w; z; y6 F- u$ E, x126
127
128
129
* ^" |9 ^% B5 y7 |7 D130
131
132
133
; q0 t! w) b$ c5 P# P" t0 w/ L# }134
135
  U1 F) B1 Y- i; P136
# q- X9 K/ p+ L+ N, U137
138
$ \$ l4 P5 l6 k; Q5 }1 _139
140
141
142
9 {$ k5 c& y% |$ x143
144
145
+ O+ q: [! Z& J) J% }! O* L146
147
148
/ N" ~0 W& a4 G% l$ B149
150
151
4 |# l. Y* A/ G9 D$ I152
9 i/ e8 ]/ W3 f) K" v2 ~+ F153
154
155
3 I3 ]  |  C1 G* }! _& w4 T( A156
& Y, q& ?3 t$ M157
) d  b  n4 l! W; j) j158
3 D  M# r5 {5 R( F$ m! i* x! M159
9 [# U6 b, S/ {3 j0 f+ v! P1 v" W. L160
! u. A6 E3 P; Z161
162
163
! s. E$ }9 I1 N164
" Y1 E& E+ e, N165
  ^& ]( t' b3 B; d166
9 d1 s8 Y# u+ Q& h' E' H3 n2 Q167
+ g/ I& D" r# Q6 L2 S168
# {2 ~2 n9 q$ q( E% m- w' f8 y' W169
6 [: t( z" V5 `1 p4 Q2 Z170
171
  {5 q- Y- p& X' w, s& }+ r172
173
每天进步一点点！
不进则退！
, @" A( b, @2 g: M" |$ g8 P/ M% ^2 p& g

  h) j+ b4 {& R' a- e9 Q. l版权声明：
0 ^. P, a& D: D: }5 R$ t原创博主：牛哄哄的柯南
6 k2 z- V5 `1 F博主原文链接：https://keafmd.blog.csdn.net/
————————————————
版权声明：本文为CSDN博主「牛哄哄的柯南」的原创文章，遵循CC 4.0 BY-SA版权协议，转载请附上原文出处链接及本声明。
3 \" n! O1 p+ u3 e# C5 ?原文链接：https://blog.csdn.net/weixin_43883917/article/details/118193663
; D5 V+ [& D' {; i
/ q+ `! {$ C6 O9 b

1051373629

每天进步一点点！