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

杨利霞

经典十大排序算法（含升序降序，基数排序含负数排序）【Java版完整代码】【建议收藏系列】
经典十大排序算法【Java版完整代码】
写在前面的话
( p# O1 Q& n9 p7 `; W十大排序算法对比
! e1 v& C0 R+ U  G' I0 r# V. y, h冒泡排序
/ H4 v' b' y0 H) ]1 j. W( }: j8 f, L3 V快速排序
直接选择排序
堆排序
) R, H9 r. z7 ?& H归并排序
插入排序
6 p% G, @1 j" t/ J9 t* R希尔排序
计数排序
4 e- a2 q0 V1 A0 [# L! i桶排序
) K+ |8 V+ Q- d; t( |- Q基数排序
完整测试类
写在前面的话
       虽然已经有很多人总结过这十大排序算法，优秀的文章也不少，但是Java完整版的好像不多，还存在某些文章代码存在错误的情况，同时也为了自己练手，决定把所有的写一遍巩固下，同时也真诚的希望阅读到这篇文章的小伙伴们可以自己去从头敲一遍，不要粘贴复制！希望我的文章对你有所帮助，每天进步一点点！！！


       我用通俗的理解写下对算法的解释，对某个算法的运行过程不是很理解的话或者想看比较官方的解释的话，单独搜索某个算法，看几篇不同的解释，就可以有自己的理解了，这里我主要展示代码以及进行通俗的解释！整起来，再强调一次，一定要自己敲一遍，这样才能理解的更深刻！
( d- G+ H5 Z3 E. c
' P' K; ?. `" N. j4 J8 O2 _
十大排序算法对比
; R' b* w. {( R  f/ F' a" o8 X

! i% h4 D9 M$ Y. p) `$ d* T/ W

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

冒泡排序
简单解释：
       原理就如算法名字一样，就像水中的气泡一样，每次我都把最大的或最小的放到最后面，这样总共需要n-1趟即可完成排序，这就是第一层循环，第二次循环就是遍历未被固定的那些数（理解成数组左边的数，因为每层循环都会把最大或最小的数升到最右边固定起来，下次就不遍历这些数了），两层循环遍历结束后，所有的数就排好序了。
7 |: [3 L' B# A# A% A: Z" S       两层循环所以冒泡排序算法的时间复杂度是O(n 2 n^{2}n
2
/ h' V' _2 \  W% ] )，是一个非常高的时间复杂度，我在下面的代码进行了优化，加了一个标志位，如果上一次循环未发生交换，就说明已经是有序的了，就不继续下去了，反之继续进行下一轮。
8 W- X+ q% i( ~. [4 V5 Y. `  g
6 K/ N' u# t. w- o/ V/ m
" |: ~8 g; E; t1 i& p) J8 C: Y

- C/ }% X! w8 n- d8 d1 ^' o. X
6 R/ ^. @7 {* i- c2 C: L
本文的图片来源网络，仅用于大家学习，侵权联系删除！（下同）

1 x2 Q9 x# J$ `4 q/ |3 V. O$ t
+ ]6 Z* }9 X; Q  m完整代码：


package com.keafmd.Sequence;

5 I7 A' h8 G! S$ G  W. r' e
' @! f7 a, U4 o; F/**
* Keafmd
*
* T( A7 W' q0 l# J" d9 b * @ClassName: BubbleSort
# [6 B" U' F6 K% i * @Description: 冒泡排序
+ J, L4 n+ d3 {6 p * @author: 牛哄哄的柯南
. \$ G0 g* z3 g6 A- h; _ * @date: 2021-06-24 10:31
*/
% p& J) V5 V( E3 u0 c0 Npublic class BubbleSort {

5 x) \8 x: [6 O) j) y% q/ Z
& ^) z5 H  d2 u" d) t4 w1 p    //冒泡排序
# V2 Z' _! z1 z  F    public static void bubbleSort(int[] arr, boolean ascending) { //exchange标志表示为升序排序还是降序排序
8 @4 y* l, K+ F0 _; T
& i  G8 w5 p+ Q+ C) ?
. z' A5 S! t) \9 o5 S* u        boolean flag = true; //加一个标志位，记录上一次是否发生了交换，如果是，我们则进行下一轮，如果没有，说明已经冒泡好了
3 c/ @* ^/ A' Q7 }5 Z! d' R, J
' ?! k" }& R& u$ m4 D  Z6 F
, ^3 o6 |) W: I        for (int i = 1; i < arr.length && flag; i++) { //控制次数，第几趟排序，只需要n-1趟，有交换时进行，只有flag=false就说明上一次一个元素都没有进行交换
# _% u& I/ L! J% N: `
6 J/ D1 h5 F" k; `: N
            /*System.out.print("第"+i+"次遍历：");
1 w9 G' n; `" \! w  I. ^            for (int i1 : arr) {
                System.out.print(i1+" ");
8 ]5 b6 {6 Q9 x+ i" j, J            }
8 x) i. I* P4 r! d            System.out.println();*/
. p4 W9 C7 x' B7 t  R& ^
9 i# |( c+ A/ M2 u% T1 q
            flag = false; //假定未交换

" t& M" W9 y0 X% E- |5 @
            for (int j = 0; j < arr.length - i; j++) {
2 S) ]6 w2 B7 S, d

% b% [4 u, s. ]9 `* R, L- d2 I, r                if (ascending ? arr[j] > arr[j + 1] : arr[j] < arr[j + 1]) { //控制升序还是降序
: n- X% ]! s! n5 n                    int temp = arr[j];
                    arr[j] = arr[j + 1];
% X- ?  {. ^& G# j0 M) \                    arr[j + 1] = temp;
                    flag = true;
/ q- \% H9 }6 u8 I1 H9 m+ w. _                }
# A: |9 N5 `  s

( n, Q9 j; e0 E1 g8 L( G            }
8 g/ t2 M! P' n0 @; F" u1 i7 J5 L        }
    }
) j$ m% x8 U% H$ e2 D
6 R; b# ^# v  q
, a& V( b7 e6 L" c- v9 P" h; w3 |    //冒泡排序 -- 默认不传参升序
    public static void bubbleSort(int[] arr) {
+ a/ D& n4 Y* n+ S+ ]; z1 s        bubbleSort(arr, true);
. _. J. f* k% ^    }
+ \9 g, o( }$ H. ?# y}
1
2
4 C# J- @4 D6 r3
4
5
( s4 \2 L  d( N, O6
7
8
9
10
11
12
13
" t& ?: N* Y7 J+ B14
15
16
) c0 L% G3 e! _9 e7 \' G17
18
19
20
- u) t' c, R3 a, U1 s6 y21
22
23
) T  [; t# z7 v+ C) Q24
- S( c0 w! C6 D. F* R) X0 B$ B25
% E! @8 C  `; W& i0 E. b26
27
28
0 f# j/ }; P2 U9 z  N. \29
7 T6 q& ], F7 @30
31
32
& x! e  _- l! i, I: Q0 y33
34
35
$ \7 ~7 Q% M6 A: t36
37
% r" \2 {6 H# x& F8 C6 E38
* c9 j% B+ y% Q8 _39
$ P$ \7 H+ [& B9 u! y40
41
  |" W9 G/ V- v( `+ n42
43
44
! u6 g8 E+ R: }7 o8 X* W% Z3 R$ t45
' z7 g8 ^8 T( O) N- w测试代码：
, R- S( r# c: {3 ]9 M
; X4 p: }' ]5 V' ^
! I. B4 ^; \8 A升序排序（从小到大）

& U- N) Q; s7 Y  M* y# T9 [9 B
/ ~/ s3 [  O7 f. j, |, G/ epackage com.keafmd.Sequence;
3 G* s& R; `- N, U# j9 U/ f

import java.util.*;
import java.util.stream.IntStream;
9 [+ f7 m. G0 ]import java.util.stream.Stream;

) r/ E+ w! P5 D( j' x& @% r( H: ~
. ~- f0 w9 @1 Y, w6 j/**
4 I) `1 R0 z6 ]. w' B1 e4 Z * Keafmd
9 b. y/ {, K/ [! D, i: a: ? *
* @ClassName: Sort
* @Description: 十大排序算法
* @author: 牛哄哄的柯南
* @date: 2021-06-16 21:27
*/
public class Sort {
    public static void main(String[] args) {


8 F  f7 A+ A; i# z, E# |% W        int[] nums = {12, 4, 25, 47, 58, 34, 25, 9, 99, 26, 1, -13, 162, 10093, -66, -1};
" B* ^/ Z( @) L& a        int[] temparr;

6 \0 S0 l/ G( b4 j: v, }  ^( w
        //测试冒泡排序
, q6 C' g. C) h6 J  @, s* w        System.out.println("测试冒泡排序:");
        temparr = nums.clone();
        BubbleSort.bubbleSort(temparr);
; e  Z4 B  q' u* j        //逆序排序
6 [5 f0 `2 Q" Y7 l% \        //BubbleSort.bubbleSort(temparr,false);
        for (int i = 0; i < temparr.length; i++) {
            System.out.print(temparr + " ");
1 O9 v" n* i+ f1 j8 j        }
        System.out.println();
! K% M( d+ S0 x- p# t# O
1 W% s8 [) c$ m) ~  m
) g7 `6 b; y5 P3 j    }
& t5 o4 l, W3 @  Z}
1
9 X. V- Y8 \( H9 m1 N2
3
1 t, A# k. R- \$ Y0 v$ b4
5
6 b, l* u/ l- Z5 O6
% `& i% C% g* N1 A7
: s# e. w8 N( I8
- x) s$ I0 I4 q6 d0 N% t5 D9
10
11
12
3 _/ h9 r3 \. `. G. S13
14
15
16
! o# n) m! I' B" K0 s0 D17
: D) n: [* E: N6 O  C! P18
19
20
. D; m, x- f0 W1 p7 J/ T, _21
22
8 l' a: a' f* Z& i23
% c# \! z$ o+ e0 ]) k24
" a0 Q1 u7 d  T# G- p1 K25
26
27
28
9 s2 D7 u- Q7 s+ r, P" i9 ]$ i0 U29
1 [/ u& Z$ j2 v* c30
31
; N" M( W) i5 |  {32
33
运行结果：

% |; a" z6 g/ \2 r
" z& s2 C% b. k5 {测试冒泡排序:
5 }/ d8 u3 ?9 d" S# @  {6 V' u' S0 p-66 -13 -1 1 4 9 12 25 25 26 34 47 58 99 162 10093
" Z1 ?* X- [$ n  m8 `1
2
降序排序（从大到小）
, D+ I0 \- F+ ~# n5 B* S% }% T4 n
2 i0 }: b3 n( Q3 W! X/ e! `
//测试冒泡排序
3 ]# i$ q# w" ^& t( `System.out.println("测试冒泡排序:");
+ ]* J- A8 @( w9 ^* dtemparr = nums.clone();
BubbleSort.bubbleSort(temparr,false);
for (int i = 0; i < temparr.length; i++) {
! y  p* t5 D( n: p2 c* k    System.out.print(temparr + " ");
0 s" J5 z8 S5 c2 y$ W/ P}
System.out.println();
1
7 n  E$ W! o8 n) L2
3
4
6 O; K9 O; |; K  R7 \. s7 z5
; y. [! s; J) J+ I  ?6
7
7 _1 K  f: R2 K% T, s& s9 P8
6 G6 u/ l1 }) X7 m# Y' O运行结果：


测试冒泡排序:
) t) t7 k! B* C3 J  l6 R10093 162 99 58 47 34 26 25 25 12 9 4 1 -1 -13 -66
1
+ Z! B: l" b6 f! J, _  s( P$ F2 ?2
下面几个算法的测试也就是换了下类名和方法名（换成相应的排序算法），如果想降序就在数组后面传个false即可。我就不一一复制了，我在最下面给出含所有算法的测试类，需要的自取即可。
8 F* z/ u/ q; h2 [

5 @& y7 r5 h% F5 [3 M快速排序
简单解释：
- y' P+ F* M3 a快速排序就是每次找一个基点（第一个元素），然后两个哨兵，一个从最前面往后走，一个从最后面往前面走，如果后面那个哨兵找到了一个比基点大的数停下来，前面那个哨兵找到比基点大的数停下来，然后交换两个哨兵找到的数，如果找不到最后两个哨兵就会碰到一起就结束，最后交换基点和哨兵相遇的地方的元素，然后就将一个序列分为比基点小的一部分和比基点大的一部分，然后递归左半部分和右半部分，最后的结果就是有序的了。
. d! D+ Z( C3 p: @, O7 e


% f) l- ~6 C. O2 J6 I  F
# r) G4 S+ D* v3 _" M0 T  ~

完整代码：


" y8 x& Z* e4 P/ `5 \3 @package com.keafmd.Sequence;


/**
* Keafmd
# [! k- E- M  d; r, Z) c& A3 B *
* @ClassName: QuickSort
* @Description: 快速排序
* @author: 牛哄哄的柯南
* @date: 2021-06-24 10:32
*/
( b# l9 w7 D8 F8 }& Xpublic class QuickSort {
2 g7 q3 {, Z; o  `
& w: N# ^. c) B9 q
0 ~' \5 z! d3 P' a& P    //快速排序
, k2 ]6 h3 i2 P    public static void quickSort(int[] arr) {
+ \/ |8 l2 `1 D4 w9 h' x        quickSort(arr, true);
1 Y  ]: r# u5 d+ H    }


    public static void quickSort(int[] arr, boolean ascending) {
8 t5 U0 @5 p- d/ O) L        if (ascending) {
            quickSort(arr, 0, arr.length - 1, true);
        } else {
            quickSort(arr, 0, arr.length - 1, false);
        }
    }

& f. b3 E! K5 ]# `, Y8 Z
6 x! O3 I4 U* F# m    public static void quickSort(int[] arr, int begin, int end, boolean ascending) {
/ l( x( g% Q  J6 O- c' j$ ?/ _        if (ascending)
            quickSort(arr, begin, end);
        else
            quickSortDescending(arr, begin, end);
3 U* G& f$ i8 f! L: s    }


    //快排序升序 -- 默认
8 y) `- k0 \; i6 T* t% [9 x' s; P    public static void quickSort(int[] arr, int begin, int end) {
        if (begin > end) { //结束条件
            return;
        }
6 Y5 P- k. a4 C% ]        int base = arr[begin];
        int i = begin, j = end;
        while (i < j) { // 两个哨兵（i左边，j右边）没有相遇
: u% r! E3 ^9 b1 s, a6 @# H            while (arr[j] >= base && i < j) { //哨兵j没找到比base小的
                j--;
            }
            while (arr <= base && i < j) { //哨兵i没找到比base大的
                i++;
, @; |# G8 f! f- ^* s/ K: v            }
            if (i < j) { //如果满足条件则交换
0 H( [+ d% ~6 k1 t                int temp = arr;
& g6 Z0 ^- W5 G                arr = arr[j];
/ q; z: }# Y- \* p" E" L                arr[j] = temp;
& w1 s- I# ~' y+ ~) O% T. N            }
+ E0 f2 c( \+ K8 V& v& ^( t- B" }

        }
        //最后将基准为与i和j相等位置的数字交换
        arr[begin] = arr;
        arr = base;
+ {* V0 b- t3 i/ J        quickSort(arr, begin, i - 1); //递归调用左半数组
        quickSort(arr, i + 1, end); //递归调用右半数组
& {) M8 f0 m9 _/ L+ Q  q

9 m1 t; f1 U( z5 @: \7 i# ]    }


: h# K) s/ K; F. }  P6 o8 _    //快排序降序
- ^1 f$ {7 |- i; w- q    public static void quickSortDescending(int[] arr, int begin, int end) {
5 g3 U; G* T) }' p5 R        if (begin > end) { //结束条件
2 c8 }0 I+ ~* e, j" m5 X            return;
        }
7 ~$ E, e4 Y3 `3 t8 ~        int base = arr[begin];
        int i = begin, j = end;
        while (i < j) { // 两个哨兵（i左边，j右边）没有相遇
0 a% [" |2 Q& B3 }            while (arr[j] <= base && i < j) { //哨兵j没找到比base大的
' U; S( a* S) i  N                j--;
            }
# S! S* f9 f# Z            while (arr >= base && i < j) { //哨兵i没找到比base小的
7 D: E" U5 I4 ~8 T. K4 m" R: N5 i                i++;
5 w9 V2 X' H! }0 P+ P            }
2 G6 T6 x( X* z% f3 p            if (i < j) { //如果满足条件则交换
  d" r( s- i9 i1 b                int temp = arr;
                arr = arr[j];
( A  ^( I( ~% [0 v" \, Y                arr[j] = temp;
            }


$ v  _* x9 B, |& d5 U( ]8 @        }
        //最后将基准为与i和j相等位置的数字交换
% R8 h: r/ g- N* T) u& [- Q        arr[begin] = arr;
        arr = base;
        quickSortDescending(arr, begin, i - 1); //递归调用左半数组
5 u) l, P. \  O- D% u        quickSortDescending(arr, i + 1, end); //递归调用右半数组

( K. O6 S( L4 I! Z! x( S# Y. ]* ?7 M9 H
4 v8 f6 f. y; |  f( G- ]% O7 y    }

5 x5 {- W; {% y* F4 o8 f
}
1
1 t5 I4 S: S& P7 g# [7 {- V2
3
4
5
4 Z! d6 M+ Q* P# y6
& s* ]: T% T7 f/ G: t7
- X+ c6 k8 l) P3 X) Z+ E; c8
9
10
2 z  r$ c; s+ t5 p# B* o11
% B2 |2 C" m; Y5 }) d' v3 Q( f12
13
- b9 b4 \; O. {  I# E9 m14
! Q  b9 l+ v+ j) v. {15
16
4 L5 f3 }0 W/ j; w. V( C% {7 V17
18
% S$ v2 g' n( h5 S- q19
, g3 Q% K/ N- g: ]  D20
21
22
/ Q6 c8 z. s; g' [4 s( Q23
24
25
/ _! j$ J  \9 W9 _5 T1 s: a26
27
% f. G3 P9 N, ]- C- |$ z28
29
3 [" c9 G7 V# e) c5 u30
$ k/ k: p0 P- m/ J3 s/ h2 g' o31
. n3 M( U6 H) P- ?7 x: l. u. I32
5 I6 @# ?3 z. w( ]( e3 W33
4 [" a3 V. }: a34
35
0 l& F; v- @) ?0 j( ~36
37
38
39
, Q1 b+ B& x( M  o7 P4 R5 D  [7 i7 x5 J40
4 I& J% o( |* q( n41
8 ^6 m, |& n) c* n6 t42
* v  x+ o  @. s$ y2 f5 b43
% W/ B; \/ X) w* E0 ?& B# d44
9 E' a& M5 J5 q$ X* @6 _% I45
46
/ X  E) O' L0 D6 T% s47
48
49
/ }, T4 i' K1 y9 T' q# f50
: H8 ?) k/ K! i# R. ~; T& J- ~' a51
52
, h; U' d7 H4 Q2 }# g53
5 G; g0 p* k$ I; q54
/ ~/ v1 X5 P- m7 C( b9 x+ r55
4 K8 c; j" i" U& S56
57
+ g/ U! E& Z$ _+ l5 d58
7 ^1 R6 u: s6 U5 N' r59
60
61
+ |* \9 ~9 {* {9 P; a62
63
64
65
/ Z. \0 ?& X4 x0 `/ Q66
( u5 f6 a' O9 ]% m: K9 c7 T, q, n67
# b: D& M4 S! P5 \2 D$ Y68
/ `  i0 g6 g3 j- O+ J69
& T! V' N! ^$ m/ ]70
71
72
73
74
75
% `& `8 d/ c/ U. p' H) Z- R( d; p76
77
78
79
80
# u' c1 U; O6 Z( f: C81
82
  H+ \: p- \" R2 F- L83
84
5 o- D9 Z! R$ }5 u' q85
86
6 B4 a: v5 p5 s! v9 F87
5 X1 s: i  k3 |3 i. _8 A9 U( Q1 v88
# W$ D  I( a: Z; |8 Z$ m89
90
, u/ `. Y1 e& l" _6 L91
/ b' `! _" u( k  b" t, F6 D直接选择排序
简单解释：
数组分为已排序部分（前面）和待排序序列（后面）
第一次肯定所有的数都是待排序的
从待排序的序列中找到最大或最小的那个元素，放到前面的已排序部分，然后一直找，不断缩小待排序的范围，直到所有的数都是已排序的了



3 b+ i3 d2 S4 S  O
. p. l- ~) ~, `# W
% {' r9 M# c& ~  ?- ]
完整代码：
" U% Y" h- `# i2 y

$ B: o1 j' |$ `/ p# I) S  Vpackage com.keafmd.Sequence;


/**
# [. P0 P5 O# J7 U! q; A8 R * Keafmd
*
9 y3 ~5 i* m6 i$ d. R6 } * @ClassName: SelectSort
1 d0 Z# x; h* }* q * @Description: 选择排序
2 C7 `8 e* \' T% H) T * @author: 牛哄哄的柯南
! A+ z& d, H* R! ?/ H( P" x6 D& k/ @ * @date: 2021-06-24 10:33
. e% d% B; H; K: Q6 X2 ] */
public class SelectSort {


    //直接选择排序
- _1 w% C7 k& p( V% V    public static void selectSort(int[] arr, boolean ascending) {
        for (int i = 0; i < arr.length; i++) {
# N3 G; w4 S3 U            int m = i; //最小值或最小值的下标
            for (int j = i + 1; j < arr.length; j++) {
                if (ascending ? arr[j] < arr[m] : arr[j] > arr[m]) {
; @! F% x+ g% I9 y! j4 ~                    m = j; //找到待排序的数中最小或最大的那个数，记录下标
                }


/ t: F9 j' m' A  l            }
/ C& M' f6 c7 y) \, R' L            //交换位置
! j3 L  D4 T  R8 |1 P            int temp = arr;
            arr = arr[m];
7 D! E5 K1 S  l. K! Y            arr[m] = temp;

: {1 Y% S# M5 N5 q# W' s
( {9 b1 R% {& m1 r        }
- @/ n" D8 h' p" ~6 W! L: k5 ]8 @+ l    }
# k/ y: ]" p' q5 ^5 w

    public static void selectSort(int[] arr) {
        selectSort(arr, true);
6 Z" \: @3 p! J: M( B- }$ c    }
}
, K4 |8 Y# ^+ ^5 w1
2 S; M6 }- _! H( ~, Q, @2
3
4
5
6
; u- g0 R. M( t  e! J7
- `$ f% U; K" X9 o8
. W- }0 q- _0 z- T9 ^9
* N, A0 U# O/ _2 G$ e3 E10
& v1 N) Y' ?! I6 X( t4 x11
/ P, t6 ^1 g7 V0 y12
13
14
15
16
17
18
19
20
9 ^* X- a, c7 P, G21
22
23
* l3 J2 x" C8 }7 H) d- |24
  r/ `7 W* T7 V" j) S1 N25
26
27
28
8 F+ U0 ?* j, N# [29
5 Q6 D( m! f+ ^, [30
31
1 e" R6 Y: J. z% K* D32
' F$ f9 Y' L8 D33
/ r: X5 I5 y' h- r# I% d# W34
. U4 |1 M' @5 y" w$ d3 ]堆排序
先理解下大顶堆和小顶堆，看图
大顶堆，双亲结点的值比每一个孩子结点的值都要大。根结点值最大
小顶堆，双亲结点的值比每一个孩子结点的值都要小。根结点值最小
; }" H$ u* f- Y/ C6 x9 Q' Q

+ k! _5 ?& g) ]0 F$ Z% J0 p
/ ~% j/ t9 V# \# i. k
简单解释：
构建好大顶堆或小顶堆结构，这样最上面的就是最大值或最小值，那么我们取出堆顶元素，然后重新构建结构，一直取，一直重新构建，那么最后达到排序的效果了。
) T, c# n+ \7 g( p1 c* ?
- {& W" R& I0 z
0 t0 _4 \+ X! B  M2 f; P

) s% _4 m9 J& m' V: c

5 X6 }+ C% Y9 B9 s2 G& N完整代码：
8 j& B+ s; B8 R& B
, Y# m  J& u) q( Q) R
package com.keafmd.Sequence;


$ H! B  T2 X9 w3 M/**
0 d) K) q5 ^7 f * Keafmd
( j, z/ L4 s+ ]9 B6 g *
7 I% c6 Z& V/ R( l3 ^ * @ClassName: HeapSort
* @Description: 堆排序
6 p% w: z% V/ C5 K+ K4 [ * @author: 牛哄哄的柯南
0 ]. p' `+ G7 ~- Y * @date: 2021-06-24 10:34
5 x  f0 k# L) K  {% E7 D */
/ X- j- P$ k  V8 T) ~1 A! ppublic class HeapSort {
8 b( {' U" w8 r/ u  ?3 W
  v9 ?8 `9 R- H, u
    //堆排序
) d! Y( X4 `, t' Z! E$ S  ?    public static void heapSort(int[] arr) {
        //对传入的数组进行建立堆，这里默认建立大顶堆，进行升序排列
        heapSort(arr, true);
    }


    public static void heapSort(int[] arr, boolean maxheap) {
4 ]9 N: R% V9 W" ]. |" q* x$ Z

5 u# z# @& j  y; ]        //1.构建大顶堆
        for (int i = arr.length / 2 - 1; i >= 0; i--) {
& X$ @: l8 z1 z; U# o( ?, K: c/ {            //从第一个非叶子结点从下至上，从右至左调整结构
            sift(arr, i, arr.length , maxheap);
# T8 O7 @! f( y/ A5 V, J5 _# g        }
. K, M7 l4 x: t7 C+ q& |) C
7 i! j( Y# G, S% C1 D& h
5 w4 _+ ^0 I. k2 N7 b        //2.调整堆结构+交换堆顶元素与末尾元素
1 f9 F% z: }1 j/ e% U: n        for (int j = arr.length - 1; j > 0; j--) {
7 h- N; R+ }! M& g( R( U

+ _, }+ K$ t: O3 {7 T2 \" v' B            //现在的数组第一个就是根结点，最小值所在，进行交换，把它放到最右边
            int temp = arr[j];
            arr[j] = arr[0];
" s3 Y* b$ \; m+ g            arr[0] = temp;


9 y" ^. X1 w6 d  D            //重新建立堆
            sift(arr, 0, j , maxheap); //重新对堆进行调整
& \2 M& R* P  w; [! [1 s4 [        }
    }


    //建立堆的方法
1 ]  i" f4 j6 r6 \! Z. |# w  n    /**
3 q$ j# L" z1 q! p! u     * 私有方法，只允许被堆排序调用
9 J% q: U4 Q# j3 Y# w( x2 q, s     *
- p# h/ _/ ]: _$ z- c     * @param arr     要排序数组
2 L7 M' o  @( S     * @param parent  当前的双亲节点
     * @param len     数组长度
     * @param maxheap 是否建立大顶堆
) W# h( F0 d2 m* u! g     */
    private static void sift(int[] arr, int parent, int len, boolean maxheap) {

4 J( B: y) g, {" [0 c
* J/ S2 K, n8 G1 j        int value = arr[parent]; //先取出当前元素i


2 L: \3 _) R+ y& C5 p6 g( d* }9 U        for (int child = 2 * parent + 1; child < len; child = child * 2 + 1) { //从parent结点的左子结点开始，也就是2*parent+1处开始
/ Y5 N5 h9 F. `# S; |% w# Q

$ x& F9 A$ J. G* m* ^8 o            if (child+1 < len && (maxheap ? arr[child] < arr[child + 1] : arr[child] > arr[child + 1])) { //如果左子结点小于右子结点，child指向右子结点
                child++; //右孩子如果比左孩子大，我们就将现在的孩子换到右孩子
            }

/ p: R8 s- O  P& E9 _# f& f) ]
            //判断是否符合大顶堆的特性， 如果右孩子大于双亲，自然左孩子也大于双亲，符合
* E$ v( I, W  U  ?0 J7 ?0 n# _) m            //如果子节点大于父节点，将子节点值赋给父节点（不用进行交换)
( l+ d2 E( f6 v/ h: F2 l            if (maxheap ? value < arr[child] : value > arr[child]) {
" A, \4 L5 m8 ?! e  a. T                arr[parent]=arr[child];
                parent = child;
            }
            else {//如果不是，说明已经符合我们的要求了。
0 ?; u3 R7 U9 D6 B1 ~- T; R; M                break;
9 O- ]0 f( y1 a. s- K            }
4 P* Y4 Z8 R9 Z$ e        }
/ j. O+ c4 h5 r# ]& Q1 V8 w        arr[parent] =value; //将value值放到最终的位置

$ P% [' b7 c9 }1 y: @7 I. I& t

" r2 G/ A6 g2 d4 O* B, o4 E/ p' d+ ?
0 N" k# u+ v+ l/ U    }
1 V- {+ h/ ^8 O1 @
! C( C2 [9 t& l+ P) k* m
5 z! r# V) ~8 s% H}
1
2
3
4
0 ^6 N  K0 X1 T( R2 k6 ~2 I# Z5
6
7
! M  H* N# z4 m: F0 L5 |8
3 P5 g4 _7 O9 Y: j5 ^6 k* ^* N+ M9
10
11
12
13
14
15
16
, D0 t" j) z- |- G0 H( p17
* Z" ?1 b& c+ n' ^1 \5 a18
19
' ~) s4 l, H7 L9 c+ K20
( _9 ^0 q7 T( w+ r- C2 o. t21
% |8 Y0 [2 m! a22
7 K$ ~& ~, i" s& ]; ~* N23
6 D( N/ a! n" C+ \  T1 J3 `24
5 g! d. O4 J; Z5 t25
26
" A, v% K5 u9 O( s1 W6 ]27
+ e6 H( g0 B3 L) U/ w4 O+ z28
3 [1 J1 \) r* ?* U29
  i5 d* }/ L7 X' @- Q& ^4 p6 S30
31
( |' I; h1 }1 U" F32
8 H0 A  l1 V& D9 m% }33
34
35
36
) E  G4 s; R5 \- I37
% N- g3 S5 N" a3 t9 Z! m38
39
  s" Y3 o8 U) @7 {# s40
( C/ K( a* T3 G3 }41
: U7 Q; j% }- K. u. E: F3 b42
2 D& y- R/ v' V4 _/ ?; T% s9 n; N43
$ ~) E4 q7 ?# |, r4 m% a# [44
+ g$ [: F3 g. @0 H2 x1 z45
( G( l% N. x  k6 X46
8 G( h+ w, O0 u7 L) Y/ W47
* Q, I$ K3 t2 H5 d: a/ v48
& y& S0 x& R% B- R  }2 i49
50
51
; f+ _' a, n" i6 v4 l2 K" f6 [52
53
& \6 k# `5 f8 J, y3 O3 G54
5 y' T" N1 D9 ], b' i( e/ ~55
56
0 P4 H- \( G0 @& f2 v) u57
6 F3 i- h; f( b$ s4 W58
59
60
61
  ~/ K' A! D9 _: q( B! L62
63
64
, ~- U" e( S' m/ s) w. z65
66
67
68
2 `3 Y  s* C3 J) [- b8 t3 L% J69
70
71
72
73
" F, E. l$ l+ E: H74
归并排序
. ^) O: ~( s/ ?  u, V$ S7 }简单解释：
该算法是采用分治法，把数组不断分割，直至成为单个元素，然后比较再合并（合并的过程就是两部分分别从头开始比较，取出最小或最大元素的放到新的区域内，继续取两部分中最大或最小的元素，直到这两部分合并完，最后所有的都合并完，最后形成完整的有序序列）
  o: {* T' e% A7 X
+ }9 `9 A" Z  C6 b& y9 l
/ H1 v0 o" R7 S; q



完整代码：
9 x3 w' G! i; g6 N

. @* ]7 [: N7 u# O- c% ?  Kpackage com.keafmd.Sequence;
9 T# t5 q. I4 M2 V) c9 b4 c2 V

4 c, ?! Q3 T1 L% y/**
( {. x( |* W$ X& R# N: r  U * Keafmd
: B1 q8 i2 D9 H( ]# v *
* @ClassName: MergeSort
* @Description: 归并排序
" f/ {+ `: s7 W) Q8 c  G) k * @author: 牛哄哄的柯南
* @date: 2021-06-24 10:35
4 e+ I' d# _# p/ }2 n: m */
, N5 R" \- c. `public class MergeSort {
4 d/ x0 x7 C' E4 l0 X7 U8 T6 O: l

3 D: {. e# E4 _2 X3 B  O  o    //归并排序
    public static void mergeSort(int []arr ,boolean ascending){
6 ~6 F" D  U2 L$ q3 T/ j; O* P" e        int[] temp = new int[arr.length]; //在排序前，先建好一个长度等于原数组长度的临时数组，避免递归中频繁开辟空间
2 v& A3 q6 d% o( V- B        mergeSort(arr,0,arr.length-1,temp,ascending);
    }
3 b( j9 N" A4 e    public static void mergeSort(int []arr){
4 C3 Y, y. t  a& [0 @        mergeSort(arr,true);
6 c0 T! K) ^- M9 L7 Y/ x9 I2 @    }

; h! H4 f7 }" c3 n( u# d" K
    /**
     *
* O3 y1 B% i. t4 S1 _     * @param arr 传入的数组
     * @param left 当前子数组的起始下标
     * @param right 当前子数组的结束下标
6 j# a' z. o! F- X; s     * @param temp 拷贝暂存数组
     */
: {; B- L. N/ Y, R5 B) g1 V    public static void mergeSort(int []arr,int left,int right,int[] temp,boolean ascending){
, g) ?2 `) O' H& D$ Z$ W        if(left<right){ //这里是递归结束的条件，我们是对半分，那当left==right的时候肯定大家都是只有一个元素了。
9 W) g1 Q( G% a3 ^/ Z) m) W$ t

- ?/ k! B. f1 U, G            //对半分，比如总长度是10，left=0，right=9，mid=4确实是中间分了，0~4，5~9
; s5 k- l; ]& k# s- C. U            //当长度9，left=0，right=8，mid=4，0~4，5~8
            int mid = left + (right-left)/2; // 防止越界的写法
            //int mid = (left+right)/2;

1 Y8 T8 l, d0 V% I7 C
8 h$ \# w: P7 t' _# k& j# W' ]            mergeSort(arr,left,mid,temp,ascending); //左边归并排序，使得左子序列有序
& ]9 x/ t) _( |, ]  @9 n; D; v            mergeSort(arr,mid+1,right,temp,ascending); //右边归并排序，使得右子序列有序
" Y2 K: d& H9 V* U1 h( Z* J
5 d! r/ d* R) m- o' T
            merge(arr,left,mid,right,temp,ascending); //将两个有序子数组合并操作
) B; o* P2 d! H9 [' E& l  K        }
# r, }+ t) w% {    }

8 q" @9 P" J$ G8 c, o
+ W8 ]. {; L3 `5 v% P3 g4 \    private static void merge(int[] arr,int left,int mid,int right,int[] temp,boolean ascending){
, C. z  R" `7 A+ k        int i = left; //左序列起始下标
        int j = mid+1; //右序列起始下标
        int t = 0; //临时数组指针
        while(i<=mid&&j<=right){
            if(ascending?arr<arr[j]:arr>arr[j]){ //比较两个序列第一个元素谁小，谁小先拷贝谁到temp，然后对应子序列下标加1
+ s+ j, k0 e/ ^) p1 S- f7 J                temp[t++] = arr[i++];
' h8 _' {& u$ n$ }. e' p            }else {
                temp[t++] = arr[j++];
            }
        }
: R3 s/ `- K# d! a6 J
, g4 Y+ K, C7 U9 e# ?$ o. I
        while(i<=mid){ //将左边剩余元素填充进temp中——左序列有一些数总是比右边的大的数
! q2 ?. U! c( ]: K" |# u" w            temp[t++] = arr[i++];
        }
6 `* N0 l" {* @: S/ D
) _0 N+ d8 Y" e7 l0 h1 s
        while(j<=right){ //将右序列剩余元素填充进temp中——右序列有一些数总是比左边的大的数
0 \- `% a& a4 N) E* @7 O% _# T/ k  z            temp[t++] = arr[j++];
0 x6 I- D6 w- R4 [        }
+ a& w( X+ s. b( I  W: W/ `
2 g# v0 J" k0 t0 @0 \
        t = 0;
# {- ]8 i6 t2 E# S* I

        //将temp中的元素全部拷贝到原数组中
* l- _" P5 q8 e7 `* w$ n        while(left<=right){
) D. a% U- v- X9 b' E7 V& E6 o            arr[left++] = temp[t++];
        }

* A: I8 w4 g. [
    }
$ p, f/ v+ ?3 _, Q! l3 A

}
1
2
( }( i) I9 N& `  z, J* E* h3
6 G% t; @6 n6 G0 i5 _  F4
5
6
4 a0 p3 }4 k7 K( H7
8
9
10
5 ^0 x* O: `0 }11
# J" j# \; Y+ k" M* C+ w4 c12
6 ^) u/ y: w; V3 y: \$ i" j+ C) G- H13
4 S$ p+ b* j+ z" O* U% i" y14
15
16
$ J! b/ ?$ d# U+ y; R2 N# D2 q17
/ A# T5 W* a' l+ [% o18
19
7 k( A5 U2 \, R0 n+ r+ O5 s+ r9 `20
21
& X/ E+ u7 f, A3 K( ]' i5 L22
23
24
25
26
27
+ }- C2 n% f0 ^! h9 ~4 n" M) z28
9 ^7 N) ~7 d7 s% ^1 }, W29
3 T6 o( x' s, h" w% Z" A30
5 c6 x/ N# t, x; L2 d31
8 L2 Y9 J: w0 q% R' U  u8 d32
; |) [0 c: h- b( D* Z% Y33
34
35
36
9 B9 U) t& z0 O6 a) [: Z+ Z3 L. m37
0 F4 @2 I3 [6 k: g. `6 x' s0 I38
; n4 m: t: O6 E2 h& e" R: K3 L39
/ t1 @7 a8 x- p40
- s5 j8 n- B- H4 ~% e9 y8 E! l41
42
43
44
45
6 s/ }6 b$ s5 [$ A2 U6 C: V46
47
" @9 z4 `0 }  @: v6 Z2 Y48
+ A7 t  X3 [' B49
50
51
  X3 v9 H( T% d3 y! ~! v52
53
+ I" L' y) f* S. ^+ n54
+ O; W/ _4 b$ v9 S8 w& \55
- U# z4 t" ?* f; }( L9 |: Q9 B56
. S& a4 `7 f1 e57
58
59
' t! q. H  ]  s, m/ `( H" i8 ?3 r60
61
5 u2 H' o8 }( ]' w62
0 s' i. \$ L8 {6 L6 `! D7 r- I8 T& _4 a63
64
65
66
67
7 I5 L8 q+ U( }7 X68
  u8 h2 J: B; a+ \) j5 S& c69
1 _8 C0 R4 _7 n1 x5 D. b  |70
71
72
73
插入排序
简单解释：
最简单的理解就是打地主时我们拿到牌后的整理过程，从第二个牌（假设我们拿起来这个牌开始比较）开始，（说下升序）从后往前比较如果比前面的那个牌小，就把牌往后移动，直到找到一个合适的位置（这个位置的前面的那个牌不比这个要放下的牌大）就把这个牌放到这个位置，慢慢的前面的部分变得有序，直至全部有序即可。
5 E" ^2 O! N1 o# i" t' O! h
3 |! T+ `" X) u/ }2 y


5 u& i' m/ x" g' C4 x1 R3 @

9 a# H; r5 y  j7 g3 B: c: u完整代码：
2 p5 X, h& b' C
6 e9 Y& {: f8 ~/ z! }1 p
package com.keafmd.Sequence;
6 s" ^2 N! g1 J! T1 e' G
& S7 a( e8 M5 t" @; A7 [* v
# J1 N% Q! W! j* S/ Q/**
* Keafmd
*
* @ClassName: StraghtInsertSort
  E) R- b; O$ b9 c; h * @Description: 插入排序
* @author: 牛哄哄的柯南
! O+ Y8 P" o$ a * @date: 2021-06-24 10:36
; d( n# _+ b; [  o) C% ?1 A: s */
public class StraghtInsertSort {
    //插入排序
' j  g3 k! e7 {% s    public static void straghtInsertSort(int[] arr) {
6 P9 B# U" M) p( C# E, ?, P        straghtInsertSort(arr, true);//默认进行升序
5 I* N0 R( W6 T3 ]' {, A5 @7 w4 O    }

, M% g3 m* }5 p. p
- r3 f/ J* a8 l" w; F    public static void straghtInsertSort(int[] arr, boolean ascending) {
4 l8 ^. d8 D) V
, Z6 q$ i: P( T* x5 S
' d( P. ^- V: c& F        for (int i = 1; i < arr.length; i++) {
$ \. ]/ V$ _# R7 f! o; P: b0 t' {            int temp = arr;
            int j=0; //这就是那个合适的位置
            for (j = i - 1; j >= 0 && (ascending ? temp < arr[j] : temp > arr[j]); j--) {
8 T- _/ q3 ?+ T                arr[j + 1] = arr[j];
            }
% ]% P( V: c. z8 _( O4 y1 e            //把牌放下，为啥是j+1，
            //是因为上面的循环遍历到不符合情况的时候 j是合适的位置的前面的那个数的位置
            //有点拗口，但是就是这个意思，看图方便理解下
            arr[j + 1] = temp;
1 u  a0 B( V7 c3 p
* V. a0 t) s6 {! F+ H9 B
  A& w: N/ @: c  V/ p
8 E% Q" v1 B2 o
% w& {8 h- h2 x& ?4 \! b/ w2 b: n4 c5 E        }
; ?7 `' d( P+ v* q, ]. V. u
* @0 U7 y* j+ u
3 m! Y4 p+ N7 k6 W6 ~    }
}
1
: s% K" X4 s, ?$ B! Z+ n2
" G% n( f  i1 `3 V# E3 O# G9 _3
( g" V) W" C6 r$ H( ^( O4
. J2 S3 G' q. ~% T3 R" L. ?4 V+ n5
/ k, |# `7 s! A6 l% X; d1 b8 g6
6 A$ u& F- @0 `( @7 u0 O" ?1 P7
8
$ z; T. ]  a* ]& ]$ P9
10
) B" i3 D) g+ D/ v% V6 m11
! W, z* b, |7 [' m* H$ F# ^/ y12
13
% ~' O. {' ~' @' d# i1 Y& c- p14
2 [" }& ~+ d* |/ d( t7 I0 f15
. A+ A7 c( x( ?) Y/ C16
" ]/ c( ^7 {3 p' R( M) }17
1 E7 M9 _5 b& ]% b18
/ p$ I7 U1 c& k7 k6 N& a19
20
21
. x% r* O3 \! L2 r22
23
24
25
, C/ n8 q0 f, E& ]26
1 M# l8 Q/ H& j27
28
! O" {) y  I3 d% ~+ e29
, n2 A- R7 w( w30
4 ]6 V0 X6 ~5 A: }; L& A: z31
32
33
0 d; s8 a- H) o$ g, v& x34
& u+ A- @; W# a: E希尔排序
7 S4 u% E9 t! W1 I2 A" }' ]简单解释：
希尔排序是插入排序的改进版，我们理解一个叫做下标差的的东西，也就是下面那个图中的增量d，初始下标差为arr.length/2，然后继续/2，对在同一下标差（相当于把这几个数单独拿出来了）的若干个数进行插入排序即可。





6 U( j' o6 w% X- j
5 x5 T; o8 k. Z% J! B$ ~' J完整代码：


0 @) g, q: m, _% D. Lpackage com.keafmd.Sequence;
2 R# O% R+ z2 ]! ?

/**
* Keafmd
3 W- D6 H# c0 a- ]8 v6 }( w* Z *
* @ClassName: ShellSort
8 t( V  U5 T2 ]8 A4 Z9 e * @Description: 希尔排序
* @author: 牛哄哄的柯南
* @date: 2021-06-24 10:39
*/
public class ShellSort {


    public static void shellSort(int[] arr) {
6 O: c  _8 f: b" r. O3 f5 I4 Z: N        shellSort(arr,true);
    }


    public static void shellSort(int[] arr,boolean ascending) {
7 X2 s5 t/ C& j
: p! Q" N, S" {5 Y- P2 E
; s" x- l8 H  m# r5 V        for(int d = arr.length/2;d>0;d/=2){


            for(int i=d;i< arr.length;i++){
+ \) n/ s5 n: C. S; r7 Z( y* G                int temp = arr;
& H$ f4 K- S2 I                int j=0;
                for(j=i-d;j>=0&&(ascending?temp<arr[j]:temp>arr[j]);j-=d){
& k, @+ @( N& }  E1 r                    arr[j+d]=arr[j];
5 \$ a; [6 f! V2 M                }
5 l+ }7 a4 D3 o                arr[j+d] = temp;
0 x3 z% D  R' w1 V; {8 h            }
        }
& i9 V8 @" s  b
3 d: ^1 M% E! q  f# l# T
    }
: g3 P/ {) ~( K; }8 j}
1
2
4 |/ w& w2 L4 Y- S7 R1 I3 q3
4
2 R9 k' T/ x9 q5
2 R7 N# D/ W) @2 M' f& j6
9 h0 O, Z' t2 {7
! w" L1 C8 R+ _8
% u; h& ~8 B) K, f5 X% Q9
/ B' U( x( A# ]' Y5 ]9 c; F/ Q' N10
11
12
: R, ~$ D0 v# y. ^6 Q13
14
15
! B2 P$ r* h" m0 {+ w6 M16
+ j: e+ c8 S0 ]/ M$ \% ?; Y9 ~8 l4 `17
18
19
8 ?! w+ L3 i7 [' p& k3 P" t& q20
21
22
23
24
0 v- r* F  L( @3 D25
: @, a) V- a" a0 K$ x, j( }6 h9 Q26
& N" A6 }$ Y9 @) ], c27
! t3 S* b) h5 V5 U) `; a0 B0 n28
$ H7 d$ a" F- n* S4 B29
30
% `5 X& d4 E, ~+ W0 {1 U31
32
计数排序
简单解释：
这个排序算法看名字也很好理解，就是就是额外找个数组来计数，然后在这个数组从小到大或从大到小把数取出来即可。
# R7 U- A: A* @! a" `
9 Q# V% ~# ^6 K
- B  f% ^/ O$ c1 G! A9 y3 u
! _4 _# @' E2 c

0 T9 T$ @) ^7 N0 J6 u8 `9 t
完整代码：


0 V0 a( P3 ], O) b! {package com.keafmd.Sequence;
; q, `- z, E9 U
  i0 @  M. W8 P& {" {0 M6 y1 o
8 r9 `" X$ u% }% a/**
8 X# T& h2 g0 `, m * Keafmd
*
* @ClassName: CountSort
. o" ~6 q) n8 _, Q3 h * @Description: 计数排序
' C6 b' C. i# i8 D8 @' Y * @author: 牛哄哄的柯南
* @date: 2021-06-24 11:31
2 q0 n9 ]$ k3 }5 @ */
" f6 o% w% t/ _  Cpublic class CountSort {


    public static void countSort(int[]arr){
; W3 w; M% a+ t# n5 W# {) t) A        countSort(arr,true);
    }
" f$ G! Y/ f+ ?# Q# Q
9 R# O, F$ I6 q$ h
    public static void countSort(int[]arr,boolean ascending){
: {: w$ b4 \" f' s        int d,min=arr[0],max=arr[0];

! ~. |8 `7 Y) v. b0 X
        //找出最大、最小值
        for(int i=0;i< arr.length;i++){
) Z1 B3 Z& ~+ D; o, `0 X+ T            if(arr<min){
                min =arr;
            }
, {. q% n7 e; d" g* h9 N            if(arr>max){
/ [4 I8 Y# V. I                max = arr;
            }
        }

' ~$ e, J/ U" \, Q; @) g
7 Y% Q( [. m  U7 h        //建立一个用于计数的数组
4 G/ O9 B1 [3 X4 e0 q% |        d = min;
) s+ [8 m+ K" Z& h5 U/ R        int[] count_map = new int[max-min+1];
        for(int i=0;i< arr.length;i++){
7 r( s3 G- B- S            count_map[arr-d]++;
        }


, D% _5 L$ H% O- t        int k =0;
        if(ascending){
            for(int i=0;i< arr.length;){
                if(count_map[k]>0){
6 l" N" S$ V* s1 w                    arr = k+d;
                    i++;
                    count_map[k]--;
8 [( {$ G0 D7 r$ V  C% y" v5 a% w" i                }else
" B0 v5 M& H! D: H: R                    k++;
6 l) @  A: r* r- x! `" F            }
5 _$ O" |% `9 v3 L. b& C        }else {
$ F: z) ^7 ?- |3 w' y/ A. ^6 Q' U. {            for(int i=arr.length-1;i>=0;){
0 p  {/ i  ^8 a* G; d, A2 h                if(count_map[k]>0){
3 i+ T2 d& `! z" W5 n! A, C                    arr = k+d;
                    i--;
                    count_map[k]--;
9 P8 J: }+ f5 \8 B' e- k: J                }else
" M, H5 z1 a/ u8 {( L                    k++;
! ?+ u) ?) N3 d6 P            }
        }
" k( P( B- g" f( y* m3 r6 y3 N& k

% R0 F9 N- Q' y, H    }
}
8 d- t7 y% S9 ~! w' \1 d2 S+ w1
! V$ S7 b2 F. M4 u$ P4 I3 `8 B' Y2
3
4
7 o% e, m' I9 S/ B0 |5
6
7
8
9
" i# J, ~# {! ?  h; v, Y; D+ G10
11
12
) r5 ^1 K0 \+ K; @" U% a' X: D13
. D5 o3 Q! h* U5 r7 P) k9 L14
15
* \! I/ I* t, _( ~# e* }16
* E- b. W: e, v6 J; b17
18
19
20
21
22
23
( [1 ?' z/ v; U4 n0 e/ k# H0 `24
3 z8 m$ q, _% M  f7 c% `0 j/ Z6 i25
( t! U+ D. A+ z% h) C, y, ?- L26
7 T0 O  b) z8 ?1 U27
28
29
' |+ o& T& K& }7 ?9 _6 g30
31
/ D/ \8 R. x- c2 U: p7 D6 F32
& W7 E  h, U( a' P( f3 \/ U33
& d4 A. b4 p: \" I3 \- h5 i34
- X# _# Q* X: N35
36
3 I( i. H; I' T* P3 o37
; a+ s  i: [3 \% R0 K38
39
40
! t! ^+ a3 O5 b8 n1 M9 b41
# w! q, n  R  K2 t& w, ~) j+ [42
) K+ X5 k! E  _4 F! U43
44
' g% w& |" Y$ h45
46
47
) R& \# t9 A( |" G5 s2 q48
4 h, Z8 j8 {8 D2 `4 r49
8 y' S/ {! D0 e8 K50
51
52
8 y- k* }1 e. S53
54
4 g0 R& M) y4 {! r% v: O55
, h. R& R3 |" x! j0 `56
57
4 x+ r) m0 N0 k58
59
8 s) ^. W/ g# q/ |3 w" f; _桶排序
简单解释：
就是把一个数组分成几个桶（其实是几个区间，从小到大或从大到小的几个区间）装，然后让每个桶（区间）有序，然后取出来放一起就可以了，相当于把几个有序的段拿出来放一起，自然还是有序的，当然需要是按照区间的顺序拿了。
4 S+ Q) }2 G: {- Q' Y+ `

$ a# Y2 f  l! Q0 a% J% }


  `8 Y9 u' D' ?4 S- A! w% s0 @
完整代码：
8 u0 H% J& W$ _- u" Y/ c

package com.keafmd.Sequence;
% H1 @* N+ O) x' D, \/ _
/ t: `( Q9 P+ `9 e7 O: G9 z
import java.util.ArrayList;
8 p4 S1 y/ f! O; Wimport java.util.Collections;


' H4 |" [; r8 h1 z# R8 `/**
* Keafmd
*
* @ClassName: BucketSort
, `  q0 s7 v8 W& Y5 v4 g * @Description: 桶排序
* @author: 牛哄哄的柯南
* @date: 2021-06-24 13:32
. q0 t: k7 |, R1 f */
* p" |' D& s1 M3 Npublic class BucketSort {
- F! ?( i" f% F

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


; W# V8 W" ~6 e) d8 L    public static void bucketSort(int[] arr,boolean ascending){
/ u% A& I3 ?8 k. E* a        if(arr==null||arr.length==0){
            return;
7 l: u* Q9 D9 j, h        }
        //计算最大值与最小值
/ |5 k1 Z2 a0 c! D        int max = Integer.MIN_VALUE;
        int min = Integer.MAX_VALUE;
        for(int i=0;i<arr.length;i++){
1 ?7 E. V' L$ @/ e            max = Math.max(arr,max);
            min = Math.min(arr,min);
        }


        //计算桶的数量
        int bucketNUm = (max-min)/ arr.length+1;
        ArrayList<ArrayList<Integer>> bucketArr = new ArrayList<>(bucketNUm);
        for(int i=0;i<bucketNUm;i++){
            bucketArr.add(new ArrayList<>());
( P( j9 [% F3 ^# p. H5 Y        }
( b0 K/ i- ^9 d: j! ^1 @

        //将每个元素放入桶中
7 W$ R( X! H' A        for(int i=0;i<arr.length;i++){
            int num = (arr-min)/ (arr.length);
            bucketArr.get(num).add(arr);
        }
  u+ X- Z2 T5 _8 t& Y
. q; M! }1 K. A% c$ z
        //对每个桶进行排序
        for (int i = 0; i < bucketArr.size(); i++) {
            //用系统的排序，速度肯定没话说
' a) Y# x8 c, w            Collections.sort(bucketArr.get(i));
        }

6 s0 B5 j  [& |# _- P% U+ g
6 p6 }: F. @2 y8 t! h, @        //将桶中元素赋值到原序列
        int index;
        if(ascending){
0 \# x! J* B! y4 ~: B! P1 |            index=0;
, Y: D2 ?6 v" H3 I6 L9 ^        }else{
            index=arr.length-1;
        }


7 w* o6 a; E0 T, s        for(int i=0;i<bucketArr.size();i++){
) T$ f2 x9 I+ h! h4 x! }* x7 }            for(int j= 0;j<bucketArr.get(i).size();j++){
( Q: T# v, a5 L$ A0 a/ |0 K0 c% K- N                arr[index] = bucketArr.get(i).get(j);
( a% i4 o% }$ o- f& s, b* O4 B                if(ascending){
                    index++;
                }else{
" F4 r8 P) T8 h+ r3 ]: h                    index--;
                }
6 K/ m: a5 J/ ]: Q% D5 [9 J            }

2 X( f4 L- x# G( W! O; y
        }


    }
* ?% X  I8 }" B6 X* v}
1
2
- T5 q  Q; r9 W* a3
/ K) w$ y# o- d  v# J9 f( z4
1 H2 {9 N  J# `/ q0 }5
6
7
# T# T$ D" _- {) y( M8
9
10
8 a/ G' ^9 u( D/ y% S# S; x: O11
% f% Z6 \6 Z1 _7 `  P12
13
14
15
6 H8 k& Q4 w; g* V) D7 j16
4 ?; h: z) g" x- c$ ^17
18
19
20
  [7 I8 A, t& n- y* n) N& h21
! h4 u) _1 y2 E; x8 d# M22
3 }2 i4 y, S( q+ T: \9 a/ S23
24
4 I2 D/ [1 y" g; ~& z: M25
26
27
28
# j  _( V, i7 J3 W$ U29
30
) d6 ]. @/ v7 I  |, i9 b% q% y31
& G( O$ u; Q  c9 t# m3 }3 `+ a32
33
34
35
$ [+ T& e0 Q/ C' \* t! r36
37
38
: u: t  m$ v) E/ k  J! I39
/ G& \) W& Q9 O' c" H. x/ M  Y+ O1 e40
41
1 V% {/ j' R0 M42
+ S9 [3 `6 e$ m0 e43
; m  c. K  r2 p3 j% }44
45
( j( t+ X" d/ N46
47
48
49
3 b* o2 H$ V/ C2 d& b50
51
52
53
7 g3 c# v3 P; I" E8 v& S0 n) o54
55
56
57
58
59
60
% D6 O* W9 z# @# B: i! f61
/ E1 x& v: _. z/ U' b3 q! s62
) R8 U. b9 m5 `% Z63
64
65
66
5 W' _$ E) H8 z7 a67
68
69
70
71
72
基数排序
简单解释：
首先说一下，我发现好多人写的基数排序只能排序正整数，其实只要处理下就可以排序含有负数的了，就是我们排序前先把所有的数整体变大（就是减上最小的负数，也就是加了），都变成正数，然后排序好之后，在减下来（加上最小的负数，也就减了）就好了。
. f' D$ J. M3 O% B基数排序就是按数位排序可分为LSD（从最低位[也就是个位]开始排序）和MSD（从最高位开始排序），下面写的事LSD基数排序。
基数排序就是把数按位考虑，让后我们一位数只能是[0，9]，就是我们在考虑某位（个位、百位· · ·）的时候就只看这个位的数，放到在[0，9]相应的位置，然后顺序取出，最后再按其它位这样操作（上面说了要不从低位开始到高位，要不就是从高位到低位）
7 f9 h8 W& o( _+ l5 R3 Y7 s
' K" P$ ]4 v8 p, K



7 s1 {9 S; Z; B) i
& W: d% ~2 O! n! }完整代码：

4 X$ @0 d1 _+ ^" K) K% o. f8 z
  M$ Z2 [$ L2 t1 Y, _. Spackage com.keafmd.Sequence;

2 S: v$ {6 p) X1 ~3 \0 t8 i
/**
* Keafmd
*
1 l, i. l+ s3 h! r5 n4 e * @ClassName: RadixSort
% s) p: l" R0 `' m/ o/ e% U * @Description: 基数排序
, C1 M; ]: x5 h. Z3 f * @author: 牛哄哄的柯南
  j  q+ E/ i7 t' b * @date: 2021-06-24 14:32
9 d, E) w0 a) K2 m/ w5 E& y */
" H- S6 f, T1 m5 B2 kpublic class RadixSort {
    public static void radixSort(int[] arr){
        radixSort(arr,true);
    }
    public static void radixSort(int[]arr,boolean ascending){
7 e& |% |" ~5 U0 \& f9 s        int max = Integer.MIN_VALUE;
. Y1 k$ ~* I1 V2 E0 e        int min = Integer.MAX_VALUE;
5 a9 ~) M! n0 S' [2 C& k        //求出最大值、最小值
        for (int i = 0; i < arr.length; i++) {
1 l9 e4 o1 I, C            max = Math.max(max, arr);
+ }( ~/ O6 w5 C) S2 F            min = Math.min(min, arr);
$ ~. ^  O! A: B% O        }
+ e& i/ P- u( }5 T" Z, P        if (min<0) {        //如果最小值小于0，那么把每个数都减去最小值，这样可以保证最小的数是0
            for (int i = 0; i < arr.length; i++) {
                arr -= min;
            }
5 W- \4 ^6 \0 j3 J1 t/ G            max -= min; //max也要处理！
        }
        //很巧妙求出最大的数有多少位
        int maxLength = (max+"").length();
. [2 @. A* D& v3 _        int[][] bucket = new int[10][arr.length]; //一个二维数组，一维代表0到9，二维存放符合数
4 s1 b$ F2 f, z$ p  z        int[] bucketElementCount = new int[10]; // 用于记录0到9某位存在数字的个数
  z, u# ^4 L' s' C1 W. b& V        for (int i = 0 ,n = 1 ; i < maxLength ; i++,n*=10) { //个位 十位 百位 这样遍历
2 l: S9 s" V: s  c* o5 K            for (int j = 0; j < arr.length ; j++) {
- f2 {6 _! u. |' \% i* v                int value = arr[j]/n % 10;
                bucket[value][bucketElementCount[value]] = arr[j];
                bucketElementCount[value]++;
" v9 ?4 T+ W) c            }
3 `8 a' R  d. C% Y2 _2 L( e8 O

            //升序
, P- c" A9 B' ~, ?+ [- y1 I& j7 N            if(ascending) {
                int index = 0;
                //从左到右，从下到上取出每个数
! m/ [4 B* t1 ]* B7 O/ x3 t$ ]+ b                for (int j = 0; j < bucketElementCount.length; j++) {
                    if (bucketElementCount[j] != 0) {
1 l. P7 s1 y! T8 H                        for (int k = 0; k < bucketElementCount[j]; k++) {
                            arr[index] = bucket[j][k];
; J& T& O, h' }. r! n( ?                            index++;
                        }
                    }
                    bucketElementCount[j] = 0;
# ~) v' e, q1 O% f% U2 t. d3 u; q, Z% g                }
/ Q8 p% {3 i# y( v0 S7 m            }else { // 降序
/ H( k& J4 y: f7 m7 T1 A# w                int index=0;
                //从右到左，从下到上取出每个数
2 _/ H6 g& j5 \3 H" P- @1 o                for (int j = bucketElementCount.length-1; j >=0; j--) {
                    if (bucketElementCount[j] != 0) {
                        for (int k = 0; k <bucketElementCount[j]; k++) {
) @7 t" S1 v6 A1 x% C2 [  W. ^% q                            arr[index] = bucket[j][k];
                            index++;
% ~1 m) `/ v) u! Z/ ~( W4 Y                        }
# H2 f2 ?" c) N( K# O' Q                    }
0 N1 w# c0 ?6 M- U( j  R8 _                    bucketElementCount[j] = 0;
, L9 ?4 I' e4 q$ ]: d/ E! l                }
! b8 R% \2 b8 n" `- r. q9 v  ]            }

: \( o. a9 J# Z) X) [  v
5 T# b/ J! N9 ^4 j& m1 d

            /*for (int i1 = 0; i1 < arr.length; i1++) {
9 Q5 P/ @+ S2 K2 }2 k& ]                System.out.print(arr[i1]+" ");
            }
1 ^$ O' B" s' A6 S/ x* ^            System.out.println();*/
3 \. G$ h3 Y3 A# B% f2 Q) z
! D' Z9 F. J  V0 h
# J. J* J% c) \3 k5 I1 X



        }
        if (min<0){
            for (int i = 0; i < arr.length ; i++) {
4 D" Q6 @+ i( G! ?                arr += min;
            }
0 |$ B: F! B  }' m* L9 z7 A  M* |9 G        }

  n; x) J5 j2 w- v; N8 `
    }
}
2 w# u# n; ~  `1
  n/ o" _" p; e3 {2 t2
3
4
5
; e0 G8 K* o1 H2 M8 a6
7
9 _8 h! M, `0 V' Z1 k8
$ P( y2 ?3 i7 U+ @% u9
3 U4 A1 [, F/ R6 e5 I10
11
! h  c$ V' N2 I3 C. I8 W8 k0 y9 j12
  Y# r" ]7 j: C0 t13
14
15
# m" V* U' _, |8 V* t16
17
1 g# v* r+ S; Q# O3 [$ q18
19
20
21
22
23
24
25
26
" y& ]1 B* b# `( _- K0 A" J27
. P$ ^3 ]- P) Z; k) ]28
3 G5 E) o" U/ H7 f3 v- h4 z! t29
. f! P4 F" K) Q* ^0 w" O30
4 B# i$ n: J% p31
1 f# h7 i8 n* Q; r5 l7 t+ Q32
33
4 X$ w( g" u: ^34
35
36
7 z* m- |. v" M9 ^$ n37
38
39
' C1 t3 K. T$ a% L40
8 @% N+ W. H0 }' z' I" F41
1 [  u% L1 b& @3 P# r42
43
8 T: k/ |  E8 ~* D! y8 A3 S44
45
46
( Z! X( A" ^; B# Q5 T6 v" u47
48
. a0 u3 N, M' F, \* _! x4 e+ M9 r% `49
" X3 v* |* |( m, c5 c50
51
; X' n; f1 a4 `! q# S* U4 u* E! f+ {52
2 X- @: x2 K0 g7 c0 |53
2 I# S$ m5 W; G# H0 p' l54
55
56
: ?' l* a7 @! `# q9 z, o: J57
58
  r9 _/ ~. @6 d& L( `( k59
60
61
62
+ V) p& U" D: T  e63
# M* y# w5 L- l( d) g64
" m) e% k0 D, M65
66
9 i' W: g7 F8 s9 R, m# z+ h3 e! A' V67
0 _! n0 I/ m/ m( n& Y% ?+ {+ F68
, d* O3 U$ @! Z+ S  [& m; z/ K69
, N) M; l. d' }  h4 m0 J70
71
# I) N$ @, I8 n- ?+ C8 G' x) G72
73
74
8 q- l7 W/ Z$ A75
# m- |; J/ `( t' f6 m76
( t1 ~5 k1 l0 E, t+ y7 T77
; Q7 T' d! k: Q78
! p7 t9 \0 Y+ x& Z9 l79
80
81
5 r* G* b3 s4 u, w. F  n& E% o/ b82
83
8 ], q) P* @. @- A/ _; s& G完整测试类
# e; Q6 R' W* a+ ^& }package com.keafmd.Sequence;
" j8 Y7 }! _/ r
( [* U  C: k5 e7 T% o) h
7 T- l# n; E0 u: A/ t' zimport java.util.*;
import java.util.stream.IntStream;
import java.util.stream.Stream;
" ]5 f5 g/ N$ w+ S* d, W& Z
2 A6 a3 H2 \  r- Q
4 I5 E; z1 b, U4 X$ i; |0 x! x2 q9 `+ u/**
; f6 J( G! J0 G1 y* G * Keafmd
*
0 k: m  [- `  ]. g) O * @ClassName: Sort
* @Description: 十大排序算法测试类
" ?3 k! |& a# }5 P5 G- u. l * @author: 牛哄哄的柯南
% H9 h7 D1 O! ^0 [( T3 q9 R * @date: 2021-06-16 21:27
7 L& ~# [% b& l' s */
public class Sort {

: D9 D0 z+ V  @1 U
. b- ?, Z- o3 ?5 X

# z  J5 R! O. Q1 G& Z. l9 o/ G& w    public static void main(String[] args) {

: [. p$ L: l* d2 f1 b0 T
2 s; a8 D( P4 L5 r- X        int[] nums = {12, 4, 25, 47, 58, 34, 25, 9, 99, 26, 1, -13, 162, 10093, -66, -1};
- Z# l' L  z5 R7 c//        int[] nums = {12, 43,56,42,26,11};
        int[] temparr;

/ X3 j9 x* \% o/ L2 A4 C' g- y
        //利用系统Collections.sort方法进行对比

3 [+ l, m" s& M9 S
5 G/ w+ _# Y# w" }        //将int数组转换为Integer数组
        //1、先将int数组转换为数值流
        temparr = nums.clone();
, Z' Y6 z* {0 Z, K- g        IntStream stream = Arrays.stream(temparr);
8 v& c8 ^) @  Z& C- x6 H, I        //2、流中的元素全部装箱，转换为流 ---->int转为Integer
6 S8 \# N$ N* H6 h- R! |        Stream<Integer> integerStream = stream.boxed();
        //3、将流转换为数组
        Integer[] integers = integerStream.toArray(Integer[]::new);
        //把数组转为List
        List<Integer> tempList = new ArrayList<>(Arrays.asList(integers));
, }: b% w) G% h1 i- V4 c1 A4 k        //使用Collections.sort()排序
        System.out.println("使用系统的Collections.sort()的对比:");
* \" x% A( T$ [9 W$ t8 L
8 j, q" Q2 n; q& f" e
  j/ N5 w; e5 f6 F4 v, a3 X- D) {        //Collections.sort
2 e4 S) ^5 w7 b: X& r        Collections.sort(tempList, new Comparator<Integer>() {
& R2 \) b  u8 _            @Override
            public int compare(Integer o1, Integer o2) {
& U7 W7 x9 w) H: x" ~+ t                return o1-o2;
                //return o2-o1;
2 Q2 |" x/ c  S! H            }
& K" z* F  G  P" V        });
/ z+ w# p* r7 r5 Y( M9 ?

: q' j! d* ~  S- |' ]8 @* _        //tempList.sort 也可以排序
       /* tempList.sort(new Comparator<Integer>() {
            @Override
9 @$ u' z4 H. U1 I' ^$ r, M            public int compare(Integer o1, Integer o2) {
                //return o1-o2;
                return o2-o1;
# {& H* G" W3 n- {            }
+ `+ J, H0 {7 z        });*/
  I! _# K* q: s
/ z6 Y( p7 }2 W: J# m5 T, a( y& h
( m8 T+ y$ j4 {- X        //遍历输出结果
        for (Integer integer : tempList) {
            System.out.print(integer+" ");
6 K* G* v# y0 ^4 E2 i& K" l4 R        }


& |1 f- b/ z* n- c        System.out.println();


+ a9 s& {+ m: h! o3 }0 Q& g        //测试冒泡排序
        System.out.println("测试冒泡排序:");
6 @5 C' R2 `: v! y5 L        temparr = nums.clone();


        BubbleSort.bubbleSort(temparr);

. `. e/ `1 O  Y) C. p% Q$ a
9 `7 j4 {) R/ x% H2 z% i        //降序
2 S% |% E' S/ |/ q% ]- j' i        //BubbleSort.bubbleSort(temparr,false);
8 S4 h$ s, t: U4 t5 I5 z" L

        for (int i = 0; i < temparr.length; i++) {
2 y! A( X# e" Z& B# G+ G            System.out.print(temparr + " ");
$ n0 o( Z# f8 C- M; T3 c  O. f        }
5 ~' V6 [- F+ b) p) i0 U+ M( m* m        System.out.println();


        //测试快速排序
        System.out.println("测试快速排序:");
8 B' j' Z. A% [) Q$ l        temparr = nums.clone();
        QuickSort.quickSort(temparr);
, A4 j4 F7 I) ]8 I$ S) z        //QuickSort.quickSort(temparr,false);
6 ?) W3 B9 o* n9 y; s        for (int i = 0; i < temparr.length; i++) {
            System.out.print(temparr + " ");
        }
        System.out.println();
3 k. _' L, Z, b4 M

  `7 ?" H. t4 e+ e- R        //测试直接选择排序
8 ~) L- b& h) I+ c& @        System.out.println("测试直接选择排序:");
        temparr = nums.clone();
3 t' A$ w+ ?8 k+ H  ]        SelectSort.selectSort(temparr);
/ \- |6 [4 U; F3 V- F# ?5 F$ l" V        //SelectSort.selectSort(temparr,false);
        for (int i = 0; i < temparr.length; i++) {
! T! a' u7 z- o: x; l0 V2 h& l            System.out.print(temparr + " ");
        }
        System.out.println();

) L  {5 O, p) J% s
        //测试堆排序
6 q9 H+ X2 y: F# |; L- s4 S5 s        System.out.println("测试堆排序:");
1 t9 u$ \3 e: H" s& s        temparr = nums.clone();
        HeapSort.heapSort(temparr);
  O1 R9 r. l+ q        //HeapSort.heapSort(temparr,false);
; S5 U( D( k% o, `) x' c& ]        for (int i = 0; i < temparr.length; i++) {
            System.out.print(temparr + " ");
* ?2 X8 H7 P: E+ {8 W" ^$ G. U1 y, y+ W        }
0 J, ?( p- \' U; x4 t/ H  X# ?, r        System.out.println();


        //测试归并排序
1 O# A! ?) b8 M        System.out.println("测试归并排序:");
        temparr = nums.clone();
        MergeSort.mergeSort(temparr);
( f3 D& ^! q# h7 L' q, o9 f        //MergeSort.mergeSort(temparr,false);
        for (int i = 0; i < temparr.length; i++) {
            System.out.print(temparr + " ");
. ^' w0 z/ ^1 n. u+ b& F        }
* Z  ?% B) A+ E5 J' y        System.out.println();

8 p! ?6 [7 E4 N! o- e
        //测试插入排序
' @* c2 l5 [7 @0 _        System.out.println("测试插入排序:");
        temparr = nums.clone();
) K; ?: ?$ k7 ?: `7 H# r" [' o- O        StraghtInsertSort.straghtInsertSort(temparr);
2 B# h4 T* x  G- Q  t        //StraghtInsertSort.straghtInsertSort(temparr,false);
( {, B3 L4 g' h! N& W1 P6 O$ x, k- A        for (int i = 0; i < temparr.length; i++) {
            System.out.print(temparr + " ");
# L/ U2 ]5 H: l  a/ x% \' N7 M        }
" @3 U. E% i7 s9 Q        System.out.println();
3 g: R) I* l5 J, n" _
6 [, S2 t# x" S
4 n4 v- X4 Z3 P

        //测试希尔排序
9 y% r4 V, b# z* t        System.out.println("测试希尔排序:");
        temparr = nums.clone();
, c$ d+ B# q9 w0 H; b8 F, m        ShellSort.shellSort(temparr);
        //ShellSort.shellSort(temparr,false);
; y# w* A6 |7 C- x. L        for (int i = 0; i < temparr.length; i++) {
7 }( {$ S% i8 E/ J2 |            System.out.print(temparr + " ");
; v" A+ k, q$ [7 n+ K0 \& u        }
        System.out.println();
9 ~, d: i/ D$ W3 Y! y6 J
1 a2 s* p7 O5 Q1 g6 q) C

& a0 C* z$ s) i7 A" e. H
        //测试计数排序
2 e' ]  ^2 _. L! O: @" T. W        System.out.println("测试计数排序:");
        temparr = nums.clone();
5 L) l7 [% [& F$ @% b( S" {. t        CountSort.countSort(temparr);
2 B% n# E; r7 o) g0 u7 v, W        //CountSort.countSort(temparr,false);
        for (int i = 0; i < temparr.length; i++) {
' D0 `+ h& g- U8 H$ \2 K            System.out.print(temparr + " ");
        }
        System.out.println();


8 T1 r, Z1 Z5 I: w0 D

$ t- k+ v/ O' E5 f7 ^        //测试桶排序
8 \/ o  v0 b* O) i/ B        System.out.println("测试桶排序:");
        temparr = nums.clone();
        BucketSort.bucketSort(temparr);
7 ^( T( S( t, K        //BucketSort.bucketSort(temparr,false);
% @  v; ^  C, @7 \% X8 J        for (int i = 0; i < temparr.length; i++) {
6 C0 k/ `: x+ G) O1 ^            System.out.print(temparr + " ");
        }
/ S3 L# Y2 o* c% a3 M. D( ~0 @7 i        System.out.println();
0 @* N# X+ ^% Z

2 h+ |8 w5 o; E6 z+ K        //测试基数排序
        System.out.println("测试基数排序:");
        temparr = nums.clone();
4 |3 \4 k) J: k. d4 p        RadixSort.radixSort(temparr);
        //RadixSort.radixSort(temparr,false);
        for (int i = 0; i < temparr.length; i++) {
            System.out.print(temparr + " ");
# D, [& x# l  l7 f! x        }
- r0 l5 A) i: E/ n+ k2 F0 P% X        System.out.println();
) ^. U" _. v# W6 e8 u
8 c7 z0 F9 X3 a- K" `% G9 S" x
* a9 `, [: J8 x  a$ [: Z    }
+ k2 L8 b' ?% b
  O  e4 k, e* i) ], `
7 ^  ^9 H# |3 r& q! i  ?  ]7 |}
1
5 r; ]% V$ T# R' x& K2
7 m0 `7 p0 W% t# [8 p) ^3
4
5
6
7
* b, j) X3 V/ }2 U5 w8
$ X8 e' C6 g1 ~, k2 n1 w+ E4 ~9
6 h$ ]) Z& [- ]; E! j10
( z# U; S$ B: g11
12
- r7 K" s5 u2 ]13
14
15
/ K( j- F- i) J" X! l% d5 _6 w# g16
$ U0 `. {. D' y6 o17
18
19
' r/ w% M8 `! ~/ `20
21
22
23
- c8 q+ O; K. C8 F( m& S4 [24
4 l, W9 R! D7 p6 B2 c# Z7 C25
; B% o  H; E! Q26
9 J$ j* I6 ]+ W1 N  R# U5 r27
* X. K4 Q! g; G8 F28
  R9 j+ M- \5 s  a0 l29
30
31
32
* f$ W' R' D6 S* N- C$ d3 N33
34
# U; \" @) O* y) B35
36
37
38
4 i# h$ }1 D; _! F# o5 \39
! w; K( \8 v* M: S1 v8 q4 G& q40
41
42
% h; t1 @$ j- K( N: w43
/ _) u6 W( r2 H1 x) i44
45
46
47
( [9 W2 O$ g  W) z) g4 T; z' S" n48
49
& M3 @: s( M5 J# N! M$ z1 k* ?50
51
52
53
54
55
56
57
9 ?4 S' }; M  J( V# s+ ^) l6 J5 A58
, C% i8 s" v5 e* _+ q7 e59
60
61
& A/ P, R6 K2 h4 W7 j- w62
63
64
% |, ^- H. J5 Q# K4 o  l65
' Y1 V6 g  r: N6 \66
67
$ ^7 x: s6 P& w) H  b% o/ H68
69
7 K6 j- m# T/ O7 W70
8 ~, M+ G$ d3 j9 F71
72
73
5 o9 _) i0 Z( J; i9 p7 G74
75
9 U% s8 ?& T' ~2 L9 M5 ]( M76
77
78
79
80
- f. Q# x/ c& X6 l$ H, Y- i; `81
% q. Q! i9 G5 @! |4 B6 Z82
83
" z2 |( R* @% E: i84
85
& {1 q" }, Z' y3 h" y/ l+ X# [& }86
87
$ C6 z. b$ }6 u6 c7 P( `88
8 x% ~& j6 I* W89
90
/ p  H- H) g6 ]0 X91
1 d  @: B( j7 L3 f4 D! n9 ?( U92
6 k3 b# D: e9 l+ T. {93
94
95
96
97
98
) J3 E; x) S- g3 Y1 e+ E4 H/ ~; g/ }# h99
+ }6 Q2 p4 n% D" [* z100
$ m$ v) h& [$ G! ?. n101
# Y# {1 W- a! l* k& t* t. Z7 Z102
103
( p1 b4 c0 r5 v/ w104
4 F- k* C# V6 ?1 C) s" U0 S6 m105
: ~+ I4 T" O4 w9 X' w( P) @106
0 j% Q6 l7 K  u& f( z7 K5 h107
108
109
- a# G) P; e6 ]! k110
111
112
113
3 u) D) I" h& N% L5 ]' q114
115
116
4 O. O' s2 r# @1 t' V' F, d117
118
* o) h- p/ V+ @/ V9 T2 ?4 T, S$ k  \5 m119
6 \# I$ s+ U- L9 G% C% A% a120
121
122
* w$ S) v( G1 V9 D# {' v+ F3 Q+ V3 z* o123
3 k; b! S3 v! D8 a" r124
2 ]6 ?; }" G+ D5 Q+ ?125
9 X0 M) p* U3 O8 ]/ G) c# d126
127
9 _1 y% S4 c0 O) J. R+ |9 U128
129
& x# G* _7 z/ p# x$ K130
131
132
133
9 C4 {* J7 S. U5 ?, `. y134
% {: u- ~( L  @. G, I- A135
136
; H& A+ f% {+ U4 U3 |/ p: z137
. i% `0 Y2 t$ \% O- \8 g138
139
1 W) q) Z9 a+ X140
2 \$ ]6 A" d; G141
142
- A/ T/ J  z" O9 e' ~143
144
145
146
, g! A) y% V5 W) ]8 A- r2 Q1 C" h147
' D9 f0 z7 K5 M- h& u  q148
149
150
151
152
153
) S  y$ u( N! a6 Z5 l154
9 W$ d% A' w1 }/ r0 t# i6 r6 ~7 L2 ^155
156
. m* ]( P* e3 ^8 |8 E& j5 h1 C157
158
159
9 c) b" ]$ Y: f+ E8 K160
6 x( }% f# [2 }# I161
# n* k  L' n, d9 o' b/ n162
4 x( q( S* ~' V  {163
164
4 a6 v9 ?/ S. U, Y: c! d165
7 T, P' p2 I* e  z2 y6 w7 y; R166
167
168
6 M9 ~! X& H  U2 d  ^) \5 }9 g1 x169
4 i0 k% H- X% m2 @6 ^1 L) g; @" Q170
+ N! ?0 i- |: c* v4 C- U* K, W8 f171
4 M9 r5 [( J$ A5 _172
4 z: m" V* W) h6 c4 _5 x; T$ [173
每天进步一点点！
7 z5 E% ^' T% ]3 d0 a: t3 k不进则退！

! [: a% e( x( w+ P
版权声明：
$ t3 O* \  }. U& z4 S% ]& ?原创博主：牛哄哄的柯南
1 ^# N  K0 t# j/ j& }1 E博主原文链接：https://keafmd.blog.csdn.net/
: L& j- K: W5 O. q  y% s' T————————————————
版权声明：本文为CSDN博主「牛哄哄的柯南」的原创文章，遵循CC 4.0 BY-SA版权协议，转载请附上原文出处链接及本声明。
原文链接：https://blog.csdn.net/weixin_43883917/article/details/118193663

1051373629

每天进步一点点！