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

杨利霞

经典十大排序算法（含升序降序，基数排序含负数排序）【Java版完整代码】【建议收藏系列】
经典十大排序算法【Java版完整代码】
4 o9 I5 T( B) Z& Y写在前面的话
* [4 c! V8 I/ O9 N6 d十大排序算法对比
$ L) _$ O) i0 w9 L6 t冒泡排序
快速排序
直接选择排序
  X6 E- L# U; k. O" Q. b堆排序
) G3 B. [1 N1 }$ ~归并排序
插入排序
希尔排序
计数排序
桶排序
3 P# Z( X! ?! X+ @* j8 _" v+ V基数排序
完整测试类
写在前面的话
1 d1 v% u6 P& o+ M/ i" K1 O       虽然已经有很多人总结过这十大排序算法，优秀的文章也不少，但是Java完整版的好像不多，还存在某些文章代码存在错误的情况，同时也为了自己练手，决定把所有的写一遍巩固下，同时也真诚的希望阅读到这篇文章的小伙伴们可以自己去从头敲一遍，不要粘贴复制！希望我的文章对你有所帮助，每天进步一点点！！！
, i( Y8 |% Q- T7 e

( X8 d6 @' P  P7 w  W3 b       我用通俗的理解写下对算法的解释，对某个算法的运行过程不是很理解的话或者想看比较官方的解释的话，单独搜索某个算法，看几篇不同的解释，就可以有自己的理解了，这里我主要展示代码以及进行通俗的解释！整起来，再强调一次，一定要自己敲一遍，这样才能理解的更深刻！
8 b, y; L7 H8 Z' E% ]
  m2 R) T# V: g0 y5 h- E
十大排序算法对比

1 I$ S6 d* n) h" C
  }3 Z& g3 g  W. p/ B  g
4 M# u7 c7 J, X+ A/ W+ x! ], @. u
4 z: {% J4 G7 t+ j7 ?- `/ f, [关于最后一列的稳定性，我稍微解释下，例如对序列：1 2 4 2 6 排序，序列中存在两个2，如果我们把这两个2标记上（让他俩不同），排序之后，前面的2还在前面，那么就称这种排序是稳定的，反之不稳定。
0 M) R1 Z9 T2 D( g) ]  L1 L; n0 d

* c' }8 f; J# r8 T6 R冒泡排序
4 R' I/ N5 m* L8 o* |简单解释：
       原理就如算法名字一样，就像水中的气泡一样，每次我都把最大的或最小的放到最后面，这样总共需要n-1趟即可完成排序，这就是第一层循环，第二次循环就是遍历未被固定的那些数（理解成数组左边的数，因为每层循环都会把最大或最小的数升到最右边固定起来，下次就不遍历这些数了），两层循环遍历结束后，所有的数就排好序了。
' i9 i5 R  p) W3 ~2 G$ b' t8 p" _       两层循环所以冒泡排序算法的时间复杂度是O(n 2 n^{2}n
2
)，是一个非常高的时间复杂度，我在下面的代码进行了优化，加了一个标志位，如果上一次循环未发生交换，就说明已经是有序的了，就不继续下去了，反之继续进行下一轮。

1 ~2 K6 C1 j' E: t+ l
1 Q/ o* u% I" P" r1 n% b& I
9 k! Y& O" K3 _. O# b$ E0 H7 m
! n! p) y( B8 t* z$ e: ^" `

" v! G/ Z! F; H8 c0 _8 N本文的图片来源网络，仅用于大家学习，侵权联系删除！（下同）
& I% Q, d1 X$ f; D% h( b4 ^

完整代码：

+ u) @9 H$ l# H
( s- B0 x4 |" i! \/ }2 b5 _3 cpackage com.keafmd.Sequence;
& V* Z; ?  |+ g6 |& Z+ U. m* ]. U
. f* t9 r) t# f1 r1 l! k: ^
/**
* Keafmd
*
! s2 H$ }6 Q! x& q+ g) i * @ClassName: BubbleSort
* @Description: 冒泡排序
* @author: 牛哄哄的柯南
% o5 i- u4 ]5 F2 ^$ n * @date: 2021-06-24 10:31
9 q9 V. z7 U, \0 a  ]+ b7 u5 s. T */
; C1 V( Q9 e0 b* p$ x7 A# p( wpublic class BubbleSort {


    //冒泡排序
    public static void bubbleSort(int[] arr, boolean ascending) { //exchange标志表示为升序排序还是降序排序

/ o+ c. ^9 A/ l+ j% O6 [
        boolean flag = true; //加一个标志位，记录上一次是否发生了交换，如果是，我们则进行下一轮，如果没有，说明已经冒泡好了
3 C! |! d- O* l1 |3 e" O7 G( P
  ?8 W* X. E0 C0 H: u, N
& f2 ]  X3 k& J2 z4 F. `6 r9 E        for (int i = 1; i < arr.length && flag; i++) { //控制次数，第几趟排序，只需要n-1趟，有交换时进行，只有flag=false就说明上一次一个元素都没有进行交换

7 Y3 K" _  s% R0 Q# D; F$ `* C* v
            /*System.out.print("第"+i+"次遍历：");
7 ?" K2 P. N( D, r# N            for (int i1 : arr) {
                System.out.print(i1+" ");
. E# T1 z3 b/ {' _( P            }
% u9 u+ q( a8 C3 B. X' w5 B/ C            System.out.println();*/


            flag = false; //假定未交换

4 t) Z- \" G* Y/ S7 e
! e) x8 m1 u# J            for (int j = 0; j < arr.length - i; j++) {

. D9 ]9 v2 Z- a( B+ m( j  m2 A3 ?
) ~8 @0 b# ]4 M& y                if (ascending ? arr[j] > arr[j + 1] : arr[j] < arr[j + 1]) { //控制升序还是降序
1 Y  @' h1 g1 Z/ k) `8 K& {                    int temp = arr[j];
( E, K3 q# j6 X" n2 G: a                    arr[j] = arr[j + 1];
7 @) G# C4 H6 n/ g4 e                    arr[j + 1] = temp;
                    flag = true;
                }

3 b* b/ _# c, d
' m0 R3 v+ A4 j; H0 w" I6 l) ]            }
        }
4 ]* N: f: N4 J* q, f: W; _    }


    //冒泡排序 -- 默认不传参升序
$ T9 a; C2 F- w% G0 b% M% {    public static void bubbleSort(int[] arr) {
" ]4 G3 R: _( Q        bubbleSort(arr, true);
8 y4 T- m# i& M2 c4 I# w    }
}
1 t4 Y( a; ~5 @. q( Z# H1
; C- W8 ^7 A+ m4 M8 [2
3
( g0 \, A5 X! E1 V& T4
5
6
7
( C- ]$ n2 W6 O) S" z8
) a' x. k5 e* I; o7 y$ V0 W9
10
) b6 \: A! G, c+ e% e4 T11
) b" x1 D1 G+ E0 `12
3 ]  w. Y0 R! b' R/ N13
14
15
) O: u( D7 e  N6 F0 h16
/ ]4 `; v, ]7 p! _; ?17
18
3 y. l) ]+ E0 }1 l4 l19
20
21
22
23
24
' J6 c/ c' A  v, Y8 A5 ^25
26
27
28
29
30
31
32
33
34
9 k* g3 b+ _' b; t! S/ d9 `( S4 k  Y35
; V0 b  Q- s& n9 C1 s8 L36
9 \, V$ N9 P8 Z& e7 b7 [37
  w! l3 v8 E; ]5 Q38
39
40
- b" p! m5 f+ G1 j. E41
# {( w" R( T8 Z+ `42
43
44
: q# s/ m" c/ f4 T: ]7 l45
测试代码：
( ]+ X& G, G9 N) ]

升序排序（从小到大）


package com.keafmd.Sequence;

9 p* |) d+ P" F1 `9 h) x
6 C0 x  i; A2 P& H3 Fimport java.util.*;
import java.util.stream.IntStream;
import java.util.stream.Stream;


/**
5 b1 [, U9 f4 k+ y; J8 h+ p * Keafmd
; |. ]. J" `' K; n# ^% m( X$ f" H *
0 P% a* Z4 V) V8 Y* z, \ * @ClassName: Sort
* @Description: 十大排序算法
$ z3 `' m/ B! Q4 M. \. P * @author: 牛哄哄的柯南
3 I9 j$ `. r; @( h/ H * @date: 2021-06-16 21:27
: f' Q5 L; [7 x0 R; ]+ t */
' c7 V3 y& l# Fpublic class Sort {
. r. Q2 p7 t2 n) c+ Y    public static void main(String[] args) {

0 ?# p5 o, I5 j5 c
* W* M. O& n- U- X; J& \: v! T* [        int[] nums = {12, 4, 25, 47, 58, 34, 25, 9, 99, 26, 1, -13, 162, 10093, -66, -1};
, t0 O+ _4 ]4 W$ \# ~7 r" q        int[] temparr;

' i! C6 D* C( O
. r3 j: ]  x* R1 l; I        //测试冒泡排序
        System.out.println("测试冒泡排序:");
        temparr = nums.clone();
        BubbleSort.bubbleSort(temparr);
        //逆序排序
1 k& |9 t% e* ?& Q0 Y0 e        //BubbleSort.bubbleSort(temparr,false);
        for (int i = 0; i < temparr.length; i++) {
            System.out.print(temparr + " ");
9 U& H. z, ^1 h2 h        }
        System.out.println();


& ]7 L7 G& Q/ d- h    }
}
1
2
: O+ ?: J, g) \$ _4 K3
1 h7 m, N, f2 k2 }4 ^4
5
6
7
. s: q4 l. g: d# h  h$ P1 X8
9
10
7 l  ?7 @9 x: d. \% K11
12
13
, y$ @3 e" ^5 p9 y, `14
15
16
3 W  v2 q5 u; P4 @& s4 [+ S: u17
18
/ k9 ^0 ]# H+ |9 N19
20
21
& }/ p6 l6 z& y% N; u22
7 V( z( s$ I( y+ I" B6 N  Y  B- m2 [23
/ m7 @6 v6 l5 @* @6 F24
25
26
27
6 Q. T3 H! n4 J* T4 R28
29
/ F7 N% w- P! k2 v) m30
31
5 c2 I5 T0 o- u6 b! p6 C6 q32
33
运行结果：


% o) L9 Q* L$ `9 I) v: _测试冒泡排序:
) y3 i* U, T; e- e$ c  _, s* p3 a+ \-66 -13 -1 1 4 9 12 25 25 26 34 47 58 99 162 10093
1 W( n3 D' U, i5 f& E9 l1
. o5 n+ [6 H8 w% W$ N( h. j2 ]8 R9 t2
降序排序（从大到小）

1 f3 q/ M" B$ R: o
//测试冒泡排序
System.out.println("测试冒泡排序:");
* ?2 f6 e( X2 \& Ztemparr = nums.clone();
/ b5 J, h1 t, J# M# FBubbleSort.bubbleSort(temparr,false);
for (int i = 0; i < temparr.length; i++) {
    System.out.print(temparr + " ");
* T7 n7 l' d9 W- u; H3 ^" L}
System.out.println();
1
" }$ F6 m+ U: q* w" C# x. `3 {2
3
4
8 i4 l! I6 S2 K9 M9 D5
6
7
, E4 ]) E* \8 G2 {$ c4 D8
运行结果：
( z) c3 l5 r1 o% ]/ B
& x. v) K; `! \  U7 N0 U- x
测试冒泡排序:
10093 162 99 58 47 34 26 25 25 12 9 4 1 -1 -13 -66
1
2
下面几个算法的测试也就是换了下类名和方法名（换成相应的排序算法），如果想降序就在数组后面传个false即可。我就不一一复制了，我在最下面给出含所有算法的测试类，需要的自取即可。
! R; M* B- \4 c/ j: i0 \* y' N

2 u' p* T! K8 J7 R% M' @快速排序
简单解释：
快速排序就是每次找一个基点（第一个元素），然后两个哨兵，一个从最前面往后走，一个从最后面往前面走，如果后面那个哨兵找到了一个比基点大的数停下来，前面那个哨兵找到比基点大的数停下来，然后交换两个哨兵找到的数，如果找不到最后两个哨兵就会碰到一起就结束，最后交换基点和哨兵相遇的地方的元素，然后就将一个序列分为比基点小的一部分和比基点大的一部分，然后递归左半部分和右半部分，最后的结果就是有序的了。
: L& Z% V$ r1 k
; O! m% P+ e0 X4 D- i

" J5 ?' o) J% F% X. E
, e/ B4 ^8 k/ R

完整代码：
) {0 f* F* I; x1 R& L9 q  {! Q
3 _' X  E. ]% ?1 h7 r. l0 G
package com.keafmd.Sequence;

3 \, O+ X1 T* v0 C% `( ~
/**
* Keafmd
*
8 j# ?/ n" P5 \2 o* f1 f * @ClassName: QuickSort
8 d5 N. k2 C3 m. ]) a% b" t$ r) I. C * @Description: 快速排序
6 }2 [3 B2 Y+ M7 p * @author: 牛哄哄的柯南
/ b- c  H4 Q* ~9 T. M8 ^4 a: V * @date: 2021-06-24 10:32
5 A$ h* \( f: M  k* s0 |* f' n */
& Y9 w. ]* b0 a. c- ]public class QuickSort {
# E$ j1 Q! K" A
/ h9 E  _4 z6 w
4 e# P& o* W9 u- {    //快速排序
& s/ m' R6 w6 `3 V' X    public static void quickSort(int[] arr) {
2 P9 Q8 K6 Y4 T) G- Q8 L        quickSort(arr, true);
  a, v: _$ N$ v+ y2 ?    }


    public static void quickSort(int[] arr, boolean ascending) {
* @2 M( _5 p) o7 Q( d6 X7 `5 e        if (ascending) {
            quickSort(arr, 0, arr.length - 1, true);
        } else {
, T: |1 d, v/ f% A            quickSort(arr, 0, arr.length - 1, false);
, v- l$ p! _7 u        }
9 R7 J8 z! ?$ P1 z  C8 o0 k5 F7 j    }


; |* E, y4 a4 N2 q# |% ?    public static void quickSort(int[] arr, int begin, int end, boolean ascending) {
        if (ascending)
' l- {$ x* E6 n            quickSort(arr, begin, end);
        else
            quickSortDescending(arr, begin, end);
/ k& T% z- U6 [7 X! B" @    }

9 o! \; j# K5 Q7 b
    //快排序升序 -- 默认
    public static void quickSort(int[] arr, int begin, int end) {
% O& D9 M  N7 M2 }. y% _2 v( H        if (begin > end) { //结束条件
            return;
, w# P; E5 H* w; s4 e; k; g4 `        }
        int base = arr[begin];
        int i = begin, j = end;
( h0 x. A1 e0 y9 S9 C5 C        while (i < j) { // 两个哨兵（i左边，j右边）没有相遇
            while (arr[j] >= base && i < j) { //哨兵j没找到比base小的
5 E6 v; ]2 x1 o. t" L                j--;
            }
            while (arr <= base && i < j) { //哨兵i没找到比base大的
5 }. _! J  j, u* K: p7 D                i++;
            }
% ^: q/ ^0 r9 M6 U) k            if (i < j) { //如果满足条件则交换
                int temp = arr;
# {$ o7 Q. v" o1 O3 I0 ^$ ?  y                arr = arr[j];
                arr[j] = temp;
! q6 P9 M+ o! }' M            }


        }
        //最后将基准为与i和j相等位置的数字交换
5 F. J# b. {. s8 I4 p8 r2 c        arr[begin] = arr;
        arr = base;
        quickSort(arr, begin, i - 1); //递归调用左半数组
9 y* m- b* |& r        quickSort(arr, i + 1, end); //递归调用右半数组


% [( x( F. R$ s5 s    }


3 Q& [- h. b. M4 X* r0 }    //快排序降序
8 B$ U# }$ S2 s3 f+ Q    public static void quickSortDescending(int[] arr, int begin, int end) {
        if (begin > end) { //结束条件
            return;
        }
* _6 p% J" f6 ]# |4 J        int base = arr[begin];
        int i = begin, j = end;
        while (i < j) { // 两个哨兵（i左边，j右边）没有相遇
  J! ?% J2 R9 ?& T1 Z            while (arr[j] <= base && i < j) { //哨兵j没找到比base大的
                j--;
) T# Z$ i0 A. Y/ `            }
, [4 J: |5 ~: k4 z0 r- a& A! u            while (arr >= base && i < j) { //哨兵i没找到比base小的
                i++;
4 X. O- h- h% n' l) `3 R: V6 e* V( \8 d            }
            if (i < j) { //如果满足条件则交换
                int temp = arr;
4 _+ V4 U: y5 Q$ U! [( ]5 @2 w/ S  N                arr = arr[j];
                arr[j] = temp;
( m; b) Q7 t+ w% G. Z  E2 c8 U            }
6 n, u9 K- _) ?% O

+ I% I+ `7 r0 l. H" E4 C" O# p        }
        //最后将基准为与i和j相等位置的数字交换
        arr[begin] = arr;
: R6 V  e1 h2 E3 S. M4 p  Y5 |        arr = base;
* c) P+ N$ V8 u4 x! y+ N6 j* N        quickSortDescending(arr, begin, i - 1); //递归调用左半数组
, g3 ?; }, u  {5 P0 H( ?% j        quickSortDescending(arr, i + 1, end); //递归调用右半数组
( H) l; ^5 S+ y& p7 q
, e& f1 p; e& K+ g
    }


1 t3 g6 `+ X5 y6 a4 E}
1
' _, |6 w& v$ S* v" o7 W5 k2
+ G! q5 {$ `3 P  k2 @3
4
5
6
) ~2 J2 a+ h0 Q! J) o) W* H7
8
9
10
11
; l% p' U' w7 o12
13
; d# J& o* }) D9 P0 Q14
, ]. J) I7 _3 t15
# M& B* s1 @& B. t# }) C16
17
18
19
& B7 ^4 e3 i* k) a7 k20
21
9 d! H& E6 Q( Y# d/ \' i22
23
$ H5 W1 B" u) q8 y* J5 n24
6 |: D' W9 y; p2 w% i1 u25
- m. @) y) x" w" n7 K5 K# y26
0 d4 ~- A1 m$ P  k; [/ n4 m27
28
29
30
31
+ v5 k1 E7 Q$ H& W/ s32
5 e, P: t# a1 e( U  M7 D33
34
% M/ A& C4 j' b  M35
36
37
5 |& N& y- s+ e) M+ z! `8 r38
39
40
  Y& t+ K' m$ x: G0 V41
" j; T: U* C" D42
43
# n4 f4 k& F8 ]8 j- [7 U) ^+ E44
45
46
* `" |& v- K. R/ h% T47
& u$ X  p- N; C' a7 g3 s; I4 ?9 t7 s48
: p, k9 R5 H* |# \49
3 r! X; p2 B9 f: m6 G; {50
51
52
  X% q+ A# H" }+ P) }8 z) T53
54
55
  P1 p) Q7 E2 A1 w$ p56
9 J% z0 _" ~' g& `" f- Y8 `' e5 a57
58
59
60
61
62
63
2 e- K& w8 i& G5 n$ g; G64
65
# Z" @: ^0 R, n' _+ Z; f& y' h4 X. S66
67
% D' Y: n+ X' L7 d( a68
: T2 D$ r5 i; o6 H8 ~+ h0 g69
70
6 Z  m& q( V5 |0 w( k5 ?% c% p; V71
* w/ X2 _. [" f  i: G1 O72
73
74
+ w! K, W& v- B% d75
76
77
  Q: w1 n' d, D5 W, n8 r78
79
! [6 u2 W# ], H1 U6 j, E80
81
82
83
84
/ s1 h3 n* M) S6 l5 g' J6 c. x85
, S9 p1 q) F5 Z1 g( T% `86
87
& @1 U$ C! b  ?88
5 f; H  D" g8 u/ t89
90
" |8 G( a% c  D91
直接选择排序
简单解释：
3 i3 ~. v/ O: B. V9 m$ D6 j8 F  V$ S数组分为已排序部分（前面）和待排序序列（后面）
5 z, z, p8 q% G& }. r5 Y第一次肯定所有的数都是待排序的
3 {  ?- Q8 z0 b/ D5 ^9 e从待排序的序列中找到最大或最小的那个元素，放到前面的已排序部分，然后一直找，不断缩小待排序的范围，直到所有的数都是已排序的了

  {, A9 Z3 j( z8 y' B& V

6 L2 C4 N9 s1 L( M1 j3 |
/ F: c& m& _. s* Q* }
) |& T0 f3 I. p" n
完整代码：

' f5 }3 K$ G8 ?0 w: V: K
package com.keafmd.Sequence;
- w  ~; D; T' C

& G% s8 a/ J8 W, W8 b4 R5 s5 u7 Q/**
+ Z4 s  A2 D. T* q, {) O, D* Y * Keafmd
*
* @ClassName: SelectSort
% y! F) ^& q4 p1 ^, S- T * @Description: 选择排序
* @author: 牛哄哄的柯南
1 s' d+ J7 N( E1 n * @date: 2021-06-24 10:33
*/
3 a$ j, H4 p" g- X' ypublic class SelectSort {


    //直接选择排序
, T- {8 J; d) U3 L' g7 Y    public static void selectSort(int[] arr, boolean ascending) {
        for (int i = 0; i < arr.length; i++) {
( ?/ V# |- f6 l/ }* i            int m = i; //最小值或最小值的下标
' O/ c" o) s8 r) {            for (int j = i + 1; j < arr.length; j++) {
3 c6 k# w- j) Z0 H3 i, r                if (ascending ? arr[j] < arr[m] : arr[j] > arr[m]) {
                    m = j; //找到待排序的数中最小或最大的那个数，记录下标
                }
2 S& A- k" c, }9 J5 i4 @
7 h: _4 N: N6 R' q! Q
            }
            //交换位置
# l2 {% V7 e# b/ N; B, y            int temp = arr;
            arr = arr[m];
            arr[m] = temp;
4 o0 E4 n' E2 j5 |8 D5 ^# p
' l% p" H+ u& M8 M7 y
- G5 C, U( v0 s, |7 M, x* q        }
8 X( Q/ |3 z9 c, C5 c    }
) L* f/ }8 y7 W9 u; O

    public static void selectSort(int[] arr) {
        selectSort(arr, true);
8 A7 x4 ?* i7 @/ K2 H- g) y    }
! T9 M3 n7 Y# e4 H2 N$ W7 t$ q3 _}
1
2
- M0 e& K- N8 Q) E3 b# I3
4
# T1 H5 q, A/ N+ f+ \5
' _9 D5 I2 [' B9 k5 y6
7
0 ]: }. m( w6 E  q) d2 }1 K" J( l8
% J% e/ q  ]1 J4 O% q: {# ^1 |9
10
& I" m+ K1 F  W# w1 ]4 t6 M9 s11
1 P1 E- o) z3 Y# V2 r12
$ f. F4 F/ ~" R- Y13
: G! @: K; u9 Z7 G! x# J8 r3 f14
15
16
17
18
19
20
! f+ }7 [) j: [0 a21
22
& P  @, o  v$ b' v4 B4 L' q23
24
$ _* |, g# D# R, a# N25
' n( j7 g0 y; h26
  j# i& l* f; n* V27
28
29
" G+ K) M2 g  T5 N: e1 O30
31
32
+ T* |$ L; ]6 u2 V7 h3 d, s33
34
" \1 V  ]8 h) R: E/ c6 b+ f堆排序
先理解下大顶堆和小顶堆，看图
大顶堆，双亲结点的值比每一个孩子结点的值都要大。根结点值最大
0 m# J6 b9 o3 y4 T小顶堆，双亲结点的值比每一个孩子结点的值都要小。根结点值最小
" z7 J  H# e. }6 E
) H2 L0 g: k! I$ S8 K3 |, o7 E8 j$ Z
0 y' O# E# g% b. d: k+ e; ^9 h

1 q& i% D8 B; [9 Z简单解释：
1 n) F+ e& r4 N9 l构建好大顶堆或小顶堆结构，这样最上面的就是最大值或最小值，那么我们取出堆顶元素，然后重新构建结构，一直取，一直重新构建，那么最后达到排序的效果了。


" e* X0 I& \) A6 Z% ?* w
* [! m) j. b( x' \- s. Z. a


5 Q8 j/ Y3 G/ E: R完整代码：


, }  A0 v0 E9 G8 N; l( n- t+ {package com.keafmd.Sequence;
+ M* a" {7 K+ e7 z- _* a

/**
2 n. ~6 j5 i2 `& \ * Keafmd
*
: g$ M5 x1 y+ c8 U& \: T * @ClassName: HeapSort
) ]: |' S" ^3 x1 P6 ?& [! x+ J2 e * @Description: 堆排序
+ W7 }: p: v2 x7 F * @author: 牛哄哄的柯南
/ T$ x% j  u1 ~% x7 l0 ? * @date: 2021-06-24 10:34
*/
8 i3 s6 \# f9 L  `" S! P5 d# ipublic class HeapSort {
8 W2 r( q  Z; T+ J% ^5 [' `5 n

) b6 b, q3 G( @7 _) m# u    //堆排序
    public static void heapSort(int[] arr) {
! {6 f0 L) w& O  Q8 Q        //对传入的数组进行建立堆，这里默认建立大顶堆，进行升序排列
        heapSort(arr, true);
! g1 Q1 L( |0 c! c    }

' F$ J3 X1 U9 V) A
! k! y! e; Q1 E8 p( F3 V0 W7 P+ Q& l    public static void heapSort(int[] arr, boolean maxheap) {
6 J) d% ]5 ?- P/ b* K0 u

        //1.构建大顶堆
        for (int i = arr.length / 2 - 1; i >= 0; i--) {
" c. s, X2 ?8 H5 X) K1 K' h            //从第一个非叶子结点从下至上，从右至左调整结构
            sift(arr, i, arr.length , maxheap);
3 U  U8 i: @# @3 B! A& D        }


        //2.调整堆结构+交换堆顶元素与末尾元素
4 r) ~, c0 \3 ^- f3 v        for (int j = arr.length - 1; j > 0; j--) {
0 j- v; F4 X6 F2 t8 W

            //现在的数组第一个就是根结点，最小值所在，进行交换，把它放到最右边
$ P4 m& w2 M+ ]% c# v4 S& k            int temp = arr[j];
            arr[j] = arr[0];
8 u' S6 k* }8 C9 y+ Y            arr[0] = temp;
( R: W! d) @9 {1 i
$ M" p+ p* X9 V3 v. J  v7 Q
* p/ ?0 g. k& |/ ]' o0 _            //重新建立堆
, G% j$ U+ `; o: O6 v            sift(arr, 0, j , maxheap); //重新对堆进行调整
        }
    }
3 s! |  K' o$ E# p" O- b
/ o2 c. S/ G/ W! C6 l2 D
# i- H6 c7 I9 G# I% D, I    //建立堆的方法
    /**
     * 私有方法，只允许被堆排序调用
     *
     * @param arr     要排序数组
% o6 Q! {! y+ U# Q0 z0 v: F     * @param parent  当前的双亲节点
     * @param len     数组长度
/ K8 |% U8 w0 A     * @param maxheap 是否建立大顶堆
  w  N% p( f# o2 L     */
9 o: A! W' X2 k    private static void sift(int[] arr, int parent, int len, boolean maxheap) {
! o8 u; e8 G6 n  X0 _  [% q) G

! v8 a  t# E, l& A! ^        int value = arr[parent]; //先取出当前元素i
: I6 n$ u- p' Y2 s
. a! }. H& o2 |% U
        for (int child = 2 * parent + 1; child < len; child = child * 2 + 1) { //从parent结点的左子结点开始，也就是2*parent+1处开始
% k: _8 j$ v8 k+ b, g  z: C2 a
6 D2 L6 @# S2 [! x4 @) g# {% f! E
            if (child+1 < len && (maxheap ? arr[child] < arr[child + 1] : arr[child] > arr[child + 1])) { //如果左子结点小于右子结点，child指向右子结点
3 r- v, Q) v2 h$ k3 k9 j                child++; //右孩子如果比左孩子大，我们就将现在的孩子换到右孩子
            }

$ n7 t( S/ \  K* ~; W
- I5 K+ o$ A$ x! ?2 r" T9 i            //判断是否符合大顶堆的特性， 如果右孩子大于双亲，自然左孩子也大于双亲，符合
0 C$ a" V- \9 U4 H7 K# f0 p  b3 y            //如果子节点大于父节点，将子节点值赋给父节点（不用进行交换)
& k8 Z2 v, l+ @! B" A# ^' Z            if (maxheap ? value < arr[child] : value > arr[child]) {
, w) V0 j0 P% v2 c5 I4 b% N                arr[parent]=arr[child];
7 `8 }2 Z1 \" C                parent = child;
            }
* f; S3 T* X, B3 p* h0 a* w5 ]            else {//如果不是，说明已经符合我们的要求了。
                break;
# O; \' c" K- ]            }
        }
& [* k. b3 g7 p: f: L# K7 u        arr[parent] =value; //将value值放到最终的位置
, M  x! P1 t7 f5 Z$ ^* s



- {* E$ t) g. ^  b; V    }


}
1
2
4 D8 n3 W- Z+ U+ L0 x3
4
5
6
7
8
* f) L- w$ O2 h( l: _, z9
) b  Y3 _6 W1 k+ B% M2 j8 ~) V  i10
' K) `: I. t4 T9 L/ p% }  H  J' E11
8 r4 l& Y- m+ J/ A$ \0 S" B12
13
14
15
16
17
18
, X) I# g) L0 R% L8 y/ Y19
20
  `; X  t0 h/ h21
22
23
! t/ s6 v0 x1 A$ W8 }' r' t2 I. d4 p24
2 i" G7 g) v% R& A* N- H25
26
27
28
) q' ?6 W2 f; r, Y  ~6 ^+ A# t  c% H29
30
! H: P  }  w1 X: W# x) n31
32
33
; z) M* ~) B  P- N* u7 e34
7 D- X0 u! ]; H) `% O" e3 k35
36
37
% ~" }) K, v/ b0 J3 r, l38
39
40
) z. K' `1 b* a41
42
) }2 s# M6 \% F43
4 Q: q; K  p4 J( R; _44
0 Y% h5 X9 D: C" }9 L45
46
47
& B9 f/ h, k0 w! p48
/ g1 U! z, ?. A$ s7 ]# x: V49
50
/ J; `2 \; S0 a2 D4 B51
52
' |, ^: l* H3 O6 V- F9 Q+ f53
/ U& H+ j+ ~# o! `$ ^4 {* ^54
7 s5 I' q( `& W% o' A% P55
56
# o: d6 X# Z5 [- z  d57
+ |# o, ?6 r; j# Z' B58
59
60
61
62
63
: `3 {0 n5 X% n2 U/ j64
65
( t$ N* `0 H' e4 }66
( L+ x6 S9 n; W/ g. }6 S* U67
% ]+ d9 U3 h+ R% x/ }" x( o# E0 U68
69
70
71
$ y4 O9 ?& Y. j& z- O1 X' T72
/ Q5 k) ]4 W% U73
& t* {0 b5 y( w) ]8 L) e74
; A8 L: H3 \1 h4 W& `- g: V4 ^0 o  |归并排序
7 E5 f5 c. g$ |+ h0 D7 ^简单解释：
该算法是采用分治法，把数组不断分割，直至成为单个元素，然后比较再合并（合并的过程就是两部分分别从头开始比较，取出最小或最大元素的放到新的区域内，继续取两部分中最大或最小的元素，直到这两部分合并完，最后所有的都合并完，最后形成完整的有序序列）
( X7 b% n3 b) w' ~6 H

* S. A8 r, B& }' c- b4 ^
  v% O2 _2 D/ X& q$ v0 i. ^
4 v" q- _& T' A& {# }
* C6 u4 f$ s( w- K2 W
完整代码：
5 h& Q9 N; o+ {6 x3 Y
) r! ~& r& {4 u% D' N9 Y4 b" X
package com.keafmd.Sequence;

# y" E7 b4 M( P
/**
( Y( P" E' n5 i7 C1 d * Keafmd
7 D! R# K; f; M" C *
# c* h6 p. Y$ m" Q * @ClassName: MergeSort
* @Description: 归并排序
* @author: 牛哄哄的柯南
9 q) \6 U/ ^- J/ |$ i" u! b * @date: 2021-06-24 10:35
*/
$ J( W9 g5 ]6 K: c1 _9 |public class MergeSort {
4 |, j- O6 J0 D. h& c% S

    //归并排序
8 ~+ c, \* D* A% m7 H8 y; h' }    public static void mergeSort(int []arr ,boolean ascending){
1 z# O- x+ g' l4 v        int[] temp = new int[arr.length]; //在排序前，先建好一个长度等于原数组长度的临时数组，避免递归中频繁开辟空间
" A" t0 l$ |: e9 ]        mergeSort(arr,0,arr.length-1,temp,ascending);
$ ?6 @: }. X$ N  G5 R2 ?& O    }
    public static void mergeSort(int []arr){
$ g$ f1 _$ c* x2 x        mergeSort(arr,true);
    }


, }9 e; D/ W  M3 y8 g  m& \( A  F    /**
7 d: U0 u& J, n( ?+ I* s     *
. ~0 E- B$ S4 T! L& y$ F     * @param arr 传入的数组
     * @param left 当前子数组的起始下标
     * @param right 当前子数组的结束下标
     * @param temp 拷贝暂存数组
     */
    public static void mergeSort(int []arr,int left,int right,int[] temp,boolean ascending){
        if(left<right){ //这里是递归结束的条件，我们是对半分，那当left==right的时候肯定大家都是只有一个元素了。
' {3 n' L5 {4 G+ r2 W2 H3 y' F6 Q& [

! p) W8 c, y( x6 a% L" e# f            //对半分，比如总长度是10，left=0，right=9，mid=4确实是中间分了，0~4，5~9
            //当长度9，left=0，right=8，mid=4，0~4，5~8
            int mid = left + (right-left)/2; // 防止越界的写法
            //int mid = (left+right)/2;
% o: ^, z4 c. i2 z3 u& n: g
" ]* [. \5 t' R* l
            mergeSort(arr,left,mid,temp,ascending); //左边归并排序，使得左子序列有序
            mergeSort(arr,mid+1,right,temp,ascending); //右边归并排序，使得右子序列有序

! a. ]+ L3 s  E. ]" H) H% R( K9 t+ a
9 u1 Z- l0 G$ ?& T1 ^: x            merge(arr,left,mid,right,temp,ascending); //将两个有序子数组合并操作
        }
2 |( k! X. w6 I4 ^) n    }
/ i( k/ j9 T4 A2 r, C) @( k
! R: a, c' H9 p3 s: u
! C9 P2 D- E2 J) z  _( x    private static void merge(int[] arr,int left,int mid,int right,int[] temp,boolean ascending){
1 R4 r. X1 N; |" z: L        int i = left; //左序列起始下标
3 C  N. b% n; q4 f. u" x" T& M        int j = mid+1; //右序列起始下标
7 z3 a( q4 g5 m( m  t3 }' d        int t = 0; //临时数组指针
        while(i<=mid&&j<=right){
            if(ascending?arr<arr[j]:arr>arr[j]){ //比较两个序列第一个元素谁小，谁小先拷贝谁到temp，然后对应子序列下标加1
                temp[t++] = arr[i++];
: G% C5 N1 b3 J6 v1 U            }else {
2 a6 C  M, v6 c# ^. }& b1 F( {% @                temp[t++] = arr[j++];
4 Z  X7 y9 O; @% r            }
+ K; v/ l) p1 S0 C        }
- u2 q5 z+ z, _5 X1 r2 C4 l& R

/ A% l( O1 q1 S# u4 ^0 Q  r* W% {. ?        while(i<=mid){ //将左边剩余元素填充进temp中——左序列有一些数总是比右边的大的数
. x3 D- M4 z; u1 y& M* _  H/ `            temp[t++] = arr[i++];
6 v. u+ |# C: v  g        }


& o5 S, i, k- ?        while(j<=right){ //将右序列剩余元素填充进temp中——右序列有一些数总是比左边的大的数
            temp[t++] = arr[j++];
; B1 o6 P# h! N+ }2 ?        }


        t = 0;
1 M8 i1 w5 B6 W

        //将temp中的元素全部拷贝到原数组中
8 @) M! b4 r7 L# A        while(left<=right){
            arr[left++] = temp[t++];
/ w+ o/ S0 A/ p        }


    }
0 Q% C7 C3 p& Z9 v' J$ _& W% @
& C) @# z# {5 \
}
1
/ w- X/ o: P: t. Q$ X8 E2
3
6 [, n* |# T6 W4
5
; u9 d- ?! a2 `) L2 h, ~2 a6
7
8
  C. a5 [0 l  v1 B9
10
- l+ g2 a! X8 V1 X) b* d8 o11
) @. v" l' u9 M* u" F12
2 g6 W5 s9 y" w/ s13
5 G8 C4 ^4 V1 o# z0 _, T14
15
  }2 b& k0 Y5 E5 P5 _! ]# K16
; t, S, H& Y( L; N/ L! R. I17
: w4 z. u& n, M: v# f/ h18
2 \! ~& C2 E: Q, M1 i4 Z1 m& B+ E19
20
1 ^1 J& n3 S* d/ X" r# G21
22
* k1 ^5 Y, R0 ~$ ~" R% F23
; y4 E  J7 h6 E; S4 S. l. c24
! M5 x% K5 e. j9 B25
/ e- [! \1 b0 K; d26
! M8 e# V# ?6 }: S$ P- y  i27
0 O! @# ?* k8 G) ?* y( f28
29
30
' G# m  Q- C# q! l# h  M& h31
32
33
34
: l( o; z% d1 u7 j! f* H35
! w2 Y# ^; `5 e1 @1 a; {36
37
, P' b* Q: i1 {38
39
& u+ o$ h0 h2 u9 Z* h) @+ o$ [  S40
7 p) ?+ j+ e) ?- g* a! i" X41
42
" @( B+ k, [9 X# c43
# H( i; T4 z$ ?4 T" ]44
& d: ~, t; x! L/ y" \: Q45
46
47
48
+ m  L; e# I  Y, K/ E- y( S. X49
50
51
, a. W6 c- W9 f$ @3 L52
  i5 L0 X, Z7 c: m  W53
54
55
56
57
$ l+ o: X( z+ O% [7 {58
( _9 b8 ^3 T" f: J, z59
9 l% p! H7 U/ q8 y# o. M+ c4 l) ]60
! }( H( |9 [( q3 b1 J61
: k8 h0 N2 G% _6 ]7 z7 E: I62
63
64
65
& p' j2 O0 f2 i  D$ `8 ^66
67
4 }5 D" a/ |8 G! X: R  b2 `68
& Z  H; _; Y, Q) s5 p69
; q2 |0 p1 ^% L' O4 X! U70
# u7 i  |: [  U! Q. U71
6 G: Z  X4 {6 i& w2 T72
73
插入排序
简单解释：
: n& y& Q+ e( n* T; C- m+ d最简单的理解就是打地主时我们拿到牌后的整理过程，从第二个牌（假设我们拿起来这个牌开始比较）开始，（说下升序）从后往前比较如果比前面的那个牌小，就把牌往后移动，直到找到一个合适的位置（这个位置的前面的那个牌不比这个要放下的牌大）就把这个牌放到这个位置，慢慢的前面的部分变得有序，直至全部有序即可。
4 f4 S2 r% I. C9 `


& t' D. ]6 W3 g2 Y& [* k

) t. C7 U: Q" _# E0 \
完整代码：

4 o: t6 [0 X, b5 Y
; c) _+ {: O3 k+ B$ B/ Jpackage com.keafmd.Sequence;

* B' A( F9 _/ R( s# O' A
8 h& W1 m1 E1 h5 u# `/**
3 H9 o0 X& \  F) ]+ X, i/ F * Keafmd
*
8 t/ v* B6 f/ q * @ClassName: StraghtInsertSort
* @Description: 插入排序
9 E7 b) h7 s0 y * @author: 牛哄哄的柯南
" {6 r0 @" c/ [ * @date: 2021-06-24 10:36
$ r& t" q6 ^( K! U5 V1 ~ */
public class StraghtInsertSort {
    //插入排序
    public static void straghtInsertSort(int[] arr) {
8 ~* a5 x7 a: V) N7 Z* Z        straghtInsertSort(arr, true);//默认进行升序
    }

# |! M. C% h, P; W  J5 x
    public static void straghtInsertSort(int[] arr, boolean ascending) {
+ W, C& P, p3 j" p7 e7 Q& R2 O. B5 s6 y
& }/ l7 v5 U* Z& X0 W
        for (int i = 1; i < arr.length; i++) {
, o6 @: [$ \2 N/ v            int temp = arr;
            int j=0; //这就是那个合适的位置
            for (j = i - 1; j >= 0 && (ascending ? temp < arr[j] : temp > arr[j]); j--) {
: O9 l" c8 u1 T* H0 |4 i0 v                arr[j + 1] = arr[j];
. S; `2 W) H  [' Y9 v3 H            }
            //把牌放下，为啥是j+1，
3 |( {" j* N% M8 e( B% M            //是因为上面的循环遍历到不符合情况的时候 j是合适的位置的前面的那个数的位置
. I3 I0 Z+ F/ j, ?- t" o3 o            //有点拗口，但是就是这个意思，看图方便理解下
            arr[j + 1] = temp;

7 A% _9 b! u1 w+ l: x

$ I' C2 d! k$ J/ l5 t$ x6 d! z  Q
' L6 j/ n8 O1 o- B/ m        }

" m6 {% C8 Q$ f, w
    }
}
8 G% t  n3 G/ X2 u1
4 x% j7 D. b3 g6 A( @" e+ j2
3
4
* z$ R+ `" f4 k, w$ ?' C4 L% Q7 H5
6
' X* F( z" Z0 n7
: i6 V# h! O0 G, J8
, v+ X$ \6 g: p. L7 s9
- U9 _# |; A0 u8 k10
11
12
13
& _" {- K  ^; V14
15
16
0 `: n% A3 h7 Z/ J' q/ S7 N; V17
$ Y( |$ U4 ^9 s' i# f% l18
/ S% T6 I3 r2 r6 n4 w# k( L7 C& A19
20
21
22
23
; L3 L( K+ Y# x' c2 A" E4 v24
25
26
8 e! {' O  a0 {$ k27
28
6 O4 y7 @! f  D/ c: ?. v! v& ]29
30
31
/ v: k9 B% A- n32
5 x) P5 g. d3 C" |1 Y33
9 r' {. S; R6 v/ T: l% r34
% u8 z6 S2 R5 I. m% \希尔排序
2 s) y- u2 q$ K8 `简单解释：
希尔排序是插入排序的改进版，我们理解一个叫做下标差的的东西，也就是下面那个图中的增量d，初始下标差为arr.length/2，然后继续/2，对在同一下标差（相当于把这几个数单独拿出来了）的若干个数进行插入排序即可。

# W0 j* a" e; w, j$ w
; v* R2 O, i2 C, @, V* j" y


# a# y7 s9 c3 _3 O. p6 a
7 t& ~  V8 t1 Z* `- [3 `& a+ F完整代码：


package com.keafmd.Sequence;
! }1 G7 @3 U+ p
4 R. U  P2 f: C7 S: S
; @" p; S: ]8 R5 `/**
* Keafmd
2 X" D; X/ q3 L9 e1 K *
* @ClassName: ShellSort
* @Description: 希尔排序
; z& w/ P  \. Y2 |& H' k1 v$ f" P * @author: 牛哄哄的柯南
  [  c# A2 V. l( d- d0 g * @date: 2021-06-24 10:39
& d; m: ~$ p) Z8 e */
public class ShellSort {

5 K$ s; y7 A0 d" V3 v
    public static void shellSort(int[] arr) {
        shellSort(arr,true);
7 x+ ?! W( k+ ]; O$ s  b9 o    }

$ \) v/ L: p2 U+ p
( C. s" D- r* Q; H    public static void shellSort(int[] arr,boolean ascending) {

* M$ v3 y, v; z8 g7 T5 |8 |6 {
        for(int d = arr.length/2;d>0;d/=2){
; d/ G8 S4 c! X- Y
+ h5 H$ u1 {4 c$ c
            for(int i=d;i< arr.length;i++){
6 W4 f& E  r* f0 q. x$ v/ d                int temp = arr;
; v% ~: m; Y6 Y                int j=0;
                for(j=i-d;j>=0&&(ascending?temp<arr[j]:temp>arr[j]);j-=d){
                    arr[j+d]=arr[j];
                }
                arr[j+d] = temp;
! C+ n" p8 T& [+ k% \: ~( e4 b            }
        }

; _2 G" t$ w% q5 j0 N2 P6 j
    }
}
( g1 G+ q0 }$ I* Z* e1
2
3
4
1 }: M: |& t. p& z( Y5
6
7
# S1 {0 j$ w6 s% i8 R8
5 U! x( y3 D2 }. U; F' z9
: a, ~/ ]" j% n/ X% R10
11
1 A8 o) J4 A) ~9 f% p7 ]2 S12
) E5 B  R: E3 D; g13
14
  X7 Z. u& t4 N15
16
17
. D* f, o' \: I; t- y18
! d% Q' j( u: L3 C19
2 ^/ b9 Z  _4 x! u8 |" ?20
% {" [- [' s0 W21
! o$ j+ {: d+ x- U' @5 f5 A& }* Y22
9 f- k# {& o8 i9 w2 H+ M4 D* ^' p23
24
2 R! I; ^& f5 R, I, a) z# V25
26
27
28
29
30
6 \3 ~+ P5 c  C( Y$ k$ \* w31
32
计数排序
简单解释：
. @8 x9 j" O; P: T这个排序算法看名字也很好理解，就是就是额外找个数组来计数，然后在这个数组从小到大或从大到小把数取出来即可。
+ G  k  u: Y. W8 i6 n3 t




& `. Z. i- V0 [
完整代码：
1 z7 `7 }1 }8 _+ @1 f4 k8 q
! }& a& I8 H7 f. _3 b( A: ?( {
package com.keafmd.Sequence;


7 d; _) a" B: B# B5 K' p/**
* Keafmd
*
/ G, @1 b+ J. M4 A4 p- } * @ClassName: CountSort
% z2 c) s8 l% D * @Description: 计数排序
* @author: 牛哄哄的柯南
* @date: 2021-06-24 11:31
4 b. x/ l  j! k& E" [: q0 v2 T */
$ j, N' h% V6 e+ f& b( D2 spublic class CountSort {

1 k6 s; C& ]) O3 o$ i" F9 l
    public static void countSort(int[]arr){
8 F+ N9 w* M( Z9 b& S        countSort(arr,true);
0 t7 g' p8 U% P2 p; A: Q" \; V    }

" G: k$ c: J  ?* u
$ u7 h' W7 f9 B% P    public static void countSort(int[]arr,boolean ascending){
( @7 L) A) A6 t* I4 u$ T. V        int d,min=arr[0],max=arr[0];


- Q5 c/ k2 ^* L" A: [        //找出最大、最小值
        for(int i=0;i< arr.length;i++){
9 a2 Z3 {; _! y+ a% |: h. }            if(arr<min){
                min =arr;
            }
            if(arr>max){
                max = arr;
            }
1 i) b: j/ k" Z7 \        }
1 a" w+ e8 M( P( e. @, S
8 t5 d+ a3 O$ H( a1 U- N& b6 |
4 C/ E" s) M$ I9 o0 ]1 R! |        //建立一个用于计数的数组
        d = min;
/ o- ?2 Z7 \" H/ b. u* A% S        int[] count_map = new int[max-min+1];
5 Q- C, K$ f- w, d4 F2 s4 v        for(int i=0;i< arr.length;i++){
            count_map[arr-d]++;
        }
6 G. c& h" E' S1 k9 y
8 G' N7 F+ E: i8 R/ Q' I* G
# i7 O( h0 q& Q$ i        int k =0;
- N  C$ @4 f& t9 n        if(ascending){
7 z) j' k( u4 w6 y1 J$ ?4 V            for(int i=0;i< arr.length;){
3 Y: I$ W8 `  |3 O2 S% r                if(count_map[k]>0){
                    arr = k+d;
$ d4 N* ^- s& ^6 ]% a! C: F; I                    i++;
' S9 C7 X9 t& c# D+ b                    count_map[k]--;
3 S3 R5 I0 j" m6 u' n                }else
                    k++;
            }
        }else {
            for(int i=arr.length-1;i>=0;){
                if(count_map[k]>0){
                    arr = k+d;
                    i--;
                    count_map[k]--;
                }else
% @5 f/ R8 o/ D6 Y2 B% S- _                    k++;
+ i  z$ h. t# r' O            }
' J3 V% s" [/ x8 d        }

, x+ X: T8 @" V. g( _
5 ^; V, X" J* t1 t    }
+ a  o1 F' L# z" \2 J8 o}
, a* B5 b# @3 Y' O8 M5 x: r1
: H9 T3 H! a( P4 `3 a) R6 s2 ]  J) L2
3
4
9 G5 K3 M: @: P; L( r3 m7 m5
6
7
9 Q9 R' m  q+ v: c  z, M8
9
10
3 c# Z2 ~5 G) K  ]11
12
# Q- l0 o( L+ k4 _; |13
9 M9 T/ h6 I% r3 V% u: h9 Y% e14
. [4 n9 `8 c: I15
16
17
$ c! x1 b) d6 ^$ {2 l18
19
20
21
# t4 D- c- x" U$ K; I3 c22
* ]% ~4 e, W9 |. n) H) y23
9 F* ?) y+ ?, x. i2 m5 B24
+ |5 l# w* w5 m) H* z# N25
26
  h) w, I% K9 l3 s* a. g' d27
# I$ W* b# j( a9 R5 Q7 s28
+ ]( T' Z" \9 t& _: y29
+ g& i  e* L8 n2 c8 @: R30
. A0 }& T3 e, t- Q- N" |6 t31
, i" I, r+ t4 }1 ^, }" p. U! |32
33
( o0 g9 H) p# e4 T) j" o34
4 r* d" I+ b% ]9 r- a+ \35
36
& k6 n# j5 R7 k& E+ @* F+ L37
38
$ {( P8 B% W; k7 `) c4 e39
40
41
42
5 Y+ s5 b7 [% y8 V: Q8 e9 ?: A" q43
44
. Q  Q, j+ i8 @$ X7 Y* Z4 v* V45
46
4 v, \) [( {. c' S47
0 h/ _1 `- X* k/ l48
49
' Q) _+ o6 A4 @* p50
9 V! Q! v0 l' e; H! |0 C51
) B) M' o  n2 W52
7 z2 C% Y) o4 P, j8 C" u5 i  K! V53
54
/ z- T! D2 J  Y5 k# l  B5 X55
# W5 _5 q# ?* _% M* h' {: p56
57
58
& v$ a3 V; c; d& s59
桶排序
简单解释：
就是把一个数组分成几个桶（其实是几个区间，从小到大或从大到小的几个区间）装，然后让每个桶（区间）有序，然后取出来放一起就可以了，相当于把几个有序的段拿出来放一起，自然还是有序的，当然需要是按照区间的顺序拿了。
5 K  U. g/ s6 W: M% ]: l


2 Q7 u' k9 Y2 J) F8 z# |1 N
. p# K2 l( ?& D" R
/ Z9 G# D+ o4 R: d. T: [# i
+ z/ S* _! Z  k+ r+ Z9 Q  |完整代码：
2 Q  m& N$ j3 h- i8 r  Z5 o9 L
* u6 V4 y' ?; @, G# c& _, _
5 t: L  |+ k( X6 m$ B7 Dpackage com.keafmd.Sequence;
2 q7 x* ]) N1 k8 u+ E
& c2 @7 n) r* W. N7 Y5 A. i  B! x
import java.util.ArrayList;
import java.util.Collections;

8 l; f, E9 y" y6 Y, }! E
/**
6 q5 L$ j+ z7 [! m/ z% L& m * Keafmd
*
* @ClassName: BucketSort
2 o; q8 N+ n8 ]7 r. [& N2 F * @Description: 桶排序
* @author: 牛哄哄的柯南
4 l6 C) c7 E. H( V3 |7 W * @date: 2021-06-24 13:32
*/
; g( Q3 u) V) ?3 v# W6 |public class BucketSort {
0 t7 }6 ~  v: E0 i
8 @- K/ [8 r: N5 T/ k4 i4 ~0 c  r+ W
6 Z( \* M7 F: r1 V1 U    public static void bucketSort(int[] arr){
        bucketSort(arr,true);
4 R$ ?( a- X& N    }
4 Y: I# X; x5 e/ E% I3 U3 V

6 S& s4 o$ q+ q2 \/ w7 _6 P    public static void bucketSort(int[] arr,boolean ascending){
1 q, e0 ]- F9 M  M. P        if(arr==null||arr.length==0){
7 p: E8 L: ~5 \' ^' e6 W  G4 v4 m            return;
        }
        //计算最大值与最小值
        int max = Integer.MIN_VALUE;
, V7 Z9 Z) X: \8 O! N: F$ q        int min = Integer.MAX_VALUE;
0 y) K6 }, ]  e' N, ?        for(int i=0;i<arr.length;i++){
            max = Math.max(arr,max);
; `3 K! s$ X6 w/ t% l6 B            min = Math.min(arr,min);
        }

" O/ j; v; D2 D! b  Z" g# j8 C3 o
        //计算桶的数量
* I4 o- l# O1 H+ i- B& T$ d/ K5 T        int bucketNUm = (max-min)/ arr.length+1;
        ArrayList<ArrayList<Integer>> bucketArr = new ArrayList<>(bucketNUm);
        for(int i=0;i<bucketNUm;i++){
3 d8 s; J- U' A& {            bucketArr.add(new ArrayList<>());
        }
; j0 e2 R4 Q9 F2 s( D9 ^8 r
& }4 W6 X  U; h, R5 L7 Y
        //将每个元素放入桶中
, Q) X" O; E$ H        for(int i=0;i<arr.length;i++){
3 e; f7 }# \. N( f3 V0 o/ }1 w            int num = (arr-min)/ (arr.length);
$ r6 e; p0 ^7 W+ \( k            bucketArr.get(num).add(arr);
        }

3 {& J) p* M0 G
        //对每个桶进行排序
0 |, B! K* G$ }7 e0 v; X9 \% W& N        for (int i = 0; i < bucketArr.size(); i++) {
            //用系统的排序，速度肯定没话说
            Collections.sort(bucketArr.get(i));
1 o" t# Y. l, {. z, c        }

# q. U1 i9 \. K
. Q8 F6 @* W" e2 I, ^0 e& \        //将桶中元素赋值到原序列
" t; @% P4 `* n/ k        int index;
        if(ascending){
6 C& J1 m3 h; ?; m0 ^            index=0;
        }else{
, G2 D) P; ]' T+ h# M            index=arr.length-1;
1 C3 n" W! Q6 g        }

/ O+ y, s: m0 @" t; g5 u9 M5 I
5 ~/ {' t* c% b0 N% F" U        for(int i=0;i<bucketArr.size();i++){
* X% a3 ]" B* `+ G2 t" J! U* Q            for(int j= 0;j<bucketArr.get(i).size();j++){
                arr[index] = bucketArr.get(i).get(j);
5 N; V5 f! J" F! p0 q' w+ S                if(ascending){
- _/ l) S2 g% N: I                    index++;
) c* `, @  t3 z& a" I                }else{
0 {9 \2 B0 I  o- d1 E                    index--;
8 l) `! O6 b4 |$ I) D                }
. O. }) l6 m5 @& L+ w            }


8 N8 q" C, S$ P* O4 j4 b! \        }


    }
}
1
# Q! M' x7 t* \) E2
4 G' u0 }$ V) q$ }# D3
4
9 t/ m: V; D- X2 h2 H1 Y5
6
7
/ v7 T3 c8 m5 d6 S! X8
4 {  T7 m8 J4 K6 D# Q9
/ H+ G8 f; e; Q( N: V10
11
; T) x! r* q) R5 `+ @- p' {12
13
* h5 u) A7 [6 A" H  Q14
$ t1 c# h" u$ D& }9 b, f/ s  w) Z15
16
17
4 ^+ R& Q! J; U7 n. L18
19
& t* G5 o& e% i+ b20
21
. S9 [8 T, l% m( P. {+ C22
23
; ~" H9 f, e+ @1 m$ U( z24
. N+ [8 C: z' V6 \3 B25
26
) P( }2 p1 x. \) K3 k, w27
; |4 \! q* y, n# b) _+ J- ^28
! m% J# s$ G5 z. P% n& m' o29
& A1 p! a+ t( b! D30
31
32
$ r! h$ r( Z2 |! t6 M33
  i: `* R. d0 E& f34
35
36
% W4 K5 X+ P; o: U% V37
38
39
40
. J/ p' Z9 J% M41
" N) Q* s: ?3 x42
2 E$ b6 A% Y/ ]9 X$ R9 W, U43
* e% J- p6 A0 U+ S) _3 T44
45
& O4 ^0 A- r+ j" w46
4 [$ v2 C, u) O! a47
48
6 d( z: ~1 ]1 v) \/ p; e49
# k3 ?/ G+ X+ O& X( ~, G/ y) m50
" }7 e+ B* g( Q- g0 [, b51
52
53
54
0 g; U/ f* H7 \0 C2 L$ T: }. Q55
56
3 B5 Z0 V; |" t2 ?/ {& c! D  _% p57
: N0 g2 [: K* g- Z  @# V+ k% @, k58
59
, k3 b9 g" r6 |# U6 J60
# @$ ]. a  K3 _61
1 i/ A. i7 i' {/ _- b0 h62
63
% ]0 m; N/ U3 Q7 {2 c64
# x6 y5 u8 U5 _5 R" P' b65
9 o. o6 ~0 Y1 \! a) D8 L* b) Y" L0 f66
! M+ o! N5 h% |- b% s( ]67
68
9 T" P2 {7 Z6 U. u& L69
6 H- W. \6 \/ p70
71
; z. i0 ^& d& M. _6 s8 W' U2 _72
基数排序
$ b; o% k  H, @4 W' H0 g简单解释：
1 l' m- L! `$ @+ W$ Y) ]* }; ~9 f7 P首先说一下，我发现好多人写的基数排序只能排序正整数，其实只要处理下就可以排序含有负数的了，就是我们排序前先把所有的数整体变大（就是减上最小的负数，也就是加了），都变成正数，然后排序好之后，在减下来（加上最小的负数，也就减了）就好了。
基数排序就是按数位排序可分为LSD（从最低位[也就是个位]开始排序）和MSD（从最高位开始排序），下面写的事LSD基数排序。
7 x: p; m( o( ^1 m# ~基数排序就是把数按位考虑，让后我们一位数只能是[0，9]，就是我们在考虑某位（个位、百位· · ·）的时候就只看这个位的数，放到在[0，9]相应的位置，然后顺序取出，最后再按其它位这样操作（上面说了要不从低位开始到高位，要不就是从高位到低位）

  u! r, O  j! Z& U3 ^
& x% U5 ~3 o" ]# R% F


" V. F0 T: E6 \
完整代码：
$ k1 w8 i4 ]6 ^8 Y1 ~

1 M3 N- h2 {/ X7 N" cpackage com.keafmd.Sequence;
% x7 i0 R( ^2 V3 A5 x  ]0 i9 M

& p% f( K3 F4 u" C# [* z" `( O/**
) ]+ Q3 M$ i) R/ g+ r  ] * Keafmd
*
9 ?: ?7 O+ ]7 I9 l * @ClassName: RadixSort
* @Description: 基数排序
* @author: 牛哄哄的柯南
5 ~  d0 I) ^" K# C4 m! a * @date: 2021-06-24 14:32
  Z3 V  Q% h5 C; ?. B */
public class RadixSort {
- _! |+ F, N" p, |! P7 e    public static void radixSort(int[] arr){
$ U! W- E. |* X+ ?+ L, ]- X        radixSort(arr,true);
/ @3 S0 v( x& ^. J) B    }
$ d$ |  T- `/ r5 N1 G    public static void radixSort(int[]arr,boolean ascending){
2 G3 Z" {: F5 G" }2 W( \        int max = Integer.MIN_VALUE;
        int min = Integer.MAX_VALUE;
        //求出最大值、最小值
2 @/ S! b+ {) v! D        for (int i = 0; i < arr.length; i++) {
6 _& g1 Y# E( A; r7 b            max = Math.max(max, arr);
8 b7 s' R# e5 H9 ^$ b            min = Math.min(min, arr);
        }
, m$ d0 m; w9 x8 d. V0 w        if (min<0) {        //如果最小值小于0，那么把每个数都减去最小值，这样可以保证最小的数是0
2 m- ]; T5 n) W# Q$ ?2 x/ U  L            for (int i = 0; i < arr.length; i++) {
                arr -= min;
            }
            max -= min; //max也要处理！
  X& g+ b% d( {! B4 o/ H* ~        }
        //很巧妙求出最大的数有多少位
: C) [9 ~9 r1 Z$ j1 T- n        int maxLength = (max+"").length();
6 U" r( Q' M* Z& x2 Q        int[][] bucket = new int[10][arr.length]; //一个二维数组，一维代表0到9，二维存放符合数
8 s  e0 Q) r6 O# v        int[] bucketElementCount = new int[10]; // 用于记录0到9某位存在数字的个数
        for (int i = 0 ,n = 1 ; i < maxLength ; i++,n*=10) { //个位 十位 百位 这样遍历
' \- {4 k/ D0 i- L; \3 U# |            for (int j = 0; j < arr.length ; j++) {
6 L! w/ W" t  J8 W                int value = arr[j]/n % 10;
                bucket[value][bucketElementCount[value]] = arr[j];
+ J) n8 T2 a5 c; H3 g# {- Q) d                bucketElementCount[value]++;
) t: v; I& x- W            }
) e% d6 T; Y3 y7 [" g  N$ z7 Z9 u& U8 O6 G
/ V9 A. B) O, n. \3 X
            //升序
            if(ascending) {
* ?$ t/ I( j& m2 ~1 U                int index = 0;
                //从左到右，从下到上取出每个数
0 Q1 Q* A' V  c0 w                for (int j = 0; j < bucketElementCount.length; j++) {
                    if (bucketElementCount[j] != 0) {
4 r' o% Y- j& W; I) Q" y1 M1 n                        for (int k = 0; k < bucketElementCount[j]; k++) {
) T7 R' l7 B& m6 m0 d- p7 o                            arr[index] = bucket[j][k];
$ ~: P; i: K- L4 T) P, S6 F                            index++;
3 L. A0 k8 n% d                        }
! O+ t# Y6 L+ t% N; D                    }
/ a: S* Y% h0 z) _                    bucketElementCount[j] = 0;
& G2 R* ^1 j1 ]                }
- H+ @0 Q% C8 D% }7 K            }else { // 降序
7 x) i  u5 o3 S  [4 O, ]/ p                int index=0;
" V, S( d1 i" Y; p7 f& I                //从右到左，从下到上取出每个数
. f8 k1 R" `" F3 R0 W( e2 c                for (int j = bucketElementCount.length-1; j >=0; j--) {
                    if (bucketElementCount[j] != 0) {
7 i, B$ r6 Y/ v" B& b                        for (int k = 0; k <bucketElementCount[j]; k++) {
3 X' Q, F& \5 z% ^! Y: S                            arr[index] = bucket[j][k];
                            index++;
                        }
                    }
                    bucketElementCount[j] = 0;
2 w4 \- o, C0 [% l                }
            }
- f, x2 K6 w2 H- ?* k0 g



6 r& Z8 V6 ~& v; m/ x! l. T# |# k            /*for (int i1 = 0; i1 < arr.length; i1++) {
4 d8 i2 G/ Z( j# ?! q1 o( W                System.out.print(arr[i1]+" ");
            }
            System.out.println();*/

3 Y- _1 l4 z" M5 i% E5 X

5 V0 E. g. R3 R( N; _: t% r
+ m, w6 \) a$ o( K9 z" K6 ?

        }
7 D6 O5 J; }, ^) u* z% m& L        if (min<0){
            for (int i = 0; i < arr.length ; i++) {
                arr += min;
* I% J+ ?) o+ k  g! g            }
3 B0 e  u2 ?$ y        }
0 Q8 s  F/ b8 U% l% h

" p& M1 z& Y' `3 c8 g: o& r1 N    }
}
8 m# s( b. F7 A* X& r# }1
2
3
& j% ]& u7 @3 X- v) g4
5
) X% [) E1 o0 T8 K$ ~" u6 J1 o6
7
4 m/ t' Q1 N4 R! L8
9
1 q1 E# X0 ?8 N5 C( M  w/ p2 M10
11
# Z5 B5 a6 m) Y( w1 x12
13
2 h% z' @$ _( Q$ p" |! {( Z. g% C14
  C" q$ ]6 \6 b7 c7 `  `15
16
17
) n9 O+ n( Q& j18
2 e% h5 ]' z$ |% v: W$ Y* j19
( \1 K0 K# U/ O20
21
' @4 Q" M. M+ A$ c& j/ {22
1 l+ t7 P: b% Z3 @23
24
25
- L6 c6 L" u) M2 L3 a- J26
8 Y" P- B' P9 }6 d27
28
29
30
31
32
33
34
35
) l- I# b& E9 e36
% Q# T  j3 C7 l, |- V0 j1 ^; @37
7 `& Q5 f. O6 E! y4 q38
39
40
41
& C1 ?; n. [/ Y' S! [8 d" k; e' `42
43
6 y% y5 i7 m8 [8 s6 ]6 s44
45
. a% t; {* r2 I% ^% s3 S46
% |& D8 _$ j! L) \% c7 a6 g47
) L3 v* h. V% ]: ?/ @+ N. H48
/ ?+ [, V6 n& ^0 S- g1 c0 j49
50
& k; N7 @' i8 r, p$ F51
# Y" [' c; x! D+ U52
53
" R. ^/ O  x/ r% c5 p3 o. p& U54
55
( H6 N/ x& O5 c" y56
8 l. l* `+ q  \2 d  ]6 W57
8 [1 p& N, E" a1 x: a3 h8 P58
4 z6 p& d7 f* }# [59
60
9 z; @: }; D6 n$ @0 A61
& M7 q3 O  R* r( Q0 {8 b62
63
0 S0 F& Q2 v3 @# Q9 g7 O0 P$ m9 @64
65
# w8 V5 g& X7 {$ x5 o; J( G66
; t# O' H" H7 v2 P6 n67
68
69
6 W  l% N$ Y3 v+ ?70
71
72
73
74
5 I0 ?4 M: V& `. T" P# o& l75
76
; [! l1 `2 V% o2 b" a# T77
) F( W# ]6 s- m# |8 G78
79
80
81
% b! u$ |0 `+ h, g, |+ }2 [" U82
; ^$ u* G% `' q1 }. x83
完整测试类
package com.keafmd.Sequence;

7 @4 [! a  Z/ @4 C& _2 R
import java.util.*;
import java.util.stream.IntStream;
import java.util.stream.Stream;

0 C5 s9 b) {7 b1 {+ }& ?4 u5 Q( B3 f
/**
* Keafmd
9 r7 m! h: k$ C- Z( Y *
1 P* s1 a% E" r' _% ]% w3 U+ G * @ClassName: Sort
* @Description: 十大排序算法测试类
) D7 X2 z/ U5 z4 p * @author: 牛哄哄的柯南
* @date: 2021-06-16 21:27
*/
3 `3 u5 ^* t  N% T; N: B* |public class Sort {
9 z- S  n. {4 l; n( M8 u% L
' s0 h/ q. O/ E7 a6 X2 f
& t: f' Y" }' P  V! K. [" c
, b0 @9 {( w5 n; I
7 v5 N' A! L8 A9 @) P. u* o# X    public static void main(String[] args) {

8 B, D0 V! r8 D" T% P; P; {* ?3 O
        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};
8 J4 [+ C7 u9 B2 L6 `  E        int[] temparr;

! J/ G4 O+ a* r8 b8 G* A
+ _6 Y2 C+ B6 z- [0 Z- k        //利用系统Collections.sort方法进行对比

+ L9 F2 v0 j8 k; V0 J
        //将int数组转换为Integer数组
/ `9 N$ N7 X$ c2 c4 ]        //1、先将int数组转换为数值流
        temparr = nums.clone();
        IntStream stream = Arrays.stream(temparr);
        //2、流中的元素全部装箱，转换为流 ---->int转为Integer
        Stream<Integer> integerStream = stream.boxed();
! |% u3 ?3 ~* F- b3 D  {, w        //3、将流转换为数组
4 ^- z4 b$ l. Q2 o+ _        Integer[] integers = integerStream.toArray(Integer[]::new);
4 X+ e1 L9 h1 {% S! F* `        //把数组转为List
        List<Integer> tempList = new ArrayList<>(Arrays.asList(integers));
' K: B( D1 I; f$ T& B) ^) e4 s; V! m        //使用Collections.sort()排序
+ [# j3 H7 A8 E4 c/ x4 B; y        System.out.println("使用系统的Collections.sort()的对比:");
6 ^/ s- {( U. @
. ?$ [8 {5 S: @/ J  G
( p9 ?8 [4 d, M+ ^        //Collections.sort
7 [  m7 A6 X5 z1 ]: [! i        Collections.sort(tempList, new Comparator<Integer>() {
            @Override
5 B( r% X" C% i            public int compare(Integer o1, Integer o2) {
                return o1-o2;
$ j. ?" s# c" s, F; }4 b                //return o2-o1;
7 t% W( E2 c5 D! _' D            }
        });


* f$ y" x# _6 W# a" C. W        //tempList.sort 也可以排序
9 o4 v+ ]& Y$ K5 y7 h9 V& X. t- Z       /* tempList.sort(new Comparator<Integer>() {
" h. V8 X- d5 r+ @6 [            @Override
            public int compare(Integer o1, Integer o2) {
                //return o1-o2;
+ n5 a1 w+ d5 q- F, o1 ^# z                return o2-o1;
5 w0 L: v4 F; k            }
8 B1 b* c" d" I) X* `, K, b        });*/
% J( W& }+ q1 D$ a
* p; J, _  e  V7 B& p: A; W4 k
) T  C8 I7 a/ _; c        //遍历输出结果
        for (Integer integer : tempList) {
            System.out.print(integer+" ");
. J, a$ i, b& s        }

  z$ T7 D' f- B) {+ X) _% B: R
# e( B; F; E8 Q& B+ L' K        System.out.println();


        //测试冒泡排序
3 X" r( W7 ^$ \        System.out.println("测试冒泡排序:");
2 @( `# H3 a. C2 [# f        temparr = nums.clone();
: B/ g) {0 L6 H8 n  o1 `" y

        BubbleSort.bubbleSort(temparr);

3 }$ S0 K' e7 i' m9 l, N( A1 s
( W2 [" V  Z9 U- t( ^        //降序
        //BubbleSort.bubbleSort(temparr,false);


        for (int i = 0; i < temparr.length; i++) {
4 e, b4 L* ]0 I" ?$ ?. g            System.out.print(temparr + " ");
        }
: Y! v  B) |1 B. j) u# y! H. `        System.out.println();
! S! L. S  q; r5 @% v& q' ?* ^5 v
( v2 g1 C8 W+ |. N, _
& k/ |9 t/ L1 m. z# F4 O        //测试快速排序
( w0 Z7 P6 w8 }        System.out.println("测试快速排序:");
        temparr = nums.clone();
9 y; q9 N/ Z$ F- z% W# m* `% N        QuickSort.quickSort(temparr);
5 r; I( p$ P0 S/ ?6 W        //QuickSort.quickSort(temparr,false);
        for (int i = 0; i < temparr.length; i++) {
            System.out.print(temparr + " ");
        }
        System.out.println();
8 ^- C: Z' ]3 \, ^1 f% E- s
2 y: ^# G* E' e% o
        //测试直接选择排序
        System.out.println("测试直接选择排序:");
2 x9 T9 _5 E6 Z% |- D        temparr = nums.clone();
        SelectSort.selectSort(temparr);
        //SelectSort.selectSort(temparr,false);
0 x/ f2 f! K1 i* j" o        for (int i = 0; i < temparr.length; i++) {
. }  V' l6 m. f' s2 h. e            System.out.print(temparr + " ");
        }
1 i" N: o- J* v) `1 i0 T5 P6 L, i1 p" N        System.out.println();

/ {4 F: f% |- P- `1 t; M0 q
        //测试堆排序
$ N, j% E: a/ o" C7 H' ^/ n        System.out.println("测试堆排序:");
        temparr = nums.clone();
$ b0 P8 M0 b) m$ S        HeapSort.heapSort(temparr);
        //HeapSort.heapSort(temparr,false);
- a2 U* I; k) k1 t/ q6 x        for (int i = 0; i < temparr.length; i++) {
/ W- t# c- ~/ D7 i3 J            System.out.print(temparr + " ");
        }
" a/ b5 c( h4 _( u& ^' g$ P7 y( I        System.out.println();
0 J& _, B. D' w( M! Q

2 v9 S& I, P' H6 `+ x! c$ p        //测试归并排序
        System.out.println("测试归并排序:");
- q0 d  x9 z8 S7 {# E        temparr = nums.clone();
! l# j. R! F6 k$ a$ R- j/ ^4 z        MergeSort.mergeSort(temparr);
        //MergeSort.mergeSort(temparr,false);
        for (int i = 0; i < temparr.length; i++) {
8 {( J  }3 ^$ c" U  X6 F( j            System.out.print(temparr + " ");
        }
1 {  d% M" O7 ~) Z$ |: u        System.out.println();
% ]% v- R, u0 K& G1 }/ T6 P. F
" ]9 {) O" E5 l$ k* y
        //测试插入排序
        System.out.println("测试插入排序:");
        temparr = nums.clone();
8 c" ^! \" u0 K7 s9 B  E" J9 Z        StraghtInsertSort.straghtInsertSort(temparr);
        //StraghtInsertSort.straghtInsertSort(temparr,false);
        for (int i = 0; i < temparr.length; i++) {
- |7 R' e. z+ A" d            System.out.print(temparr + " ");
        }
        System.out.println();
' t( |- v& E' E" Z1 N: g


, t) n& x: i. m, P1 {" Q" a
        //测试希尔排序
# D( b0 l: W; m* u8 U8 Y        System.out.println("测试希尔排序:");
9 e/ h3 P0 O( ?        temparr = nums.clone();
        ShellSort.shellSort(temparr);
        //ShellSort.shellSort(temparr,false);
        for (int i = 0; i < temparr.length; i++) {
            System.out.print(temparr + " ");
        }
        System.out.println();

& T! E  n# i. }9 k$ Y  C
6 w% d5 B' v5 u- ]. J0 {
0 v$ u( a9 C5 c% J0 s9 U9 M5 K5 m: Z
        //测试计数排序
        System.out.println("测试计数排序:");
        temparr = nums.clone();
        CountSort.countSort(temparr);
        //CountSort.countSort(temparr,false);
        for (int i = 0; i < temparr.length; i++) {
7 O9 v$ V6 s2 R: t- D0 o( P            System.out.print(temparr + " ");
        }
        System.out.println();
$ X! s2 M- b5 N1 ^- d% J5 q7 m


0 E1 Q3 ^+ J! P  b2 x
6 H" q6 P4 t% F+ {) [        //测试桶排序
- T" ]0 ^' f& A' E% ]        System.out.println("测试桶排序:");
0 o  l4 a( g! H: C8 }* O% L        temparr = nums.clone();
        BucketSort.bucketSort(temparr);
        //BucketSort.bucketSort(temparr,false);
        for (int i = 0; i < temparr.length; i++) {
$ F& ~+ O. X4 I6 I6 \7 }            System.out.print(temparr + " ");
0 t$ m5 g  x( O! S: M        }
4 b" I- ?; H' a! Z& V/ ?& F        System.out.println();


8 Q/ O; p7 H/ g        //测试基数排序
" J5 b1 a) f# V' T' m( @! e; j        System.out.println("测试基数排序:");
        temparr = nums.clone();
        RadixSort.radixSort(temparr);
# k. m0 k6 t, e' |( e' l1 Y* q6 g        //RadixSort.radixSort(temparr,false);
        for (int i = 0; i < temparr.length; i++) {
8 d- R, w" ^8 K# k1 Q            System.out.print(temparr + " ");
        }
        System.out.println();

0 g$ E) S  N5 ^
) j" }# A; @0 }: `: R. |6 H  F# o    }
* L7 d1 }9 K6 o5 E

7 s" b0 I+ l1 x* {% s; |' p5 M}
1
2
3
4
5
; O& C- r& G6 x) C$ ?0 h$ o6
2 I- K6 U! R0 V8 L7
: J5 f. n2 A% }% p+ Q, h8
9
10
5 H9 F- Q% W4 A; z: @% U6 z6 {11
4 [+ ^1 B& K* [9 }12
13
14
15
16
  ~+ I/ [. H# w+ Y: R. G17
6 A! |3 W2 m0 L* O; Y) Z; ]18
7 d4 n+ B' y2 c% g' ^' u19
" k! N* p: @! ~- g5 g20
- b( ?8 k6 q; b. N( S, q, {1 X21
22
23
24
1 z/ R2 M1 ?  V' p25
26
27
2 z7 S5 ?6 Y+ D' ~2 o28
2 ?2 ]/ X0 B3 j4 s: @4 w# G4 u29
30
3 ^9 ^; l- c0 Q) R31
32
33
34
35
36
! O, @- T1 ~1 w0 g37
7 _$ b: n% i; ~7 m; A( J: Y# Z38
39
5 V! B6 M. _( U" c" ~& d40
) O! Y" {( H4 Q% G41
* N4 N5 ^* X  L2 o$ q0 z2 P. G42
  X" H/ _% _! E1 x+ c6 ^43
44
45
46
47
48
, l5 ?) W+ @% P& p49
50
51
8 Q! ?! C6 ?* {8 |5 e52
53
8 U  R* q& H' U- N; t54
55
56
$ ~4 `; |- i; R4 k* J$ r$ K( K57
58
! S: Y( w7 ]8 S: R1 B8 V59
% u4 R6 F- X* y6 [- _60
61
62
63
64
7 w2 ]3 j9 w5 {1 f  C65
66
67
) j. A/ s6 Y" j! s$ @68
+ M/ ]* N& u4 y1 p69
70
9 L$ q# m6 G* n2 ?% m& F71
/ @, C' [) D& i2 o72
% N  P, F# c: E% y& G3 a73
74
75
: I$ w- o$ I; w  Q6 I0 Q! R. ]76
77
3 C8 i2 |: ]" _78
. T1 l; \6 T* c4 h' v79
80
) O& O4 W( F6 i' q+ ^8 M81
, r) r0 W; G; }4 L6 m& ^82
3 Y1 d$ q# @! g- p; `/ s83
84
85
$ w& [  x# L( Q9 b4 H& k+ s86
87
88
9 |" l2 |9 @( ]0 o89
90
6 `* g+ R2 P9 U. K, f91
92
6 f0 {; N- {" l1 p- ]93
3 x- A7 ^: `  B! D  t94
0 d) E7 _7 o9 c! |95
96
97
7 ?- m0 a$ [8 a4 j$ H9 w98
99
100
101
102
103
104
105
% u# z, o# `* q# @4 c  |! ~; ?106
107
108
109
2 Z* @3 S* `9 L2 A$ U8 C110
111
  g' H5 B7 B# S6 e, E5 |* F) p112
# m- i1 R5 N7 y0 ]" q- K& [2 i113
114
7 P- b: ]. y- f. o9 h115
116
: l7 E0 R4 L! H+ n# @117
118
- `7 C+ P2 o) G% E3 R- G8 T# l0 W5 H6 P119
120
121
: {6 g9 I! |8 F! O& L4 `; z122
9 A3 e! P) J6 y& C/ P3 W" i0 z123
124
- {3 I2 d: z% `' ]4 P; C7 a5 F9 m125
) C( x# o  z5 G126
127
6 l5 b; {, w( |  N; ?8 ^( v( i/ j128
9 |3 P& b4 @1 E; [129
' D# I5 t; E5 R; |; f' |+ w130
, g/ q2 k8 K" U131
4 f" Y1 P) s3 q+ f4 q132
+ c6 h2 Y$ F3 {5 U133
$ a3 H5 p% B8 X/ t. E$ f134
& m7 F# {  E# p+ }6 Q6 W135
136
: e/ Z! ~. u6 B7 |) ~137
$ F  |2 Z" j9 ]. w3 K4 a! l5 q: d138
139
# k/ P6 j6 ^7 c4 L% f. L3 P, F( B140
141
142
143
5 G. h7 H0 }9 K0 w: Z144
- J' c$ L3 F" X; m/ h& v. g145
146
, `7 B. A- u2 P, j2 ?7 x147
; @/ y/ u1 K( X! K. y$ m: G148
/ _7 \) _! a9 n; ^& I7 i( `149
0 q5 ^2 b' D8 @& g0 N150
151
152
. N9 {$ o, c; q; G153
* ?. o) i) T( O' n+ }7 n154
& [1 O5 G* z0 H1 W, Q1 X3 _( [3 e" y155
156
157
158
$ w  q3 P% _3 ?* x$ |: {159
160
161
; z) t0 _9 d  i" `2 n. p162
. J$ M7 i) G1 V! @' J" Q163
164
5 e1 L" l* n% R' N/ c4 d5 b* m3 i2 G165
166
167
, M2 U& |8 C, x6 N) Q168
4 S; s0 H" R9 `; t169
170
* X$ h! E$ ~7 k; W( b' t* b171
# q2 w) L: o- `, b172
& X+ |2 p+ C4 L" p0 F% |" _173
每天进步一点点！
不进则退！

' E$ H% g5 H" w$ s# V2 _1 l: G
& q! B; |* ?+ ~# b: N版权声明：
& P9 Z6 y2 }6 J9 U) [# u原创博主：牛哄哄的柯南
; O) a, b! H, h; I博主原文链接：https://keafmd.blog.csdn.net/
————————————————
3 ?' c0 }7 d; J3 }5 P5 V版权声明：本文为CSDN博主「牛哄哄的柯南」的原创文章，遵循CC 4.0 BY-SA版权协议，转载请附上原文出处链接及本声明。
2 n" k( P: `3 t& g原文链接：https://blog.csdn.net/weixin_43883917/article/details/118193663


- g$ h% I: b. j& H

1051373629

每天进步一点点！