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

杨利霞

经典十大排序算法（含升序降序，基数排序含负数排序）【Java版完整代码】【建议收藏系列】
经典十大排序算法【Java版完整代码】
6 ?. a; X+ ?! D写在前面的话
十大排序算法对比
冒泡排序
快速排序
* S* A! ]! u- H% a( b5 p直接选择排序
1 ?2 H& W3 b# N1 V! J* \堆排序
, N6 j7 s, i6 V8 P6 a( d" w! X归并排序
+ B" c0 i( c/ J2 d+ }3 f4 ]插入排序
希尔排序
% A" y4 {4 }% i+ B4 V计数排序
桶排序
基数排序
完整测试类
, w' d9 |: B$ X5 G- `写在前面的话
6 c- j9 k$ L$ Z/ L       虽然已经有很多人总结过这十大排序算法，优秀的文章也不少，但是Java完整版的好像不多，还存在某些文章代码存在错误的情况，同时也为了自己练手，决定把所有的写一遍巩固下，同时也真诚的希望阅读到这篇文章的小伙伴们可以自己去从头敲一遍，不要粘贴复制！希望我的文章对你有所帮助，每天进步一点点！！！
& K& B* Q2 q- }/ H6 V+ ^0 F
. Z! [1 c9 i, S8 B, z0 @9 h
) ~& @7 r2 `1 E% w+ V5 f; u4 h$ P       我用通俗的理解写下对算法的解释，对某个算法的运行过程不是很理解的话或者想看比较官方的解释的话，单独搜索某个算法，看几篇不同的解释，就可以有自己的理解了，这里我主要展示代码以及进行通俗的解释！整起来，再强调一次，一定要自己敲一遍，这样才能理解的更深刻！


' _( Y. }  ]+ x, o0 T十大排序算法对比
- ^( {) B* ]$ S9 R: n! d
1 D, z4 N7 V; _- R- }


' p+ r) i& }; [, W* H8 p关于最后一列的稳定性，我稍微解释下，例如对序列：1 2 4 2 6 排序，序列中存在两个2，如果我们把这两个2标记上（让他俩不同），排序之后，前面的2还在前面，那么就称这种排序是稳定的，反之不稳定。
7 P+ `$ s' a1 F0 \( f( D4 z) w: h
& Z: d$ v% K# z: r( w
冒泡排序
5 W+ K/ f3 F+ j8 m% y简单解释：
. L& X0 q3 L, |7 `9 P) g       原理就如算法名字一样，就像水中的气泡一样，每次我都把最大的或最小的放到最后面，这样总共需要n-1趟即可完成排序，这就是第一层循环，第二次循环就是遍历未被固定的那些数（理解成数组左边的数，因为每层循环都会把最大或最小的数升到最右边固定起来，下次就不遍历这些数了），两层循环遍历结束后，所有的数就排好序了。
       两层循环所以冒泡排序算法的时间复杂度是O(n 2 n^{2}n
0 R4 q5 l" F9 ?1 I. }* H2
' J0 m& s* y0 @- N )，是一个非常高的时间复杂度，我在下面的代码进行了优化，加了一个标志位，如果上一次循环未发生交换，就说明已经是有序的了，就不继续下去了，反之继续进行下一轮。

* |, ~, h7 b* R' |5 ?/ \+ T8 m% s


( U/ K5 n/ {- p4 T, C! U/ K4 Z2 H
3 f( j: p0 s+ n
  O' N. T# o& D% @- R8 G8 P本文的图片来源网络，仅用于大家学习，侵权联系删除！（下同）
' Y8 U  x- ^( J/ z0 j! ]5 e

完整代码：
$ b! j4 L9 A; F, S2 g
% a* v' u% n8 Q7 i4 K
package com.keafmd.Sequence;


8 r1 B) u6 w9 p9 \/**
* Keafmd
2 f" W+ p# ]% f0 o- E5 T+ F" L *
* @ClassName: BubbleSort
* @Description: 冒泡排序
) b; H2 a2 a+ J* U" T/ U: ? * @author: 牛哄哄的柯南
* @date: 2021-06-24 10:31
  C2 Y' ~( W9 x6 |( Z. v, Z4 | */
" e- W; l; p" R, z( g3 ?* qpublic class BubbleSort {

' n+ y/ @8 |* q8 O' s7 l$ }5 V4 N
; N* \0 {, d, W- U8 |    //冒泡排序
    public static void bubbleSort(int[] arr, boolean ascending) { //exchange标志表示为升序排序还是降序排序
5 r: f/ m  P" ?* H; ~0 T- Z0 ~) n1 o

        boolean flag = true; //加一个标志位，记录上一次是否发生了交换，如果是，我们则进行下一轮，如果没有，说明已经冒泡好了
& X+ [* g0 S! @3 }. W5 I. \# T0 I
" @/ G$ [. h: G5 B7 I
; L* P) [7 O6 x( R$ f        for (int i = 1; i < arr.length && flag; i++) { //控制次数，第几趟排序，只需要n-1趟，有交换时进行，只有flag=false就说明上一次一个元素都没有进行交换
$ V/ o* O( d5 {$ K8 T- F

4 k7 B7 o9 a- ?* ?4 G' B            /*System.out.print("第"+i+"次遍历：");
            for (int i1 : arr) {
% T9 ]/ {" C3 X' k4 y                System.out.print(i1+" ");
; a+ M: Z( y: F  h% X% e* u# Z$ F            }
; l" S: p6 W, T            System.out.println();*/
1 C% C( Z3 h* y! [

            flag = false; //假定未交换
! E+ c8 D6 c: {1 B& ~
/ Y% s& H  ~" n9 L) P3 D% y9 [' o
+ V, m4 E& c8 y( K' J            for (int j = 0; j < arr.length - i; j++) {

- h2 L- y: u/ D; k1 Q  v8 h
/ z4 Z) T2 q; @) T" p5 X                if (ascending ? arr[j] > arr[j + 1] : arr[j] < arr[j + 1]) { //控制升序还是降序
                    int temp = arr[j];
                    arr[j] = arr[j + 1];
                    arr[j + 1] = temp;
/ x7 [  r+ G5 `+ G" w. J% n                    flag = true;
                }
1 k5 V8 f- E, g7 j3 R# C- @

: g6 a6 w/ M! M9 M" h' `- ~            }
( S$ U* N! o/ Y  g        }
( Z1 V1 v, Y& `: u9 ?2 i    }

( K& i) N4 M- e2 _  y9 f/ W
2 a. [) g7 R" V    //冒泡排序 -- 默认不传参升序
) W/ Q$ a& Y+ X9 \0 g, a    public static void bubbleSort(int[] arr) {
        bubbleSort(arr, true);
/ Q# D( l* |! q9 o# c. X6 Q    }
}
% E# T0 v5 ~- i1
* }$ J: _- \2 n6 |. i; I8 l1 ]2
5 i. Y* j8 ~5 \6 J3
4
! V' I4 B& q: j& y/ E4 w5
6
7
8
% k/ g2 P/ m+ w0 E: j6 N. R* I9
10
; Y" U9 a2 x7 }9 G11
12
/ X. F) W. C6 Q: s+ {2 q! u13
14
* D" r5 `$ t; C* _15
- [: B* S/ k5 U) c- \16
. A- q; Y( i! ]$ ^9 X# O( p9 C% e6 V17
- l- e. y% e7 B% z* E18
19
20
+ t5 K8 h0 T5 @+ @" t! o21
22
; H" W- s8 h- t% }% \23
' z  F+ }' {( [24
4 d" K. z0 L% X: n25
26
27
28
7 {# W; Y0 V4 |! f29
# I( K" V; U) R5 ]30
3 I4 k- Q; h+ M: E/ |4 T% _9 \9 c0 w31
, g4 n/ C& c& Q0 Q- A8 b$ c32
33
34
35
' [- D, S+ d$ y1 b36
3 ^. t0 \$ y9 l3 T! ^37
38
9 v+ g% Z/ q+ [4 v# g8 m39
. e; ]5 A  O; ~$ f40
/ d2 {  d/ }& G- i+ Y* `  p4 P2 {41
* t( M7 p) N4 s4 K42
43
9 Z  `1 o7 [4 D4 |: n44
45
测试代码：


/ U8 f9 `$ P3 |( E7 _; c升序排序（从小到大）
" W, z0 Q2 A+ `3 L& s

/ B0 F' u* v/ ~7 bpackage com.keafmd.Sequence;
/ J. D& a# d6 G7 Y
7 s& {: J$ ]2 n) R  `% Q6 X2 F
import java.util.*;
/ J# r& n9 ]5 D+ _9 E# y. ?import java.util.stream.IntStream;
import java.util.stream.Stream;


' o! s0 {# P) p, ]; ?/**
* z% ]* E  u1 t) P/ I/ {- A: Q * Keafmd
*
* @ClassName: Sort
( P' M4 x/ D* P4 w8 j * @Description: 十大排序算法
4 f/ ]* M; v" D/ Y/ | * @author: 牛哄哄的柯南
, X8 n. ^- W5 B  R; E. Z * @date: 2021-06-16 21:27
) _* ?: z9 E/ o6 b( i- n3 |) X& E */
public class Sort {
! [  a- P+ L4 Q8 O! f    public static void main(String[] args) {

' f( p  i- c8 R, g; N
        int[] nums = {12, 4, 25, 47, 58, 34, 25, 9, 99, 26, 1, -13, 162, 10093, -66, -1};
        int[] temparr;
' g5 H! z4 E9 _( E" Q8 _7 {8 J
, @" C2 Y8 N/ B( M9 {7 i$ R
        //测试冒泡排序
        System.out.println("测试冒泡排序:");
  K1 z  k& J' X# M) `        temparr = nums.clone();
        BubbleSort.bubbleSort(temparr);
! W* d, M* i* B+ S8 k! q/ l        //逆序排序
4 {6 l# ^* B6 k* M/ G  Q4 e7 c        //BubbleSort.bubbleSort(temparr,false);
        for (int i = 0; i < temparr.length; i++) {
; Z; Y6 Z! C* z2 s, U            System.out.print(temparr + " ");
        }
        System.out.println();
0 n0 Z& ^! o  j/ h9 y( J: A
, y8 b- I/ I8 @$ \. ^, m% ^6 e
    }
1 W/ |6 [/ r" b& M, ]" k}
# X5 r4 x2 i4 m* q5 ~* t, i1
1 a$ g: e  p+ z2
- I9 Z2 q. w4 Q$ ^3
8 C# V3 R0 u# j/ m; v, }3 x4
( H- f7 |" H* F# q" O5
" i3 [. p5 h* w- `5 U2 O6
% G8 s: a+ v( G; [& z7
8
% z6 C" c5 p$ P. s# }# a0 K4 L( B9
10
8 J( }2 u9 j, G- K3 ?1 [11
12
13
14
$ ^7 p  u; E/ S  O0 j- T) J8 D15
$ b: P" h* T& P8 R16
2 k& `/ f  D: U/ }; Q17
18
+ D: q( H: D( q* l& U19
0 n% N3 x4 }: R% d5 i1 A20
9 ?# m7 N" r7 n; f/ K21
22
23
" L; k* ^, Y. n4 o1 a# O% w24
7 B+ [5 B* j7 {/ m9 W  n25
26
( D5 u& W* V' d+ C5 N27
+ {$ D  |) U$ {4 x# j. E28
29
30
  _1 S6 e  v( n9 A31
- I  t/ r3 Z4 n" ^3 ?- Q32
33
! D4 C( {/ l. p6 e% G# f, u运行结果：
1 |( ]' J: u" j  Z" ?+ Y. x& j& S

测试冒泡排序:
-66 -13 -1 1 4 9 12 25 25 26 34 47 58 99 162 10093
! {3 {+ N7 J/ Q1
% M5 }# I4 T. E' h2
降序排序（从大到小）

- T) i2 Q% W2 ^+ [. h2 j9 }2 O8 f
//测试冒泡排序
3 e. S% K0 e1 c* B3 q0 W& wSystem.out.println("测试冒泡排序:");
temparr = nums.clone();
BubbleSort.bubbleSort(temparr,false);
for (int i = 0; i < temparr.length; i++) {
    System.out.print(temparr + " ");
" Z+ A3 Q9 K- i5 ~; N$ S* Z' G}
, v  D$ N: c8 b% z: U3 fSystem.out.println();
3 z4 u$ ]; P) H! o6 N; a+ {1
1 ]8 m+ p* P: p6 S2 U, V5 v2
3
4
5
6
. c' s5 m$ f& [& Y7
/ ?2 E! `  x7 H' F) J/ V8
2 I2 r1 I, y/ W3 S; L8 p运行结果：

, x4 L6 _, W. P3 g, W/ g6 N
8 A6 q3 m1 E$ E# I2 C测试冒泡排序:
" E0 G; C6 e! `- Q10093 162 99 58 47 34 26 25 25 12 9 4 1 -1 -13 -66
- ]; N! _7 b& p: q  h3 d) b1
2
2 m6 ]5 H3 ]0 z/ f3 K7 _2 O下面几个算法的测试也就是换了下类名和方法名（换成相应的排序算法），如果想降序就在数组后面传个false即可。我就不一一复制了，我在最下面给出含所有算法的测试类，需要的自取即可。
- d3 _* @) M8 Q0 T5 @
! }1 h# y5 ^& O3 I
快速排序
2 Q! r8 f  _, M* c% T8 y) f- ]$ c8 {4 S; t简单解释：
快速排序就是每次找一个基点（第一个元素），然后两个哨兵，一个从最前面往后走，一个从最后面往前面走，如果后面那个哨兵找到了一个比基点大的数停下来，前面那个哨兵找到比基点大的数停下来，然后交换两个哨兵找到的数，如果找不到最后两个哨兵就会碰到一起就结束，最后交换基点和哨兵相遇的地方的元素，然后就将一个序列分为比基点小的一部分和比基点大的一部分，然后递归左半部分和右半部分，最后的结果就是有序的了。

: f) @9 O  N. D7 R0 n
$ |* t% M* W: H: k4 e" v# u3 E5 n8 G
7 C4 o! ]# a; f
5 h5 T0 @" H( _1 Q

& ?* @) ]3 z. E# f完整代码：

  N4 a+ P- @& t- Z
package com.keafmd.Sequence;
- z* k- h1 f3 D. j# L8 m
2 U1 x& S6 p3 O; D4 l/ a
/**
4 p; ^1 `% B- g; A) [ * Keafmd
*
* @ClassName: QuickSort
* @Description: 快速排序
' _5 t8 _) N4 B" r8 ?6 G6 h * @author: 牛哄哄的柯南
) @4 U( d4 }; H * @date: 2021-06-24 10:32
: y" G5 I+ M( i+ L! W" d- ^2 z */
public class QuickSort {
9 q/ K/ o: _( e! A9 s
3 l4 y0 \/ ?  C8 f9 z( p0 v7 }
/ ]/ W7 v* J3 z    //快速排序
    public static void quickSort(int[] arr) {
        quickSort(arr, true);
    }
7 S( }  ~. f2 _' X7 _2 u

    public static void quickSort(int[] arr, boolean ascending) {
        if (ascending) {
* @7 X6 e( I. V+ j& V( n3 M5 D            quickSort(arr, 0, arr.length - 1, true);
        } else {
            quickSort(arr, 0, arr.length - 1, false);
% B8 r: S2 t0 R* K        }
    }


/ m( u5 l0 P7 A% B! t7 `$ A+ q    public static void quickSort(int[] arr, int begin, int end, boolean ascending) {
        if (ascending)
0 U5 n6 E0 m  @% E            quickSort(arr, begin, end);
" B9 G5 Z! {1 c        else
; z1 \0 |0 {# M4 g+ r1 W# D4 ]" v            quickSortDescending(arr, begin, end);
    }
* B, `, M# S  [" B
0 h2 @5 H- c: Q6 @: F2 Q& k
) b: s, w9 J! l( `. Q1 a$ q5 K    //快排序升序 -- 默认
    public static void quickSort(int[] arr, int begin, int end) {
        if (begin > end) { //结束条件
7 o% t: |: p& ~0 o  t" p) @            return;
        }
        int base = arr[begin];
  \8 n. I, {  \3 X  |: G, l" {        int i = begin, j = end;
        while (i < j) { // 两个哨兵（i左边，j右边）没有相遇
' O8 F% m6 ]- I- c% \            while (arr[j] >= base && i < j) { //哨兵j没找到比base小的
) d) I: c4 B- n% j% Z                j--;
            }
            while (arr <= base && i < j) { //哨兵i没找到比base大的
: E3 D# u% q7 A* s* [( b                i++;
            }
            if (i < j) { //如果满足条件则交换
                int temp = arr;
+ f# ?+ c; T) N- `                arr = arr[j];
                arr[j] = temp;
# T/ S- A3 t- b            }

6 e$ p* w4 U* A" I  h' D8 l
6 p/ K3 J( \+ `& ?! g' U        }
* x% L) h/ V. A2 m5 F        //最后将基准为与i和j相等位置的数字交换
! g8 Z. n  V7 s1 p3 C; N        arr[begin] = arr;
  n" K+ X( `* a- }9 v: n! F        arr = base;
. R" K4 |* h: [  q- K. l        quickSort(arr, begin, i - 1); //递归调用左半数组
        quickSort(arr, i + 1, end); //递归调用右半数组
8 o/ ^" `9 y/ c! P

/ ^; u. C' K2 z- m+ _) s- \0 `9 w3 Q    }

0 `, j; W9 t" _+ h9 }
    //快排序降序
  h9 p( ~7 W. x4 `7 _! G& H    public static void quickSortDescending(int[] arr, int begin, int end) {
        if (begin > end) { //结束条件
            return;
        }
        int base = arr[begin];
        int i = begin, j = end;
        while (i < j) { // 两个哨兵（i左边，j右边）没有相遇
  i+ @9 L( f* {            while (arr[j] <= base && i < j) { //哨兵j没找到比base大的
6 D2 f/ N8 V( s9 ?" r  I) g6 r                j--;
) y$ W4 i- q2 m1 w" E            }
            while (arr >= base && i < j) { //哨兵i没找到比base小的
+ @! d9 H2 y  j3 Q% N                i++;
            }
" s; G( |  B) f0 g4 i+ S- i            if (i < j) { //如果满足条件则交换
: T4 D- E  L8 H: k                int temp = arr;
, ^) i8 a0 A7 [" R' b                arr = arr[j];
0 C: k1 S' k0 a                arr[j] = temp;
% l+ n& {6 D  s9 Y7 m            }

% ?+ E, Y) A2 s! Y# R: V0 n
% t' R% r: W& r% l& d# C        }
        //最后将基准为与i和j相等位置的数字交换
4 g. s6 ^5 O' C" E  s# y5 ]: y0 L        arr[begin] = arr;
: ]- g2 |# j* L9 K9 b        arr = base;
        quickSortDescending(arr, begin, i - 1); //递归调用左半数组
        quickSortDescending(arr, i + 1, end); //递归调用右半数组

5 h, \1 J- X# Q+ o6 h) m
    }
; [% w8 J& h# ?! @8 T+ {: H

; L4 E) Y! W0 T}
' f1 {$ H' I/ L9 C$ X6 n" c, _. G1
4 f7 e6 y+ h( @* W& _# w! {2
+ j1 a$ ^  N& m) j3
9 C2 f; R. P: v2 {& C  I8 L( ?5 a4
) V" B( y/ l( j8 m, J, O$ M: j6 Y5
6
: d, N5 e8 O/ P6 w) g) s7
( D" n; @; s& G8
5 s& y6 T+ O. I" q1 F9
10
11
7 a! Q* K2 t+ A* V) N* ~12
! Q" t6 ]& [! H0 ~5 Y13
14
15
, |1 c2 ?' [: W16
- n8 N5 Y2 @6 Q$ [9 j& g17
18
  r( {! `2 z2 T. w3 X19
20
9 c# O4 y6 @  |8 e7 W3 H( g21
22
23
5 g1 G6 ]7 j! T1 }7 V9 C24
25
$ V" E* S) E4 ?; F8 z, S26
27
28
0 \& O+ f) |" L. c# }29
30
1 {* I) t5 L, ^! z) F$ `9 A31
; T3 Z# L# Y7 a/ {8 z3 A32
33
34
35
& d( ~( n% B* f+ l/ g2 u7 J36
37
38
' m+ l; m2 h0 N39
40
# l0 ]) |2 l9 c/ K! L41
0 H" ]. Q# @$ ~2 J) n42
/ w5 E8 V# N" N( t43
& n0 }% D1 p4 u; b* @, J+ u% h2 \2 m44
45
46
47
* O+ F9 p" o4 E- G8 M+ j6 i48
49
50
51
52
53
1 d& D1 k5 E: B, Y& q0 J54
55
9 D7 D2 `+ }" m4 P56
57
58
59
60
; A7 F5 \' l  i; x& k- V0 ~1 a61
; ~) g. ]! z  I' [8 _8 B9 F62
63
64
; U3 w, E/ Q" k/ Y/ W65
( s9 A- n- S9 {7 S66
" p, w9 h3 I# N, Z' l67
68
69
70
71
0 S) O1 F, P. ^3 D, l$ P72
. w! ~6 T6 j. N, z* ~1 y73
74
( l- S8 a" V6 @. ]+ B, Z9 L. ?9 h75
+ W: e. U: ?1 u5 b- b+ @76
77
3 U6 [$ \( @; `/ w/ f+ U78
79
80
81
7 H- p4 n" E! i. j3 }! r82
1 R+ ?6 r* m& c/ s83
84
85
86
8 y: W$ C2 `5 x4 i! O) t6 g/ W87
; ?5 M9 k- A, o8 n88
89
+ ^3 V7 F! P" d90
# d7 f, X! t1 E# ^9 [/ Y) J91
直接选择排序
% }# w1 A3 K4 a; V7 ?" n简单解释：
数组分为已排序部分（前面）和待排序序列（后面）
2 D' D% u' t) C5 m) r7 P第一次肯定所有的数都是待排序的
0 K- g& s& k# B) o( x; w从待排序的序列中找到最大或最小的那个元素，放到前面的已排序部分，然后一直找，不断缩小待排序的范围，直到所有的数都是已排序的了
3 o" \$ v% g1 B1 v, C% B/ }


7 L+ x2 S% f2 [
' ^# m( R0 t" {+ `
! }' t. }! {/ M' ]9 L% O9 ~
; L" P( a9 A" l) \6 [( X( I0 ~完整代码：


package com.keafmd.Sequence;

. F9 ^, y, o4 h3 ]0 K! n
1 a' r; v) F: T. C/**
* Keafmd
*
* @ClassName: SelectSort
* @Description: 选择排序
8 ]3 @5 _2 _' O8 F( h0 u! a* P, h * @author: 牛哄哄的柯南
* @date: 2021-06-24 10:33
/ h+ o& N+ O1 S1 ]$ n% h */
public class SelectSort {

/ z% Y2 w% [5 Y( E$ H
  t! O$ T0 J4 _0 D, a8 j    //直接选择排序
    public static void selectSort(int[] arr, boolean ascending) {
2 D  I0 e3 Z6 D2 H! L( ?9 Q        for (int i = 0; i < arr.length; i++) {
            int m = i; //最小值或最小值的下标
            for (int j = i + 1; j < arr.length; j++) {
. g2 h: C7 G, z) r$ P                if (ascending ? arr[j] < arr[m] : arr[j] > arr[m]) {
5 N' c& A' b6 H6 K8 [9 E3 h+ N                    m = j; //找到待排序的数中最小或最大的那个数，记录下标
                }
. h+ n) F8 C9 L5 N# q+ {3 R3 R" v
" X9 a6 _3 a' H3 x! w4 {4 {7 a
            }
            //交换位置
            int temp = arr;
            arr = arr[m];
            arr[m] = temp;

$ b8 R. b* ^5 y6 v# l8 r, B
% \' p* p( D0 p2 a. T        }
    }

  G0 y  `8 Q* d( n$ K( V9 `( O
' D, y2 [* ]) V/ U" @7 y* \0 \    public static void selectSort(int[] arr) {
9 e" i0 j7 ]4 t3 D2 [5 U! r% @* x% O        selectSort(arr, true);
    }
}
1
2
3
4
5
6
0 B% Z2 {! C/ e5 K% s& b3 X7
) p7 p( ~6 x* y) B  \, C( H8
9
10
& U1 A9 {, x( v11
12
13
% y& W; }  n+ h, [14
( d1 z3 ?0 ~* I* r15
7 `& q, r- k0 B# [% C4 R9 l16
17
18
  d  V8 f% \) ^  ~- ?/ c19
6 ^8 e, J2 o9 ?+ C. c! f0 L  W20
* ^: c* _' s2 \5 \7 T# {21
: c4 E8 ]$ i: J) u+ P7 `+ ]22
23
24
0 D/ x7 a& s4 ?% A  ^& r& s9 o25
26
% _7 h" h' R& }27
28
9 r) W' {. ~: o8 D1 `6 Y29
30
- M* {. b8 y' d% Z/ p' G/ M31
$ }7 ]- S  n' \4 ]32
33
" }' r) x+ c+ H1 j. W, I34
堆排序
先理解下大顶堆和小顶堆，看图
, K- v; d8 z2 H+ U大顶堆，双亲结点的值比每一个孩子结点的值都要大。根结点值最大
- Y3 Q$ F  }" O小顶堆，双亲结点的值比每一个孩子结点的值都要小。根结点值最小

% z# h' m) O  i- H1 l9 l1 S# m
# ~/ Y/ N$ w, Q
0 f) w$ m2 m( T! D; S1 ^' T9 _
  W0 h8 E$ ?. R1 q+ n0 Q7 A' @: X简单解释：
构建好大顶堆或小顶堆结构，这样最上面的就是最大值或最小值，那么我们取出堆顶元素，然后重新构建结构，一直取，一直重新构建，那么最后达到排序的效果了。

" M# O* n+ E% o* N( `


8 P* \; D) {1 l& P2 t9 S: |' h

4 d; T) B/ }/ t3 j完整代码：
8 y4 P9 ^' c. u2 p+ M# I$ `- p

1 t9 P) F) I+ b: Fpackage com.keafmd.Sequence;
7 B7 O- D8 b- [/ o
: K8 p" B% G- D
5 \4 E+ J: N; Y' c7 C/**
* v& ]: L+ b& n * Keafmd
% G' [/ e+ x+ c; |  |% b *
* @ClassName: HeapSort
* @Description: 堆排序
* @author: 牛哄哄的柯南
, @/ [* N. }, h0 b' D7 _  ^% ?' c: x * @date: 2021-06-24 10:34
*/
' G2 d. L5 X( tpublic class HeapSort {
( d$ L" h: Z  p: ?2 ~" l, N
2 K  L+ I+ g. o" @! U+ k$ d2 O/ i
    //堆排序
$ V6 X0 A$ {5 A, q    public static void heapSort(int[] arr) {
( d# n: C. M+ |) W6 |: ^        //对传入的数组进行建立堆，这里默认建立大顶堆，进行升序排列
        heapSort(arr, true);
( r3 x$ ]& y3 z: |    }
. Z' B6 ?& K  [& N* s# k
" O- l  u/ @' ~! B7 G
    public static void heapSort(int[] arr, boolean maxheap) {
% G; L6 T  @2 s

1 M+ @" ~4 N7 C, E0 ^0 e        //1.构建大顶堆
        for (int i = arr.length / 2 - 1; i >= 0; i--) {
6 l. ^7 q& h/ H6 j0 q( B            //从第一个非叶子结点从下至上，从右至左调整结构
/ j/ t1 Q( `2 j! B0 X9 d. _            sift(arr, i, arr.length , maxheap);
, y% |4 R4 D+ p: j        }
/ B3 A% j- j/ P, k% I8 ~
0 j, V$ o9 L- Q$ B1 Y- ~
4 n. d' i9 q/ o' |+ ~0 P4 T        //2.调整堆结构+交换堆顶元素与末尾元素
! R6 F4 U! v+ t9 n' l4 I        for (int j = arr.length - 1; j > 0; j--) {


9 q  R% H7 @! T0 [( B3 L            //现在的数组第一个就是根结点，最小值所在，进行交换，把它放到最右边
            int temp = arr[j];
+ b3 d. A( A7 d4 G- @, ?            arr[j] = arr[0];
% n% P# u1 y8 F1 f            arr[0] = temp;

% \* P$ p) Z. A" t) i$ R
            //重新建立堆
, e  J' _8 p$ w# R% `0 U            sift(arr, 0, j , maxheap); //重新对堆进行调整
  `2 k: A- _% k! w7 X+ Q, A        }
    }

# g0 ~( k9 H% ]
6 ?; W( d* @. ^7 p& V. y7 b( @1 v    //建立堆的方法
/ m# t# B6 F4 l; y# T, t* V    /**
, n/ Q0 S6 S. e     * 私有方法，只允许被堆排序调用
     *
     * @param arr     要排序数组
     * @param parent  当前的双亲节点
) J' N0 p, ~4 v$ `3 p     * @param len     数组长度
     * @param maxheap 是否建立大顶堆
8 ]$ H% `7 G9 W6 K) f( z     */
; Q& R+ r9 y, [    private static void sift(int[] arr, int parent, int len, boolean maxheap) {


  U1 i5 V' @: D  Y9 o: Z        int value = arr[parent]; //先取出当前元素i

+ y- Q! y1 U" E: u
        for (int child = 2 * parent + 1; child < len; child = child * 2 + 1) { //从parent结点的左子结点开始，也就是2*parent+1处开始
, j: m! A) }# s( S$ F
. t1 {9 y8 ?' J1 j" T
( ]& T" k% z( a% j            if (child+1 < len && (maxheap ? arr[child] < arr[child + 1] : arr[child] > arr[child + 1])) { //如果左子结点小于右子结点，child指向右子结点
6 Z$ g' s0 F/ R. T1 x5 W                child++; //右孩子如果比左孩子大，我们就将现在的孩子换到右孩子
            }


            //判断是否符合大顶堆的特性， 如果右孩子大于双亲，自然左孩子也大于双亲，符合
+ ?+ e! w/ i$ Z9 Y5 @" x            //如果子节点大于父节点，将子节点值赋给父节点（不用进行交换)
: n& P' U6 @2 p            if (maxheap ? value < arr[child] : value > arr[child]) {
                arr[parent]=arr[child];
9 e' y7 _9 a: _' |& a                parent = child;
            }
            else {//如果不是，说明已经符合我们的要求了。
* ~8 \) s5 M$ \+ J' _                break;
; z+ i3 c8 h6 ?- w' \            }
. Z2 b6 j$ O) i5 N( V. n, v0 r        }
        arr[parent] =value; //将value值放到最终的位置
3 F7 C0 F0 x: ]* c  Z6 w; ~
, i4 A& P' N$ r! g


9 J' @. [  d# U$ I% {3 \& B    }
+ B7 n" f0 J- E: F
" z2 r) c) `* a! f" F
}
1
* G& g/ R! e' D/ m- k1 B. y: W2
3
4
' {/ {& l6 @3 z* N  S5
6
# S: g  N( a* _" I7
6 z6 _9 ?1 N  r2 ]% I3 r8
9
0 p$ q9 N$ n/ n8 U8 X  C10
9 s4 N, K' o% K11
8 V/ w/ J& Y% Q3 L12
13
& j0 \4 O9 ?" ~: h0 I; b& a% n14
15
3 j1 k7 }2 N- z1 `& `16
17
18
19
; s! s* u. X. w20
. c6 h6 Q' g. \' E21
22
1 l9 l) Z# Q: m- Q, L! W" Y( y23
$ c" O6 ]3 J% z- o% }- y/ ^24
8 f: j9 \6 f3 e# p/ P4 ]. u5 X) S25
26
27
: o( E8 c( t( }& B0 b( _4 G" e9 D  u28
29
' e+ Z  n( s, V9 A30
- P% l; T) y- x* W6 z- q31
$ J  n) ^1 m/ D6 e4 N: x32
$ a. ]/ S7 W5 _. J6 V33
& \  y6 T) q& z34
35
36
37
: U  h% Y( ^' E' R+ X( {5 {38
39
40
9 N& ?( [$ o8 m& F! [3 ?41
42
( I4 z  E8 \/ z0 ^" z8 p43
44
& y3 o( F) v5 R& v. I45
46
) `9 ]1 L$ O: ]9 t; s" B' C% ~4 h47
' g7 Y. e, {  p( |48
49
50
51
52
53
/ v( f6 j8 S) M$ |3 V54
55
% j1 J* E* ]3 W8 G7 [( N56
57
58
1 ]/ K4 v1 V1 c1 ^0 Y/ |. o59
60
61
3 n! }9 f' a* M2 ~! f8 f62
63
% j5 @* f3 P% t: U( u, M64
65
. D! y' L) N: ^% E6 E8 q66
67
* S6 A2 U& Y4 Z. ~/ J68
( }& ~( ~. ^# s! R8 x$ i: @& e( W$ f69
70
6 @3 H9 T1 D& |& B71
% b- V9 ]; T3 R9 ^7 Q  e% l9 h0 S72
% `! F7 ]8 `" ^* u1 [# k( h1 P! R( f73
; |6 N$ L. H- f$ ^74
" H& V* N. T* u, P9 ?归并排序
简单解释：
该算法是采用分治法，把数组不断分割，直至成为单个元素，然后比较再合并（合并的过程就是两部分分别从头开始比较，取出最小或最大元素的放到新的区域内，继续取两部分中最大或最小的元素，直到这两部分合并完，最后所有的都合并完，最后形成完整的有序序列）
* E2 V5 X2 x$ f
3 B9 a' ]; K; G1 |1 P
) U! O" ~$ p) S- d
) Q# v8 ]% f: A1 Q
1 ?$ j( b+ m7 T1 v
; g5 A( W" T5 p- E5 c
完整代码：

: X! ]6 Y( `# V) O
$ x* F; L' p* m. C* Spackage com.keafmd.Sequence;


2 o: i4 l# J- A: f$ C0 o/**
2 a' y. E0 [, d, w * Keafmd
' _, w, p; V0 u *
# i; ~" X3 _$ y: s0 P% F* ? * @ClassName: MergeSort
# h, q% l4 L8 [* {. J. X * @Description: 归并排序
0 d6 N- ]0 R7 G8 Z+ m3 M * @author: 牛哄哄的柯南
; O: k& i1 N7 ^( F * @date: 2021-06-24 10:35
; b$ t7 J9 N# x: w* C */
public class MergeSort {


7 ^  y! q6 ~% t" U3 f( G    //归并排序
& H4 g$ u$ q: Y, @) C    public static void mergeSort(int []arr ,boolean ascending){
% R. |/ ~2 w3 w, s        int[] temp = new int[arr.length]; //在排序前，先建好一个长度等于原数组长度的临时数组，避免递归中频繁开辟空间
3 \9 _% A4 _% e$ z9 B" W+ j+ p        mergeSort(arr,0,arr.length-1,temp,ascending);
    }
    public static void mergeSort(int []arr){
        mergeSort(arr,true);
    }


    /**
8 M$ O% {$ h8 {: Z     *
     * @param arr 传入的数组
     * @param left 当前子数组的起始下标
, l3 ~8 i8 R1 ^& e0 U* N! i     * @param right 当前子数组的结束下标
- T, ~- L  W: ?( R7 ?     * @param temp 拷贝暂存数组
& ~5 y! k* A% D) q3 [+ X" i     */
  \) q1 {$ Z4 V, D5 r    public static void mergeSort(int []arr,int left,int right,int[] temp,boolean ascending){
        if(left<right){ //这里是递归结束的条件，我们是对半分，那当left==right的时候肯定大家都是只有一个元素了。
, P5 u) ?( d7 s' a7 G* a
8 u9 e; _6 X0 R- c. o4 X
            //对半分，比如总长度是10，left=0，right=9，mid=4确实是中间分了，0~4，5~9
, \7 x% j9 d5 P7 O. {4 |2 _4 Y            //当长度9，left=0，right=8，mid=4，0~4，5~8
            int mid = left + (right-left)/2; // 防止越界的写法
" u$ x- p' b! {( M5 Z1 e  y; w            //int mid = (left+right)/2;

) d6 t  t7 m6 V9 _3 g# n4 ]1 q
            mergeSort(arr,left,mid,temp,ascending); //左边归并排序，使得左子序列有序
1 _& J) Q1 Y& |- S, w            mergeSort(arr,mid+1,right,temp,ascending); //右边归并排序，使得右子序列有序


            merge(arr,left,mid,right,temp,ascending); //将两个有序子数组合并操作
        }
    }
- a- S; J# _* B- Z2 j  M- V: Z
, N% Q) T( Z# w; E( p. |
    private static void merge(int[] arr,int left,int mid,int right,int[] temp,boolean ascending){
        int i = left; //左序列起始下标
        int j = mid+1; //右序列起始下标
2 B3 V: F* @# D% J- k/ @' x        int t = 0; //临时数组指针
        while(i<=mid&&j<=right){
$ K! B2 f$ n* y: o            if(ascending?arr<arr[j]:arr>arr[j]){ //比较两个序列第一个元素谁小，谁小先拷贝谁到temp，然后对应子序列下标加1
' G" f1 `+ u( \                temp[t++] = arr[i++];
0 \& _' c" J/ W9 z            }else {
                temp[t++] = arr[j++];
8 a! B7 Q. H" R- }7 @            }
        }

  p1 `( q: ~" k% d; f1 Y- u
3 @  s8 `, {9 l3 ^3 v* \        while(i<=mid){ //将左边剩余元素填充进temp中——左序列有一些数总是比右边的大的数
            temp[t++] = arr[i++];
' L- Q, M3 X0 g( t7 H! i/ c. E        }


/ }9 x' F9 \9 I* ?" h# l4 L: z        while(j<=right){ //将右序列剩余元素填充进temp中——右序列有一些数总是比左边的大的数
            temp[t++] = arr[j++];
" r$ I+ i& E' b7 ]& y        }
1 O- Z, b$ G4 |6 |! ~3 X

        t = 0;
0 S  O  c& A5 g* _' Q* @3 |2 A5 E

        //将temp中的元素全部拷贝到原数组中
        while(left<=right){
9 p' ^+ }" p/ |' i            arr[left++] = temp[t++];
4 P6 R6 ]: O  b( Z        }
" F* c8 E1 i  Z, E+ u: h) |' K  l

6 I; k* R+ S5 Z$ g- e" f$ l5 o% v    }

! z$ A% G# N2 w8 G) X: v
/ `1 d* o1 P# N. ]* q" l5 s  q}
1
2
3
! s  D4 n4 q& w* \4
5
6
  {2 J% ~, Z4 d7
8
9
10
11
12
4 G; f+ f8 R2 k: ^1 y7 g( B' Z13
/ M9 k" ~0 `* ?+ H3 O+ D$ m# o: E% \14
* Q2 w) K( w+ F* p8 ~* A0 \15
9 y1 M' ?8 F$ |* `. S2 O& W, b16
/ G% ^0 K. `3 R- h5 M; H17
; c% w* D! z" ]( M18
19
  p9 ]. `' D8 `( x6 l% m$ F, B2 Z20
21
22
23
24
" x1 e! C, c" ^$ U, x5 u8 F25
26
0 l6 E4 J) ?+ {1 s# w27
- X3 h: T; r# p# V) K9 s% j28
29
3 \9 a: ^- Y, u! L) {; V7 S. ^$ b30
1 ~9 J1 E- i* v8 v+ a$ v31
32
33
34
35
36
) D; H2 |/ D" O5 k( j' H37
38
5 r4 \( T. ?: V39
0 ~$ @* t; D" b( L# f  v7 m40
41
8 Q( W4 i- w0 r' p9 D$ i8 e42
, l. `, n) G' J" }+ p' o43
44
45
, S0 Q7 ]# ~  u! a46
, W. L/ |. q# p) {3 T  O8 \- K47
48
2 V0 Z8 s3 d1 P$ l" ?6 @49
50
" `: M+ A5 U3 w. d0 V* J3 Z" Y51
52
! @, F. x( j1 @! Q0 ^* L0 a53
54
55
56
$ b) M- t" ^$ b' l: B8 O$ b57
58
59
( `5 e' G7 z3 [* Z: v60
  u0 S7 |0 r+ T: K' u61
5 W; W+ x( D! q' G) y# G  Y. u, \8 I7 Z62
63
! ]4 S. _* r; a3 X4 l6 t1 t' q7 F) Z$ ?64
65
66
2 M3 l* d& t6 n67
! `" }1 F4 ~3 D6 |- F68
69
70
' j) W3 Q0 |! g) n8 H- h: E  F7 L71
72
& K& `4 [1 k% c$ m  s7 q73
5 U+ c7 P7 l) Q插入排序
简单解释：
- Y4 F0 D0 B# I' Y最简单的理解就是打地主时我们拿到牌后的整理过程，从第二个牌（假设我们拿起来这个牌开始比较）开始，（说下升序）从后往前比较如果比前面的那个牌小，就把牌往后移动，直到找到一个合适的位置（这个位置的前面的那个牌不比这个要放下的牌大）就把这个牌放到这个位置，慢慢的前面的部分变得有序，直至全部有序即可。

) H; [8 q/ }. I# I# s/ i3 |* t

: O2 t3 r& a2 s( C8 `+ X' z

6 K0 ^" [* |% [: s+ f
完整代码：
4 l7 I, \  n' L% q, F# R

package com.keafmd.Sequence;
$ o  k# L3 Q! f( L3 _& n

/**
* Keafmd
*
* @ClassName: StraghtInsertSort
* @Description: 插入排序
: O0 W+ z3 y( W) y! _+ } * @author: 牛哄哄的柯南
" J# l% Q' e6 u& {+ ~ * @date: 2021-06-24 10:36
% N+ s4 _1 j/ Q/ } */
( u( K- L( g9 Zpublic class StraghtInsertSort {
    //插入排序
    public static void straghtInsertSort(int[] arr) {
        straghtInsertSort(arr, true);//默认进行升序
5 W5 R+ c+ g' ~& E" a$ _2 g1 g5 T    }
! ]. j% {7 r2 E1 H7 W$ E+ r

9 A7 Q. P( s8 Y+ v' Q    public static void straghtInsertSort(int[] arr, boolean ascending) {
4 B1 n% q( }# ]/ e8 s; ]

* j* x/ o- m% u3 Q2 i  Y        for (int i = 1; i < arr.length; i++) {
            int temp = arr;
5 X+ `  D6 G9 F: H7 e  Y4 }& q            int j=0; //这就是那个合适的位置
            for (j = i - 1; j >= 0 && (ascending ? temp < arr[j] : temp > arr[j]); j--) {
                arr[j + 1] = arr[j];
: B: r  _2 ^, G7 V7 J            }
            //把牌放下，为啥是j+1，
/ h% C( S# b* b% ?            //是因为上面的循环遍历到不符合情况的时候 j是合适的位置的前面的那个数的位置
            //有点拗口，但是就是这个意思，看图方便理解下
            arr[j + 1] = temp;

1 h4 o6 l% Y9 ]4 d, d, q4 M
: O( {# K( n2 D& p4 F" I
! c% D; z" I2 s/ e
! o( @0 Q/ B- C( `1 y, p. e        }

/ ~' ?4 {) f( |2 `5 Q
    }
}
1
2
3
4
$ `; E7 y: V" e% G5
9 K1 C1 e! v% d" j/ A3 A# b6
, @! Z. G7 x4 A9 {& F4 N7
9 C* C/ e" o; h; I' H8
1 y6 e) l1 j3 k( ^7 V9
7 N/ ]9 C$ e' N9 S9 |10
7 R" {  X+ h' t/ j5 y) @- D11
0 F8 ^7 N% T. d: ]" `12
13
; E9 }5 j; p& ^! N) D14
$ }  i7 V5 o( ]* n. a15
16
17
18
19
20
21
22
' d# i: E- j5 G7 `& R6 v23
  q+ f8 @0 M1 Z24
25
26
27
  ^, s$ Y6 a% u- c( E  c28
29
30
31
6 k; p1 @% O* s32
: T( K. |1 W8 d" d6 k. `3 {- P+ \33
5 P! S6 C/ `7 U34
8 _8 ]( g) o! A$ Y! \希尔排序
简单解释：
希尔排序是插入排序的改进版，我们理解一个叫做下标差的的东西，也就是下面那个图中的增量d，初始下标差为arr.length/2，然后继续/2，对在同一下标差（相当于把这几个数单独拿出来了）的若干个数进行插入排序即可。
" J% `0 _+ A6 r' W3 [! ^; Z, o

' W! _0 ?3 G1 i! p! z



完整代码：
/ {5 @* v2 k# n  v% i

package com.keafmd.Sequence;
+ q/ D; V! `2 Z- ]& C( K3 o& \. n; e

/**
* Keafmd
*
. T1 T1 s% p& _$ k5 K( ` * @ClassName: ShellSort
5 r; \2 `; Y  |5 T( j: r * @Description: 希尔排序
3 {$ q: v1 }4 D/ K$ V1 [ * @author: 牛哄哄的柯南
+ G1 ^! q4 q7 u3 E; d * @date: 2021-06-24 10:39
/ j! e" ?. E( X0 I. O& b */
public class ShellSort {
* v/ J* E+ i; m2 q6 h

7 X. Z2 C4 C0 I: b    public static void shellSort(int[] arr) {
8 D' R0 h& s" X3 E' O5 R        shellSort(arr,true);
2 v% O* M; f# u( O3 M2 |* p: p& u    }
5 \3 X9 H3 m6 S9 q# Z% M$ l- u

. P" d- b" B" ~; D7 l1 l2 m    public static void shellSort(int[] arr,boolean ascending) {
& g7 J3 ]( X% R5 Y9 b

. n0 N: I8 C+ F        for(int d = arr.length/2;d>0;d/=2){
# r& l' t  V2 ]5 L2 \

            for(int i=d;i< arr.length;i++){
                int temp = arr;
. k" J! U: C5 x1 ]  G- w4 [+ A                int j=0;
1 J; I7 j: p" K5 F3 l( V+ ~* b1 v                for(j=i-d;j>=0&&(ascending?temp<arr[j]:temp>arr[j]);j-=d){
7 N) M# r# }4 n7 f4 `+ @- o                    arr[j+d]=arr[j];
                }
                arr[j+d] = temp;
            }
        }
8 P0 T* l- y1 q& U' \  b
, F7 k1 d- @5 A: [9 y
7 ^3 H# M1 W/ }    }
}
1
$ E1 B6 i+ l1 N! C9 f% C6 G/ L8 p2
) \5 _! U! h. ?0 M  I9 q  [* i- x3
0 r. b# c5 ?! n' o4
5
  C/ F+ l3 O* Y+ l2 s6 o# @# P6
7
# T! j: {. a$ l2 u/ D1 ]+ k; h* r( V8
9
3 g2 U8 C- g% M+ g6 r8 P10
11
12
13
( h( O) b4 E- k! q& ]5 F14
. p$ `  e! X2 E3 [* B15
0 _& T$ s3 Q+ b- c, L' C8 M16
17
: B& b' R% v& d18
19
, `1 \9 n$ n& F4 g# n! ]20
21
22
, z( a( i+ `/ ~# S; ~$ p* }) ?5 J) @9 O23
24
25
- \+ ^+ ~/ y* J" x26
( T3 a, N( Z/ x. P; h- m27
1 y6 I0 i! v3 ~+ O$ P1 E28
' M. `- E/ `) f) P& T4 S' f29
8 o! J! x, t$ Q30
31
5 k& q; a$ s0 R9 g; I2 x9 _& c, w9 B32
' N0 N+ f# U7 o! B计数排序
, ~. R# Z: \/ A! w简单解释：
这个排序算法看名字也很好理解，就是就是额外找个数组来计数，然后在这个数组从小到大或从大到小把数取出来即可。


. w4 d; U3 Z9 L+ r8 d2 |1 o" q

+ z3 ]. ^& s5 `, [

完整代码：


$ S( }1 U. q. k0 zpackage com.keafmd.Sequence;

& a* f% U7 H, v: f6 i' h6 Z; E" B
/**
* Keafmd
*
* @ClassName: CountSort
1 _( ~$ J+ C5 b * @Description: 计数排序
3 r8 E4 Q  \* J * @author: 牛哄哄的柯南
* @date: 2021-06-24 11:31
; ?' \* s& A/ l9 | */
- ~4 w) d. o& R! Mpublic class CountSort {
( v4 T, \9 B' g4 ?. o8 S4 v

    public static void countSort(int[]arr){
        countSort(arr,true);
    }
  f4 u' i2 f; }
7 H: }% o; F, E& [
    public static void countSort(int[]arr,boolean ascending){
        int d,min=arr[0],max=arr[0];


" e- K: L5 U$ l        //找出最大、最小值
        for(int i=0;i< arr.length;i++){
            if(arr<min){
                min =arr;
            }
8 Q5 I( f" T% l9 K* J            if(arr>max){
! f# Y; @+ i8 Y6 P2 V                max = arr;
            }
        }
) O) J9 _$ {4 u/ o; W& ^6 u
4 r/ @6 {- A) ~- A* o
        //建立一个用于计数的数组
! T% s7 P% c4 f) N6 J        d = min;
        int[] count_map = new int[max-min+1];
, J5 ~- c3 E6 n  b, Z1 D        for(int i=0;i< arr.length;i++){
' j! E3 I; A$ T* y            count_map[arr-d]++;
( c; l# y9 r" R2 K; n+ J        }
9 j1 q$ f7 X( e  {
6 Y# N3 q# a/ \
        int k =0;
$ @" I! P" r5 s9 n        if(ascending){
" E( }5 `% R  E- L" u  n/ v            for(int i=0;i< arr.length;){
/ J: s" u6 `' o7 w  o6 y$ c  L                if(count_map[k]>0){
                    arr = k+d;
                    i++;
                    count_map[k]--;
0 v0 u9 b# b) Q# N                }else
8 V: L( U2 ^+ Z. f                    k++;
( t$ I  m- }$ l- V/ s            }
        }else {
1 `' _* @' \3 k  S4 v; F6 L& F            for(int i=arr.length-1;i>=0;){
: I+ m6 R: C7 ~9 N: n& u                if(count_map[k]>0){
                    arr = k+d;
                    i--;
' A1 e6 |" R6 ~                    count_map[k]--;
                }else
                    k++;
            }
5 H4 v9 `& i( ^  U! T5 ^        }
+ W+ O" L; ^1 f, Q" K( z- Q
" F2 i/ A; D8 t) v  ^0 Y
    }
}
% G4 K" E8 L0 w0 i& l7 b# Q1
6 y% v, k* |- B0 q2
, l3 A  H% K+ r6 J5 {# }/ C8 @/ W3
4
+ E5 B+ M/ j" A7 t0 ~5
6
7
1 W# F- S8 L( ?/ i* V. I8
9
  f$ x& D( j  ?  Q10
2 A& A2 e, A! b1 X11
12
13
) g. u5 b6 s) ^5 ~) M0 C14
" Q$ P' }' l5 F- n/ |3 m15
; @7 j1 ^' f- w, r- ~  J16
& ^. K4 M7 {( J0 M17
/ s9 E' }3 S8 Z8 w8 `& X18
- `7 p$ J6 `- `19
* K$ \4 @" A- s20
21
22
23
24
25
+ j& `9 z% P" h& L9 o3 N8 B1 L. \26
; V( |9 |2 A- O. b5 S7 z4 W9 H5 M27
28
/ @; f  a; e0 _& W) d9 {. a( }29
- m, {- q% w% B5 v5 X30
31
% g4 Y/ h, }0 h: T1 ~, ^8 P32
33
9 q! Z& b3 T* e+ z4 U4 S34
$ v4 i2 O" x4 T% \7 \' W6 x35
! Z' A: q3 D; B9 @0 i: ]' [36
6 W9 ]6 c5 k- c* w! _1 W" K4 a37
5 R8 S& M4 H0 l, r* R4 \" `38
39
40
1 [: }! K# }7 j+ t) s; l41
42
" o0 \( T' R- M43
& u. G7 {9 O6 B( e2 s$ ]' ^+ P44
45
5 U1 r' W* k7 [46
47
48
49
50
. D! {$ Q/ N6 o4 j51
6 Y, {3 E2 F" o4 v7 g9 f! G8 D52
53
54
55
56
57
58
* p$ G( J) P1 S- D) H6 ]59
: x# T0 f; x/ `$ O0 W3 k" ^桶排序
简单解释：
. s$ g( p  F8 O/ I就是把一个数组分成几个桶（其实是几个区间，从小到大或从大到小的几个区间）装，然后让每个桶（区间）有序，然后取出来放一起就可以了，相当于把几个有序的段拿出来放一起，自然还是有序的，当然需要是按照区间的顺序拿了。
5 N9 W( i; C3 H3 U

% k0 m7 e) g- P+ d' Q2 P

( Z' v6 G( G4 |5 U
5 i1 ~* C% c1 X6 O& r3 O
完整代码：


package com.keafmd.Sequence;
2 J& W6 u6 a( F  z* C
5 k% r2 T! q) D4 H1 z2 n/ A  W
import java.util.ArrayList;
import java.util.Collections;


% \. ?+ |, i* ]/**
. c) g( U- q8 o, Q# \; v2 L5 M* J * Keafmd
7 Q2 ?/ E+ [5 z8 B2 _4 T' J, x *
* @ClassName: BucketSort
% B* O( {% w( c" {1 `3 ~% U; G# O- h * @Description: 桶排序
' C, _* X  _- E; `+ r, R4 e * @author: 牛哄哄的柯南
6 o4 T& _- u$ ~0 B * @date: 2021-06-24 13:32
*/
( I4 ~1 [# n9 v3 E. L4 S8 v% Upublic class BucketSort {
0 w% i5 m. E) k
. I! j' a0 ^* F- T
    public static void bucketSort(int[] arr){
/ i! z4 Z+ Q$ z2 M1 a6 s        bucketSort(arr,true);
    }
6 \6 W: W- r& A/ z9 i* E# _

: |" ?' y* \/ `# G    public static void bucketSort(int[] arr,boolean ascending){
" M6 t! z- X" z$ p  W% ]        if(arr==null||arr.length==0){
. u8 d: @0 K  u            return;
! }/ [" m. V, o5 f$ U; `5 i" P        }
' s& N% e9 m% H1 R) m0 P; V0 G        //计算最大值与最小值
        int max = Integer.MIN_VALUE;
0 n6 W4 Y5 X* b        int min = Integer.MAX_VALUE;
' k4 J" H- R% x        for(int i=0;i<arr.length;i++){
            max = Math.max(arr,max);
            min = Math.min(arr,min);
        }
6 f, l7 E" d8 Y* _

) R/ V% Y  S  ^2 j1 _+ ~8 w        //计算桶的数量
        int bucketNUm = (max-min)/ arr.length+1;
        ArrayList<ArrayList<Integer>> bucketArr = new ArrayList<>(bucketNUm);
        for(int i=0;i<bucketNUm;i++){
; v' C/ h& d9 B, G            bucketArr.add(new ArrayList<>());
        }


        //将每个元素放入桶中
        for(int i=0;i<arr.length;i++){
3 Q( ^6 g. @3 Z# ^" i( ]            int num = (arr-min)/ (arr.length);
1 N+ C' H/ u5 c" T/ c# H. M            bucketArr.get(num).add(arr);
7 {5 u* B; e' q1 L        }
) e2 k* C$ H! o" \" ?* e) A& |- G4 `
) m# N9 G* M. |- R
) {  r9 l4 l1 S2 G% q        //对每个桶进行排序
        for (int i = 0; i < bucketArr.size(); i++) {
            //用系统的排序，速度肯定没话说
# r, Z/ w; \) G/ |( f2 ^            Collections.sort(bucketArr.get(i));
        }
  x: b1 M  s4 |6 e+ y
) T5 U% R  y, F: @0 x" J
        //将桶中元素赋值到原序列
, C6 q9 `1 q1 M        int index;
        if(ascending){
0 m/ x$ R: @! N5 C            index=0;
9 g- N' I: N* i- J7 h% r/ K9 k' Y1 M        }else{
* x, w* }. u: Q            index=arr.length-1;
+ v4 W9 f, a+ c2 B% Z$ Y  m# D0 G        }
. H4 o9 O# a( ~5 y

        for(int i=0;i<bucketArr.size();i++){
            for(int j= 0;j<bucketArr.get(i).size();j++){
4 z2 G% C0 f( L- Z1 \                arr[index] = bucketArr.get(i).get(j);
                if(ascending){
                    index++;
                }else{
7 v/ c! E9 A# [+ v                    index--;
  f3 T, C* F$ A5 g$ w                }
            }


% b6 S% D  X' L        }


# g, }" N' q/ N0 J( f( ^    }
. h; @! C7 L! E: Z" [& {* d; ^}
/ v: Y' g& G) |5 Z1 x1
2
6 d' g. Z: J5 G; T: E" D) |3
: j; Z# n& w4 l/ c( _4 d" `4
) R, ?, P  W; I5 h. b$ e5
/ k; P7 d* c( ^0 g: R6
7
+ }* M, e( _" Z! d) Z) ^: i8
9
10
0 D( Z* T1 T1 \& O9 P: J) m11
6 V& V! K; @% @' H8 O% U12
13
, x7 C8 V4 b# Z1 w% F5 `+ F14
15
16
17
( C/ `3 s4 }( V( i, |. C" n7 p0 l/ A& v18
! k- x5 [* s3 X' e$ _# S# S1 ^19
$ v) I& H' v/ t7 m20
7 U  |' x! ?- v1 i/ n- p21
22
. b% @4 e& i+ _! o& f+ N0 ]23
* D% V4 m# L  G24
25
26
6 [  g; O6 J4 F+ A* K" P# P7 W27
2 D( B: c5 X" Y28
9 r* _& Z- ~3 q3 i0 O% U29
# t& v& ~' j7 h% R30
31
32
: u9 h% c3 h! F5 R33
34
5 l% r0 X% {- J4 [: {! f' k35
/ @4 i: H- d+ ]" V7 z( w36
+ g$ T$ ~5 M- M- _37
6 A5 a) m6 ]5 M) s8 h% q5 _38
39
/ X0 Z' J. C& |8 d) P' ]- F40
7 v4 ?, B2 ?! W% D, Q- Z7 y41
: ?- A) c' `# K+ ]8 Z; \  P42
) I* w8 b' q; n5 k: D( e* L43
. ^  G! ]8 l4 E5 X2 ^* g: V44
0 U, f% [& k" }" ]4 U1 I4 i5 w45
3 ]+ b, A" ~9 n9 L+ m3 O- W" D46
" X( {  L7 z0 Q1 _9 N% |47
48
: H6 |& O& S3 z6 i$ B49
4 x, l1 ~4 e) u  j' n% A7 m50
# ^6 h! e- K/ x% r51
52
53
6 z0 W8 L, e! |1 h7 d6 u% P* F54
55
56
57
58
59
9 ^" U) y6 I  N4 E60
& c3 i, ?: k' U' O3 e61
0 g* \/ T' ^( S7 k6 f62
63
64
8 `5 T5 A0 z  P4 S" z6 v65
66
67
68
69
4 p4 z8 d3 @2 @2 ^0 F70
* r! v2 U0 L. C' f; {71
72
基数排序
$ g/ ?/ T) I! Z+ `- J3 p. ^3 D& J简单解释：
0 ]; ?- R# |& n" \: O首先说一下，我发现好多人写的基数排序只能排序正整数，其实只要处理下就可以排序含有负数的了，就是我们排序前先把所有的数整体变大（就是减上最小的负数，也就是加了），都变成正数，然后排序好之后，在减下来（加上最小的负数，也就减了）就好了。
基数排序就是按数位排序可分为LSD（从最低位[也就是个位]开始排序）和MSD（从最高位开始排序），下面写的事LSD基数排序。
: J/ N3 x4 h" [7 b  T基数排序就是把数按位考虑，让后我们一位数只能是[0，9]，就是我们在考虑某位（个位、百位· · ·）的时候就只看这个位的数，放到在[0，9]相应的位置，然后顺序取出，最后再按其它位这样操作（上面说了要不从低位开始到高位，要不就是从高位到低位）
/ h; h% x: I" O4 y! Y
1 x; z: [9 d5 B0 \5 e


* K2 k. [: X  a& ^8 F8 [
+ Z* Y2 t+ n$ g' v1 A+ x
4 ^8 h: _# P! ^7 R- V) Y完整代码：

: c. L0 u) ]: ~' K: \
* |3 s6 I" H3 F0 g" r$ ^4 T7 S% F7 wpackage com.keafmd.Sequence;

) z' j* x) Q+ W) \+ X2 |  p
/**
* Keafmd
' O$ A  R( Q; x1 m- h, ? *
3 F3 g  m6 G: u * @ClassName: RadixSort
3 Z. M1 a# P7 K9 R: I * @Description: 基数排序
; I5 i, p2 C% O0 v * @author: 牛哄哄的柯南
  L* k1 @0 m' g% D5 `& W4 n * @date: 2021-06-24 14:32
*/
/ b! T: x- I& {* a) Jpublic class RadixSort {
    public static void radixSort(int[] arr){
6 P7 h+ x2 d" d9 Y$ P2 a" B        radixSort(arr,true);
    }
    public static void radixSort(int[]arr,boolean ascending){
        int max = Integer.MIN_VALUE;
! d1 R5 O5 j* C        int min = Integer.MAX_VALUE;
$ g6 f9 V. s. V* f$ k9 v. y9 M1 B        //求出最大值、最小值
: `2 r2 g) [# G6 G; b! I        for (int i = 0; i < arr.length; i++) {
, O; s2 y3 {4 v+ f3 G; ~9 a            max = Math.max(max, arr);
            min = Math.min(min, arr);
. B  X: J/ x: z6 v4 V. `3 _        }
9 y" s+ L& B; U. F) U3 M3 l/ f        if (min<0) {        //如果最小值小于0，那么把每个数都减去最小值，这样可以保证最小的数是0
; Y: P4 R* Q$ G; S: z3 Q! @            for (int i = 0; i < arr.length; i++) {
4 g' }# m' ^+ E3 Z" d                arr -= min;
, k7 H6 s# e8 ?. T            }
3 ~* Z# l) `: Q: B7 l            max -= min; //max也要处理！
        }
        //很巧妙求出最大的数有多少位
# l8 z( c3 n" P7 Y        int maxLength = (max+"").length();
        int[][] bucket = new int[10][arr.length]; //一个二维数组，一维代表0到9，二维存放符合数
7 B$ Z3 X# L8 Y# N4 `# ^1 _        int[] bucketElementCount = new int[10]; // 用于记录0到9某位存在数字的个数
        for (int i = 0 ,n = 1 ; i < maxLength ; i++,n*=10) { //个位 十位 百位 这样遍历
' ~1 Z9 f! ]: ~( D$ m# m3 I8 B            for (int j = 0; j < arr.length ; j++) {
! o' g$ o3 v3 {                int value = arr[j]/n % 10;
                bucket[value][bucketElementCount[value]] = arr[j];
( l) ~: Y) Y9 g. H7 l; Y1 g                bucketElementCount[value]++;
            }

. U* n$ J0 Q7 ?- `! w+ ?, J
8 Z/ i' ~$ I& l7 i            //升序
& X9 K1 f9 L/ d9 ~- W            if(ascending) {
( D: r" S3 Z$ W; a6 N$ _                int index = 0;
4 ^# B* l8 V1 ^, `5 n                //从左到右，从下到上取出每个数
) w6 N% z* F6 W/ e. {4 H6 U) j9 c8 d                for (int j = 0; j < bucketElementCount.length; j++) {
                    if (bucketElementCount[j] != 0) {
                        for (int k = 0; k < bucketElementCount[j]; k++) {
+ Z4 d2 T1 v7 x* u* ~                            arr[index] = bucket[j][k];
! k/ E0 h1 A; s6 A5 t6 T! Z                            index++;
$ D% H, M# p' K) _$ N; _                        }
                    }
                    bucketElementCount[j] = 0;
                }
            }else { // 降序
                int index=0;
                //从右到左，从下到上取出每个数
                for (int j = bucketElementCount.length-1; j >=0; j--) {
" X9 y8 Z4 t# N: S                    if (bucketElementCount[j] != 0) {
5 S; u/ ?0 z* x+ D) _* X5 `' O                        for (int k = 0; k <bucketElementCount[j]; k++) {
7 ^: v/ f/ ~; B( [$ M                            arr[index] = bucket[j][k];
& V2 a% d4 b2 s9 `  O; I                            index++;
                        }
, b4 L, G0 Z8 i7 t                    }
7 \% L& f" N* t2 w                    bucketElementCount[j] = 0;
1 ~1 M0 P2 w9 _0 Y                }
6 C, z( ?8 h% E. N            }
& z4 V6 z( e$ N3 o. P7 @9 t
- h( P* \! |1 Y  P+ r

8 \$ {6 |6 x$ O2 e9 m
            /*for (int i1 = 0; i1 < arr.length; i1++) {
                System.out.print(arr[i1]+" ");
            }
/ ?7 _$ s" K2 p: K            System.out.println();*/
6 A0 n/ g0 ]. ]4 O# q
1 r; W7 o" t5 w9 T9 x




        }
8 q& \7 ~% P' k! r1 X* P% Y  r        if (min<0){
. N  E9 V% E. C. M# e: h            for (int i = 0; i < arr.length ; i++) {
                arr += min;
            }
        }
* j, N7 v+ D( a7 z' W

    }
0 H% d0 {$ X. q) F" f5 r}
1
2
. r/ x( X  ]+ d5 p7 ?7 K3
4
( |. u% J3 v7 k5
6
7
8
9
: S7 m$ D3 W0 x# \10
11
12
13
1 M& v$ W# i. N  [7 T14
15
16
17
18
19
- ]- y7 Z( F( K( L1 M20
" _& K; |& _& x; Y& H8 S1 k21
22
7 J8 W1 C. a5 G9 V1 g! Z3 u) p8 h$ H23
24
25
26
27
' e) h" v. {/ T! e28
1 z$ Z1 p$ }' J& s& Y0 y29
% D( |) g, v& |+ a30
31
32
33
34
35
36
37
38
39
40
41
/ f, p# Y+ |1 e% s! W$ [42
: u' g1 z5 c& I* A- ?0 F1 O8 |- n43
44
45
6 x1 s9 p9 Z7 u: @+ q46
! b5 I1 @. [2 V  x& D6 c: D47
0 x! p$ o& m! C) K6 P( ]48
49
50
51
52
; s+ ^5 N- U1 h3 v6 r9 i# Z. Z5 u8 V6 h: R53
54
55
2 p# f" f4 I  z" F! D56
# B) O  R2 Z, `. D- h- C3 z% N57
" [' F: N' t+ I) H0 e; N58
+ C5 X* f$ g7 X" d  M, ^59
2 s5 ]# m& J7 h& h) w8 |2 D60
61
0 ?. i8 P( M+ u* t62
0 t' V' J. ^8 z: u( e63
  m& s6 ]4 J+ _! F% |$ q6 m64
$ D- l5 Q& u1 r' a- S65
66
67
68
# A$ j! e  R& W! @69
  j8 A  ^, }; V) s, Y+ R70
71
/ L: B8 _5 B) C" Q72
% R0 R% z! E! M0 F& m( f0 Y- D# y73
74
75
76
77
* d$ `2 e! X$ B78
& t2 o4 d3 [" I79
; t- z6 w5 }, s80
% l8 O$ Y* K  {, p. J81
2 r4 d; X: o) K6 j1 f9 ]82
* s8 i1 [4 ~2 V5 M! c% v6 }, P83
! [2 x6 N# u; C1 o6 y5 H. ]完整测试类
package com.keafmd.Sequence;
! I4 t: j+ e" ~- _) g- j! r* o5 S

' b9 Y& b! S0 u4 limport java.util.*;
+ J, p8 g2 F& `/ @* ?* iimport java.util.stream.IntStream;
& k7 w) D# }  A* V' timport java.util.stream.Stream;

/ ~0 J( Q2 i& U% y
/**
$ E6 T3 y0 _. A) o * Keafmd
*
1 O# O2 }/ G$ r2 q1 F8 T: t * @ClassName: Sort
* @Description: 十大排序算法测试类
* @author: 牛哄哄的柯南
+ m9 m8 ~. f/ i& l6 q( G6 P( V* X * @date: 2021-06-16 21:27
7 Y' d; d" g' l4 \! B) X1 i  ^! B */
public class Sort {
( n7 a3 _& r9 J3 s1 M2 [% ?
$ C* {6 ^: L# v. K' M/ t
" G0 T# w" J  I  [4 e+ T# I

/ ^! g7 I/ I" R5 r    public static void main(String[] args) {
; j$ t) D' }7 Y8 E1 j  P
; J/ v; e& L5 h% t1 `( y, d: @+ ~
* x# E! T, N% H/ j( l/ @        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};
1 r. O. I) H3 f. A        int[] temparr;

* C$ a, x0 H; |
        //利用系统Collections.sort方法进行对比


        //将int数组转换为Integer数组
        //1、先将int数组转换为数值流
# O/ g$ s9 e9 p4 E9 Z% Y        temparr = nums.clone();
        IntStream stream = Arrays.stream(temparr);
        //2、流中的元素全部装箱，转换为流 ---->int转为Integer
        Stream<Integer> integerStream = stream.boxed();
2 S; Q* m7 R9 F        //3、将流转换为数组
& b/ y, t6 V/ p" u+ B) W  I8 Y4 q        Integer[] integers = integerStream.toArray(Integer[]::new);
0 V1 @1 X0 \+ k9 {# {6 Z) ^        //把数组转为List
) d! [; ]% z9 O& e& `        List<Integer> tempList = new ArrayList<>(Arrays.asList(integers));
+ ^- L* b; m2 y6 B8 U' J        //使用Collections.sort()排序
! c  E. w5 R+ H$ S3 n) r! U+ c3 j        System.out.println("使用系统的Collections.sort()的对比:");
9 [& B/ h+ o/ {4 P
3 y2 K* ^1 B% r( i
        //Collections.sort
        Collections.sort(tempList, new Comparator<Integer>() {
  e4 c8 p# a8 O- A# S: Z. y            @Override
            public int compare(Integer o1, Integer o2) {
" C5 O. z. d5 f0 w0 S4 `) e+ y5 B: t2 {                return o1-o2;
$ T& p9 {% ~+ ~, f% V                //return o2-o1;
            }
" i- U+ d1 |! R1 z9 l7 P# s. w        });
- d! ?, L, h: l. l9 ~
; Y/ C6 v# K% V# F, y
        //tempList.sort 也可以排序
       /* tempList.sort(new Comparator<Integer>() {
            @Override
            public int compare(Integer o1, Integer o2) {
                //return o1-o2;
3 {1 ]+ @! {- ]! @, w+ `                return o2-o1;
3 h6 [) D) h7 J) R' G' u( \! T: h8 K) l            }
        });*/

* k/ q2 y) s3 m3 Z
        //遍历输出结果
        for (Integer integer : tempList) {
            System.out.print(integer+" ");
6 s1 i/ E0 n: p# ]1 E& O: T        }
; g! d% k3 S/ g6 x

        System.out.println();
2 K5 V- E3 B; d/ u9 N7 M
& x0 |; q, r, x7 F1 o9 ~) Q
' s! l6 ~+ C- H- [$ N0 ]        //测试冒泡排序
        System.out.println("测试冒泡排序:");
, h" D* |9 o5 M- G2 u, w        temparr = nums.clone();
; Y# B& {/ ~; d
% S' C$ s6 G& v9 ?4 g+ {: U( i
        BubbleSort.bubbleSort(temparr);


+ Y' R: W! a/ E6 {" B        //降序
        //BubbleSort.bubbleSort(temparr,false);
- s$ Y0 C8 M; L1 f. i0 h7 Q
) T. ?& E+ x& i. g
# o, K7 W0 g3 c0 |' H        for (int i = 0; i < temparr.length; i++) {
, N9 ?# q- Z  w3 L0 R; W# }            System.out.print(temparr + " ");
        }
" M$ J# C: Y3 F        System.out.println();


: g. A4 ~% E9 m2 f3 W  r2 b        //测试快速排序
        System.out.println("测试快速排序:");
        temparr = nums.clone();
# J6 y9 G' _: A! O/ F        QuickSort.quickSort(temparr);
0 H: ~8 J8 a; F( P; K# A1 ~        //QuickSort.quickSort(temparr,false);
& z! M( Q2 w! S0 S+ {0 n# V        for (int i = 0; i < temparr.length; i++) {
% m6 q9 `$ ?& J5 E/ B& d# \, ]8 ~            System.out.print(temparr + " ");
8 _( A( I/ ^3 h        }
* |  p) A" d. F% n& C! P! N        System.out.println();
* O( \8 |8 b7 n" `
1 _) C, b* ?" K- z9 X0 G1 t5 h
        //测试直接选择排序
$ ]5 k9 i7 t% L0 }( z" a5 k9 F        System.out.println("测试直接选择排序:");
  l, P5 s/ x; K) P  @' \# D) v  s        temparr = nums.clone();
        SelectSort.selectSort(temparr);
5 f5 G0 z) D. L7 R& ?, F        //SelectSort.selectSort(temparr,false);
        for (int i = 0; i < temparr.length; i++) {
8 r& w: _1 S- K% d+ ^% ]            System.out.print(temparr + " ");
        }
: f* l; i4 e: `) V8 o        System.out.println();
+ {3 u& F" J# U

# H0 \! g! F7 {. ~6 B        //测试堆排序
( o* O9 }' N; K  N5 X9 ?) b        System.out.println("测试堆排序:");
) [2 \; t. _9 l+ X4 b        temparr = nums.clone();
        HeapSort.heapSort(temparr);
        //HeapSort.heapSort(temparr,false);
        for (int i = 0; i < temparr.length; i++) {
! K: I" |9 G+ ?/ t/ B' \            System.out.print(temparr + " ");
) n( B" A& L! `- o" V0 B% d$ N        }
        System.out.println();


        //测试归并排序
0 p6 j( f- R- y* R4 Z        System.out.println("测试归并排序:");
        temparr = nums.clone();
        MergeSort.mergeSort(temparr);
        //MergeSort.mergeSort(temparr,false);
        for (int i = 0; i < temparr.length; i++) {
, d/ k9 l& r) x( Z- g; A            System.out.print(temparr + " ");
        }
        System.out.println();
7 t& {, z/ c( v' J; a/ Y

" g3 |0 x2 ~7 @) U* [        //测试插入排序
        System.out.println("测试插入排序:");
5 p& J8 }0 X. n2 a; s  t+ w        temparr = nums.clone();
        StraghtInsertSort.straghtInsertSort(temparr);
' h9 j; Y# `5 z) l, k( A        //StraghtInsertSort.straghtInsertSort(temparr,false);
: z3 u5 ]2 g- l5 `8 [$ T        for (int i = 0; i < temparr.length; i++) {
: J8 ?& W$ {4 O. c            System.out.print(temparr + " ");
( B( ~% u/ e7 L, {. F+ w/ l        }
% ~( I, g% K3 B2 U        System.out.println();
8 H8 h3 ]9 O# B1 M



8 k* d( b; v6 Y7 Y5 T/ C        //测试希尔排序
        System.out.println("测试希尔排序:");
) Y2 k/ u+ V0 T9 y5 K; v! I5 k        temparr = nums.clone();
        ShellSort.shellSort(temparr);
        //ShellSort.shellSort(temparr,false);
        for (int i = 0; i < temparr.length; i++) {
            System.out.print(temparr + " ");
        }
' {- ?3 e, K2 r( [7 B5 v        System.out.println();

, J1 ?) X( |3 k" A1 [) _
  m+ b0 Y, p4 J2 Q# z3 A
* _  G, [% [. D- Q& H
$ v6 ~( p# N- e        //测试计数排序
        System.out.println("测试计数排序:");
; F' w/ W. D; X0 b9 B4 F        temparr = nums.clone();
1 m/ U* z0 q+ x& c/ n        CountSort.countSort(temparr);
        //CountSort.countSort(temparr,false);
1 f) E7 J; P# R        for (int i = 0; i < temparr.length; i++) {
' s% Z3 H7 K- C4 X! N! z4 ]+ S            System.out.print(temparr + " ");
% ^4 t7 @+ p% c+ k        }
        System.out.println();

. q" w4 m6 m& H4 z0 C
! ~* _5 G, H1 E5 e) H

" _5 f* V' j5 H. S        //测试桶排序
$ b  ^( P" g3 E3 t. C        System.out.println("测试桶排序:");
. I# S$ b! n- S! ?5 ^" X8 F        temparr = nums.clone();
        BucketSort.bucketSort(temparr);
        //BucketSort.bucketSort(temparr,false);
+ [$ [# w# [1 c& U- n        for (int i = 0; i < temparr.length; i++) {
. {& n1 G% |  e* N/ R" W4 r            System.out.print(temparr + " ");
: f* g1 j  f3 r! s$ o/ F3 f8 ~        }
8 J( p. B9 T& m4 c# m        System.out.println();
9 U  l: H& j/ N4 I0 s; r- F0 U
& z7 l( N( {0 R
6 I# [1 o' |* z) o8 t5 `9 W        //测试基数排序
" f* \+ T$ L# O' l  r5 C+ P, k        System.out.println("测试基数排序:");
4 m( n; e$ P  s1 }5 W. f4 e        temparr = nums.clone();
        RadixSort.radixSort(temparr);
+ P6 p  N, O/ i7 }& u1 [4 u( y        //RadixSort.radixSort(temparr,false);
        for (int i = 0; i < temparr.length; i++) {
5 m9 G, Z8 X6 P% y* Y' Y  m# U7 h            System.out.print(temparr + " ");
        }
  Y- U: b7 A) F6 B$ D( Y        System.out.println();
6 Z( c$ j! S7 c- d! G8 \/ R
# K* R' V0 B$ m, W1 c4 B7 K' @
    }
- u9 x2 S' n8 x4 |8 M
8 r1 e4 P; |' m# q: G
}
1
2
2 M: g* J* i' q/ \3
* M, s3 _9 m; ]3 |1 |# P- E4
5
* Z2 b4 f( n& G9 z( N6
8 C/ v5 b. E7 x  ^3 b. `7
3 y' r6 v: C" A+ n8
9
4 h+ a5 o/ _  x5 v0 H+ b10
11
$ d/ v7 W& p7 ~/ i$ v12
13
2 o1 V9 w( y2 ^7 Y% z- n14
15
! E" M/ X9 h9 e+ [16
17
2 y7 w" E; _7 q$ [18
2 L3 i  x" b& l/ ^8 q" `+ E4 n19
20
21
4 H& r7 G3 P# U1 S22
1 ]7 {/ u  ~6 y23
% P2 X, @, [4 O4 z24
' A& E. e  ?% B* b  M25
26
, q% g; |8 A3 ~9 ~. H27
7 p3 r. B( K+ z28
: Z1 k% h: s  G. A5 g29
30
' M) I$ r& U* P9 b31
/ n$ d# v9 I4 Z. s- f5 M4 U32
% \+ k" M. a8 b. j/ g33
& T9 S4 x! k; k4 x/ M34
; e7 M2 o4 x5 l' y. {- w35
36
37
38
' F7 h. k" h& N: K- z5 j39
' z* v4 V8 J2 d3 N4 j6 L7 g4 W40
6 x$ }. n6 M: \41
1 F' T( j. p7 O42
/ ^' |' f6 e# @# v0 b  G7 {43
44
45
46
47
48
8 `1 _* k! c9 D& r% }8 q49
50
51
52
53
9 F) m/ C# \1 m8 _54
  S7 F! s( a& U4 c55
56
57
1 Q, R( a# Z5 C7 L! @, {' n4 H$ n) B58
59
60
4 X$ E6 u4 v/ T) a+ s& m, K61
62
63
64
( @7 I1 i8 t& i: s1 D65
66
, ?% E: W5 a) F) N! i8 d67
* O" _% Z, J# m! l" j7 }+ ?  U68
: u! e+ P9 s; G- h69
70
) s9 t( G& _. T. S( o# _, Y71
72
73
74
* c7 t7 @8 a0 Z) Z- v% H75
76
77
+ ^5 S0 R5 D5 p3 A/ e78
- }/ W/ b" l, X. n- B( k$ z6 n1 Y79
80
5 v( b) I( A7 u% B( F81
+ n$ [$ w# k6 q* C82
83
- a# ^, F3 I% n: A84
$ [  e" U, M0 Q! }+ n4 F85
86
/ h/ e1 R& _1 \% F/ M7 M' Y87
88
- _7 b. \+ u4 o' Y- I+ y" v! _; |89
90
91
92
93
94
: u, F7 E! y, B2 C2 E& J- ]95
96
  D/ x: t: k' l97
98
99
: \* _) U/ D# |0 j/ R) C  w100
8 p& d; A3 V" `/ W' V) H101
102
103
! D& Z( Z7 |4 L104
/ l. D5 o( |! N$ }" @7 b105
106
) F5 r+ K7 Y' ?107
108
/ z1 G  f9 j6 a' r# L109
110
111
112
3 d8 p- T# t9 f5 b113
114
115
116
117
6 F9 _6 |& \* M' @118
, z0 W0 S8 O  e7 N4 K$ d( W3 I119
120
1 @5 i+ g' ~; S. ?! M6 d* [# f; [9 \121
122
123
124
$ l6 S4 @( l0 k* v. T125
126
  x5 }% m7 V& m  f127
128
- R# d% V. d4 U# m, n129
130
131
  ]* v4 v& v, k" _8 o132
133
134
135
! Z5 t: E# @+ X! B136
- a" d2 p. E& ?! d6 P; m$ P9 z137
# w- A2 J; t& g% j- X. N138
139
140
141
142
143
2 y8 K3 n- l* n% P2 m144
5 a" Z, ]) u0 [/ n7 ~- g+ t" Q145
4 C7 n) B4 X2 O' u! a$ e146
# v& T  s! P5 Q147
! ]7 k% j0 k- {: V" l148
149
0 Y2 T' y1 F3 C" H( B+ G8 ^150
# w0 a) }; ]. G* V) N151
+ ]" {* t  n8 J( H( E3 g, H. F152
% k! S! P/ G9 R* e$ j' Q% t153
2 {. F1 `+ ^# Z154
155
- I% r9 E0 w. h156
157
158
159
. V$ e7 S6 X1 c2 _160
161
0 Y# T# K3 A3 U5 b/ s& E! j4 k162
% I; w4 D1 h2 Z" z) h163
164
/ }! L- A: O" s' e, x0 H165
166
167
168
% M$ h4 t' p) |" G, w8 Q# j6 M169
& l: u; y4 @& Y& q8 v' E170
171
172
$ d1 y( S+ c$ g: Y173
, M5 ~1 G& g  k; w每天进步一点点！
不进则退！
- f5 ~6 O5 h. d. e

7 n; g0 H, ~$ V# X7 H版权声明：
原创博主：牛哄哄的柯南
博主原文链接：https://keafmd.blog.csdn.net/
6 s+ o- q7 @  [# V8 H————————————————
& J0 e( A$ g/ U+ E5 n版权声明：本文为CSDN博主「牛哄哄的柯南」的原创文章，遵循CC 4.0 BY-SA版权协议，转载请附上原文出处链接及本声明。
, ?  w: P1 f6 {: ~原文链接：https://blog.csdn.net/weixin_43883917/article/details/118193663

; P5 V/ f0 {2 M7 T% I6 \

1051373629

每天进步一点点！
1 @$ V! Y4 T* E+ G7 F