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

杨利霞

经典十大排序算法（含升序降序，基数排序含负数排序）【Java版完整代码】【建议收藏系列】
2 Z. U: E2 b& q/ G- c9 i! |经典十大排序算法【Java版完整代码】
写在前面的话
十大排序算法对比
冒泡排序
快速排序
直接选择排序
堆排序
2 H3 _1 `3 f1 D0 l/ {6 F7 q归并排序
( @0 t1 _# H3 r6 c( S插入排序
  X: ~$ K7 [# J& s希尔排序
计数排序
桶排序
基数排序
完整测试类
写在前面的话
" e5 m  S: c+ u0 q% k0 x; Z       虽然已经有很多人总结过这十大排序算法，优秀的文章也不少，但是Java完整版的好像不多，还存在某些文章代码存在错误的情况，同时也为了自己练手，决定把所有的写一遍巩固下，同时也真诚的希望阅读到这篇文章的小伙伴们可以自己去从头敲一遍，不要粘贴复制！希望我的文章对你有所帮助，每天进步一点点！！！


       我用通俗的理解写下对算法的解释，对某个算法的运行过程不是很理解的话或者想看比较官方的解释的话，单独搜索某个算法，看几篇不同的解释，就可以有自己的理解了，这里我主要展示代码以及进行通俗的解释！整起来，再强调一次，一定要自己敲一遍，这样才能理解的更深刻！
& p* F7 _) V. T2 R# d
7 g5 a  a$ Q5 r5 k5 h/ l  r
6 _9 \# K( C1 _8 q$ R3 M十大排序算法对比


& L" a( F- J. H  Q6 t" _
) ?; w- X0 b& }8 z
关于最后一列的稳定性，我稍微解释下，例如对序列：1 2 4 2 6 排序，序列中存在两个2，如果我们把这两个2标记上（让他俩不同），排序之后，前面的2还在前面，那么就称这种排序是稳定的，反之不稳定。


, E) ^, g  H! f) C# D* o- q9 Q3 C冒泡排序
: H! }9 X2 T1 h1 b7 P简单解释：
       原理就如算法名字一样，就像水中的气泡一样，每次我都把最大的或最小的放到最后面，这样总共需要n-1趟即可完成排序，这就是第一层循环，第二次循环就是遍历未被固定的那些数（理解成数组左边的数，因为每层循环都会把最大或最小的数升到最右边固定起来，下次就不遍历这些数了），两层循环遍历结束后，所有的数就排好序了。
       两层循环所以冒泡排序算法的时间复杂度是O(n 2 n^{2}n
) S  ]! x, z8 M9 @: e" N' F2
)，是一个非常高的时间复杂度，我在下面的代码进行了优化，加了一个标志位，如果上一次循环未发生交换，就说明已经是有序的了，就不继续下去了，反之继续进行下一轮。
. N  J1 a7 f* A2 B9 H' c% W, n: s  f


- Q/ Y% S8 v/ Y, V. j  @# L


本文的图片来源网络，仅用于大家学习，侵权联系删除！（下同）
$ j  X* a, A, G5 Q' X, E

完整代码：


# I& J7 H8 M0 }, I5 U! @package com.keafmd.Sequence;
, [2 T5 w; o! }/ W# z* n

, P( f6 u; B- s8 Z& \/**
6 W% k! P- o7 \) i% w+ L4 W * Keafmd
*
* @ClassName: BubbleSort
* @Description: 冒泡排序
* @author: 牛哄哄的柯南
* @date: 2021-06-24 10:31
1 u1 v6 C6 |+ n5 M* N- T8 z- s: p */
public class BubbleSort {
1 I; P. k$ Y6 ]4 d* t' U
* X- R' b6 w1 T/ T
" n) S4 ^# z. i) H" V5 V  l* S    //冒泡排序
    public static void bubbleSort(int[] arr, boolean ascending) { //exchange标志表示为升序排序还是降序排序
1 ~1 r+ T8 g: Q* }% l

1 P* C$ c( @- y) g3 _        boolean flag = true; //加一个标志位，记录上一次是否发生了交换，如果是，我们则进行下一轮，如果没有，说明已经冒泡好了
$ d, ~* j3 Y  m  C+ M. U

        for (int i = 1; i < arr.length && flag; i++) { //控制次数，第几趟排序，只需要n-1趟，有交换时进行，只有flag=false就说明上一次一个元素都没有进行交换
. e/ x( g: Z+ F- g. T

            /*System.out.print("第"+i+"次遍历：");
0 `/ `# C/ [; ~& J# x            for (int i1 : arr) {
                System.out.print(i1+" ");
            }
$ F% p1 Y5 Z2 |) n1 V            System.out.println();*/
9 G: o; F* w0 R% `# T& ~

            flag = false; //假定未交换

/ q/ G* M2 C7 g) e+ h
            for (int j = 0; j < arr.length - i; j++) {
+ M4 Q- X& x- r/ S" }0 N$ h% c
% j/ q, J8 T3 n5 U
                if (ascending ? arr[j] > arr[j + 1] : arr[j] < arr[j + 1]) { //控制升序还是降序
& X8 i4 f, [; p3 a3 q# _' ~8 J                    int temp = arr[j];
; i% O$ v- Q, d! e6 B1 B6 p' }                    arr[j] = arr[j + 1];
                    arr[j + 1] = temp;
                    flag = true;
                }


- u# C" v, d' {2 z* r            }
' j+ B1 c% F& @& _        }
    }


    //冒泡排序 -- 默认不传参升序
9 a5 j2 [4 R4 J, `    public static void bubbleSort(int[] arr) {
        bubbleSort(arr, true);
8 T: F- [: \" D8 @+ [' E    }
- H2 E: s4 ~* E& P1 ~/ C( _}
1
2
3 `6 T8 X/ W  r! w9 W1 c/ _0 q3
5 Z; I' H) S0 U# a6 E0 p4
& c4 z$ L( q! q5
6
7
8
9 j4 K: v. i8 X9
6 S, R; W4 K" g8 p' Q10
8 J: i& o$ `, K' C# ?0 y( f11
9 Y9 N+ E# o! X! {' d0 {! a$ ]12
! t& e* U9 K+ t& Z8 z- |13
14
15
+ L. b: B) W* e16
17
6 g3 j9 m$ `2 F9 h% a+ b, @18
7 q  m$ X: L  j% z19
! W0 @8 t% x8 F( t( a20
21
  ]+ W" ^/ b  \* a22
' [* N5 E$ Z/ j7 @+ p23
24
25
! O! |! G& e2 l' H" _26
7 A6 {& J3 Y% a" b# k/ T" f27
28
' v6 i/ I+ c* U3 b5 ^3 W29
7 C8 n' c5 G( w" X30
8 X) K" n5 h5 C! K  h31
32
33
34
# p5 O2 g7 @, @( B% O; X35
36
37
. u2 z4 g' l$ V* p& D38
39
40
41
2 b7 N; V1 H9 o) \4 p42
8 n! N7 F  |* I$ b9 l43
  k' F9 O; H$ Z" \- |44
45
测试代码：
% F$ d# ~" q, Y' _- d- c

( r3 z" U7 h7 r% Q) r升序排序（从小到大）


& K6 Y! m$ v8 p4 C9 V0 ?package com.keafmd.Sequence;
; O" h3 Z, N* }' J/ V
- N5 L; P0 F  I1 E4 L- g- |
# L' G! c4 R  M& g6 simport java.util.*;
import java.util.stream.IntStream;
7 E$ A6 ^6 H/ T, m( oimport java.util.stream.Stream;

2 z- _7 j6 G, N
1 k' t' C4 k2 E/ Z" k1 r/**
6 [+ ^8 V+ u1 S * Keafmd
*
4 q( A; Y( }3 y * @ClassName: Sort
* @Description: 十大排序算法
5 Y7 ~3 e7 J9 v% X * @author: 牛哄哄的柯南
6 t. D% ?8 @% G2 g2 U * @date: 2021-06-16 21:27
*/
, x; E9 B4 v3 y9 O4 Y( d) M- kpublic class Sort {
' s1 \) T6 L/ v3 g9 ?    public static void main(String[] args) {
6 R) Q2 ]6 W' ~4 H( v

        int[] nums = {12, 4, 25, 47, 58, 34, 25, 9, 99, 26, 1, -13, 162, 10093, -66, -1};
2 [& e  q. j) b) S9 q        int[] temparr;

  O$ \  T  H8 b
        //测试冒泡排序
! e0 u1 _1 F. g: X        System.out.println("测试冒泡排序:");
        temparr = nums.clone();
        BubbleSort.bubbleSort(temparr);
( \6 }6 ]: z' H/ E' ^/ F5 d        //逆序排序
        //BubbleSort.bubbleSort(temparr,false);
        for (int i = 0; i < temparr.length; i++) {
) C+ T9 `( t$ u7 P            System.out.print(temparr + " ");
) P! t, T! `7 N        }
" }& H+ f' f; R) R0 l  M        System.out.println();


+ g6 r$ k" U- C: s6 T6 I    }
" ~) t# M. t) k* ?4 l9 n}
1
! R( g3 p9 Q! Q: \: \* {; f2
% h# v3 a' v. x  b6 i" i# Q6 w0 S3
4
: Q! M2 P& c; |" P4 y+ y5
4 n/ Y' G  h9 I% z( X& J5 E6
7
8
9
, i* X! K$ q3 @5 R10
5 C, r6 I) Z, y( v& P11
12
- f6 \+ |6 K% ]' O" }, x13
14
. {: P/ v5 \) ^+ G: u15
5 o* L7 i3 P& F0 ~6 T16
& j* ~2 d! ?) ^0 x17
18
" p6 d0 P) L# t1 l! S19
8 e$ ?' Z4 K: |" N20
21
22
23
; T, G. i9 B7 M1 _3 ^24
25
$ S8 R' T' y5 [6 R) R26
8 C3 W5 ?, z( U8 I0 L27
" N2 q9 e# ~3 D* D% j* M28
0 C2 z+ y" u. }: G& x' t29
30
* Q4 U0 q" t1 m0 C7 r( P9 e; _31
9 \8 g8 a+ W, _+ N6 T32
33
运行结果：


测试冒泡排序:
-66 -13 -1 1 4 9 12 25 25 26 34 47 58 99 162 10093
1
# ]  c: j' {1 f2
降序排序（从大到小）
% ~7 g, g, X2 g5 w  f
- D5 b4 G; Y8 v9 {, I
+ {; `. u' {4 l$ C9 ]3 B//测试冒泡排序
System.out.println("测试冒泡排序:");
! I1 F/ [* ~7 U8 r% n  j& S8 U1 Ltemparr = nums.clone();
0 @8 C2 }6 p& Q) BBubbleSort.bubbleSort(temparr,false);
$ \. ~' ~% ^, q' J; I% gfor (int i = 0; i < temparr.length; i++) {
; ]+ \0 l$ @7 E    System.out.print(temparr + " ");
}
8 R( ~7 n; a, q$ u* d% gSystem.out.println();
3 Z" G0 P* Z0 k9 a1
2
3
4
5
6
7
* u& C  S( ], ~& c" E% y8
运行结果：


3 l+ i$ R& \, S- L测试冒泡排序:
( M: b% V, w5 p% [/ `9 b3 p" ]- I10093 162 99 58 47 34 26 25 25 12 9 4 1 -1 -13 -66
8 W  \) w' z7 n1
8 L. T; I1 h( S1 c- z2
: h4 F( b% g. }! q  S8 \下面几个算法的测试也就是换了下类名和方法名（换成相应的排序算法），如果想降序就在数组后面传个false即可。我就不一一复制了，我在最下面给出含所有算法的测试类，需要的自取即可。
0 R. c! [0 D) L+ i# H% v8 R7 C' M
7 i' _* @- ~  G0 R: q; c  q
! b6 g2 @) h9 D+ ?. C快速排序
简单解释：
快速排序就是每次找一个基点（第一个元素），然后两个哨兵，一个从最前面往后走，一个从最后面往前面走，如果后面那个哨兵找到了一个比基点大的数停下来，前面那个哨兵找到比基点大的数停下来，然后交换两个哨兵找到的数，如果找不到最后两个哨兵就会碰到一起就结束，最后交换基点和哨兵相遇的地方的元素，然后就将一个序列分为比基点小的一部分和比基点大的一部分，然后递归左半部分和右半部分，最后的结果就是有序的了。
# X2 {  V. ]% y2 I! u
  M$ c  i' m1 _3 V" }* h/ b
; r9 ]" c0 Y; w* N; m

5 {% `# x2 Q% l
; T" a' L, V& z' K2 D# W$ p& g6 m7 w
完整代码：


package com.keafmd.Sequence;
1 a6 [: {: E7 r, G# i$ U  o
' w! r: L* m0 b" k
7 v8 q6 Z$ X# R. d2 v/**
* Keafmd
/ u# M6 k% z( ^6 C *
* @ClassName: QuickSort
* @Description: 快速排序
7 p" {& k8 w9 h9 t, J * @author: 牛哄哄的柯南
: u: d  [6 E; |5 C+ w * @date: 2021-06-24 10:32
. x# |& d* U- ]: J */
( N0 g7 `- \( |1 ~. @2 Z2 Qpublic class QuickSort {


% K. s7 ^4 p7 a4 `( c! j$ I    //快速排序
    public static void quickSort(int[] arr) {
* v, B! h) P  |        quickSort(arr, true);
    }


    public static void quickSort(int[] arr, boolean ascending) {
# q' [) Z! a2 |" S# _- Z        if (ascending) {
            quickSort(arr, 0, arr.length - 1, true);
# u1 ]7 h# }6 C) z* L# {+ g2 V        } else {
/ O/ H( \* k# E6 }. _            quickSort(arr, 0, arr.length - 1, false);
        }
    }
0 a# v, P6 d; T0 S
9 }: u  f: I9 W* Y7 r" _- {
    public static void quickSort(int[] arr, int begin, int end, boolean ascending) {
$ f+ x( u) w% T: B% V* S" v: b        if (ascending)
            quickSort(arr, begin, end);
5 X2 e- `/ T( |# ~" h        else
# n- b" e% U" l; V( T9 }0 q- u            quickSortDescending(arr, begin, end);
    }
/ v/ f; E% }9 `$ z$ A
# H/ c# u! ]" a) r9 u0 N
# S# X( ?7 b0 x( Y5 @    //快排序升序 -- 默认
    public static void quickSort(int[] arr, int begin, int end) {
; {. v* @4 ]  O. E6 o3 c( z3 t        if (begin > end) { //结束条件
4 o3 H% D  B/ P% [% M# q- B, D            return;
        }
        int base = arr[begin];
* V, y! J( a5 }3 o- e        int i = begin, j = end;
        while (i < j) { // 两个哨兵（i左边，j右边）没有相遇
5 q& j# @/ ?4 F1 {. V2 x            while (arr[j] >= base && i < j) { //哨兵j没找到比base小的
( L- d* i9 t$ q                j--;
/ w9 I$ w4 N/ R0 K  U& x) x1 L; u            }
% x, O* C' S$ {1 L$ y1 F            while (arr <= base && i < j) { //哨兵i没找到比base大的
5 S& j5 U$ k0 G. e; U                i++;
9 J! V. q. W9 W" n; s* G( E( B            }
7 J# [: ?% X( l; y/ @+ _% V            if (i < j) { //如果满足条件则交换
( l" e! o( R# ^# h( }3 p                int temp = arr;
                arr = arr[j];
                arr[j] = temp;
            }
) y2 D; j. q! k* W

        }
- g* y0 Y5 }. z" I        //最后将基准为与i和j相等位置的数字交换
$ i0 E2 l$ |" m5 _9 d; A        arr[begin] = arr;
        arr = base;
6 Q5 v8 K8 p- A* L( ^5 r' [        quickSort(arr, begin, i - 1); //递归调用左半数组
        quickSort(arr, i + 1, end); //递归调用右半数组


5 z# R+ f; A5 g  x0 N& F    }


# T1 d  S) I' R$ v2 ~    //快排序降序
7 l. \' Y: u( l% \7 i    public static void quickSortDescending(int[] arr, int begin, int end) {
7 C" P7 C4 c& k' C1 W        if (begin > end) { //结束条件
            return;
        }
7 y) u0 }, }$ a0 @! H        int base = arr[begin];
        int i = begin, j = end;
' q2 s. g  {1 A& e7 T7 {" p7 a' ?0 u        while (i < j) { // 两个哨兵（i左边，j右边）没有相遇
            while (arr[j] <= base && i < j) { //哨兵j没找到比base大的
                j--;
# O5 ?, x% B' X9 i/ l- B2 b0 R            }
            while (arr >= base && i < j) { //哨兵i没找到比base小的
: M! y  M* Y. ]2 B3 k/ w( j$ L2 Z1 J                i++;
            }
- X8 h; o" \9 ^4 e$ J7 j' e+ G            if (i < j) { //如果满足条件则交换
1 ?# o# Y5 s* ~1 m9 v* `3 ]                int temp = arr;
* R2 c7 g) c5 Z2 Y  n  N' F                arr = arr[j];
                arr[j] = temp;
            }


/ ^- Q6 d0 F. D/ @4 q1 Z        }
        //最后将基准为与i和j相等位置的数字交换
% w) v. b) R% f        arr[begin] = arr;
        arr = base;
3 t8 T6 x: B1 E" U- ]8 A, P2 b        quickSortDescending(arr, begin, i - 1); //递归调用左半数组
        quickSortDescending(arr, i + 1, end); //递归调用右半数组


1 @: z: u1 j6 N- q  D0 p    }
/ b8 m& W& V% y! P
5 W( n4 h( h2 W: K1 [
$ N, J0 H  P3 [3 R}
& D8 Z9 |  P+ R7 Q* ~1
6 K2 B3 z- E- _# s* n% l3 B2 S2
3
4
3 ~' ?" M9 E' B  M" u2 s' j$ H4 X5
+ c9 G# `8 z6 Z' P/ w1 Q* f6
4 T( D( x" u8 g5 n0 ]7 t  f  t$ B# {" F7
2 h% a- f) h- ~+ m1 t% ^* V8
9
$ s& x% X5 n$ P8 G10
) X2 |4 Y/ Y5 N7 o% U6 Q' n11
4 ?% i) s5 r3 ?4 j, g" I# M" t12
% b6 E/ C, N$ U/ U  i% n1 M13
14
2 g) J, N* O% h; q, _15
16
$ U4 D' y* K/ r6 V17
& ^9 S# \$ X' C3 X18
19
0 O* B/ V* ?/ k0 _* _! [20
- L4 [. t, w( S0 I8 h, y8 i  [( j21
! Y& v7 [  P- u$ N! U. P4 z22
23
24
+ z6 W2 d! `) F& Q% w25
26
' [& [% M( c/ a8 @+ t0 b27
( C" D' i! q2 G# Q28
29
30
31
32
33
% r' ?5 a& d7 M$ O* Z" E34
* M9 V) @& k5 F6 c2 N35
. X) X/ C9 j1 a36
37
38
* l) \7 |2 n' }6 U8 [' b39
40
8 x* Z5 B% K* o, z41
42
5 G/ v9 ~+ Q  U* @# \2 \43
44
45
46
47
48
49
50
51
52
( e, \( o% B8 V+ b53
54
55
56
5 y) X7 M  Q1 a& n$ _57
58
59
60
61
) t0 F# p! s+ N' w+ V62
  ?' Y9 K5 ~2 I' n: h63
7 H& u& a. S# E64
65
66
67
68
69
" P: Z' Z: o% Z+ V- }# T70
8 Q6 b- n# ^8 ~71
72
73
% M2 X3 B! Y# t# V* S9 W74
75
7 J8 R2 [9 a6 P( r; k76
  T; C1 Y2 H. \77
78
79
" j3 r1 t* H6 O1 ~$ ?: X8 X80
' m# p8 B0 x9 F9 S# v81
1 O' d9 s0 @1 B7 y* g6 \82
83
84
85
86
87
88
89
2 A0 L& {) z/ W2 k/ R+ B# n90
% b( j* I" m, D9 \4 R91
4 F4 y. j& j0 R7 B直接选择排序
5 i, J6 M& L# z( l; j4 J简单解释：
8 d2 h4 m& @! F9 o* X9 G" `数组分为已排序部分（前面）和待排序序列（后面）
: r6 v  K" K1 P: R: T; G第一次肯定所有的数都是待排序的
从待排序的序列中找到最大或最小的那个元素，放到前面的已排序部分，然后一直找，不断缩小待排序的范围，直到所有的数都是已排序的了
7 ?* L/ ~6 ?& @% Q6 i5 l& N1 z# q. ^
: y8 t; T* y) z$ ^
2 E: o2 L3 e, w. b( X; o7 p# {

( V9 ?* P! G5 D

完整代码：
) e+ M% Z9 ^! V6 a+ C$ B# r

package com.keafmd.Sequence;
0 G% k5 p$ U) U% t. X) {3 V; o

; L) L% T& u& e( t- P& v/**
7 U7 K9 f8 V' `( y( w9 t4 H: o * Keafmd
0 ^9 T/ r. N- q/ o3 v2 W3 d *
* @ClassName: SelectSort
* @Description: 选择排序
* @author: 牛哄哄的柯南
* @date: 2021-06-24 10:33
*/
public class SelectSort {
1 f6 U' W0 r( y, p
8 I6 S8 f5 ]0 ]& X6 o% p- l
    //直接选择排序
    public static void selectSort(int[] arr, boolean ascending) {
        for (int i = 0; i < arr.length; i++) {
            int m = i; //最小值或最小值的下标
  u) ?/ C! A, y: n4 N            for (int j = i + 1; j < arr.length; j++) {
                if (ascending ? arr[j] < arr[m] : arr[j] > arr[m]) {
                    m = j; //找到待排序的数中最小或最大的那个数，记录下标
                }

2 `% B$ ^* @( @/ C" S* i
$ H7 T0 Y# |# N0 H' o+ J+ H7 e            }
            //交换位置
            int temp = arr;
            arr = arr[m];
+ j$ F+ H5 q! K' k, ]' }/ ?            arr[m] = temp;


        }
    }


# d- L  [- a+ Y0 R! Q    public static void selectSort(int[] arr) {
0 b7 J1 F# }( K. Y+ @, [# g+ c: t        selectSort(arr, true);
+ e" k& y' N! x  t  G    }
}
( E) s/ p/ q9 Y5 W, m1
2
. ?% `; U& k8 Z7 P+ L/ |% ], [3
% d' _& U1 f8 @8 C/ C8 e# Z, U4
- t" R% ]* K' u5
6
% [$ |2 w" A6 ~. _7
, E& k, j2 Y" t- A1 G8
, v4 ^- c2 X* x9
10
) @: x# r. Y, @11
12
13
14
4 c9 Y) f; q7 D15
, n) a; _. f4 d/ ?16
- R4 [! Z) P' S17
18
: p5 T: I: O2 E! u, v4 P; {0 T19
20
2 K* C8 G% X, a8 `21
22
7 v* ^" H/ V2 h# F! r23
24
: t2 D1 q. g% Z: `25
* ?5 y2 o3 i# V/ l3 ~26
27
28
; p( k% ?  I# b: [29
30
31
' j: P3 P3 q" I" n. d32
33
34
堆排序
7 c8 y( A, t9 w8 \4 M2 X先理解下大顶堆和小顶堆，看图
大顶堆，双亲结点的值比每一个孩子结点的值都要大。根结点值最大
( Z/ P* @6 D$ D+ d7 P: w小顶堆，双亲结点的值比每一个孩子结点的值都要小。根结点值最小
* ^! G% N4 w0 l) i9 D4 O2 G% [; T
1 ]' }* s4 z0 E* t  g& Z5 D. ?

- X3 X0 V# C; F- G9 \
简单解释：
构建好大顶堆或小顶堆结构，这样最上面的就是最大值或最小值，那么我们取出堆顶元素，然后重新构建结构，一直取，一直重新构建，那么最后达到排序的效果了。
/ f0 _+ e- X1 c1 w
0 R% f6 ?$ w  S! }8 F2 y, c
& C# c4 X7 [1 c; g. G5 |
& M/ X) Q) R5 K0 q


完整代码：
7 }1 {# [8 q/ x- @3 Y0 w6 }  x! o

package com.keafmd.Sequence;
: u, c/ k" l2 f9 p3 E% T

8 i6 e) ?# n3 @( M( x. q/**
* Keafmd
*
' v! Y7 O! C3 d% n * @ClassName: HeapSort
# {% L5 U( E0 u( c# y0 @' \; ? * @Description: 堆排序
* @author: 牛哄哄的柯南
: j9 {3 x+ n) B8 h2 Y, N1 i * @date: 2021-06-24 10:34
*/
public class HeapSort {

% _9 g( B* h% ^: j# X0 L6 i7 F
4 a8 F7 @5 k& o& j2 Y4 G- ], T% E" E5 o    //堆排序
' z2 v' r" w2 e! b7 a5 e$ w    public static void heapSort(int[] arr) {
1 t- o0 r* b: b$ s        //对传入的数组进行建立堆，这里默认建立大顶堆，进行升序排列
; W! Y- M* E' u7 P7 o9 [! m2 {9 s        heapSort(arr, true);
    }


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


        //1.构建大顶堆
0 V! N; Z! f3 s        for (int i = arr.length / 2 - 1; i >= 0; i--) {
            //从第一个非叶子结点从下至上，从右至左调整结构
            sift(arr, i, arr.length , maxheap);
        }


& R' {0 s3 i( e2 U3 x- \) U$ M        //2.调整堆结构+交换堆顶元素与末尾元素
        for (int j = arr.length - 1; j > 0; j--) {


+ H! [  e2 ?5 m. t            //现在的数组第一个就是根结点，最小值所在，进行交换，把它放到最右边
            int temp = arr[j];
5 v, {% A! f: R4 |, V3 H- r3 i% B            arr[j] = arr[0];
            arr[0] = temp;
8 H1 K8 H! M( c/ v" _

            //重新建立堆
& H9 Y# n, }$ b8 F$ B. _            sift(arr, 0, j , maxheap); //重新对堆进行调整
# k9 e" A9 |' H* g! y$ `# S0 ?        }
    }


& h& c3 V  x$ @3 j. `2 Z3 V    //建立堆的方法
    /**
     * 私有方法，只允许被堆排序调用
     *
3 m1 Y7 l5 e. U1 [1 O% l% O     * @param arr     要排序数组
6 q# ^( k# O6 R1 _. b6 i     * @param parent  当前的双亲节点
     * @param len     数组长度
6 |- u$ }4 s" N% {, ]- }5 z: `" d     * @param maxheap 是否建立大顶堆
0 Q) R3 f- T+ `9 h' z/ p     */
    private static void sift(int[] arr, int parent, int len, boolean maxheap) {
" p% K# Z& Q  c2 d$ r

        int value = arr[parent]; //先取出当前元素i
8 @* X% R2 S5 _( R. F

6 E% k+ e' M: j( I        for (int child = 2 * parent + 1; child < len; child = child * 2 + 1) { //从parent结点的左子结点开始，也就是2*parent+1处开始
6 i; v# t& G6 x" I, L
1 F6 [: j9 Y# g6 E! c- K
# z; c1 G7 ?5 y4 }1 \. U. W: n            if (child+1 < len && (maxheap ? arr[child] < arr[child + 1] : arr[child] > arr[child + 1])) { //如果左子结点小于右子结点，child指向右子结点
                child++; //右孩子如果比左孩子大，我们就将现在的孩子换到右孩子
            }

8 j  J: J; x$ V. ?( |
            //判断是否符合大顶堆的特性， 如果右孩子大于双亲，自然左孩子也大于双亲，符合
            //如果子节点大于父节点，将子节点值赋给父节点（不用进行交换)
6 @5 l% n( I( c- b( L2 q            if (maxheap ? value < arr[child] : value > arr[child]) {
! L  v  w4 V! |; E( v+ m/ w# n                arr[parent]=arr[child];
                parent = child;
# `8 m! Y# a/ Z            }
            else {//如果不是，说明已经符合我们的要求了。
                break;
+ g. r& E2 S6 G0 g: _2 F            }
" o6 M9 X2 b' E* x; ]* r+ S0 j        }
        arr[parent] =value; //将value值放到最终的位置
1 P9 r; _. y! s
  R3 b: [' J6 A2 F* }+ `
9 O3 ^6 L' g2 P- s7 f1 i

$ `3 L. h' {$ g" b    }
7 e/ E4 }; e3 A

4 J  `0 k4 X$ P( C, L' ?( N+ ]}
$ P! M! ]) B# W( C* j* s# b# w1
% d) K/ [2 K6 j5 u2
2 Y  \& [3 p- E& h5 |( y1 x3
$ i( z2 V' R! q) O$ \4
/ q! U! h4 i4 a; p5
. e6 _: a' x7 q! t* I3 Y1 ?4 N6
7
8
) M9 m. x2 h0 N) b, }9
9 P- T) f' W$ ^+ w4 I# P10
11
$ H2 y) o) C" a12
13
14
' E) c9 N( c- ~# f  z15
6 }6 P, }: D6 N# C16
3 O5 b2 i8 ?& F  O- ^) \! m& R17
4 G( c" H9 n+ e# Y6 D18
# u* a  d0 J; f( V2 a; q% B19
  l% C5 w1 t# b& S20
, ?+ N% F4 m5 A! J  t21
) q& @8 O7 i# A  f* Z22
23
' b  B+ R4 C  Z* a# t24
6 [. k0 h, f4 C; k25
26
27
. B+ H6 n" p: G, L1 H28
29
! K* N* n7 t- {+ [! n30
31
' H9 V& ^: Y( B$ z$ n. j9 b0 v32
7 `/ y1 t9 N0 P33
34
35
36
37
5 t( L2 Q% e5 e( ?5 c38
39
4 z2 c$ {+ ^# j40
41
4 }, f8 M7 B) E9 e42
9 |/ n& F- `* T0 P' L5 ?43
: v+ A" Y( `6 C2 B% V3 Z44
45
- F3 c! p  ?# [' x46
47
0 g. K. y7 a- X: l# ?/ l& S4 y; i48
- Z, Q- D$ P8 a" [" K3 e9 s" y49
/ G5 U% U$ l; m2 C+ X50
51
52
53
54
' D0 f( w' R3 O55
( P& q' C) B- T56
/ d9 \+ W, n5 D3 y3 T: N2 Q57
58
59
60
61
62
7 _) f1 `+ z  b1 N  u63
64
4 C  U9 ]: j  C* z8 h65
5 T8 O' g) W7 _6 Q6 `5 e5 K66
67
: p! Y6 s  j$ f: {  k68
7 `- E  U3 q) X- ?  p69
6 X% I* d7 z/ Q9 t5 y70
71
72
73
8 \1 ]3 W4 y& @# T6 }2 Y74
9 a, t7 q# C+ t6 t% Y归并排序
简单解释：
该算法是采用分治法，把数组不断分割，直至成为单个元素，然后比较再合并（合并的过程就是两部分分别从头开始比较，取出最小或最大元素的放到新的区域内，继续取两部分中最大或最小的元素，直到这两部分合并完，最后所有的都合并完，最后形成完整的有序序列）


. _7 c7 [4 A8 @8 e* q


6 ?, `5 [: A; t0 v) d
# e  p0 C; U: r完整代码：

+ g5 O7 ^" J  ]5 {) H% Z! D; F2 }
# [6 c% {( g. y6 \& |  wpackage com.keafmd.Sequence;
; v0 a. n! C/ A
0 a. }6 ~- ~6 i1 H
/**
* Keafmd
0 r! a; ]) d: I7 Q *
* g6 K: d% J# A" g5 _ * @ClassName: MergeSort
8 G8 k/ o! W. m  A! E. l) k- s+ c" E% B * @Description: 归并排序
* @author: 牛哄哄的柯南
" w2 p1 Z% b" h" {: \7 i0 |3 a * @date: 2021-06-24 10:35
; v0 s2 K  Y5 Y' } */
public class MergeSort {
0 a2 b- I$ Q2 ?/ K  q  U

    //归并排序
: @0 D$ a0 ^& F# }% q& S% a) W    public static void mergeSort(int []arr ,boolean ascending){
        int[] temp = new int[arr.length]; //在排序前，先建好一个长度等于原数组长度的临时数组，避免递归中频繁开辟空间
1 B) D. E  G; T- H0 b3 s4 m3 F        mergeSort(arr,0,arr.length-1,temp,ascending);
    }
4 q$ X  }, Y0 B$ E0 Q2 T3 G    public static void mergeSort(int []arr){
        mergeSort(arr,true);
    }
/ R1 _! ?% j$ o8 s6 @" t# J$ D
1 U0 ]+ Q% A% s  Q0 L
/ P7 b+ x; N. ]    /**
8 @7 O3 Y8 h- J2 }( }- w/ T     *
  Y8 q) p6 z* k; D/ J) X     * @param arr 传入的数组
5 R0 S# Z+ h+ O0 |) n2 t     * @param left 当前子数组的起始下标
     * @param right 当前子数组的结束下标
  G0 N9 M0 G. Z  G" Q+ U3 ?     * @param temp 拷贝暂存数组
     */
$ z9 H9 b: N6 d    public static void mergeSort(int []arr,int left,int right,int[] temp,boolean ascending){
( _, E0 X4 `. Q  b; m. g& V( E- N        if(left<right){ //这里是递归结束的条件，我们是对半分，那当left==right的时候肯定大家都是只有一个元素了。
5 z) }- s* v0 X" p) m4 C, t
) D) c/ w: ^0 |4 G8 F
% z2 p3 K( y0 U0 `! j2 {            //对半分，比如总长度是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;
+ l3 n/ [4 V7 o) P3 G5 i; S

/ X  x# D6 l, [8 R4 |* N0 O            mergeSort(arr,left,mid,temp,ascending); //左边归并排序，使得左子序列有序
; j2 K9 J) |5 r$ p            mergeSort(arr,mid+1,right,temp,ascending); //右边归并排序，使得右子序列有序


            merge(arr,left,mid,right,temp,ascending); //将两个有序子数组合并操作
        }
4 a$ n3 ]. o7 |+ D8 e    }
  N9 I2 t1 d( m8 ~5 ?2 E

* E! s+ ?  e: c8 P/ J: ^7 g5 G    private static void merge(int[] arr,int left,int mid,int right,int[] temp,boolean ascending){
+ y) ]2 I9 X5 \& C4 ^2 D& e( W0 G        int i = left; //左序列起始下标
        int j = mid+1; //右序列起始下标
        int t = 0; //临时数组指针
        while(i<=mid&&j<=right){
2 d1 }1 M& f+ c  T$ r  H1 m$ A- n            if(ascending?arr<arr[j]:arr>arr[j]){ //比较两个序列第一个元素谁小，谁小先拷贝谁到temp，然后对应子序列下标加1
                temp[t++] = arr[i++];
. f1 p+ d* e8 E2 @0 o& l            }else {
                temp[t++] = arr[j++];
& m: Q: S  q; i7 `            }
& I, \' |' Q0 q( M0 U' K0 T) q        }
' h- P# \. S" z7 z! g  G; y
% G, C1 Y# Y6 \' r$ H
        while(i<=mid){ //将左边剩余元素填充进temp中——左序列有一些数总是比右边的大的数
+ l$ e( Y8 x2 ~            temp[t++] = arr[i++];
        }

3 l/ D8 N/ E5 J* v9 ?
# y8 ~0 ]& G3 @! K/ m. P! ]        while(j<=right){ //将右序列剩余元素填充进temp中——右序列有一些数总是比左边的大的数
            temp[t++] = arr[j++];
        }


2 D, K, j0 y4 }' Y* y! Y0 A        t = 0;
7 ~# X! n' n8 P

# V+ a3 [' V3 ]) G        //将temp中的元素全部拷贝到原数组中
        while(left<=right){
: ^. @4 r$ g" V& ]' U. k1 [% q& l* o            arr[left++] = temp[t++];
        }

1 _/ C& {- O' [" T
! b( c, m/ r- R+ L6 `    }
1 l- o' C& [  X( k( n

7 a3 _3 C  _+ t  N+ B9 K0 Y}
! \+ K/ M" r9 A/ Y( |9 I: h0 h1
0 X/ X1 s0 P% u& d2
3
" W* T; A8 D! B" y4
" p. B1 f6 [* _/ {# y9 y5
3 ^/ g- Y* Z/ W. ^" L' @- l" k6
; L2 `& u& J; w+ P/ l: }7
+ Y3 [7 a8 N$ n8
9
10
11
12
1 c: M0 |  s# D7 ?# N3 b13
' U7 I0 E4 L5 I. i5 u( }4 f6 d- M' d% Z14
& [. i' S# l" x5 _3 R6 ~$ W15
+ n' l& h8 a( k+ ]16
- a0 {" M6 C0 G6 j# x: Y$ {: Q17
18
19
20
$ W' @& m: E0 \: W21
22
. p4 Y3 l6 W  K  D* _23
0 l0 S5 W1 |3 S0 r, {24
25
26
27
28
29
/ J/ S; e7 K( |& z6 H30
31
1 w2 l6 y3 _* X7 z& s* r, ^; Z32
33
4 L) l1 {% R2 m0 ?$ x$ o- [34
8 f6 U6 `% j2 t# H* u- W! {% c: w: _35
! F" ?; z4 i# D) K: D: i36
37
9 }3 }: v  t$ ?! ]38
( d2 O1 }, z' V' L* R39
7 N8 M; S) m  j# N. i40
& F0 ~) B  J+ |: k- D0 S5 t3 {41
42
- U3 U" x/ @7 Z  t+ ]/ L3 c43
" |' W" {9 k$ V: A4 f44
9 \% S6 Z: |0 O5 Q45
46
47
48
6 m4 V+ {, a0 R: p49
6 j2 a; a) @" ?2 U50
51
3 I0 g/ c5 y2 r4 r. `/ o' T52
8 n0 N6 i4 l. m" [9 v1 K2 \$ y53
8 _. C9 g' ~# I+ n4 T' D54
. ?! c  j6 h7 V% w$ l0 m7 o55
/ C' s: r  Y! x8 X56
! z. S; I. O" |/ k, _  F57
" Q" D% w9 a7 Q2 L# j! k/ D5 p: C58
$ U; {; Y8 R; g5 p% K! V) A3 p( T( ]59
7 G* w! q; U& g/ e: S$ M) d2 q60
61
8 H  G- g$ R, U7 G62
6 P' i( X- @/ m7 C9 h5 E1 v8 F" s* _. S63
9 V/ y7 l# l8 S+ Y' l64
; o+ @# d) y5 T, I65
4 V; Q) ~* r& B66
67
68
69
$ i6 Y3 `8 F" Y  D0 U70
71
72
; I  l7 ?% c6 s) N8 y73
+ |0 @& ^6 z1 o% I, x0 t插入排序
; x5 u& E- @$ }' q+ \$ m简单解释：
5 Z. d7 {* y4 B最简单的理解就是打地主时我们拿到牌后的整理过程，从第二个牌（假设我们拿起来这个牌开始比较）开始，（说下升序）从后往前比较如果比前面的那个牌小，就把牌往后移动，直到找到一个合适的位置（这个位置的前面的那个牌不比这个要放下的牌大）就把这个牌放到这个位置，慢慢的前面的部分变得有序，直至全部有序即可。
2 W3 n2 x. Z4 f! h
8 F- D3 R- Q* v
( }1 c) ~0 C3 {% w
  _# O! {: {4 Z( \. G5 f

. X% v. M7 z7 h$ n3 j
完整代码：
1 k& ~3 s6 q  ?% y* j/ V. |0 ^

6 M; |$ M0 W- F) m0 ~1 F7 Zpackage com.keafmd.Sequence;


/**
* Keafmd
*
! M; ]0 j: @9 d" I. d; p9 _, }% J * @ClassName: StraghtInsertSort
* @Description: 插入排序
* @author: 牛哄哄的柯南
, o' w' F# q) N( v. Q * @date: 2021-06-24 10:36
3 ~9 @! _% X! k5 P* K; z" k */
public class StraghtInsertSort {
    //插入排序
7 H3 W" u0 G5 w8 F! D) c" E! Q' p    public static void straghtInsertSort(int[] arr) {
1 L3 i3 e" W7 X2 n+ l        straghtInsertSort(arr, true);//默认进行升序
8 P5 {# x, a+ L- G% @/ t$ z6 G    }
* t4 @$ T; @# H

    public static void straghtInsertSort(int[] arr, boolean ascending) {
; p# v+ X' k; V- h

        for (int i = 1; i < arr.length; i++) {
            int temp = arr;
7 H! a/ K( w1 P4 d: k            int j=0; //这就是那个合适的位置
            for (j = i - 1; j >= 0 && (ascending ? temp < arr[j] : temp > arr[j]); j--) {
                arr[j + 1] = arr[j];
+ w" ]* _$ c' F- Q* a2 @! W6 o1 |            }
. U& A7 s; ~; l            //把牌放下，为啥是j+1，
            //是因为上面的循环遍历到不符合情况的时候 j是合适的位置的前面的那个数的位置
            //有点拗口，但是就是这个意思，看图方便理解下
( B# m. C1 I, Q; M            arr[j + 1] = temp;
; y/ W1 u4 A6 t+ Y3 m' c



% t2 ]7 |8 o& p# @        }
3 v+ L! W8 q6 W$ d
- e0 a# H' V. N5 E, E. h
- c$ ?, C' ?9 u% N+ n' N" [5 l    }
, X7 k3 a' ]+ i. h' N0 C}
1
2
3
4
% G+ I9 D% z1 j9 C$ W% B8 V+ @$ t5
6
7
8
; T- e# a8 z1 |4 t9
10
11
12
13
14
15
16
17
5 B1 T5 @; D5 g% F18
, {7 X3 {  S* H) c6 x19
# [  H) U2 \6 |$ K2 A3 p/ {, o20
3 t" W$ Q& W3 L: H% u21
22
23
24
# ]" V& o# H" s2 y/ t# U  A+ F25
3 N) \! U) B" [6 k& {; y26
' m% T' m, V0 `7 d( s3 B27
6 D6 m9 v6 w# G( e. {9 m! B4 x28
2 r. B" }% y& \, e: o0 e" a29
8 t  z9 o% ^( u7 a30
31
32
33
34
8 s- a( v/ h. s2 y0 [- q9 W希尔排序
' ?8 g% |, r; \) p简单解释：
希尔排序是插入排序的改进版，我们理解一个叫做下标差的的东西，也就是下面那个图中的增量d，初始下标差为arr.length/2，然后继续/2，对在同一下标差（相当于把这几个数单独拿出来了）的若干个数进行插入排序即可。
6 ?. J  ?8 p) _1 Y! w- w% Q; A: K
" T) E/ u: I4 T& M

' h. C3 K) ]% C# ]. _9 D
9 B, d, ~6 ^3 q: h

完整代码：


package com.keafmd.Sequence;


/**
* Keafmd
0 X2 X0 ]6 P' `# u" i *
* @ClassName: ShellSort
1 ?+ y3 R* |, S5 ^2 S0 s7 {3 }$ z * @Description: 希尔排序
" f! `9 `& `' |- t * @author: 牛哄哄的柯南
. {! f# ?+ L8 z) B* c, T& K) w * @date: 2021-06-24 10:39
& ?6 m: ~1 w+ f* i4 ^ */
public class ShellSort {
4 R7 C+ \7 n7 M! i! y
, V$ a, v; z, j- r- b$ l
4 _' j3 O0 C# d# b    public static void shellSort(int[] arr) {
        shellSort(arr,true);
, H9 A* P6 T! _! [    }
6 ]" k4 }7 v. S$ |

& y8 T' M3 ], y$ Q2 @9 D5 I, V3 {    public static void shellSort(int[] arr,boolean ascending) {

% p# V& t- c( B; V3 @) A
        for(int d = arr.length/2;d>0;d/=2){
' I, N$ L- k' w+ r5 {8 [" z; {

            for(int i=d;i< arr.length;i++){
! G/ Q3 X' m2 \) O                int temp = arr;
                int j=0;
, x6 ?: [, D) _- b( W9 E                for(j=i-d;j>=0&&(ascending?temp<arr[j]:temp>arr[j]);j-=d){
                    arr[j+d]=arr[j];
. l( m4 z) H' T2 ]                }
                arr[j+d] = temp;
            }
        }
$ ?3 Z% Z. H% |, t7 U

% T( T+ w) p* k% c; b    }
}
1
2
" T6 I  v$ G* @6 A! F3
4
5
% B" c8 q/ A" b( y6
+ h! e% A1 r& J; U$ K# n7
* p/ U8 l$ Y/ m' s# m8 K- y8 K8
9
10
7 W5 ?4 I3 f4 u# ^; n& P11
, D; T5 }; W2 N+ F$ ?12
. |, G! d4 p  `+ M: {. _13
14
7 {  P' z( R% c9 Q) C! b- ]/ T1 c! X15
16
6 y+ [% E8 L0 T' N$ u2 ?8 S17
18
19
) C* f  O1 M; |* M& H5 u/ t20
21
! F6 n) j& ?8 m5 l1 J. t3 h22
  I$ ^9 _* o( [23
24
25
26
, t  Z  H/ \! L5 J; q# X27
28
29
30
31
32
* G' w/ `8 B8 K% i; B6 R& x& R4 i% O计数排序
9 w1 a& h4 U8 U8 E; Q  _5 r  t简单解释：
4 \+ e0 a( Z  n2 m0 S: D这个排序算法看名字也很好理解，就是就是额外找个数组来计数，然后在这个数组从小到大或从大到小把数取出来即可。

8 J1 ^4 f) k; S# {4 L
2 ^. l) K; ?) }, D# ^3 Q: ?0 o
" Z9 r( p! |+ T$ l
1 r  f0 n7 ^3 Y5 K& N
! v  s$ y* }/ V/ l+ q/ L
完整代码：


package com.keafmd.Sequence;
4 ~: S: U* W4 {9 P) c
2 a6 Q$ i5 X/ w( K7 H3 S& G  X' a
/**
* Keafmd
*
* @ClassName: CountSort
* @Description: 计数排序
* @author: 牛哄哄的柯南
; u* Q# D) e8 k5 y$ p' c * @date: 2021-06-24 11:31
- w2 l# y/ ]: k9 V" w$ n' i7 u9 S */
public class CountSort {
: X% C- z3 w" X/ Q' m- B

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


0 c4 x4 X& c4 ~; M  @    public static void countSort(int[]arr,boolean ascending){
        int d,min=arr[0],max=arr[0];
) e- w5 b) t( H( B9 o0 D8 T
- j5 D0 r1 ?# B' }* p4 N
7 F9 T" y4 e, X; n/ r0 a: U# t        //找出最大、最小值
        for(int i=0;i< arr.length;i++){
1 s/ M4 R* K* l, D* V$ P+ O9 p            if(arr<min){
" y. t8 ]  |/ g1 s' s                min =arr;
4 N* ]4 p& g( Z* i4 H            }
. }% E, l2 v4 o/ k; ~7 z# U9 u  I            if(arr>max){
# i7 m7 u: [" d' d# P* d/ n                max = arr;
            }
        }


        //建立一个用于计数的数组
3 n4 T  F. E$ {+ T        d = min;
  b9 M+ a! B6 A! H0 K3 c. e* Z        int[] count_map = new int[max-min+1];
        for(int i=0;i< arr.length;i++){
            count_map[arr-d]++;
  q7 C7 g1 J. r8 P        }
) \$ ?8 j8 x6 z# J) d

        int k =0;
% S  c8 x" [$ S- x! ]% [( o3 s4 }        if(ascending){
/ h; }% Q) R* p            for(int i=0;i< arr.length;){
                if(count_map[k]>0){
                    arr = k+d;
) d- \5 m' p# w; i7 F5 d2 @/ A                    i++;
                    count_map[k]--;
# G) \% m: u  J7 N1 {: `' o                }else
" C9 {/ C- |. C3 D/ I0 K5 K                    k++;
            }
: W+ M) S. U3 P        }else {
            for(int i=arr.length-1;i>=0;){
4 Z+ g; g, }) {4 f/ A3 f                if(count_map[k]>0){
" u0 g2 j& A0 e. _3 v6 @; l                    arr = k+d;
. l4 p" R7 ]. R7 u                    i--;
' S$ Q! r; \- Y% U                    count_map[k]--;
0 ]' J. N' @; s* l6 H; b                }else
: @0 H. E& J0 z) |, |3 L' l1 ^& D                    k++;
            }
2 [1 q8 N% V5 X6 x* ^& h        }
3 S0 D- I1 t5 w! n( z
: x$ o9 [! ^' D4 ~
    }
0 s7 ?- n& B+ r  k( P/ z9 b7 R0 [% l}
1
2
3
4
5
8 Y# l; ~' h+ R  M6
7
8
9
10
( U$ v  k% D, n6 J: O5 U7 K11
/ x! T  G0 @% l3 ~) i2 o3 O12
13
14
15
" G9 n6 B, ^- @5 I16
17
18
19
20
3 U, w, z" C( d. v( L0 K) i- W21
% L6 r; T9 ]8 m4 ^22
23
4 D9 t3 T+ Y1 b5 y2 b3 z24
- b5 o/ a1 f( Z8 X25
: |7 n! V. D- i- W; V26
27
28
29
30
31
32
33
* }0 X, O- c8 S" `34
35
2 m4 d. V' a2 |. V! m8 P36
37
38
39
1 q! @! F- z3 a$ C" V+ ?" o9 w: z40
6 X- Q3 y' R: e/ h/ u0 @4 r/ ^: {' ^41
42
' l( l1 p( h9 f  Z43
, T3 l; w% z9 \  B2 j" l* q6 |44
45
& k9 c' y, j# z, V4 z  g& `6 b46
# b0 {$ u& O) e6 L4 E+ O47
7 [, ?, ?$ Z; r! H3 i8 ~5 r" c% U48
49
50
51
+ v( x. ~4 e& O# Q52
; O1 v0 ?( z# @53
! c! b( V  }9 M) C. q54
55
56
57
6 j; v  x  A* y4 h58
- w/ A3 W& w+ P59
$ K7 P. r, w* k# K* e桶排序
简单解释：
就是把一个数组分成几个桶（其实是几个区间，从小到大或从大到小的几个区间）装，然后让每个桶（区间）有序，然后取出来放一起就可以了，相当于把几个有序的段拿出来放一起，自然还是有序的，当然需要是按照区间的顺序拿了。

, z- S2 Y" S1 `. {/ J
( G- U; J4 t% T: c" p
' |" ]: z6 k2 b2 i
: D  u, w9 `: ^& ?5 o+ h
! T7 w- ~+ @2 C, u+ V1 ?8 C$ w2 n
2 d4 ~9 c) t& I( Q完整代码：

: Q+ B1 M! J/ h) U0 U
package com.keafmd.Sequence;


2 {4 }1 e1 Q  `2 e6 h0 Rimport java.util.ArrayList;
import java.util.Collections;
5 Q: q' B5 G; i& n

: [; m8 N7 o% N) Y/ b$ B/**
2 @2 V' q( ~% P5 U% x" e * Keafmd
/ b$ m' Y- ^0 x% X9 S *
9 O9 L5 _, V/ x, y+ b * @ClassName: BucketSort
* @Description: 桶排序
- v& s. k9 n: r* F& q) d$ s * @author: 牛哄哄的柯南
( V' S4 r4 U; `$ J * @date: 2021-06-24 13:32
*/
public class BucketSort {
9 h4 u8 J5 u4 O* k) \& S4 Z8 x+ v
! o, k* c6 T8 v2 N
    public static void bucketSort(int[] arr){
        bucketSort(arr,true);
    }
9 K* S  f" k  m* V1 W. s
3 O/ r$ E7 C$ o; L2 u
2 S" ^8 Q& f; M4 m" p9 f0 o- U( i    public static void bucketSort(int[] arr,boolean ascending){
        if(arr==null||arr.length==0){
            return;
* Z7 Z. }8 U& s- F8 A+ f2 s6 Q        }
$ Y0 |' A; n( X2 S' |# O        //计算最大值与最小值
        int max = Integer.MIN_VALUE;
        int min = Integer.MAX_VALUE;
        for(int i=0;i<arr.length;i++){
% P0 k5 p  T1 D" [0 s, Z            max = Math.max(arr,max);
( Q+ b9 s# [! s% x3 e            min = Math.min(arr,min);
        }
: N" G7 w$ }# }5 X
! B3 M1 x" ]4 K7 e+ d3 O
        //计算桶的数量
        int bucketNUm = (max-min)/ arr.length+1;
        ArrayList<ArrayList<Integer>> bucketArr = new ArrayList<>(bucketNUm);
6 W9 }% e$ K) y  Q. Z) a( F3 k- \        for(int i=0;i<bucketNUm;i++){
            bucketArr.add(new ArrayList<>());
- K3 ]$ Y: O# ]; {: G3 o        }
! I, v$ a6 @3 P5 h5 `6 C( m2 j2 P% r

        //将每个元素放入桶中
        for(int i=0;i<arr.length;i++){
- I" n' C7 O6 B, Q/ P0 Q5 D            int num = (arr-min)/ (arr.length);
            bucketArr.get(num).add(arr);
        }
; S! o8 A" S' e; i) S! d; O
! F& m/ D" @' Q! @* V6 N" J
        //对每个桶进行排序
, R; B; {, M& ]$ i/ a4 k2 z9 \        for (int i = 0; i < bucketArr.size(); i++) {
            //用系统的排序，速度肯定没话说
            Collections.sort(bucketArr.get(i));
3 W4 G' w' M3 A. g" N2 N+ e6 x7 M        }

. |& p+ @" A/ m
        //将桶中元素赋值到原序列
& {; m6 n% t$ m9 X        int index;
) V  c" z& h% k( {, u) j        if(ascending){
4 U9 o: c" R# F, C) W- T- d4 q2 o1 {            index=0;
2 d4 ^+ R1 \# v8 I        }else{
; U! g4 H: i" E6 O            index=arr.length-1;
6 V/ Y$ y, R: T1 }, o9 _        }
3 f5 Y8 l/ K2 w" j/ i4 t% S

        for(int i=0;i<bucketArr.size();i++){
            for(int j= 0;j<bucketArr.get(i).size();j++){
: O+ [1 b) w$ _5 Z2 a                arr[index] = bucketArr.get(i).get(j);
: X* W) {$ u9 A; M6 z                if(ascending){
$ P, G- i0 X7 e6 ^: }5 _8 b                    index++;
9 s# v' O" q; z  n% J                }else{
                    index--;
                }
# Q: B- v. v+ K/ Y4 j" O9 N            }
$ ?) s- ?3 c) Y+ s: B9 O- i" u' c
8 w& g& X3 D/ t' ~. ?6 v
        }

4 T  O  A/ `7 q1 f
5 j. ~, I6 E  ^4 p2 @+ [( [; b' X% x    }
/ c- H# N' T/ G# |" J" O" |}
3 Y% h* o0 D* c: |1
* K8 L( i; }! h9 K5 ?# l( m2
3
! U. @& _! {- L4
5
- _* V  ^4 v9 E5 w- m6 E- Y2 }6
( z+ o( H) m% N0 H3 t. B" f7
8
9
$ f2 I6 Y' ~/ B: @& K4 [5 X( u10
" e4 R  R- Z* |; m11
12
13
) F, k) v; J7 ?2 ~14
15
16
. ]' t% e. B& X" X2 ^8 m& g/ g! M17
18
19
# U- X# g0 H7 F8 k20
  E/ q1 o) U$ F$ |' U& O* b2 U5 j21
22
$ b2 k' E0 W" d; |23
" ~! n7 ?  {# U- C) l( E24
25
7 a- G+ _' s4 T3 C, v$ R5 Y26
$ O2 a* E1 _$ \7 _27
28
5 {1 a& \- Z9 _29
30
/ I' H1 p- L7 J7 x# e' C: C31
32
+ ?( |2 {0 L& j0 A33
9 M$ c" U9 d& d* a7 R34
9 v9 \# F, O4 }0 l) Y1 J35
, x' ]  h3 o; u6 x  D36
37
38
4 `% n' a7 _! ~% i39
40
0 R; ~5 Y  Z: g0 j0 K+ Y41
42
43
44
45
46
3 t5 h% }  z& ^# O, M. \& k5 l47
48
49
* |4 X' [* v: T- j4 c: a- n2 h50
51
+ |4 \& N9 w% t6 d! N' Z6 z- r1 I52
53
+ y! O" Y+ {+ m54
55
1 e+ V, G% ]' ^' ], O% o4 W3 U56
57
3 m2 L2 \$ k. Y% U7 X4 j  J$ _+ q9 d58
59
60
61
1 Z' ~. d8 J5 ^+ W1 V1 t62
* H6 q9 A  L5 m9 t* a2 ?63
64
65
% w' D7 V4 r9 {! ~' i: A! T( f( q66
8 }6 `" w" x0 z, }8 E8 k& T" ~' g$ }67
# Y: O  ~4 g$ y2 t$ k68
69
' x  F5 x: ^6 Y2 p$ t70
+ s% [1 ^5 |- n2 R' A( }4 G71
+ Z& c, A" Z9 l8 C" z72
基数排序
6 e/ g: j9 R. m简单解释：
首先说一下，我发现好多人写的基数排序只能排序正整数，其实只要处理下就可以排序含有负数的了，就是我们排序前先把所有的数整体变大（就是减上最小的负数，也就是加了），都变成正数，然后排序好之后，在减下来（加上最小的负数，也就减了）就好了。
基数排序就是按数位排序可分为LSD（从最低位[也就是个位]开始排序）和MSD（从最高位开始排序），下面写的事LSD基数排序。
( I: B' C5 i8 `& J" z基数排序就是把数按位考虑，让后我们一位数只能是[0，9]，就是我们在考虑某位（个位、百位· · ·）的时候就只看这个位的数，放到在[0，9]相应的位置，然后顺序取出，最后再按其它位这样操作（上面说了要不从低位开始到高位，要不就是从高位到低位）
& b! E! I; S* X' L) I) Z- s4 r! h



0 R% _! E# `6 ^" J1 l9 _3 I

完整代码：

2 o* X% j  k# y  k: Y
package com.keafmd.Sequence;

2 B# g6 Y3 n$ x! d& z3 d  a
/**
* Keafmd
*
* @ClassName: RadixSort
! Q: y: f: K) ~7 } * @Description: 基数排序
* @author: 牛哄哄的柯南
* @date: 2021-06-24 14:32
  k: U& e$ @+ p7 r: v3 U */
public class RadixSort {
' l* f+ e$ B7 _/ R! S7 U! W- n$ @    public static void radixSort(int[] arr){
0 Q+ A) l  p! ~; R        radixSort(arr,true);
    }
5 j% @: k! s8 D$ Z4 i; F    public static void radixSort(int[]arr,boolean ascending){
  @3 q( o/ D0 Q3 \        int max = Integer.MIN_VALUE;
        int min = Integer.MAX_VALUE;
7 G. e7 Y' Y' S3 a        //求出最大值、最小值
& A0 C! h% Z+ Q0 \+ Y8 c/ F        for (int i = 0; i < arr.length; i++) {
            max = Math.max(max, arr);
            min = Math.min(min, arr);
# D2 q4 M8 F0 @; x. r; y1 \. X        }
, @( z6 [3 T7 R* ~* C4 C! U        if (min<0) {        //如果最小值小于0，那么把每个数都减去最小值，这样可以保证最小的数是0
            for (int i = 0; i < arr.length; i++) {
                arr -= min;
  F( C- n3 R2 A            }
            max -= min; //max也要处理！
0 X8 A/ Y/ J5 B5 ]5 ^3 n4 K% _3 N! m3 p        }
- \; d8 ]7 o0 c# e  d9 r1 c        //很巧妙求出最大的数有多少位
7 N. p' ?8 r! q/ F' I7 S        int maxLength = (max+"").length();
        int[][] bucket = new int[10][arr.length]; //一个二维数组，一维代表0到9，二维存放符合数
' E! T9 p* F, ]% `6 z  d) K; T        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++) {
8 R3 F) ~& u6 ?                int value = arr[j]/n % 10;
                bucket[value][bucketElementCount[value]] = arr[j];
) {$ ]' I/ i0 ?: D( b                bucketElementCount[value]++;
# A9 ]0 F# |4 W' n- g  j# h/ W            }

! `! A9 b! s7 T7 h- a& P
            //升序
% ^7 q* O# c% u6 ^: A            if(ascending) {
0 f2 r/ d, i' ^9 ~; @! V: o                int index = 0;
                //从左到右，从下到上取出每个数
                for (int j = 0; j < bucketElementCount.length; j++) {
                    if (bucketElementCount[j] != 0) {
" T  ]7 ~/ h/ e& B                        for (int k = 0; k < bucketElementCount[j]; k++) {
                            arr[index] = bucket[j][k];
- E- _) z. E- [( h                            index++;
1 s9 C$ p; [" [; y+ w& T, ]: \, b& L                        }
                    }
                    bucketElementCount[j] = 0;
                }
/ F' u" X4 m; d. k8 C) J0 }            }else { // 降序
: j% y1 Z0 i7 o5 n, W! `                int index=0;
                //从右到左，从下到上取出每个数
! T! i: q2 s4 g9 b3 J) v                for (int j = bucketElementCount.length-1; j >=0; j--) {
1 q4 A3 ?* C$ ~/ t9 w                    if (bucketElementCount[j] != 0) {
                        for (int k = 0; k <bucketElementCount[j]; k++) {
                            arr[index] = bucket[j][k];
. `8 T/ r( n. {                            index++;
9 q$ Q$ q) E9 |/ s8 Y                        }
9 K8 c4 z  o4 }: D+ ]: ?                    }
                    bucketElementCount[j] = 0;
                }
9 z8 K1 [' [3 y: G1 O            }


1 a+ C$ ?6 C' c6 _8 k

            /*for (int i1 = 0; i1 < arr.length; i1++) {
% Q; F0 g6 u- X! g                System.out.print(arr[i1]+" ");
8 E3 r8 i0 q5 Q, i            }
            System.out.println();*/
- V5 M+ D4 L) \' S* G1 O

+ q% @  }# I/ ~( }

% ?0 A4 j4 @& H7 ~, D
8 {( n: t# K1 `" g5 l
        }
        if (min<0){
/ c4 G* s, s" S; R; U            for (int i = 0; i < arr.length ; i++) {
3 Q/ b( n* m7 O9 G                arr += min;
/ R4 M, ?# Y6 Z6 s* t. a            }
) D4 `- a; Y0 G        }
2 U" B* P- @3 a6 S
2 i1 s( M' I2 I; u! o
    }
6 t" j5 ]( |9 W0 A( r. l}
1
2
3
4
5
6
# T* b' J+ }  k3 l; O7
8
9
, ^& f' f/ O8 Z# d1 n10
11
12
13
14
15
16
  P1 N8 K( F/ l! c) `* C* T17
18
19
20
21
22
6 Z6 ^5 t+ }2 s. p! h7 C1 L23
24
/ _' J# r2 u6 d7 Z25
26
; ?" r! N( o1 b+ Z" i1 w$ |27
3 l" m7 U: S5 [% C+ E0 s28
  M9 V. w. b7 D$ }# N  @29
+ ?( B! |9 J6 J30
5 Z2 r/ z/ I  T) e31
32
33
1 ~1 F+ V4 Z2 \1 C1 R+ l1 D0 x34
0 L) B/ `3 D$ w35
36
* u4 O/ u: P! ?0 T37
( ]( u: G8 ?# w% Q) H. G38
39
40
41
0 g9 u8 u7 K$ u. H# b* B7 S1 v42
43
' n3 C  f0 |& m1 s4 g44
! i* R. G( t& F, O1 j7 b: Z. _) i" Y45
46
47
48
49
3 C& W2 |5 ~" F* b9 H! w50
& ?; P1 ^1 b$ l" T* d' n" x51
52
53
' R7 m2 u# P: m" K54
, s& S8 l* R9 K. e9 R' g& i1 \55
56
( d/ E  Q: {( n- @0 G" H' n/ {57
' E& s# v, R. a' z. H- i" v58
59
! U  c8 ]+ e2 U# ?60
% K- v2 V3 q' J" @' U61
62
* M2 O8 x! A2 p5 ]$ N/ I- O0 p63
64
65
  a0 e4 l: `8 C* f" N3 a66
67
1 c9 O6 @& q. _* b/ o68
' J; S& @# M: h0 p) F$ c69
/ Q2 q: j+ G9 A! ^( ^1 b$ t9 f# i70
# E2 a% p0 K6 l8 e71
72
73
# S" o6 l6 W3 Z9 L4 v74
0 _2 ^5 ^. l2 c0 @75
" C8 f3 h4 X/ P5 s' H76
77
) \) B/ Q: R( p. O/ h78
79
4 i* D, z& P# o( q7 j9 Y80
$ g( U8 r" U* N  Z; k# N1 y81
5 v4 E# Q: C! P2 J; ~82
1 `) \$ F& i# ~6 H/ m( I83
  g! Y- w% L; w0 z9 x完整测试类
package com.keafmd.Sequence;


import java.util.*;
: Z0 C( @& Z1 k; Wimport java.util.stream.IntStream;
import java.util.stream.Stream;
' a4 W9 J6 H+ f' _( g* W

/**
* Keafmd
* B/ J. o9 L( P6 b) e7 T( _ *
- V! E4 w" b5 C. f2 A * @ClassName: Sort
* @Description: 十大排序算法测试类
* @author: 牛哄哄的柯南
9 A& s( o' U- p) w& d1 A: O * @date: 2021-06-16 21:27
, H* Q$ `( ]1 S0 _4 t */
& Y5 O% t6 q! f. H& R4 l0 t! ~public class Sort {

2 ]0 H9 H% J" \$ l: s- n' _2 C0 g% P


    public static void main(String[] args) {

+ O2 A% {1 k" J* P6 c
        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;

2 i) T- j3 [" e  b5 ^  E
        //利用系统Collections.sort方法进行对比
  @% R7 E. \4 v; }0 ?* T2 F
5 ?# I* y6 ?0 r0 ?' T: C$ H
        //将int数组转换为Integer数组
        //1、先将int数组转换为数值流
; \6 @: v7 ]9 g5 Q: l        temparr = nums.clone();
' d* y! v2 Z' g' ]0 V        IntStream stream = Arrays.stream(temparr);
! n" M7 o* u2 l8 H9 A7 ?        //2、流中的元素全部装箱，转换为流 ---->int转为Integer
/ m5 q  n$ Q7 W* @' S        Stream<Integer> integerStream = stream.boxed();
" [/ t/ E; ?6 k3 u" W        //3、将流转换为数组
! I! c: s: q9 B9 w3 _7 u$ r' `1 B3 U        Integer[] integers = integerStream.toArray(Integer[]::new);
% V  U: i4 s+ O# X/ @/ o5 }& d        //把数组转为List
        List<Integer> tempList = new ArrayList<>(Arrays.asList(integers));
        //使用Collections.sort()排序
        System.out.println("使用系统的Collections.sort()的对比:");
7 b. ^+ z) K$ Q3 ^

- L8 e  d: Y! e: l( Q: p4 b- i        //Collections.sort
        Collections.sort(tempList, new Comparator<Integer>() {
  k0 a4 ]! B( \" ~- u8 y2 c            @Override
' s" ^, O. _! |            public int compare(Integer o1, Integer o2) {
                return o1-o2;
                //return o2-o1;
( O5 s0 i5 J  t4 D4 v9 |            }
        });
8 }- w: B$ J+ z2 Y/ `6 J! c1 @
9 \% b( r2 x+ R1 |
        //tempList.sort 也可以排序
       /* tempList.sort(new Comparator<Integer>() {
            @Override
) _6 O+ B' _) Z% K3 v+ d/ c$ P; t% Q            public int compare(Integer o1, Integer o2) {
                //return o1-o2;
# y, M6 ^+ G8 g' o1 T' p  x* X                return o2-o1;
6 S( l$ t$ Z+ Q* z$ z3 [" z            }
        });*/
$ E" o" }- O/ L4 }
, m( y, R* O+ v5 L! l
        //遍历输出结果
3 \1 i$ F/ G& u3 v, z/ a1 c" n        for (Integer integer : tempList) {
            System.out.print(integer+" ");
( m2 k3 V. Y# L2 [+ w) i        }


9 X) Q& v8 w8 @        System.out.println();
  O$ B: M$ e' X% G4 Z9 h

1 A" G2 h( b0 }8 K& F9 ?4 i' Z        //测试冒泡排序
% _0 ?" X0 N3 G9 H' e" w        System.out.println("测试冒泡排序:");
        temparr = nums.clone();


        BubbleSort.bubbleSort(temparr);


        //降序
( }9 {+ B+ P, Z  j4 K# }        //BubbleSort.bubbleSort(temparr,false);
9 ]  r5 x+ b, J5 A. q" g* q8 x

        for (int i = 0; i < temparr.length; i++) {
) _% f- L2 `% L+ v6 @, L0 I+ h            System.out.print(temparr + " ");
; F+ N" @0 U( [9 ~1 C1 ^3 {6 e1 k        }
        System.out.println();

5 n2 c9 `- q& m% X# g$ e+ d+ U
3 Q( p1 G  a% x& \  }- |: {- G) c        //测试快速排序
        System.out.println("测试快速排序:");
        temparr = nums.clone();
        QuickSort.quickSort(temparr);
        //QuickSort.quickSort(temparr,false);
        for (int i = 0; i < temparr.length; i++) {
4 V# n' [4 u5 M' U* S! G' c            System.out.print(temparr + " ");
        }
( X7 k9 ]9 H- M  P2 I' O        System.out.println();


0 A2 T0 b+ Q. p4 N5 _3 ~; A        //测试直接选择排序
        System.out.println("测试直接选择排序:");
        temparr = nums.clone();
        SelectSort.selectSort(temparr);
        //SelectSort.selectSort(temparr,false);
: P. t2 g% H: j- a3 r        for (int i = 0; i < temparr.length; i++) {
! |5 p7 _5 _1 }3 V+ [' h            System.out.print(temparr + " ");
1 @% x7 [% h# W8 B- e3 E& B        }
        System.out.println();


        //测试堆排序
2 H, l# T- H' M  s& X/ q5 G. c        System.out.println("测试堆排序:");
* z3 `7 O5 [, y3 ]% l/ E        temparr = nums.clone();
        HeapSort.heapSort(temparr);
        //HeapSort.heapSort(temparr,false);
        for (int i = 0; i < temparr.length; i++) {
            System.out.print(temparr + " ");
2 ?# p) E/ J9 h% L! h* K        }
        System.out.println();
# C7 j  H5 i! O7 X8 H" R) z
" _8 d9 k: M; y" q4 c
        //测试归并排序
        System.out.println("测试归并排序:");
        temparr = nums.clone();
# Z4 \$ A5 }: i, t        MergeSort.mergeSort(temparr);
        //MergeSort.mergeSort(temparr,false);
        for (int i = 0; i < temparr.length; i++) {
            System.out.print(temparr + " ");
2 f1 z) m2 j, a) A* T3 ]5 T        }
- n  V) y% M5 O% M/ y        System.out.println();

% L, d$ v% h* ?  a* I. T1 k
" O! n# D8 v' [  S5 C        //测试插入排序
' Y! E& g; ^; F# A. N0 ]6 P        System.out.println("测试插入排序:");
        temparr = nums.clone();
( l4 w$ T; y2 K/ p; ]9 [/ i        StraghtInsertSort.straghtInsertSort(temparr);
        //StraghtInsertSort.straghtInsertSort(temparr,false);
        for (int i = 0; i < temparr.length; i++) {
            System.out.print(temparr + " ");
        }
        System.out.println();

: Z( e& v( d9 P/ u

2 `' q' O4 D( {1 z- D1 P* `
        //测试希尔排序
        System.out.println("测试希尔排序:");
        temparr = nums.clone();
        ShellSort.shellSort(temparr);
# W& \4 U% w2 g/ V  w; q        //ShellSort.shellSort(temparr,false);
8 h1 i; E3 G' x: f+ D! s$ H        for (int i = 0; i < temparr.length; i++) {
) C  X1 j$ j- h. W( W) D$ ?$ l            System.out.print(temparr + " ");
        }
2 |' S1 u+ @3 K        System.out.println();



  j: J( e, j# `4 R
        //测试计数排序
# N! X* D) ~! {4 d7 [. b        System.out.println("测试计数排序:");
        temparr = nums.clone();
        CountSort.countSort(temparr);
        //CountSort.countSort(temparr,false);
8 Y) \1 g' A! ]! _) S5 h4 C        for (int i = 0; i < temparr.length; i++) {
3 F' R9 G. C2 c: W9 z9 i1 P! z2 L            System.out.print(temparr + " ");
# g/ e+ g# I( s$ B7 W        }
        System.out.println();

. @! i' ~% L2 k9 H7 ?6 F
7 a. @" @; Z( B& D5 U  b  t. n
' d1 S0 I1 Y% F' ]) ]& F: N
        //测试桶排序
5 C7 Q5 i. I, t: _# G) N* m        System.out.println("测试桶排序:");
* y2 ]: ~) t4 W4 q        temparr = nums.clone();
+ y  D6 w, P# [) D6 f- e        BucketSort.bucketSort(temparr);
        //BucketSort.bucketSort(temparr,false);
        for (int i = 0; i < temparr.length; i++) {
& S3 M6 a1 B4 L' Y            System.out.print(temparr + " ");
        }
- V8 N- ^7 }/ F& x$ C* [9 D        System.out.println();


        //测试基数排序
# Y" g, j; ]5 G1 f        System.out.println("测试基数排序:");
" l2 P5 n. G+ z1 ?        temparr = nums.clone();
  z  Y  a3 J% n% Y. n        RadixSort.radixSort(temparr);
: X$ Y) J! }( {1 t/ g        //RadixSort.radixSort(temparr,false);
        for (int i = 0; i < temparr.length; i++) {
( |6 r' }. n% e$ E% L) o. `2 M# J) C            System.out.print(temparr + " ");
        }
        System.out.println();
0 ]7 _; ]8 J3 }+ R/ J. V

: e7 j5 s4 G1 V5 d8 O    }

# c2 T3 @% l( R/ O: U0 |8 v
}
) V. U/ l% [( i9 J$ i1
# k# j: g0 V4 V3 n' H, N2
, f) P" @  C2 g0 j+ k3
1 R+ a! _- O' d3 z: f. O4
$ _$ m8 o# Z$ Y6 k5
6
" k* s! w8 \7 W& V7
/ ?! V5 T# U5 J/ B- A8
* R: H, `+ Q  [( J% A9
10
  v0 ], o& Q; _2 i+ R: x11
12
13
14
- E  j! k5 |, ]4 i' y15
! h! T0 l; y! s. z- y& v16
: H! H8 Z0 G0 L0 X2 c" m17
: W* D6 f( s% Z! g18
19
+ ]$ s, y( J: M9 F20
( {( u! g- |2 C: S+ U3 \4 y21
& b9 b# ~) Y/ ^2 f3 X# G22
0 S, N# ~  N- _' F23
24
25
/ s) e) f! D9 W+ J. \# n/ f1 k26
27
( Z5 f9 O. B) g, \( R5 B) `: ~$ M- W8 V28
29
- |  p5 D6 a+ T6 v30
31
32
( u5 E. V6 C$ m33
34
35
36
37
* g, G# y+ b) W* z- n38
& ]& K/ d/ k1 v1 S! u. }% ?* b0 z39
40
41
0 P4 |0 z/ p) i/ Q$ Y- f42
0 o7 n. p1 q' A' b* G5 v43
44
: w) d2 V: L+ r! @1 i45
3 \; c( t, v: O  Z9 e( U( _. p46
47
: c+ L# J4 z' ^$ e* Y# A48
49
8 i* O6 `- W- G  P( U50
+ C6 a! y' V0 ~4 P- @7 ]  ^51
52
53
54
1 i2 z, C: N0 |8 N1 J- O8 G) o, U55
56
: |0 `* |: R7 \1 c) S$ s3 p6 u- w57
58
59
. \9 B' e1 u6 j2 o  n60
3 q$ L0 }( Y) j7 j# M, n! _61
62
+ i  F; b# @+ u: d# o2 U7 q63
, j- f- ^3 x" L( E64
65
. Z! ]) V, a8 u' x! m, L  R66
' l  X0 @% Z* N( r. ]# X% W67
" g/ V5 y1 t% b& {' q68
$ @* B$ I6 v7 C* R69
9 a+ u2 N% v/ v7 N70
4 ~! z8 ~% R2 K" f3 v71
1 l$ J# [: n7 l( w0 g0 }72
73
  N0 v3 B" D7 ]74
0 j2 H+ ^  z) L# w6 l7 n9 R75
% C1 [% L. V% L+ c0 _; k3 _; M# V6 \9 I76
. u$ M( {+ q' N77
* j6 k( g" g* @! R& q78
: e# G4 [$ u' ^* a6 g79
80
4 ~# l1 a. i  M# h7 A81
82
83
84
85
" u+ ^4 U' L9 D* P4 @* |* W3 K86
87
: K9 x5 m3 Y" I6 B8 L88
) P2 p; j6 e3 o" g& N89
& ^7 u4 B% d# x& u( y# z90
+ ?3 l% T; S1 ^, u+ w) `3 v91
- E% q- [- K* c; O92
93
- y4 \5 p3 S) [# |& J& ^94
95
" o& p# I! `# z/ J+ h! g& {9 l8 N96
2 |; k7 w3 ]6 M97
98
99
100
- a) [3 c% C" C& r101
102
; @8 @0 v3 r+ \2 ^103
! O4 J  V7 z6 O9 Z, D104
105
: E8 t. s9 q) s% n' b106
% Y' f* \6 O0 ~5 t9 c107
9 C4 h8 |* U* ?4 }108
6 ?; Y3 }+ i1 b+ g" p109
110
111
, f6 t+ B7 f. X) F3 u112
113
114
2 \- ~, @( F& ]  i$ h115
116
117
118
( i$ d. }+ a  J  P8 l2 l119
; h) c' g+ E- V120
) j1 l) ^; @. D121
122
7 \  e3 `, E/ o$ W5 H3 u1 {123
124
- n( |$ G  e" I# i, k& y; ^125
  J& O" c: u6 ]4 E5 a! ~$ a126
127
128
& z- U# E& q* b0 C/ [129
130
131
132
133
$ y6 ~+ d. y9 X' b) S134
135
136
3 L0 l2 A3 o. ?- ~5 M0 r137
138
139
140
# K4 e4 ?- S8 f: y! K) o+ d  z141
142
: D( \* i3 g5 y7 O0 R143
* Q; w% s4 a  y. ~! [2 \+ I144
145
146
  b2 K+ G$ B2 e8 n* ~$ t0 e: c1 s147
# H( X- x1 C2 I! S9 {" G/ m8 _6 u148
149
150
151
152
153
* c2 [* ]/ p: k3 d/ h/ ~7 i8 J154
155
, {+ c* [5 @" x8 R9 H0 o5 k156
157
158
159
160
. N% I) `) S/ f! l+ H" V161
162
163
* W# R  |2 M0 u4 i8 r164
" {% {3 {' s+ u! x' i+ a. K9 K165
  g) G  m% r. {4 `166
167
168
0 G9 p: Y$ ~( F1 c; j' q+ ?169
$ o4 N  z' I5 x- j170
+ N5 f7 [. C  l& }% e" T6 s+ t3 ^171
172
+ R- L+ I1 P  S4 M: D173
/ Y1 \0 \) C, z6 F  m每天进步一点点！
不进则退！


& f! L. F) Y( S版权声明：
原创博主：牛哄哄的柯南
( L3 M& L* a" y博主原文链接：https://keafmd.blog.csdn.net/
————————————————
7 I  u) O: d8 c( ~9 r版权声明：本文为CSDN博主「牛哄哄的柯南」的原创文章，遵循CC 4.0 BY-SA版权协议，转载请附上原文出处链接及本声明。
% j2 M# m+ R- d原文链接：https://blog.csdn.net/weixin_43883917/article/details/118193663
; E9 L3 D; U+ `* I& U) x

1051373629

每天进步一点点！
: {! w$ v4 D+ O2 P1 F