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

杨利霞

/ z0 R( x+ A1 _* t+ T. W+ H6 \经典十大排序算法（含升序降序，基数排序含负数排序）【Java版完整代码】【建议收藏系列】
. b% X" O% _  B' K经典十大排序算法【Java版完整代码】
1 C* Q2 i2 R6 u" `  ]2 `) [写在前面的话
十大排序算法对比
冒泡排序
% `5 t( e9 [  V  x8 K' M快速排序
, Y! D$ V% v' j8 Y2 b直接选择排序
; z$ F" _# T! w0 D. R; h堆排序
归并排序
  }5 f/ f& C% R4 w$ L# l插入排序
希尔排序
; }( N" |+ c! S. q! Z+ q7 Y计数排序
桶排序
基数排序
7 W4 }% H6 P3 _; J/ J2 |- ]完整测试类
2 m; ~- y- P8 u& D写在前面的话
" P! v. Q1 @+ W( u9 {       虽然已经有很多人总结过这十大排序算法，优秀的文章也不少，但是Java完整版的好像不多，还存在某些文章代码存在错误的情况，同时也为了自己练手，决定把所有的写一遍巩固下，同时也真诚的希望阅读到这篇文章的小伙伴们可以自己去从头敲一遍，不要粘贴复制！希望我的文章对你有所帮助，每天进步一点点！！！
$ h9 I% b- h4 l" E9 G% ]: `/ ~6 s
0 [+ v1 B& k3 w8 g  l9 H9 |
" ]( j+ t& _/ j- X* a9 @       我用通俗的理解写下对算法的解释，对某个算法的运行过程不是很理解的话或者想看比较官方的解释的话，单独搜索某个算法，看几篇不同的解释，就可以有自己的理解了，这里我主要展示代码以及进行通俗的解释！整起来，再强调一次，一定要自己敲一遍，这样才能理解的更深刻！
! V" [4 r$ w6 [& F* e
2 }" O2 ]7 R! I* D  @9 v% z
十大排序算法对比
; A0 m  F* \9 Y2 ~( K
4 t" E4 Q$ {% |" h. z' I

+ O- U8 u3 G& Y
关于最后一列的稳定性，我稍微解释下，例如对序列：1 2 4 2 6 排序，序列中存在两个2，如果我们把这两个2标记上（让他俩不同），排序之后，前面的2还在前面，那么就称这种排序是稳定的，反之不稳定。
+ B  @+ }8 J/ T7 Z! g( k3 I

冒泡排序
简单解释：
8 L0 s# m* C5 K2 M. c, J& @$ i       原理就如算法名字一样，就像水中的气泡一样，每次我都把最大的或最小的放到最后面，这样总共需要n-1趟即可完成排序，这就是第一层循环，第二次循环就是遍历未被固定的那些数（理解成数组左边的数，因为每层循环都会把最大或最小的数升到最右边固定起来，下次就不遍历这些数了），两层循环遍历结束后，所有的数就排好序了。
5 [* F/ G3 C4 J9 K, o9 u       两层循环所以冒泡排序算法的时间复杂度是O(n 2 n^{2}n
2
)，是一个非常高的时间复杂度，我在下面的代码进行了优化，加了一个标志位，如果上一次循环未发生交换，就说明已经是有序的了，就不继续下去了，反之继续进行下一轮。
/ Y! s3 P& T3 m1 s9 A/ ?1 m) u2 R+ k
4 _6 L- i+ p" A) l  t* f
* e: I$ X/ h& |, j1 a



本文的图片来源网络，仅用于大家学习，侵权联系删除！（下同）


+ Q4 B1 Q) L& H1 v完整代码：
' L; A  w5 O" m2 Y' c7 ~9 M7 Z

package com.keafmd.Sequence;
5 O. L- U) l8 X& z

/**
% X) o" `, G/ T" G# S4 b7 z * Keafmd
*
* @ClassName: BubbleSort
* @Description: 冒泡排序
* @author: 牛哄哄的柯南
- V; d  l! `5 K5 E  Z* A * @date: 2021-06-24 10:31
" l! A+ e+ l4 T/ `0 g% t9 x */
( p3 J! q! v# F! b0 q( l% }public class BubbleSort {


0 A7 a' J# w7 H  z, U! |+ F    //冒泡排序
    public static void bubbleSort(int[] arr, boolean ascending) { //exchange标志表示为升序排序还是降序排序


, p4 M7 Z1 i0 _$ M        boolean flag = true; //加一个标志位，记录上一次是否发生了交换，如果是，我们则进行下一轮，如果没有，说明已经冒泡好了
3 _+ {2 o& M: i. d) c5 ]4 S7 b
$ }$ T$ [9 Q3 C. d) {2 ^  Y
* e+ L, A/ s) I. e3 [) }4 I. v5 D        for (int i = 1; i < arr.length && flag; i++) { //控制次数，第几趟排序，只需要n-1趟，有交换时进行，只有flag=false就说明上一次一个元素都没有进行交换
" V9 b. @+ b) w% Y0 Z8 t- X

  N# s5 V  h& _, r' g. ~            /*System.out.print("第"+i+"次遍历：");
            for (int i1 : arr) {
4 I) J; M1 h' I, {                System.out.print(i1+" ");
            }
            System.out.println();*/
3 [+ f5 O& c: ~+ @8 S  W

( g6 X6 P" K( o& N4 a: \: g            flag = false; //假定未交换


+ E; X( s8 ~' W; k' N            for (int j = 0; j < arr.length - i; j++) {


                if (ascending ? arr[j] > arr[j + 1] : arr[j] < arr[j + 1]) { //控制升序还是降序
+ v/ z- U! T0 R, G0 f% g/ Q7 L' b9 `                    int temp = arr[j];
% K0 O! u7 ~4 R9 U) |" l                    arr[j] = arr[j + 1];
                    arr[j + 1] = temp;
                    flag = true;
  g% [) x1 S$ V, x9 U                }


; n* x$ O' t. J6 d0 j            }
! D2 G9 o/ a( k        }
3 u* D5 Q5 L, h1 C# Z    }


% `# j7 R' G- G" f4 ]: Y    //冒泡排序 -- 默认不传参升序
    public static void bubbleSort(int[] arr) {
8 W; l$ S# f' {' j  x' }        bubbleSort(arr, true);
" `1 U. F; I! |1 t    }
. e1 s8 C) }1 V5 D7 W+ _: Y: s}
1
( Y& U# W7 T5 x: H' X  s2
$ M5 L; h1 a* h0 v% Y5 E, Y3
4
, m/ @  u: G9 a; l1 W7 S. J5
6
) n, G! d* C) U, E1 w, a, a- Y7
  i+ A) R0 C+ U! q$ n1 }- i8
) _& Y. `. [$ w0 }7 j; i5 m9
* c! `! c+ v+ S0 P* j9 B6 y8 y9 `10
11
12
& P9 n# R: ?$ {( e13
14
! g, q; Z" S# z8 s6 O, K  ?7 G15
16
17
18
19
9 _5 c8 \1 E7 H9 @+ u1 l20
6 W9 R$ I) g# s* U21
* l6 p; I' a( E" _' W! y22
23
" e! \& E! A  B: R$ U% s, J- F24
25
26
27
4 U- L' `; y* A7 _1 G( z' L28
29
30
31
32
33
34
35
/ ~3 {; P2 I% G4 I4 w36
37
38
39
40
) h; @9 w+ r# G) d2 {0 E3 o) u5 @41
2 c9 N5 [7 y# J+ O8 ~42
43
44
" f& x' y2 \& z* [45
测试代码：
. B) ]! s% V- C. m  I

, r9 F( Q) `* M: ~升序排序（从小到大）
. w2 C0 Q# r, N( {9 |, x% V

; w, J, J* |, @' u$ epackage com.keafmd.Sequence;
! I% t# b( k/ m. d$ O" X& f. X  W
  |# f- K: B- [% q. L8 D" y0 g9 X
1 b1 |: [6 z0 ^import java.util.*;
import java.util.stream.IntStream;
import java.util.stream.Stream;
) ~- A, W+ U: ]- X/ J2 P, a% d0 p& D
2 D% I$ @! q( w! U
- R! O0 R2 \4 u+ B9 l  v/**
* Keafmd
*
$ C9 J8 }, G0 h1 t * @ClassName: Sort
. r0 t7 h8 u. S- Q9 }/ D * @Description: 十大排序算法
* @author: 牛哄哄的柯南
* @date: 2021-06-16 21:27
*/
* r) U" I, W' N, tpublic 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};
        int[] temparr;
: T, `! [; W% l5 Q% E

% R1 ?- S; _! r( }) x2 e- q& k        //测试冒泡排序
0 n9 f' }( o4 W. s! a0 L        System.out.println("测试冒泡排序:");
        temparr = nums.clone();
: G% u( K7 z" b  f0 e' O7 @4 Q" n        BubbleSort.bubbleSort(temparr);
& N5 ?7 W" t" L        //逆序排序
        //BubbleSort.bubbleSort(temparr,false);
        for (int i = 0; i < temparr.length; i++) {
            System.out.print(temparr + " ");
  G8 _" ?- d* n% ^$ |( d- r5 r        }
* S7 E' x6 p; J- d& ^+ o- `1 P        System.out.println();
- j, i' x! F9 C  G0 ^

    }
}
) n+ M" _8 w) ^0 b5 F0 G8 x1 O1
) b/ B- f8 K; }# ?0 N: y% z6 ~2
( I- ~1 m( h6 i3 C/ D3
# O( |9 e! `6 h! j$ y7 J4
1 Z! J; B! Q  z4 _. U5
$ P* x0 L1 X2 |1 r$ m9 x6
7
, G8 b: c# d: _+ @% z4 r+ m8
9
- q2 C$ X" |; E" }6 g6 i10
11
12
" l6 S4 x( H! @; k  s4 {13
& `: T* z, D/ [, K' [' w14
/ `7 ?+ _1 t4 c$ E1 F: {2 V8 N: D15
16
6 @, |( Y9 j8 e! x, u* v1 [17
7 l, a8 @. X2 x) l2 W5 J4 e; `18
19
20
4 N% |) E4 n$ N1 h21
9 _2 S$ d5 m9 e) G( E$ q22
23
24
25
26
' f: {" J9 h; k9 E2 @6 v27
2 v3 a* K' ]' m) `3 p$ |28
/ ~7 ?; F* _9 n# |8 O/ j! `. h29
4 v! x5 k6 g$ L- Y6 F30
31
32
0 c6 H% {: T) G1 Q" D0 M33
运行结果：
$ W$ R0 _( \7 C4 X- M
8 X8 F0 [, \+ x+ E: d
测试冒泡排序:
2 v5 f. L: V9 E. I-66 -13 -1 1 4 9 12 25 25 26 34 47 58 99 162 10093
$ I: I2 F  B" I# w- @$ }5 a1
2
$ P/ @3 G# a7 ~9 `降序排序（从大到小）


& z1 S  ?9 j0 \5 M  K+ a//测试冒泡排序
System.out.println("测试冒泡排序:");
temparr = nums.clone();
$ _) f) D# h  R- y* t1 ~BubbleSort.bubbleSort(temparr,false);
for (int i = 0; i < temparr.length; i++) {
    System.out.print(temparr + " ");
4 z8 K( o0 L. H! U6 |% M, c}
6 F. T3 I9 K& E6 u/ v5 [  XSystem.out.println();
1
( y5 A3 m! p& v& c$ _/ h8 {' l2
; W+ j  m# c( A$ B- J( o! M1 u) A5 q3
. L+ D* {- d$ O9 [$ f4 F5 R4
( q. A/ y! d+ U* \5
6
7
8
运行结果：
0 W5 f# l3 q: L0 R, n/ _

, u' g) w1 d, Q: _测试冒泡排序:
10093 162 99 58 47 34 26 25 25 12 9 4 1 -1 -13 -66
" ~+ V  E8 Y3 X- T& r$ O1
2
, U+ X2 s# O& l+ g下面几个算法的测试也就是换了下类名和方法名（换成相应的排序算法），如果想降序就在数组后面传个false即可。我就不一一复制了，我在最下面给出含所有算法的测试类，需要的自取即可。


快速排序
! o/ w9 ^% i( G# a$ `+ s7 G简单解释：
4 I$ }& S& F0 D6 L( O+ ^快速排序就是每次找一个基点（第一个元素），然后两个哨兵，一个从最前面往后走，一个从最后面往前面走，如果后面那个哨兵找到了一个比基点大的数停下来，前面那个哨兵找到比基点大的数停下来，然后交换两个哨兵找到的数，如果找不到最后两个哨兵就会碰到一起就结束，最后交换基点和哨兵相遇的地方的元素，然后就将一个序列分为比基点小的一部分和比基点大的一部分，然后递归左半部分和右半部分，最后的结果就是有序的了。

5 s7 `+ v3 ~+ U; w- G8 _

$ x) p/ D/ S8 L, O$ v8 B3 z* S* a

: C$ k+ ~  a; M/ H2 s7 ^5 C4 D
完整代码：
8 v& @- o3 F: t0 {1 W
4 F! x% u% R% X
# C( b' |  N( X  r- npackage com.keafmd.Sequence;
2 z% I4 R; h) O, W- M

: f6 y# d! ]" S$ j- W6 F3 P/**
' Y+ c/ {5 {- q/ F$ h7 h * Keafmd
% N0 K/ D: Z% H- Y *
/ V. n: n5 Q4 t( u: c * @ClassName: QuickSort
/ y' p) k" L; c+ Y+ v2 J * @Description: 快速排序
9 s- c/ V% Q( d/ o * @author: 牛哄哄的柯南
% p% N+ q( ]. C& y  K * @date: 2021-06-24 10:32
*/
6 i8 p2 W. \7 K4 J$ V, e; Rpublic class QuickSort {

/ i0 s, B. c9 O2 Q  Z
    //快速排序
( Q6 K/ p/ j& V, M% `    public static void quickSort(int[] arr) {
        quickSort(arr, true);
    }

2 l* N# [2 B! K3 Y+ p! j
    public static void quickSort(int[] arr, boolean ascending) {
        if (ascending) {
            quickSort(arr, 0, arr.length - 1, true);
' y7 X3 N8 D! \        } else {
            quickSort(arr, 0, arr.length - 1, false);
        }
    }


    public static void quickSort(int[] arr, int begin, int end, boolean ascending) {
        if (ascending)
            quickSort(arr, begin, end);
        else
/ k6 m; a2 K5 H8 B$ r2 |            quickSortDescending(arr, begin, end);
    }

# E( ?4 s" I0 f% s- }8 \+ K" p7 b( X
( P1 d' Y1 H! I# w) W* B* h" Y    //快排序升序 -- 默认
' Z9 y% {7 L1 o9 O& z; l  Q4 P$ c    public static void quickSort(int[] arr, int begin, int end) {
( x1 t2 @5 `3 q        if (begin > end) { //结束条件
            return;
, K* Z' v) T$ e, {        }
        int base = arr[begin];
        int i = begin, j = end;
        while (i < j) { // 两个哨兵（i左边，j右边）没有相遇
            while (arr[j] >= base && i < j) { //哨兵j没找到比base小的
                j--;
% h% G( n$ J& p; `) K2 Z6 _            }
            while (arr <= base && i < j) { //哨兵i没找到比base大的
                i++;
7 W/ q, p; O4 D            }
            if (i < j) { //如果满足条件则交换
                int temp = arr;
$ Q. ^% i5 }8 f. D) G. N1 E                arr = arr[j];
+ ?- f3 ~7 t7 ?( \. |# h                arr[j] = temp;
            }


        }
1 ?: r" b) _. O9 p; c; U. ?9 y8 D        //最后将基准为与i和j相等位置的数字交换
. S2 L9 U8 @' V        arr[begin] = arr;
        arr = base;
2 B7 u. D; Z4 r/ G) @/ Z        quickSort(arr, begin, i - 1); //递归调用左半数组
        quickSort(arr, i + 1, end); //递归调用右半数组


2 n! r! t3 V: R# L* `    }

! Q; ~( X% w- S" l
/ z/ t- @5 m- l9 A! s    //快排序降序
; t' m$ P6 H( c- E7 k; `    public static void quickSortDescending(int[] arr, int begin, int end) {
1 s- ^8 m3 ^& h! o        if (begin > end) { //结束条件
/ c! T2 y3 q8 ^/ v* I            return;
        }
( q! J  }! L1 `  ?) H8 Y) U2 o" b( P1 }8 p! `        int base = arr[begin];
        int i = begin, j = end;
$ W3 k6 O7 V8 r; G# _( j        while (i < j) { // 两个哨兵（i左边，j右边）没有相遇
            while (arr[j] <= base && i < j) { //哨兵j没找到比base大的
                j--;
1 l" b. [; u' M1 \) Z9 M            }
* N( v9 ?) v: j7 @! \            while (arr >= base && i < j) { //哨兵i没找到比base小的
                i++;
7 P! f7 [7 I1 M0 B; b6 W2 M8 G            }
0 d: }9 J* C& X5 ]3 u2 d0 g, {9 I            if (i < j) { //如果满足条件则交换
                int temp = arr;
                arr = arr[j];
2 ]' }% `& {2 u2 ^: b& S4 C                arr[j] = temp;
            }

* H4 U8 G8 X) \1 _# _* ]
        }
+ Q2 U! j, U8 l: g# \4 R) s" ]        //最后将基准为与i和j相等位置的数字交换
        arr[begin] = arr;
; I+ Z. J; j$ C5 O& z0 X        arr = base;
        quickSortDescending(arr, begin, i - 1); //递归调用左半数组
8 Y; l% y- f8 O        quickSortDescending(arr, i + 1, end); //递归调用右半数组
. H) D1 [' B* F

9 x: s5 k7 g& h/ g* E- F    }
( e" g- V: i, s; M, [6 k

4 j8 F9 p- _8 ^2 I}
1
2
9 _$ @+ l8 S1 O3
4
/ `& l" _& G" [+ K' t/ @5
6
. z* g2 a  F& ]4 @7
8
8 ]0 x* E" o$ ^' ?9
) D% f/ |9 q+ c4 \& b10
3 J  p( M/ D0 b- {' j11
$ J7 q; B, m6 d  a12
13
" [/ Q3 c. W& z$ t14
15
4 V, r4 u: s- Y# ~16
17
18
19
0 s% \( g9 ]; [; p6 a. l' e% ~20
21
22
23
24
- c3 k- g6 ]0 Y5 V, z  j% T25
8 c5 X, u+ S; P+ k7 L26
27
28
29
. v% ~( S( ], X5 h: v30
+ L8 S$ }2 V' C  h2 L' j) I7 I. i31
32
33
34
1 S, K* n' ^( l  ]! E# F, T35
4 g* H; a4 U& G7 Z/ P2 Z36
37
  E% w: S- v) H6 W38
3 R6 b6 L6 ^# ^  l39
40
  L! ]" O% I4 g41
5 d  ~( V% D2 h$ F. S/ E, g& M42
43
44
) n' K* {9 h) ~( s- c7 L" Z5 K' p45
4 {/ m' ~7 E8 i' i6 I46
3 M+ H9 s# `+ b2 S# E, F47
9 }$ g: y2 ^9 ]; r* k. h  H$ p& f48
' t0 Z- H8 u* B5 x1 K. U( W49
50
9 K* D. ?( M+ W" a( o1 c0 Z51
* [7 x5 T/ t8 K" [! b. ^52
53
54
/ W$ e2 G$ `# j/ h& j55
1 g: q5 G7 y: p) h: p56
2 y( W- i3 c3 d) v- J3 p, A57
. ]6 s( {+ {# P) I) c58
59
" t: S& a4 [& E60
61
1 _  s. O0 U; S8 [. w4 b+ ]62
7 E2 ], n% T  P63
! Z+ O# V: _& U* i9 C" j' }/ \1 {* z0 ?64
- g  r+ S0 A" ~5 N+ z! e65
66
67
68
69
) o' n8 ]0 X8 V+ v( y70
71
4 ?+ }* f7 D0 c3 ^/ d) g72
73
0 y/ u/ k& ]% C! r0 h( J+ g74
; P/ C) h; a1 c  H, v75
76
77
78
& p3 y( \/ f0 a! @9 F5 {79
80
* G4 c& j3 K/ E8 r# U81
82
' ^2 A& Y+ X' G4 h83
8 }) A0 h% H9 c' _84
& x- m8 O( P" O0 i7 X0 M% P) ~2 t85
4 W7 X7 R, K7 s: R+ \86
+ m! H) |( I# ?! ^& U! T; r87
5 Q0 P; ~' Y" c4 e- d88
$ Y/ P$ m- z9 r89
90
91
! y( g! j$ @  K% L% j  r2 E' _直接选择排序
简单解释：
/ a7 g# Z5 [- F+ L" F数组分为已排序部分（前面）和待排序序列（后面）
) S0 K/ K# [9 X" K4 s1 `第一次肯定所有的数都是待排序的
3 ?- S. c" |1 E6 T从待排序的序列中找到最大或最小的那个元素，放到前面的已排序部分，然后一直找，不断缩小待排序的范围，直到所有的数都是已排序的了
' A6 z9 Q  Y( x! [) D

) F, }5 o# X; J" s

. P! o+ F$ C# j0 a
& u5 ?, F, e3 P1 A4 H( \
完整代码：
4 O" ~8 V' x! j. X4 ]# H

  q7 t1 a7 A* k7 Npackage com.keafmd.Sequence;

! K' n+ l, ]; h4 Q5 [4 H  u
- }1 g# {' s% _4 }$ {( C/**
* Keafmd
*
* @ClassName: SelectSort
* @Description: 选择排序
* @author: 牛哄哄的柯南
8 ?4 ?5 D# ~6 p/ h) c * @date: 2021-06-24 10:33
*/
; h6 W" X! _& W0 w' w  g" B* ]1 u" Xpublic class SelectSort {
% [7 G; }6 I  b' P6 A( U" B
7 l" \# A0 p/ W( t9 ?5 a
% N+ G8 F. |: S' ~8 B+ T( f: W    //直接选择排序
    public static void selectSort(int[] arr, boolean ascending) {
% K3 b. D/ B/ |" a- \' Q        for (int i = 0; i < arr.length; i++) {
            int m = i; //最小值或最小值的下标
) i1 y: m! l. Y& J            for (int j = i + 1; j < arr.length; j++) {
                if (ascending ? arr[j] < arr[m] : arr[j] > arr[m]) {
( _( P0 H- H- Z  p( y) g                    m = j; //找到待排序的数中最小或最大的那个数，记录下标
                }
: r9 F# R& s7 ~$ K! X9 ?' X, y
& W4 R4 |& j" h4 Z. }+ C/ y: n
            }
. M; o9 ^% x* U4 g/ c/ A9 E            //交换位置
1 H( |: {9 I( w! o            int temp = arr;
            arr = arr[m];
            arr[m] = temp;


+ I. W( D; J2 R4 Q. U( N8 _        }
4 i8 A# ?- Y( H    }


6 E; @" \% h, |! r8 _' u- m    public static void selectSort(int[] arr) {
5 ], g0 F' r! V$ ~% j7 b6 ?        selectSort(arr, true);
    }
8 A) {& ^4 a7 u8 q  C( ?' b}
1
2
3
! ?- F/ {5 F: W; \; ?6 i# B+ Y4
! m. l$ `4 o$ {; j  U+ Y% T5
6
7
  \) x0 g' Q4 F. I2 S2 ^8
9
. B* v( k3 E3 j% R/ i' l10
8 a& E' G' `5 f. ?6 O$ c11
12
13
14
15
& o/ W, ?; r' l2 k( T2 v7 \/ u16
17
18
19
20
7 d0 C  Q* o+ c3 h- p1 P21
22
23
$ h% P4 T% ]$ L3 z24
25
26
27
28
29
30
31
6 b" }  a( n, W1 h" E32
33
34
1 q3 Z0 O) a1 i+ q- y堆排序
先理解下大顶堆和小顶堆，看图
大顶堆，双亲结点的值比每一个孩子结点的值都要大。根结点值最大
小顶堆，双亲结点的值比每一个孩子结点的值都要小。根结点值最小
- ?1 o8 G) a8 M2 C+ u- {

" k4 t: r7 [7 F

简单解释：
9 K6 d$ N6 l4 P1 D  v* I+ G2 f" l- a. H构建好大顶堆或小顶堆结构，这样最上面的就是最大值或最小值，那么我们取出堆顶元素，然后重新构建结构，一直取，一直重新构建，那么最后达到排序的效果了。




  g) }  t; c' s$ S: Q" h
+ P; W( {* C+ h3 ^
完整代码：
+ j2 I- r# p7 B" ~+ M( Y
! y! r/ S/ {- ?; z% E7 H( F' @
package com.keafmd.Sequence;


/**
7 D: f6 b: N1 v * Keafmd
*
2 u# B. N! G; r( h4 @* ? * @ClassName: HeapSort
* @Description: 堆排序
* @author: 牛哄哄的柯南
* @date: 2021-06-24 10:34
*/
4 ~" g3 L1 y( b4 J) Z  Epublic class HeapSort {
3 `% c$ X1 o; i
2 J+ L; C4 R$ Q7 x( O+ l% \3 n5 n
    //堆排序
; W& e8 a% f% v7 }# }! P* c, n    public static void heapSort(int[] arr) {
        //对传入的数组进行建立堆，这里默认建立大顶堆，进行升序排列
1 c9 S% X+ w# w5 p' Y6 P        heapSort(arr, true);
. _' s  m; O: D3 l4 x$ y    }

/ ]1 J7 @: p: Z% y& R: D
' v$ U+ @! q& E    public static void heapSort(int[] arr, boolean maxheap) {
# ^' R) }. n; f3 k, |
; c$ z4 m, J  @5 {
% X# _# s/ H  N1 O  v" Q        //1.构建大顶堆
; n- ^4 N" r; n+ a0 Q1 B        for (int i = arr.length / 2 - 1; i >= 0; i--) {
            //从第一个非叶子结点从下至上，从右至左调整结构
# O' ^6 _; u+ g/ d% {8 C# M8 x            sift(arr, i, arr.length , maxheap);
        }


        //2.调整堆结构+交换堆顶元素与末尾元素
        for (int j = arr.length - 1; j > 0; j--) {


- i9 M8 a0 [( o( c$ Y0 l+ [$ m1 k            //现在的数组第一个就是根结点，最小值所在，进行交换，把它放到最右边
            int temp = arr[j];
1 x% S, E4 }0 @6 J$ h" E            arr[j] = arr[0];
            arr[0] = temp;
$ V" ]$ Z/ H/ k2 M% f6 c6 H

9 _/ G6 x' g! ~4 l, d            //重新建立堆
% d- O6 h9 B- V) a            sift(arr, 0, j , maxheap); //重新对堆进行调整
! D/ E% k$ p5 I1 h/ _' [% J        }
  _- ^- r. j1 g4 `. n& x    }

# T' I+ P6 n. a. d& ^+ \
" q$ }  X) I8 k    //建立堆的方法
    /**
3 ]9 M/ H& g6 }/ G+ G     * 私有方法，只允许被堆排序调用
2 ]6 E2 n& Q( ?0 g0 k5 X5 _0 Y3 F     *
2 D+ n+ X6 m3 X* j+ A* R" e     * @param arr     要排序数组
6 ^7 u3 Z; R$ S0 c! M     * @param parent  当前的双亲节点
     * @param len     数组长度
: ?6 _2 H# b2 ^: E# m7 ]     * @param maxheap 是否建立大顶堆
) q+ ~9 e0 h4 O; I# }$ n# L: N     */
    private static void sift(int[] arr, int parent, int len, boolean maxheap) {
8 v! E1 B7 C: ]% D/ e2 t% Y6 c) K: Y
0 [3 q( _( {: w
' O1 E0 F3 f% s  U        int value = arr[parent]; //先取出当前元素i

- K' _8 q$ H6 h4 `7 i# {8 M" c9 S
        for (int child = 2 * parent + 1; child < len; child = child * 2 + 1) { //从parent结点的左子结点开始，也就是2*parent+1处开始
1 c, E/ o* D1 l4 n2 D* p9 b8 E& p1 d

" V) j$ k; Q* N  T" ~9 }; R            if (child+1 < len && (maxheap ? arr[child] < arr[child + 1] : arr[child] > arr[child + 1])) { //如果左子结点小于右子结点，child指向右子结点
; A! T! \8 t; v1 s3 c6 ?( H! {                child++; //右孩子如果比左孩子大，我们就将现在的孩子换到右孩子
, H( f# a2 _6 l% Q( M            }


            //判断是否符合大顶堆的特性， 如果右孩子大于双亲，自然左孩子也大于双亲，符合
/ r1 X" `9 t$ |9 p; \, f$ \            //如果子节点大于父节点，将子节点值赋给父节点（不用进行交换)
            if (maxheap ? value < arr[child] : value > arr[child]) {
+ [7 ^# Y8 e4 B( c                arr[parent]=arr[child];
; a  A  E. A$ a  Z                parent = child;
( B7 C( @, T+ {2 w- Q1 L6 Y0 [$ u            }
            else {//如果不是，说明已经符合我们的要求了。
" b4 d) V: X; N& p" Q7 {7 R( d                break;
  [# c) ~% s4 }* x) H            }
0 I- h9 K' P6 ]/ W        }
: m& L. ]* U6 j. X7 |& L* e+ d        arr[parent] =value; //将value值放到最终的位置
! U1 b# S% [+ v. u& i4 R7 a
4 ?" s0 {- ]+ h8 a: S# N, h: N

6 `  ~1 n2 }, e
# B) u* q0 C! r) k) Y( {, `, h    }
% m, g6 k6 B" [1 c6 G! E7 O& q

- S( r/ x3 V# D1 Y}
: a9 {# C- u1 H1
2
/ ?8 D; o3 V# n: Z4 J! r  |, I3
' C& m$ Y: j  g3 R) I- {4
+ o; [+ x, \- @- u/ K" M; q' ~5
/ x1 {0 c' H' ^$ P4 p6
7
# t: s3 ]% B/ X9 H8
9 t: J8 S. O( y2 |( `% y! S, _/ G9
10
8 p+ A7 ~1 l- `$ E11
" C- X: g6 ?( ^( D12
% e  a+ Z3 U+ u) g. t  b, z13
$ N3 \+ {8 w: |: E" }/ q14
15
2 j  [( n- D2 g- Z( @16
17
$ `: t9 E) u: x+ x4 h0 d& D* N9 F5 O18
' u/ g9 N7 T: ?4 _19
1 T4 n( v8 f- r2 \1 d, A20
21
; Y- [8 w+ n3 h; _# A. m; S22
; {: x4 [9 O# ?, F: q23
24
7 I0 ?& o( d; z& }5 j25
5 ?; M" N2 k/ z3 F26
27
28
29
( u7 E' V: E; \$ W$ J30
3 `" j2 ?! N! G. @1 t1 A0 Y2 y31
$ c* x/ I1 M" M( i7 Z32
: }( Z0 T' [8 G+ Y; s) Z33
/ H6 |+ q* C" U34
35
36
. t) K$ N" ~0 n& j) g7 h37
38
39
. v/ O+ P+ M( E( l5 r' Z& E* i3 C/ L40
41
42
43
44
45
* t/ r/ l( B6 H; K/ e! Y3 g9 R46
& \6 ^2 x! ~( `( F! Z; B/ |47
48
- \+ F5 I* Z( y! s6 b7 m49
. `6 E& w& W+ ?9 `% l& |/ k2 V; d- m" o50
51
52
53
# d1 t9 ~4 G3 W2 {3 s54
55
' s: Z0 F0 B/ m  A' I$ X7 V3 |56
57
& D: `) Y+ G. J3 i) B, z$ O58
59
) A3 D6 M  L7 m( g1 a$ b2 ]! P60
61
62
# c& B$ p7 @3 @63
64
/ S* Q; q4 m) w$ R: z- Q0 O& A/ W65
66
67
) S. V( I; ~7 D2 Q68
69
70
* U% Y: s8 F, \& A: [, ]1 t  p6 G71
' q0 Q: j+ j2 s/ o) @72
73
74
; W5 |  ^$ p( [$ x归并排序
简单解释：
0 C4 C( n* t- O" g7 m: _* A( I# N该算法是采用分治法，把数组不断分割，直至成为单个元素，然后比较再合并（合并的过程就是两部分分别从头开始比较，取出最小或最大元素的放到新的区域内，继续取两部分中最大或最小的元素，直到这两部分合并完，最后所有的都合并完，最后形成完整的有序序列）


6 [  \/ s5 [8 n$ W( G  l


/ }, @: A) x4 G+ M7 Z" D4 l
  h5 a6 i% v2 |4 g完整代码：


; C( O4 u" x( Npackage com.keafmd.Sequence;
- g, F+ A$ \1 a( T. T: ]* w/ U6 t

0 M  W" I  ?$ w6 v* b$ Z/**
2 d) d8 c5 Y7 Q; B+ e * Keafmd
/ g- H: V$ D) g- v6 ?) m& |+ ]5 ~ *
% H/ Z+ ?5 W' p2 T% x0 s * @ClassName: MergeSort
* @Description: 归并排序
* @author: 牛哄哄的柯南
* @date: 2021-06-24 10:35
) s( w' f7 Q  o) a) [, g! Q */
public class MergeSort {
) o, T3 J  X/ v+ w3 [+ {# L& K

  b8 b& C8 ^! _# F    //归并排序
2 g, c& O# x1 x9 C) ^4 ]+ y- ?- `1 Q    public static void mergeSort(int []arr ,boolean ascending){
5 W( z1 ^: O$ E8 k6 B        int[] temp = new int[arr.length]; //在排序前，先建好一个长度等于原数组长度的临时数组，避免递归中频繁开辟空间
- M2 f9 }# e9 S3 {1 L5 d+ n4 U        mergeSort(arr,0,arr.length-1,temp,ascending);
9 }& v( A* @) E, V$ M    }
6 C9 n9 R; I# y5 N0 y+ r    public static void mergeSort(int []arr){
9 S( j+ }8 A  s# x! h5 k# x        mergeSort(arr,true);
5 Q* ~% _  |  s' _5 d! K: X    }


    /**
     *
* s4 ^7 M4 H, l. b; Q7 ?     * @param arr 传入的数组
     * @param left 当前子数组的起始下标
! H0 [: R; v0 s% J& u. u     * @param right 当前子数组的结束下标
     * @param temp 拷贝暂存数组
  z' M) _) N  w. j! C     */
    public static void mergeSort(int []arr,int left,int right,int[] temp,boolean ascending){
/ w! L/ j) J! }2 r& \        if(left<right){ //这里是递归结束的条件，我们是对半分，那当left==right的时候肯定大家都是只有一个元素了。
3 S5 J4 ~9 T+ d
# ^: [1 z* ^) ?( k9 P" j# o) P; ]% u9 P( G
; Z8 ~" e6 V3 w, f4 _5 z            //对半分，比如总长度是10，left=0，right=9，mid=4确实是中间分了，0~4，5~9
9 n* G! I/ ?: g  q            //当长度9，left=0，right=8，mid=4，0~4，5~8
: b2 T0 z1 h9 S) W- }            int mid = left + (right-left)/2; // 防止越界的写法
5 k7 e, \0 \& b  y9 u% l# p0 F$ }            //int mid = (left+right)/2;
9 l2 p1 f- v& l: R  D& X

8 B$ a; @( J( {% ?0 y% z; B+ \            mergeSort(arr,left,mid,temp,ascending); //左边归并排序，使得左子序列有序
8 o" d1 D* c+ l1 E            mergeSort(arr,mid+1,right,temp,ascending); //右边归并排序，使得右子序列有序

1 i. S6 p$ N" [% {7 t% W
) M+ K  g( Y# W4 h' A            merge(arr,left,mid,right,temp,ascending); //将两个有序子数组合并操作
6 ?- J" p1 ^3 ~+ s) {2 P4 e        }
    }
" Z! ?) r# }: a0 t

    private static void merge(int[] arr,int left,int mid,int right,int[] temp,boolean ascending){
        int i = left; //左序列起始下标
- h* Q9 K5 H6 j. X% I2 ?3 |* t0 i        int j = mid+1; //右序列起始下标
1 Y( B1 g" H$ G* V8 ~: g3 h8 |        int t = 0; //临时数组指针
        while(i<=mid&&j<=right){
            if(ascending?arr<arr[j]:arr>arr[j]){ //比较两个序列第一个元素谁小，谁小先拷贝谁到temp，然后对应子序列下标加1
                temp[t++] = arr[i++];
            }else {
& K/ a* D) \4 q& V9 t( Q4 m                temp[t++] = arr[j++];
            }
( l9 i: ^3 \  D! ~5 V        }


/ k' H( ?0 ?- z3 R. P3 d' K) V) E  j        while(i<=mid){ //将左边剩余元素填充进temp中——左序列有一些数总是比右边的大的数
3 G; _: F5 r$ I3 ~            temp[t++] = arr[i++];
        }

* A: q$ P- l  a! [
+ F) z( n3 E$ D+ o        while(j<=right){ //将右序列剩余元素填充进temp中——右序列有一些数总是比左边的大的数
            temp[t++] = arr[j++];
        }


2 I5 n$ q/ R$ G+ f        t = 0;

. P4 F6 X$ N5 @4 b3 T
        //将temp中的元素全部拷贝到原数组中
3 P+ }( Q5 `2 x3 _        while(left<=right){
            arr[left++] = temp[t++];
, Y" t8 v; ~: q0 b        }
" r9 ~& u- }/ v$ g3 G2 Z& s4 Y

" S: V, G0 R' Z/ e% \    }


$ v- W, \9 [3 [$ T8 I* C# @}
1
2
% j6 v* K$ C6 \  {, R3
* n+ a( c8 G- c, o4
* \$ o9 a6 e: N' E% S5
5 f( Q4 p$ ?# w6
, \8 q6 K5 E/ v) X0 O; r- q# i0 l7
! H' t. d; t7 I+ G" H) c% A. q* L8
2 w( m3 Z. T2 T9
* n, \  q/ C" n# ^1 ^) F( u10
11
! H  v  ~) `8 P* K! a12
13
14
. C' r& v& w5 r15
16
17
18
  a! x, b: E7 u1 a19
: s2 U8 G) X& j3 R! x9 z20
* H9 x4 J9 q! x' t% J+ z21
22
- o. T& Q' a' @0 Y, h6 i; m1 j23
% @/ C% {; J$ {6 q5 u7 J24
/ ~# C" a; A3 A8 x( I3 h25
- R  y; S9 b! g# k( ?! f* s7 g3 o26
27
) Q/ w: Y" u: F/ B& u# f28
29
30
, Z/ U" b( b/ u) y: O. Q9 j; K" ^31
' I$ W, j/ b' ?/ g9 r% t32
" O. b1 m1 S: h% S) ~33
1 T* p# K  e* T* [4 k) m) O34
! U1 F6 k# S7 y) R  ~35
36
37
38
8 R; L( Q. j5 u9 v3 \39
40
41
42
: u0 _! |1 |+ m! i; X. ]5 v/ n43
44
5 H3 p- G7 Z8 x7 @# z+ S: c45
( P0 J( X- `# E+ ?7 P46
47
6 o2 b; w4 j+ Q% k48
49
50
51
0 ^/ u" O- D3 [52
" M+ H/ d' {" B53
& i9 T' l$ `! v0 s' W54
4 t1 q# z$ [) ^7 u6 ~4 q! d8 [55
! y+ G; P# M( n' A7 R5 e56
8 e5 {% Q1 o9 x) b0 _' [3 a57
" m2 J" H6 X) a' n58
59
60
# l5 ?3 G4 f5 U61
3 l; ?7 I9 g* J6 G62
9 Y& P  Q+ M, _* @5 L. B63
64
65
) \2 I) O% }2 X5 F6 l% L66
+ q7 P4 p$ v4 W. C9 u/ I67
68
6 N' h/ ~4 h9 Q+ F, @6 |69
70
71
4 @# T# \: k; q( ?72
73
# O* I7 M. R" ]& B1 w  D6 ^  J5 B插入排序
简单解释：
最简单的理解就是打地主时我们拿到牌后的整理过程，从第二个牌（假设我们拿起来这个牌开始比较）开始，（说下升序）从后往前比较如果比前面的那个牌小，就把牌往后移动，直到找到一个合适的位置（这个位置的前面的那个牌不比这个要放下的牌大）就把这个牌放到这个位置，慢慢的前面的部分变得有序，直至全部有序即可。
5 N  B* \3 F$ [" O& N% O3 s
. K0 F9 g( p' I- H2 K; C9 f


) G# O4 V! i. _+ Y
; R; r2 O9 g8 w$ P$ v
完整代码：

3 y9 t; F( n4 T4 B$ L+ [+ D/ H
package com.keafmd.Sequence;


/**
& A! N* F5 p0 a1 O+ W2 c  T% `8 m * Keafmd
5 ]5 Z$ k; q- r  X( t" f% D *
3 t1 o( H9 u2 D; T# r, {: t1 m * @ClassName: StraghtInsertSort
# {4 Q7 x4 S# i) R0 R * @Description: 插入排序
$ R: D( k  u8 b* e; C * @author: 牛哄哄的柯南
0 J" H, I/ g3 a; M8 {; m3 h * @date: 2021-06-24 10:36
*/
public class StraghtInsertSort {
" R" p* j" `; F  O    //插入排序
3 l2 s) I, x( F    public static void straghtInsertSort(int[] arr) {
        straghtInsertSort(arr, true);//默认进行升序
    }
0 C8 z! s7 V3 C" R" b
) v( f5 X2 [" U
3 W: z# C* `5 d  Z; c- y    public static void straghtInsertSort(int[] arr, boolean ascending) {
! {# ?: L0 n4 V! V& m; |

        for (int i = 1; i < arr.length; i++) {
            int temp = arr;
8 l3 w" Z0 l1 ~& T* s0 M: E8 q            int j=0; //这就是那个合适的位置
7 b* `+ o( F0 @            for (j = i - 1; j >= 0 && (ascending ? temp < arr[j] : temp > arr[j]); j--) {
( A9 R4 o! j" b3 V9 }                arr[j + 1] = arr[j];
  K$ d: t% v" m" r            }
            //把牌放下，为啥是j+1，
            //是因为上面的循环遍历到不符合情况的时候 j是合适的位置的前面的那个数的位置
            //有点拗口，但是就是这个意思，看图方便理解下
            arr[j + 1] = temp;


, [% S" }) ^1 c7 @$ [: f

        }
" y  F% `+ w( ]' G* m

& t7 ?; C3 o0 x* u    }
}
1
2
# L% B2 M$ }7 J& @8 H3
4
0 F7 P0 u; D, S2 B. k+ R" y# G5
) ]/ i) B8 k$ K$ z- S! R% Q, _6
7
3 k& l6 j! i5 U% p2 b% p8
9
# n% w9 U' I# i& D7 ]10
4 a* {& }( E0 _+ \5 v3 m$ [11
12
13
, u  H% ]1 C+ T/ _6 D9 C14
15
6 k* h  K8 v& T" \16
, x0 m1 P  k) p9 D17
2 z- R. F+ ?$ r( D9 m18
19
20
2 z4 T% o0 u5 e, o6 E4 q6 a21
22
23
24
4 C2 Y& y" G% f5 u25
26
27
3 I/ Q5 _3 f! O8 r' l28
  H% B) e, V. F4 J6 p2 |29
+ w. G3 Z( ^  O& Z  ~5 S+ u' A30
+ q3 L3 n+ Q7 x* N4 a+ e" I0 D31
32
9 g; i' ]+ H. I- R* a. e$ ]33
34
7 x/ e# ^+ B* k$ @/ Z8 R7 i希尔排序
简单解释：
希尔排序是插入排序的改进版，我们理解一个叫做下标差的的东西，也就是下面那个图中的增量d，初始下标差为arr.length/2，然后继续/2，对在同一下标差（相当于把这几个数单独拿出来了）的若干个数进行插入排序即可。
. R0 U% E9 s6 _1 U5 S
( @1 p+ j2 f$ M3 i8 {
) ]2 E! g$ ~( @' ]
8 t- i+ y: M# H5 U# c) ^
9 }" R1 j( I) U* k# n5 G

  [0 E7 G  J9 U$ u) O完整代码：

6 X: k8 h5 R7 h% }2 H+ X$ d5 c
4 o, F4 u8 v& z7 V4 \4 x  dpackage com.keafmd.Sequence;
6 z" V: C: x& q# D# @
( O2 Z  r" m) A. g% n8 }- p
# n. A2 f9 w% W$ g/**
* Keafmd
*
* @ClassName: ShellSort
, ?% a1 Y8 ]1 ~* j! _ * @Description: 希尔排序
8 K1 e5 k) k) z2 W6 [ * @author: 牛哄哄的柯南
0 M! ]6 F1 A) `% J3 t * @date: 2021-06-24 10:39
2 U8 p( P% L+ h' o */
public class ShellSort {
0 F# |, X, K4 G; j9 X2 G

$ w$ `% A; i& q" C, C9 `7 z    public static void shellSort(int[] arr) {
        shellSort(arr,true);
  E, N) Q7 [; Q0 a5 ?+ s8 P    }
' J$ `8 f% v& W" u/ c6 [& F' i

" O$ x7 O& Q" `- r5 h: y6 U    public static void shellSort(int[] arr,boolean ascending) {
" @4 k- q) h, f
$ {$ P! A' [) S4 ^4 l
        for(int d = arr.length/2;d>0;d/=2){


" S1 B' n* x9 R( o8 s4 u* S$ `; O            for(int i=d;i< arr.length;i++){
, [, b# Q1 k3 v                int temp = arr;
: z1 f8 w: ]' M  g                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;
# x" v4 v! S) G: K  }9 P; i* v            }
) c# k5 O" z1 y3 s+ C, E  R) y        }


    }
* [( R' D& {$ w" F}
1
2
3
6 Y7 v% h2 V( k  o7 D0 g6 u# d4
5
6
7
2 Y  V- A: f* p3 Y6 X. D' @( D8
, ?1 E2 d. n$ t+ U1 v0 z9
+ M. ?7 }2 D' h1 w10
! L' V( P# t8 c. @% p8 F11
12
13
14
15
2 _8 t6 ~3 D, v# U1 `# O$ b16
+ h0 c; W( s9 d0 b7 W. ^17
3 u) M4 L/ A7 c18
$ n7 q$ N. d0 A# Q2 n$ b! a19
$ [3 {: U1 M# {20
2 ]1 Z/ M  ]* t6 d) g21
22
23
  J2 j! K6 R4 _& s* F+ ?24
25
5 t4 W$ C; v, X8 m8 a5 s26
27
  h7 q, v. Q) w3 X28
29
9 Y5 K2 O0 V3 B30
31
: Y8 I2 j4 e& |( e32
4 D2 ~  f8 q3 q! ~8 i/ ?4 v" f$ ?计数排序
& E* |) c% {* s/ L1 W, U/ Y简单解释：
这个排序算法看名字也很好理解，就是就是额外找个数组来计数，然后在这个数组从小到大或从大到小把数取出来即可。

2 g" ~7 q: M5 V& v1 u$ ~& |) j/ ]. T
) C2 W+ B$ {/ U

$ P2 ?! C6 U" o# j! Q

# n1 U8 i2 J$ U$ F# H完整代码：
) m/ p" z- \4 g2 g' O( s* n! f. q% m$ b
" d/ b' m3 S5 @+ c
7 E! E  ]- T- F" U; vpackage com.keafmd.Sequence;
( F* s  V! h! K0 v+ U
" I+ d& n7 W4 g
  W% `: @* r9 u/**
* Keafmd
*
& A- |+ l1 ^8 I% S * @ClassName: CountSort
* @Description: 计数排序
* @author: 牛哄哄的柯南
* @date: 2021-06-24 11:31
*/
3 I& t9 _- L6 [6 {4 Epublic class CountSort {

" @5 w% V0 `+ D# K- Y
4 ?9 [& I) h! I    public static void countSort(int[]arr){
        countSort(arr,true);
    }

" ?5 n' f: Z, h/ ~: W( L, p" b
    public static void countSort(int[]arr,boolean ascending){
/ t, B) G, |  V; Z, G4 x        int d,min=arr[0],max=arr[0];
( Y7 m9 n, L0 O

# }& e1 A7 v: A- ]        //找出最大、最小值
5 M! x; r8 L8 Y) }5 B4 s3 ~+ w        for(int i=0;i< arr.length;i++){
            if(arr<min){
* f) ?5 v8 W: [5 i                min =arr;
- s) `  J( G5 M( K/ H            }
. l0 u/ \( s% C; j- u3 X            if(arr>max){
0 O8 [0 \; J/ }, U$ s  N                max = arr;
8 G) Y9 X; N+ s4 N            }
! W! h( ]  p& |% O# y        }


        //建立一个用于计数的数组
. Y+ x( W  U4 X& H% Z        d = min;
: h* x% b" }4 A0 S( H7 c& X4 r* h        int[] count_map = new int[max-min+1];
        for(int i=0;i< arr.length;i++){
: S. n# m' y8 C1 T, D% Q: T            count_map[arr-d]++;
1 c: Y, [) x# a# I( c5 z0 A( H        }

- p* W% K- w' j# _- K
        int k =0;
: o, H6 @& @" ~        if(ascending){
            for(int i=0;i< arr.length;){
. e% ]! l; `7 U1 t( m& N4 f3 p  A                if(count_map[k]>0){
                    arr = k+d;
                    i++;
                    count_map[k]--;
                }else
( ?2 Z4 }( |+ {8 P1 V+ M                    k++;
6 W- K+ o" [) s7 ~* x. p+ P            }
# u! B4 n" e* f        }else {
  S6 j- ?3 x5 E! Q! H* V4 ]            for(int i=arr.length-1;i>=0;){
1 W- p- d: G7 N/ S; N                if(count_map[k]>0){
2 A$ s& F) p. p+ {7 O                    arr = k+d;
                    i--;
/ ~8 R; `# r: I0 U! R8 x                    count_map[k]--;
                }else
3 l& Q) m  V2 W                    k++;
5 z" A$ n- V1 I( i" \            }
3 {. B8 o  s1 A5 e        }


    }
; F% y1 r+ J7 A+ M2 v}
1
0 b% F( p1 k. R- \+ F4 w2
2 R. e% _% v6 ~# m  s) C0 v3
/ n5 k: A' k( X, `, j: Q6 e" Q4
5
4 x6 p7 U9 s1 V2 I6 D6
7
8
( D% q* f; N9 l4 ~9
% i, i5 A' q- `% I10
; n/ n5 c6 q$ F* t0 p11
) _: l/ D: j3 B% \/ [1 q+ {; z12
; f6 c& C$ c) ]8 @8 ~! V; }13
2 t1 n* ]  |6 c# i14
& k- O# _4 X/ f* h15
) G: E6 F; g! L- C16
, f1 c& @$ J7 @6 n' ]17
18
3 Q0 v  o/ b: d+ Y2 J6 g+ t1 z19
20
21
2 H4 J7 N, _! i6 T( ~5 S5 ]/ j# [22
23
  A  F$ X8 B% l2 u24
' ?; w: d! Q3 V6 F* W25
26
27
, x8 T. F* C4 ]% x' ?9 \+ X28
29
6 l( h$ G, ]: M8 n  h1 {30
: y' M) V/ a- f: C31
, ~) W  G! b0 x2 c) d. ?& [32
33
34
35
% [4 }: e8 }( D$ K& W- t; y, V36
3 @9 y8 ]3 p: F0 d. y2 F37
4 A! t* T( p) k- e; M38
39
40
41
42
43
44
* G3 G4 q6 |5 A0 r4 K6 K45
46
: {: N$ {/ E0 S5 E. w3 a2 H47
48
49
50
  g+ E* t* |9 o# G8 F" Z2 @6 h51
& C& t4 n1 }9 H1 z2 W# W% v5 ]52
53
# P( G# a' c- ^5 D5 l: @54
55
56
3 n# a. r$ m! o* M0 ^57
/ ]  K  n0 U$ Z58
6 u# {& L5 x7 x' O' B59
桶排序
简单解释：
: P8 G  ?/ _6 K9 T/ Z# A就是把一个数组分成几个桶（其实是几个区间，从小到大或从大到小的几个区间）装，然后让每个桶（区间）有序，然后取出来放一起就可以了，相当于把几个有序的段拿出来放一起，自然还是有序的，当然需要是按照区间的顺序拿了。





. ?/ i& s1 d0 F0 c! L# M
& @1 ?! {; Q2 V; |$ p8 V完整代码：


package com.keafmd.Sequence;


; j' [3 e$ f0 L4 d, Q( D: z9 kimport java.util.ArrayList;
import java.util.Collections;
8 V: P* P( `/ A+ [, {* W

/**
; n" p8 ~+ E" i * Keafmd
: X3 I% k+ J6 _  V9 ?: i *
8 E/ Y! d' |0 S9 x * @ClassName: BucketSort
* @Description: 桶排序
6 \8 E! H7 r: N6 |# N7 X * @author: 牛哄哄的柯南
* @date: 2021-06-24 13:32
, \* ]4 b& g4 _- M1 g9 Q& } */
public class BucketSort {
9 O' n8 g& j/ C2 ~

    public static void bucketSort(int[] arr){
        bucketSort(arr,true);
    }
9 g7 w% d% {0 ~6 D' d3 n& W

    public static void bucketSort(int[] arr,boolean ascending){
        if(arr==null||arr.length==0){
7 S% b- D6 k. L5 j' C- n' E  s# n            return;
        }
2 Q  \' i3 i& r( U        //计算最大值与最小值
) j/ e9 g3 s6 Y8 V/ r        int max = Integer.MIN_VALUE;
        int min = Integer.MAX_VALUE;
        for(int i=0;i<arr.length;i++){
8 z/ |( j. z8 U% [  f$ q$ ^% a            max = Math.max(arr,max);
            min = Math.min(arr,min);
        }
/ ]: `1 B* L5 H- X2 p# q

        //计算桶的数量
" m& [$ q5 k: r# Y        int bucketNUm = (max-min)/ arr.length+1;
4 S" b4 Q" R# T) h        ArrayList<ArrayList<Integer>> bucketArr = new ArrayList<>(bucketNUm);
        for(int i=0;i<bucketNUm;i++){
            bucketArr.add(new ArrayList<>());
  U9 m8 \% u9 \; C  Q2 o        }


  R# ~. f% Z$ m        //将每个元素放入桶中
1 }5 D9 Q! o6 o0 n, T3 z0 T        for(int i=0;i<arr.length;i++){
            int num = (arr-min)/ (arr.length);
& e  Q/ C9 l. O3 g' g# L5 d4 m            bucketArr.get(num).add(arr);
" `, b0 O/ Z7 M        }

8 r' n5 z* a; N5 P$ T1 V2 t/ C
        //对每个桶进行排序
        for (int i = 0; i < bucketArr.size(); i++) {
. K# i7 B+ D0 p) Z% J            //用系统的排序，速度肯定没话说
            Collections.sort(bucketArr.get(i));
4 o9 l& k; x( e7 y* d# c% v        }


        //将桶中元素赋值到原序列
        int index;
9 ~. d+ G# G8 S, T% ?0 b" x        if(ascending){
4 R- g; m3 r/ `* R+ C5 i            index=0;
        }else{
            index=arr.length-1;
5 @3 v. L' d' G: O        }
3 p3 A8 ?. Y" M# S- j$ D
: n* Q& D# X8 g2 d( n
        for(int i=0;i<bucketArr.size();i++){
6 h3 e5 c8 C; G4 y$ T7 K            for(int j= 0;j<bucketArr.get(i).size();j++){
                arr[index] = bucketArr.get(i).get(j);
; u8 Q* A) c4 w' I- j0 c+ T( O2 k" k                if(ascending){
4 o; q& N5 G; Q* X8 ?/ k% `- f                    index++;
5 y/ B3 K% [# h+ B* E* X3 F5 P4 J% l; r                }else{
                    index--;
( I6 L7 k0 o# X- A$ e5 u                }
- p! J. V. D3 f* r7 d) m            }


        }
# |! ]" p  C! K: A7 N
! ^- `( }& h  f& Y
    }
2 }. |; G: O, r& J$ X}
1
2
3
4
5
6
7
9 m2 y5 r& M+ ~' D' S5 \8
9
3 M) g( F- g  N- R+ o8 K10
11
, K' v  K! \& B+ O! f12
13
14
9 c9 U" k+ x3 i; p) r  u15
; b4 t. V: ?/ {$ E/ a16
17
18
  l, k( F8 j& g! P$ k% a  T& U19
20
21
) o7 ?# w" b2 Z3 k' n22
23
! o- d# ^. v: f$ x$ v( e24
25
26
27
28
. v' ?( I/ V8 y8 ~4 [! g: L. z" E29
7 ?! h! T- H  |0 V" Z8 K/ R1 J" @30
) ^! D/ P9 H2 I- r$ @  O31
32
: y; D3 b# U  J  d3 m8 Z, @! \33
34
- C8 ?' |" c2 z3 h6 h* s" Z35
36
4 q: M+ o* e( d. ?4 y37
38
8 ~. W  L2 W! P9 b& f8 ^/ m39
40
41
42
43
44
. G) c+ i1 A7 z: |7 ~3 F/ a# ^$ b45
8 F: u' h& u) y' N' C9 C+ [6 g, L$ c46
47
% A9 D- o; _; b( L! V) X48
49
50
51
52
53
54
5 T* l, f9 Q8 f: C1 a4 I+ {55
56
3 A! A! n: y4 s$ ?# t0 p57
1 e4 C# g/ l- }& e58
59
) H9 o' y# [& J3 H' J' o' `6 w60
, A+ \& y0 I! M8 y% a0 x61
62
63
9 `, _7 R) d7 E! C0 U& n4 A6 ]  _/ @64
& ?# p2 e3 n3 X5 e65
/ L0 r1 _/ s  G# j2 B66
67
68
69
' y3 g0 _3 s# s: e. X70
2 G4 z5 i* R, D71
72
基数排序
简单解释：
首先说一下，我发现好多人写的基数排序只能排序正整数，其实只要处理下就可以排序含有负数的了，就是我们排序前先把所有的数整体变大（就是减上最小的负数，也就是加了），都变成正数，然后排序好之后，在减下来（加上最小的负数，也就减了）就好了。
基数排序就是按数位排序可分为LSD（从最低位[也就是个位]开始排序）和MSD（从最高位开始排序），下面写的事LSD基数排序。
基数排序就是把数按位考虑，让后我们一位数只能是[0，9]，就是我们在考虑某位（个位、百位· · ·）的时候就只看这个位的数，放到在[0，9]相应的位置，然后顺序取出，最后再按其它位这样操作（上面说了要不从低位开始到高位，要不就是从高位到低位）

% u/ v1 l1 o: w9 \& r3 ^6 j* V


- F" u* u$ X* {

完整代码：

: r% q$ V! D0 p( ]5 q
package com.keafmd.Sequence;
4 [% m( X6 [1 n3 x) z$ G- f
: w5 W( B. i: ^; H
4 D" t) i. A8 W  l2 z4 a/**
6 B2 D% T" d" s * Keafmd
8 u) e5 u  p; `* G$ ^8 Q; B *
* @ClassName: RadixSort
* @Description: 基数排序
* @author: 牛哄哄的柯南
( F# V# D6 V( l2 ?; `0 R * @date: 2021-06-24 14:32
, P1 K/ x) h5 b( b# W4 b */
public class RadixSort {
    public static void radixSort(int[] arr){
3 l) R, @# u5 }, Y# @        radixSort(arr,true);
6 U4 F7 G# m5 A$ A    }
' P+ n/ n8 z1 Q1 ]    public static void radixSort(int[]arr,boolean ascending){
        int max = Integer.MIN_VALUE;
1 C+ r3 S( ^0 |% d/ C4 ?& ^( v: }, T( N        int min = Integer.MAX_VALUE;
        //求出最大值、最小值
0 J7 y2 y2 v, e! t! x/ L9 J        for (int i = 0; i < arr.length; i++) {
            max = Math.max(max, arr);
            min = Math.min(min, arr);
% h) `* x$ ^7 h4 J8 z. V9 S        }
        if (min<0) {        //如果最小值小于0，那么把每个数都减去最小值，这样可以保证最小的数是0
            for (int i = 0; i < arr.length; i++) {
                arr -= min;
            }
, h- H7 o; `8 h- H: R9 T            max -= min; //max也要处理！
        }
        //很巧妙求出最大的数有多少位
7 S' \! @# T; [3 g7 y6 g        int maxLength = (max+"").length();
) e9 {. }# l0 _# P, ?        int[][] bucket = new int[10][arr.length]; //一个二维数组，一维代表0到9，二维存放符合数
7 y9 v  u9 t4 b5 ~8 ]( l4 G        int[] bucketElementCount = new int[10]; // 用于记录0到9某位存在数字的个数
        for (int i = 0 ,n = 1 ; i < maxLength ; i++,n*=10) { //个位 十位 百位 这样遍历
" k  g# I1 x5 V; ]& C            for (int j = 0; j < arr.length ; j++) {
                int value = arr[j]/n % 10;
                bucket[value][bucketElementCount[value]] = arr[j];
3 L6 B7 i. I( {/ A                bucketElementCount[value]++;
            }


0 z. J: z; i6 W  K( y  g            //升序
            if(ascending) {
                int index = 0;
                //从左到右，从下到上取出每个数
                for (int j = 0; j < bucketElementCount.length; j++) {
                    if (bucketElementCount[j] != 0) {
& [1 N8 y8 c6 |                        for (int k = 0; k < bucketElementCount[j]; k++) {
                            arr[index] = bucket[j][k];
                            index++;
                        }
                    }
) k1 v. ?& a' S                    bucketElementCount[j] = 0;
. @" r7 M/ `9 Z# H) e; B* K                }
            }else { // 降序
8 v" W" q1 |7 r                int index=0;
                //从右到左，从下到上取出每个数
" g! x/ W, S0 Y( r0 X7 Q                for (int j = bucketElementCount.length-1; j >=0; j--) {
                    if (bucketElementCount[j] != 0) {
/ R: L3 {4 @0 ~8 Z0 p! R2 Z* O( U                        for (int k = 0; k <bucketElementCount[j]; k++) {
                            arr[index] = bucket[j][k];
                            index++;
/ F- l# [0 c0 a: G9 m) g& v2 N8 T# Y( d$ c                        }
                    }
                    bucketElementCount[j] = 0;
                }
9 r$ A  {4 p- F7 Z! q. _            }
8 e5 U! b% B( D, s& I

3 x4 c8 [; ?! s5 j' N: d

0 u" w4 [* n& A            /*for (int i1 = 0; i1 < arr.length; i1++) {
3 y8 h! g' U3 Q" K                System.out.print(arr[i1]+" ");
            }
4 q9 I0 C! n& X) R$ v! u5 E+ d            System.out.println();*/

1 B5 G4 C, f) l( N, u
# u& R; _' R. Z; }( J5 j


' a5 C) [# o- l( F3 J. f5 R
% K/ z8 A  i# ]) E        }
7 l% x( z5 @; r1 _0 d' p        if (min<0){
9 L5 a! g. Z: b" ^: @) ?            for (int i = 0; i < arr.length ; i++) {
- I+ V* F: Z/ G+ ~                arr += min;
            }
        }
! [! {# L6 o6 V8 K; |  `

    }
5 S' N7 `6 d, A" E9 Z9 _6 ?' p}
1
2
! V! D% P4 }  V2 V% L* d4 f3
4
5
+ z0 u1 \2 d. Y* @6
7
4 `* v  H3 e, L  k8
- J7 Y9 z/ h' n% _9
10
11
12
13
14
15
9 g( a8 U) v3 n7 }; Q# n16
17
18
% g: ^3 O/ _( _/ Q7 N3 X7 u& {% f19
20
/ N: J; _( }: B; L1 X4 s" F. ^7 }21
22
23
# @; g# b, X5 O. L. I6 J5 I24
" W# I  C1 z. a; r# |- x  Q% _25
26
' w) d$ m+ r( p8 b6 f" I, `8 ]27
28
% S7 n8 w4 }5 e5 F0 ^/ \+ U8 y29
; m, t0 g. b+ X2 ?1 Q" b30
31
32
33
9 G/ ^) a, N5 L# L$ N34
35
36
37
& L) L. ], {4 @+ k1 A38
7 k* x* [! u3 m, P3 N; Z39
1 I# u, t- K% F& O  ]! p40
7 _; m4 }" [; j  K& a( I41
' j3 Y" q. P6 _42
43
- w$ S9 l3 D2 W9 M( |5 Y9 c: P44
45
46
47
48
: Q- M' ^9 F4 K49
" E2 E8 M% n9 ^50
' e" g' D0 a/ Y* a5 F51
52
) p5 ~- K- e  z$ _; O$ v6 y53
54
55
& [# P/ z; D3 o3 q# ]56
9 `* ]  K6 a7 u  b8 P& F& r57
58
9 Q" @0 u5 ^+ A$ a) j) Z. y1 W6 c59
3 z7 M6 S6 Z5 U. R60
. M2 c) G. n7 s- ^0 L1 z- i$ g61
3 E4 c, d) B  D, N6 I. p62
* {# r+ R; F. M9 X( f63
64
65
* o* F8 X& m& r66
67
68
69
! W% ~, ]4 ^1 X) a& J2 b70
( q9 p9 K* {2 n# i2 f9 }71
72
73
  \; D% b0 @5 X" ~: E- D' c74
7 p3 `* a! U! ]+ G0 _5 }75
76
77
9 b: `$ ]/ p8 p: K7 q) M78
79
80
81
82
83
$ z# P6 A0 ?& n+ `) K完整测试类
package com.keafmd.Sequence;


import java.util.*;
" V8 M6 G  m! Eimport java.util.stream.IntStream;
import java.util.stream.Stream;

1 u$ ^3 C% C& h- W" O: t( L
7 \' A; u& d. n( i/**
* Keafmd
*
. }# U9 C% ]' s8 Q: [" i. O * @ClassName: Sort
* r$ W2 M0 Q7 Q4 U2 h2 U * @Description: 十大排序算法测试类
: z6 O/ s+ J& r/ m) U * @author: 牛哄哄的柯南
* @date: 2021-06-16 21:27
*/
public class Sort {

1 ~  X, d: J* X, m8 q& G7 _% w


    public static void main(String[] args) {
  L& t/ |- O0 k% p% a" n

        int[] nums = {12, 4, 25, 47, 58, 34, 25, 9, 99, 26, 1, -13, 162, 10093, -66, -1};
//        int[] nums = {12, 43,56,42,26,11};
        int[] temparr;
* x8 b; s6 e3 q  ^5 Y

        //利用系统Collections.sort方法进行对比
" N# j$ U: W& g6 c

% |4 m8 f4 [$ ^" V        //将int数组转换为Integer数组
        //1、先将int数组转换为数值流
        temparr = nums.clone();
        IntStream stream = Arrays.stream(temparr);
" ?0 \7 v% a. D  x8 h3 a5 b$ y        //2、流中的元素全部装箱，转换为流 ---->int转为Integer
3 m1 ?* I6 s( z& d        Stream<Integer> integerStream = stream.boxed();
; U7 |' C$ M, L0 ^        //3、将流转换为数组
" V0 T) g9 y5 R        Integer[] integers = integerStream.toArray(Integer[]::new);
; M& C3 @/ r; R$ p+ j        //把数组转为List
        List<Integer> tempList = new ArrayList<>(Arrays.asList(integers));
* G0 v; K; _- g8 l# _9 R( h8 N        //使用Collections.sort()排序
        System.out.println("使用系统的Collections.sort()的对比:");

1 P( D! o3 M1 [0 J7 V
        //Collections.sort
        Collections.sort(tempList, new Comparator<Integer>() {
            @Override
$ ^7 H$ d2 U3 H# D            public int compare(Integer o1, Integer o2) {
0 t$ r( i1 c2 M9 y" u/ s                return o1-o2;
                //return o2-o1;
            }
1 J- P' ^/ V9 O4 c# i        });
. O1 h6 j- _+ \5 w7 \+ v: |* v" d

. `) f6 c: H7 f        //tempList.sort 也可以排序
       /* tempList.sort(new Comparator<Integer>() {
            @Override
            public int compare(Integer o1, Integer o2) {
+ E/ S6 G4 h* ]2 q                //return o1-o2;
                return o2-o1;
* e3 X) ^! K6 W6 Q1 h9 c            }
2 k/ a- e6 L% j2 f3 F5 ]4 i6 m- d, `        });*/
" j1 W6 f' G" v! l7 t" d
; w, O7 h, h  P& F2 v' m6 V
+ ~4 j  c6 i9 y; ]7 l        //遍历输出结果
        for (Integer integer : tempList) {
3 P1 C. `6 S% Z* x! `. ]            System.out.print(integer+" ");
$ v) E8 m* Q: u0 F2 y/ {$ w% g9 P+ s$ e        }
% W# D1 Z9 W, p4 z
' F; s2 ]6 G0 w0 f6 Q* J
        System.out.println();


! i7 R6 T8 J. K6 B, A4 z        //测试冒泡排序
+ o3 ^7 `" M* T3 F: r- r2 G9 ~        System.out.println("测试冒泡排序:");
. i( t8 _$ B7 ~+ i) g        temparr = nums.clone();
% U* E+ D; c3 y+ w: k" \6 Q6 W$ r

        BubbleSort.bubbleSort(temparr);
( e- @2 Z9 f* ?
" ^( C1 |3 t: _
        //降序
        //BubbleSort.bubbleSort(temparr,false);
3 @4 f, K) h6 w8 t0 }3 s2 i& z
1 E  _  p4 r/ N6 X
        for (int i = 0; i < temparr.length; i++) {
/ f$ _$ W; |- X- S( i% I            System.out.print(temparr + " ");
6 ?/ J; A0 f( i        }
        System.out.println();

+ t- t6 h; K  H6 r
! `8 O/ i% Y" d+ m* y5 t) r, ]3 n/ }6 H        //测试快速排序
        System.out.println("测试快速排序:");
        temparr = nums.clone();
        QuickSort.quickSort(temparr);
        //QuickSort.quickSort(temparr,false);
        for (int i = 0; i < temparr.length; i++) {
            System.out.print(temparr + " ");
        }
6 O( I; D* N" M7 C7 O) F        System.out.println();

% U" c. R& Y2 r' p) B
( ]; a3 h" i) n5 P9 p1 C' K7 H        //测试直接选择排序
        System.out.println("测试直接选择排序:");
        temparr = nums.clone();
        SelectSort.selectSort(temparr);
2 y* g# G+ N' E: E  V+ D* X* |. o        //SelectSort.selectSort(temparr,false);
        for (int i = 0; i < temparr.length; i++) {
            System.out.print(temparr + " ");
        }
, [! }4 q8 O- H$ H, R8 Z        System.out.println();

+ c: C. E. e/ B# m; G9 @9 r+ w$ Y
        //测试堆排序
: w" j/ T; B. A9 P$ w# ^, a: `- c        System.out.println("测试堆排序:");
# @% w' E' E: C' Y        temparr = nums.clone();
        HeapSort.heapSort(temparr);
" g1 L- Q& m3 B4 I% J        //HeapSort.heapSort(temparr,false);
; A4 d4 [, A% T0 r/ r7 T        for (int i = 0; i < temparr.length; i++) {
0 T' t. [& `5 L4 `            System.out.print(temparr + " ");
0 c" W9 E* O. z" [: b. I1 U        }
) v/ @' \9 p4 ?6 ?" ]$ \  Z) t1 e        System.out.println();

6 v- t7 |  `4 J
        //测试归并排序
        System.out.println("测试归并排序:");
        temparr = nums.clone();
        MergeSort.mergeSort(temparr);
        //MergeSort.mergeSort(temparr,false);
. V- b) `! t7 U8 e4 M. ~        for (int i = 0; i < temparr.length; i++) {
            System.out.print(temparr + " ");
        }
. u1 m. R# D" e3 U, c% l        System.out.println();
& _5 \' V: {7 Y" Q% H$ d0 X
/ y/ q5 e2 S# T$ a: H* s' C; W
( V$ o) \/ x! R0 Z& e        //测试插入排序
& @4 w( z2 m5 {! E" E; _# B6 s% u! W; I        System.out.println("测试插入排序:");
        temparr = nums.clone();
        StraghtInsertSort.straghtInsertSort(temparr);
        //StraghtInsertSort.straghtInsertSort(temparr,false);
        for (int i = 0; i < temparr.length; i++) {
4 v9 h0 D" Q7 @" Z1 f            System.out.print(temparr + " ");
6 l; i  e; _: J4 ?; r1 s( a2 o        }
$ \8 T" a! p" M' ~! w        System.out.println();


' Y# M) M- B/ {/ p9 h
* n( Z0 Z% ~8 f' N) M- a* b4 o
- a) v; L8 ^0 e6 a4 T/ C! r        //测试希尔排序
        System.out.println("测试希尔排序:");
1 e% t0 k, ~8 q6 ~        temparr = nums.clone();
        ShellSort.shellSort(temparr);
        //ShellSort.shellSort(temparr,false);
- I: w; \, F# K9 M        for (int i = 0; i < temparr.length; i++) {
            System.out.print(temparr + " ");
        }
        System.out.println();
% D5 h$ {* g; p/ ^


) y# ]/ S1 W. Q9 Q, _
0 u2 E: N1 h) @7 x9 ^: s7 }        //测试计数排序
0 `' {7 I/ _' E' d. o5 E        System.out.println("测试计数排序:");
1 y" j+ n; R( }        temparr = nums.clone();
# S9 Z1 j" }4 M9 j        CountSort.countSort(temparr);
        //CountSort.countSort(temparr,false);
        for (int i = 0; i < temparr.length; i++) {
5 H6 m( i7 U6 E0 e& W            System.out.print(temparr + " ");
        }
8 ]' y$ Z- X7 Z( x6 \  O7 u( l6 g        System.out.println();

$ D' i. _4 [7 x" k) ]4 p, C" t


        //测试桶排序
5 b; b1 H( E5 O" J* H; n        System.out.println("测试桶排序:");
- d! R; g' x+ P2 [- n& Z+ t+ H' X        temparr = nums.clone();
/ Z. Z& S7 g0 X- y# J3 O6 m        BucketSort.bucketSort(temparr);
0 c3 e, E$ X0 ~. {3 Q        //BucketSort.bucketSort(temparr,false);
2 ?2 M7 `/ W* _* [6 v+ V' d# G/ n        for (int i = 0; i < temparr.length; i++) {
            System.out.print(temparr + " ");
        }
        System.out.println();
. ~9 e% _# ?' {2 b4 P6 ]* F5 h
, c0 m& M# _2 w  x/ J
        //测试基数排序
' V: m! z# @) A& M) }& R1 A        System.out.println("测试基数排序:");
4 @- O! X6 ], o3 w" a' M% N/ @4 R7 l        temparr = nums.clone();
        RadixSort.radixSort(temparr);
        //RadixSort.radixSort(temparr,false);
1 _" k1 i" [! e        for (int i = 0; i < temparr.length; i++) {
8 |( Y; E; |. s# q            System.out.print(temparr + " ");
        }
        System.out.println();
3 t. x% g, j  g$ _! P8 r

' ]2 W0 t1 k+ _; ?  R0 D    }


}
& ~4 b' _2 \3 S1
0 q& b% F# w7 o2 U2
3
4
" f7 i3 U0 Q, m! P# o3 F  s, F5
4 {) m% R3 b! C/ b8 k6
& N# d* X8 A6 u( b# K7
8
9
% f' b  t9 f, j- B10
) h* O$ w4 f  _7 x% c# H+ D11
, B4 Q" I$ z: m8 y& ]3 A12
: E  p7 J# e  H7 q13
1 c2 k, _- w3 o+ n14
: Z- Z# y( \& D: O1 c3 ~15
16
17
- C: K! P6 k2 h+ f* ]# t7 b/ w4 x18
19
20
, }! o( s+ u! ], k. b21
# v# w+ ^! |' s% C22
23
/ [  u* ^% D. U+ t24
25
26
0 |+ L1 R4 T5 v$ n% P+ H. \, d/ g27
% z/ n: a3 y5 b+ Z# g4 ]: T28
29
30
31
, y1 i  W6 f" s1 Y/ @3 \32
33
34
" H9 P) r% D9 w8 w& j* \* v35
36
9 J0 Q& V$ l, p, c37
38
6 G8 [5 u1 e  a0 j5 [; _+ x5 j39
40
41
, R# k. U/ f$ c, f3 ?! N6 r- k5 m1 _42
+ ]7 n% B- M3 }+ u: D/ B. g7 ]' P43
# ~# I8 e  r4 {" `44
3 G+ ?9 F0 G1 A  w8 h9 T+ I+ z45
46
7 Y- T$ L: Y( w6 U  l  |1 y47
48
+ n+ W$ V, w9 |7 y) {: Y0 q* z49
; M6 @+ G9 C% j, M50
51
52
53
5 o7 i' T" P! m1 `, M54
55
' ~0 D1 Z. g1 K; j7 ~56
57
' h3 B  _3 i3 b( K8 C58
59
# L2 S+ ~" v: Q+ `, ?5 X60
% _; Q; U( K) G7 G61
62
5 p$ I3 }5 s6 Z$ D1 `2 P2 S+ e  B63
6 |1 b8 S6 Z) F; K$ m( Z& U/ c64
' e+ n$ g8 c3 j  G. G2 `65
: l% k- r8 @; i66
67
68
) W' h% C3 c: Z69
( w; _) @" t& c- F7 |70
% b4 B$ u: U7 o9 h7 n% C1 x7 U71
72
. g3 \/ w+ t$ f0 C0 a" R73
8 S; H3 {3 a1 F6 {4 U74
75
76
6 c" H3 y7 ~" g# R- ~" p8 _77
78
7 Z  L0 }% ]* a+ j79
80
; i3 n, K  z& P! u' o' h6 E81
4 b! h5 T! A( ~4 `82
: l; z! F& O0 ~6 X5 z83
+ s5 L6 Z( x4 w# l4 O3 K84
85
86
! a/ J  A5 ^. U( u. ?87
7 C9 y  F% Z; p88
, l' J$ |; X% `4 Q89
8 o/ Q9 U3 @& v6 m; c90
( V( }2 P- [8 H( e$ ?91
6 q! _6 B( V) j) r5 z92
/ J8 }' ^) J; {/ k. n3 F93
94
6 \+ {7 }( o5 k3 G* S' j0 S0 @9 e5 n95
) P6 {/ Q$ w' k% C$ L4 \96
97
98
- y, x' e4 t4 z7 X# Z" S8 z99
100
0 O) L9 ]8 E1 N* Q! R' |9 G101
102
5 n4 }7 t% h2 ^( I2 H$ p/ L103
104
# k2 T$ W% I1 r# X- R105
8 G4 r' \" Y0 S$ t& n8 }106
107
5 f( k+ f0 D% M108
5 {, _: x8 y2 G109
110
111
# J: t. r" y. _112
! T" z& Q8 I+ j# |* R113
114
115
% H( U$ ^% N( A4 V( A116
117
! c' x" W6 i1 J. Y8 u5 `, ?4 H118
+ I6 S  E8 g3 S7 p2 x119
" ?, H" i5 S% Q- ~- X0 r( f; `9 W/ P120
0 H5 a! c$ d: ]" I( F! s121
; B% H$ G# K0 k+ F: l122
- Z$ @! Z; U! Z- d9 B123
/ g% s  [/ t/ E$ R* z" C" y- N/ z124
125
126
127
+ V' x" c% }7 y( K128
129
130
' ]4 q4 J) _4 Z& V' Z131
132
6 k7 e2 ~! K. a7 Q. }, x! d" O2 p133
4 m' {# ?; c0 ?( c) Q134
135
# k2 W: H+ C# P. [: o136
! J) S4 ^/ A8 k( a# m137
138
139
/ v8 B! L! k) K( o* }- m140
1 W' I- M; z9 o, k! F" I141
+ z8 i' M4 P0 R0 s& @1 w142
143
9 n6 h- y* p4 }. `2 I5 `/ F4 `8 M- M144
145
146
$ H( x  P  W& {& i5 D8 p; U147
148
9 r2 y- M5 h6 s2 v149
150
9 O" y8 n' M1 a5 A151
6 Y0 t. I. p$ n  d1 M( I2 d% W152
5 _- J6 _$ }* u153
! h* `; p, J6 G; \154
/ o7 F( e2 Q# h% V3 p" u4 \+ f" Q155
156
157
158
, ^$ R" r! `$ U# a7 K159
160
161
) @% M8 U& Y7 e+ |# w' B; L162
163
164
" I5 f/ M: y- K& h; ?! Z165
. p! h' F1 B. u* J! m3 ~166
; Y+ x% I, K' _( m% `9 m167
168
169
170
( U6 a' ?7 b0 e/ |171
172
/ Y: m4 x. c& d5 m( V/ j! x173
每天进步一点点！
不进则退！
5 v( S0 z% V  ~: Z" L  I: M, P
4 n$ k* ?5 x/ @$ ~1 G* w2 H8 t
版权声明：
原创博主：牛哄哄的柯南
+ @5 \- ^: P$ L1 P博主原文链接：https://keafmd.blog.csdn.net/
# w  C$ n& t, `% o0 |4 W" n& Z————————————————
版权声明：本文为CSDN博主「牛哄哄的柯南」的原创文章，遵循CC 4.0 BY-SA版权协议，转载请附上原文出处链接及本声明。
' g1 F( Q2 f) v7 F6 g" {: A  d原文链接：https://blog.csdn.net/weixin_43883917/article/details/118193663

) x( g8 U9 N1 K( U4 ]4 t

1051373629

每天进步一点点！