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

杨利霞

% }0 |/ a- |" o. L$ F  \经典十大排序算法（含升序降序，基数排序含负数排序）【Java版完整代码】【建议收藏系列】
经典十大排序算法【Java版完整代码】
写在前面的话
十大排序算法对比
1 T+ c6 l' a7 T9 v冒泡排序
. {) R7 m2 o  c1 U) N快速排序
7 v) V: ~$ f# I8 }# [6 I直接选择排序
3 |% T. |% S  [" i/ N堆排序
归并排序
插入排序
8 w# B3 l" W* W希尔排序
. {% j3 O# X0 G* Y) J计数排序
6 G( K5 y* T! ?. Q  M( g6 A, I4 ?桶排序
8 T9 p/ h! e6 L/ N/ {, v7 z4 @! W# F- i基数排序
( ?, o8 v( R& @' ^7 x- h+ m完整测试类
' I4 |8 b/ J& H( O& ]8 g写在前面的话
       虽然已经有很多人总结过这十大排序算法，优秀的文章也不少，但是Java完整版的好像不多，还存在某些文章代码存在错误的情况，同时也为了自己练手，决定把所有的写一遍巩固下，同时也真诚的希望阅读到这篇文章的小伙伴们可以自己去从头敲一遍，不要粘贴复制！希望我的文章对你有所帮助，每天进步一点点！！！

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

' R% P* g5 C. G+ H$ x
十大排序算法对比
9 {& u, Y- Z4 A8 B  P' @
6 B0 W2 E+ r1 f' |! D. e" U


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

9 g; C( \# z$ H
( Y( j9 F" l* N' Y- i  s冒泡排序
! @+ R6 a8 i' c2 G- c简单解释：
       原理就如算法名字一样，就像水中的气泡一样，每次我都把最大的或最小的放到最后面，这样总共需要n-1趟即可完成排序，这就是第一层循环，第二次循环就是遍历未被固定的那些数（理解成数组左边的数，因为每层循环都会把最大或最小的数升到最右边固定起来，下次就不遍历这些数了），两层循环遍历结束后，所有的数就排好序了。
       两层循环所以冒泡排序算法的时间复杂度是O(n 2 n^{2}n
; x) p# M: Z) m! w2
  a; {/ ]0 S/ o4 r( H3 p )，是一个非常高的时间复杂度，我在下面的代码进行了优化，加了一个标志位，如果上一次循环未发生交换，就说明已经是有序的了，就不继续下去了，反之继续进行下一轮。
# J4 w: i9 H1 i2 s* [$ C
% x0 Q* d$ p$ |+ i0 k

8 _9 L& f# v  D  o- F7 J  g8 |

- [  i3 m( V* x
本文的图片来源网络，仅用于大家学习，侵权联系删除！（下同）


4 {: q  c  q6 N. L4 \& D4 }完整代码：


: `+ c6 r6 L) ]3 H' zpackage com.keafmd.Sequence;

+ N2 Q; E, L- s1 _+ X
' ~: `1 U! [( y1 k7 a  W/**
* Keafmd
0 [$ h9 y" o$ w: Y$ B' f! C. L *
, c3 R% r- s2 F+ ? * @ClassName: BubbleSort
* @Description: 冒泡排序
* @author: 牛哄哄的柯南
# t( p. J) p# E, k3 e8 h( r * @date: 2021-06-24 10:31
*/
public class BubbleSort {

' j8 A+ @) y8 X# t/ z* V
    //冒泡排序
. ?2 j# L* f8 T    public static void bubbleSort(int[] arr, boolean ascending) { //exchange标志表示为升序排序还是降序排序
, D9 E2 g# L& O4 l
0 [# Z, a7 b3 b# s3 I$ S; H
        boolean flag = true; //加一个标志位，记录上一次是否发生了交换，如果是，我们则进行下一轮，如果没有，说明已经冒泡好了


* p' W: b: z& C2 q  D, J( A        for (int i = 1; i < arr.length && flag; i++) { //控制次数，第几趟排序，只需要n-1趟，有交换时进行，只有flag=false就说明上一次一个元素都没有进行交换


            /*System.out.print("第"+i+"次遍历：");
            for (int i1 : arr) {
1 n5 c! {/ c) ~( I                System.out.print(i1+" ");
            }
            System.out.println();*/


            flag = false; //假定未交换


* U; Y9 \% k' w+ S7 D            for (int j = 0; j < arr.length - i; j++) {


( p$ b1 L7 Z, m6 u4 A7 g% f                if (ascending ? arr[j] > arr[j + 1] : arr[j] < arr[j + 1]) { //控制升序还是降序
                    int temp = arr[j];
                    arr[j] = arr[j + 1];
9 _$ Y" q& T; y+ A$ V                    arr[j + 1] = temp;
                    flag = true;
- O7 x+ C  T) z& N                }
' A/ I4 y8 J2 k7 {- C0 ^

3 `( D' x: f; V0 D% n1 J            }
) `, {3 [1 p1 |: n- |* N8 p        }
7 g+ W' K# h1 Z. f    }


    //冒泡排序 -- 默认不传参升序
+ q4 R4 L/ D" ]3 Y9 L    public static void bubbleSort(int[] arr) {
        bubbleSort(arr, true);
    }
}
+ O" b: R% s" i$ ]1
2
3
4
5
6
7
* |# a% N5 ^: Z% z- P; t8
9
10
11
9 u: u4 e8 C' i12
2 }# A, k% L3 _0 K& V; ]3 o13
14
$ x0 q: m5 T1 {' |0 S. k15
16
4 [# U4 w- d' ^% N+ a. Y. o17
18
19
20
21
& }0 G4 e4 w" G22
* `5 z' O* }# V) w& @; i23
24
25
1 n3 x4 w/ d& {- e0 e" V! U# q  p26
  V- y* v2 ]4 D: U9 u27
28
29
30
31
5 k% ?2 a4 M' w4 `( u32
33
34
- N6 g) H! M0 W! y6 f' V  a8 u& ^7 c35
36
1 z# e% x5 V+ F4 Z2 ~1 B) E( v37
38
+ u1 |; j- m# H- g39
- b5 z5 m' V& K: G1 F4 A% h- p40
' x, e+ R" F% K; F2 v' M' c; {+ y% B41
42
9 J7 R4 v8 x& m( _! W. ^% l6 H43
44
) B% ]" k* Q4 E) I+ R% f45
测试代码：
. }: j, }7 Y0 Q! G) P+ ^- ?5 r: i
  P- r% N: h* E
升序排序（从小到大）


4 g! r; i( h  N  e+ ]package com.keafmd.Sequence;


import java.util.*;
6 }( U5 ^# B, p$ k2 ^; Z* y8 M$ `) y6 Eimport java.util.stream.IntStream;
import java.util.stream.Stream;
( m4 @" G% c/ d  E7 H. F
/ ?9 p' F* E  m: M. b: q
/**
* Keafmd
* k6 g: B0 K0 p% Q; K( i$ D *
  |" l0 q' R+ J/ o& m5 q* e; O * @ClassName: Sort
* @Description: 十大排序算法
* @author: 牛哄哄的柯南
* @date: 2021-06-16 21:27
*/
public class Sort {
    public static void main(String[] args) {
3 a+ Y9 ~, O* e% \

        int[] nums = {12, 4, 25, 47, 58, 34, 25, 9, 99, 26, 1, -13, 162, 10093, -66, -1};
/ T1 c* p1 J8 M7 U        int[] temparr;


0 r- a, k. r/ k( L1 d        //测试冒泡排序
        System.out.println("测试冒泡排序:");
        temparr = nums.clone();
  O8 ]* q* R! p  m  _        BubbleSort.bubbleSort(temparr);
        //逆序排序
; X1 G, h+ }6 r1 V" `4 H/ I        //BubbleSort.bubbleSort(temparr,false);
        for (int i = 0; i < temparr.length; i++) {
7 C* f2 q$ P" f2 h4 ?            System.out.print(temparr + " ");
) y, p) O4 Y+ n" B# U; u        }
        System.out.println();

2 v  F) Y' K6 G, i; G
6 ?2 d2 {! J" Z2 c    }
}
% r% d/ [' S+ A/ M0 Y0 ]1
2
3
4
5
6
* q, T& X) |9 z+ b4 H; \7
# F9 _' N4 {9 D$ {+ s8 P( O3 l1 Q8
9
10
11
12
* T! U/ [' j4 Q1 _3 j, L" c13
7 g/ c$ n' _" J/ Y" k/ t14
15
16
17
18
19
0 e1 G. B2 b2 @% T4 \, L: k: b$ g20
5 L+ Y! |0 v) O9 s. J0 ^, B21
22
* x# I) t. W8 y+ B. @# |; l23
! p3 j* D7 B3 r. W& x  v1 S24
25
. Z9 w% M$ U: j& Q3 d, s26
27
0 ^' C8 g: P; X  ^28
29
$ A0 u) q- t5 |0 y2 k0 A* R2 Q; Y30
31
32
33
' N: V: x+ L. A2 h( d运行结果：
) ]% `# e, m+ B% Z- M6 D6 T
& x1 Y5 i/ X! F! a
测试冒泡排序:
-66 -13 -1 1 4 9 12 25 25 26 34 47 58 99 162 10093
1
0 f1 {/ J- M/ k8 j, v" o5 W2
( J6 t# q/ Z! [降序排序（从大到小）
1 O8 I: C8 U1 W$ V8 L7 w7 ~

/ K! R3 u2 B# q//测试冒泡排序
5 N% v+ ~# s5 A/ u: D5 w) ySystem.out.println("测试冒泡排序:");
temparr = nums.clone();
BubbleSort.bubbleSort(temparr,false);
for (int i = 0; i < temparr.length; i++) {
    System.out.print(temparr + " ");
}
System.out.println();
1
2
3
4
9 k. g' ~) q& M% u5
3 e) A; z" L( e5 A) ?6
7 o; e& D- C0 E: q8 x* m0 u8 N7
. r) K" _# p# `: A+ k8
# W! a' P+ p; @, c3 p2 e8 E4 D! w# d运行结果：
4 _6 g( }8 p7 K* l) _  M9 g# M

测试冒泡排序:
& F$ R" E: ]  ?9 S. Z' S3 D10093 162 99 58 47 34 26 25 25 12 9 4 1 -1 -13 -66
1
2
下面几个算法的测试也就是换了下类名和方法名（换成相应的排序算法），如果想降序就在数组后面传个false即可。我就不一一复制了，我在最下面给出含所有算法的测试类，需要的自取即可。
4 V5 C$ q! \1 o, K; G
; I  R6 W& t" L$ F
2 x$ Q2 U9 ^- F: y- d- I/ V: k- _快速排序
简单解释：
0 @; T! U/ w: O9 J# V) o8 J快速排序就是每次找一个基点（第一个元素），然后两个哨兵，一个从最前面往后走，一个从最后面往前面走，如果后面那个哨兵找到了一个比基点大的数停下来，前面那个哨兵找到比基点大的数停下来，然后交换两个哨兵找到的数，如果找不到最后两个哨兵就会碰到一起就结束，最后交换基点和哨兵相遇的地方的元素，然后就将一个序列分为比基点小的一部分和比基点大的一部分，然后递归左半部分和右半部分，最后的结果就是有序的了。


0 P) K4 a. u$ F. C  r0 q
) P  f) o3 ]' F2 q. c0 \
* M9 u0 f& c4 f" j, E

完整代码：
7 y+ z6 K5 n) m/ j& t

package com.keafmd.Sequence;
* G- P0 n, @) L; F+ |: L1 m0 F
- @# @; B* t, e& `5 z$ J7 \
+ M6 O8 ?/ w5 X. g/**
( U0 A9 l$ s+ ]) x * Keafmd
9 w6 Y) C; O. f* S" _; f0 ] *
+ d8 S4 z/ E+ C/ ]1 t- u  Z) y * @ClassName: QuickSort
9 m5 s" a, K0 f1 Q& q! ~( |: A * @Description: 快速排序
; s, T- N. g. T0 s$ w * @author: 牛哄哄的柯南
  Y1 Z  M" K0 S0 U * @date: 2021-06-24 10:32
*/
6 i$ E& i1 u; V# u% @; X) o" cpublic class QuickSort {


+ ^/ W; Z0 p9 C8 I1 t    //快速排序
0 A! L' t0 t+ h( y( j+ D7 e$ c3 n    public static void quickSort(int[] arr) {
        quickSort(arr, true);
    }
  |7 T. d; ?6 o4 @1 q2 f! Y3 G! w
' p5 X& H( b' }7 h, c
    public static void quickSort(int[] arr, boolean ascending) {
        if (ascending) {
            quickSort(arr, 0, arr.length - 1, true);
        } else {
            quickSort(arr, 0, arr.length - 1, false);
# H% e) |1 T4 K) H, {. C5 ?! I8 y        }
    }
- H- j3 D2 @$ U
( U# W; x+ w7 P! j
    public static void quickSort(int[] arr, int begin, int end, boolean ascending) {
/ d: c9 w7 |. M7 T        if (ascending)
7 }0 I0 r- u* }/ Q" z" e; s            quickSort(arr, begin, end);
        else
2 w: z" M4 z5 K/ C7 L! G) r            quickSortDescending(arr, begin, end);
    }


$ m/ l# G9 b4 W/ Z" w    //快排序升序 -- 默认
    public static void quickSort(int[] arr, int begin, int end) {
' O3 t1 Y& f- ^4 }. {: T        if (begin > end) { //结束条件
) X* c' l  d1 P0 t$ f3 T            return;
        }
( w: r# F- B0 A& }3 [        int base = arr[begin];
/ m+ \/ ?9 C' C- b: m3 p! ^0 h5 U        int i = begin, j = end;
        while (i < j) { // 两个哨兵（i左边，j右边）没有相遇
9 A5 J" s2 ?* P! ?( u8 K            while (arr[j] >= base && i < j) { //哨兵j没找到比base小的
4 {# y6 B' B3 g: j3 J/ t' v  k                j--;
# @- G" i# O! [3 r2 W            }
. z, x- ]; \4 R5 ?/ H3 |            while (arr <= base && i < j) { //哨兵i没找到比base大的
                i++;
$ \5 q) K$ u2 M2 V: W3 _            }
            if (i < j) { //如果满足条件则交换
" V! T: a. l2 f; M2 L% C                int temp = arr;
                arr = arr[j];
2 T) _# ]( m$ w9 S                arr[j] = temp;
            }

4 W8 I5 N0 Z2 ~2 e! W& j
" B! R5 `/ W2 }& Y* d0 x        }
        //最后将基准为与i和j相等位置的数字交换
        arr[begin] = arr;
        arr = base;
1 O' I% @( f8 M* |1 S        quickSort(arr, begin, i - 1); //递归调用左半数组
        quickSort(arr, i + 1, end); //递归调用右半数组


+ G; ?3 b5 |+ B4 @" t1 s; j    }
  I" l, \8 R* ]% t; j
! x& [* n8 w$ s8 o1 E/ u
. W9 t: F9 T! ~- o    //快排序降序
    public static void quickSortDescending(int[] arr, int begin, int end) {
8 V, S8 z0 ^6 E( u! z$ ^9 h% C        if (begin > end) { //结束条件
; e2 C9 g! q; p; t+ Z6 G& _            return;
1 R# ]+ |1 b- h) ~# q! ^1 u        }
        int base = arr[begin];
        int i = begin, j = end;
$ ~5 j( g1 T, l2 c" k: E8 c8 Q        while (i < j) { // 两个哨兵（i左边，j右边）没有相遇
            while (arr[j] <= base && i < j) { //哨兵j没找到比base大的
% F% l; j" h- A                j--;
6 [/ m. ?% Q" C6 K% n            }
            while (arr >= base && i < j) { //哨兵i没找到比base小的
7 F; B" u' C% A% C) Z8 W2 C                i++;
            }
            if (i < j) { //如果满足条件则交换
& `; k  q6 k- ?' @" X$ E; C                int temp = arr;
  {7 U0 ?5 ]8 q# N                arr = arr[j];
                arr[j] = temp;
6 ~& E' C. H7 F            }


3 `1 T# [$ H7 h3 v! g6 ]  P* o        }
        //最后将基准为与i和j相等位置的数字交换
        arr[begin] = arr;
        arr = base;
        quickSortDescending(arr, begin, i - 1); //递归调用左半数组
2 P4 n3 @8 W3 v! p        quickSortDescending(arr, i + 1, end); //递归调用右半数组
2 D3 T- c' Y( L+ o4 K7 Z

    }

7 z5 {! Q$ d6 r% g$ u
}
8 e1 G% G( E" W  ^* ^& u: ~1
; x- n* U/ m# ^5 X+ D2
3
7 h4 B4 Z: e5 b1 n4
5
$ q  ~3 N, W7 Y6
7
; ?/ W( y  ~( j8 X* u1 i' s/ \8
" m/ ~: K" K4 U% n/ x9
" E0 @4 s. j# j# J5 O: q10
11
" w6 Q1 z! U3 w% K7 f. S, Y, ^12
) j+ G( Z3 X! N( A8 i13
7 [3 f$ l, K( }  b! T8 |) h5 Q14
- L  Q2 ?& \6 ~9 n15
16
17
5 w- f4 a, h+ h" q18
% c( d" c3 B0 O7 N: M# q8 W  b& X19
20
21
; H* L2 o( v% l22
23
24
: W' j$ I3 t. l* Z* k25
! Q9 B' z# X# h4 Y26
27
28
29
- p7 Z' f( K4 q30
31
( i0 h3 s/ [' ?9 t32
33
9 e/ G- g6 N& b7 D$ f+ D* R34
( I; ?* i/ o* a7 w2 g35
* |# S. B: N# V36
37
6 V/ V# S$ O* `: K38
39
2 n! B9 P+ }$ u. Y1 A40
; p5 V5 n- r3 i  ?41
& p3 E- W7 g1 W$ M1 X0 j) Q42
- W% R6 M. Y  {- h3 v" @9 s43
44
/ r& b" W. y6 ~. z- s45
& Y' |7 V2 |7 v7 [46
. ^5 K4 |6 _' ^+ H* H$ d6 ?47
48
49
  v- h) g% Y. t5 w" C50
! j! ]% V' Z; F51
52
" @# K; U5 s, p; S53
54
55
  x6 Y6 c1 i& Y2 {+ e- B) s. A56
57
58
$ H( b) ]" b: Z  }59
60
& k& H1 j1 R" V8 H' {61
62
9 R2 S* s* V4 C$ c' M/ `' x63
64
65
66
67
& i! T8 T! p5 I/ @( ?68
69
70
( G8 X) Y( s' z- s5 \% J; c71
4 i! c' o: v! H8 N. _, ]72
/ f, D! [9 a$ i9 J* l% T/ x0 a73
6 _$ ]. ~, U9 g; S/ c) A; C74
" [! a3 N. l% S+ t& c& {75
76
77
78
' ^, ~0 e3 i- p9 V5 @79
8 V1 S* _! ^, \4 I80
6 m, W) P% J% h8 r% y" B" w81
82
9 y- }, S; O$ a6 i( L# B83
84
& r6 I7 X7 W3 w85
7 d. p9 M3 @# W; N. C% t  ?% n86
87
, A' `5 @, B  @! j% D! o88
89
8 O! J8 w+ f" K) v2 C90
# ^. R0 i- h: d91
4 M" W9 j& n. D$ N  ]7 l直接选择排序
简单解释：
9 w: B( e. b1 o* V' L+ _* c7 K% M/ ]( t8 Q数组分为已排序部分（前面）和待排序序列（后面）
+ X' J, }3 p: M' W" f8 V第一次肯定所有的数都是待排序的
从待排序的序列中找到最大或最小的那个元素，放到前面的已排序部分，然后一直找，不断缩小待排序的范围，直到所有的数都是已排序的了

+ |, |( m3 M! ]/ L; j. F, t


5 S* ~  Y  D' f7 ]5 ~

完整代码：

9 `, B0 Y( w3 ?/ q8 `! A
package com.keafmd.Sequence;


/**
0 x" s% g4 m: {, P * Keafmd
" r0 S& s0 l) K8 |; |8 s) ^! W* q, k *
$ y; k! F% {% ]$ B( C# w * @ClassName: SelectSort
* @Description: 选择排序
* @author: 牛哄哄的柯南
1 @( M1 i* d  g( H% `- y; D& d * @date: 2021-06-24 10:33
- O% a; ]: f1 h# n, r$ v */
8 Q6 ]0 l$ i0 [/ W6 t; Y3 Lpublic class SelectSort {


. }3 O% a* L+ ~- n4 `2 A: j    //直接选择排序
. \7 b) O: q2 z' D+ c, P    public static void selectSort(int[] arr, boolean ascending) {
        for (int i = 0; i < arr.length; i++) {
            int m = i; //最小值或最小值的下标
            for (int j = i + 1; j < arr.length; j++) {
                if (ascending ? arr[j] < arr[m] : arr[j] > arr[m]) {
) z( j7 N' d, B- K  Y+ M2 t0 F8 u                    m = j; //找到待排序的数中最小或最大的那个数，记录下标
                }


/ ^3 s" F0 Q0 G+ |! m( s) r/ }            }
            //交换位置
            int temp = arr;
            arr = arr[m];
. N/ C7 G+ N9 ]* K/ s            arr[m] = temp;
7 g1 w6 G* F. N  y- R5 T/ d. K
0 K$ I" O: l  m9 ^" s
7 T$ X+ s* g$ T4 e  I        }
    }
, Q) x  [% s- n: Y8 t3 Q

( M1 K. g- R' [& r; l8 e% x    public static void selectSort(int[] arr) {
        selectSort(arr, true);
! U2 x9 g0 J# t* }+ |5 T    }
' v( q/ T/ ~) G& J$ `4 J# t}
0 N$ ~* Z+ a. f/ d8 l- \8 k1 C1
4 \# `/ u5 H' T) u8 D2 G* N2
3
4
+ g; \- @+ F0 E! H7 X/ C5
# ]6 e, s/ p$ j, V8 G6
7
! w2 g# I0 }) G$ O% [* I8
9
10
' F) u" l& O; A- ^, C4 l9 y* S2 v5 ~11
12
13
14
15
16
17
18
# H+ Z, z6 Y9 ^% ^7 w# d19
20
5 M/ r$ I0 e4 v$ G5 K' n2 w9 j21
9 h% A+ n8 i0 }  f& `$ F$ f7 S, G& H22
7 d" g3 h* B4 \+ N6 ]23
24
0 x' }) h5 l4 K. P# ]& v) I' d25
26
$ k  p! @+ ]* l1 d2 w& M+ d) O" T! n27
28
* V4 q: o. x! j  y9 N' j29
30
0 R/ D3 Q! f0 o! r* p/ r31
# E9 J* h2 E" U$ r32
33
- N) I! {" `8 S2 z: I4 l7 Y2 B) \34
堆排序
9 L9 u/ l) C! N0 Z  Y4 h7 g6 }4 `先理解下大顶堆和小顶堆，看图
" t9 ]6 q8 E, r( h, A; z: k! n大顶堆，双亲结点的值比每一个孩子结点的值都要大。根结点值最大
小顶堆，双亲结点的值比每一个孩子结点的值都要小。根结点值最小

1 W3 J! q8 r% P/ `7 n* o

( N* F# W# r1 T. I- N( o
0 U. \* A8 T$ h; L) w4 m* W9 S简单解释：
6 `% ?5 y6 R, h4 [  `" p' E构建好大顶堆或小顶堆结构，这样最上面的就是最大值或最小值，那么我们取出堆顶元素，然后重新构建结构，一直取，一直重新构建，那么最后达到排序的效果了。
; L; G& y1 A% ]0 q
5 [# N* \8 P: D9 ~/ p7 S! L* y9 {
  d5 P7 y% c: o# N1 j# @7 X( z" r+ D


2 s- e2 P+ p" w
' @3 a$ y8 {! G. S  M" G( D完整代码：


package com.keafmd.Sequence;
, X8 L: a; L- k$ {5 Z+ q

/**
' R1 {9 W  O/ g# r, A * Keafmd
*
4 K: m* `' w, B& R" ]0 Z; m * @ClassName: HeapSort
5 `) M3 L) D! j  s* d * @Description: 堆排序
* @author: 牛哄哄的柯南
* @date: 2021-06-24 10:34
5 y" K3 j6 q0 i# j */
3 I$ ~# f8 z, _) X$ ypublic class HeapSort {


    //堆排序
0 o3 ~  L. R( n  d$ V, ~4 G    public static void heapSort(int[] arr) {
) Z4 e) U' B: i        //对传入的数组进行建立堆，这里默认建立大顶堆，进行升序排列
        heapSort(arr, true);
4 q8 r7 @" f3 r5 E1 v1 \    }

4 B" c& k5 y, z. t) c
    public static void heapSort(int[] arr, boolean maxheap) {
$ i8 f" i2 n6 }, }4 X

3 i( g& K- P5 g2 r        //1.构建大顶堆
        for (int i = arr.length / 2 - 1; i >= 0; i--) {
            //从第一个非叶子结点从下至上，从右至左调整结构
& [. v3 `1 N6 W* f, X            sift(arr, i, arr.length , maxheap);
        }

% s3 M' T+ b" z* L9 k
        //2.调整堆结构+交换堆顶元素与末尾元素
        for (int j = arr.length - 1; j > 0; j--) {
0 I* _8 g$ t2 ^7 W1 a
) _5 l4 {* T; [9 ^, |$ T
            //现在的数组第一个就是根结点，最小值所在，进行交换，把它放到最右边
            int temp = arr[j];
            arr[j] = arr[0];
  u% a8 v( I  X            arr[0] = temp;


            //重新建立堆
7 [8 o- ?6 L2 u2 v            sift(arr, 0, j , maxheap); //重新对堆进行调整
: p! _0 o5 t6 [: J' X        }
    }

  x9 c- N  \) Z! I8 P# _7 O
    //建立堆的方法
" e, |0 B9 a) \7 h    /**
     * 私有方法，只允许被堆排序调用
     *
. q) {6 p, }, l     * @param arr     要排序数组
     * @param parent  当前的双亲节点
     * @param len     数组长度
% \1 e' D& q$ t1 K! m7 P1 J9 K     * @param maxheap 是否建立大顶堆
) m# I2 i% E3 D' ?& L     */
    private static void sift(int[] arr, int parent, int len, boolean maxheap) {
$ A2 r4 u( \! r# Y4 X& @
/ {% u  G8 _9 a
3 _3 Q! b5 Y0 n        int value = arr[parent]; //先取出当前元素i

- Z; C9 ^( t; ?
        for (int child = 2 * parent + 1; child < len; child = child * 2 + 1) { //从parent结点的左子结点开始，也就是2*parent+1处开始
! I$ [9 v8 U0 Z; {

$ }. m5 b4 F' \' a            if (child+1 < len && (maxheap ? arr[child] < arr[child + 1] : arr[child] > arr[child + 1])) { //如果左子结点小于右子结点，child指向右子结点
+ h3 k6 O* M1 H/ p' W                child++; //右孩子如果比左孩子大，我们就将现在的孩子换到右孩子
$ _6 d% V( X8 q* w4 h; t- ~  S! l5 ~            }


, _; a6 H' R. c( J( B            //判断是否符合大顶堆的特性， 如果右孩子大于双亲，自然左孩子也大于双亲，符合
3 p& z5 ^7 G$ ~4 \; \" A1 B: `            //如果子节点大于父节点，将子节点值赋给父节点（不用进行交换)
, @( b' t1 E* Y& L8 [& q! N) F* a            if (maxheap ? value < arr[child] : value > arr[child]) {
% D+ t8 K$ ?, m0 g# o                arr[parent]=arr[child];
# r0 S! `; [7 }6 d# ~8 |+ T                parent = child;
5 ]& H* P$ Q# }$ ^" b4 ]) }; ~& R            }
            else {//如果不是，说明已经符合我们的要求了。
                break;
: z# `. A& }3 s6 U! X& ]            }
" N3 @) Y1 ?* T5 {, {        }
        arr[parent] =value; //将value值放到最终的位置
0 Q2 }$ d6 [7 B  Y- L9 }2 ]
2 k4 K. q- @$ h  Y% r
: J3 w. ]' O( x' R3 V

    }

$ v* T6 z0 M, K
1 d  c$ E0 i. Y8 H+ ?& Q6 k! W: K}
1
2
3
8 ~# h1 i0 Q) V1 `0 J5 U4
5
% C( L# Q5 u' `3 u, e' ^6
7
6 L* f) V( w6 b8 h/ S6 V8
( O$ c) i* R) j, Z8 ^9
1 b6 e. S  [' i10
11
12
& }" q, _3 y, E/ M* R" v7 z13
14
15
, L9 I4 @! q7 v  I16
: y: Z9 c3 n& _1 D; b' c2 Z17
18
19
) y' l4 m8 H9 x4 ?20
21
22
' e4 Y3 q* [: x; B$ V2 M23
24
* |2 G) ~8 b& Y25
3 M9 ]; j. D' e: D26
6 [( _! ^" L0 G/ u% Y27
& s; `: M9 B2 {28
& B: U6 ]0 \8 ~29
- h2 b. N6 x1 _2 Z# Z30
' b" _& A4 l) c+ i7 a. ~31
32
33
34
: f6 g5 A& ]. h35
36
1 H7 @. B/ _/ h37
( K! E& ?% c" Z38
1 n- k3 v* U! T& j0 |4 e39
$ }# M. w' ^; V" L$ S8 x9 a* x40
9 h4 c: ^$ O* w5 n& b41
. m7 N% a! |4 V$ k3 |+ e4 N. q42
9 W+ U1 y& J+ R0 c: W43
44
9 G8 I( s4 m+ O9 `) \+ _45
46
47
48
1 J' @4 Q& z3 q49
* y, ^3 y) K& N) n% k( V7 H# k' C. w50
51
52
% ^& I1 K/ e# K. |/ N; W53
54
  _8 ?: l0 ^! @4 t5 |; b0 F55
56
( h: b6 z% {0 {1 R57
! I$ E5 u  `. I1 r58
7 X! Y, V; h2 `2 c6 ~5 K6 L59
9 x2 _( c* d% z( W+ W" y60
9 J$ ?) F9 F3 M61
62
7 t3 i6 ~( R& Z- x- d9 U) [4 K/ y+ W63
; o+ O, T( P) G0 ^: v& ]8 J  C/ l# d0 p64
65
66
: O. [; ]  q& H8 y0 k67
68
5 u7 Y2 L, E0 ]9 j6 B69
, A! E( U( K) C2 L2 a$ O: a70
71
72
! V2 ?: n% c3 J5 X, O5 ]. z3 Q73
3 T' W" u, k4 Q8 |2 q74
归并排序
( ]  O# P9 @" w+ b! j! s& o) I1 l简单解释：
. F$ J& V1 ]  t2 Z该算法是采用分治法，把数组不断分割，直至成为单个元素，然后比较再合并（合并的过程就是两部分分别从头开始比较，取出最小或最大元素的放到新的区域内，继续取两部分中最大或最小的元素，直到这两部分合并完，最后所有的都合并完，最后形成完整的有序序列）

+ m3 M; ~( X1 t, G0 M$ s2 e0 w
; n; ^# f7 b' ~  U0 g
4 O: ]& a  g( k- T* O$ u( D* X- `/ b
9 v7 d( |3 r  ]$ Q6 J; a

7 T+ R- |* A( c  f9 }3 ~* H完整代码：
. L; e* Z' o/ L# t. g# C
! H, {- z7 p& i
package com.keafmd.Sequence;
7 b0 Z" |0 R+ g& v( j# Q

5 r/ C) `$ r- f4 K) G/**
, t0 J9 F$ P; o. \6 |4 I5 u. N, G- \ * Keafmd
*
! D& J. d8 k# Z! { * @ClassName: MergeSort
, k! u# R) l- b7 l9 H4 H. H0 _ * @Description: 归并排序
2 [2 a3 h8 ~; z+ V- V: o/ i * @author: 牛哄哄的柯南
: \4 s7 c5 x" w0 U0 k' o * @date: 2021-06-24 10:35
*/
public class MergeSort {
: b9 {, y" H1 C2 z$ u5 x

    //归并排序
    public static void mergeSort(int []arr ,boolean ascending){
4 v9 r, c. o3 f2 t( T8 Y        int[] temp = new int[arr.length]; //在排序前，先建好一个长度等于原数组长度的临时数组，避免递归中频繁开辟空间
/ j$ l2 n* @, ^) r% F& e        mergeSort(arr,0,arr.length-1,temp,ascending);
    }
    public static void mergeSort(int []arr){
        mergeSort(arr,true);
    }


    /**
. V6 j. W- ?3 }4 z9 _     *
0 X1 t3 \5 M- p7 q: @! L- [3 c     * @param arr 传入的数组
+ [% Q/ e/ _" q& L# s     * @param left 当前子数组的起始下标
     * @param right 当前子数组的结束下标
     * @param temp 拷贝暂存数组
# C# }5 W3 G$ h) B2 Q     */
2 p1 r6 U3 s, u. `5 R; y+ K    public static void mergeSort(int []arr,int left,int right,int[] temp,boolean ascending){
- n! e/ U: z# i$ e        if(left<right){ //这里是递归结束的条件，我们是对半分，那当left==right的时候肯定大家都是只有一个元素了。
+ ]- @+ o6 {( V# r! q' z. {1 X

& ?" p* R- A8 P- h$ h            //对半分，比如总长度是10，left=0，right=9，mid=4确实是中间分了，0~4，5~9
            //当长度9，left=0，right=8，mid=4，0~4，5~8
            int mid = left + (right-left)/2; // 防止越界的写法
            //int mid = (left+right)/2;
1 r( [" O5 U/ F6 ?

            mergeSort(arr,left,mid,temp,ascending); //左边归并排序，使得左子序列有序
            mergeSort(arr,mid+1,right,temp,ascending); //右边归并排序，使得右子序列有序
% @' ~3 Z& {6 h" H; ~2 x

3 a* j% \3 i8 `            merge(arr,left,mid,right,temp,ascending); //将两个有序子数组合并操作
        }
    }

  N( S# Y! c* B2 Y
& q* X# x. y4 R; q+ |& w+ Y5 I    private static void merge(int[] arr,int left,int mid,int right,int[] temp,boolean ascending){
        int i = left; //左序列起始下标
% N! N6 p  ^) t  _        int j = mid+1; //右序列起始下标
        int t = 0; //临时数组指针
        while(i<=mid&&j<=right){
1 P3 A4 G, O( w& u2 y- q2 s            if(ascending?arr<arr[j]:arr>arr[j]){ //比较两个序列第一个元素谁小，谁小先拷贝谁到temp，然后对应子序列下标加1
                temp[t++] = arr[i++];
            }else {
                temp[t++] = arr[j++];
            }
        }
4 h( l% ?: }3 G/ t3 l' ^0 V& i* z

$ O3 c% c  V: g" ^+ R# {( }  d6 O        while(i<=mid){ //将左边剩余元素填充进temp中——左序列有一些数总是比右边的大的数
  U$ n- O- v  h7 t0 v' R* j9 i            temp[t++] = arr[i++];
        }
$ P3 |5 }3 O8 a7 l
9 i5 f7 C' f' H& ^9 n6 f- a! g) J
        while(j<=right){ //将右序列剩余元素填充进temp中——右序列有一些数总是比左边的大的数
            temp[t++] = arr[j++];
  L$ L) A9 N" t' N; M        }
' J8 i" \% x6 ?( p- L. N9 q7 N; q
% N# ^* O( `$ B) B# E+ v- q
8 s( z8 u6 q; P9 q$ R. Q  B        t = 0;
5 T- h) G( {- f  ?2 m' {9 y( B
! ]* E- C7 A( A2 r5 ^
        //将temp中的元素全部拷贝到原数组中
        while(left<=right){
            arr[left++] = temp[t++];
' w7 d9 f+ Y5 ]! a  h0 p        }

# ?2 f  e" J: G- u) n% T$ |
' ?' q  H# H0 w    }
' w7 @7 Z' k$ K
  Z" F$ |0 R. f5 @
}
: c' b' O, ?7 H& t6 ^/ l0 `1
2
% q5 `6 W# B0 b1 s( h4 W3
1 g" B8 D9 Q; X" K4
& [7 R+ z/ a) g% U+ _: u5
6
% C, e9 S$ y" y7
8
9
. c/ P7 V9 |% I6 {" ]1 Y10
11
; o# T# @9 U/ o) a& p, Q- J& ^12
# U. J" [0 q1 M9 |13
14
- R4 v, K1 a2 m" v" w. ~15
16
5 e+ x& w  b* r6 g: z# V17
18
19
: d: M5 f/ ]" N" t, V6 ^# I20
- v$ o' c9 `: W4 k9 ]% s' J21
22
23
24
6 M7 A( u5 N- b2 J4 g0 w25
26
$ ]3 A) D/ [( t+ S( h27
2 N4 P7 G# Z' F28
0 l+ M2 h" m( h# J29
30
% J- L- a8 D- K6 z* b! N7 W31
; ]. b  s; e& j3 i! ~& ?32
33
# V1 I4 ~, e: Y1 T3 t, ?1 M. [! r34
35
36
37
38
9 b6 h, `! N2 J- g39
/ h% f- R) T" o1 b& ]40
& _( B, d) J0 M6 H: c' {41
4 F! v) \$ k6 H) K6 X42
# \* L) \$ V  b; r4 b/ T43
44
- v  s8 V: x" N" a+ \45
46
7 u+ g( x3 O/ W, Q; f; [' j47
48
% z2 _$ B$ C6 G1 z, k. R49
; X5 ^. j! g- o, u  f50
51
52
- S9 @6 ]: u9 o# F6 @53
54
55
56
8 }, y& \9 x. q57
58
59
$ p# B' n: |- j9 x4 |60
$ {* U% L( p3 }0 u61
+ D, l: i$ S. \  U& D$ {: ?' S/ p62
3 l" `, @3 G. H5 Q! V63
5 S* ^- s; c8 N! o  R64
65
66
. j! p' ]  }0 K0 R. w4 P! i8 b67
0 n. d. _* [- G$ v4 g; U' S. {- a68
69
, u0 e  |- I1 o, O7 r: d- y70
71
72
' W5 b% o8 K. P% T73
% e1 T8 E" @( n& U1 \插入排序
简单解释：
; ~$ P/ @  }2 |( U% I7 h最简单的理解就是打地主时我们拿到牌后的整理过程，从第二个牌（假设我们拿起来这个牌开始比较）开始，（说下升序）从后往前比较如果比前面的那个牌小，就把牌往后移动，直到找到一个合适的位置（这个位置的前面的那个牌不比这个要放下的牌大）就把这个牌放到这个位置，慢慢的前面的部分变得有序，直至全部有序即可。
3 ~$ u0 u+ R- y2 x
) g. u! `# D9 K
" G: {) _& A) B9 v2 T! E
. Q, ^) M# j! e+ H3 b3 l7 o
, H1 X; ?# H5 D9 y+ }! V6 i4 w
- t1 B& t  A: j+ w9 Q% |
6 Q& v  l) S1 A# C& P$ t; k  S完整代码：

7 e) |5 h' _3 d6 i- q% Y
package com.keafmd.Sequence;
8 W5 X# P& u7 b' I! V

/**
# y  n5 T# w: ~0 Y+ o, x * Keafmd
*
; a" J, {6 M3 |1 l/ ~ * @ClassName: StraghtInsertSort
* @Description: 插入排序
* @author: 牛哄哄的柯南
* @date: 2021-06-24 10:36
*/
, F( u) M. A: c! n, H- Q' _" W9 ypublic class StraghtInsertSort {
( @2 @, w; u5 o" b: b9 X* O" G9 B3 o    //插入排序
' ], R2 a; f0 ^; J4 l5 z( b    public static void straghtInsertSort(int[] arr) {
( K. Q3 Q& _& \$ U7 Q2 _$ Q        straghtInsertSort(arr, true);//默认进行升序
    }


    public static void straghtInsertSort(int[] arr, boolean ascending) {

: s, j3 {! W6 L$ t' \$ A! x
        for (int i = 1; i < arr.length; i++) {
            int temp = arr;
) A* k6 A; m/ z2 J3 N/ ^            int j=0; //这就是那个合适的位置
* P/ d9 e/ ]9 ^. x            for (j = i - 1; j >= 0 && (ascending ? temp < arr[j] : temp > arr[j]); j--) {
7 ~& N6 ^  Q5 v, \/ f" V1 Q4 z                arr[j + 1] = arr[j];
4 [6 b0 N$ u2 s/ P% Q: @            }
            //把牌放下，为啥是j+1，
3 S) q  f$ ?- v3 E            //是因为上面的循环遍历到不符合情况的时候 j是合适的位置的前面的那个数的位置
            //有点拗口，但是就是这个意思，看图方便理解下
& `7 [8 Z( R9 w& E; |$ U" I! \            arr[j + 1] = temp;
% \# E, G1 f0 m5 H

. `# ~) o, ]+ |0 J" j9 s; ?
" s  e% D, H" Q( H& q+ q
/ u' N& ^* Q$ F: \" M! v2 j        }
- b8 @  i/ P& h  L0 e! u

    }
}
9 J6 j- w0 L9 W+ D, _1
2
% R! D0 m: F+ M4 i& l& L- \' f2 n' l6 a3
4
% X+ x) v. M" a5 j6 ^8 q5
& M1 A2 y4 h3 \3 o  W6
7
8
1 ~" U% t% s  w$ y0 y9
10
+ w4 y) U, H! v11
12
" u. }6 |! c5 t7 b5 g- [, F, d13
14
5 p/ d1 B$ b3 T7 K3 j15
16
# ^! T% m$ c' ^) i' p17
- u1 E7 e5 g& ^  Y, e18
1 i5 i# K1 x) `. m* n/ k/ \( p19
20
' C% B8 W8 k, h8 X+ S1 ?7 r21
' |1 R7 }9 q0 r. I( @- y22
. x! |# x" {+ S  a; ?% N8 h23
4 Q& h* q& u& L* e& I) c& V" g( D24
25
26
3 l/ X* h% R. G7 n- t3 {- `27
28
29
2 x% A( J: T0 ^3 ]6 N; p30
) K) r! Y1 u3 J* Y31
32
+ U( c$ e9 T8 X; s33
34
: \# ?* s8 X4 F; d/ Z/ q希尔排序
7 Z8 r# Z* [7 s' f) n简单解释：
) t, G- j8 Q1 o; l" r7 |3 Z" C/ Q希尔排序是插入排序的改进版，我们理解一个叫做下标差的的东西，也就是下面那个图中的增量d，初始下标差为arr.length/2，然后继续/2，对在同一下标差（相当于把这几个数单独拿出来了）的若干个数进行插入排序即可。

; e; \+ v; j# `0 _( j2 C
" N: c, f2 T' w8 J1 p
1 i8 q5 f  l9 v0 ^+ ?

% A8 e! p% Q1 E: J* H
完整代码：
1 t1 x; t6 |" }0 [! x5 \

/ g# H7 L; P! R# }: N: N+ {package com.keafmd.Sequence;
1 B5 z2 L8 f9 D& O

6 q# }" s/ g$ }* w# [' Z( E( Y+ Z/**
* Keafmd
) g4 q4 v8 J6 w- Q- m' f *
9 a# r9 M3 z4 V2 \6 u4 P$ y * @ClassName: ShellSort
* @Description: 希尔排序
) d7 q7 u/ \/ f2 l4 x$ S * @author: 牛哄哄的柯南
: c0 C4 A% m  z4 T, ]& h1 u. j( ` * @date: 2021-06-24 10:39
*/
public class ShellSort {
1 S" s1 o* ^, c
1 n- O  J7 X) ~2 |( a
    public static void shellSort(int[] arr) {
        shellSort(arr,true);
    }

0 U8 \6 O: f) T9 L; C
    public static void shellSort(int[] arr,boolean ascending) {
0 H/ z! x& F' X6 w0 f

/ v1 j8 o  P$ J4 I        for(int d = arr.length/2;d>0;d/=2){

7 O4 j# j5 K7 o  k( L: n7 \
7 k) M- I$ P+ y! P) X* ]            for(int i=d;i< arr.length;i++){
$ b' o9 ?" Y  Y6 E                int temp = arr;
, u8 z6 u" z- p! ^; M                int j=0;
                for(j=i-d;j>=0&&(ascending?temp<arr[j]:temp>arr[j]);j-=d){
                    arr[j+d]=arr[j];
4 c& r1 H4 P" S$ `. L% M                }
  O+ F, Z+ o! E8 f; T6 @4 g+ \                arr[j+d] = temp;
            }
        }
+ {0 D) L. x1 P: U; E4 e

3 T0 j: y' Q, w% h' q# Y    }
) K. F  e; P' S}
' A1 o; t' I; o  q( E% M* N1
, z- }; H' q7 G( I2
7 ]0 ~8 ]8 B! ]: F& I* }3
3 Q4 E) O6 {/ {/ r. a1 Y4
5
- B/ S7 A+ m, I/ D) S+ u6 T8 O6 t6
, [# O$ n8 r- N7 t; t3 d0 O7
( }9 k" _1 _8 L& A% W% s8
# |4 V! l3 v: t6 @2 A3 L9
7 g( X- B1 w$ L& l+ |& D10
- q! A0 r' I4 M11
3 X* }3 m% V/ v12
' U9 e1 g5 o: E13
$ f$ ?' i' ?; r7 h! h. _5 i" p) H% t) n14
15
1 m; L6 s- ^2 J& b3 j! L16
17
5 {* b& e2 h' c; k18
19
20
: U7 i* L$ Q% ~& t+ D21
& r2 C: Z7 U! e22
23
9 R4 |/ A5 @5 u; L" G" N24
3 b" ^8 Y  ~* Q: c9 v; n1 _6 T, }25
26
! J( \$ q2 P0 F/ M! s27
28
. y! ?% N8 F5 j" p6 y29
) O6 _" q1 }. j$ L8 ^30
0 o& f% c% f* k0 W& @6 h0 i0 M31
6 U/ W8 l/ f% R) v32
计数排序
简单解释：
; ?# L! X( b% Y7 j这个排序算法看名字也很好理解，就是就是额外找个数组来计数，然后在这个数组从小到大或从大到小把数取出来即可。
; p9 \. O* K( Q8 r
; n' L) B0 [. J" v0 g



: a$ s' R2 f& ~# {! ~! L
完整代码：


# X, S" h: I: Z5 d2 upackage com.keafmd.Sequence;

1 X1 V& |& J2 B& X! t: G" c
1 }7 M7 [( Q6 H; L2 F/**
5 R' V7 A; z7 H2 z. r1 W9 y1 c * Keafmd
2 q2 d) F* H4 V" i: C: | *
( v$ i! B+ ~- _1 T6 Y) u+ X# T' B * @ClassName: CountSort
* @Description: 计数排序
: z) A+ X* }/ V" a! n. _ * @author: 牛哄哄的柯南
* @date: 2021-06-24 11:31
*/
! N; {! q7 M% l# [  \; Wpublic class CountSort {

6 P- Y+ K7 u2 M6 w
) h8 h3 E+ y; e7 C1 F4 h    public static void countSort(int[]arr){
* }: U0 G, j' _4 b+ R4 V* |        countSort(arr,true);
( h7 v& k/ M; H$ }, c( K    }
5 P# A. H, j& w0 l  m# U* C

    public static void countSort(int[]arr,boolean ascending){
" k1 B8 j/ Q" K  X1 a) G: \" b        int d,min=arr[0],max=arr[0];


0 r8 x- I( q6 _0 x0 j        //找出最大、最小值
! e& z' n( ^" K: [+ w        for(int i=0;i< arr.length;i++){
            if(arr<min){
# y* p7 T9 z/ {8 p6 g/ E                min =arr;
            }
            if(arr>max){
                max = arr;
6 e6 U* o% p9 i! q0 Q7 j& y6 Q4 N            }
        }
) d* b$ v  [- K; [, [
% i0 Z8 k7 l9 L/ }  K$ T5 ]$ H) W
        //建立一个用于计数的数组
        d = min;
        int[] count_map = new int[max-min+1];
        for(int i=0;i< arr.length;i++){
% i5 e. R5 z- d+ L0 K' {' {/ F            count_map[arr-d]++;
) U* i$ T8 D8 F        }
8 |# j5 n6 e! S

. w; B* u+ P" p: i9 W$ Q3 y        int k =0;
4 A& g/ C0 [% Z! Q6 E! ~5 r        if(ascending){
6 i0 m4 a2 Z! o3 r            for(int i=0;i< arr.length;){
! J. J3 F4 Q8 d                if(count_map[k]>0){
- f9 p/ a. G) k6 F$ Q1 y% z' J                    arr = k+d;
) R9 R. r4 n4 I: }9 I( t                    i++;
5 }6 u: X+ \* ]4 a+ w8 j! V                    count_map[k]--;
& t' p. v3 W3 V, Q/ m' @. d                }else
                    k++;
8 {  I0 L+ I/ h9 m            }
- w( @5 J: F" b( U$ O4 V        }else {
. h& ]- Y- U- @* }% S            for(int i=arr.length-1;i>=0;){
) b: r5 {0 G$ E) A                if(count_map[k]>0){
                    arr = k+d;
8 e% L8 y+ L1 z                    i--;
. J/ n. C( V* E$ v                    count_map[k]--;
                }else
* o9 H5 V% u9 a8 o" x9 I% Z- L) c/ r* A                    k++;
            }
$ b9 x) l/ ]$ F% `9 ]+ w" R+ X. r        }
5 O2 X4 C$ f0 f. m7 C
; t. j: ?9 g: K  I8 ]: o$ Y
0 b% K# r5 [$ i" Y8 D1 |) R# V    }
: [9 C3 K5 [& O5 Z}
- |6 g" D, s! [$ |& h  |1
2
6 e4 j3 c; F* V+ s  b7 Q# B3
1 x- P* N* \, @* a7 X( Y! `9 ?* ]0 O# T4
5
, S  I" @3 @$ ?8 l6 R; j( d$ \6
7
8
9
7 q! z  b! f% a4 p1 c10
. ]7 V7 }5 _4 t2 o; N11
12
- b: t3 a  V4 \0 `- p) B13
3 }6 o! Z% H+ q1 D14
+ y1 r9 u1 S7 x15
16
6 ^/ }( p/ B. w7 Z: @8 K17
! X5 b; H- f! _18
19
  {3 V# n0 w4 v( u20
21
2 j' v4 t  M0 `6 c! l9 l1 c: b22
23
/ r% H+ Z- x$ L7 K24
25
26
27
28
29
30
6 z. j! e: G. \: W- [31
32
% G, y2 v' a8 M. u; z! _33
. C* A: E, h7 Y0 R& P9 v34
3 O& i( e( q) ~" `# d: d$ Z35
; X* X- b4 l. `: ~. x36
# g4 \# K# j- a5 E5 `7 r, L+ y37
7 `- d$ y: @  D& H& S38
) y* y/ V0 v- m: j2 Z39
# K  S) r! c4 l; m40
41
42
+ s8 j( g. D. c% f7 J43
44
3 a! a3 _2 a4 I8 I45
& O  C) F% r, K6 d4 c, ]46
47
48
, e  t8 X5 Y1 k; E; E2 Y4 s9 [' _49
# y. l/ U4 h% J. c50
51
( }; I' `6 {# l7 _52
53
3 N' o5 ^/ D" ]54
55
56
+ W+ j; ~1 j. K0 x57
58
0 H/ W5 Q" s/ a( E59
桶排序
简单解释：
就是把一个数组分成几个桶（其实是几个区间，从小到大或从大到小的几个区间）装，然后让每个桶（区间）有序，然后取出来放一起就可以了，相当于把几个有序的段拿出来放一起，自然还是有序的，当然需要是按照区间的顺序拿了。





7 Q: d' J+ f1 s- ~+ t+ t
完整代码：
, h* C$ s& H$ g

package com.keafmd.Sequence;

+ G2 J. e0 z1 r7 T! a9 Q
7 ^* L' }. O& Y% @# c' c8 Mimport java.util.ArrayList;
& P& }/ @) {/ p" Q& y6 rimport java.util.Collections;
0 o# [0 j8 K: b' U; P3 s4 r
' d6 R* q8 V" T3 T2 v4 m
/**
* Keafmd
; W! V# v* D& H4 v7 m& L+ e *
+ |4 t8 ^$ `6 z; i' s2 j * @ClassName: BucketSort
( B3 ^* z! w! ]$ Z" S: D * @Description: 桶排序
, @2 m% M) k5 m- } * @author: 牛哄哄的柯南
3 J* C# _+ N2 `; _7 z7 M * @date: 2021-06-24 13:32
4 m4 v0 o- V' d */
public class BucketSort {

2 E$ D5 G8 I, F% j4 k
    public static void bucketSort(int[] arr){
        bucketSort(arr,true);
+ I: I* ~# a( {: v" c    }


    public static void bucketSort(int[] arr,boolean ascending){
3 [" v, T5 f, b; ?+ I' F        if(arr==null||arr.length==0){
3 n1 X) G: ^/ W            return;
        }
# [0 r: D2 m/ n8 J        //计算最大值与最小值
        int max = Integer.MIN_VALUE;
) L% ~% f% L/ X        int min = Integer.MAX_VALUE;
        for(int i=0;i<arr.length;i++){
            max = Math.max(arr,max);
( |( p5 d1 J$ U. ^* v- b            min = Math.min(arr,min);
        }


8 e8 X: e, I" T+ W- a6 y        //计算桶的数量
+ f0 T0 ]% k1 J+ O        int bucketNUm = (max-min)/ arr.length+1;
        ArrayList<ArrayList<Integer>> bucketArr = new ArrayList<>(bucketNUm);
+ q/ Y( }( Z" C& C, c) y0 ^( h$ X        for(int i=0;i<bucketNUm;i++){
2 w' m7 N1 ~! ^8 W  }            bucketArr.add(new ArrayList<>());
        }


$ d* h8 ^5 \+ v  z        //将每个元素放入桶中
( ~  j$ m9 o* q3 f1 o        for(int i=0;i<arr.length;i++){
            int num = (arr-min)/ (arr.length);
5 {1 `2 t" r3 D9 O& H            bucketArr.get(num).add(arr);
        }


        //对每个桶进行排序
        for (int i = 0; i < bucketArr.size(); i++) {
% }3 P9 q& I3 ~  Y1 D            //用系统的排序，速度肯定没话说
( j9 {  J4 j1 z+ q$ Y+ I7 z            Collections.sort(bucketArr.get(i));
        }
4 A# F6 q4 @# L+ O  C
- t/ [9 w2 F* f/ C% I8 u
        //将桶中元素赋值到原序列
7 t- w4 C1 ]8 I2 C$ S3 Z3 i        int index;
        if(ascending){
            index=0;
        }else{
            index=arr.length-1;
% T9 [! N1 {  S' Q4 v- m* ]( ]        }

4 I+ ?; p& f$ i( Z/ [
4 I( Z5 u0 V3 b8 w! z3 m  |        for(int i=0;i<bucketArr.size();i++){
+ J1 k2 [1 j; G            for(int j= 0;j<bucketArr.get(i).size();j++){
3 {1 h3 Y; S, P                arr[index] = bucketArr.get(i).get(j);
  T/ _7 w: [- h2 c0 x5 |2 m$ E                if(ascending){
                    index++;
                }else{
) m& w7 k. Z  I" l! I' N                    index--;
6 r2 z6 ^+ o4 I( i2 h6 Z# A                }
            }
) C# o0 S! F4 X5 X: s& \

        }


    }
# c6 \4 j: L  I}
+ a5 f! o1 ^" D9 L1
; u( m& E2 W+ [7 ]* x% G- k2
6 A; c) h# y- D" |0 |' P4 A/ r3
4
5
6
. Z. g1 H0 w" z/ W7
& n  g, w5 t) I' X5 E" B* E8
" ~' S7 O: N6 k# r4 m9
+ R5 t- S% \1 a: @) W  v' E% Z10
1 H! M6 w2 E" v5 w11
12
13
; c5 S- _2 d! R: E$ E14
" G" G3 _# d3 S9 o: ?15
* I1 h/ k. j. k' {16
: S0 Z8 _8 J+ g. w: z( ]17
/ U% |" ?2 S& u- a+ J+ A18
19
5 X/ x: s: |  c8 ]$ N20
: V. a5 l; Y; x5 K: b# ^4 [21
$ [; k& ^9 W& p) h22
. U7 a' E$ _& {* ~& x0 q  |3 f23
; n; b- B/ h% z; ]9 |24
& m* u% d* b6 U& e% E25
26
0 ^! g( N" P  u27
! p  B5 r$ R2 c! A28
29
  R! W/ j$ B3 g$ @30
31
32
33
. K; V( b# N% H  t34
35
36
; _3 L# A. U# G, h9 N- z" @37
3 Q4 S1 I$ c* X# W38
9 e( K$ ]7 |/ @' E" z1 ^39
40
41
' o% q  m' p) U1 M/ W' L42
43
  p& Q& v* {" `" o/ S44
45
$ ?5 Y) ^1 |& e3 s6 n# F46
47
) T& {" T$ }0 @: s  H6 |9 `48
49
3 W! f# ^' o" ^% E6 j' V- I50
2 G: n6 z5 O# {51
52
- ~4 `: f2 n7 m+ m# ^53
) _( ^# J! m1 Z; t$ x( N54
55
, ~+ a. n/ x$ ^6 k1 @56
57
& q; Z. g$ ^, k7 `" O% ^6 h58
( W$ o$ y2 F* e& C9 r59
60
# U% M2 u1 j6 g  y61
5 p2 R# _, E5 U# X. j1 W0 B62
" g7 p0 h0 Y4 w& T9 \63
8 l* q$ r3 K9 ]. \64
65
66
67
! ?' R% @( a: Q68
69
9 h- |; M9 x' t70
: U- M/ R; Q* L2 {6 T) q71
72
, a; U1 t. t9 u/ ^基数排序
简单解释：
, F3 C- L# C/ t) r. @7 b3 _首先说一下，我发现好多人写的基数排序只能排序正整数，其实只要处理下就可以排序含有负数的了，就是我们排序前先把所有的数整体变大（就是减上最小的负数，也就是加了），都变成正数，然后排序好之后，在减下来（加上最小的负数，也就减了）就好了。
8 A  v( M: j" X基数排序就是按数位排序可分为LSD（从最低位[也就是个位]开始排序）和MSD（从最高位开始排序），下面写的事LSD基数排序。
3 `# j0 t$ Q. X+ l1 s基数排序就是把数按位考虑，让后我们一位数只能是[0，9]，就是我们在考虑某位（个位、百位· · ·）的时候就只看这个位的数，放到在[0，9]相应的位置，然后顺序取出，最后再按其它位这样操作（上面说了要不从低位开始到高位，要不就是从高位到低位）
9 l" \# v$ P; ?
8 \2 P  T$ e. B( l% L

9 S( X! D* k" j! U4 `


3 ]( I1 R8 m3 V& z完整代码：

. p- o) |8 p3 k
package com.keafmd.Sequence;


/**
" w! K, @7 k. l1 r, Y * Keafmd
*
$ A' D* D$ ~  ?1 e4 M1 I * @ClassName: RadixSort
* @Description: 基数排序
* @author: 牛哄哄的柯南
9 }) Y/ Z* ~3 M* A2 H# s* ] * @date: 2021-06-24 14:32
*/
$ U4 m9 R1 ~+ J  k- x: i8 Opublic class RadixSort {
    public static void radixSort(int[] arr){
        radixSort(arr,true);
    }
    public static void radixSort(int[]arr,boolean ascending){
        int max = Integer.MIN_VALUE;
        int min = Integer.MAX_VALUE;
( ]$ J0 o# G4 c5 m; G. Q0 E  v        //求出最大值、最小值
7 O0 P* D6 l# j        for (int i = 0; i < arr.length; i++) {
- t! z7 X) L- f- a# A  R            max = Math.max(max, arr);
            min = Math.min(min, arr);
! X. s: e5 P3 |        }
8 U! A. m# Q; ?1 f; R- j' v        if (min<0) {        //如果最小值小于0，那么把每个数都减去最小值，这样可以保证最小的数是0
1 A. i8 d! _9 L9 D! E3 t/ n            for (int i = 0; i < arr.length; i++) {
: e$ e6 m+ Z8 q7 d                arr -= min;
1 t7 k, h" q- y( a1 ^& m) }: K0 F            }
: q$ ?" x4 k% j. E5 g) }& X            max -= min; //max也要处理！
: }8 H* k* N) D" V" @3 p        }
        //很巧妙求出最大的数有多少位
        int maxLength = (max+"").length();
        int[][] bucket = new int[10][arr.length]; //一个二维数组，一维代表0到9，二维存放符合数
        int[] bucketElementCount = new int[10]; // 用于记录0到9某位存在数字的个数
+ u% U2 c$ G% y7 |4 w. l        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];
                bucketElementCount[value]++;
0 r; x' ^1 Y8 V4 \3 f; y) d7 ~            }

! y% h  T# b' Z" h5 c4 G5 G4 H5 A
! \" j6 f( X: G7 _6 c; B0 [4 o            //升序
            if(ascending) {
                int index = 0;
7 t) N: Y1 Q( M                //从左到右，从下到上取出每个数
+ i8 p: J; Q! j8 E                for (int j = 0; j < bucketElementCount.length; j++) {
                    if (bucketElementCount[j] != 0) {
% t/ p2 K5 r" B3 w7 f$ G                        for (int k = 0; k < bucketElementCount[j]; k++) {
2 V/ f/ g5 `: T1 g9 U: \, Q. U                            arr[index] = bucket[j][k];
                            index++;
                        }
# V+ j9 R) t  o: X9 b                    }
                    bucketElementCount[j] = 0;
( R" f/ r% ~7 [- L& D                }
            }else { // 降序
/ T2 R* ?- p# U/ w6 U: M                int index=0;
9 z6 D; g* m' `9 {) I- J                //从右到左，从下到上取出每个数
9 J9 _- u4 H7 T& ?" ~# ^) G1 [                for (int j = bucketElementCount.length-1; j >=0; j--) {
& O* p+ y1 ~4 h                    if (bucketElementCount[j] != 0) {
                        for (int k = 0; k <bucketElementCount[j]; k++) {
1 H4 n( ?  U& C                            arr[index] = bucket[j][k];
* D9 ?. [- j' }, S) A! x7 P  c                            index++;
                        }
. f/ G$ J6 s: u1 v2 B* O: H! N                    }
. N! O) G' z" I3 ^1 [                    bucketElementCount[j] = 0;
                }
            }
# L! W: I* t0 E

$ m( p- d# ]) P: n

$ h4 k- [. t  `+ O8 q            /*for (int i1 = 0; i1 < arr.length; i1++) {
  }1 E/ i, u* {0 l9 j                System.out.print(arr[i1]+" ");
6 i" W6 E( d0 a( I8 E            }
- `$ f5 @- K1 e4 E8 _$ O# F            System.out.println();*/
1 W) T, i; X; B
- }% F! U6 ]& X# d8 {2 A! W% `' L

+ {% f3 {8 V+ r9 |. j6 Q2 \( ^

! U8 X8 p: H# G1 Y2 D( q
% I1 D" Z' {' W+ n: m        }
4 x) K' b) _- `. q        if (min<0){
- ], r: D' @2 n: f% F/ g; _            for (int i = 0; i < arr.length ; i++) {
- S4 \( C! \1 H( o                arr += min;
            }
        }
7 U" G% P1 W0 `* ~
4 u. Y$ {. u  m5 s
' l! d7 u# h+ }    }
}
6 G: x0 e* c3 C/ C1
( U; C6 {+ B# B! I2
3
4
5
1 b, w! U- M5 V2 E, Z  c/ X# B/ A6
- r) a$ a6 R9 N& v  c3 n7
* n/ x2 x# J+ P: `' X) F; K8
9
+ S4 Z, S" {' G: h$ u7 j5 `10
6 s" Z7 y) P& i11
12
" v$ c; o  _7 `1 y  E13
1 {4 f8 M0 B: U3 C; e3 r3 k14
15
- [4 T& F# E, e- [" p/ a/ M16
6 |) f: L& B( s2 n. N2 Z$ Z17
* Q; t; L, g4 M) ^6 }( a18
19
20
) T; m3 E" Q# @21
6 G. ]3 H: Q% K3 d( U3 `22
23
24
5 H% j5 \1 I- X+ h" Z3 _  [25
26
+ B& `- }" ?7 i( [27
28
. ?4 l. a8 I: D8 \29
30
4 h& j! {: h, s- j! U$ ~31
32
33
34
; h0 h$ e3 u: |8 ~35
+ n+ z' X' V# w/ g& L; @7 l36
37
4 ?; A( j, P4 X38
39
40
41
42
3 O  r/ O& F  a: {* L0 g43
: M* x. T( o7 ?8 W3 L44
2 W+ |- U) a! a" V1 o8 }2 q/ U45
3 g+ a, l. o# D  Q& N46
) x* E. l1 l4 d. n* J) J47
1 P6 I* _% i# C1 W48
' @. i0 A8 h- z" C$ U4 C49
50
51
1 t" C+ `, B7 ?52
' E$ w8 v3 M9 ?% F- W0 M* n. C53
54
3 X8 c+ T/ d8 V! b$ p% }* B- `' {55
56
1 a* q0 i; p; q2 Z8 ?57
58
59
60
61
. A1 r% L1 H; s6 K- I6 V) C' V) Q. I62
63
. |1 v/ \' H3 r+ i) v' a& y, x% D, b64
1 d, C8 u* T6 \& _: j5 C4 B65
; j. K% }# X$ r$ U66
67
68
69
( \" E/ w% k" A) n4 J& W! r1 b70
71
72
3 x' t( i' C- x# g73
+ [5 g! w, |! {& \3 G74
9 {9 H  E3 z% ]' B: U* i. N75
76
77
78
79
80
81
82
# x& U: ]" f' Y+ w83
完整测试类
( u( {/ {" P, E% Qpackage com.keafmd.Sequence;
! y% u% D4 a' s2 J
' k  v! Z+ L9 x: N/ r  G- F& {
import java.util.*;
: G4 ~1 r; q& J0 x  E4 [import java.util.stream.IntStream;
. w6 ~% f9 ^7 q0 y! q& V- S- d  M- b( uimport java.util.stream.Stream;
$ x9 S- @( v3 ]! T, N* h$ I: H
+ `' U) X# A- W8 ~
8 ~# E% G3 t- u* C6 ]3 k/ q. @/**
8 m  j+ L6 h' G: d0 ~! t& Q0 D" q. ` * Keafmd
$ l$ {4 e* M( S/ c' i *
* @ClassName: Sort
3 F8 U" J, Z/ U8 ]* {5 @; w" [, J* C# [ * @Description: 十大排序算法测试类
* @author: 牛哄哄的柯南
* H0 m. L( K6 k2 f. A * @date: 2021-06-16 21:27
*/
public class Sort {




) Q& |( P  @/ q+ z6 S! _    public static void main(String[] args) {

. D4 c, k& F& D! U! c4 M5 r
" w0 p  X$ t7 G" n/ F        int[] nums = {12, 4, 25, 47, 58, 34, 25, 9, 99, 26, 1, -13, 162, 10093, -66, -1};
) l0 N* g& V+ i//        int[] nums = {12, 43,56,42,26,11};
        int[] temparr;

! U% e; B: P* D6 V( \8 a
        //利用系统Collections.sort方法进行对比
- ^) }, d- L7 d& |6 m

        //将int数组转换为Integer数组
+ _3 K/ |" Z, A( A! @2 z. `, v        //1、先将int数组转换为数值流
& A3 W7 Q/ S, G5 y1 C% V& M        temparr = nums.clone();
4 \1 t! i% ?' m) b; B* U        IntStream stream = Arrays.stream(temparr);
! e$ I, S6 X( B! {# p3 q4 Y  N        //2、流中的元素全部装箱，转换为流 ---->int转为Integer
        Stream<Integer> integerStream = stream.boxed();
6 `6 |; F+ d) r& G" f0 x        //3、将流转换为数组
        Integer[] integers = integerStream.toArray(Integer[]::new);
3 w2 U5 K0 \' ^        //把数组转为List
        List<Integer> tempList = new ArrayList<>(Arrays.asList(integers));
        //使用Collections.sort()排序
7 T+ [$ {+ ^! [' i$ p# D& P6 H% ]        System.out.println("使用系统的Collections.sort()的对比:");
, P) B: Q! a9 I: B" G# W! V* E2 w: F

1 [/ y9 X7 I, a, Y        //Collections.sort
# q! f4 _# |6 Y+ w% d( a        Collections.sort(tempList, new Comparator<Integer>() {
            @Override
/ j1 x+ @$ `4 z) O6 a/ l            public int compare(Integer o1, Integer o2) {
* S7 i: x7 ^# X3 ~                return o1-o2;
7 S4 W4 |8 i3 Q0 z% `. F                //return o2-o1;
) ]& v2 {3 u3 b- Q- J: V: O  }            }
: y8 l6 X6 U) h* j) e( T7 x4 _        });
# t3 E. x6 V9 t* y& h
; P. m/ Y$ F/ n' o5 \; Q6 I
        //tempList.sort 也可以排序
& k1 W7 @, X  [       /* tempList.sort(new Comparator<Integer>() {
            @Override
8 I/ ~% x! F% B' b2 R            public int compare(Integer o1, Integer o2) {
* r& K% L) Y5 g* @) l8 k% M0 x* _                //return o1-o2;
                return o2-o1;
            }
        });*/

+ h) r1 f/ c9 V) }
5 G8 `0 P: [  P4 z9 p        //遍历输出结果
# ?+ \- I" H2 V- V3 G* _        for (Integer integer : tempList) {
            System.out.print(integer+" ");
        }


        System.out.println();

$ o  f1 i8 U7 y0 Q, Y0 ]
4 v6 j# d  ^8 x5 W& U. _        //测试冒泡排序
        System.out.println("测试冒泡排序:");
/ D5 n' }5 Y/ C7 v  i2 n1 R% M        temparr = nums.clone();
3 O& }6 l& Z9 s6 R( ~1 s

# P4 `. S% i# K3 }) M2 H        BubbleSort.bubbleSort(temparr);


        //降序
1 P* w" l* X3 ]        //BubbleSort.bubbleSort(temparr,false);
/ Z) N5 ?5 I% H8 F$ B8 D
" M1 A, p* b( I
; k$ i+ L4 W$ ?4 M# \* u7 v1 k  P        for (int i = 0; i < temparr.length; i++) {
            System.out.print(temparr + " ");
% V9 t8 J4 P# n) e& L" F        }
        System.out.println();
9 X( x! B- G+ s

0 D9 b/ K, _+ r        //测试快速排序
        System.out.println("测试快速排序:");
        temparr = nums.clone();
        QuickSort.quickSort(temparr);
  m: M& R; B1 Q) b/ X) ]        //QuickSort.quickSort(temparr,false);
" W) h$ \; j% s% V        for (int i = 0; i < temparr.length; i++) {
: E0 n( O7 i3 y$ x            System.out.print(temparr + " ");
        }
- {* W! H! t6 V" w: q        System.out.println();
! ?) N0 _; P# Y4 m

+ X( @$ a  j& x" k$ e# O: e' [* \        //测试直接选择排序
( v0 o! P5 ]  j8 s/ ?5 B        System.out.println("测试直接选择排序:");
% r, s0 Z1 f! r8 y; Z        temparr = nums.clone();
        SelectSort.selectSort(temparr);
* y# b8 `& f, k% V6 P  t/ Z: T5 Q( y        //SelectSort.selectSort(temparr,false);
$ L& T# F  f( j# \' Y! _        for (int i = 0; i < temparr.length; i++) {
            System.out.print(temparr + " ");
        }
        System.out.println();
5 ]. w0 ?' ~- |$ J9 [, g9 K
4 `6 Y* P# i7 j$ C
        //测试堆排序
        System.out.println("测试堆排序:");
* |( L* D7 Z0 R, N$ Z& F        temparr = nums.clone();
( |6 z; N$ b5 Z6 }4 r) k# ]4 _( r        HeapSort.heapSort(temparr);
$ T$ Q. b4 B' V! ?2 k6 y( }        //HeapSort.heapSort(temparr,false);
        for (int i = 0; i < temparr.length; i++) {
1 t1 g$ k+ G6 }, o. Z( g            System.out.print(temparr + " ");
        }
  t/ d, E( `6 J( D* C        System.out.println();

2 f( Z. K7 K% w9 f. a
        //测试归并排序
5 l& O2 o1 @. e% m        System.out.println("测试归并排序:");
" d7 [4 o' m* _# b; F        temparr = nums.clone();
        MergeSort.mergeSort(temparr);
3 n7 K  y. Q+ W        //MergeSort.mergeSort(temparr,false);
% u& ^- y0 c/ L& H  I9 X7 R        for (int i = 0; i < temparr.length; i++) {
1 V7 j) I: w+ ]( Y: R% v            System.out.print(temparr + " ");
' }+ K" c3 m( o' M        }
9 \. l1 O! z+ ~6 i/ [* o8 }        System.out.println();


- L4 Y, W  `2 N2 s' s        //测试插入排序
        System.out.println("测试插入排序:");
        temparr = nums.clone();
        StraghtInsertSort.straghtInsertSort(temparr);
7 `8 X/ k$ `+ Y2 }0 T5 Y& m& G* q        //StraghtInsertSort.straghtInsertSort(temparr,false);
        for (int i = 0; i < temparr.length; i++) {
            System.out.print(temparr + " ");
' d* ]. ]1 v' R        }
        System.out.println();

3 k0 {0 L7 a: x1 v

6 @6 R6 o: i% I% U
        //测试希尔排序
        System.out.println("测试希尔排序:");
' j. q& O3 r9 v9 Z# }# ]        temparr = nums.clone();
/ k( y& S3 _+ \        ShellSort.shellSort(temparr);
        //ShellSort.shellSort(temparr,false);
        for (int i = 0; i < temparr.length; i++) {
            System.out.print(temparr + " ");
! g6 |# J+ H4 T/ Q3 }        }
        System.out.println();
! L  ]0 P; Z; n- l) O: o" z8 m, H
/ U% g3 }0 M' [+ E
, d+ D# B1 y9 ^; G: n; `/ V
2 a! }  x, B  O8 [7 f6 A( m
        //测试计数排序
4 x/ x' @! a$ c+ R        System.out.println("测试计数排序:");
        temparr = nums.clone();
% l9 T2 U/ K/ s- t/ d3 `7 {1 p% _0 G        CountSort.countSort(temparr);
9 S' @2 _3 B$ W& g2 e# u9 o" ?3 _        //CountSort.countSort(temparr,false);
; W' N3 v1 x2 v" I( T        for (int i = 0; i < temparr.length; i++) {
            System.out.print(temparr + " ");
        }
) X! _  s- ~/ X( N, `) k; S' s        System.out.println();
; O8 z/ G8 M7 ^5 u% I
: k! T3 A: k2 R' ^% J9 |6 K) W/ W
7 ~% s/ R1 u  L. X1 T& ~

        //测试桶排序
' g: f4 ?0 E0 K$ T        System.out.println("测试桶排序:");
) K; A' a+ F9 R3 l: x6 h        temparr = nums.clone();
        BucketSort.bucketSort(temparr);
, C7 v1 |& U9 x- t        //BucketSort.bucketSort(temparr,false);
; v& U; z' a+ K: d' M# L/ @* J6 W        for (int i = 0; i < temparr.length; i++) {
3 B9 y4 P. t8 }/ l! g0 A            System.out.print(temparr + " ");
        }
/ f4 J% k( K! |8 k" h& b& i; |        System.out.println();
% r( {, ^6 ?3 I# h8 D

. w9 Q9 w8 T# w& a        //测试基数排序
7 s1 t8 ]7 i3 b+ A1 G/ P; G, A        System.out.println("测试基数排序:");
        temparr = nums.clone();
6 T: M( t/ \! {- K0 s) D        RadixSort.radixSort(temparr);
! L8 _7 X% c  j+ P7 k# G        //RadixSort.radixSort(temparr,false);
9 L, ^. ]! N4 z( ~7 U        for (int i = 0; i < temparr.length; i++) {
            System.out.print(temparr + " ");
0 j5 p" i, n, r$ k& U3 {8 n% c        }
6 }% D: Z' b* U) x        System.out.println();


/ e) y" I" R( Z4 m* v/ f    }

: O6 P1 g. }( ?. s+ C) B
- T3 `. X0 j- w}
1
2
9 }5 b5 {" L  h6 n1 T3
4
3 z# @. K5 h7 i, J0 [& K' U5
6
/ M- N9 f9 ?& ^! r+ e7
# Z* g8 s1 x$ T3 C. l8
6 M( }( o/ _' @0 j. D& B6 ]% z/ @9
. [, L$ L1 z& v! P' B9 V+ W10
7 s% k& R7 {6 l7 A& q2 w11
12
13
0 ?' ^- z6 p' O8 {( A8 j: ]14
15
  S) }" C4 k* ?1 [# R5 c# K16
6 K% q& y2 P. w; u; x6 ]- A17
18
19
20
2 Z! Y4 W& w2 m4 G" G! k21
22
0 ~& t2 a% Y# q# w' a0 n( {23
6 j4 V1 z4 C7 a' R: c5 v24
25
8 O* Z$ M5 k# P3 {  h26
27
28
3 B2 x5 d$ w  n( j29
! D% m+ Q# |/ D& I$ p6 i3 q30
; ?9 m& b  X. R  P; [- T5 D31
; c$ U9 e7 r+ D/ `4 W; j32
0 z% g; i# q+ p: j9 {9 i$ ]33
4 H5 ^9 F# G0 z% Z34
35
36
. I1 `, u! B0 I37
4 |8 U0 Y* U( M0 P: D4 ~38
39
# n3 o% g+ N0 ^  w/ U) A8 ?' Q40
41
42
43
' K* C) m1 [% E& [! J44
45
46
47
5 l  X! T9 V0 v7 G8 H8 d& P5 F48
49
50
1 T- k. n% w3 a( h. N4 J7 P51
" A- z% s( c. U8 y, ?, d( r52
' \1 V9 Q( E. K, s! x7 K8 d53
54
55
56
5 g9 _" m9 i5 D57
58
; l1 V' R3 L% y+ D5 h' k59
60
2 B' m! [9 _% w1 a2 _( m2 M5 Q7 P61
5 W6 B2 h& R& k" y7 J$ o62
63
7 s$ q! f) b& p; [0 f- ^64
2 ]4 Z- m" V( t65
66
7 d8 \( T/ y" R5 y67
% G( b7 p% v* O; c" m% [68
69
70
: o4 ?* A4 B: X0 u+ g- f$ ?+ |8 z71
- N+ ?& Q# K0 K& k  S72
9 G# D/ O7 H+ w0 `6 q3 k1 T73
74
75
5 V% U2 p  P4 r1 A  `76
. H  c9 o  `9 M' L# g$ G. S77
# x, G. v$ Z$ T78
7 ~) _$ B+ Z) H: U/ C- h) z6 C79
  S) K, x0 Z& I* c1 l80
81
82
5 \8 \$ W. ?6 \( S! z, }5 @83
84
85
% u) [" G0 o& `$ R8 N# h86
87
' ]6 m* L7 r! J1 ~' n! c88
89
" H! `& T% w: j/ L90
, g: u! b) Q( }/ z9 R91
$ E9 N2 S' ~7 i( s( W: ]3 D! ^; s92
93
94
' L8 N0 B+ W% t4 [8 E; w7 `7 m95
3 d  N! k5 {/ @- M( z& I0 e7 p96
97
98
$ X, L3 I2 {- G+ m7 {, N3 [6 x: Z99
100
101
# q- g4 V2 {0 n102
. B9 s% A1 C, p) y- H( A2 L% y4 e103
' i; d' Y  D+ i) Z2 s& T$ o104
105
106
9 s6 H# l* S* s' ^7 j& U4 x107
108
109
4 N. ?+ b) l* `7 ^6 C110
: f% K# q9 P) m+ i9 S111
; S) G' a+ h" @1 S112
113
114
3 [2 B* ]+ z1 k: C9 t' Q115
116
# L; D! E# i3 y7 K0 M7 a117
# O/ {4 d+ B+ ^118
119
# y% B! v/ [: Q! G2 J, [120
3 q* g2 O' k0 U121
122
* i9 O5 P9 t+ I$ g123
124
  e; H0 j0 x* ^; r; E$ ]125
4 ^* S# T0 Z6 g5 z; X( n* w126
0 p0 N# C# `" c0 r. P127
128
5 _, \8 `0 X  s7 @& W+ \2 m' c129
" C7 U$ h$ @* z3 p" @, X0 |130
131
132
; [4 I) e4 U; G# B  E5 {  A( ^& @2 J9 a133
134
1 F  H0 y) l/ l$ ]135
136
4 ]( c! b% P8 E; M& G137
# {4 ^/ @8 h* V+ m6 J8 q! U138
139
5 k; v, W  Y6 a140
, W1 F+ I& w9 V2 Z! h8 E! x141
: D. @6 W$ g+ a: B( v1 u0 h142
4 Y" v+ J9 I4 w- @4 S143
144
145
146
' M8 c3 l$ Q* S, N/ c2 h0 A, C  L( Z147
148
149
150
151
2 l+ P* u0 T% _" s: ~152
$ k5 k/ T8 \, ~/ {7 p153
7 i/ ~3 q4 x, I4 ~# b0 Y  A5 A" e( }154
! R2 n" x+ y7 U0 z* _" F155
156
157
158
% H. ^  E  I* f$ Q# h2 |: H+ C159
160
161
162
! X! Y6 k; D# M, T163
* O* t7 P7 o) _4 O# {/ J+ m164
165
166
2 S' a( O7 k8 O1 F: r1 O( d167
( C% H6 R& O) x1 E  n( ^3 c2 Q9 Y168
2 s; Q; ?2 r2 t, K9 ^169
/ ]/ I$ ~' E7 G5 P# b4 S, \8 ^# g170
6 r* K5 [8 z4 R! F% ]  E" ]: Q/ Y171
172
8 G! {% e3 s- S2 x173
1 \4 j  S% ?2 j3 T3 d3 w* d每天进步一点点！
不进则退！


4 n) ~/ v  k/ p& }# V版权声明：
原创博主：牛哄哄的柯南
博主原文链接：https://keafmd.blog.csdn.net/
————————————————
版权声明：本文为CSDN博主「牛哄哄的柯南」的原创文章，遵循CC 4.0 BY-SA版权协议，转载请附上原文出处链接及本声明。
& ~6 H+ Y! d( L; ?! q原文链接：https://blog.csdn.net/weixin_43883917/article/details/118193663
8 p" R$ {! Q8 ^. F* _% {

" B7 q, y, V, I8 n. }

1051373629

每天进步一点点！
1 u  E9 R0 |8 U5 H* g4 |0 E$ n. G