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

杨利霞

; I- f# Z9 R9 @5 a$ V0 E2 o经典十大排序算法（含升序降序，基数排序含负数排序）【Java版完整代码】【建议收藏系列】
经典十大排序算法【Java版完整代码】
写在前面的话
十大排序算法对比
4 {' g4 U  S" i! k8 O/ `冒泡排序
快速排序
, g8 n0 h, x# t5 C* A1 O直接选择排序
5 ?, A# d' _, s0 I- O堆排序
归并排序
插入排序
希尔排序
计数排序
$ L. w3 c$ q" }! z5 K( I7 `# h桶排序
0 x% d& w( e+ s: ?/ V+ S! Q基数排序
完整测试类
8 B5 N. F2 L1 X6 F写在前面的话
       虽然已经有很多人总结过这十大排序算法，优秀的文章也不少，但是Java完整版的好像不多，还存在某些文章代码存在错误的情况，同时也为了自己练手，决定把所有的写一遍巩固下，同时也真诚的希望阅读到这篇文章的小伙伴们可以自己去从头敲一遍，不要粘贴复制！希望我的文章对你有所帮助，每天进步一点点！！！

. w% Q! Z0 ]7 y
! t3 u2 C) S6 {' h1 K       我用通俗的理解写下对算法的解释，对某个算法的运行过程不是很理解的话或者想看比较官方的解释的话，单独搜索某个算法，看几篇不同的解释，就可以有自己的理解了，这里我主要展示代码以及进行通俗的解释！整起来，再强调一次，一定要自己敲一遍，这样才能理解的更深刻！


) M1 c3 z/ o1 C# T  S6 n+ M$ |十大排序算法对比
7 S( e  P5 n$ Q6 z$ o5 D; ]( A* l
1 D, j, ]3 w+ U5 t


关于最后一列的稳定性，我稍微解释下，例如对序列：1 2 4 2 6 排序，序列中存在两个2，如果我们把这两个2标记上（让他俩不同），排序之后，前面的2还在前面，那么就称这种排序是稳定的，反之不稳定。
) m) Z, T0 {! _7 q8 L; Y3 L" H
  m/ [0 Z' d/ K" H/ H
# K" y- r% w0 t8 N8 u冒泡排序
; N" D5 Q; S5 R7 ?) X. r! a6 Z简单解释：
) x9 |2 m9 o, R; Q' _& O       原理就如算法名字一样，就像水中的气泡一样，每次我都把最大的或最小的放到最后面，这样总共需要n-1趟即可完成排序，这就是第一层循环，第二次循环就是遍历未被固定的那些数（理解成数组左边的数，因为每层循环都会把最大或最小的数升到最右边固定起来，下次就不遍历这些数了），两层循环遍历结束后，所有的数就排好序了。
       两层循环所以冒泡排序算法的时间复杂度是O(n 2 n^{2}n
2
& f  c& M* T1 x& b4 ~1 ^- A8 \* P )，是一个非常高的时间复杂度，我在下面的代码进行了优化，加了一个标志位，如果上一次循环未发生交换，就说明已经是有序的了，就不继续下去了，反之继续进行下一轮。

7 h0 E) A2 N6 f  v* b1 n


( L6 V: }: \! i
8 u4 Y" U' j' @. ]
本文的图片来源网络，仅用于大家学习，侵权联系删除！（下同）
& ?: t# g9 A. v* F
. M' D  g; X# F0 m* S5 I2 p
4 S( m! [5 Y8 z) Q, a1 g3 E4 d完整代码：


- t% x3 |5 g( M2 u* K1 s6 qpackage com.keafmd.Sequence;


/**
, E! u3 i6 i' ]' _3 P  F! v& P) j * Keafmd
*
2 p9 X1 L- V6 a+ v9 E/ l' Q) M$ B * @ClassName: BubbleSort
# ]! n1 |8 B2 s, k4 p * @Description: 冒泡排序
! X. }1 D3 W) |% S' T * @author: 牛哄哄的柯南
* @date: 2021-06-24 10:31
8 E% A. v( m( [! d* F# `6 L' ^6 J */
( P# P3 X) ?! b: Cpublic class BubbleSort {
$ V/ s; ]+ l  j. B- s

9 k& B, T* @: v    //冒泡排序
& M- E1 S7 j, F    public static void bubbleSort(int[] arr, boolean ascending) { //exchange标志表示为升序排序还是降序排序


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


2 z+ x, |  }+ B9 c, K- }        for (int i = 1; i < arr.length && flag; i++) { //控制次数，第几趟排序，只需要n-1趟，有交换时进行，只有flag=false就说明上一次一个元素都没有进行交换
5 M- l" e( A- p  H+ w3 @) k, _( q
6 Z! d+ \4 d* F+ X
            /*System.out.print("第"+i+"次遍历：");
            for (int i1 : arr) {
                System.out.print(i1+" ");
1 k7 {4 u# g( {+ h# U1 w; x            }
            System.out.println();*/
' d* {2 s2 _- E. f3 ~2 u

% r( S* \2 y3 l: k/ e            flag = false; //假定未交换
) a7 a) s7 c* V# J

            for (int j = 0; j < arr.length - i; j++) {
0 P7 j; l2 B' Q" W

                if (ascending ? arr[j] > arr[j + 1] : arr[j] < arr[j + 1]) { //控制升序还是降序
                    int temp = arr[j];
                    arr[j] = arr[j + 1];
7 N" o  y2 r3 w2 A4 j' e                    arr[j + 1] = temp;
6 G- X0 O& E: C4 S! k                    flag = true;
                }

5 Y* ~( C( M0 C8 w& D' T
6 v0 J4 s# c# u6 r0 j& v# S% `            }
        }
( Q8 _- \. [9 {& D    }


    //冒泡排序 -- 默认不传参升序
    public static void bubbleSort(int[] arr) {
        bubbleSort(arr, true);
    }
}
1
  I+ Z/ J- D; X+ h/ f$ z+ l6 ^, |/ u2
3
" J5 F" u  t9 Y' G, @4
6 e( U" f4 O( J. p4 a4 p+ k2 G5
3 R- e. \+ [& r1 j6
% e! V, I& N+ G' ~7
8
! \4 @. p2 {# G9
10
11
12
6 a) E7 p( w3 U3 L8 n13
; q7 i0 b( u. L# A$ X8 J14
/ @9 }8 P; _- [. }% X15
0 @4 k! U& a- ]5 l2 ?16
17
18
19
20
21
22
* R9 |% v( e- Z( D" |23
8 v* w1 o5 y/ g& {1 D6 y2 v24
25
26
27
28
29
30
  Z1 q- k+ B) n. u31
* s, y8 U2 \- g0 T: k8 ~32
/ J2 ~0 z7 H& F( O33
6 T1 g; m7 d$ U% e0 }0 f34
2 g4 u, q% X" t0 F1 L" o35
36
37
" n+ k% r1 t$ s) F2 {/ _38
  N! q3 v+ G# I' N3 I5 v39
; B! H7 a1 H% r2 u5 }! r: y40
41
1 x' y7 Z, k+ F+ u3 n1 j% f/ a42
43
44
+ F, v3 D0 w: ]3 |6 M45
测试代码：
' K8 B$ `! A: ]. ]% {  }
! k% A4 u' }; c; @. H6 e
升序排序（从小到大）

. N& g# T4 n: x
package com.keafmd.Sequence;


/ x$ @7 N! W4 o4 Q1 n( Y( J* ?) o! y' jimport java.util.*;
: ~5 B% F8 `  D, C& N" ~0 Ximport java.util.stream.IntStream;
import java.util.stream.Stream;
% X% H  f5 U3 Y/ q2 R/ I0 X

/ {1 X* M2 [; v9 Y; U9 w- F/**
* Keafmd
*
2 ^* {) N& v* J1 t5 b6 ^% W; M6 y% p * @ClassName: Sort
2 D$ J9 P, i( D  t9 d1 ?0 L, J1 o' H. I * @Description: 十大排序算法
! K# i% J0 u! M  b; J9 [ * @author: 牛哄哄的柯南
8 D4 G( ^2 u3 a# m& w7 ` * @date: 2021-06-16 21:27
" Y) U0 h2 ?( s3 D4 p) _8 y! r: } */
public class Sort {
3 }' D/ W" A, h2 t+ }) e4 W0 X    public static void main(String[] args) {
  [8 `2 J, L3 W

        int[] nums = {12, 4, 25, 47, 58, 34, 25, 9, 99, 26, 1, -13, 162, 10093, -66, -1};
        int[] temparr;
5 v; @/ J/ d. Y) R0 d" N
* C" \4 r$ g" y3 r! |9 v9 Y
! e) J  G' v3 ?+ l/ K& @        //测试冒泡排序
3 i3 n9 K. R3 i- l* N; o        System.out.println("测试冒泡排序:");
        temparr = nums.clone();
7 y& N4 q4 A1 W. \        BubbleSort.bubbleSort(temparr);
        //逆序排序
        //BubbleSort.bubbleSort(temparr,false);
3 h& r  Q- f* D. S8 ~        for (int i = 0; i < temparr.length; i++) {
3 ]  d0 k6 {# x  O/ G/ C) a# a            System.out.print(temparr + " ");
7 u* C% j7 e7 C& e1 `! c        }
, _8 c+ f9 r5 i3 y7 \. C1 d* K        System.out.println();
7 x# v- Y. N' r; I: |
5 U1 S6 X# D2 d  J" i& M/ W6 d1 b
    }
}
1
2 E, b3 y4 R( y- X' p" B5 Z& ]2
) h! `: e- {& r6 M7 \( K3
4
5
8 L! r1 e& z0 A6
6 C3 w/ A* R! b9 z, |7
" k0 @3 |; S/ R8
9
1 [5 m8 H6 o7 ~10
11
12
13
. B  {: K) F% R' C14
- R4 C1 S' D' @2 L+ i15
9 Y4 u2 P, Z5 R16
17
18
' `  ^2 Q  v! l' e. W9 z; i19
0 o- i# b! T( s& R3 g4 T20
3 d* r: d  g9 q( x; @21
22
23
24
: e, L1 E" V7 M) a25
26
27
28
29
  K4 K4 d- f) `! x30
31
4 Q3 [) q3 v, B2 S32
33
运行结果：


* d6 e- }9 @0 Y1 B1 C测试冒泡排序:
! ~" y0 o0 p" @+ a8 Z7 A+ J-66 -13 -1 1 4 9 12 25 25 26 34 47 58 99 162 10093
1
2
/ s& g4 M& |) D$ }5 L, a& E降序排序（从大到小）

4 A! R( _9 q) U4 z/ s& N- d
' a- F' @+ F7 e0 J8 r3 U% W; N; a//测试冒泡排序
1 Z9 A9 W1 n+ k7 v. x8 SSystem.out.println("测试冒泡排序:");
6 O8 l+ I' E% l* B( i! J- ltemparr = nums.clone();
( ^6 y6 J1 H# S, y% QBubbleSort.bubbleSort(temparr,false);
for (int i = 0; i < temparr.length; i++) {
* U  y9 M/ ?# Z3 X    System.out.print(temparr + " ");
}
System.out.println();
1
2
+ A5 Q% ?7 g8 P1 d# h: o3
! g' I  Y7 j0 t; C4
$ A8 l; B7 l! J+ k5
- t9 x- q# P+ c! C3 [6
, {  k( I2 w  x7
8
& ^* r. `6 |  P; X' g6 l运行结果：
9 b# }. t7 m  R" |

测试冒泡排序:
3 v! Y; r* v3 N5 n! W. Y; {- M+ Y10093 162 99 58 47 34 26 25 25 12 9 4 1 -1 -13 -66
2 ^( E3 E8 b  r- I9 \# i: u' i) i1
2
8 M" r5 }) I0 `6 G0 T下面几个算法的测试也就是换了下类名和方法名（换成相应的排序算法），如果想降序就在数组后面传个false即可。我就不一一复制了，我在最下面给出含所有算法的测试类，需要的自取即可。

  A1 C+ g, I+ n- i7 j# v) G+ D; M4 v
快速排序
! g- J7 g0 {6 n" w2 b: b3 ?简单解释：
6 k! b0 o5 X6 i# t" C% w6 D快速排序就是每次找一个基点（第一个元素），然后两个哨兵，一个从最前面往后走，一个从最后面往前面走，如果后面那个哨兵找到了一个比基点大的数停下来，前面那个哨兵找到比基点大的数停下来，然后交换两个哨兵找到的数，如果找不到最后两个哨兵就会碰到一起就结束，最后交换基点和哨兵相遇的地方的元素，然后就将一个序列分为比基点小的一部分和比基点大的一部分，然后递归左半部分和右半部分，最后的结果就是有序的了。

5 ]! ]% l2 b3 X5 A2 K

( I: f9 j# F+ y7 v

5 w3 o) V3 W) u
完整代码：


7 n8 t. p6 s0 j" @package com.keafmd.Sequence;

  E* h( f( h4 n2 G7 P% Q) U$ y8 l
8 V" W/ T! k- W, i/**
/ t, a$ _) K. R2 d1 d5 v * Keafmd
1 o8 [1 T3 X  R3 V8 O$ R *
* @ClassName: QuickSort
* @Description: 快速排序
* @author: 牛哄哄的柯南
0 \8 ^3 p0 D* l# z- w; F8 W * @date: 2021-06-24 10:32
*/
public class QuickSort {


* K2 B+ o) F* s1 c! s( e    //快速排序
    public static void quickSort(int[] arr) {
        quickSort(arr, true);
    }

  B) P+ J% }2 h' D% l
    public static void quickSort(int[] arr, boolean ascending) {
        if (ascending) {
            quickSort(arr, 0, arr.length - 1, true);
        } else {
            quickSort(arr, 0, arr.length - 1, false);
        }
    }


    public static void quickSort(int[] arr, int begin, int end, boolean ascending) {
2 ?! v$ d, C% }% d        if (ascending)
1 r# K# D% E6 e1 v% H+ N            quickSort(arr, begin, end);
  K( l+ f; \5 a        else
; y! q( I/ z8 w& Z( T0 {            quickSortDescending(arr, begin, end);
    }
, v) [8 t) S) w+ }

- J1 h" X5 Y- l2 ]    //快排序升序 -- 默认
7 X5 T; j! |# j% w+ H& P/ |    public static void quickSort(int[] arr, int begin, int end) {
        if (begin > end) { //结束条件
            return;
, V: S0 P& m0 G1 N) b        }
        int base = arr[begin];
, ^6 f  K4 {& x        int i = begin, j = end;
        while (i < j) { // 两个哨兵（i左边，j右边）没有相遇
' @) r6 T) {# r- Y9 r) E. T7 V            while (arr[j] >= base && i < j) { //哨兵j没找到比base小的
! F. b2 A( U3 E0 B0 ], ?, Q                j--;
# q2 E4 G9 Z' f' V! F( E. ^' ~& x            }
            while (arr <= base && i < j) { //哨兵i没找到比base大的
                i++;
! }2 X# u1 q8 d3 d/ b0 J            }
            if (i < j) { //如果满足条件则交换
5 H! ^: e8 l0 P1 c0 ], T) [                int temp = arr;
' X* F. u$ a6 w  S& u                arr = arr[j];
( _) N% s/ E* U+ D6 |, U                arr[j] = temp;
            }

+ |$ s0 s0 B4 n1 U9 M: D6 g# O
        }
/ e7 u" ~+ ~+ Q: O- k' f9 |! ~        //最后将基准为与i和j相等位置的数字交换
  I  b" ~0 k7 q' t! b        arr[begin] = arr;
        arr = base;
! V8 P, O+ v# j9 x        quickSort(arr, begin, i - 1); //递归调用左半数组
        quickSort(arr, i + 1, end); //递归调用右半数组
! A7 [& N) }: P7 }- B: t. b; N
* A7 @* e7 T* n& ?9 r/ E/ G
: A* ?- {* Z# u: E4 ~; ?' W9 d" o    }
* m+ f6 k% ]; [) R: F
& i7 S3 `% C& K' l1 x" s
    //快排序降序
- H- ?# n4 h( h& E5 o! ^    public static void quickSortDescending(int[] arr, int begin, int end) {
        if (begin > end) { //结束条件
. n$ y; z. i9 g2 q; J) G1 c: O( r            return;
, N: b/ J# D" ~& W( M- O% l        }
        int base = arr[begin];
        int i = begin, j = end;
8 k  \: t; f& ^: T( P        while (i < j) { // 两个哨兵（i左边，j右边）没有相遇
            while (arr[j] <= base && i < j) { //哨兵j没找到比base大的
& W6 `6 c* M1 [3 Z# ~; o. ^7 v                j--;
            }
7 f, R3 B' Q- g3 F5 a2 d            while (arr >= base && i < j) { //哨兵i没找到比base小的
                i++;
' C* U; l( P0 Y1 X7 L: {! K- B            }
! o1 O$ m7 F. [: j            if (i < j) { //如果满足条件则交换
9 ~0 f1 ^8 M. S                int temp = arr;
                arr = arr[j];
4 S; ]7 H6 e; n" m; o" e' X( `                arr[j] = temp;
$ T1 s6 Y) Y# M; i            }
/ V/ Z2 c/ Q' K* A5 m8 D+ g

% u/ E) {  r$ _4 d4 g        }
        //最后将基准为与i和j相等位置的数字交换
        arr[begin] = arr;
, L* c0 ]/ }, X$ R1 X2 j! x" K; e        arr = base;
        quickSortDescending(arr, begin, i - 1); //递归调用左半数组
        quickSortDescending(arr, i + 1, end); //递归调用右半数组


8 b( {7 s$ J# {& C5 Q* \    }
6 _( p/ [# v9 s9 r
" A5 K% b. w+ Z# ]
}
1
$ Z. R, R( v4 @1 R, j2
7 p) v, Q# o! l. t3
5 U# [& m6 r! `: C' t4
5
9 b6 @8 b9 Z# Y8 }5 b: u2 R6
7
8
$ Z5 i/ y" P" F9 V6 s) T7 M9
% Y, i) z; l! C& A7 }* j. T5 i10
! q0 m1 M, L: t/ m11
8 I0 j  O1 I# d12
13
' o2 o4 i. ~* S, d! D' I7 o" r14
. R9 h7 j" t' B4 R7 q* O) N15
16
17
18
19
; }/ v7 h: ?) {0 |7 @20
$ `' g1 L6 M& N% u6 ?7 H21
# i& n% u1 C6 p* `8 a* k, W22
) _, L8 y! Z  O% F# y0 Y23
24
$ g" |  X) Y+ r( A25
* Q2 o* Z- i% y) }26
27
7 Y: w( ?4 a& g* \" e" i28
29
9 c# \" q8 _9 K: q% K# J30
! `1 y9 o/ U5 l# F31
+ k9 j+ _9 l+ N/ J* v) q0 q32
33
34
# q7 o$ T# Z3 z1 f0 p* u! K; `: F35
7 [, ~% L7 g/ T: G6 |- S# `1 I36
7 Y4 n# X3 L" t4 ~- o+ j1 \' y37
) O+ m5 q8 s* c  L- i4 [4 a+ F38
$ f' Y( n% A1 B  J  i# v" R1 Z39
4 \( n+ {3 a! t6 v7 K! I5 e40
41
9 ~8 L: f0 ?. z42
* Z* r- ~, d1 \& `+ Z43
' b1 h' e. h# {% R44
9 D6 g9 t% w3 Z: P* v45
& e# b/ f' V$ R( Z: I( p  |46
1 \, O% V7 M/ s( {. h+ W47
0 B. i/ g" y/ O6 o4 O# B/ o$ M48
! O$ b2 |) z" G& R- q49
50
51
52
53
54
8 ?6 [3 Z, ^% ~( `9 J55
# |; o& y7 q  I+ }$ J5 \+ V56
$ t% w% Z5 O- y57
58
( ?8 C' z; L( P1 o59
6 h; y! e* Y- `" ?  F$ C60
: ]7 p& X6 t# c% i+ r$ F61
/ B( p4 @: K1 x* k; a5 r' l62
63
/ J# K' s- ]9 c) K# j$ {64
65
66
67
68
69
/ L' I% a# W5 A: n! H! |, R1 v70
71
72
) q4 z5 n+ A; Y; C8 U, U' A6 C5 H73
9 p2 e3 z+ M2 D1 g74
7 s0 o; D2 \6 G4 E75
3 t- s' |# {2 g) q( {: ?2 s. `  y" W76
1 T8 H$ r8 K" T& C6 Y  ]( q  ~77
78
* `! o( Z1 Z( C2 I79
0 ~0 P& `. J6 X' B80
- P5 K0 j1 A, L81
, L2 S. D2 `+ ?- Y: V/ Q3 \/ J82
83
7 ]  a8 ^+ P: q0 t9 _. w84
85
86
8 N; v% a( S( }- r- \87
8 g) Y7 v$ G5 `88
0 k6 i6 f* R7 W8 N89
, |, u# ?1 o( p7 z% O" {( w90
! S% J. g# @: m, f1 \5 u" j6 Y! v( V91
, r& p) p" G1 u  }3 s4 L直接选择排序
简单解释：
9 f6 E9 e0 B- x; v3 c/ r数组分为已排序部分（前面）和待排序序列（后面）
3 Z7 J5 v$ e2 r7 l第一次肯定所有的数都是待排序的
从待排序的序列中找到最大或最小的那个元素，放到前面的已排序部分，然后一直找，不断缩小待排序的范围，直到所有的数都是已排序的了
( s! A7 i! ~) K, v! \
5 y+ J1 t8 s; r% v2 Q9 z4 d% @% c
- [3 }, Z4 N; P2 h' @: E! l  D


$ x4 d& B# J, g/ F
0 Q* d; U2 w$ D' N& U* s' Z* O完整代码：
$ u0 d% [$ Q3 w! @. g

) d( t- T2 l( b3 [$ M/ {package com.keafmd.Sequence;

# I' \3 W" _- p$ I8 O
/**
! i4 q7 a) j, o- N * Keafmd
. ]) a7 H/ L# x8 A1 m1 _/ i *
* @ClassName: SelectSort
& I. c5 F" s/ Z * @Description: 选择排序
* @author: 牛哄哄的柯南
( Q% P+ N- s6 U * @date: 2021-06-24 10:33
*/
public class SelectSort {

7 f0 ?) h/ Q% R7 K) e1 [
( _2 M' B9 x/ D/ {' |$ X    //直接选择排序
! x2 W9 m. v9 p8 S$ P2 f$ L    public static void selectSort(int[] arr, boolean ascending) {
: j& }6 m" E6 ^: m0 n" Q        for (int i = 0; i < arr.length; i++) {
& _% M  J5 {3 i' Q0 T+ n6 ~            int m = i; //最小值或最小值的下标
            for (int j = i + 1; j < arr.length; j++) {
. s, ^! g; }0 U2 c% i                if (ascending ? arr[j] < arr[m] : arr[j] > arr[m]) {
$ y& l/ z8 w0 O' |" [  l' E                    m = j; //找到待排序的数中最小或最大的那个数，记录下标
                }

( c% c/ d4 `; O2 m  i/ ^$ \
' L& w) U3 p- v6 B            }
8 E! ?% L  C2 A2 L/ H5 k' M' J6 j            //交换位置
  m- q6 U2 \8 s2 K+ O, ?1 Z            int temp = arr;
            arr = arr[m];
5 u2 o, p1 m. z9 X* i            arr[m] = temp;


        }
    }

( x4 {, n- e/ }" Q; J8 e
1 [+ g+ E2 ]* ]& C    public static void selectSort(int[] arr) {
        selectSort(arr, true);
    }
& w5 V- R% t; `  Q5 G9 t" {6 S}
3 D; P( W. v# H1
% f# S( N. w- t2 l+ |5 e2
* D$ G) ?. p1 Z: }3
( s; E/ j) [# y! x, p7 x3 H! ~4
0 T/ p6 ?; O& T/ V5
5 o- P2 k4 p! E4 b! J4 g6
% s) p$ x# B0 r  i. d7 c7
9 T" d, b; p4 }( V5 L8
# z# ~9 j5 g# S) }6 \7 Z9
10
11
$ Z8 N' t0 m9 {  G  C" q/ R9 J12
13
14
/ |6 Y8 [+ r) t# o15
16
) x% a' ?, ~8 N7 b  H17
% M6 ?5 e, Q  s18
19
20
21
22
9 {0 p' Y7 t. h% I23
) ?( |9 V7 d  L5 E  d' s# _24
0 w% L$ M) E4 f  y4 }, W& c25
, I  e- B" w# s: f# [- D26
+ g- v3 s) i2 C3 R27
+ ~& q( X" [8 @+ G, B6 Y$ N28
29
: L1 Y: A. _+ ~3 ^( n30
31
32
; G- w/ v+ \5 z* l33
" t0 u1 e: u1 v34
  ?  O! v0 a0 O3 g堆排序
% @3 U, p2 p# @! z先理解下大顶堆和小顶堆，看图
大顶堆，双亲结点的值比每一个孩子结点的值都要大。根结点值最大
7 J! E& {2 O/ T* L2 u  q小顶堆，双亲结点的值比每一个孩子结点的值都要小。根结点值最小
' l# ^, p+ b/ s' p

% R  c/ i' F' y- Z
5 J" m6 v0 ]: N  R% M  q
简单解释：
  c6 J- H5 G8 Z构建好大顶堆或小顶堆结构，这样最上面的就是最大值或最小值，那么我们取出堆顶元素，然后重新构建结构，一直取，一直重新构建，那么最后达到排序的效果了。
- R- t, Y) D  z


# o: \% L  x  w+ j# o1 z+ {  o# S! Y

% D# V3 e& p/ @1 W- J
4 Q4 e( s/ S# A7 k1 o( G8 K" d完整代码：
& J% s' H8 x6 S! m) j1 Z3 C. E, x

* R" ^. h; |+ ^; zpackage com.keafmd.Sequence;

8 [- o5 M% H% n3 B6 Z2 b
% g# \0 y# s5 A: q$ T0 Z% e+ P, ]/**
- o; B+ D6 `( g( T6 i* m * Keafmd
/ k# K; o9 Y# v* D& e4 Z *
* @ClassName: HeapSort
& E( W* R' O1 ?9 J; t. ^ * @Description: 堆排序
0 T4 m& J+ }0 s * @author: 牛哄哄的柯南
* @date: 2021-06-24 10:34
- J. F- z$ o% W+ o. U* I# R& V */
public class HeapSort {

- v  _" p6 z" e; S7 Y: |' S
    //堆排序
) ~+ S1 G0 t0 `4 H0 y2 M# L    public static void heapSort(int[] arr) {
        //对传入的数组进行建立堆，这里默认建立大顶堆，进行升序排列
        heapSort(arr, true);
6 \7 J; J9 [: x0 _, d    }

6 O7 ?& m3 @" M* R% Z: [: A  {+ H0 s
    public static void heapSort(int[] arr, boolean maxheap) {

2 `; K6 o* x' |" \$ s9 j
        //1.构建大顶堆
        for (int i = arr.length / 2 - 1; i >= 0; i--) {
4 m6 l' O1 {8 Y+ ?% ?            //从第一个非叶子结点从下至上，从右至左调整结构
3 ?, [2 J1 L* p1 X: s% n( l, T            sift(arr, i, arr.length , maxheap);
; U# s( {3 V( I4 b% Z5 W) L        }
& C! ], x8 N( ]2 A

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

$ g' c) @* w, R6 H, {
            //现在的数组第一个就是根结点，最小值所在，进行交换，把它放到最右边
            int temp = arr[j];
            arr[j] = arr[0];
1 c/ W/ J6 i0 H' q) ~            arr[0] = temp;
3 f/ U. M2 }7 r, y

            //重新建立堆
            sift(arr, 0, j , maxheap); //重新对堆进行调整
$ a4 H; k0 {; h        }
    }
, |* G0 ~% `  _7 Y" H

    //建立堆的方法
3 n9 ]; E* a) y3 u1 V    /**
( t+ g+ i7 d; H  {# k+ @' \     * 私有方法，只允许被堆排序调用
     *
     * @param arr     要排序数组
" W9 \2 e, p7 O& H, V! K     * @param parent  当前的双亲节点
" `- S7 j9 w+ b/ |     * @param len     数组长度
0 [& S8 Y8 B6 ~9 i     * @param maxheap 是否建立大顶堆
+ y5 l' R$ T5 g1 x; C     */
% q8 v7 E6 b* l/ d, L    private static void sift(int[] arr, int parent, int len, boolean maxheap) {
1 a; C) Q: N0 O, T3 ]: }" f" S
+ ?) L( r2 {5 L7 }
        int value = arr[parent]; //先取出当前元素i
0 g% m$ |; ~& s( z3 g# ~8 H

/ F6 C+ {4 R; B3 C# ~# Y        for (int child = 2 * parent + 1; child < len; child = child * 2 + 1) { //从parent结点的左子结点开始，也就是2*parent+1处开始


            if (child+1 < len && (maxheap ? arr[child] < arr[child + 1] : arr[child] > arr[child + 1])) { //如果左子结点小于右子结点，child指向右子结点
                child++; //右孩子如果比左孩子大，我们就将现在的孩子换到右孩子
- s& Y. I& D; e. o            }
+ F: D- g7 f$ A$ q: \! A( ?

* o1 ]' W/ V/ ]6 p: b; c) B* z            //判断是否符合大顶堆的特性， 如果右孩子大于双亲，自然左孩子也大于双亲，符合
1 i" g( x$ F; }/ j- C            //如果子节点大于父节点，将子节点值赋给父节点（不用进行交换)
            if (maxheap ? value < arr[child] : value > arr[child]) {
: ~9 X1 J; L7 L2 c  N5 q                arr[parent]=arr[child];
                parent = child;
7 _' {/ t" n% \2 `- T& c            }
3 Z1 p$ f! W7 x" e3 ^* P            else {//如果不是，说明已经符合我们的要求了。
                break;
& k; h* _! J. j- F  g; }+ r$ U            }
# ]* M3 g' e7 D0 K        }
        arr[parent] =value; //将value值放到最终的位置




    }

: U6 E  N& F7 i2 h
}
9 I& _/ `" P1 X! I3 `. W! I1
2 W8 P! s; n6 Q% Y6 v" @; e; d2
3
4 Z: c5 `6 @! @6 j& j0 S6 i# \4
5
: u3 R' }, l9 ^! v$ ?  p% Q6
/ D. c; {& M  f1 e9 y4 Y! {; J* _* w- R: Z7
: Y9 K7 D+ m5 z( h8 G, B6 c( X8
% w: f& f. Y5 ~) \1 G' e8 i# O: G( R9
5 U6 U) J# S. K% C' a10
. \  A/ H) H6 D0 O( n! b) I  E11
12
13
14
0 j) D$ `8 d, \& H( A15
16
17
& Y& M) L% ]' k18
19
' o+ ?( o4 p% w. V% R20
21
% r1 H% N- _# q, f0 N9 _% ]: y22
23
24
; v# `1 w3 j/ T; l, F" C. b/ F25
+ V5 c" u# w' }26
27
28
29
. ]; V9 g" |# n$ q, |3 [0 z30
31
: o! z5 j" D$ ?+ x32
$ `  M9 m$ x  u- H, z( j0 n9 J33
34
35
6 b, d  J7 @3 G3 b6 X7 S  o36
37
38
39
9 F& ^# U. E, k40
41
42
" b! e# ~, g# ?" P& D43
44
45
6 o% j- X1 y2 S+ F46
; k( |3 u2 n0 s- l47
/ i* g+ }% m$ ?! q1 ?) F& E48
49
, f7 n9 W. O, b% {$ Y/ t# A! o7 {50
' ~# ^4 I: r" b51
52
! b8 m' Q' L1 n; B% c53
54
7 J0 v4 H7 k4 N6 T! F55
56
57
$ e, @( v0 B. {; @58
9 h' o8 \5 ]( n/ \( K59
60
61
$ F3 z  m7 \, q# {. e8 Y62
63
64
% x" z, k) S) e  g) x) H) j65
66
$ \; o2 x7 V) ?; c67
9 P* P8 a- X$ ]* b4 }) s68
69
" o! Q* z  w" U70
71
72
$ k( A- y. b) I3 J73
# i& E3 Y5 T* O" z74
归并排序
简单解释：
该算法是采用分治法，把数组不断分割，直至成为单个元素，然后比较再合并（合并的过程就是两部分分别从头开始比较，取出最小或最大元素的放到新的区域内，继续取两部分中最大或最小的元素，直到这两部分合并完，最后所有的都合并完，最后形成完整的有序序列）


) [3 z+ P0 r' ]! T, f0 K

& M) l3 B2 I$ ^# M( s9 J, ?* M
$ h4 v& [# W- T5 e
% o% h( P8 M8 ~5 x( B2 d( k完整代码：
  E" Y( f" C# M' I

% S) U0 a% \5 m" K! dpackage com.keafmd.Sequence;
1 I3 m1 Y0 O! Y. _) B; z8 ]6 @6 c
& e% K/ a0 e/ E. m1 o4 i" a: k
( y- x3 E) L6 |; ?2 h2 A/**
9 y- q) f; `/ S& [  A. @ * Keafmd
*
* @ClassName: MergeSort
1 O7 c; G0 u/ H8 N * @Description: 归并排序
* @author: 牛哄哄的柯南
* @date: 2021-06-24 10:35
*/
public class MergeSort {

3 Y3 |. Y$ z4 Q8 n# L, M' @- m- k
    //归并排序
    public static void mergeSort(int []arr ,boolean ascending){
/ F( ]9 y  J" w% U        int[] temp = new int[arr.length]; //在排序前，先建好一个长度等于原数组长度的临时数组，避免递归中频繁开辟空间
* L& _2 q& x4 W: Q  [' Y* d% r        mergeSort(arr,0,arr.length-1,temp,ascending);
    }
    public static void mergeSort(int []arr){
" t9 F/ g5 j6 q        mergeSort(arr,true);
: R# z5 T5 ~* _$ D$ s    }


- N! m. e8 l: f, w9 R* Y: O9 W    /**
8 [! j. F" i. c5 i3 S     *
     * @param arr 传入的数组
9 E- \, {. e3 Q# v' t     * @param left 当前子数组的起始下标
( P7 T( ^! z& h     * @param right 当前子数组的结束下标
     * @param temp 拷贝暂存数组
     */
' ?5 N6 \8 _( f  G( w7 R" c    public static void mergeSort(int []arr,int left,int right,int[] temp,boolean ascending){
        if(left<right){ //这里是递归结束的条件，我们是对半分，那当left==right的时候肯定大家都是只有一个元素了。
! \# W! a6 e. U( A2 E' Z! D4 r1 W
0 s9 k6 D0 l, U7 ?9 e8 ]/ z
            //对半分，比如总长度是10，left=0，right=9，mid=4确实是中间分了，0~4，5~9
" B0 \9 e! j1 G% H            //当长度9，left=0，right=8，mid=4，0~4，5~8
            int mid = left + (right-left)/2; // 防止越界的写法
! M1 O/ b' }. `            //int mid = (left+right)/2;


% m5 f5 D: O" i+ u; [            mergeSort(arr,left,mid,temp,ascending); //左边归并排序，使得左子序列有序
            mergeSort(arr,mid+1,right,temp,ascending); //右边归并排序，使得右子序列有序
! T* H" q" r! d; ^) Y

            merge(arr,left,mid,right,temp,ascending); //将两个有序子数组合并操作
* X; J; T* ]; d, @        }
: A$ _1 `9 P5 e) j9 {    }
5 ^+ B/ ^3 l! x, E6 w. ]- P0 S3 k

    private static void merge(int[] arr,int left,int mid,int right,int[] temp,boolean ascending){
        int i = left; //左序列起始下标
        int j = mid+1; //右序列起始下标
        int t = 0; //临时数组指针
0 k4 E5 ?7 S8 l, g' Q) l        while(i<=mid&&j<=right){
            if(ascending?arr<arr[j]:arr>arr[j]){ //比较两个序列第一个元素谁小，谁小先拷贝谁到temp，然后对应子序列下标加1
/ c8 I8 N7 G$ k; N/ X4 B* x$ C                temp[t++] = arr[i++];
            }else {
0 {6 W- O2 G7 f0 i3 R* L* O                temp[t++] = arr[j++];
            }
7 k5 W9 h: d2 T0 I3 T: z        }
2 C/ }# u2 X! J$ ?: ?

        while(i<=mid){ //将左边剩余元素填充进temp中——左序列有一些数总是比右边的大的数
            temp[t++] = arr[i++];
        }

( T/ r! ], ]" Y% [3 B
0 P3 S! \/ T/ H' ^        while(j<=right){ //将右序列剩余元素填充进temp中——右序列有一些数总是比左边的大的数
6 \2 m6 o  Q: T! ^& w            temp[t++] = arr[j++];
9 z7 p6 G6 ]7 s4 F; C' o$ f        }


        t = 0;
- B+ u7 D6 \2 ~* O/ o/ ~& S# u( D( P

2 a* \6 h! S. K1 d' X        //将temp中的元素全部拷贝到原数组中
        while(left<=right){
            arr[left++] = temp[t++];
        }

  p- z4 w4 x  H; z4 n0 m) r$ S
    }


  U; C4 K3 x8 w) C+ z: |9 Y}
8 ]" Y, w4 }# |9 f' t. z1
2
: h$ v! G$ W/ N- P3 e3
4
5
3 u) ]) a& y! v! ]6
7
1 c- v8 |2 M! s' G4 x% [! f8
& |+ \2 f' p  r* F9 F9
10
11
12
$ c- P- h% S; }, h13
14
15
16
17
18
; [6 l( t3 P1 Q: ~$ ^. V$ r19
20
21
22
23
24
25
26
8 l/ L. M% E: y; \( b) h27
28
- v1 ]$ S- a9 G# D* j' r- e0 v29
30
$ E& e5 k& k8 E4 @4 G7 m( [3 h# K8 {31
& S! p( k6 _  l; x# \7 W32
$ p" T  w3 W' f9 {. \33
34
/ a9 A: ~7 o( m+ h5 R2 I4 F35
! _3 c. h; G: U3 ?36
8 |+ A# w8 i5 i# V37
0 t( n% I/ e: Q. g" Y1 k9 t38
39
3 K$ F  s& y- Z  [6 h40
41
" H7 m8 G' k4 V# L3 [! x42
43
3 n$ n6 c$ ~3 S0 `0 `44
" K7 R8 t  ^: X( F# A. w! v45
46
7 |, F2 o! b1 i5 j47
! s8 C9 b. F4 E; u+ O+ R% J48
6 u7 T6 \% j  y6 L7 C$ s. D49
50
51
* {$ N4 t" ^# `, x0 S; S4 h: D9 n52
) S# [7 e) `& X53
( {1 A: o9 ^: Q. u5 j  U% g54
55
56
! s; A2 ?2 [! w/ R7 K! h9 F- A57
58
59
60
61
* a( U3 v6 O9 ~, h. L62
/ }- ?; V' R/ d/ \" y9 k4 f63
64
65
66
, M- u" F) y( j- N* G( [" q67
68
3 \. p( p  |( x7 y- K/ ]4 i3 s69
70
71
- J; o! Y3 _3 U! }$ i/ s0 n& l; S4 `: C4 X72
* F$ B  F  \2 U$ e73
插入排序
简单解释：
最简单的理解就是打地主时我们拿到牌后的整理过程，从第二个牌（假设我们拿起来这个牌开始比较）开始，（说下升序）从后往前比较如果比前面的那个牌小，就把牌往后移动，直到找到一个合适的位置（这个位置的前面的那个牌不比这个要放下的牌大）就把这个牌放到这个位置，慢慢的前面的部分变得有序，直至全部有序即可。
; a' r8 ~$ L) s! o' B
* W& C( K2 [( ~/ X! u% F4 h
% r7 y0 b4 f' f; r


# j% ]+ w! h- k4 i7 z( g
2 E1 k- S6 x$ s7 u完整代码：


+ a5 B8 R3 k  X) z0 d$ O* hpackage com.keafmd.Sequence;
$ `' `& r7 o1 H& a

/**
* Keafmd
0 F# z0 I% I2 H, t8 I6 f5 v+ f *
* A( d- @* p. \' t * @ClassName: StraghtInsertSort
4 u2 Z; ]# d3 j" y5 U * @Description: 插入排序
9 ~* @( }; k  @4 j * @author: 牛哄哄的柯南
- i+ O, r/ _3 [6 T * @date: 2021-06-24 10:36
*/
. q2 n/ ?1 U1 h  w% \5 m( ?public class StraghtInsertSort {
    //插入排序
3 e; S; s0 w; x( {7 w+ y    public static void straghtInsertSort(int[] arr) {
& n) o9 D& k5 W5 M        straghtInsertSort(arr, true);//默认进行升序
! ^1 C6 }" I, Q    }


    public static void straghtInsertSort(int[] arr, boolean ascending) {


        for (int i = 1; i < arr.length; i++) {
5 q8 K( k7 X3 v1 ^            int temp = arr;
% V9 M3 V  D$ I' r/ w1 ^& W4 S7 G            int j=0; //这就是那个合适的位置
$ a1 w3 I& o* b( ]3 L  u( k- v7 \            for (j = i - 1; j >= 0 && (ascending ? temp < arr[j] : temp > arr[j]); j--) {
                arr[j + 1] = arr[j];
! y% [( B3 B* `% J% [% Q            }
3 V7 D* T5 x. b% ?            //把牌放下，为啥是j+1，
            //是因为上面的循环遍历到不符合情况的时候 j是合适的位置的前面的那个数的位置
5 P  @/ d5 u6 d5 u' w            //有点拗口，但是就是这个意思，看图方便理解下
            arr[j + 1] = temp;
' e: C6 j& ~5 u7 j
8 V" l* X+ L' z/ p" M4 o+ I* m% b
  R7 F( j2 {3 J4 R! w9 p& T6 d

2 s7 b; P. I9 H' j        }
# q" a3 q: L" b7 d5 l

2 |8 B3 h3 d9 L5 Z    }
- Y" x9 y) p9 |, E2 B' s8 j}
( ^9 k9 d3 r8 |, u$ y4 Q1
% Q0 V. q+ a. E# z9 \( a+ U2
3
4
5
6
0 H2 ]2 k7 \6 h! b* b7
3 B7 A$ m# T0 H2 p8 }7 Q8
9
" N8 f% l% A/ T10
11
12
13
0 y; ~7 j3 `7 Z' r14
7 F! {% y7 f2 f+ l8 _15
16
17
18
19
2 ~: x! j& u9 r& c' I' |20
21
$ e6 e' ]* M/ K. d  u: B  k1 I, D22
7 i% o( n0 j1 E4 Z, f23
24
; |9 M# x2 n+ a25
26
27
28
4 a. d3 h0 h/ V7 l: E4 f29
% _5 r% m' t% c/ s' _4 m3 S30
: g5 y2 v$ g, a$ Z3 y1 g  o2 T31
32
- ?3 e% N. y$ l% z1 c( a( `3 t9 e! B33
34
希尔排序
( C1 Y5 U7 G; s3 m# v' Y简单解释：
希尔排序是插入排序的改进版，我们理解一个叫做下标差的的东西，也就是下面那个图中的增量d，初始下标差为arr.length/2，然后继续/2，对在同一下标差（相当于把这几个数单独拿出来了）的若干个数进行插入排序即可。
5 v( p- {# N+ Z" ~
+ {1 W* c) u' V1 H* c
1 n; u5 f! v5 T% B6 W; V* H
  G: a1 c7 G5 d, l( ^

# T& f0 _  O4 Z5 ^+ y
完整代码：
3 F' L) q! E3 V$ h) H

" U1 _$ t4 X& |8 y0 tpackage com.keafmd.Sequence;


/**
! @- W* Y9 ]7 O& C! X * Keafmd
& }0 y- _8 R% N) Q *
* S) w4 ]3 O, f! h * @ClassName: ShellSort
/ b! ]3 y* v3 E% p' S) a * @Description: 希尔排序
$ J$ |, j. `4 w6 D9 K5 D) Z * @author: 牛哄哄的柯南
* @date: 2021-06-24 10:39
  G7 A/ x* n0 [ */
) k5 r7 I" E: z/ I+ h# jpublic class ShellSort {


    public static void shellSort(int[] arr) {
        shellSort(arr,true);
2 Q9 x1 c# `) O) j1 A/ S6 h    }
& J' T8 E2 w  D
3 V# d- L6 {% m7 r$ _
    public static void shellSort(int[] arr,boolean ascending) {


        for(int d = arr.length/2;d>0;d/=2){
6 |$ x  E4 L/ \- D* P3 V9 @

            for(int i=d;i< arr.length;i++){
  j2 e! Z7 W; R                int temp = arr;
( H) x  W: M8 ]6 ]1 G. p8 i& M                int j=0;
+ U; r& v8 U0 O' v4 q                for(j=i-d;j>=0&&(ascending?temp<arr[j]:temp>arr[j]);j-=d){
                    arr[j+d]=arr[j];
) E2 s8 v8 \  L) J                }
                arr[j+d] = temp;
            }
( h' e+ ?2 g/ m        }
( i. o5 m+ y0 {# g$ C5 q

    }
}
9 ^; d+ K. ]2 w) l7 f2 M1
2
5 n1 t- X' p- z; w* b1 L' K7 o3
0 l% @" J7 @! C' S7 K; d5 {, e4
5
6
3 j* W  O! m, w/ B4 r) N/ K! k7
, H, t" V) c' b, O8
9
10
1 X1 \3 R4 T, }/ S' w11
12
! y; k, Q/ a7 P& B13
14
15
16
" G+ u% O( [4 R7 T1 K0 [# d9 i17
: y+ k3 F& \2 L& Q" {( H8 F0 K18
19
# }, ?4 u/ V. Y20
& r: W; }- _$ L/ z21
) Q3 o; i3 T7 v7 S22
& Z6 y# u# H" d3 V4 h1 S' B23
24
$ s$ p  o0 v9 k& G* g2 d25
! b, @/ R: m* N1 B/ z* Q26
27
28
+ k. P- [1 K1 [3 w5 X) L29
30
31
32
计数排序
简单解释：
" s: ?! U  G0 \) E9 H# u这个排序算法看名字也很好理解，就是就是额外找个数组来计数，然后在这个数组从小到大或从大到小把数取出来即可。

( L+ \# X  B- ^4 g$ s7 W

4 d* j! R7 P& b% ~2 `; h
. a, J# f+ u* V) n) P4 o9 _
8 T3 F+ i0 d  I+ ~$ }2 B: X# m- t
& B9 {' W5 y* ~# @* x& o( e完整代码：

8 u3 h$ ]- T  `- c: L% r
/ e1 |$ R) z$ }6 Z# M  p/ ipackage com.keafmd.Sequence;


/**
* Keafmd
  z: z+ F0 Z! X+ K; a1 m' \& i *
* @ClassName: CountSort
* @Description: 计数排序
0 h% C+ ~8 V% Z& k4 C' v% P7 A! f * @author: 牛哄哄的柯南
* @date: 2021-06-24 11:31
3 j. |7 }1 O/ O */
public class CountSort {


1 C  |& G; N1 U6 g8 Y    public static void countSort(int[]arr){
        countSort(arr,true);
3 \; J$ {9 [. I" }& H2 b( F! x    }


4 W* H4 ]) V6 Y: P2 N    public static void countSort(int[]arr,boolean ascending){
, O0 L. [/ a+ W& Y7 I: W' a        int d,min=arr[0],max=arr[0];
; Z$ D$ B0 u/ X+ ?, d6 U
4 s. u9 o# F- U( S5 D" ?) h
        //找出最大、最小值
# P7 O; K7 L* E        for(int i=0;i< arr.length;i++){
  [" j; S2 d0 n7 @  J            if(arr<min){
/ J! L$ d) L$ F                min =arr;
- b0 X+ M6 o& |( x$ A+ ~            }
5 V$ x+ H+ F% f; ~7 ]& B4 Z) V2 y4 {4 E            if(arr>max){
6 T0 z+ B1 t# R& K                max = arr;
            }
' K1 A! h- k9 y7 ]# m* S$ R        }
6 g0 [4 I- F& O% u$ L% w. ^

9 n8 e' v1 K+ u7 c. ]0 s- r        //建立一个用于计数的数组
        d = min;
        int[] count_map = new int[max-min+1];
        for(int i=0;i< arr.length;i++){
            count_map[arr-d]++;
0 i- R; g7 H+ }9 |7 ~% Q, S: D  {8 R        }
4 u5 |" J) g' X1 u# N) z$ v

. u3 j. ^1 M: e' C, [9 W5 t        int k =0;
        if(ascending){
- c4 k  h9 Y- f9 n) q% V            for(int i=0;i< arr.length;){
- M- r3 p, D% l" K6 P                if(count_map[k]>0){
                    arr = k+d;
+ q, p* q; d: x" q, q7 w. i5 [8 y                    i++;
                    count_map[k]--;
                }else
                    k++;
  R: ?7 s) x$ B) ?            }
        }else {
            for(int i=arr.length-1;i>=0;){
                if(count_map[k]>0){
; \+ J$ J+ I' o, b5 e                    arr = k+d;
0 [0 a& F- ]" B  U  K' Z8 ^9 d" T; D; A$ `                    i--;
3 Q' q$ V2 N: y+ p1 h$ Y. o6 Y                    count_map[k]--;
                }else
# O. n" J+ }: r( j% G( r                    k++;
7 K) K+ m  g: O9 [            }
        }

  t- a6 L2 i6 r
; Y: h' v: H. q) @6 j3 r3 E/ J) u) v    }
! y- _3 h( x0 C" z) T}
& a. z) o# D- e( K  `0 P! ]3 Y1
4 @( i4 }6 D0 C& u2
3 T- H- j) s7 g# R5 y# y3
4
/ f% H9 ^, y6 k$ {" [7 Y( u5
6
) o* ]  s6 s( l. z7
8
1 C0 g  X& O/ L) w/ L0 h9
& h" ]: }  D8 V6 T2 W0 n7 E10
11
$ u& d; R( _) @7 }: z+ H12
. Y) k0 h: W9 z& {13
# R: I6 a& I2 W' |; t, L  b: n14
+ P% Y/ M& E/ q) R4 x: x5 d15
16
) q2 D2 ?8 W! r" I9 R17
18
8 l: L8 b9 A$ [/ u1 X19
- l! ~4 \5 d! P5 W$ u( N/ J20
21
22
23
  p% s: r: `: R24
; }( M% M8 k4 A9 g/ `4 |$ a25
26
27
( z% X: ?" o0 c1 [5 ?28
29
30
31
9 l" r9 r! |. l/ g+ ?8 Z32
33
5 H- @" ~, J* H4 j. D* s' l$ z34
2 H. ~& `5 r# V: j1 W1 D. v  V35
36
3 u; O0 Q  b) ~/ e8 m1 u7 P37
2 V4 d% H/ P1 b, r+ m38
39
- O6 ?8 H$ I5 e- z+ ~4 R40
$ e. J# W& {" ]5 l5 ^% u41
8 R) L, r. u% {2 P% d42
3 O/ |3 J3 i' K2 J" y43
/ F3 T& b( k7 ^4 }44
45
46
8 O0 W  _1 x; C2 L, l  i+ {/ K47
/ f: v/ n# Y& o) |0 c' g0 ^$ ]5 E, F48
+ s- T8 J( B9 y; w" V/ D3 }+ l3 ?49
% T2 B  J8 `1 g9 B50
1 |3 _! {: e! n: `51
2 n3 w+ A1 j- s$ Y% s52
53
+ m) M. f4 y; O( G, ?3 C' h5 ^54
55
56
/ u+ t+ {9 E, n57
* S4 K, ?7 q) t& n& `58
59
9 ^2 n2 F$ B9 b* z9 ?* X, G+ M* D桶排序
3 J  J5 \7 @2 M: {简单解释：
就是把一个数组分成几个桶（其实是几个区间，从小到大或从大到小的几个区间）装，然后让每个桶（区间）有序，然后取出来放一起就可以了，相当于把几个有序的段拿出来放一起，自然还是有序的，当然需要是按照区间的顺序拿了。
- v7 F$ D( }4 g% x0 u0 F; {  E



% w3 g9 A# j1 v, n

. i: K; M% r0 H# C& I' s4 U' ^5 `完整代码：
+ w9 E% C' B% j; Q$ A

package com.keafmd.Sequence;
! N- r* S- Q+ A# j5 M) F
9 ?0 z1 \$ k  }" O- E% b7 k) ^
9 O1 X+ D! Y2 E& Y  C4 x) Ximport java.util.ArrayList;
) l# Y3 l9 }  `1 X% S9 }) j! V' Kimport java.util.Collections;
  y% M) l5 M+ u( E4 \: R. U) }
7 s2 q4 J- `: C" u
/**
* Keafmd
1 S2 L7 t- ]  G1 R! ?% i *
* @ClassName: BucketSort
* @Description: 桶排序
7 H8 s. M8 r4 Z$ z * @author: 牛哄哄的柯南
, H, B1 w- n! H( N& I; A) q * @date: 2021-06-24 13:32
* B/ w; `7 z$ E. O& ]9 Z. k! T */
1 t* |: z5 x0 P8 a9 a5 w' j+ Apublic class BucketSort {
5 N* H9 J0 v- |! [- v3 S$ m0 z3 |- V
, k/ z+ {9 c1 V9 w2 v" S; e( x
# W+ u7 `+ R: A  R) O1 D    public static void bucketSort(int[] arr){
        bucketSort(arr,true);
4 W" R0 _1 j0 f, X9 {    }
( i: h; O, \: B' j5 H3 i& h% G7 ]( S
' {2 i# p+ p3 T- M9 Q2 d. h
    public static void bucketSort(int[] arr,boolean ascending){
        if(arr==null||arr.length==0){
            return;
' C6 Z" T4 y# T  [( X3 \        }
        //计算最大值与最小值
        int max = Integer.MIN_VALUE;
        int min = Integer.MAX_VALUE;
; ~# m& r' j; t7 {) H5 `* W/ h        for(int i=0;i<arr.length;i++){
, ]( [$ }1 u1 z8 M            max = Math.max(arr,max);
7 E! ]0 T- o4 }* }1 j2 _2 \) F* z% {            min = Math.min(arr,min);
  D3 m  L9 x0 I8 @& k& w        }


2 g1 d5 v, r6 k6 @        //计算桶的数量
6 O1 w  ~+ M: Z# Q* g) Y        int bucketNUm = (max-min)/ arr.length+1;
$ ]) j; b. b! U* M- d        ArrayList<ArrayList<Integer>> bucketArr = new ArrayList<>(bucketNUm);
        for(int i=0;i<bucketNUm;i++){
9 q" S" s! R( \5 F0 m. l' v6 f            bucketArr.add(new ArrayList<>());
        }


        //将每个元素放入桶中
+ V2 p- ^4 v6 f8 w        for(int i=0;i<arr.length;i++){
& k" ?4 B3 X/ ]. `3 j2 ]3 p0 e4 P            int num = (arr-min)/ (arr.length);
$ d$ W+ l( p7 _# ^            bucketArr.get(num).add(arr);
0 {& c) Y, s) q3 e2 N        }

1 Z, W/ E! s, v) }4 ]) p& a
5 l- N4 Q3 \+ G4 P        //对每个桶进行排序
3 v# l% W, P/ A' V. O  k        for (int i = 0; i < bucketArr.size(); i++) {
7 ]5 I+ ]2 s' |8 _; z& \            //用系统的排序，速度肯定没话说
# ~& l4 q3 E1 j0 Z9 O& M' }( W7 a            Collections.sort(bucketArr.get(i));
        }

, x! _2 I6 g/ @8 r: y
5 }4 W) d) K5 I/ l        //将桶中元素赋值到原序列
        int index;
        if(ascending){
. F: L* v3 `8 R1 X! ^5 l( S7 i            index=0;
        }else{
            index=arr.length-1;
        }

+ T& d& D' V! x& F& E- p' q
        for(int i=0;i<bucketArr.size();i++){
            for(int j= 0;j<bucketArr.get(i).size();j++){
/ q/ J* V! f+ c                arr[index] = bucketArr.get(i).get(j);
                if(ascending){
                    index++;
                }else{
                    index--;
8 R& ?& {; k# ~. x4 Q                }
            }


        }


; z; t( q/ d& q" y! Z    }
}
1
2
3 H" u) \( S; h2 p+ i7 l3
4
5
% P4 n+ W, e  ]' ?' H5 ^# {% O6
. {) d- \  |+ L) g, Y0 x7
8
9
10
11
12
# v; H: E1 [4 D; Z# T8 g13
14
+ d. J! r7 H0 Q6 |, ~15
16
9 Z* K" H4 j6 b& M& `( i17
18
, a9 x2 z6 r  W* a; x; ^* ]19
3 a) F3 u% s+ K% L" p& R20
21
# i* ]; e; K" g; M$ x' D22
23
/ G8 c/ B) Z4 Q3 ^# W% U! V- F24
25
- I  |( ~& H& K9 |# g4 N1 X26
% V# _$ d# W& f' C27
28
2 h7 ~; O( S1 q1 K29
4 N: y. w7 X" I" i4 ^( q30
& ^8 J) K3 L2 o* ]9 G31
0 L) B8 Y% q: Y32
" g+ p: q9 C- f1 Z$ @33
34
7 T. [  y9 Y4 p0 y, o' G9 b! h35
36
37
38
39
2 d: I4 F2 c5 `2 \" a* P: ^$ n  \40
  N/ ?2 e" C1 E7 o9 y+ E# a41
; g, z% o7 M) V6 r  r0 M42
43
* P  n6 ~( v3 a  G44
45
- P: F( o3 I1 b1 l# I; x5 F+ G46
  ^) ~8 J! J; y. Q47
! \$ f5 i8 S, O" h$ q48
& _6 O: \; b! G8 n4 X- v49
50
51
52
* B. H: R( o: M! T53
) v7 Z2 N# M1 |  U% y0 ^54
# O; k. v# l5 g5 B55
56
57
58
8 A* T5 _, s# b. V59
60
4 R+ [' ?" B: \+ R6 e- X0 l1 ]8 ~61
62
63
64
: q6 s2 m# D6 K# M; l' D0 f65
66
67
68
69
1 F5 V# K- I! v7 x% m70
# Y3 ]6 ?0 L! N! Q' Z7 V$ o: j71
72
基数排序
% a9 ?/ F# @; f9 ^简单解释：
6 |" W% d  H) O) D& e" m! C# g首先说一下，我发现好多人写的基数排序只能排序正整数，其实只要处理下就可以排序含有负数的了，就是我们排序前先把所有的数整体变大（就是减上最小的负数，也就是加了），都变成正数，然后排序好之后，在减下来（加上最小的负数，也就减了）就好了。
6 z; a# x3 K7 r/ c1 k- Z; P基数排序就是按数位排序可分为LSD（从最低位[也就是个位]开始排序）和MSD（从最高位开始排序），下面写的事LSD基数排序。
& C2 R, s0 `5 J* r  I$ u1 e基数排序就是把数按位考虑，让后我们一位数只能是[0，9]，就是我们在考虑某位（个位、百位· · ·）的时候就只看这个位的数，放到在[0，9]相应的位置，然后顺序取出，最后再按其它位这样操作（上面说了要不从低位开始到高位，要不就是从高位到低位）

/ ]- V! ^8 v* f, r


8 m  e' w, X/ g6 E3 v) A, `8 A
% c3 v0 g7 v8 C1 `; m9 X
完整代码：
0 U; y! I' P! E( f
1 s  R9 X2 I/ l% g# B: @
package com.keafmd.Sequence;


. s8 I0 A' h1 q$ [, |/**
& g/ g; q& P; S1 C/ }5 ]' M( ? * Keafmd
*
' \* i8 z- k2 l6 U9 ^9 D0 J8 `! ] * @ClassName: RadixSort
* @Description: 基数排序
* @author: 牛哄哄的柯南
* @date: 2021-06-24 14:32
+ p! d& y2 X  R# @2 [- r+ g. d- } */
% L* y. q' P! x' `( ]; vpublic class RadixSort {
    public static void radixSort(int[] arr){
        radixSort(arr,true);
    }
" d5 ~; Y" H! B, B) l  i  H    public static void radixSort(int[]arr,boolean ascending){
        int max = Integer.MIN_VALUE;
; H7 {7 b8 Q# T; j3 c& d. F) b        int min = Integer.MAX_VALUE;
        //求出最大值、最小值
6 n- u3 {6 X: c7 x& o' H. }2 @$ f        for (int i = 0; i < arr.length; i++) {
, s- l3 k- t8 e4 m" W- _1 p            max = Math.max(max, arr);
/ u( R/ }& J$ M, w+ F7 o8 v            min = Math.min(min, arr);
        }
        if (min<0) {        //如果最小值小于0，那么把每个数都减去最小值，这样可以保证最小的数是0
            for (int i = 0; i < arr.length; i++) {
, @& F) S$ w' X% y% {                arr -= min;
7 |' X4 g- ~4 {( F1 ]8 X1 o9 O5 K            }
( |* Y& O& V0 `, I. f            max -= min; //max也要处理！
        }
        //很巧妙求出最大的数有多少位
5 k( B6 R' C) o8 W        int maxLength = (max+"").length();
3 [9 t, X) k6 M" C        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++) {
                int value = arr[j]/n % 10;
# ?4 q( P0 b& M; J; P2 x9 j                bucket[value][bucketElementCount[value]] = arr[j];
- _' Q1 ?' S3 v                bucketElementCount[value]++;
            }


            //升序
/ Y) a9 M" W; W& k( Z1 n  N            if(ascending) {
                int index = 0;
2 z3 O3 ~. J6 K5 r1 d                //从左到右，从下到上取出每个数
                for (int j = 0; j < bucketElementCount.length; j++) {
+ [/ E5 r: D% k& }" }1 S                    if (bucketElementCount[j] != 0) {
                        for (int k = 0; k < bucketElementCount[j]; k++) {
% P4 P- U7 b  v/ C# ]5 ?( p                            arr[index] = bucket[j][k];
: g5 X- `, s" N# J! v$ G! s/ s0 y                            index++;
8 x. M/ K3 E  P. ]5 \                        }
                    }
                    bucketElementCount[j] = 0;
                }
; l7 y3 u" l4 ^0 G" o+ r8 s0 _            }else { // 降序
                int index=0;
1 q) M) ~( a9 f; {0 h) {& ^$ N                //从右到左，从下到上取出每个数
                for (int j = bucketElementCount.length-1; j >=0; j--) {
                    if (bucketElementCount[j] != 0) {
6 R+ o, r* x9 h# n1 l2 f                        for (int k = 0; k <bucketElementCount[j]; k++) {
                            arr[index] = bucket[j][k];
                            index++;
4 t% s6 F& Y, t8 o8 J- j1 Y                        }
                    }
7 [- ~3 s4 \" g                    bucketElementCount[j] = 0;
. {' E: m# B8 \8 r                }
+ z$ w, [& k: k$ A# U7 [! z& c& e            }

& Z5 L& u. N; I( I4 m" ?0 O


            /*for (int i1 = 0; i1 < arr.length; i1++) {
( _1 c& t5 ^8 f$ N7 [' c                System.out.print(arr[i1]+" ");
            }
            System.out.println();*/


; |* G+ `7 L6 F, M( C1 ^



( {8 o  R: {4 e$ H% g7 }        }
        if (min<0){
            for (int i = 0; i < arr.length ; i++) {
                arr += min;
            }
        }


  K. l+ p& z( E' a4 A    }
}
+ L& l2 B3 p. g" m% O0 Z2 U9 {( J1
7 x" H* x, e) p$ F, W7 c" i2
5 \2 j6 V( s& d( Y$ [3
6 ~; b, }) r7 v7 L4
5
: Y. J* y4 \! g3 @: Y6 T6
* Z: Q/ L8 p4 T) r# I5 b5 |7
8
0 z& D' R, I" l+ U, \; _9
10
7 K' {' U( A0 B: m11
6 w$ Q* U; `+ Y+ o12
13
( `- y4 e% N' W% J# ?# Z14
' L* i9 E2 J0 v7 T6 ?15
16
5 _2 e, l# Z7 Z' ]# O1 i/ j17
18
19
20
21
22
23
- _/ M, k# n+ Q1 B  f" N2 k* `24
4 I$ X- ]2 b: t# s9 I& i3 s25
+ \' ]) _: r7 A4 `: f2 a26
4 k1 d, x  D! d* m27
$ y+ R+ ^: g) s4 ~2 h28
& I& Z, e6 v- j( P29
30
31
32
33
1 D5 O; W# E8 j- H& `' r# H, D8 G34
- l' t& Z5 o2 o& i35
36
37
38
39
& i. X9 \; t) B  q* e7 L40
7 X7 _1 k/ l  m41
42
8 w  n3 U5 e7 c  `1 {8 a43
44
! X1 {! ]6 ^) i+ l' g( T45
+ O( J$ k6 A9 r/ V! y5 ?46
# z9 _! H" y- ^! [' q1 d. o47
48
49
50
51
( @/ _* `- L4 A$ Y- u) K8 n52
! K0 ~7 R, P7 C# Y; k  ^53
54
55
56
/ F/ L; o5 Y' y6 S/ x( g$ Z( q7 E57
7 e0 r% ?5 b, u9 ^58
. _9 D" C7 }( i; M$ h9 H; Z59
, {* V, G1 {5 L$ m! s7 j60
$ e+ p, ?1 k9 ]4 V; x4 M5 F61
62
* g, {2 D! F$ w% x63
64
65
66
67
% R  o9 D9 j( R1 L68
6 S) v, v) H+ Z; L" ?; j9 h; z69
6 m% e: b( G) f70
71
72
) L  x+ ?% `4 ?* E- I* l  X4 z' X73
; u) z& c, i( A1 [: c% [74
' M$ c+ M, y' c! C% T- [75
76
& F/ F- \- i5 d$ O. n. n# M77
78
79
- |. }. \3 c  d80
, g) G! F7 I2 H, B( A4 Y+ n9 W- M81
82
83
  l. X) I! z& L1 Q* K8 A- k2 T完整测试类
package com.keafmd.Sequence;
* i6 P8 w/ A- F. d3 m' T

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


/**
1 Y) j6 K: ]. [. j! q * Keafmd
) w7 K$ L' m6 `. S *
* @ClassName: Sort
* @Description: 十大排序算法测试类
* @author: 牛哄哄的柯南
, H$ G( H. y" m) p. Q  d& b- f * @date: 2021-06-16 21:27
  M# |4 `3 `8 w* T2 \; Q  e- O# a$ p */
' a8 n. ^- M; T) c+ G" I8 p( rpublic class Sort {
" [6 ?/ _6 T4 `8 a+ g
0 v4 ]" [, j! `
4 [, ?, i, ]4 C, ~* R# s3 |: }

    public static void main(String[] args) {
! e' E6 X; k7 V7 R/ ]: J( G% S: j/ X

  n& e) w5 L7 k1 H6 T        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};
0 O4 @' ^0 {) z+ R2 y        int[] temparr;
# [! `2 w2 @" X

        //利用系统Collections.sort方法进行对比

& o# f  B( `+ p6 s
/ u7 J1 \0 i* K2 X* a        //将int数组转换为Integer数组
        //1、先将int数组转换为数值流
        temparr = nums.clone();
# ~) U0 p5 w7 T0 [) W. t1 P        IntStream stream = Arrays.stream(temparr);
& s* A$ D: w& H4 x        //2、流中的元素全部装箱，转换为流 ---->int转为Integer
        Stream<Integer> integerStream = stream.boxed();
        //3、将流转换为数组
        Integer[] integers = integerStream.toArray(Integer[]::new);
        //把数组转为List
2 [6 l" X/ N" [4 \0 \% j& _* h        List<Integer> tempList = new ArrayList<>(Arrays.asList(integers));
        //使用Collections.sort()排序
        System.out.println("使用系统的Collections.sort()的对比:");
1 }( J* \( h' L  V: n

        //Collections.sort
7 Z9 Y- p7 Y, z' O9 I        Collections.sort(tempList, new Comparator<Integer>() {
: W/ t: N' ~" V' O7 W5 u* X" V            @Override
            public int compare(Integer o1, Integer o2) {
8 n2 s! V( ^3 Y! W1 W+ c                return o1-o2;
3 Y: M6 e$ r' l+ q% x$ z                //return o2-o1;
/ G5 u# L% _4 A/ U/ ?# y. g: k/ _            }
        });
* E; n  a0 h% C7 j6 U  o  Q" {: N
$ P( B$ ?5 S# s3 W# a
$ @: |" P5 C: Q' }& H$ M0 w        //tempList.sort 也可以排序
       /* tempList.sort(new Comparator<Integer>() {
            @Override
            public int compare(Integer o1, Integer o2) {
                //return o1-o2;
1 C; _1 D3 K' E  s# |                return o2-o1;
            }
" o! }+ m8 D0 w        });*/

! s* n$ K5 ?9 m# G5 o
( q9 P& V* s; ~! i. T        //遍历输出结果
        for (Integer integer : tempList) {
            System.out.print(integer+" ");
        }
$ ?9 S# d# V3 V- R, p' H( }
5 \; \1 A; Q1 x( \8 [  t* Z
        System.out.println();
" |& d0 X: k/ E6 ~  j+ |3 w
7 P' p; u. R1 k2 P. q; `
        //测试冒泡排序
; G8 R5 q6 b- B$ ~        System.out.println("测试冒泡排序:");
! u5 y  v2 y5 m- X        temparr = nums.clone();
. n7 ^, h/ D1 d+ S$ s

' ^# x0 e& p$ S8 N& P        BubbleSort.bubbleSort(temparr);


        //降序
        //BubbleSort.bubbleSort(temparr,false);


        for (int i = 0; i < temparr.length; i++) {
9 _; o1 h* m7 N. V' \1 x            System.out.print(temparr + " ");
; ~) `: O. T. L( D% e        }
        System.out.println();

2 m* ?, r+ D  V4 J+ X' w
% e! q9 z" C  z" H& O* r8 A& a        //测试快速排序
        System.out.println("测试快速排序:");
/ P6 n" M& S5 m        temparr = nums.clone();
. J: u3 j  U! u3 H+ V        QuickSort.quickSort(temparr);
        //QuickSort.quickSort(temparr,false);
3 O8 A4 k; [1 f        for (int i = 0; i < temparr.length; i++) {
            System.out.print(temparr + " ");
" R8 N) ?, r" l! U3 O9 [+ _        }
        System.out.println();
* a/ O9 I) ^3 A, s# k( U
. j, h  A8 X: L6 K
        //测试直接选择排序
0 e+ u0 {! u% R: H$ K5 ^        System.out.println("测试直接选择排序:");
        temparr = nums.clone();
& a4 O  J8 `! O9 a6 e& }3 S        SelectSort.selectSort(temparr);
        //SelectSort.selectSort(temparr,false);
        for (int i = 0; i < temparr.length; i++) {
; x: o+ q) N8 _9 t            System.out.print(temparr + " ");
        }
        System.out.println();


! D$ n& @/ K) N/ G5 q4 Z        //测试堆排序
6 a7 K0 U5 G3 ?+ b5 C: O3 s        System.out.println("测试堆排序:");
2 l# r5 D% [, E6 t1 ]6 f1 T) i: }        temparr = nums.clone();
        HeapSort.heapSort(temparr);
        //HeapSort.heapSort(temparr,false);
8 L% G9 F9 R9 |* e2 E# B  l        for (int i = 0; i < temparr.length; i++) {
2 N8 _  \2 h. ^3 w            System.out.print(temparr + " ");
        }
7 \; Q- g' k0 u        System.out.println();
4 f( s5 C' k2 W
) d+ @7 v% ]' N& A
        //测试归并排序
        System.out.println("测试归并排序:");
9 g4 T% p' A/ w$ f, y1 g* y/ G        temparr = nums.clone();
, y( w5 ?- m% B; ?        MergeSort.mergeSort(temparr);
; b# N) m) n' ]( g, C        //MergeSort.mergeSort(temparr,false);
3 S8 T' e/ E' W4 ~        for (int i = 0; i < temparr.length; i++) {
4 n# J3 K* Z: i% \& L            System.out.print(temparr + " ");
        }
+ [" C: B2 o5 J        System.out.println();
" v. p' Q2 J% e9 V% E* O

" U/ A0 `. J4 H$ T2 i& _2 S        //测试插入排序
. |& O( z* f. j- g# k9 Q! b" ?& H, B        System.out.println("测试插入排序:");
        temparr = nums.clone();
        StraghtInsertSort.straghtInsertSort(temparr);
& T9 o: M' O- a/ O- M0 Z& m$ T        //StraghtInsertSort.straghtInsertSort(temparr,false);
        for (int i = 0; i < temparr.length; i++) {
            System.out.print(temparr + " ");
        }
        System.out.println();
3 }4 I$ m/ j/ h1 ~6 N& X. Y


2 C  j: ?, C6 O2 D9 K- A& ]
        //测试希尔排序
        System.out.println("测试希尔排序:");
        temparr = nums.clone();
7 g8 }7 W9 e& A3 K3 }        ShellSort.shellSort(temparr);
0 f1 Y0 X9 m9 ]) L3 @: q        //ShellSort.shellSort(temparr,false);
% M7 o8 K6 @! K/ }: J$ D3 H        for (int i = 0; i < temparr.length; i++) {
4 n  B& d: j( x& I6 B/ p            System.out.print(temparr + " ");
. q" d: G& U( F! p& @/ @- t        }
        System.out.println();
" R  \6 h6 _# O- q- d0 j


! L! K, L7 S+ |- Q  X# L- ~
        //测试计数排序
7 g& m" g/ j3 N* i3 V+ ]        System.out.println("测试计数排序:");
        temparr = nums.clone();
* q1 u; s1 J: Q0 l7 s* G        CountSort.countSort(temparr);
0 w3 g& V3 V0 r! J        //CountSort.countSort(temparr,false);
        for (int i = 0; i < temparr.length; i++) {
            System.out.print(temparr + " ");
1 K+ e( y$ x' \- d: M" |( l& u        }
: i7 k  J9 t+ K5 \! E        System.out.println();
) `  \  {7 Z* {0 ?* @; n
; J. u- u8 z) D' _2 \


        //测试桶排序
        System.out.println("测试桶排序:");
" [  }" W( l3 D( X" C        temparr = nums.clone();
0 `2 o* C  g( _0 I, r        BucketSort.bucketSort(temparr);
# G' C, h7 w" L3 L5 C8 D7 X        //BucketSort.bucketSort(temparr,false);
        for (int i = 0; i < temparr.length; i++) {
            System.out.print(temparr + " ");
        }
5 T4 y! z) Q$ m; l        System.out.println();

  A! i6 a0 b* `( D: [$ R8 |
        //测试基数排序
3 Q, E, r8 ~8 B        System.out.println("测试基数排序:");
" r9 v- Y' |7 M0 N  O9 _9 t9 x        temparr = nums.clone();
' ]$ |2 ~  z' [; x' |5 B        RadixSort.radixSort(temparr);
) r% r' k4 A  K        //RadixSort.radixSort(temparr,false);
        for (int i = 0; i < temparr.length; i++) {
+ |' h  n5 r# P) b! Q2 P            System.out.print(temparr + " ");
        }
8 m& S1 }( ~0 a& n4 W  _        System.out.println();

4 ?5 j" g. g* `
    }
, m7 ?  W8 H' m( m8 b1 }; J$ p2 G, w
8 V& N  P" f0 y, I3 c
* ]' V* W& S2 R# a& b# Z# V8 a}
2 r3 t6 D" n( g' ~1 H: W9 s1
2
3 m, E2 y& o4 p3
, f7 B' h$ X  A' W- i; Y4
0 h. w9 O$ ]4 o2 s8 `5
+ {" d5 p# c3 j/ E  `6
7
8
9
- ]+ H( C. {' w10
11
12
- t% \) p5 _# N6 s+ L3 t( [13
14
1 T) D3 D9 W; t3 N15
9 D; f4 F3 g7 d* t0 x  g" |16
17
18
19
3 k7 p; \5 V7 ~6 u3 {- x+ l2 \20
* x9 A& I3 T  w21
) a7 L) j, S( D3 [( a( Q2 {22
2 Z7 ?5 I. i0 q0 f23
: N* }" n$ Q. P9 C  t2 B) @! Y24
25
. y/ g: q9 k% F0 t) Q26
2 J- J2 C7 n) d* I* V0 o1 j$ X27
( z9 o* o0 c8 s/ |& E8 w3 n7 |28
' T1 o6 T' x" j3 t1 e29
$ c  j1 y( U$ u30
31
9 H" R' Q; @( I3 c% c2 x% \( x32
% }" @% j' Q1 ?33
34
35
) M& [$ c' c) k" v: ~36
' _- `# p. u! s. n/ e37
$ c3 ]) y. f$ q* n  W% g+ V7 i38
39
& R' D; N5 {! S, g! O- R0 [4 y40
3 f  u$ [7 F; y' P& \. K1 N41
42
$ E: ]5 z4 P% F7 T$ C43
1 c0 v0 T( S" H7 o44
45
46
47
1 B2 h/ S+ ]5 b, r0 n) H48
49
50
51
" v% S( \8 `) U8 Y4 z+ i52
6 C0 T  A) \. \" w3 J* J1 L5 O53
: j/ P; |: Q' a+ Q) s54
55
56
; u5 [6 B8 B9 |9 `57
58
' j3 W+ @8 y( i: ?59
2 ~, f( b7 L; \/ J& z% {9 D% M60
2 |; d- ~, ?1 p# q3 x61
+ a$ q; e0 }6 t2 }7 M62
63
$ b' M6 n! B/ u% h: I64
3 g! X6 v4 Z3 k& M65
66
67
68
, w7 V6 H0 {% t; {. _9 @! _" h! A69
  _' k% t4 o2 p. E1 O70
71
72
+ C& [5 _" T, T2 {# @73
74
8 }8 V$ K# u; N% [9 |: ]75
76
77
78
79
6 q5 R( S5 q& l5 L3 ?' n) ^* y+ ^80
- c- {+ ]1 K* T* j% |3 c( v81
. _. S9 c: M! ?# I# a7 }82
83
84
85
8 R: `3 q8 P2 x1 F3 m; c9 D4 q! Q86
% t* f$ K) t9 n3 H- W87
" g2 _4 q4 g6 [7 ?4 ?, ?8 x88
' j$ u3 Y4 q8 M89
90
5 k9 L( ^3 K/ U8 y) y91
" E7 L  m3 g4 m/ l. [. d92
) C# J: o0 t! w9 j+ c93
, o  L: n4 ]% l1 n- }' g0 A94
9 h. x% j. \- t7 P95
6 S5 e1 O; Y  u9 J4 L2 f2 v) d96
97
98
99
, y, g, }1 ?( u) s0 G100
; g$ d* }0 p* @, a( ?101
) T, B$ C; _; k( g6 {102
103
104
105
106
107
108
109
110
7 F& S! t9 p0 [* Q- _8 ^111
112
113
114
115
116
) T8 \( D8 b' F8 z6 p117
3 {6 g/ C5 r& l& {5 _118
" m8 u" T: L% M7 x& q' }, f/ S119
$ {9 c# j; U6 _2 h120
121
122
123
124
; Z+ k" \5 S+ E. @" o: X125
126
127
' g6 u+ ~, M3 C( z; F) e128
8 O% ?  T: M. f129
130
* }) q$ f  ~. ?9 t" ^  q0 J4 {* r131
( ]! S, ?7 M# b6 e" U, ?9 ]132
# ~* _- w8 y9 E; |# l133
134
$ }& Y  N7 E3 U4 t' V2 `7 d9 L135
136
) b; _% @. B7 R137
4 i9 E+ o: ?2 [: l2 v+ O138
139
140
141
142
' R. P+ O! D2 h& B6 p143
* T- L  _/ _  M5 w9 B144
/ _2 s5 _( I. m+ n, [- \145
146
147
1 V1 P6 _7 c. D148
149
0 Y1 }5 v% Q5 s) h5 X150
151
" A2 x$ n8 i4 X: ^! Z, c9 a152
153
154
4 H' [# U2 @8 j" x155
156
157
! l, x' Y+ i3 i9 T158
159
160
/ S4 h7 V  l, u161
  O0 e8 Q9 V/ y1 Q  E) T8 t162
163
: m4 c, G+ v, T! b  G164
165
. |) g8 q8 F4 Q6 i  M166
167
168
169
3 J9 @5 z8 C) y( H$ a& z" @8 c170
171
/ u3 Q; P  |7 M! b: y! M3 P172
  v. u, c: m' L1 l$ U- E173
每天进步一点点！
不进则退！


( C8 h: Q7 _- D8 c版权声明：
原创博主：牛哄哄的柯南
博主原文链接：https://keafmd.blog.csdn.net/
————————————————
) j+ G6 F! @; R5 `+ N版权声明：本文为CSDN博主「牛哄哄的柯南」的原创文章，遵循CC 4.0 BY-SA版权协议，转载请附上原文出处链接及本声明。
& d, q) `% [" w9 S$ k! t原文链接：https://blog.csdn.net/weixin_43883917/article/details/118193663

1051373629

每天进步一点点！
3 Z# {8 [& C: `! D* X) e5 j( Z