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

杨利霞

经典十大排序算法（含升序降序，基数排序含负数排序）【Java版完整代码】【建议收藏系列】
经典十大排序算法【Java版完整代码】
写在前面的话
十大排序算法对比
) _, P0 n; z1 r" {4 M冒泡排序
0 w5 s: I+ S( I- G' Z* N; ?0 B快速排序
8 i. O* ~* R# l6 \$ d8 c1 W" Q! S直接选择排序
堆排序
归并排序
) P2 D# ~  O) C) r! X9 C  S插入排序
# z) _/ Q$ y- J. i+ Z) i2 N希尔排序
计数排序
桶排序
基数排序
完整测试类
" t0 R: c% b+ ^" z. q$ i  V# X* b写在前面的话
" {; _. s5 |+ E. j- B: q2 k! U       虽然已经有很多人总结过这十大排序算法，优秀的文章也不少，但是Java完整版的好像不多，还存在某些文章代码存在错误的情况，同时也为了自己练手，决定把所有的写一遍巩固下，同时也真诚的希望阅读到这篇文章的小伙伴们可以自己去从头敲一遍，不要粘贴复制！希望我的文章对你有所帮助，每天进步一点点！！！
3 u! Y( ~" R+ K4 _/ ]* T, M

$ x9 y4 K7 ^- U8 w/ Y1 {       我用通俗的理解写下对算法的解释，对某个算法的运行过程不是很理解的话或者想看比较官方的解释的话，单独搜索某个算法，看几篇不同的解释，就可以有自己的理解了，这里我主要展示代码以及进行通俗的解释！整起来，再强调一次，一定要自己敲一遍，这样才能理解的更深刻！
7 ^# N, i- G- e+ p# D" q* R* M0 C
/ `6 t, S: t/ }, c6 f9 O  G
十大排序算法对比
" V1 d6 O% @6 U8 y! o3 q* }

2 \! j: `5 n8 B

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


冒泡排序
简单解释：
       原理就如算法名字一样，就像水中的气泡一样，每次我都把最大的或最小的放到最后面，这样总共需要n-1趟即可完成排序，这就是第一层循环，第二次循环就是遍历未被固定的那些数（理解成数组左边的数，因为每层循环都会把最大或最小的数升到最右边固定起来，下次就不遍历这些数了），两层循环遍历结束后，所有的数就排好序了。
" E3 J( ]  g, e/ I2 Q       两层循环所以冒泡排序算法的时间复杂度是O(n 2 n^{2}n
2
)，是一个非常高的时间复杂度，我在下面的代码进行了优化，加了一个标志位，如果上一次循环未发生交换，就说明已经是有序的了，就不继续下去了，反之继续进行下一轮。
$ p& ]% u1 G  A# I9 d! x. k% F: w
! |9 G0 L) O9 R# m/ `. j

6 i- G  _; E- T7 S9 A
3 E$ ]4 V! d( f

2 i- ^$ d( }$ i# o; v8 y本文的图片来源网络，仅用于大家学习，侵权联系删除！（下同）
4 f) Y3 |% Y' Q5 W) ?7 |
  I: X4 k4 ]0 |& @; s
( Y" G. r4 M* F+ c完整代码：


. J6 a; q9 Q& f! S0 K& tpackage com.keafmd.Sequence;


, m' {% i) \4 O' o0 e9 {/**
* Keafmd
*
: C& K2 q1 j/ ~4 `) s * @ClassName: BubbleSort
' x5 y7 t5 X6 f! g4 ? * @Description: 冒泡排序
/ m; ^5 _! y) o0 |2 { * @author: 牛哄哄的柯南
* @date: 2021-06-24 10:31
*/
# e# `- V1 _# c, ?3 @- K# npublic class BubbleSort {

- ]* S5 D# M- W1 i9 J& x, g/ d
    //冒泡排序
    public static void bubbleSort(int[] arr, boolean ascending) { //exchange标志表示为升序排序还是降序排序
- r' h, l6 K7 Z' j/ T3 J6 L

        boolean flag = true; //加一个标志位，记录上一次是否发生了交换，如果是，我们则进行下一轮，如果没有，说明已经冒泡好了
3 Z" H7 b" w' H4 d; c4 |- t
5 M% u5 g- p' P
$ A, c+ `8 {: r" {        for (int i = 1; i < arr.length && flag; i++) { //控制次数，第几趟排序，只需要n-1趟，有交换时进行，只有flag=false就说明上一次一个元素都没有进行交换
7 }# ], H1 }' R3 n' w
  \% L# q- [" W- S9 ?: p* y
# _# p. V. F' z' n: b1 [% y- ^# t            /*System.out.print("第"+i+"次遍历：");
            for (int i1 : arr) {
) I/ d: U" j/ D& C- R                System.out.print(i1+" ");
. a! G: |0 i$ ?2 S9 o5 P6 M  k            }
            System.out.println();*/

  ~/ p$ l" c; {: U
* H* E  _+ T8 ?/ F6 T            flag = false; //假定未交换
3 Z: z. w5 o# j! P8 F/ {) q) [9 N

2 f. h4 P- Y! U6 A( F            for (int j = 0; j < arr.length - i; j++) {
% u0 \$ k1 ~' b0 Y  o8 j
, w0 }, N2 P) u- \- `2 h) L) A
) b0 I+ \1 @5 L5 \& A                if (ascending ? arr[j] > arr[j + 1] : arr[j] < arr[j + 1]) { //控制升序还是降序
9 \, d' g1 s! e+ O. H. p                    int temp = arr[j];
                    arr[j] = arr[j + 1];
                    arr[j + 1] = temp;
                    flag = true;
6 S" r" |; t9 k4 R: Y; Q                }


9 Q: k4 p5 V5 p; V2 p! ^            }
$ r6 z$ E0 b: J2 v1 S        }
    }
% ?9 _: {: y5 l, O& Y; q6 T
4 r$ f, t. q% r' J
7 z" q/ f5 [" G( N: {" ?9 I    //冒泡排序 -- 默认不传参升序
    public static void bubbleSort(int[] arr) {
        bubbleSort(arr, true);
3 \/ f5 T* z2 Z8 F/ i8 c! H    }
}
1
( L, l8 p* f& R/ [# o2 R- S/ _2
% y. P* X5 g  |9 A# O3
4
5
6
7
8
6 x9 ~0 p/ a6 k0 _, H5 P# N) u9
10
+ H1 N3 k7 I. f. ~& w6 Q7 z4 k11
12
$ ]2 p4 ?/ x6 _( B13
14
15
16
) s1 u0 l0 S  t& n5 n, Q6 B17
; e( H  W1 C6 V4 v: D: N7 x  B18
19
20
21
22
23
! q# L6 A/ m) d24
! w1 \8 B$ T8 S25
. ^* M9 Q7 Q3 Z% \5 s6 C% [26
27
28
29
30
31
7 r/ S4 s& K" t& @32
. i* R  u) W& n33
34
( e% O% p1 \/ D$ Y35
; Y: c$ v/ {! k. F; g3 `- B+ c36
37
38
2 ?. @" O) L0 ?$ h' n0 k# @/ A$ f% a' N39
0 V* v  H' u; f; e40
41
& U$ x" A/ H: g" m42
43
44
& E; j8 g% {( l2 g45
测试代码：
7 k* ~; v5 p" V% h8 t# \" H; f% P

升序排序（从小到大）


package com.keafmd.Sequence;


import java.util.*;
% m9 J3 h  d; timport java.util.stream.IntStream;
5 z5 w/ h- W; `9 i6 g5 ^import java.util.stream.Stream;
: k' C* E+ l; {( [
4 q+ Y. g" N) m/ y
/**
% N4 w3 f3 J1 }0 X# v' x- E * Keafmd
*
' ^; J' i) U+ c0 e* R; R- Q6 }1 U * @ClassName: Sort
* @Description: 十大排序算法
# c! h  Z! i# d: V * @author: 牛哄哄的柯南
* @date: 2021-06-16 21:27
1 s+ T# N# m- X/ [ */
public class Sort {
    public static void main(String[] args) {


        int[] nums = {12, 4, 25, 47, 58, 34, 25, 9, 99, 26, 1, -13, 162, 10093, -66, -1};
4 T" D% U, _4 h; d        int[] temparr;
+ c- l, D" ]! T3 Q

2 V0 _& ~  [2 s' R4 c        //测试冒泡排序
        System.out.println("测试冒泡排序:");
        temparr = nums.clone();
3 t& @/ z# q  ]# X        BubbleSort.bubbleSort(temparr);
        //逆序排序
. X) z5 s, ^4 M0 d# q% C+ P        //BubbleSort.bubbleSort(temparr,false);
        for (int i = 0; i < temparr.length; i++) {
8 |( {/ a2 z/ o2 H: V            System.out.print(temparr + " ");
1 y" {3 b) b! d        }
        System.out.println();


    }
}
) s. ]+ U5 P; R/ n1
0 @- q  p, P0 X- V+ t9 u8 l1 I2
3
( }" t1 y2 B1 l1 n5 \4 h) q7 |/ k4
. y: Y& r5 r" F3 f) E8 _: b5
6
7
, b$ u9 N# y5 T- ]( `8
! \1 U' i, G$ g9
# C9 S% X  v9 K* t6 j10
7 e8 f# t9 G3 E* c11
3 t" y' D& W, I0 c12
% m* ~, @7 P4 H9 D7 x; S- ]13
2 X! u% ^- e" l- J+ s5 I14
5 T- y1 h7 M: A15
16
5 P0 c' S# Z; O* _( ?17
5 F# l" B. g3 j2 p18
19
$ a" o# D3 D% U# b20
21
6 W4 _$ }9 l: m: h2 }8 r  d22
23
7 v# A* z. Q! S24
25
* s* b6 T7 {7 {  \, e26
27
28
29
, |8 V7 q5 {) H2 K" a1 j7 O% y( q30
, ?: \7 [% D- M- Z31
. ?% Q+ v8 X$ N* B4 x7 q32
33
, H% \+ [" f- ?6 u7 h运行结果：
/ b5 K- a4 X7 X: |
) m9 _+ g0 D4 h) R! }- E
测试冒泡排序:
-66 -13 -1 1 4 9 12 25 25 26 34 47 58 99 162 10093
, A# p0 a2 v8 @$ [. U1
! @( k+ ~8 l0 d8 ~1 l/ H; V2
降序排序（从大到小）
4 j0 t' C( S' s/ y, K: F( ]1 l) H. Y
# J# r2 H* ]  a, ]' H
//测试冒泡排序
System.out.println("测试冒泡排序:");
4 a, G, }; P' ]! J6 M8 a. Y# Itemparr = nums.clone();
) {  T* b0 L" o2 G( z: x  M$ g- F7 oBubbleSort.bubbleSort(temparr,false);
" r# A8 v4 K) @% \# a& Pfor (int i = 0; i < temparr.length; i++) {
% k; J9 G+ k2 r% Z' g    System.out.print(temparr + " ");
7 z3 j: b; U& N& W7 i0 W0 R5 y}
4 r9 c2 c) o# D2 T( fSystem.out.println();
1
) x8 ^( W( n+ n3 h3 y2
/ e! l( D8 u+ S& {3
4
3 x2 ]7 q. s5 O" B4 q7 s5
% Q5 {" n" u: i0 @# A/ r# ?& `( Q+ p  G6
* D! l3 Y. a( a7
, J5 i9 G  f% u, ?4 l  y8
) x7 `/ D1 k% z; _运行结果：
2 b. \. R8 n" p, m6 @: t$ g

测试冒泡排序:
- L, B% J# }5 c: H10093 162 99 58 47 34 26 25 25 12 9 4 1 -1 -13 -66
1
2
下面几个算法的测试也就是换了下类名和方法名（换成相应的排序算法），如果想降序就在数组后面传个false即可。我就不一一复制了，我在最下面给出含所有算法的测试类，需要的自取即可。
+ {$ Q1 u* R1 D" I' m: r7 p

快速排序
7 ^+ T& u! K  l5 s- p简单解释：
快速排序就是每次找一个基点（第一个元素），然后两个哨兵，一个从最前面往后走，一个从最后面往前面走，如果后面那个哨兵找到了一个比基点大的数停下来，前面那个哨兵找到比基点大的数停下来，然后交换两个哨兵找到的数，如果找不到最后两个哨兵就会碰到一起就结束，最后交换基点和哨兵相遇的地方的元素，然后就将一个序列分为比基点小的一部分和比基点大的一部分，然后递归左半部分和右半部分，最后的结果就是有序的了。
. l: X  I# ^: t0 \4 F) N8 Y

3 H7 D' W! [0 h1 a, r* K

% w6 |4 P5 ]  _" _. @0 w
( ?! T: Z/ Y( C' {0 B) U# P
完整代码：


. k) Z  E8 B0 J7 O  Cpackage com.keafmd.Sequence;
1 N5 X3 s9 K' F8 e9 ^+ v: X

6 H+ \+ }' c1 m/**
* Keafmd
. ]7 }* f- y2 k* B. U. g  l  w *
* @ClassName: QuickSort
; H% ?2 S( ]+ x2 J7 ~ * @Description: 快速排序
* @author: 牛哄哄的柯南
2 g8 D; h& m8 x. e7 \  c * @date: 2021-06-24 10:32
) z2 x; ?! E- L2 Z9 S/ r */
+ S; w4 s7 _, ?0 w5 \# x0 Xpublic class QuickSort {
' C- l: n& I$ ~3 V% B
( q8 {2 S( ]8 q6 M# L2 J
! ^7 F5 R2 Y- y8 }7 V    //快速排序
6 Q8 O" g: w- m; S! a( q, I    public static void quickSort(int[] arr) {
        quickSort(arr, true);
    }
# h( R0 k) z1 J7 y2 L, r' c

    public static void quickSort(int[] arr, boolean ascending) {
4 t; b" F+ O1 @8 M4 |        if (ascending) {
            quickSort(arr, 0, arr.length - 1, true);
; B. _) J) r3 t; h* O        } else {
' \  m$ [: Y! q0 V            quickSort(arr, 0, arr.length - 1, false);
        }
% U6 m0 A$ ]6 w1 E" R0 P9 q8 t! D    }

3 p5 N: W* G$ c7 t( \
    public static void quickSort(int[] arr, int begin, int end, boolean ascending) {
        if (ascending)
            quickSort(arr, begin, end);
        else
& v/ ~, n5 z7 Y: Q            quickSortDescending(arr, begin, end);
  l8 |, \1 f; r" U9 r  e; L  @6 \- [: z    }

/ {# |% F8 w6 g/ P( D" r1 l: a
  R3 \- h9 j8 d# ^    //快排序升序 -- 默认
7 V' u4 F+ d4 i" ]4 X0 Z5 \    public static void quickSort(int[] arr, int begin, int end) {
4 `1 u% y$ q9 i        if (begin > end) { //结束条件
            return;
: Q8 Z4 H- a% L/ y3 I2 I        }
1 G  L9 Z! ?/ c        int base = arr[begin];
        int i = begin, j = end;
# v8 m; Y+ q" }. J8 l; F1 W        while (i < j) { // 两个哨兵（i左边，j右边）没有相遇
            while (arr[j] >= base && i < j) { //哨兵j没找到比base小的
8 N* `" w2 ?+ `7 |: x  i" \) [2 o                j--;
            }
            while (arr <= base && i < j) { //哨兵i没找到比base大的
                i++;
2 k7 ?0 \4 ~  g& R' |$ O6 m. Y            }
            if (i < j) { //如果满足条件则交换
; ^. [3 M& B  O& F; I                int temp = arr;
4 b. e0 L: r) n                arr = arr[j];
                arr[j] = temp;
            }
+ k! m$ J+ e" W/ R9 H' P5 y
8 N' c7 s0 r0 N/ M0 \
        }
        //最后将基准为与i和j相等位置的数字交换
3 S' O9 t+ R& @  K2 H* W        arr[begin] = arr;
& ]5 }; N1 }2 v/ m1 ~9 C1 v        arr = base;
        quickSort(arr, begin, i - 1); //递归调用左半数组
* _8 Z" x* ^  I% ~        quickSort(arr, i + 1, end); //递归调用右半数组


    }

$ d, E5 P7 Q( s
/ w: p1 h! A* q1 l. J8 ?/ E0 f    //快排序降序
7 [! w1 _# K9 I+ e4 s. z    public static void quickSortDescending(int[] arr, int begin, int end) {
5 v) a6 I2 u/ k' }        if (begin > end) { //结束条件
            return;
        }
" M" S7 m- \1 C! M: L* l2 ]        int base = arr[begin];
        int i = begin, j = end;
9 T# ]: j0 x" e3 Q, ?: B% d/ k' j        while (i < j) { // 两个哨兵（i左边，j右边）没有相遇
            while (arr[j] <= base && i < j) { //哨兵j没找到比base大的
                j--;
8 c4 W. k1 T2 `$ U) c" E  I            }
            while (arr >= base && i < j) { //哨兵i没找到比base小的
$ b* w( f: Y2 l: W                i++;
% P' D0 q* ^, ~8 F" x9 i- J4 Z            }
            if (i < j) { //如果满足条件则交换
( z$ W, E4 r9 ^8 x( L* p                int temp = arr;
                arr = arr[j];
                arr[j] = temp;
            }
6 g# L- _* L) Y' m/ N3 t
! [. ?2 t9 H- ]! b
2 Y+ V) D0 l$ x        }
$ o) O* [8 I; t; z2 O        //最后将基准为与i和j相等位置的数字交换
        arr[begin] = arr;
        arr = base;
1 v3 ?0 l% v  M: H/ I$ p8 a" D/ g        quickSortDescending(arr, begin, i - 1); //递归调用左半数组
! N/ [; j5 C5 G) L" f. n# n! Z& D2 H) A        quickSortDescending(arr, i + 1, end); //递归调用右半数组

( H' {- X4 \  V1 P' \4 O& }
8 R/ _9 t6 ?4 D) \$ q$ E! I& @    }
' a* p3 e/ Y) b8 t

}
. D( a. J# \) U, }, T+ M& l9 R& d2 }1
2
& l! @2 S5 ?6 y$ H2 k+ V3
+ j, d. e1 N2 e& y0 D+ q8 e4
5
) y9 e. b, n, _( @6 n4 p6
7
8
  a0 ^5 ?9 b& J- K9
10
# h& \- `3 k0 N" b" k6 Z6 I11
12
6 l+ E+ c. D' G8 e13
14
15
16
! ?9 r; A* F7 h- ^6 r6 X, i+ w! N9 h' h17
; I' ^3 c- F7 g# t4 T) ~18
19
5 _, u/ q. W  |$ u20
21
: M) {& U2 x2 j' C" D0 e22
23
0 O% Z5 E( i$ Z24
25
2 L. l+ f' i$ m5 Q8 R! @# [- v26
, F3 A6 p8 u0 N$ Z  X27
28
29
2 y. i! _' S/ J8 [30
1 F7 I' d6 P) n- B- L8 K9 L/ D31
2 t5 X  U& o! X% B32
* P+ S: S- L# W, q" N* L33
34
35
36
1 \2 d; p0 V8 n6 H1 F; g  w- {9 T37
38
8 W: @3 A; o+ B; l39
& a6 }4 R9 r( r( W  u# I4 X40
4 J! z0 W; d5 U& L8 J) B41
42
43
44
45
46
47
) v0 c% T$ _3 j; }% V7 _9 ^7 ]48
: B8 B* N% b' Y* \7 w49
50
9 _8 S. |2 w. I% N51
52
. T1 u; ]5 h+ o: N53
& k% M9 e5 ~+ S- O! m3 U# f  o54
' [( M+ `) x3 G  b8 m1 a7 s55
56
# d! h+ j6 J3 o  T- L' \- b! k57
58
59
. P* m( I+ Z0 Z+ n9 l60
61
7 @' y( Q0 @6 c% ^. T( _62
* N5 }! A. {0 x' e63
64
$ Y5 E: O+ U; r' Z# x: g) F4 M. ]65
7 D6 n6 ]  t2 s4 Y& q1 _66
67
68
7 [1 A! p. }7 y* K) M9 C69
! @7 O3 B0 a9 b, V0 N4 F- y& D70
2 r0 H& c, y( C6 x1 m, |71
: e1 V+ O- x) M- N9 f1 V8 }72
73
; {' m8 G9 y9 x! b1 V% E( z74
75
76
. e2 `. A5 p, h' I# W4 ?77
78
79
. K/ e4 m8 D4 p5 Y% V80
81
" U7 ^$ Z3 F# F, d1 \" d" ~82
83
84
% x# j' k: a' S8 @5 F  z9 d85
* m+ F, Y  N2 R) A  T3 T: `86
87
. S* t( u7 H& z3 x88
89
90
7 @( z# v, L; l7 {6 p91
直接选择排序
( k$ M' E3 o# d9 g8 D# a3 Q1 X简单解释：
" I0 Z/ \0 O5 e; d' n1 _' H数组分为已排序部分（前面）和待排序序列（后面）
第一次肯定所有的数都是待排序的
2 G: [% H8 _5 x7 A从待排序的序列中找到最大或最小的那个元素，放到前面的已排序部分，然后一直找，不断缩小待排序的范围，直到所有的数都是已排序的了




" [$ X' P7 E4 V5 m; [$ o; R/ J
! j+ w: h; g4 S% o: b- Y4 y1 _
完整代码：

6 _# U1 R) W. ^
# M( [1 o5 H4 C" a& v2 ypackage com.keafmd.Sequence;
6 Q/ e5 d. ^6 U2 B8 v. K1 [

# E0 R8 @/ x) X, C4 D$ {2 h/**
* Keafmd
  f6 H% S" z4 G *
* @ClassName: SelectSort
* @Description: 选择排序
) o) b; J. D( q * @author: 牛哄哄的柯南
* @date: 2021-06-24 10:33
& X- i% p" W, ^  u; B  ~ */
( [# s8 B/ @5 ypublic class SelectSort {
; B7 ^* D) e3 |5 K8 _1 p
1 q6 r2 X( p8 `' {6 I
    //直接选择排序
    public static void selectSort(int[] arr, boolean ascending) {
        for (int i = 0; i < arr.length; i++) {
            int m = i; //最小值或最小值的下标
3 i2 E1 W6 w% W% w- h6 U8 u            for (int j = i + 1; j < arr.length; j++) {
& _7 {& S# \$ Y. d/ V! s! {0 `) r; t                if (ascending ? arr[j] < arr[m] : arr[j] > arr[m]) {
                    m = j; //找到待排序的数中最小或最大的那个数，记录下标
9 F3 W- V+ c: Z                }


  o" _. H7 G: g, [  w: r! p3 ?- t            }
            //交换位置
            int temp = arr;
& a% P/ f8 _# Q* C6 I7 @            arr = arr[m];
5 F3 G9 Q% W( t* u            arr[m] = temp;


4 C1 K* J/ u7 U$ w2 F0 U; ^        }
    }


) {6 C) I( ?: ]' r6 b    public static void selectSort(int[] arr) {
        selectSort(arr, true);
    }
/ u8 U  |' L, I/ n# A* ~% w) \9 C}
1
) I  S1 v2 L6 f7 M9 J) o2
5 A' ]9 }5 z& a5 o3
4
+ Q. B# S, t3 ~0 l5
: J* i# q9 @3 p7 G" \% K5 Q6
7
8
5 H% b1 Q6 X" U7 }) i( h( g5 X9
/ Y" K( \( J. r% v10
+ H1 H2 k( n8 d! Y) W11
! g9 [3 k  p' j  W* H7 ^12
13
14
15
16
+ S6 P* Z' Z' G  k' e" U17
% y/ v. p  Y: Q18
19
% @* W- H8 }1 g; T7 L% b# s6 R20
( W% w; O" ^( n2 A21
' o5 _& \' R9 v5 ~4 U% U22
23
9 N  W6 w& _6 w6 m' B$ A  o% J24
25
( {; I; R3 \$ P) f5 ^0 [- s26
27
+ t4 k* N. I4 P28
29
, U  l  p- \, f6 x* r1 Y30
31
32
9 ~. G7 @; w7 M  j4 R33
34
, \0 J: P  y( r堆排序
8 V0 N) l! v; w) v$ b- ^先理解下大顶堆和小顶堆，看图
大顶堆，双亲结点的值比每一个孩子结点的值都要大。根结点值最大
; {$ }  Q9 T5 s+ \+ n) b5 W9 }4 s小顶堆，双亲结点的值比每一个孩子结点的值都要小。根结点值最小
5 X2 r/ Q1 [9 w% V: ]0 z  u$ C& C
' x; P8 D. M9 ^  M6 K
. _& u7 n' T2 z& S: }% `, J2 w) {

简单解释：
) q$ u, l3 ^" M构建好大顶堆或小顶堆结构，这样最上面的就是最大值或最小值，那么我们取出堆顶元素，然后重新构建结构，一直取，一直重新构建，那么最后达到排序的效果了。



# ]2 C2 W/ l' J! ]


完整代码：
0 P# {& O% _" g& G- u7 K( b5 s

package com.keafmd.Sequence;
. O, e0 S' O- E0 _& R( I0 I  J

. j/ S" I* A/ {- N% ~/**
8 s7 X& U  o) h4 Z6 z! e * Keafmd
9 h$ D" Q( }+ b7 q *
* @ClassName: HeapSort
* @Description: 堆排序
" Z, e( h/ V4 o * @author: 牛哄哄的柯南
3 Q& j# x$ @; X7 w, u6 y5 B * @date: 2021-06-24 10:34
*/
$ p. M! S& G. M( u9 \public class HeapSort {
  D9 Z& `3 Z& e& y
  d8 `: }1 c3 b( z4 Y
    //堆排序
0 Y' L4 {: J7 M" V# O3 `: B6 O    public static void heapSort(int[] arr) {
1 H) t# s" k/ i! k        //对传入的数组进行建立堆，这里默认建立大顶堆，进行升序排列
        heapSort(arr, true);
. h, g. i% `! ]' H3 B: y    }
; }4 H. h; k2 L. j, M9 l. M

    public static void heapSort(int[] arr, boolean maxheap) {
0 X4 ?8 N( _) i! F7 ~! L. u

" ?+ s: @& t$ d6 Q2 j  J# h% f        //1.构建大顶堆
        for (int i = arr.length / 2 - 1; i >= 0; i--) {
1 Z& {8 X( R$ M7 Q) W            //从第一个非叶子结点从下至上，从右至左调整结构
  |: f/ C3 j2 I; X, d            sift(arr, i, arr.length , maxheap);
        }

3 r+ T5 C' w3 h! M% j
        //2.调整堆结构+交换堆顶元素与末尾元素
        for (int j = arr.length - 1; j > 0; j--) {
# G, w* t& R0 g

            //现在的数组第一个就是根结点，最小值所在，进行交换，把它放到最右边
; {: [. Z' K1 s% B, V2 x: F4 C            int temp = arr[j];
            arr[j] = arr[0];
            arr[0] = temp;

2 g+ P9 Q" @$ C. J, P
            //重新建立堆
            sift(arr, 0, j , maxheap); //重新对堆进行调整
' p+ M0 x" w7 L0 `! t        }
    }

& \% A6 Z! r6 X  F  E! m
    //建立堆的方法
    /**
7 h% r+ W, y1 L% j     * 私有方法，只允许被堆排序调用
4 E# Z( V: s! b% R     *
     * @param arr     要排序数组
     * @param parent  当前的双亲节点
     * @param len     数组长度
     * @param maxheap 是否建立大顶堆
     */
    private static void sift(int[] arr, int parent, int len, boolean maxheap) {

' q2 D" `1 E/ [) d
        int value = arr[parent]; //先取出当前元素i
5 v3 g0 k5 o0 S! r/ D  Q, K3 b
. ?7 ]" J* B1 c, |$ F' Y2 |
        for (int child = 2 * parent + 1; child < len; child = child * 2 + 1) { //从parent结点的左子结点开始，也就是2*parent+1处开始
- {  y1 t5 Y+ c6 J
' Y+ p- @$ e8 b' @1 K1 S" L% B
            if (child+1 < len && (maxheap ? arr[child] < arr[child + 1] : arr[child] > arr[child + 1])) { //如果左子结点小于右子结点，child指向右子结点
                child++; //右孩子如果比左孩子大，我们就将现在的孩子换到右孩子
5 h  ?1 ]9 ~0 m5 @, t% M8 k            }

4 A& J& e. a1 O) M
8 l6 O6 T7 I+ C            //判断是否符合大顶堆的特性， 如果右孩子大于双亲，自然左孩子也大于双亲，符合
            //如果子节点大于父节点，将子节点值赋给父节点（不用进行交换)
& U+ h. Y2 n/ M! q            if (maxheap ? value < arr[child] : value > arr[child]) {
                arr[parent]=arr[child];
                parent = child;
$ Q5 |2 D1 r* ]% ~; l0 L            }
# A' d& \: e# u4 E            else {//如果不是，说明已经符合我们的要求了。
                break;
; w8 S0 r. Q) l! |" \* ]0 U            }
8 I* [' j5 G+ c( I2 Q7 J5 c& `3 {        }
        arr[parent] =value; //将value值放到最终的位置
; n# d# B2 v: z; r& e* |7 `, c



    }

4 S8 K; c7 M# h$ \5 z6 J" C# s
) g* @; m9 n: k. \* c. _; P, S3 ?}
! Y, b9 ^; Z* ]  ^+ }1
2
3
) @+ u  H0 d% K+ S4
5
: I2 j, U. I( j6 c% o  |6
* S* W; [& F0 l# ^9 f( S# l7
8
5 R& j6 }2 p% `5 A9
8 s' P( O/ s- d/ {, C* h10
; C! A* Q% \% Q" m! }11
12
6 {: i* c! M- R0 i6 p5 Y  W13
14
15
$ d8 [. M) [8 z  @! d& o/ z+ Y16
17
. p+ m$ ~6 E- O. G+ E) {4 L+ [/ `3 @% h18
19
20
21
& X' _3 l  L9 O, o* Q0 Y4 C22
23
) N8 ^1 Z  {3 x1 [# x1 c! a24
( H" c7 b/ r4 l6 S6 f25
26
27
8 f1 t8 v. c( d+ W( l28
7 \: ?$ y* Q0 q: I29
- v4 C# [: E0 o/ X# E30
31
32
- H& d( ~- C& {8 A4 V, L5 \33
34
+ y) {* F. @5 l. d35
9 |2 V0 R; c5 j, L2 ~1 U9 F36
37
38
39
0 q+ i& J; J/ E40
; r( [! r. i0 w+ l" p8 T2 X- D41
3 M& z5 j" f6 Y+ E9 B& q  c42
43
4 L, ^* R: T  C" }+ t! m1 a( r44
45
" u' l/ I8 r" Q. j; K$ o46
+ q* ?$ X6 B+ [8 p9 E8 T, P47
, J& A5 C8 A7 H0 I2 v$ u  V  ~( H5 y48
49
* I. \( N/ _& q. Z% k- t5 v50
51
" r0 j2 d/ t* g, I6 l2 P. A52
53
54
55
7 C/ X; I7 y# }56
57
58
59
, e5 U" K5 b# `/ n" W3 X  X# k60
& X% |3 Z# b2 v61
6 g& r+ O* H" [8 {. v2 S( I62
7 B2 t. `5 x! W( _' R4 P63
% T4 E1 `. V1 C" y' E64
65
. m" S6 y9 r7 N* h8 w: h66
67
68
69
, C+ Z& S0 v& A0 T70
71
1 i( w( A; T* w- g72
73
( W5 p2 ]  W7 h. P' M74
归并排序
) t* R0 g/ [  O. r1 G& _简单解释：
1 Y$ f+ T; ^3 x( b% R; f该算法是采用分治法，把数组不断分割，直至成为单个元素，然后比较再合并（合并的过程就是两部分分别从头开始比较，取出最小或最大元素的放到新的区域内，继续取两部分中最大或最小的元素，直到这两部分合并完，最后所有的都合并完，最后形成完整的有序序列）




" Y" z$ a' Q9 _6 U
6 F+ x, _$ {. {& }+ S+ O
完整代码：
& F7 K% B( W& f+ v3 ]0 k' b* [

package com.keafmd.Sequence;
7 g7 e4 o, ~4 E

. U6 }8 }% h. v+ r. w; o/**
* Keafmd
( ?# w3 i2 M2 g( B *
$ \3 `% S- i! Y( r" S7 S+ w  K4 B * @ClassName: MergeSort
* @Description: 归并排序
/ l4 f6 r2 k& N2 u& n * @author: 牛哄哄的柯南
* @date: 2021-06-24 10:35
6 v. {  @% _6 j& z9 ?% A */
public class MergeSort {


- H" E. ?2 u; B, h9 B+ f) \2 O    //归并排序
    public static void mergeSort(int []arr ,boolean ascending){
        int[] temp = new int[arr.length]; //在排序前，先建好一个长度等于原数组长度的临时数组，避免递归中频繁开辟空间
3 K1 F# h6 z( ]- q8 Y$ ~0 d        mergeSort(arr,0,arr.length-1,temp,ascending);
4 r0 P6 ~6 ^- q8 v4 \4 G* g( V- S    }
    public static void mergeSort(int []arr){
5 M. H. U+ n! L6 X5 L        mergeSort(arr,true);
    }
8 ~5 E6 u+ y2 t, \7 Y

    /**
6 e  L: R- r* ~4 ]# ]( g     *
     * @param arr 传入的数组
6 R- i; q9 }" j) _1 ^9 C5 r     * @param left 当前子数组的起始下标
     * @param right 当前子数组的结束下标
0 e* S; F2 c7 W6 `$ z, A+ d     * @param temp 拷贝暂存数组
+ \1 l! c1 |7 ?     */
4 a" C4 d; [- Z7 r* @4 i& e1 @/ N    public static void mergeSort(int []arr,int left,int right,int[] temp,boolean ascending){
1 _" K& ]+ ]7 G9 I  B1 \        if(left<right){ //这里是递归结束的条件，我们是对半分，那当left==right的时候肯定大家都是只有一个元素了。
+ |/ U5 S) f" q0 o1 x( \6 o, E
: F$ ?6 F! _" q( f& e0 |3 {% N* f
! n# R8 g' K# @            //对半分，比如总长度是10，left=0，right=9，mid=4确实是中间分了，0~4，5~9
/ m9 |, ^/ q2 _8 t- D6 }; y8 l            //当长度9，left=0，right=8，mid=4，0~4，5~8
            int mid = left + (right-left)/2; // 防止越界的写法
8 B- A) C! v9 ?$ G! l: {8 K            //int mid = (left+right)/2;


/ S4 P* N/ A& `$ _3 ^            mergeSort(arr,left,mid,temp,ascending); //左边归并排序，使得左子序列有序
/ u' b" o! G+ _$ T; O; U; L) j2 ~            mergeSort(arr,mid+1,right,temp,ascending); //右边归并排序，使得右子序列有序

$ U' T4 s* `) |; C  C$ q
- F. U" C' L0 u1 ^: S            merge(arr,left,mid,right,temp,ascending); //将两个有序子数组合并操作
        }
    }
  i) r# j+ {0 E  _2 A# L4 Z6 D% r
8 O# f' `1 L% c$ A* N
  c3 z2 o( v5 m    private static void merge(int[] arr,int left,int mid,int right,int[] temp,boolean ascending){
5 ]; i; y4 |- q        int i = left; //左序列起始下标
) q; M, ^- x3 z. Q* _  L% k        int j = mid+1; //右序列起始下标
        int t = 0; //临时数组指针
        while(i<=mid&&j<=right){
            if(ascending?arr<arr[j]:arr>arr[j]){ //比较两个序列第一个元素谁小，谁小先拷贝谁到temp，然后对应子序列下标加1
2 I' B& \: f! u* w! ~$ F                temp[t++] = arr[i++];
5 o7 @5 x: L4 {) s- @' d+ k. r$ L            }else {
                temp[t++] = arr[j++];
( L# a  W6 F% E: Z            }
        }
6 E& b1 x) q9 e; {0 ~
. {9 A. l! ~7 P9 m
        while(i<=mid){ //将左边剩余元素填充进temp中——左序列有一些数总是比右边的大的数
            temp[t++] = arr[i++];
, t) Z/ L, T7 ^: ?/ v* t$ ?8 Z        }

8 g2 V1 @+ [. d
! X7 e. y8 g& {& R) E) p! F        while(j<=right){ //将右序列剩余元素填充进temp中——右序列有一些数总是比左边的大的数
' @- B/ o2 V5 X7 B            temp[t++] = arr[j++];
# Q/ v  C' T& ]& n# g        }

9 ?- k3 ]4 _% h2 v' L' r. i
3 H( U8 d7 n3 B8 i/ W        t = 0;


/ p8 m; h  w2 \1 q  g( Z        //将temp中的元素全部拷贝到原数组中
# R1 S) h" p! D# r: ~* c" D) ?        while(left<=right){
            arr[left++] = temp[t++];
9 V. W8 B: h, t: L        }
% f* h* l5 o) p1 u) G
- N( \, ]5 m, J3 ?: E5 b. m
4 M9 O! C9 [# V- n5 d7 S$ n6 O" U    }
+ T: y# o& }; e  ^- N

2 |; n% M" A+ f: U  s}
1
4 G6 n% `) I4 s% d7 x/ n+ q3 w8 l2
3
* L* N+ ~' D, x6 f) f' n+ M# X$ g& X+ R2 ?4
5
6
% `5 b1 i; O7 N/ d- R/ b; p9 y7
8
9
10
11
3 K! J! w( u& o( U7 j& _& M12
13
7 q% l. B, `4 R9 k14
7 E6 l0 U: D- @. W. x7 y% L- x0 {5 W9 t15
16
' i$ D7 G) X4 a% e! E6 {17
18
19
* z! ^" j2 M4 Q, D1 v7 x9 g20
21
) q1 m* Y: g9 v/ L8 {- m" J22
23
24
* @. d" {0 b# i8 C; {; E25
+ a% f, s3 c+ E2 M+ x26
6 q7 P- F( V6 O. E9 k27
+ W% ~( {% a. B# C3 E) W5 A28
29
30
31
3 ^0 O) k+ z) h2 i: x32
33
0 ?! F: R$ z' `( Z, S34
35
5 K0 F8 R! C" J8 b2 ?! V36
37
38
39
% \5 p! C& E  J6 g40
$ r8 r* b6 ^$ T) K+ `* k41
42
* s' A8 h" S5 X4 e9 P43
44
7 j( ]  e( [& l2 q45
46
47
48
49
! q8 B" x( a5 j50
* v% L  ^) T1 ?8 C: K" B51
52
53
% Q( L$ L3 d. L& [/ M54
55
9 K8 L' S9 S  \- k2 ^# j56
4 U4 R/ y" Q2 |. ~  q57
2 G* g; u: z8 ~& @$ `58
59
! ^2 W5 r) f; X" V60
( h, F8 g' N( D) L61
; ^: b9 h/ }% Z7 q1 d62
63
' n6 }8 b: {$ D64
65
66
67
68
69
% n  T: j8 h% N9 j& C70
71
72
- Z  W/ Z5 _5 x* R73
插入排序
简单解释：
/ c( T& ~2 `) w% K1 g/ N, K最简单的理解就是打地主时我们拿到牌后的整理过程，从第二个牌（假设我们拿起来这个牌开始比较）开始，（说下升序）从后往前比较如果比前面的那个牌小，就把牌往后移动，直到找到一个合适的位置（这个位置的前面的那个牌不比这个要放下的牌大）就把这个牌放到这个位置，慢慢的前面的部分变得有序，直至全部有序即可。


& A* t4 d9 Y# b5 g/ ^* M
) v) j! W/ I6 J8 h, ~) w
! J7 Y5 m  c+ _1 y

, [7 i) [) f' d8 O. x% Z完整代码：
; z" R; d8 f7 n  y& a4 J4 u1 Z

package com.keafmd.Sequence;
6 u. w) I3 v: C9 z6 V3 ~
& n2 x. l, O3 k
/**
* Keafmd
*
* @ClassName: StraghtInsertSort
: ], {& K8 F( b! {% c3 p$ { * @Description: 插入排序
* @author: 牛哄哄的柯南
; p/ j( s$ s( [/ t9 u * @date: 2021-06-24 10:36
*/
' o0 Y: c4 l. D" E* f6 X7 |& Y$ z0 {public class StraghtInsertSort {
    //插入排序
    public static void straghtInsertSort(int[] arr) {
* Z8 \6 J0 ~& _& }( D6 q        straghtInsertSort(arr, true);//默认进行升序
    }
% P( P4 W+ Y$ }# A3 b. t. [

    public static void straghtInsertSort(int[] arr, boolean ascending) {
$ b) ~" R# N1 G* g

0 r1 i" A% w& J4 N9 Z; \8 r  s        for (int i = 1; i < arr.length; i++) {
) n4 n3 _/ A1 D5 g            int temp = arr;
) O# ~" B( d5 d1 R            int j=0; //这就是那个合适的位置
7 z. k6 L7 ]3 q4 A            for (j = i - 1; j >= 0 && (ascending ? temp < arr[j] : temp > arr[j]); j--) {
' ^! e3 x9 T% T- B5 y6 J                arr[j + 1] = arr[j];
9 d/ f( g# H+ o/ m+ M/ W9 ^            }
            //把牌放下，为啥是j+1，
            //是因为上面的循环遍历到不符合情况的时候 j是合适的位置的前面的那个数的位置
            //有点拗口，但是就是这个意思，看图方便理解下
% X+ h: D; O4 g' ]            arr[j + 1] = temp;

7 ]' L6 [9 q1 [+ n

8 U+ e# S& J, \+ F- E; S
2 T; T( A# R# P$ k% F+ d        }

- k0 Z- ]0 H8 R2 r7 d
" v) v6 j; h% I6 M: s5 a    }
}
1
0 t: R" \7 p& K. E2
3
. b8 H" A3 @; D4 n/ r$ Z9 D1 y4
5
& \( ?+ W9 d; t' I* A6
7
0 O0 q1 d$ d: d. f, v$ ]) E5 P) C8
% y0 x3 [* ~( y8 ]$ H- b1 [9
$ N  o+ r$ D7 U10
11
% E& q4 q! K1 V3 r, a* ^12
+ C2 k  G# f2 j& r! I13
14
15
2 }/ V- ~2 ^! q' N( @5 e. s16
7 U- u3 V0 h' h" R3 J" `0 v17
18
19
20
21
$ d6 J; V) g; k  a6 j& P22
9 L( h; T1 p/ I4 v: v, ~5 q23
% k. q+ J, P5 q7 @+ c" J24
) ^& w' s# H8 ]# w$ Z( c$ i( j9 m25
$ ?. O0 j- C8 c26
8 j+ o/ I( G6 `$ j. Q) e' R+ i27
28
+ X( ~2 N( i- [" `! r$ R29
30
* Z! H8 C/ Y+ B! }4 S/ o31
32
+ H  q$ d9 N9 U0 ?9 C* ~/ _33
. [7 A5 ?5 l# Q- V6 L8 a8 H34
希尔排序
  F7 N7 N* [+ G. P简单解释：
希尔排序是插入排序的改进版，我们理解一个叫做下标差的的东西，也就是下面那个图中的增量d，初始下标差为arr.length/2，然后继续/2，对在同一下标差（相当于把这几个数单独拿出来了）的若干个数进行插入排序即可。
! F- G4 q2 i% Z: C3 {0 K) n6 g

& Q% V2 t1 a7 {: ^( n

! X/ q7 C: q$ e4 P
6 _' [- y+ o2 [1 A! [
& S) ]& j7 G/ m/ _7 q+ z完整代码：


0 p( }9 I) v2 S+ Spackage com.keafmd.Sequence;
: |  ?1 I3 A( f- P3 ?

# f9 P6 k, x+ g6 e4 K2 N: }4 g/**
* Keafmd
*
* @ClassName: ShellSort
4 j8 i( v2 h& h* n7 D( U * @Description: 希尔排序
* @author: 牛哄哄的柯南
6 X9 m- L" x& O. B+ e: b. b; V) Z2 f * @date: 2021-06-24 10:39
& s0 k2 j$ s7 G( \7 F7 r9 i */
public class ShellSort {
' m& {; f0 N- t% F2 `5 s& o2 Z
. W* ^9 R* W' I! q5 v  |
    public static void shellSort(int[] arr) {
        shellSort(arr,true);
    }

  Q. P+ a8 z" f6 [1 V) [7 ^
1 e8 a/ u. L* s( F6 {6 `    public static void shellSort(int[] arr,boolean ascending) {


        for(int d = arr.length/2;d>0;d/=2){
' _! V' p* X5 J5 Y3 L  g. c

* d/ D" F7 Q$ h4 J" M0 m            for(int i=d;i< arr.length;i++){
                int temp = arr;
                int j=0;
: y1 Y! H4 G0 D3 e) x( ^0 [                for(j=i-d;j>=0&&(ascending?temp<arr[j]:temp>arr[j]);j-=d){
                    arr[j+d]=arr[j];
                }
: `+ m7 w4 }# j% X                arr[j+d] = temp;
/ Z* t, v$ H- m  }3 K* V            }
        }


    }
}
1
2
3
4
5
( e$ e% O/ I0 t2 z6
' |( ]3 O$ e7 N+ d; N% p7
8
9
6 p  y. V5 g$ k10
11
12
9 f) a+ J5 D  U13
6 f$ p3 J; c. H1 Q14
15
$ `' u& p) n( ?7 S& @+ ?$ C$ V16
; U0 q2 E1 |7 }) }% `4 x3 |9 \! z17
8 V" @$ X; {& d3 f6 c18
0 [9 w/ l2 \9 @. t' A19
20
21
22
+ H8 J5 Z6 M9 J' s0 [3 s23
4 K7 x' E& A6 Y4 n& A( _24
/ Z* Y! M( j" e, r) l25
" [3 J$ J3 ~& e26
27
' D  y* ~6 z: ]4 |8 D* J28
29
! z. V! ]$ H' [3 j, f30
31
2 m3 k0 h7 s) }5 l/ G3 R32
计数排序
简单解释：
, D& A' f8 I* J这个排序算法看名字也很好理解，就是就是额外找个数组来计数，然后在这个数组从小到大或从大到小把数取出来即可。


; X' C! F& W/ W9 e3 i4 I5 ~



完整代码：

: Y7 E3 h0 }# B: b8 w: ]8 F' B9 z
6 q2 v" @. v1 T- }9 W+ C2 D0 Qpackage com.keafmd.Sequence;
( v4 z: U; F0 ]0 k- L$ S4 D
# k/ H' g% v! |" g; d
+ m/ C- }, h% T/**
  `7 |/ J3 |( F* B% _ * Keafmd
*
& H; `9 L. y5 B8 C" Y9 D8 P  ], v * @ClassName: CountSort
( ~# \" D# S0 m8 [ * @Description: 计数排序
$ u8 {7 x. f; d * @author: 牛哄哄的柯南
* @date: 2021-06-24 11:31
*/
public class CountSort {
% a* q1 N; J0 b  E/ [; g
0 F5 C# k; N4 K0 a
1 a0 |6 H  [" p7 ]- @% Y, [    public static void countSort(int[]arr){
6 n6 p' Q9 x5 \% W        countSort(arr,true);
    }
/ h8 L/ s* n. I, p7 A, o
' Y2 P, h2 Q% m. h7 k  U3 X
    public static void countSort(int[]arr,boolean ascending){
        int d,min=arr[0],max=arr[0];


0 d" g/ `# C$ B$ I4 Y0 f& [        //找出最大、最小值
% x7 F3 w/ L  [$ Y. e' z  @3 ]2 L* k        for(int i=0;i< arr.length;i++){
            if(arr<min){
- }9 F, R; w/ j                min =arr;
: I3 D- Z' h# t* j$ H            }
            if(arr>max){
                max = arr;
" _5 g& Q% B& T: a            }
- ]6 e8 r. d8 t6 ]! r6 y3 O( Z        }


        //建立一个用于计数的数组
        d = min;
        int[] count_map = new int[max-min+1];
! D& Z: b$ _4 J; I        for(int i=0;i< arr.length;i++){
2 z! v9 b" U. v4 p            count_map[arr-d]++;
        }
3 ~, b9 g9 ^6 |  w
5 q) M8 b* F$ q8 q" k$ k
        int k =0;
        if(ascending){
# x$ j7 Y5 h2 @0 ]' C) v            for(int i=0;i< arr.length;){
, O" I: p7 S  L7 Y( j; y. y                if(count_map[k]>0){
' I( V0 G4 ~( [2 P1 E# s! C/ _                    arr = k+d;
                    i++;
! `9 B- T) i- B- A                    count_map[k]--;
                }else
6 L/ M6 K2 @: `2 q; l6 }                    k++;
            }
' R. l# q0 w1 j2 r2 R        }else {
2 w0 k7 c- \- Q0 x+ L/ q+ H; J+ K            for(int i=arr.length-1;i>=0;){
                if(count_map[k]>0){
                    arr = k+d;
                    i--;
7 n- ?+ ^& ]# h1 `; B                    count_map[k]--;
3 p( q, |/ M, q1 J8 Z% L- [3 n                }else
/ N% v( q- ^* K) g; ?                    k++;
            }
        }
$ `1 b7 j; N/ I2 V

! o9 |; {5 T" F    }
}
8 l; x! W( `- d' X8 }0 k/ D3 E2 ^4 l1
2
3
4
5
  {' t! `* h- b  H, R$ G; m. |9 T6
7
8
9
10
11
1 k( S* |/ N, w7 Z- m2 |: f12
) h* T  R  U2 s" _9 L0 p/ u- i! J13
0 e! g# ~2 R2 U; |* }2 |14
15
16
17
$ w0 F1 B' E+ A  B18
( Y0 _+ O- ~' G& }19
20
21
7 i5 U' C0 ^  |8 ?) J9 z8 Q+ `4 P22
23
- B' w+ L' G' M$ v24
+ X% r% S$ v0 X25
26
' @/ E" B- R9 i- ]' J; k. ?27
28
: _" Y& N' F( r; w) y& V. M29
30
* y$ @( o# Q1 S/ t31
32
5 v# q" Y6 D& C* D; m33
34
: L* b2 |. j, ^& H& {- A35
36
$ w9 R' L/ n, I) L' k6 c" r$ B6 @37
. B: O/ w2 f# A* U, R- g$ W38
" s8 N. L' `9 ]& R2 V& O39
40
9 V: d' u1 J# [3 o; |8 ~9 s41
42
43
4 W' O; E- S+ n& ?* j$ E44
45
46
47
48
# Z2 G: e* z8 l- A( N49
/ w. Y. G. x( o8 V( z. r. ^50
$ {* T: ]# }2 s0 T( V8 L51
+ ^0 J0 Z1 W  R; \7 u# z* C5 e52
53
: s5 l+ R2 S) V9 F54
55
56
57
' e. ?+ p- s4 U9 @) q. V2 f58
59
桶排序
: r) f+ [$ h& _3 L. o' @7 M+ @, @5 D简单解释：
- M  }* V2 N3 {& D% V" @就是把一个数组分成几个桶（其实是几个区间，从小到大或从大到小的几个区间）装，然后让每个桶（区间）有序，然后取出来放一起就可以了，相当于把几个有序的段拿出来放一起，自然还是有序的，当然需要是按照区间的顺序拿了。


  X& @6 m' j/ [6 S6 Z

6 L# J$ {. b& V  b" I6 `4 K& t

& r4 C' P1 U* m. O" _# ]完整代码：


4 C  w1 X1 Y3 Kpackage com.keafmd.Sequence;
8 k. H& V* a: k$ |# [! r0 j5 X3 ?! A1 J
& J7 _1 _0 u3 I/ y& B
! {% J0 i; E: r9 Y  zimport java.util.ArrayList;
import java.util.Collections;


/**
* Keafmd
  @' z# C% y& l *
2 j7 f& v3 B, s* ?4 c0 |. D4 |2 X * @ClassName: BucketSort
* @Description: 桶排序
* @author: 牛哄哄的柯南
* @date: 2021-06-24 13:32
*/
public class BucketSort {

) U2 t$ l4 h. d2 ^- A
/ L+ Q4 C, \0 A+ e5 J    public static void bucketSort(int[] arr){
        bucketSort(arr,true);
    }


" }! E' `$ N, @- H    public static void bucketSort(int[] arr,boolean ascending){
. w2 y) j  P4 j( u& p, }0 A' ]) b  A        if(arr==null||arr.length==0){
            return;
        }
        //计算最大值与最小值
        int max = Integer.MIN_VALUE;
        int min = Integer.MAX_VALUE;
        for(int i=0;i<arr.length;i++){
            max = Math.max(arr,max);
! s! A0 I' m' T* @7 V            min = Math.min(arr,min);
        }
9 V) @7 D4 q" e/ S; k
2 V( u" o9 w8 n( k
, U9 Y6 K3 }* C        //计算桶的数量
3 i) `3 u: Y$ W, e, q; [6 n5 _; r  s' G        int bucketNUm = (max-min)/ arr.length+1;
5 H, L" ~6 ^2 ~6 F& Z( T        ArrayList<ArrayList<Integer>> bucketArr = new ArrayList<>(bucketNUm);
0 p/ A3 ^8 n* g8 K) g0 W7 ?2 L* r        for(int i=0;i<bucketNUm;i++){
            bucketArr.add(new ArrayList<>());
        }

/ C* m0 k% i- E( d) j
. Y7 }) ~: O- W9 C% g4 `1 f; p        //将每个元素放入桶中
        for(int i=0;i<arr.length;i++){
            int num = (arr-min)/ (arr.length);
; W7 C. h& h7 v& [" y- y2 |            bucketArr.get(num).add(arr);
& z& g/ b" k: r' W        }


        //对每个桶进行排序
        for (int i = 0; i < bucketArr.size(); i++) {
            //用系统的排序，速度肯定没话说
            Collections.sort(bucketArr.get(i));
0 x: ~! V( _' W1 _! @, f! z        }


  I- P" Y. C9 o" s$ w/ C; W& X        //将桶中元素赋值到原序列
        int index;
! i9 `: O, F6 H- ]        if(ascending){
3 z4 }; I% b8 z            index=0;
" Z  x" m* W. f% t        }else{
            index=arr.length-1;
& |( T4 a2 Y  i# X( [        }
8 x/ l' l5 l* \, c+ f

6 j' L3 u% f( p4 I* Q        for(int i=0;i<bucketArr.size();i++){
            for(int j= 0;j<bucketArr.get(i).size();j++){
                arr[index] = bucketArr.get(i).get(j);
                if(ascending){
7 Q% g; Q) r6 w' w6 j                    index++;
+ p. z5 P. [9 [: x3 ^+ h* ~, h                }else{
                    index--;
3 d( b) y, x; }5 [4 |                }
            }

5 w, t7 j3 b3 z2 |5 @' i$ {
7 y9 L( ~. E2 X  M- k% h; V0 x+ Q        }
7 Z. Z1 l+ b$ [4 Q1 D) I
" R6 A, v9 U7 T
7 B2 P: R0 @* G2 C  o9 }    }
" @. i0 z+ ^  u1 T6 y" [2 ?}
+ s, d/ m# l- j: t+ J' L1
2
3
* M3 ^! J% {" e5 F/ B6 a4
) F9 \; Y9 g* J1 D' D& Y6 U5
6
8 b9 _/ L7 E1 C# l3 P9 Z7
. I2 q: o3 [( N9 J8
9
" G) c, p# I( W: W5 k9 D10
& m: @$ W; g7 {$ D11
12
' u# F& @) X  l* O- n* E7 @13
# I1 V, [4 E( ^, N' I14
15
1 w& c7 x: x; A. Q9 B16
, B. d( [0 W9 W' P/ _17
# V: O4 b; C- p# v18
19
20
21
* a$ q5 M3 |+ S) g6 ~22
0 I2 }& H: K- f- ]. B23
24
- _& N3 k! m, J9 R8 q+ X25
26
27
28
. J4 ?, @$ N; e8 ~* ]0 n' s29
30
" a+ B9 G& K7 N! s31
32
33
5 M, U2 @4 \: t34
; p& ]% s# ^1 J4 b: X) V35
36
37
; h& S. a) G; y$ o0 u9 p6 m( d7 H38
* x- i0 T& F! v$ M* _39
40
41
42
43
1 x, I5 D# F. W7 z$ N6 k44
45
3 F' h( m/ U- Q$ m46
47
48
  ^4 D! l! v, `49
50
51
52
53
% q3 b3 ?$ L% |* ~$ M9 c54
$ ?$ f0 [7 s' O55
56
57
58
$ G6 |7 K/ t( f) Z$ y4 L/ E1 c. t59
60
61
- ~1 \7 t4 H6 B: ]62
63
64
65
66
9 {  r0 ~0 l0 K( C! V* B67
0 v& V9 v3 p, v5 e) E) |68
69
$ |3 B% E; p* h( r- Y8 T70
  N/ H3 J- H3 c  e  c71
72
基数排序
简单解释：
- k1 S1 W4 U7 H* Y首先说一下，我发现好多人写的基数排序只能排序正整数，其实只要处理下就可以排序含有负数的了，就是我们排序前先把所有的数整体变大（就是减上最小的负数，也就是加了），都变成正数，然后排序好之后，在减下来（加上最小的负数，也就减了）就好了。
5 ~: e" k( }" M7 F基数排序就是按数位排序可分为LSD（从最低位[也就是个位]开始排序）和MSD（从最高位开始排序），下面写的事LSD基数排序。
+ L( \, m$ n! K基数排序就是把数按位考虑，让后我们一位数只能是[0，9]，就是我们在考虑某位（个位、百位· · ·）的时候就只看这个位的数，放到在[0，9]相应的位置，然后顺序取出，最后再按其它位这样操作（上面说了要不从低位开始到高位，要不就是从高位到低位）
) W* q" q5 m# Z- _. |7 _- Q6 [% W
" Y" E! ~8 o+ X
2 D2 Z' w$ j& v" q" D# v7 a

2 [% ]0 ?: ?: r) |
4 N  f6 G  g0 Z- N( Y5 j% ~- D
完整代码：


7 g5 I+ }& C; w3 |% X2 vpackage com.keafmd.Sequence;
2 v" @+ a2 x1 A; i1 l% J" r1 y
2 e- h' G, e+ V5 l: g( e" i' D' r
1 N9 _4 S5 G0 ^, h3 n/**
# |2 G- [3 T& m# [) ]$ ]" X8 q+ I * Keafmd
  @7 D6 N& ?- q9 F. `: d7 r+ } *
* @ClassName: RadixSort
* @Description: 基数排序
$ p" N; E# N. l0 {3 q$ v3 x * @author: 牛哄哄的柯南
! C# m9 D7 \! K" |0 G * @date: 2021-06-24 14:32
*/
; h- ^! {% k! k& D( ~) s2 ]public class RadixSort {
6 h6 g8 h+ o+ D* E. ]    public static void radixSort(int[] arr){
        radixSort(arr,true);
: H) \  F7 r/ i    }
$ m  R7 t8 d% z5 D* g    public static void radixSort(int[]arr,boolean ascending){
: w5 [3 s) v# Q+ p9 t8 m        int max = Integer.MIN_VALUE;
4 o3 L/ l* v0 w        int min = Integer.MAX_VALUE;
        //求出最大值、最小值
. b- h3 H; x- _! `  O% n        for (int i = 0; i < arr.length; i++) {
6 t4 N3 O' u! A' F' E. ~4 M! z            max = Math.max(max, arr);
$ M9 {, g$ @. e& ^' W            min = Math.min(min, arr);
& v3 h, ?$ l$ e        }
        if (min<0) {        //如果最小值小于0，那么把每个数都减去最小值，这样可以保证最小的数是0
            for (int i = 0; i < arr.length; i++) {
                arr -= min;
1 @# d6 J" V5 M" g            }
; E7 P8 R; @% \; R% G6 M            max -= min; //max也要处理！
        }
        //很巧妙求出最大的数有多少位
        int maxLength = (max+"").length();
        int[][] bucket = new int[10][arr.length]; //一个二维数组，一维代表0到9，二维存放符合数
        int[] bucketElementCount = new int[10]; // 用于记录0到9某位存在数字的个数
: V* Q3 Z/ T0 V( p: D9 L# n        for (int i = 0 ,n = 1 ; i < maxLength ; i++,n*=10) { //个位 十位 百位 这样遍历
            for (int j = 0; j < arr.length ; j++) {
                int value = arr[j]/n % 10;
                bucket[value][bucketElementCount[value]] = arr[j];
, A1 n( `* k  X' b' u/ j                bucketElementCount[value]++;
            }
, ^' Q; ]- F! n$ }2 o, ~3 m

            //升序
            if(ascending) {
                int index = 0;
                //从左到右，从下到上取出每个数
: ^9 |$ u8 Q2 A; U, C" u& A                for (int j = 0; j < bucketElementCount.length; j++) {
0 z: Y8 i/ x0 v+ Y                    if (bucketElementCount[j] != 0) {
                        for (int k = 0; k < bucketElementCount[j]; k++) {
                            arr[index] = bucket[j][k];
                            index++;
                        }
5 `- i2 E& p# N/ |# f( i" }/ m                    }
                    bucketElementCount[j] = 0;
                }
            }else { // 降序
                int index=0;
5 D' d! w% l4 U% w( w                //从右到左，从下到上取出每个数
* g- p# y) t& l1 m                for (int j = bucketElementCount.length-1; j >=0; j--) {
, h; R' ?& a6 p' J                    if (bucketElementCount[j] != 0) {
# x& J4 R* v# E- C, L                        for (int k = 0; k <bucketElementCount[j]; k++) {
0 y: C  r  G5 T5 Z                            arr[index] = bucket[j][k];
. g4 F/ i; X& R  T2 d4 Y                            index++;
                        }
2 H+ Y% `! O  i3 R1 d                    }
! \' Q- i& h7 l, u                    bucketElementCount[j] = 0;
                }
            }



; \. W( S. E/ q1 k9 w( c. |
            /*for (int i1 = 0; i1 < arr.length; i1++) {
                System.out.print(arr[i1]+" ");
            }
1 ?+ o( e. a( X            System.out.println();*/


" ~: o! S8 U( w0 i2 f
8 Q% d  L5 H$ m1 ?5 }% i, m9 n


+ j  ~) F% ]1 i2 v3 R        }
& t) }  b, k, `$ ?7 j        if (min<0){
            for (int i = 0; i < arr.length ; i++) {
- [" m; l# I( u: Z                arr += min;
            }
        }
+ S3 u8 E6 Q% I' V1 u+ ]
8 i  D: i! }. L" n0 y: Q% {' N
    }
}
: O+ T( b% Y6 Q5 ^1
, t" b& B" I, V, h2
  w& X7 G8 W/ G6 L2 ~& P3
4
& h) E8 }- g, K) Z( @# c5
  R. p( _0 a9 L9 u7 q6
7
4 A- |& m) \; J8
8 @5 P. }8 w: D4 h9
10
/ C: R, k  ?# [9 E9 L11
12
13
' Q: v! X, I8 M* C& K/ h14
4 A# l7 }; a4 i15
& B* Z* f) K6 w+ e0 h( I/ P3 J16
" C# d1 O  s; e: n. Y17
: [3 l' l; t0 _5 B- s0 c" ?18
2 x! A5 C& ]2 E+ W19
6 O5 L( O/ q6 O9 k2 S0 C. O, n( v20
21
. |8 w2 o5 K, J) E, u7 C22
23
24
) H4 o( w, e8 i8 Y/ E( i25
0 D6 G0 F3 N( j8 z8 z26
27
$ O; d- F6 T$ D28
29
30
7 l; `' \* U; |! n% L7 S( H31
32
+ g6 N0 E5 F6 E: s3 ]1 c- j! ^33
34
/ g7 A; J1 p( z* m; z. Q/ @0 v35
0 r5 \8 U( n0 l3 `/ Y" l  C$ B36
1 w3 u$ h6 i4 A) q37
38
39
# M2 n+ {8 }! u& s% w6 v" a: \40
# T$ @. c- z/ Z) R7 Q& u) i41
$ r2 {/ M, O" }% _+ e6 S! y42
( d! ?/ m; C8 N7 I3 x43
. l8 |, @1 r# G44
45
46
47
48
49
* p- t* [% L+ E- M( |$ u3 @50
; i% a5 }% k7 S7 X) o& @) y51
52
53
54
2 }4 t! H5 m( d55
56
57
# M% z; g  j8 \; ]2 R, W) V58
: v7 a& P& ~( {59
9 ~8 v! e$ h$ h" B/ `60
+ f: M4 m4 |5 t61
/ O. ?9 [( L* c- w! J" `7 K62
3 b) r7 u; K  e2 ?! V63
- x( E' F+ @3 v+ q" |64
65
, \+ I4 w: S' h66
67
, ?" G, H3 [2 Y9 Z0 n" g) E68
5 y. p: |, H1 s. t7 E# w+ f+ [69
70
* e7 c+ u$ I5 p6 S) ^* d71
) I5 E7 h1 f3 n6 e4 \72
73
* [8 c, f6 |, T( q74
: A* u2 I$ B! v& p: h75
76
% N1 D# v# U+ C3 P4 a77
78
79
0 Y9 ^9 V) O5 i" ~6 d' L0 G80
81
82
* |0 w1 W* t" T83
/ ?; T- }4 S$ o+ k1 d完整测试类
# v: ^( D" s2 e# O9 k9 X! apackage com.keafmd.Sequence;
. O6 _1 d5 v5 k5 a" X
3 ]7 q1 K# ?" T  l! {6 }- Y1 k0 y7 r
import java.util.*;
. {3 M3 `& I& Pimport java.util.stream.IntStream;
# w- F5 ^& Z- q2 D) \import java.util.stream.Stream;
" L4 c) N& G; [0 Z( k' l
+ `, Y4 _) F0 f' g  u
' r0 i) @0 X9 n/**
* Keafmd
6 j) r$ o9 M5 K9 y' A+ f+ o( R *
2 b+ U# Y# p# ]/ F& H2 I$ D. O* J. \ * @ClassName: Sort
* @Description: 十大排序算法测试类
" V) G7 x  K; a6 w$ k: O8 k * @author: 牛哄哄的柯南
* @date: 2021-06-16 21:27
*/
) f3 b- k7 x5 l' h" m% E' ypublic class Sort {

8 Q: T+ B1 C) R  F4 w2 @( M
3 |5 e# u/ z' n! ?; r
) A9 t1 e: f1 L) \) V# G4 r7 e# j
+ ]2 X/ K# ?" ]    public static void main(String[] args) {
- G* J  {7 J" q. K) }
/ I. P2 O; B' _/ {: k7 r1 \
# W) v0 l8 t: O' S3 j( j8 G        int[] nums = {12, 4, 25, 47, 58, 34, 25, 9, 99, 26, 1, -13, 162, 10093, -66, -1};
5 J7 j6 {8 R) u* f* a8 N& o//        int[] nums = {12, 43,56,42,26,11};
5 J, }+ \3 g, F        int[] temparr;
4 d1 N* j# U9 `

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

+ y3 ]2 x, B% N. c' @5 H% l0 u5 p$ g
        //将int数组转换为Integer数组
& o: x% A/ M7 u' V, F        //1、先将int数组转换为数值流
; L6 `6 J( h$ S6 N1 o7 w        temparr = nums.clone();
        IntStream stream = Arrays.stream(temparr);
/ D! D) v  V- O; \/ s3 A3 _! S        //2、流中的元素全部装箱，转换为流 ---->int转为Integer
( r5 i9 x& A$ ]8 V% E        Stream<Integer> integerStream = stream.boxed();
        //3、将流转换为数组
7 z0 V$ z/ O9 n4 ~* K# F        Integer[] integers = integerStream.toArray(Integer[]::new);
* n5 N& @* }* L9 r8 f  a0 A, c& A        //把数组转为List
1 E: K% T7 L, D2 f7 ^        List<Integer> tempList = new ArrayList<>(Arrays.asList(integers));
        //使用Collections.sort()排序
& o  N: b5 ~$ J        System.out.println("使用系统的Collections.sort()的对比:");
' {& E1 v* P* ~. ^
& c: g. B# e2 B4 X, g7 `; f: I
        //Collections.sort
( j4 o: K4 W6 Q7 _* w2 c! f* |        Collections.sort(tempList, new Comparator<Integer>() {
7 R1 e8 |7 F% X9 x" i            @Override
            public int compare(Integer o1, Integer o2) {
                return o1-o2;
( T" t; e6 o  W, J: j' y& `4 G                //return o2-o1;
            }
        });
4 _: F) y% [4 I  R

- R& G  R4 |- S' U6 S* _8 S        //tempList.sort 也可以排序
7 P0 F! b' p6 X" @2 P1 M% Q       /* tempList.sort(new Comparator<Integer>() {
5 J  d8 _8 C' o0 s5 _            @Override
            public int compare(Integer o1, Integer o2) {
                //return o1-o2;
                return o2-o1;
/ p; v5 K9 R  F# ^4 b            }
        });*/
9 q/ G& g9 d% n5 E. X) o# n6 b
# R$ g0 n0 g2 O: H
" z. U, v9 T! z8 ]: J  s0 u        //遍历输出结果
9 n* R5 x/ K# [( w        for (Integer integer : tempList) {
            System.out.print(integer+" ");
        }

8 V7 O4 m3 a6 d" o8 @
        System.out.println();

- G/ I6 n& u, R9 ?2 ]7 Z
        //测试冒泡排序
8 j3 K( K4 O. T" H0 p9 x        System.out.println("测试冒泡排序:");
) p; w$ d8 g$ K6 Z' Z1 N# x        temparr = nums.clone();

- D3 Z2 S1 {: J
        BubbleSort.bubbleSort(temparr);

' ~  f: v: Z! F. y7 W. y5 y) o+ T
        //降序
        //BubbleSort.bubbleSort(temparr,false);

! v, {/ a" G0 x3 Y8 O, i) a, f5 r
        for (int i = 0; i < temparr.length; i++) {
            System.out.print(temparr + " ");
        }
( t, j: z& N& q        System.out.println();

- M* v' S7 h" y2 K8 w
        //测试快速排序
% D3 r6 d. E$ y# ^) h. H8 g        System.out.println("测试快速排序:");
        temparr = nums.clone();
% w0 L. }4 B! F( \: j* v$ T% |        QuickSort.quickSort(temparr);
        //QuickSort.quickSort(temparr,false);
        for (int i = 0; i < temparr.length; i++) {
            System.out.print(temparr + " ");
- G3 v+ W! D- l; {        }
0 o4 B6 i- y  ^4 ^4 L8 M9 B, n        System.out.println();
9 i& r8 M4 g2 a9 u( D

        //测试直接选择排序
        System.out.println("测试直接选择排序:");
        temparr = nums.clone();
        SelectSort.selectSort(temparr);
8 n+ M  L; Q, P# y* _8 r  o        //SelectSort.selectSort(temparr,false);
        for (int i = 0; i < temparr.length; i++) {
5 ~! O/ `* Q6 B- g            System.out.print(temparr + " ");
' H2 C" k8 ~0 f3 ]6 M        }
- _4 g2 S* p; i8 J4 t' P8 s        System.out.println();
% n! o6 X# D- g6 `& ?2 z
' C# z/ ^3 l1 [) m
        //测试堆排序
        System.out.println("测试堆排序:");
) B6 Q) U+ u" g9 ?* y$ t+ }        temparr = nums.clone();
        HeapSort.heapSort(temparr);
        //HeapSort.heapSort(temparr,false);
  t3 {( p5 U  v  [8 x: u        for (int i = 0; i < temparr.length; i++) {
            System.out.print(temparr + " ");
" P2 T' x) }/ e& p7 ?6 f5 U6 C- k        }
        System.out.println();


        //测试归并排序
        System.out.println("测试归并排序:");
        temparr = nums.clone();
( l$ ?+ G% v9 m  j- }# \" j        MergeSort.mergeSort(temparr);
  h. S5 x! O, m+ Q; C        //MergeSort.mergeSort(temparr,false);
        for (int i = 0; i < temparr.length; i++) {
6 I9 C/ t: w% d4 k            System.out.print(temparr + " ");
        }
        System.out.println();
* A* F6 ~7 \/ @+ W

+ `0 A6 n6 }8 l( b        //测试插入排序
7 Z3 H& j( K% \# ?3 i        System.out.println("测试插入排序:");
        temparr = nums.clone();
        StraghtInsertSort.straghtInsertSort(temparr);
  Z3 ^: ]1 ^" H- C8 q" Q        //StraghtInsertSort.straghtInsertSort(temparr,false);
        for (int i = 0; i < temparr.length; i++) {
            System.out.print(temparr + " ");
' h" Q9 {( |9 g. O; |! q1 M        }
        System.out.println();

9 `' {2 j3 k) q% u$ n# H& M

  v5 S7 K: b" z7 K- z# G% q" @
% P2 \$ b* n/ e        //测试希尔排序
, L$ F# e/ z* V/ s        System.out.println("测试希尔排序:");
        temparr = nums.clone();
* S" g; o) a0 x; m( A2 ?& l6 s; J        ShellSort.shellSort(temparr);
$ @. W5 T/ e, Y$ X  J0 }        //ShellSort.shellSort(temparr,false);
9 i$ c5 b8 H. _* P" F/ b4 Z7 E        for (int i = 0; i < temparr.length; i++) {
9 N( P3 c  O# q5 D' X            System.out.print(temparr + " ");
        }
) |& N. t4 w$ z        System.out.println();
3 }' C; S  |* z
( _' h/ V/ \) E) {' g" s$ k. ?4 Q
* i8 P( ]8 }% w; Q5 ^; z2 h
6 H; k2 r# w8 S+ Y4 {
0 E7 `4 @! X, V8 m& O        //测试计数排序
        System.out.println("测试计数排序:");
3 u" L' u, E0 m# O7 B. ]5 `        temparr = nums.clone();
) i+ |. u+ T8 C        CountSort.countSort(temparr);
        //CountSort.countSort(temparr,false);
        for (int i = 0; i < temparr.length; i++) {
2 q: V$ S$ b7 f: c5 x+ O            System.out.print(temparr + " ");
        }
! C( F, R) ]* Z) n        System.out.println();


9 N* [# Y! H. {7 }2 G

        //测试桶排序
, f. ~% T5 ]! D0 ~2 a  Z- [        System.out.println("测试桶排序:");
! x/ D) q; a$ Z0 a        temparr = nums.clone();
6 X' C- i' f. A+ r# ?8 l        BucketSort.bucketSort(temparr);
- T* F7 w( l' b, `% H        //BucketSort.bucketSort(temparr,false);
- o% i. f/ N8 |, F. o        for (int i = 0; i < temparr.length; i++) {
0 S# L3 Y% T+ {6 w! p8 s            System.out.print(temparr + " ");
        }
        System.out.println();

( L5 P1 s4 P. M- n: }2 X! t
        //测试基数排序
; P3 |( j7 K; l6 V* i. B        System.out.println("测试基数排序:");
        temparr = nums.clone();
        RadixSort.radixSort(temparr);
1 t8 A# p, `; L, _  H        //RadixSort.radixSort(temparr,false);
6 F5 r- s6 V% T, y7 h) X        for (int i = 0; i < temparr.length; i++) {
, R4 i( o! D% l1 ?" V7 F            System.out.print(temparr + " ");
$ O& D5 F3 k% Y        }
        System.out.println();

, [! m$ e5 o( y6 t0 [* S% x, R
    }
3 X* T' p: m( Q; s2 X
( [  q- g, w# L1 j2 \! z" c
}
0 \4 }  N8 [! A; w* J1 g' H9 I1
) ~" m# Z  b& ]- ~/ z, C2
8 q( p, M* x+ |4 d6 t0 Y3
* K4 ^9 u4 c% j4 a2 T# W& u4
5
6
7
8
9
10
9 Q( z7 q# d' V' F) y3 {11
9 j: C! m8 F8 W( ]12
13
& X" u4 i  m% g' a7 R' v+ ]14
15
  f$ A6 O: j1 ^7 J. p16
4 ?) v9 ~9 J5 V17
- Y7 J) y0 E1 D: }9 |) T) I: Z18
! h2 Z3 [, K8 ~1 ]  ~, d2 j19
; G) N5 l. C% M( a0 O, \20
21
& c/ C. s" i- S% h+ ?) W6 S* R! I22
23
24
25
8 Y' g2 k4 K4 T/ Y% c26
27
28
29
( j- \3 f; S5 W5 x) T30
31
4 m9 J+ [$ s0 z# j$ i0 N32
$ |6 o+ O" `& Q" n& B( {/ h' ~33
34
; w( _6 j- @5 p1 U35
36
37
8 _) \1 X! Z- d9 E2 C38
39
; T7 N% [" D! T$ k% p40
41
42
& l; u/ H1 t! n  T0 G: X43
* ^' x( ^" d8 M' G! O2 O! @# }44
4 ^. z/ V/ A& R2 b5 D3 s45
! I3 x. O2 m* g4 i' [( H) d46
47
5 h( c8 e0 F  D; @) K( v9 g48
( W6 I+ [; R( ]" k8 S, S; R49
50
4 Q. V  ^. G7 a1 u! z  S51
& z5 O0 d: ~! c# M. C! v52
* b  p( B7 y" G1 }" Q9 S3 _53
  q7 m7 l& ~1 u3 w9 G54
  ]. k% F$ e+ X55
3 N& D! c- S0 i  y56
' }4 u, {! S$ C5 F" C$ j, D57
3 d3 @: g1 X9 F0 F& }8 Y6 [58
! N& l% F, {& ?) N# b1 `59
60
61
62
/ V/ d0 j) p/ d  Y( j" B& s63
64
% e% e7 |8 e6 c4 n- ]( E3 q! T65
& S, N% _+ c# e; f66
% c; m; E! @, _) e9 [1 q67
: ]7 d/ ]3 e4 b* _$ ~0 |68
69
70
7 R4 j! e2 L9 T! N. y1 u& R71
5 S0 P* r% c$ h8 u7 Z. o72
73
) V/ _( ~5 f8 [, f: P+ e4 c74
/ v1 {8 u# M; P5 u4 X4 @) {75
76
77
78
9 S* G% M5 y; t1 s2 Q- ^79
; R; o7 X2 O1 T  M8 u1 ?80
81
# G" [  `( B; W/ t) I" r82
83
  W6 Z# i1 W+ u$ ]9 C6 Y: L' b84
85
86
% S1 w9 q: K: g87
88
3 B: W( W5 c9 A/ h- q5 w* A/ B& T89
90
. b9 f9 m1 G3 X/ S91
92
3 M7 h5 }$ N/ @" _93
94
95
1 L$ z9 h2 O! w& ^/ k& I/ e6 n96
& N+ s* }9 v8 w0 H0 I, I2 J+ Q97
98
5 z$ O, D* q+ g6 D99
100
; z4 q+ U/ s. O; d) P  P101
102
" @" E) _. V8 d% J' V& z103
104
! y9 @7 W# z' V' `105
" `; Q. {4 s1 L( a5 h  g7 M) u106
- y" }( T% m4 B0 d7 m107
108
109
110
( x( [  O/ K  f111
- o- I& X3 `3 M) s5 ?112
4 b  J; O* o/ s) ?3 v. n6 N113
114
115
1 v  s* c7 X6 E! H% B5 W2 u116
# g8 B! ]0 u/ T9 _117
6 o  Y3 V2 i! P4 M& `3 u118
119
120
5 r7 Q& ?6 N3 U9 u9 a' C8 h121
& P, [/ A; F$ G8 E+ H! |; \, v122
123
% L4 j/ l6 s+ ~6 x124
125
1 ]# O; X3 T; k. L( N! S126
! v7 b) f2 `8 @127
128
129
* j$ d& P0 P) J+ ]( ~! r130
) M7 t: ]1 V& R. G* Z. I: w' J5 [131
132
: x9 C  ~  G3 V/ a4 H- Y& u133
1 [0 _8 C) p% c' b: a4 c134
135
6 _3 i% a9 |& M  [) d$ g2 G136
137
" ]( d" D' J# u( c" N( G138
139
140
- v+ [, Q0 g4 F! f141
142
4 o; |  o3 W) L3 ?# H9 ^: i143
3 c3 a8 ?7 {0 m$ w" w  j144
. ?8 m* E8 {6 w8 z. y145
: b/ Y* ]- c" j# r146
" a6 J0 u, p% G147
148
- e) z. ]0 F2 b. {: P$ A: ~149
150
' U  v3 U/ B9 d2 G; s3 i" r8 R151
: t# a8 d$ Z# @; K152
' K& g6 W' J: i153
$ G1 [$ [5 I) v# R1 |* \154
& v6 |3 S% i* L, @/ ~155
$ a+ o/ u) I( N0 R$ E! s/ Y0 X156
5 U; Z/ N$ I! z1 o- e1 d, X% D157
% A* x8 p$ S4 u4 I/ G158
; |) ~1 c. u/ m5 _/ B) x8 Z5 n159
# A/ V( r7 w! |% G2 K: [( B160
9 t$ J0 ~, N2 }7 t( y161
5 u! V8 `9 F, _3 r' M162
163
6 I+ J  w" f8 n$ {$ e4 D4 l, h164
165
# D$ f6 e0 ?/ c3 V* w8 i166
, m* M9 ?" b1 s7 H' b9 O+ {167
168
( g& V+ |$ k: A2 |5 w169
( [! K  Z) u. ^0 q: B170
171
172
173
8 h0 b8 O: y! `3 O8 c每天进步一点点！
不进则退！


版权声明：
' V; N: n: z/ H" O1 I原创博主：牛哄哄的柯南
博主原文链接：https://keafmd.blog.csdn.net/
1 {! T* ~6 s+ K- w5 T————————————————
版权声明：本文为CSDN博主「牛哄哄的柯南」的原创文章，遵循CC 4.0 BY-SA版权协议，转载请附上原文出处链接及本声明。
原文链接：https://blog.csdn.net/weixin_43883917/article/details/118193663


6 d& o! g* K8 B8 g

1051373629

每天进步一点点！
, P" _7 u9 T- z