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

杨利霞

* Y* j8 B' R4 w5 T' w经典十大排序算法（含升序降序，基数排序含负数排序）【Java版完整代码】【建议收藏系列】
8 f( u# x$ l9 z经典十大排序算法【Java版完整代码】
写在前面的话
十大排序算法对比
冒泡排序
快速排序
. |6 h% k$ u4 y  P直接选择排序
堆排序
归并排序
, z) p0 H8 f& [5 B" V2 I# A* E插入排序
希尔排序
, H& r6 Y1 i* o8 S3 ]计数排序
桶排序
基数排序
' I# M+ p( K  N% B3 i- f3 E5 p: {完整测试类
写在前面的话
6 x7 d: E% n7 a! v4 m3 c+ u       虽然已经有很多人总结过这十大排序算法，优秀的文章也不少，但是Java完整版的好像不多，还存在某些文章代码存在错误的情况，同时也为了自己练手，决定把所有的写一遍巩固下，同时也真诚的希望阅读到这篇文章的小伙伴们可以自己去从头敲一遍，不要粘贴复制！希望我的文章对你有所帮助，每天进步一点点！！！
6 j! D3 p& k2 b% _- ?) y

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


十大排序算法对比

4 {( r) Z7 I, a3 c! W7 \


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


  ~8 u7 B8 C* o% `2 I) ^冒泡排序
' _( ^- t: O, \  u0 @6 [1 L6 d简单解释：
       原理就如算法名字一样，就像水中的气泡一样，每次我都把最大的或最小的放到最后面，这样总共需要n-1趟即可完成排序，这就是第一层循环，第二次循环就是遍历未被固定的那些数（理解成数组左边的数，因为每层循环都会把最大或最小的数升到最右边固定起来，下次就不遍历这些数了），两层循环遍历结束后，所有的数就排好序了。
2 l3 W! O& y5 f" ?2 x9 \( S       两层循环所以冒泡排序算法的时间复杂度是O(n 2 n^{2}n
5 M: v; R, v( `3 f4 A  X5 J- f% E* ~2
)，是一个非常高的时间复杂度，我在下面的代码进行了优化，加了一个标志位，如果上一次循环未发生交换，就说明已经是有序的了，就不继续下去了，反之继续进行下一轮。
: K* C) C- o: R0 i& o5 ]




! l  w, H# ?$ c! l
' \2 L+ `. A6 @本文的图片来源网络，仅用于大家学习，侵权联系删除！（下同）
. p. n3 ]  Y( }/ m+ E
% M) n* O; Q( D6 R; g8 s
! u6 M7 E4 c6 E  H完整代码：
6 b! C- d( V( T4 y
  [( n$ z1 n3 i8 b% b) x
) L# p6 @# R+ k; f- q* E( M1 Epackage com.keafmd.Sequence;
' N" r, p" w6 O# @' c
% i2 E' B% d% B
/ R: M& X6 x$ {5 h. i) a& Z/**
* Keafmd
*
* @ClassName: BubbleSort
0 K6 Z; K9 G! G' r' t * @Description: 冒泡排序
6 K4 T7 |' `$ J, I; U  w * @author: 牛哄哄的柯南
* @date: 2021-06-24 10:31
+ B  T  X& l* M& t& ~ */
public class BubbleSort {
4 m9 c$ c1 C8 A1 p6 X1 _3 x) h

    //冒泡排序
3 x/ k$ }$ U" Y7 s: O' |9 ~    public static void bubbleSort(int[] arr, boolean ascending) { //exchange标志表示为升序排序还是降序排序

* F8 n) t9 h! l5 S0 G' ]: C5 x
) l& [* z1 d6 Q+ P  R$ o        boolean flag = true; //加一个标志位，记录上一次是否发生了交换，如果是，我们则进行下一轮，如果没有，说明已经冒泡好了

6 U* _; U3 N3 ?; r5 n& i
        for (int i = 1; i < arr.length && flag; i++) { //控制次数，第几趟排序，只需要n-1趟，有交换时进行，只有flag=false就说明上一次一个元素都没有进行交换
# r' g. g3 S) h, M& g

            /*System.out.print("第"+i+"次遍历：");
! H9 p/ a& K  y# h1 ~8 i            for (int i1 : arr) {
                System.out.print(i1+" ");
            }
            System.out.println();*/


) p1 I3 V$ ]# M  ?, v            flag = false; //假定未交换
- J* Z, @! a$ r/ e" C

            for (int j = 0; j < arr.length - i; j++) {
/ A$ C1 m5 j! u5 v0 E0 ~0 l* j

0 m, R' Y# ~* `: T$ P                if (ascending ? arr[j] > arr[j + 1] : arr[j] < arr[j + 1]) { //控制升序还是降序
                    int temp = arr[j];
                    arr[j] = arr[j + 1];
                    arr[j + 1] = temp;
  X& ]8 D/ x& w9 U                    flag = true;
5 Y6 v$ u. ~% C( Z                }
9 \* d  o1 [+ H, T0 x" t1 c
2 c- C; U/ i8 ^3 E' d
            }
        }
    }


    //冒泡排序 -- 默认不传参升序
    public static void bubbleSort(int[] arr) {
& ?# t4 [$ ^. k5 M( r        bubbleSort(arr, true);
    }
  Q2 j7 a% {5 u$ x8 o1 l, c7 W}
3 u* d  h' n3 c, N, {1
2 y  s$ y6 ~, W2
6 \7 b( F3 g$ P4 A* \# {3
4
) ?4 K+ M# t7 I! l6 p+ g5
; U- A3 v; A4 H- `1 y+ U6
- P8 W1 ^. z% k( g0 I( j0 D4 Z7
0 J2 o; r0 w" I8
& c! W: |* O4 T1 t8 `4 V9
10
11
/ {" K( O% f, R& c3 s12
13
14
3 n. ]! s" R- P- T( u15
16
2 [  d8 P8 M$ d. O9 Q17
18
  Q( v/ N7 h5 @( z, A; H/ v1 F19
20
+ a1 k9 E' j3 P$ S  ]/ N" p21
0 g& ]) A- j, ?% ]. {4 x22
2 v* `9 m2 g# U2 g23
0 W- |, z: d0 _3 I& c24
25
+ M3 D# y( i* a0 f26
+ Y( I6 [# `. P" C) F27
8 b% C8 T$ s4 p- G28
29
30
" ?) T6 E- h' m! p; @6 x31
. U8 `+ B+ y" N32
33
34
35
36
37
38
39
5 |% F. G4 p# A0 c( _6 G# K40
  o- J/ b) n  S! N3 J41
42
, w) U7 l3 R8 q* M# J; |1 O43
! S9 C1 Z0 ]+ U) N5 W$ Y, b8 P44
+ F+ |! Y! V" ]9 x45
测试代码：
* I! N% S, N3 g2 f7 S" x
# m# F# T, m1 N, v  o. p
升序排序（从小到大）


package com.keafmd.Sequence;

1 g6 ?" R; r: C3 ^/ j
import java.util.*;
- F5 p/ ]# p' A' p- Y" rimport java.util.stream.IntStream;
import java.util.stream.Stream;


) Y( t; Q: e& A4 S  }; f/**
* Keafmd
*
0 Y$ k! m  u+ `, K6 r, y7 q. ^8 k * @ClassName: Sort
* @Description: 十大排序算法
4 a% H! i# X* C * @author: 牛哄哄的柯南
) p% ]' U$ J% M * @date: 2021-06-16 21:27
*/
public class Sort {
    public static void main(String[] args) {

8 J% b  h+ G, u3 J
        int[] nums = {12, 4, 25, 47, 58, 34, 25, 9, 99, 26, 1, -13, 162, 10093, -66, -1};
        int[] temparr;
& I. ?1 b) ]+ O* \

        //测试冒泡排序
, G6 L' V2 a1 m8 ]: @, }. U" ]  A        System.out.println("测试冒泡排序:");
7 |& Q2 J2 J! G/ q$ W6 {5 u        temparr = nums.clone();
        BubbleSort.bubbleSort(temparr);
        //逆序排序
9 e( K; {1 [4 S* j/ o0 K        //BubbleSort.bubbleSort(temparr,false);
/ |/ t4 `) T+ {) L        for (int i = 0; i < temparr.length; i++) {
, S+ ~  A7 y0 C# U: R- K7 N* u            System.out.print(temparr + " ");
8 I* r2 \& i6 {4 v  Z( e        }
        System.out.println();
  d8 o7 J6 K: {1 {  M
& j! V1 W6 S$ E$ |$ F
# E* h4 ]  _+ Y3 @; ^8 o, q8 Z    }
1 e" g9 b3 U9 g$ F}
* n7 G5 t. w6 N4 b. X) Y1
2
3
4
5
6
& H. K. D" ^1 Y6 ?, ^& n7
. Z9 ?0 j( T6 W- n: s8
! B1 ]4 \* d" K* A& z* b0 @9
10
11
12
. f; u& p! U- P3 E  K13
14
  s+ M* Z: L" m15
16
3 I5 `$ e. d; C) N5 Y1 B+ Y17
18
# N3 k8 p" h' {- ]" K19
1 G% q6 @3 R$ r; W20
21
3 h5 ?- T+ E' R; p8 X) E8 u4 E22
23
24
25
26
4 ?/ Z7 u& p. s! B6 U' T# y  P, o27
# y6 S3 K- X# O3 v7 b) J" N$ s& P7 V28
: F; r& A2 r4 z. L2 f: X* L29
6 h9 x5 f6 a6 Q5 q) s, d30
31
32
33
( p% S: B- V. s7 h$ b运行结果：
8 n) B8 J# h' @# T1 T
2 A6 b/ m! ?  v8 M; {; y& y
: Z# G, U- z4 E& A- [测试冒泡排序:
-66 -13 -1 1 4 9 12 25 25 26 34 47 58 99 162 10093
1
7 g  j# h9 Q; e+ ^( N# w2
降序排序（从大到小）
. r/ |) H; V" k" w
2 m9 r! @. y+ V  g8 H
//测试冒泡排序
System.out.println("测试冒泡排序:");
temparr = nums.clone();
( _+ q9 A: z- cBubbleSort.bubbleSort(temparr,false);
$ L5 m- q; g# t9 |/ Pfor (int i = 0; i < temparr.length; i++) {
* S% [6 I# j- s  U4 B    System.out.print(temparr + " ");
  O9 q$ d6 O( R. N}
System.out.println();
! I$ s5 `% q; V# k6 W1
% [4 K. A& n# q  K% _2
) {+ Y2 c3 ?$ p9 y3 L2 i2 I$ m5 I; }3
( _. n8 r+ I1 f4 j5 `' F4
) }# {5 c7 ?& P$ w5
6
; e/ {3 {) n# b6 y& ^+ l9 R/ `7
2 f) c' `8 \# B8
运行结果：


& k% ]3 S! b- e* x% ^: i2 p3 c测试冒泡排序:
10093 162 99 58 47 34 26 25 25 12 9 4 1 -1 -13 -66
1 O) P9 h. p2 _0 V0 Q5 ^4 b- p: E1
2
9 D- ~. i) t, `, G: c# G' i- f下面几个算法的测试也就是换了下类名和方法名（换成相应的排序算法），如果想降序就在数组后面传个false即可。我就不一一复制了，我在最下面给出含所有算法的测试类，需要的自取即可。

8 d6 k: L  S3 w2 L+ k# l8 C* _: l
快速排序
' c4 w6 ?3 |* f, _; J简单解释：
( K6 J8 N7 q. s. e+ J快速排序就是每次找一个基点（第一个元素），然后两个哨兵，一个从最前面往后走，一个从最后面往前面走，如果后面那个哨兵找到了一个比基点大的数停下来，前面那个哨兵找到比基点大的数停下来，然后交换两个哨兵找到的数，如果找不到最后两个哨兵就会碰到一起就结束，最后交换基点和哨兵相遇的地方的元素，然后就将一个序列分为比基点小的一部分和比基点大的一部分，然后递归左半部分和右半部分，最后的结果就是有序的了。

3 Q5 y; ~6 T9 n( x3 p1 ]& q9 \
% ]. B' W, h) \; `

5 S2 O- r2 E) l4 s  I, [+ l( Y% Z3 I
, e9 ^$ k( U  ?. A
4 u$ W7 b0 O6 [% Q完整代码：
0 K4 S/ u! D: g

package com.keafmd.Sequence;
' P# M. i& u6 L) z1 }  `$ n2 }: e! t

/**
* Keafmd
*
( S( ^" J; |% J: ~9 F * @ClassName: QuickSort
1 X' O- a5 g" H3 h. ` * @Description: 快速排序
* @author: 牛哄哄的柯南
7 d$ w* c7 Q: ^  k! |) K * @date: 2021-06-24 10:32
  m: L6 e$ Y4 P2 n */
public class QuickSort {
$ k& r( ^2 v2 i& ?2 v2 e+ u7 K
8 u8 m/ p8 ~  h" S+ x
" J7 t9 `: f) S8 F) U. b# q    //快速排序
! F# H9 o2 \- T8 m1 x    public static void quickSort(int[] arr) {
$ [5 T7 W1 A) ]0 I; k        quickSort(arr, true);
7 x  E1 f- ~: S$ ~; n6 D    }
  c& ~1 d0 ^3 k, x

, v- u* j4 I; ~" _* u! A    public static void quickSort(int[] arr, boolean ascending) {
# |) q: K% Z1 W$ N        if (ascending) {
            quickSort(arr, 0, arr.length - 1, true);
        } else {
; i  x9 K, u, l" d* w            quickSort(arr, 0, arr.length - 1, false);
3 i& G! D) H8 p4 Z" \        }
" \! ~: ~# w; O; O/ H3 l    }
- ?1 k- t0 P' B6 Q8 f1 B' y

+ F1 u% q) P( D5 \) P4 n6 R    public static void quickSort(int[] arr, int begin, int end, boolean ascending) {
        if (ascending)
: g1 e3 b* X3 i  ]' H3 P8 C' a% T            quickSort(arr, begin, end);
$ [" ]& }3 J1 z% ^- Q3 R3 q- {        else
0 `! p; o+ r: E, t( c+ _            quickSortDescending(arr, begin, end);
; S. K+ ~0 \4 F- d, }( @2 h8 a6 |    }
, v4 N  _* f6 ?+ k, ]

    //快排序升序 -- 默认
" X3 K3 m* Y0 J2 c* ]8 Q    public static void quickSort(int[] arr, int begin, int end) {
5 W1 d; i7 T6 x- L- q        if (begin > end) { //结束条件
$ o& B" c! N! @' s6 `* ^* T            return;
        }
        int base = arr[begin];
: U5 D1 r% W7 g2 ?2 p        int i = begin, j = end;
        while (i < j) { // 两个哨兵（i左边，j右边）没有相遇
9 J/ L  t# {0 H  y( [/ E            while (arr[j] >= base && i < j) { //哨兵j没找到比base小的
# w2 P% }) v2 b& d% {  V9 E8 o                j--;
& G" f9 T3 Y+ _5 m& j6 ?            }
* y5 W! W/ V# i+ Y1 _. a            while (arr <= base && i < j) { //哨兵i没找到比base大的
( `. Q+ j3 S$ q+ |7 e7 G                i++;
% ]- O# o$ b, k6 @: C9 i7 Z            }
* j; m. w0 U8 D            if (i < j) { //如果满足条件则交换
                int temp = arr;
                arr = arr[j];
$ Z+ g* Y9 p* E0 y# n& V+ c) x                arr[j] = temp;
. C2 b6 h1 k. p9 v4 x            }
/ N* n# i  S. L* U

        }
        //最后将基准为与i和j相等位置的数字交换
        arr[begin] = arr;
. _/ B& I/ d2 l9 ?: Q9 w        arr = base;
        quickSort(arr, begin, i - 1); //递归调用左半数组
+ B0 l8 j+ x- T" w& E        quickSort(arr, i + 1, end); //递归调用右半数组

4 |1 m, @: G$ o
    }


  _& e2 l) B- |) B% e    //快排序降序
    public static void quickSortDescending(int[] arr, int begin, int end) {
0 r. U! {. ]# N2 k( K. Q        if (begin > end) { //结束条件
            return;
        }
        int base = arr[begin];
        int i = begin, j = end;
        while (i < j) { // 两个哨兵（i左边，j右边）没有相遇
            while (arr[j] <= base && i < j) { //哨兵j没找到比base大的
, J% d# D; T4 x& c# e% f/ O                j--;
; K5 \+ {* F) E0 F' j* _0 O            }
            while (arr >= base && i < j) { //哨兵i没找到比base小的
                i++;
            }
7 P- L1 E4 |, }) X' r. J5 I- v' }. S            if (i < j) { //如果满足条件则交换
7 j7 e7 F3 P: o2 D( g! H& p0 s- u6 B: k: _                int temp = arr;
                arr = arr[j];
3 J1 R9 `3 V! k: ~4 E: ~) A: B                arr[j] = temp;
* n9 @* N$ X* P* b5 T            }
. T" `# m% Z! A+ G* j1 f) h

9 n6 |2 O' o- _: d! J        }
/ R' l6 W! x2 _% E        //最后将基准为与i和j相等位置的数字交换
        arr[begin] = arr;
4 v. q; e) ~$ s) [4 p' W8 M( t        arr = base;
8 @+ J3 v0 J0 e8 j        quickSortDescending(arr, begin, i - 1); //递归调用左半数组
+ y+ G& e9 h) L/ V2 F, a        quickSortDescending(arr, i + 1, end); //递归调用右半数组
0 C  G1 i& u  j0 A5 i- i; y) }
$ w6 w) B3 z' E' r; }( i9 S9 C3 I
    }

4 K3 F* D8 f2 a: r$ `
6 v5 R7 o/ j$ f) M}
8 E& F$ R. j. w: G1 _1
; A1 @7 A9 O0 O: s9 |2
3
+ }2 J/ K" n% t8 D; E/ K2 d4
5 g+ e" x# R9 _6 ?) J5
6
  q  b9 U$ A! f. T! L7
8
9
" `3 e1 F+ X9 n% S  U/ A( K) I10
0 Z: T  y) g$ ~$ Y4 P- P) x+ V$ k11
: z) `& L( P" s0 T( Y, y4 a+ C12
' w3 a: I& K- h& M" L13
14
" T/ m% H/ x! `, R9 U15
3 g! c" P+ T7 \. V9 c3 ?16
) {0 {6 g  H, Q8 m; ^2 T17
18
19
20
21
7 H; k. H/ @. ?/ ]$ v* x! ?22
23
# T8 t) |- M/ r24
25
26
27
+ q1 P" C' z# y28
29
30
31
32
33
  @: B  ~8 D* \; w( N# @34
  `. S* {$ d, O: S2 o8 Y$ t35
8 @; v% m' Z1 ]) q( b3 v0 g36
37
38
39
9 z0 g* U( |2 r8 a4 ]/ Z; ~40
41
" }1 V: ?4 T, J$ V4 I42
43
44
45
! m5 u. Z  M7 |/ S7 S! j1 Y46
  k* B8 R4 E0 {0 B) J9 L$ Y, J' v47
48
3 p1 L2 E# E) l; x4 x% N49
50
51
' f$ E2 b; Y; ]52
53
54
55
: G: Y7 b4 x; F" a2 t4 j56
8 l& Z( R& J" E% [" t57
# I0 n0 {7 L$ U58
59
: D, d) O8 ~: M9 k; E5 [& N60
6 ^: L& M/ X& e" H% b61
) ]8 X2 u1 ?1 J* k9 B: d62
63
64
0 D' T) ?" h4 U, O65
66
, {. d( F. ^8 K6 p( G* K% O67
68
69
- z# Z/ ]+ p% J$ R2 E1 m; p70
5 f2 K4 M- q" V- O, ?, O' ]/ I71
72
73
74
75
6 T; \( w" b3 W5 G- s76
77
- d+ ?& \" S  f78
79
/ x( Q5 W/ x9 S6 k* t80
& c1 U. w( ]/ s% ~6 F- ]81
82
( W& r' |! F& W6 Y83
84
7 {/ x7 r& w! L% ~* d  n85
% `" O) O  D3 b* V2 x86
* x, S! Z* d- x87
88
89
90
! b, Z: W0 l; g% f8 a91
# ]0 X* [# O) u3 j! @直接选择排序
" A8 V( h3 U1 O9 B7 [8 R3 U5 e简单解释：
0 z/ z0 C0 j) `6 {$ F数组分为已排序部分（前面）和待排序序列（后面）
第一次肯定所有的数都是待排序的
从待排序的序列中找到最大或最小的那个元素，放到前面的已排序部分，然后一直找，不断缩小待排序的范围，直到所有的数都是已排序的了
% B2 W' L& A$ q3 ^: ~9 y) @$ b
5 k. d8 D7 X, d1 Q$ l& c2 x/ d
( o5 A2 R* y3 }


0 {0 K; a8 s- c# E* i4 Z5 A% X4 O
! x# V  F: z' ?0 ~; W: P完整代码：
0 {# @5 c) [! r" g! y! _1 h3 _( F) P& T

+ d; ?  w2 W" b" hpackage com.keafmd.Sequence;
6 t  l  W4 h" E: u! K% H3 L  v
) k: f: e$ \0 q
/**
* Keafmd
*
* @ClassName: SelectSort
* @Description: 选择排序
* @author: 牛哄哄的柯南
7 S4 U3 h. J$ ~ * @date: 2021-06-24 10:33
*/
public class SelectSort {

' V  U" y' D& ^4 I
/ i. v9 v( `) A$ }    //直接选择排序
7 Q! U0 a# N) r9 S    public static void selectSort(int[] arr, boolean ascending) {
        for (int i = 0; i < arr.length; i++) {
6 X! V( b# E6 F# F0 ^, G            int m = i; //最小值或最小值的下标
, i% C1 T# z& }8 F            for (int j = i + 1; j < arr.length; j++) {
                if (ascending ? arr[j] < arr[m] : arr[j] > arr[m]) {
8 T% I# W1 ?& w                    m = j; //找到待排序的数中最小或最大的那个数，记录下标
' j1 H6 ~; k5 H5 ^) Q                }


" {( i& S0 V$ S2 z8 c" h( H6 A            }
2 e% j3 ]/ I( e. }* f: K' e            //交换位置
            int temp = arr;
9 @) U2 H4 N# U' g            arr = arr[m];
/ J" J3 J) @6 k' j0 o8 e  ?" g            arr[m] = temp;
! d1 _' g( i! E+ M9 F: d

. Q3 q' X/ N7 ?% ]        }
    }
* p# G2 w# H4 G' H* @
2 v4 i/ F9 s6 d; q! i
    public static void selectSort(int[] arr) {
8 ]) H4 [$ v- M        selectSort(arr, true);
    }
}
; M; T; L6 j. m4 ]* w1
2
! ?4 H( H- H: J3
7 p! K+ X* i7 R3 C4
4 P9 M) Z5 u, `# y; y) C- M5
6
% ?2 }- _3 S0 z' t) [& t% F7
8
9
10
11
7 m3 L) E; l+ l12
13
) d7 c/ F3 }, s8 l  Q14
15
" d- [$ m; o( L) x% I16
9 v! k2 W( V& f- O- @% [17
' w. U; @4 P* h0 R' R" M) r- l; u0 g18
19
, n. B& ^+ ?1 I2 k20
21
22
23
24
25
26
27
28
29
30
6 T6 U" F9 E& C/ H$ _$ _( Z( b31
3 E8 J+ m; M2 Q# u32
33
2 E9 l. J' w9 ?0 S* C" B6 \2 T' H34
% i) ]$ a. @& K0 u* C: f0 h# T' @堆排序
先理解下大顶堆和小顶堆，看图
大顶堆，双亲结点的值比每一个孩子结点的值都要大。根结点值最大
  x% O& y. s$ z7 w7 D" m: e3 I小顶堆，双亲结点的值比每一个孩子结点的值都要小。根结点值最小
3 S/ y+ O4 A- m, c& n7 N/ c& S



简单解释：
( p: q! |2 l& k! r构建好大顶堆或小顶堆结构，这样最上面的就是最大值或最小值，那么我们取出堆顶元素，然后重新构建结构，一直取，一直重新构建，那么最后达到排序的效果了。



# b  L7 f( M  @7 |7 F( }; T

$ l' X5 p6 L- j
完整代码：
# ?0 F# m4 i* [, z" N4 h

package com.keafmd.Sequence;
5 P5 p) V5 G/ T& O4 e

/**
( q; ~0 v) M7 j& M$ ^( t1 b( d: S * Keafmd
*
  \. M4 |' `+ ^- Y9 G6 \9 f9 r  n * @ClassName: HeapSort
0 z9 [. m: S( [. z% ]1 W * @Description: 堆排序
* @author: 牛哄哄的柯南
1 ]% @8 I4 w1 M, O) h0 d8 |! c * @date: 2021-06-24 10:34
*/
+ v! `$ @, {4 f* p" [public class HeapSort {
# P2 b! `: _" i8 R: p

0 C6 F8 q, S( w    //堆排序
    public static void heapSort(int[] arr) {
        //对传入的数组进行建立堆，这里默认建立大顶堆，进行升序排列
& W8 {, J4 x7 {+ [7 }        heapSort(arr, true);
    }
7 W0 \2 a: k: m8 C2 D) l6 c

: O6 O; h5 y. x# k5 }$ l3 Q) S; u; |    public static void heapSort(int[] arr, boolean maxheap) {


# T/ B; [2 [4 \0 }7 Q        //1.构建大顶堆
        for (int i = arr.length / 2 - 1; i >= 0; i--) {
& E. d5 A8 a; J- d9 W. c- p            //从第一个非叶子结点从下至上，从右至左调整结构
6 o! G8 X. I- x: y/ L, Y2 M/ q$ B            sift(arr, i, arr.length , maxheap);
        }

( ?$ x+ r( l6 O2 M( R+ w+ _
        //2.调整堆结构+交换堆顶元素与末尾元素
        for (int j = arr.length - 1; j > 0; j--) {
( D( V8 v% O  [5 z: _7 N

            //现在的数组第一个就是根结点，最小值所在，进行交换，把它放到最右边
            int temp = arr[j];
, g# B' r5 ^# m& ~" c! M            arr[j] = arr[0];
            arr[0] = temp;
2 M. X6 @$ e5 i0 P( z/ v% K

            //重新建立堆
6 Q% U+ C1 x: M3 b0 U6 s            sift(arr, 0, j , maxheap); //重新对堆进行调整
, V( c8 H# w) c- `2 d# }6 ]        }
    }
9 R" A$ V) j" g7 D) Z$ M+ }! X* B" B+ K
: Y! M4 M" T( P7 M
, A( i% ]6 i1 ~9 @    //建立堆的方法
    /**
     * 私有方法，只允许被堆排序调用
     *
     * @param arr     要排序数组
# k, Y( w+ M. u: O. Q7 X* \     * @param parent  当前的双亲节点
  p4 p* k: o$ z     * @param len     数组长度
- k7 u9 V. t, f$ Y     * @param maxheap 是否建立大顶堆
( V8 `3 H0 z+ ~6 N2 N     */
$ ^- u9 V% [8 ]* ~, J# ]    private static void sift(int[] arr, int parent, int len, boolean maxheap) {
( u4 g( a1 B8 t% O; N, U

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


. Q  c/ j* {! _; j0 V3 z. _        for (int child = 2 * parent + 1; child < len; child = child * 2 + 1) { //从parent结点的左子结点开始，也就是2*parent+1处开始


( z' u" ~* C2 b5 x( k            if (child+1 < len && (maxheap ? arr[child] < arr[child + 1] : arr[child] > arr[child + 1])) { //如果左子结点小于右子结点，child指向右子结点
                child++; //右孩子如果比左孩子大，我们就将现在的孩子换到右孩子
            }
1 |; q6 C5 V+ ]* \$ R
4 m+ d5 r- `& v+ w+ B# w3 Y4 q
) \) |7 C) k) b# I            //判断是否符合大顶堆的特性， 如果右孩子大于双亲，自然左孩子也大于双亲，符合
9 [4 `; l9 Y5 j            //如果子节点大于父节点，将子节点值赋给父节点（不用进行交换)
            if (maxheap ? value < arr[child] : value > arr[child]) {
# M2 f& m. Q# P9 ^( m  E$ S* L                arr[parent]=arr[child];
+ G0 M+ a* R2 d* x                parent = child;
            }
* J9 ]% Q3 V8 g% n2 ]            else {//如果不是，说明已经符合我们的要求了。
                break;
; \; m: `' l/ F# U, R) ~3 f, ~            }
8 I0 X& @) g5 }- d2 G        }
        arr[parent] =value; //将value值放到最终的位置
3 T" [- f+ a  W
) y0 B" H6 r/ N1 G5 [


    }
4 V3 |& I- u  E8 q; g' K
1 W, y2 M$ C! j
8 I# ^/ u+ c6 I}
1
) H. g# e# g# T6 r* T- A2
3
4
& q- ]6 f8 m3 q, m6 m: Y" C! r! r5
6
* d8 Q  {9 w8 d3 c* I$ J3 g7
) {' n% N5 I7 N3 }9 e/ h8
9
10
11
2 ~$ b# G" ?1 T, z. i: u12
$ l8 I' s7 x( b13
/ ?& P9 J- ^# G5 P, V0 S! w. [14
15
16
$ I& s" Q8 Z$ t3 p, I" E! ^  X17
18
! A' S8 D, d. f' @19
20
21
22
23
# k8 `) n: B& B# u; [1 U24
25
$ ?; ?2 _' J3 f26
* s& L* W/ H! @7 z' m4 |27
! u' P5 m& k  P) H& Y28
29
/ X' ^7 b! y5 `  b' g+ Z5 ^30
6 H1 o! A* a8 C$ Z31
32
33
2 ~" {( Y1 b; I1 a34
35
36
37
38
39
40
41
42
43
44
1 t2 P. L) u# _6 c5 A, y* z) \45
46
47
48
4 U. X5 Z. x, V" {$ b0 S49
5 I+ h' V9 W* m2 g" Z50
51
% s- o% x, U5 e2 d2 v* [. c# Q5 H52
& d5 A* q+ X3 E/ i/ [53
54
9 i" N8 o3 L; }/ z55
56
57
58
8 {& J1 C" l) Q) i2 Y59
60
7 w5 t% i6 k8 v+ |8 m7 H: w61
62
5 s# Z' I$ d' O5 w" d! E2 @9 a63
3 v  B5 p  C" H: p! j! I64
3 I5 a/ u% t8 P% y# c" g5 d65
66
3 ]6 L! ]- L+ X67
& f/ q5 l3 ?" y  N68
69
( d6 `$ l  z9 D& i8 s7 v: B70
71
72
: D* l: D* i* {. x8 H6 n4 a3 ?73
74
归并排序
简单解释：
- c4 g* S( R+ c( g; o该算法是采用分治法，把数组不断分割，直至成为单个元素，然后比较再合并（合并的过程就是两部分分别从头开始比较，取出最小或最大元素的放到新的区域内，继续取两部分中最大或最小的元素，直到这两部分合并完，最后所有的都合并完，最后形成完整的有序序列）
- I( w% X) p* U* H# f0 d
+ |" i* V8 j' ?( [# M, A* ^

+ z; L) E3 J/ u1 X( ~
2 _  [" ]$ [) ?% ~, ^
, R6 u; N, Q) F3 k( E& k- H4 |+ I
完整代码：


package com.keafmd.Sequence;

0 Q5 l+ \+ ?  `; y4 D
/**
+ |  y, [. y; Z * Keafmd
*
* @ClassName: MergeSort
* @Description: 归并排序
* @author: 牛哄哄的柯南
+ l7 J% j+ y8 y" D4 v# \1 M4 i * @date: 2021-06-24 10:35
5 }2 n  Z% {: N */
public class MergeSort {
- j9 N1 w0 l4 @5 C0 b& c

! s( j$ I" }1 W* x8 q, o2 `: W    //归并排序
$ W( t; ^; w* j  `' l- a    public static void mergeSort(int []arr ,boolean ascending){
        int[] temp = new int[arr.length]; //在排序前，先建好一个长度等于原数组长度的临时数组，避免递归中频繁开辟空间
; q" b% b! |& ^$ p$ i3 M5 p* ~/ ~        mergeSort(arr,0,arr.length-1,temp,ascending);
4 ?( l1 v- n! M: a% e1 [4 ?# g" \    }
    public static void mergeSort(int []arr){
        mergeSort(arr,true);
+ a. ~/ h1 s' ~3 |9 ^    }
6 X- j- r$ @( C# N
% T2 O0 k/ X' g* \+ K
& _6 W! i9 `) ?5 i* S8 P6 p    /**
$ f; Y9 I: e& O: S) _% C     *
) P% ^: X1 k' u$ X4 v6 e8 W     * @param arr 传入的数组
     * @param left 当前子数组的起始下标
     * @param right 当前子数组的结束下标
7 e2 B4 M3 M" I5 j) F     * @param temp 拷贝暂存数组
0 P  n6 q4 L$ g4 c" [6 l     */
- R/ F- V7 }0 [& m    public static void mergeSort(int []arr,int left,int right,int[] temp,boolean ascending){
        if(left<right){ //这里是递归结束的条件，我们是对半分，那当left==right的时候肯定大家都是只有一个元素了。
1 Q" y" h$ X3 e+ ^& o* e* G

8 P7 `% D7 L5 c5 s, Y4 f9 D* I            //对半分，比如总长度是10，left=0，right=9，mid=4确实是中间分了，0~4，5~9
! y- q8 _; x7 ]. U! \# r! G( x            //当长度9，left=0，right=8，mid=4，0~4，5~8
            int mid = left + (right-left)/2; // 防止越界的写法
            //int mid = (left+right)/2;


            mergeSort(arr,left,mid,temp,ascending); //左边归并排序，使得左子序列有序
, _, n: P& m  F: p1 {. V# t3 X+ I            mergeSort(arr,mid+1,right,temp,ascending); //右边归并排序，使得右子序列有序
$ C( ]2 X5 B  k+ ~6 H

            merge(arr,left,mid,right,temp,ascending); //将两个有序子数组合并操作
8 x8 g- H- r* t$ t1 p7 Z        }
    }

' ~8 H! S- x  K  B: B6 c& I  k
9 @# X" u4 @2 N0 G    private static void merge(int[] arr,int left,int mid,int right,int[] temp,boolean ascending){
        int i = left; //左序列起始下标
        int j = mid+1; //右序列起始下标
5 h) m% |( f. v% l        int t = 0; //临时数组指针
        while(i<=mid&&j<=right){
. _& C6 T2 s0 ?* B/ `            if(ascending?arr<arr[j]:arr>arr[j]){ //比较两个序列第一个元素谁小，谁小先拷贝谁到temp，然后对应子序列下标加1
                temp[t++] = arr[i++];
$ q( S, }$ c( y" ^4 J            }else {
                temp[t++] = arr[j++];
            }
        }
% M& |( _6 V" z# a7 J" a) S  T

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

" g. y9 o; w. H0 v: l% A# j* K
0 l6 j. ?9 U, \9 `        while(j<=right){ //将右序列剩余元素填充进temp中——右序列有一些数总是比左边的大的数
            temp[t++] = arr[j++];
% x: H9 Y3 M1 b0 z        }
7 a6 n2 }+ X% n1 |  ]4 p0 C3 t

9 l' l: u0 }. {  j        t = 0;

! f, _7 }, E% M7 H9 s
        //将temp中的元素全部拷贝到原数组中
        while(left<=right){
! s, ^6 ^# }! {* s) B* O# x            arr[left++] = temp[t++];
, N3 r. u5 Z: M9 \( H        }


    }

5 L! A+ F1 [2 E( m$ d- J8 Y
}
1
2
3
6 j% p- y9 B7 J2 h; W4
5
6
% o! F/ y$ Q1 w7
8
, ?, E# {6 B& S- }2 u9
10
11
4 ?4 x" Y) J0 D+ @/ V12
13
, B* V6 x1 ^; I& i14
# H0 `: z% Z- L7 d& i1 j* j  B15
$ c7 H9 t: k, @8 G0 u* s' j0 D& q16
. `/ z0 `+ L( N. R$ `8 `17
* z% @% f% c( c2 l9 Z- ^; P$ m18
19
# ^5 I! J* L6 y& ]; ?3 Z20
21
2 a! J7 f& Q6 {22
23
* e$ q' y3 @  i- X9 C24
25
8 ^- h3 R: i4 I8 u" Z7 o2 u5 g26
" Y" ?4 D, O- G& T$ s; T" j, ]27
$ d. M; N& p; \( h28
9 h) f: @5 v* t2 K6 e& P/ Z9 }9 P29
9 T  b) q/ k1 a3 F2 g- Q  U6 `( z' r30
31
, `6 N2 g; Z: b( P/ j. V! J* L0 c7 b32
" K8 a, d7 I/ j$ y& F+ R# p3 U- P33
34
6 \; p& ?, ]+ e35
36
# t2 o! x5 G/ p37
38
39
40
4 y1 c4 O7 x3 Z41
42
43
44
; G- D2 u% N7 C* u45
3 e8 t, ]; A8 M! I6 a% y0 [46
47
48
49
: U2 c1 n/ J0 u! G# |8 L50
/ W7 U) _6 P1 M+ k, K; ]51
4 e9 A! v0 Y$ a3 O, S52
53
: w  u! q: Q2 p" X: b' r54
55
56
' W/ o# A% a) Q& e8 _/ M. G57
58
- E2 c3 D0 d% c, n- D59
60
0 @' [6 N2 L  c' m) ~) }  ~61
62
" I! S& U8 g3 @, a& _- f7 Y63
( O$ s+ C+ ]1 k) |. x& z; B/ d3 g64
65
66
) j% s  h& l% t1 m67
$ W3 u5 r: j6 r6 y) f68
. l3 e/ W2 k8 p5 e69
70
& j* c8 _" ~/ {" Z71
" P% S7 d* v1 z' d0 e# t2 ^72
+ _) F) R( G# ]9 ]9 I$ Z! `- D73
- b  W" R" m* O2 R; v& }插入排序
简单解释：
最简单的理解就是打地主时我们拿到牌后的整理过程，从第二个牌（假设我们拿起来这个牌开始比较）开始，（说下升序）从后往前比较如果比前面的那个牌小，就把牌往后移动，直到找到一个合适的位置（这个位置的前面的那个牌不比这个要放下的牌大）就把这个牌放到这个位置，慢慢的前面的部分变得有序，直至全部有序即可。
9 N7 Q9 f! O) d) {

- v8 Z! x: c% s  `" _) ]
+ \* B3 p/ |6 G. k7 u. G
( \! }! `( h3 ^% m3 _( X" M

完整代码：

' l5 N6 j+ v6 k3 w" b3 r* Y
* s) R$ m; K6 H" A8 Gpackage com.keafmd.Sequence;
& p% N9 v" |* ~2 C9 B0 y3 }% }
: j6 z/ p9 ]) ~# [  l2 m8 N
/**
/ a) `8 Y8 G$ z& L * Keafmd
*
* @ClassName: StraghtInsertSort
* @Description: 插入排序
6 Z$ \9 n; Z- T8 M/ x! I4 Y$ F) s. [# K * @author: 牛哄哄的柯南
) a" y& n) y6 F; y; V * @date: 2021-06-24 10:36
*/
public class StraghtInsertSort {
    //插入排序
: C: y. u/ \; H3 G! ]1 v  j    public static void straghtInsertSort(int[] arr) {
% r8 ~! D1 d& q        straghtInsertSort(arr, true);//默认进行升序
- z: d6 G2 d1 W8 s    }
: U: \! T' E2 Z9 I* ]

7 C3 d& I+ y" q/ y# c7 u    public static void straghtInsertSort(int[] arr, boolean ascending) {


: J! I. E; h( M- o! O( R  n4 i. ^        for (int i = 1; i < arr.length; i++) {
            int temp = arr;
            int j=0; //这就是那个合适的位置
            for (j = i - 1; j >= 0 && (ascending ? temp < arr[j] : temp > arr[j]); j--) {
9 e$ v# d% \$ r5 \* u( e7 R                arr[j + 1] = arr[j];
1 P% H: Y) `- G' s            }
            //把牌放下，为啥是j+1，
            //是因为上面的循环遍历到不符合情况的时候 j是合适的位置的前面的那个数的位置
/ M  F: Z4 j9 l+ H& F( q6 o            //有点拗口，但是就是这个意思，看图方便理解下
1 F( U# ~1 z! z& J. v1 q            arr[j + 1] = temp;
3 c1 x# p2 ~( V$ f; Z8 N
2 s0 U* C% H# m0 o) l$ R9 A$ u
/ v. ~  {4 z  {
2 k. r+ v. P$ a) u  T* p, L1 ^% [
4 N/ o  }% h, {        }

* z# O( V% u4 R1 s( `
/ Z2 ~' w! l! d/ C# O. z    }
* A, W; _. C) Z0 P' s6 k$ _}
" q6 c0 ~3 g& O4 y1
* o! ]1 N. H+ o% B% d8 o2
3
4
+ b% c" x2 I; Z9 X5
8 t7 c; E" \& x3 _) S6
7
8
3 T! `! U4 R& F# Q  ]- D/ O" p9
10
11
12
13
$ R" C# T% `$ m9 U- S14
15
16
17
: h9 F& h- V3 n0 X18
19
2 Z" ^; F) C" ~' K  l20
% L& j: T( U& h+ P( z21
/ U2 V, U( @/ C( k& ^: T7 R  L22
23
* U5 M% Y! I" `24
25
26
27
( K$ o# O9 L* c28
29
30
! g7 w! I/ ?0 a) h( e8 }8 `; t31
32
( r* m0 T6 V3 X8 y& [33
& @) J0 e0 y( w; O% Z34
希尔排序
5 G; F7 W. D4 l简单解释：
5 J+ K9 i/ q; `# i; ^( O希尔排序是插入排序的改进版，我们理解一个叫做下标差的的东西，也就是下面那个图中的增量d，初始下标差为arr.length/2，然后继续/2，对在同一下标差（相当于把这几个数单独拿出来了）的若干个数进行插入排序即可。

9 R0 U# E) N* H9 A$ \' b( K



- u' }+ X7 G7 [( Q- T
& p/ U5 o! m9 f$ E完整代码：

! _% R5 a4 \3 \2 k% o6 `% D
, _0 L+ L  W6 a& G/ i% t* Bpackage com.keafmd.Sequence;
2 X) U8 U8 n/ M* c7 @

/**
$ w/ r4 q7 T; H' W * Keafmd
# y' Y/ P  a, m- F( w: a- B; m *
. ?1 I, {7 Z3 I  x4 j3 _. X * @ClassName: ShellSort
/ a4 }! }3 L3 S: l * @Description: 希尔排序
' o  x* Y- y! L, y * @author: 牛哄哄的柯南
$ q3 q' T, f6 g& V8 @- U * @date: 2021-06-24 10:39
. a4 R9 m1 h9 `1 u( V% e% f8 f */
1 W  j4 x  D6 }  M7 p1 s0 t' U! [. Cpublic class ShellSort {
" w: j: J7 |' V) b9 O

3 Q1 R4 E$ Q3 g, ?& j/ ?4 _4 ?    public static void shellSort(int[] arr) {
: K1 R# S5 {1 i( |- o4 o        shellSort(arr,true);
    }
) Y! ~" l- l' F% T% U  _& F* P
, S) _! N2 n5 D0 J! i
) h0 o0 a6 j, T9 B    public static void shellSort(int[] arr,boolean ascending) {

* k2 Z8 A, a* F; g% [
$ W, K1 C$ J8 r. D8 w        for(int d = arr.length/2;d>0;d/=2){

- M2 ~8 S' n4 a; c6 M
            for(int i=d;i< arr.length;i++){
  a  `) l3 ?' I3 f4 m! y) l                int temp = arr;
) h4 p; D8 b0 g                int j=0;
, e7 S8 m+ `# U( w                for(j=i-d;j>=0&&(ascending?temp<arr[j]:temp>arr[j]);j-=d){
                    arr[j+d]=arr[j];
; ?/ C' n4 \, T/ G  ]% |5 G# t& p                }
, i# J/ Q2 j$ h: d                arr[j+d] = temp;
            }
        }
  C. @- C/ H# G: L/ i

    }
6 F' k& G0 f; O, `/ A}
1
2
5 t7 o  Z( a- b7 B# Q3
4
5
+ J4 K* ?6 [3 d3 l6
7
8
" v; ~' z' V' R9
10
11
) p' j( E* v4 J, R$ O. [' p* ^& i12
# p+ S& _) A9 Q13
$ B3 k+ s% t0 R8 y+ R14
# U- [1 w  S9 T; E15
16
17
18
19
20
) P( ~5 a3 m& w. V21
22
, W; @- o  j2 n23
: r+ z. V: L! v& _) k8 C& L) ^24
/ R8 M1 ~6 y2 f25
* Q- C, a6 C8 F8 `26
$ i6 L/ W. G8 t7 }- F27
+ I. |3 l9 k# c) q0 K1 A4 U28
% u! X8 U2 k" B3 ]29
30
; _! e& q8 ~: e3 Z4 j31
32
9 }1 F0 Y5 j+ B3 d2 l计数排序
+ E: k4 d% Y) H2 Y' y! t简单解释：
这个排序算法看名字也很好理解，就是就是额外找个数组来计数，然后在这个数组从小到大或从大到小把数取出来即可。

& }& h  x# [7 f2 Y4 [6 C

# m0 C2 g! {# C( a6 ]
, J, c" i8 U( D
3 b9 K- W; a) ^% C6 a# A3 O3 J0 ?
完整代码：
5 y9 `" J. f. q8 C: k9 m  F. E

2 ^7 b# e& ?) z- ~5 f7 w9 ]package com.keafmd.Sequence;

  ]7 t- M6 P; T. u
/**
, R- C9 b& w' Y- Z6 p * Keafmd
7 t  ^9 N+ m5 O) h+ M$ ] *
: g) r( }+ P5 y3 `/ G * @ClassName: CountSort
* @Description: 计数排序
0 p6 V4 y9 J, k  { * @author: 牛哄哄的柯南
* @date: 2021-06-24 11:31
*/
public class CountSort {
3 L8 R  L: V% k

    public static void countSort(int[]arr){
8 g; p4 i/ l1 h; N: Z# c9 `        countSort(arr,true);
+ n$ |* Y5 X  y! Y    }
6 X1 m1 y3 p' t4 l8 M

    public static void countSort(int[]arr,boolean ascending){
9 H5 K% A9 s0 O  t        int d,min=arr[0],max=arr[0];
& @2 t+ H6 s7 O3 G! h
- \9 R1 D9 g! F1 U, b
2 \( t4 r7 W+ [. r+ G2 D        //找出最大、最小值
" E) M8 Q- H; v+ d        for(int i=0;i< arr.length;i++){
            if(arr<min){
                min =arr;
            }
            if(arr>max){
                max = arr;
% O5 t0 A" l6 P3 P' ~9 a! L# K            }
        }
* F+ a3 B, o& `9 Y* X, F- f9 y9 B! {  a

5 u& A4 U! l$ p5 l% F8 E$ q        //建立一个用于计数的数组
) ]7 G+ Z0 F# L+ d: e7 c+ J# ?; Q        d = min;
  t& c( f. D) y# p3 s        int[] count_map = new int[max-min+1];
        for(int i=0;i< arr.length;i++){
            count_map[arr-d]++;
        }
, M6 ~( n8 U& r( l9 g

. m5 g4 `: l  s9 t) U9 Z        int k =0;
5 o+ c0 z: m( p; z. H4 B        if(ascending){
9 p, K" k1 ]# v            for(int i=0;i< arr.length;){
% c* j( @* L) e                if(count_map[k]>0){
                    arr = k+d;
( X) O# `, i! g) J0 V0 w  N                    i++;
                    count_map[k]--;
+ y* o* m$ l3 |# ?4 N- ~                }else
                    k++;
            }
2 L1 g6 K: y  |6 ?- x        }else {
            for(int i=arr.length-1;i>=0;){
                if(count_map[k]>0){
                    arr = k+d;
: U' }) ^( Z' n5 K1 K                    i--;
                    count_map[k]--;
" w. g5 G' X4 A0 x- E                }else
2 `' V& S' T! M; \                    k++;
, C4 l, e0 z( p6 {8 z, M/ T            }
        }

% F4 w+ o3 v# z2 O; o2 p
8 \# {7 \0 V$ Y  M. }( K    }
}
1
2
3
4
5
- @: m* V* R' @  g2 g/ q! v: K) M. k6
4 B& T& \! B. {* c" v7
8
9
# q9 M" V9 |4 O; N10
11
  z8 q2 W' K, k& H2 k( K12
8 w/ _: x+ k% W0 @* h13
14
15
1 W6 e% m/ M! u# \; l* ^16
; p  I6 G0 M# n17
' l+ l3 G, M  q5 U# {' ^18
2 J, V# \' i6 I19
8 Q7 X2 x& F4 D) h6 G( w  p20
+ \( R" T6 x$ D  U, P21
3 T% @8 Z8 m: h4 T2 R6 j! \22
23
3 _; ?. \$ v  G$ w8 d4 v24
25
26
! @7 P  h* U3 x5 Z9 Q! f27
) U: ~/ R) I* `4 p, J! ^% Z28
29
9 _3 i# {6 ?- r30
) |1 b" i% K: v% U5 O3 c31
32
33
34
35
36
; b! r( w  {! c' X4 m9 g, }37
38
39
% y. {$ \  X* F3 }: g5 w0 j* B) F40
41
. M* q3 Y7 U  \" K* K42
6 c2 m! l! A8 n2 W+ i43
7 g  ]  m! b  ^8 F7 d  y44
45
  i+ B2 T: b: E( u* I46
# A2 _, @8 w6 {/ w9 k# B47
48
49
  _# [, x  R  @50
51
4 ]& d. ^- _# ^- r. l52
53
+ C9 f  V& Q6 R- s+ u54
, z% a  `7 k3 ?$ p& g' L55
56
57
58
2 Z* S+ I" H! ?2 D59
& c' W1 S6 ^. H3 b桶排序
简单解释：
; N2 Q% B- z: b; {3 `* \$ H6 p. ~/ f7 N就是把一个数组分成几个桶（其实是几个区间，从小到大或从大到小的几个区间）装，然后让每个桶（区间）有序，然后取出来放一起就可以了，相当于把几个有序的段拿出来放一起，自然还是有序的，当然需要是按照区间的顺序拿了。




6 O+ z/ u, f5 o$ `( l3 N4 l

完整代码：


% O2 k( ~7 o* f8 Z3 Hpackage com.keafmd.Sequence;
1 T! ^3 v9 `0 f- c( Y" x

% G- G: T) Z" |" i  y: `import java.util.ArrayList;
2 Q7 }; U$ Y. x  w; ?8 V  }( Kimport java.util.Collections;


/**
* Keafmd
" M& V4 f! |( ~( g *
* @ClassName: BucketSort
( J8 U+ V8 e3 M3 I * @Description: 桶排序
$ {. x; G/ A! x5 w: v * @author: 牛哄哄的柯南
3 c6 t& q: Y7 v; R/ e: F * @date: 2021-06-24 13:32
*/
public class BucketSort {
, s. u5 |7 h3 [2 m3 e- A- U9 g* v

/ O2 N; l. f$ g; l5 e& }    public static void bucketSort(int[] arr){
        bucketSort(arr,true);
. r  M  b5 q' i+ }% m1 V( e/ i    }
4 d. Y1 |& v* p4 \) Q7 C

    public static void bucketSort(int[] arr,boolean ascending){
5 x3 G; ~3 v/ x9 o        if(arr==null||arr.length==0){
4 B8 z* x/ O, @" q* u0 {            return;
) A( f$ R4 f0 }: B' D# o        }
7 R; s3 N4 c) f! V- _" f        //计算最大值与最小值
* y2 ?3 g& o' N) v        int max = Integer.MIN_VALUE;
        int min = Integer.MAX_VALUE;
! |( Z- i; |. V        for(int i=0;i<arr.length;i++){
0 O0 U4 W- N: b0 v9 Y, R: S+ r            max = Math.max(arr,max);
% u4 D: Y2 U8 l- i$ ]5 E1 J( x/ P3 R            min = Math.min(arr,min);
        }
8 G! u, R3 w) c* e; G3 P/ L2 c
. e3 F0 ?8 t$ H! \0 w) m# ?; p
1 D( K6 p4 h6 C$ e  j7 c        //计算桶的数量
        int bucketNUm = (max-min)/ arr.length+1;
& Z+ l) j- O1 i6 w* V  y        ArrayList<ArrayList<Integer>> bucketArr = new ArrayList<>(bucketNUm);
/ Q, O2 Y- ]3 S        for(int i=0;i<bucketNUm;i++){
            bucketArr.add(new ArrayList<>());
        }
$ z- w' D( `" s
6 V. |  O, [1 w0 H- S
        //将每个元素放入桶中
        for(int i=0;i<arr.length;i++){
+ R2 V+ d- ~7 I' T( H) L, o            int num = (arr-min)/ (arr.length);
            bucketArr.get(num).add(arr);
1 h0 e3 H! f) M7 ?' P  `3 }9 D+ v        }
$ e! ?5 E2 Z) `" H+ e4 Q4 ^
; h, E2 x) A" B# G2 d) g- `, L
        //对每个桶进行排序
9 L7 T% \  e# G        for (int i = 0; i < bucketArr.size(); i++) {
            //用系统的排序，速度肯定没话说
# \+ C3 z9 H8 r8 I            Collections.sort(bucketArr.get(i));
4 o+ \4 c* {/ I& ^8 A  e1 z        }
! \- E5 _9 p9 B, g+ w
4 C; v) {+ U! Q' K8 H& c. q
. o' Q( _& a6 s# D0 t. X        //将桶中元素赋值到原序列
        int index;
        if(ascending){
            index=0;
        }else{
            index=arr.length-1;
3 L8 U4 S' a* k( t        }

7 n. B, B3 I( A3 @& E. R
5 o, a! D9 I3 f. c+ p4 W        for(int i=0;i<bucketArr.size();i++){
            for(int j= 0;j<bucketArr.get(i).size();j++){
' M) S& p$ i4 r# Q' r2 y$ C                arr[index] = bucketArr.get(i).get(j);
                if(ascending){
                    index++;
5 b! z- h9 }# D* q' X2 f                }else{
                    index--;
                }
            }
" _4 ~2 v2 k) C$ c; \( }
( y, q" \) g# X6 @% s
        }
0 I% L+ s) Y+ j7 ?2 X

/ @9 J1 B" m4 c) t3 S3 x, n    }
0 X" n) T8 s2 A5 @0 @0 Z+ j' g0 o}
7 l( q( K0 k! G2 w  V, {+ e1
2
3
4
5
; G! W: i8 S. Y6
) P" |3 J. K: j7
8
: L1 @, T) y2 n+ u( `0 _9
3 n9 v- i3 q7 p' ^; h. Z! R10
11
: I! O0 c* @# A12
13
& q$ I) ]- K# ?14
15
16
3 u$ x  M5 l' c0 e6 Y) \17
4 R& m: S) t. x3 a* d* B3 b18
# i& `+ V4 C& Q" L19
20
+ k- w1 n/ G: y& E& D* X1 v21
/ t. T2 ^) o9 F9 m( W* c22
- g) o7 J' t; I3 D% _# B0 e- P+ T23
3 u( z/ `# x/ }- ?( |24
7 h# r& b, o; X) b1 J25
, I. {  b2 C: y: e* u; J. u( ^+ E26
* h! }8 F2 q) j6 K$ f27
28
29
  n1 W* [; P7 O30
31
32
& a- G9 ?% q" p) O33
34
! T; Q2 z0 L$ m2 `, Y% B: s+ {35
5 q# q/ _( I7 z$ Q4 d36
37
1 }# H% Y8 ~) i, M& Y. j9 h6 u38
39
: C2 v# h4 V* x8 L7 r7 f+ W40
6 ?2 u4 j8 s3 d$ F1 U# G3 N! e6 y41
5 A5 v" g2 v% A+ a. i" Q42
43
44
1 u( J. \4 F( u3 A45
46
47
48
49
50
51
* t8 g! p, T( v8 M52
+ O2 I& T7 I8 S- h53
% g! ^. K) O5 S  R" `7 T( P3 a1 {54
6 ~7 `* Y! K0 r55
  ^8 B4 o& h8 R) {& w56
57
58
9 W( Y+ f; G2 R4 q5 @# z! p8 k59
/ e/ B; p* ~! G3 l60
7 X+ v( A! u& f7 ~& L2 o0 E% c61
& v$ t) W, Q/ S. Q62
63
0 u* X8 b" G) E. Q; f! b64
! ]" h# ]/ e' }8 V4 `2 y' S5 v/ i65
3 k9 Y1 J) P5 L: p2 Q66
6 S! j' t* `$ V. O67
1 |) r2 T* y0 r% V  H68
% _6 E  g5 A/ z2 V( @* f8 }& P' N69
6 b! E1 M2 ?$ {8 E& C3 ~70
71
: k0 Q# A' A! m2 `  V  x! v72
; Y. J8 n+ V$ {5 B' @5 B  P: ^基数排序
( N5 g- P( U! _! A简单解释：
首先说一下，我发现好多人写的基数排序只能排序正整数，其实只要处理下就可以排序含有负数的了，就是我们排序前先把所有的数整体变大（就是减上最小的负数，也就是加了），都变成正数，然后排序好之后，在减下来（加上最小的负数，也就减了）就好了。
基数排序就是按数位排序可分为LSD（从最低位[也就是个位]开始排序）和MSD（从最高位开始排序），下面写的事LSD基数排序。
! U) v7 o; I( k' v- k1 K; o& Q7 @! z: Q基数排序就是把数按位考虑，让后我们一位数只能是[0，9]，就是我们在考虑某位（个位、百位· · ·）的时候就只看这个位的数，放到在[0，9]相应的位置，然后顺序取出，最后再按其它位这样操作（上面说了要不从低位开始到高位，要不就是从高位到低位）


. q8 b3 Y, }8 |3 m% C/ o+ A/ i



完整代码：

9 ~2 ~" R: Q  ]) `  g
/ s: u7 B+ ^; `6 T0 _( r' P5 |7 Y: N: Tpackage com.keafmd.Sequence;


/**
. m5 U! |) Y0 T# A1 Q: V * Keafmd
*
* @ClassName: RadixSort
9 x9 }0 ?! e, G9 p$ g. j9 p * @Description: 基数排序
1 y2 b3 R2 @% ?( ?7 K( r- U * @author: 牛哄哄的柯南
  e9 ]! G7 g8 S. `( e * @date: 2021-06-24 14:32
6 i; |) D4 H" l; F! l */
. d- @6 s$ V+ g9 s$ G0 m: q$ lpublic class RadixSort {
    public static void radixSort(int[] arr){
( l  T! Z6 {; }2 I        radixSort(arr,true);
: p3 C5 |6 m9 E2 c5 c* g) J    }
    public static void radixSort(int[]arr,boolean ascending){
- [- M' g8 ?) f, N        int max = Integer.MIN_VALUE;
8 V8 H) A# t4 J        int min = Integer.MAX_VALUE;
        //求出最大值、最小值
        for (int i = 0; i < arr.length; i++) {
            max = Math.max(max, arr);
            min = Math.min(min, arr);
        }
        if (min<0) {        //如果最小值小于0，那么把每个数都减去最小值，这样可以保证最小的数是0
/ o" [+ H% \# [7 o6 I            for (int i = 0; i < arr.length; i++) {
6 [1 M! x' [& m: ^2 v$ ~" R7 L/ a1 d                arr -= min;
' U7 G! B$ v2 `8 C  k            }
; P( }7 K5 ~/ c3 m' A- }! Z) M            max -= min; //max也要处理！
! g- P/ N& ?, Q7 M; m        }
% c$ S9 j" t3 g' P( @# o$ i3 K        //很巧妙求出最大的数有多少位
        int maxLength = (max+"").length();
- c3 V5 }) S3 Y) {2 \        int[][] bucket = new int[10][arr.length]; //一个二维数组，一维代表0到9，二维存放符合数
        int[] bucketElementCount = new int[10]; // 用于记录0到9某位存在数字的个数
7 B1 C3 \8 j: C9 Y- R* C! Y        for (int i = 0 ,n = 1 ; i < maxLength ; i++,n*=10) { //个位 十位 百位 这样遍历
            for (int j = 0; j < arr.length ; j++) {
+ i0 Q5 x# @* L" d1 `  W/ K0 i3 o, |                int value = arr[j]/n % 10;
                bucket[value][bucketElementCount[value]] = arr[j];
                bucketElementCount[value]++;
            }

7 ^& O! L9 O7 S0 I6 _1 d
" X1 e0 J: Y7 w4 o9 l            //升序
$ z) j( Q1 m4 |( j* E' l            if(ascending) {
' {% `" l% Z. e7 N+ |! t% W, r                int index = 0;
& X9 Y2 l9 |" g) j4 j                //从左到右，从下到上取出每个数
  J+ n( s0 w. |) r! M/ I7 B$ v' N                for (int j = 0; j < bucketElementCount.length; j++) {
                    if (bucketElementCount[j] != 0) {
                        for (int k = 0; k < bucketElementCount[j]; k++) {
                            arr[index] = bucket[j][k];
                            index++;
                        }
                    }
                    bucketElementCount[j] = 0;
                }
/ V$ E, b3 ?8 H# R. Q            }else { // 降序
                int index=0;
" `5 n* h8 L# Y! L) f% y8 [  t" |                //从右到左，从下到上取出每个数
* k$ M) s& }8 M4 l                for (int j = bucketElementCount.length-1; j >=0; j--) {
' k6 i9 w/ g! P2 T, [! d3 P1 W, F                    if (bucketElementCount[j] != 0) {
                        for (int k = 0; k <bucketElementCount[j]; k++) {
. W9 G) r/ l4 v- i  D  \                            arr[index] = bucket[j][k];
5 k  u7 _+ Q( f$ l  J                            index++;
                        }
; @' \/ Q& r- l! m+ ^! H                    }
                    bucketElementCount[j] = 0;
0 U' y& M6 y; d) {% C                }
            }

9 r! _3 h* }+ _# F6 L: a


5 H; d  s$ z7 r1 s9 ~; D            /*for (int i1 = 0; i1 < arr.length; i1++) {
/ O$ k8 r: ~  r. ?                System.out.print(arr[i1]+" ");
0 M- L4 g: Y3 b& c0 K- o) A            }
            System.out.println();*/


% p- @& T6 R7 T' F

  N% L3 i' R3 d. s3 w1 f

        }
, {& w" o$ A2 @( ^        if (min<0){
; _& z, a: a* y/ W            for (int i = 0; i < arr.length ; i++) {
5 A. e2 [4 j1 }' h  u7 O                arr += min;
1 F8 J& D9 ]8 T5 W5 V3 D& P) }            }
; ^. L" m4 K: ^3 P: g        }
! A/ [7 g0 k$ B7 a1 M' R
  t+ }+ G, L5 j7 }1 u. r
    }
}
1
0 B2 O8 V& V  g7 n; E; M# n2
( w6 o/ O9 t, U: l3 Z) w; z7 G3
4
5
6
7
8
' j! X% q" J5 n9
5 x, G1 v( V/ E) ]3 F10
11
; {2 {1 I6 d5 o, p. N* M12
13
- Y" ^& X4 M6 n" o0 p. A4 s14
15
  r/ Q' C! \6 g* ^2 b. m$ i+ }5 U16
( k' Q5 y3 z4 ], Y17
2 H: D3 L. y( a. o4 N+ Z18
" p9 s+ D; q3 `$ c19
20
21
, C" h6 d9 F+ T# U/ P" J22
23
24
25
26
/ V3 Y* v; ]0 D% {% A& n27
28
/ A4 W' x2 V4 t3 ^8 l0 Z2 w& c29
30
31
" y' w, m; _) Y7 u32
33
  I+ w/ G$ a$ X/ Z# H& e% h" r% K% o34
3 f% {$ B1 D' V2 ?; w2 P35
36
' b* S- ]0 A! g0 d$ n37
38
5 I5 |9 b" g5 r; G+ y, H, L7 M# B39
40
0 z( i" ~) \: i+ A: l41
' s1 J1 {! \6 q$ `# h. H42
43
44
45
46
1 k1 _* T2 C) f- c! W/ I47
( i9 k1 k8 m% g" |48
% w/ ^5 A& X0 u7 K& x49
50
51
# ^8 y/ p- H7 u. t7 Q' T$ f/ f52
53
) \# x, ^+ _: C7 `. ~4 P7 o* a54
" r8 _0 P  o5 E/ j) ~55
7 Q- J' X- o1 j9 Y& A( M56
1 K' m- S* c; F  Y# T) Q57
$ e% m1 `# R# R0 }+ i, e58
59
5 R' T; K# c* X/ i! S% T: n60
/ z6 [3 S. o( U3 Z9 o61
62
3 A9 \( I$ e2 F0 M7 p63
8 e) _% R* u0 J6 X  m( ~; z64
4 Y: {' `8 a7 O# O$ N1 y, P' T. W65
66
67
! l  p- |1 r! T3 L" P9 ^7 N$ W3 ]2 ^4 E68
69
70
2 y: S# S. K6 C7 m! }71
7 o0 b( M2 z( S5 l) @1 o72
73
74
9 ^& E2 M+ A! E' x3 w75
76
77
5 D' Z6 v9 v2 E0 U  E1 w+ h" M8 g0 Y! S78
+ _% ~" }3 t; @/ {7 N79
7 I( C, K; F+ o7 }80
81
82
4 w4 f( r$ s+ Y, P! c! S: y" X83
完整测试类
package com.keafmd.Sequence;


import java.util.*;
+ i. s+ b/ h  D$ V; J0 ximport java.util.stream.IntStream;
  m$ `$ A# V8 ]# d7 S) R6 Mimport java.util.stream.Stream;
" R5 W7 c9 I; Z- r

/**
* Keafmd
$ ?5 v+ {3 y3 p2 Y4 |( v) z& P+ G *
% o5 S( Q7 K! f: r; D * @ClassName: Sort
7 n, K) S8 J& b. ?+ U* ? * @Description: 十大排序算法测试类
* @author: 牛哄哄的柯南
* @date: 2021-06-16 21:27
, N9 W3 B' n+ J) ]! m */
public class Sort {



4 e, |  \/ d: n5 z5 p- x" R8 w
* q" ^% M& C% t$ Z    public static void main(String[] args) {


        int[] nums = {12, 4, 25, 47, 58, 34, 25, 9, 99, 26, 1, -13, 162, 10093, -66, -1};
//        int[] nums = {12, 43,56,42,26,11};
9 _* h5 A/ `8 @' |& z+ h% T* B( P$ @2 I        int[] temparr;
5 }; Y/ i- |. H; x' F& O

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


        //将int数组转换为Integer数组
        //1、先将int数组转换为数值流
: f, c3 P; H9 Y9 R6 F5 i" W        temparr = nums.clone();
4 F; z8 I0 a" K        IntStream stream = Arrays.stream(temparr);
' j. [9 l- _0 Z4 f3 k        //2、流中的元素全部装箱，转换为流 ---->int转为Integer
        Stream<Integer> integerStream = stream.boxed();
4 E: w- G) C' ]0 b        //3、将流转换为数组
        Integer[] integers = integerStream.toArray(Integer[]::new);
7 `1 K" e* q2 f        //把数组转为List
        List<Integer> tempList = new ArrayList<>(Arrays.asList(integers));
        //使用Collections.sort()排序
0 l0 d+ H8 F* p5 o) \! T) F        System.out.println("使用系统的Collections.sort()的对比:");


# v; f3 ]# z6 P        //Collections.sort
1 v7 ^2 I- x5 e( p( X, |# V: R        Collections.sort(tempList, new Comparator<Integer>() {
8 J7 S% a7 G1 s/ z8 o            @Override
/ U) F" m- n+ b# P$ x            public int compare(Integer o1, Integer o2) {
5 Q- e- O+ u8 L" k; g8 S# |# ?                return o1-o2;
                //return o2-o1;
3 y+ z9 `) s1 H9 ]            }
% z! L) V3 N$ l8 r$ I        });

+ }8 Y% I+ V( r
0 u9 E# U" ^& }7 ^+ M) H7 z        //tempList.sort 也可以排序
       /* tempList.sort(new Comparator<Integer>() {
            @Override
            public int compare(Integer o1, Integer o2) {
                //return o1-o2;
                return o2-o1;
            }
/ l# c7 W* O6 W* c" X9 c- t+ Y        });*/
! q7 B( k0 [( T( n8 p- o

8 a. [4 T  t+ g( n  Z        //遍历输出结果
) U4 N" U: C5 w+ }" n- l        for (Integer integer : tempList) {
  @: W$ x( M* k1 X# c; `+ j, r: w            System.out.print(integer+" ");
' z$ A2 W1 b0 b0 o7 B9 N# E3 X/ o+ k        }
- h4 c- j' W2 O

        System.out.println();

' [+ y# {! E5 w, ^; }
! d6 N% z' {- O. G, U/ |( {! ^        //测试冒泡排序
        System.out.println("测试冒泡排序:");
        temparr = nums.clone();

4 Z8 @( W6 `$ u( C
        BubbleSort.bubbleSort(temparr);
/ j; _! m" [6 h0 H4 ], C

        //降序
) Z" Z" [/ d% P. I  a5 ^& A" J" ^4 P        //BubbleSort.bubbleSort(temparr,false);
) A5 s+ G6 ~0 v$ N) L
% C/ }! a" ]% T: D. y7 C6 V
5 l. Y# s/ }. N        for (int i = 0; i < temparr.length; i++) {
            System.out.print(temparr + " ");
- }6 B) X% L7 J5 l        }
8 ~7 m* W& k+ l        System.out.println();
2 F% y, e/ m0 p9 g+ R/ |

3 ]6 [  M8 }6 g8 G$ u        //测试快速排序
        System.out.println("测试快速排序:");
- R- {0 e9 Y$ h4 W$ q- Q$ b- J        temparr = nums.clone();
        QuickSort.quickSort(temparr);
        //QuickSort.quickSort(temparr,false);
        for (int i = 0; i < temparr.length; i++) {
            System.out.print(temparr + " ");
6 N4 \6 |! s& v7 e  t6 D- U6 ~! m        }
+ o2 c/ \, K3 L( C; n1 v: {/ P        System.out.println();


8 f8 ~7 d. O; i2 E4 ^$ o1 s- R        //测试直接选择排序
- d; ]5 P1 a2 e5 B. `6 H        System.out.println("测试直接选择排序:");
' _2 ~$ A: q5 W% K9 J) h6 M        temparr = nums.clone();
, @( }6 b( U* j        SelectSort.selectSort(temparr);
0 I5 A: B' k( e        //SelectSort.selectSort(temparr,false);
        for (int i = 0; i < temparr.length; i++) {
- O/ m; q( t( Y            System.out.print(temparr + " ");
, @& ]# M( B% O        }
        System.out.println();
8 t* d2 J) Z) V& Z% ?% m' Y9 v

% n  l# g& O0 q/ s        //测试堆排序
- J, r/ _2 J% v( Q        System.out.println("测试堆排序:");
        temparr = nums.clone();
        HeapSort.heapSort(temparr);
# [! m" \( \# z. ^# S. R: L        //HeapSort.heapSort(temparr,false);
        for (int i = 0; i < temparr.length; i++) {
            System.out.print(temparr + " ");
& j. V) O% d2 e# B9 E7 y4 g        }
        System.out.println();


: _) I& s% ?3 H8 D( W% r' L        //测试归并排序
% s7 ?' x( @2 X& X" {+ Q# |' J1 p        System.out.println("测试归并排序:");
8 ?  {; s2 w0 s4 W+ k        temparr = nums.clone();
- w$ w2 p1 W6 E/ ?0 ^$ W+ ?' D        MergeSort.mergeSort(temparr);
        //MergeSort.mergeSort(temparr,false);
" _: X( `$ s& U5 I        for (int i = 0; i < temparr.length; i++) {
* N6 r) s/ u3 e' w            System.out.print(temparr + " ");
" A# N: H5 B' E7 R7 B! R, t$ a: ?        }
8 o" b" {4 H/ Q, Q# F        System.out.println();


        //测试插入排序
        System.out.println("测试插入排序:");
        temparr = nums.clone();
8 O- ^0 P- J+ G% n6 l9 S        StraghtInsertSort.straghtInsertSort(temparr);
% h: [6 i1 y$ F" ^        //StraghtInsertSort.straghtInsertSort(temparr,false);
        for (int i = 0; i < temparr.length; i++) {
9 v0 N+ I- }' H            System.out.print(temparr + " ");
        }
        System.out.println();
6 ?% J: R; [" S1 z1 N  v& B7 i
5 Y  A+ b/ j( h* Y  U


. c8 N+ g& ~  [  c# G' r        //测试希尔排序
0 V+ @) d3 u1 I" x  n: ^0 k        System.out.println("测试希尔排序:");
        temparr = nums.clone();
        ShellSort.shellSort(temparr);
        //ShellSort.shellSort(temparr,false);
        for (int i = 0; i < temparr.length; i++) {
3 x. x& k, M1 i/ w3 ]            System.out.print(temparr + " ");
        }
        System.out.println();

& T7 ]9 }  n+ L* ^# R$ ^$ ]
& q6 a6 X+ Y' \( Y& M, ^
# j8 H- }) k7 U. N- E2 Q
& _' H& V9 r" ^7 V3 X; `! U        //测试计数排序
; G4 Y$ h' M- F/ ?        System.out.println("测试计数排序:");
        temparr = nums.clone();
$ k% l$ F# h& D! q( g- }        CountSort.countSort(temparr);
        //CountSort.countSort(temparr,false);
1 \) Q( z  O9 C1 K. f0 m( b& F        for (int i = 0; i < temparr.length; i++) {
9 v! H$ L2 s& L            System.out.print(temparr + " ");
        }
+ R/ f" P0 W9 r7 G: G2 Z9 m) ?/ F/ j        System.out.println();
( e) h7 k8 x6 x+ [

  ?" v" o. o+ s' f1 C
- C7 I( a6 Z& r4 s4 `- a; i
        //测试桶排序
        System.out.println("测试桶排序:");
        temparr = nums.clone();
        BucketSort.bucketSort(temparr);
! d2 c+ C6 T! Y; n3 B/ v        //BucketSort.bucketSort(temparr,false);
        for (int i = 0; i < temparr.length; i++) {
* L! N  K5 R( w. H6 L, w/ W8 ]            System.out.print(temparr + " ");
3 ~  F+ N7 ~  @5 H4 c# ~0 @* Q. [        }
4 u5 t& ]. U+ ~( j        System.out.println();
* d5 p2 z. p( V# _" D

        //测试基数排序
        System.out.println("测试基数排序:");
! M& S, M0 p. ?* b        temparr = nums.clone();
        RadixSort.radixSort(temparr);
        //RadixSort.radixSort(temparr,false);
8 C$ O; u: S# U# k7 V7 |  o; P7 d        for (int i = 0; i < temparr.length; i++) {
4 d. W0 o9 g4 ?1 u5 F4 Y- B: V) e            System.out.print(temparr + " ");
        }
        System.out.println();
8 \$ H9 i, x3 C+ h" p  M
( e& _3 x+ v, C8 P% F1 f# _4 Y6 m
    }

1 d, q% ^/ F( o; g
2 T# p( t. b$ M5 H+ @, Q}
$ v9 ^. G2 F) H, W: J3 B1
5 q" h  C7 x4 U& p2
3
7 W! |) Y5 W' `4
5
6
7
( L& _0 A: X7 ^8
" p$ s" r4 F* a+ Y4 R4 F9 b9
( Y7 ~3 I' n( V; ~) D8 J4 `10
- @2 D" k7 K0 z11
" b7 |  k! v$ j; F12
/ F& h6 l/ D3 Q5 d% a13
14
15
16
17
18
19
4 n' C3 c; T7 v8 ~# M5 [5 E20
5 p0 C/ U6 Z9 r21
22
23
" J+ P7 A; ~" W% k9 `  {6 {24
25
! z( }& A9 @8 h9 @& u7 C1 M9 S26
27
7 G4 q$ L3 j) f$ h- V2 c6 [28
29
$ [/ ^. w+ T, E3 v4 [. Z30
31
: ^8 J% l  [$ m: N+ J, ]6 F32
33
34
35
% ^' F+ Q: I: F) Q9 |, B36
37
3 H8 m0 a5 Z! _5 r+ ~  |38
39
" c% T- o0 p8 [6 S8 }0 @40
41
. O3 q# q  W" k42
43
1 a6 y; l! h5 @, B" G3 a0 S3 t44
45
46
47
3 [8 w% l1 T( Y48
: f; n( O7 C/ T3 f0 x/ ~9 V# L49
' l8 s2 g) q+ s3 }5 K50
51
52
- \) K8 j- H; t& T53
% b: R# g4 C. M) O54
/ f5 _+ `+ y4 B; d' q55
! d3 m. X% M! B8 ~" c% N5 k56
- s# t! s2 F$ s- D57
+ _9 v" q+ N1 b6 H0 ^$ d58
, ^8 `/ T$ J# P2 R59
) ]: a. b- i4 m0 B60
# X7 z% w$ w0 E# C6 U2 O  o61
  a0 \2 y/ _( |! g% S, E( p62
63
1 O" N5 G# j7 L, R( L2 Z4 M' _  A5 a64
65
4 [; v6 K! {3 |* K; k66
9 a$ I) ^3 F4 ?: b+ C8 z0 B6 }, |67
+ d! z: C% W: i" W: L68
69
6 ^+ k: j3 @$ y: Y1 J& x70
71
; }! |+ M! a4 z, h; V* I7 @72
73
74
75
76
% t$ {" t$ \- D% b; u6 k77
78
: r3 i' s( H. @7 ]5 d1 h" J+ u79
80
7 f0 T* g/ J. y# I& H: E81
82
9 H: K( H" C$ V2 [83
' f2 ^% x- }! \( ~4 r* O84
9 N$ `4 t* W8 \6 {3 w85
86
+ ~+ Q  C9 w# ^5 J$ @9 L* A# k87
88
89
6 }7 ^; V( O( I/ h90
8 }5 G- _' z9 H2 F: @  r- d& `91
4 n) v! e, i4 i; @+ P+ ~- K0 t7 f92
7 o* ?' v! V9 L7 v93
94
95
/ B. P! x" \$ b! Z. F' }- [96
& O. g& ]9 h! s. y2 h97
) s# r+ U9 l8 Z# b) K98
! ^# t/ f4 Z# K9 w2 N. g% V2 j99
100
; f1 X% z. o( a101
' w; @8 B* _0 K' B102
103
104
105
( I2 p3 W% G/ r6 _/ [106
! {! q5 E1 Y% b/ F  ~5 Z5 r107
4 Q; X# c7 f' _3 h/ U) T108
1 v% t1 s( G6 R# s109
110
7 [  h0 Q/ C3 u9 R1 @1 A: x111
112
113
114
$ u! ~0 k8 B; w% r115
  Q3 u: C. Q& x2 v( f1 }# k: [& S% k116
117
5 M1 X# x5 T! Z9 |+ s7 W118
119
( ~9 B% q2 r) u2 b$ J2 D120
121
; G* Z7 {; U: l, U$ O122
123
7 G; C7 F% \6 M* b( L) l# [' k124
125
+ J& q& R& r" A126
127
128
* }. _; X. j/ F7 S; I* G8 o129
3 }  p7 o; \) |# C- d. D/ S* @- {130
9 g! E, I3 V$ F131
6 J, @  Y% l5 F' T$ v& U/ ^132
133
( l; ]' b$ g1 g$ ?" T) q134
135
+ C$ c2 b  k9 _# I' w136
0 E( E+ m5 b/ j2 w137
138
139
140
141
142
; @! x9 _0 S9 v4 y2 O* }' i143
8 W0 S& p& k$ ^3 M! O144
) s: d9 p; b: Z5 [145
146
147
148
* p! Z. x3 n; z+ N  j  v% @149
150
151
5 j. q1 P$ n* `# `152
* y' Z7 h* g/ D7 {153
154
+ g2 f- t* Z5 o# [+ \155
156
157
158
+ _8 ]# M$ U2 w! f- ~159
, D0 [; Z8 v6 n/ m# S! e) f& M160
! V( Z8 U% ?5 R161
1 j! |7 L' J) _0 I' z6 o162
163
4 z+ ^0 @8 R0 u1 H( E( `$ h8 X164
3 d6 ]2 v# _2 a3 H. _165
; O& B9 {: L6 j0 |* b* V166
5 L9 i. x8 s# D. Y. }! l167
6 p6 T2 T. K. s- d$ c$ n168
0 E) {" b9 b$ S% z! t6 p6 x" H' ~169
170
2 t, q8 I) c- v2 {, S171
172
5 l2 l4 Y9 e& z1 H5 y' p173
每天进步一点点！
不进则退！

* o: F4 ]& S* J5 L) ^( T' ]6 t; f
版权声明：
原创博主：牛哄哄的柯南
$ }( q5 [- p2 T9 Q2 R* j博主原文链接：https://keafmd.blog.csdn.net/
! `8 \9 {% G# ]8 w————————————————
/ _4 Q3 i  @" S版权声明：本文为CSDN博主「牛哄哄的柯南」的原创文章，遵循CC 4.0 BY-SA版权协议，转载请附上原文出处链接及本声明。
) a$ F, B  o2 k9 R- z9 h; a) `原文链接：https://blog.csdn.net/weixin_43883917/article/details/118193663

5 Y- J+ a+ w" @3 I1 u  j, T1 N

1051373629

每天进步一点点！