数学建模社区-数学中国

标题: 经典十大排序算法（含升序降序，基数排序含负数排序）【Java版完整代码】【建议收... [打印本页]

---

作者: 杨利霞    时间: 2021-6-28 14:36
标题: 经典十大排序算法（含升序降序，基数排序含负数排序）【Java版完整代码】【建议收...

) z+ N: b1 R  J/ r/ C2 B经典十大排序算法（含升序降序，基数排序含负数排序）【Java版完整代码】【建议收藏系列】
; D5 D3 D) {: g+ ~经典十大排序算法【Java版完整代码】
写在前面的话
$ a6 E$ F3 ~( `' Q十大排序算法对比
' Y* u- e( M* Q5 F9 y冒泡排序
快速排序
# U7 b0 o% y% \8 e  A直接选择排序
堆排序
+ C  q/ @8 @( j& p" p. j% H* @归并排序
. K2 }& q8 |9 B1 w' R& y插入排序
希尔排序
3 @% o3 o$ M1 k0 y: d8 A计数排序
桶排序
基数排序
完整测试类
9 w* k/ C0 S8 Y$ ?! }( {写在前面的话
+ x( a, ^9 p. U9 r       虽然已经有很多人总结过这十大排序算法，优秀的文章也不少，但是Java完整版的好像不多，还存在某些文章代码存在错误的情况，同时也为了自己练手，决定把所有的写一遍巩固下，同时也真诚的希望阅读到这篇文章的小伙伴们可以自己去从头敲一遍，不要粘贴复制！希望我的文章对你有所帮助，每天进步一点点！！！
* d; i( q/ j2 S4 Z4 Q

, Y1 H. B, `9 c- C& k       我用通俗的理解写下对算法的解释，对某个算法的运行过程不是很理解的话或者想看比较官方的解释的话，单独搜索某个算法，看几篇不同的解释，就可以有自己的理解了，这里我主要展示代码以及进行通俗的解释！整起来，再强调一次，一定要自己敲一遍，这样才能理解的更深刻！
. s5 e& E: M* p: K: d7 ^+ q
. R: ~% g( t' {' ^2 h6 p9 G
十大排序算法对比


) t( {) O! n" C
+ j+ R4 s0 Q5 ^$ M
关于最后一列的稳定性，我稍微解释下，例如对序列：1 2 4 2 6 排序，序列中存在两个2，如果我们把这两个2标记上（让他俩不同），排序之后，前面的2还在前面，那么就称这种排序是稳定的，反之不稳定。
! n3 m4 p. J  @

冒泡排序
: G( ]) B: A# d# a0 I8 l) {简单解释：
       原理就如算法名字一样，就像水中的气泡一样，每次我都把最大的或最小的放到最后面，这样总共需要n-1趟即可完成排序，这就是第一层循环，第二次循环就是遍历未被固定的那些数（理解成数组左边的数，因为每层循环都会把最大或最小的数升到最右边固定起来，下次就不遍历这些数了），两层循环遍历结束后，所有的数就排好序了。
4 I0 @; E+ Q! H/ k1 V* K1 V, ~- Q: u       两层循环所以冒泡排序算法的时间复杂度是O(n 2 n^{2}n
2
8 Q' ^0 Z/ q/ u )，是一个非常高的时间复杂度，我在下面的代码进行了优化，加了一个标志位，如果上一次循环未发生交换，就说明已经是有序的了，就不继续下去了，反之继续进行下一轮。

. I- Q8 x8 x5 u- a! \7 |; f

* D5 @% P  u7 Z( ]1 I  E5 t


/ t+ I' O$ \7 P3 {本文的图片来源网络，仅用于大家学习，侵权联系删除！（下同）

0 H0 ]$ j* I3 r4 I; K, B8 K
完整代码：
* l. e& G9 }8 r$ D

; ^9 y5 n3 F6 d, H; z- Upackage com.keafmd.Sequence;
! I) }+ W; g$ Y% U" \4 e

, U) L- J' Z' [# C/**
+ j# s5 p/ {* _8 ?, E * Keafmd
9 x$ o3 b( Z9 K1 e3 S *
6 ]! n2 f  b5 o. q+ Y * @ClassName: BubbleSort
) E* L$ X7 d' v& K! E * @Description: 冒泡排序
* @author: 牛哄哄的柯南
. O- b& U% i* U( ~7 u6 ~ * @date: 2021-06-24 10:31
*/
public class BubbleSort {


# ]3 N4 [* n& M" A3 }" ], T$ K: \    //冒泡排序
    public static void bubbleSort(int[] arr, boolean ascending) { //exchange标志表示为升序排序还是降序排序


        boolean flag = true; //加一个标志位，记录上一次是否发生了交换，如果是，我们则进行下一轮，如果没有，说明已经冒泡好了

; I8 }, b4 U6 W: t
        for (int i = 1; i < arr.length && flag; i++) { //控制次数，第几趟排序，只需要n-1趟，有交换时进行，只有flag=false就说明上一次一个元素都没有进行交换


5 x6 Q, H% O+ r8 R8 P0 b- r5 _            /*System.out.print("第"+i+"次遍历：");
            for (int i1 : arr) {
                System.out.print(i1+" ");
3 ]' v- r+ Q7 X* n: N5 U            }
9 K8 }# C% k8 i0 V0 Y: M            System.out.println();*/
* M( o0 e- e, [) |9 ^; s0 ~! ]: ?
: U9 z8 W( x$ i
            flag = false; //假定未交换


            for (int j = 0; j < arr.length - i; j++) {

# }5 b! p" O9 W9 `! W
                if (ascending ? arr[j] > arr[j + 1] : arr[j] < arr[j + 1]) { //控制升序还是降序
" }2 R  \1 \8 N  ]. ^                    int temp = arr[j];
# q9 i" ^2 i* H6 T. h                    arr[j] = arr[j + 1];
! L2 |& }2 e/ ^/ b6 w& H# r3 _                    arr[j + 1] = temp;
                    flag = true;
$ q. W  o6 C# o5 \# Q9 h+ b8 G                }

0 e2 H% h- q0 R7 \" Z/ U
            }
        }
7 N! o% x) Q, d    }
8 o0 T/ E( ~9 Q6 h
1 i: C/ H# ?; b6 ^
+ q& l2 m. B. a  D  ~) F' Z! E    //冒泡排序 -- 默认不传参升序
* }7 o- G) E% j/ G8 P4 q    public static void bubbleSort(int[] arr) {
        bubbleSort(arr, true);
    }
}
1
2
, u: h; |/ V0 q& d' Q9 |! \3 J! A4 Y3
4
5
6
7
8
& o% ^/ H! y  b$ g. X9
10
8 t: p! D! S; y" ]2 Z11
12
( R) }, g& P) M8 s1 d. ~3 g13
+ g) e. J! }& u4 W14
) T$ n- s5 c' {4 Y15
16
9 ^& e+ t. C) U+ c) ^6 R17
$ f/ [& k9 N# ?$ x, [18
0 H# ]! T9 x$ Z  I* g0 P19
20
21
! j0 U/ V1 b+ z/ d5 I- V" J+ L& R22
& u9 J2 v4 w3 ]7 u5 o) o4 u5 y23
24
25
26
8 d2 ^- p# T5 v( k8 d* m! m% Y  N27
28
29
% U# N: O! I$ q30
# j6 l$ E: w' S7 i% Y31
& ?! Y. i0 \' X7 G  V; W' W8 r32
33
34
35
36
37
, O: ~; Y1 X8 T, g- ^* Z: G/ `" T* v38
39
40
+ b% V" \- T/ @6 e- e41
42
$ P4 [* q1 U$ i# a& V# G43
44
, T8 W7 W/ N3 b' T4 L45
3 Q( J( A2 q: L( g0 Y测试代码：


升序排序（从小到大）
1 h4 y& w% r  S7 x7 N2 b/ C; v  O3 i
, S& b, B/ H1 Z- W' M. ]% ^
package com.keafmd.Sequence;


import java.util.*;
import java.util.stream.IntStream;
9 ?8 a4 T# K: ?' |( W& Dimport java.util.stream.Stream;
# j# A" D, i" X4 c, l' b% [

5 M) _( w0 k  ?3 H; n; d! Z5 [/**
* Keafmd
*
* @ClassName: Sort
# \7 \+ M# ?$ k  P9 Q( R* [ * @Description: 十大排序算法
2 Z5 X: j: {- V( O+ D: M * @author: 牛哄哄的柯南
* @date: 2021-06-16 21:27
*/
) g6 g+ q& t, y& [  d9 |2 u" O: K  Apublic class Sort {
9 J& s" B* M3 ]    public static void main(String[] args) {
, D) Q9 N9 C1 m. K3 u: V0 n+ W

        int[] nums = {12, 4, 25, 47, 58, 34, 25, 9, 99, 26, 1, -13, 162, 10093, -66, -1};
# ]' c1 }# M( ^7 h* f        int[] temparr;

% w9 T$ _+ c! ]  |( _$ M0 ]
' I" B: Q5 X; ~! \* ^6 l        //测试冒泡排序
" c7 b6 a, {8 x- @        System.out.println("测试冒泡排序:");
, P4 q" ~: v$ h8 l        temparr = nums.clone();
; O0 W$ r# r$ i6 K9 x# f. Q        BubbleSort.bubbleSort(temparr);
, J, s/ B8 {2 V( W' R% e6 l0 K        //逆序排序
: Q# f2 b+ \% E9 y        //BubbleSort.bubbleSort(temparr,false);
$ }6 S2 @  L* D; [; j$ A        for (int i = 0; i < temparr.length; i++) {
) G: [$ T. \2 \1 n  ?% f2 l; |            System.out.print(temparr + " ");
        }
* s* G) h: t0 y6 z& @( b        System.out.println();
- A9 a5 Y4 N  t) s4 z' L
& w) f/ \! v8 a9 T. W* [: |
    }
}
3 U! T  H+ S, l+ c/ x1
2
3
4 W; [: o6 N) i* R4
5
6
7
6 P0 B' ~% M" G- K. a& r, w. t% }8
$ @- o6 x& y! ?2 G, @! J6 V9
10
; i/ A, u. L! V+ {0 g* j11
9 s" o) S- x- {2 }12
13
: |) M9 I/ y4 h14
15
4 A1 m. y0 j9 Q( @& `16
17
# n+ r& J4 @# y- j5 _18
19
20
21
% G# X' G. Z5 @22
8 h5 t1 {/ e/ V9 F( i5 w23
24
. A( j5 ~7 L! j; b! A, |. F25
7 g# q% [! O8 M* c7 Z26
9 ~3 d% J- M. g. G27
6 M+ I1 B# T# \0 ]; q0 l28
9 k0 ^  j5 t( |" t29
( e% d. G  Q1 E30
31
32
: w; p' y( _0 V2 @33
' q, C' Z6 ~2 k运行结果：


* ]7 `: s9 ]0 i( u/ N, J; U% S测试冒泡排序:
4 I: H8 K8 z5 }7 J-66 -13 -1 1 4 9 12 25 25 26 34 47 58 99 162 10093
( a% a$ K, Q3 l2 m- p5 ]+ F1
2
. Y, y6 g  m# h5 a2 t! }. y/ @" S2 a降序排序（从大到小）


" v8 J; s) `7 [, y- H- f//测试冒泡排序
System.out.println("测试冒泡排序:");
temparr = nums.clone();
BubbleSort.bubbleSort(temparr,false);
, p+ j2 f  _- ?( o, Mfor (int i = 0; i < temparr.length; i++) {
    System.out.print(temparr + " ");
}
; e3 M* h7 _: E4 KSystem.out.println();
7 K& G" {7 p% n! v  W) x. I1
- d1 O8 O* @2 a+ t( v* w2
3
, R2 b+ s" U: e' n$ W4
5
6
$ o+ o( d' J/ E7
8 M6 s6 `# M# @: Z0 T0 F! ?% x8
运行结果：
, [  y- \/ ]' U" |

测试冒泡排序:
0 e/ W1 y4 [, ~* F10093 162 99 58 47 34 26 25 25 12 9 4 1 -1 -13 -66
1
7 g0 C; R4 p$ `) l0 B% L  f  a2
" k, m8 L9 ~& h+ G$ R3 I- \; G3 c下面几个算法的测试也就是换了下类名和方法名（换成相应的排序算法），如果想降序就在数组后面传个false即可。我就不一一复制了，我在最下面给出含所有算法的测试类，需要的自取即可。
) A6 h4 f0 P/ B# h/ e

快速排序
& m; h& c9 f2 G; N( ~! |: E简单解释：
, X# i5 V& b* j4 o/ J快速排序就是每次找一个基点（第一个元素），然后两个哨兵，一个从最前面往后走，一个从最后面往前面走，如果后面那个哨兵找到了一个比基点大的数停下来，前面那个哨兵找到比基点大的数停下来，然后交换两个哨兵找到的数，如果找不到最后两个哨兵就会碰到一起就结束，最后交换基点和哨兵相遇的地方的元素，然后就将一个序列分为比基点小的一部分和比基点大的一部分，然后递归左半部分和右半部分，最后的结果就是有序的了。

+ C3 ?$ n/ Y; o) ?
! S" T% u- R% u, r6 d5 Z
% t) l( n1 I. m- g# H% q7 O

6 ~3 @- n8 [+ L8 n2 K* r5 d7 h
3 w0 k3 W4 Q, @* u' q' e# H8 E完整代码：


, i/ N9 s- y* B- q6 ppackage com.keafmd.Sequence;
2 m9 e, j% N' T7 F. b' W% ?1 ~
  Q' Z0 Z( w2 N$ k$ \* V
/**
9 a9 h2 G9 y6 D0 O% W * Keafmd
*
4 a" w1 Y' S2 a; R3 @: \7 y * @ClassName: QuickSort
* @Description: 快速排序
5 O* E9 ~3 B1 f4 }* v * @author: 牛哄哄的柯南
* @date: 2021-06-24 10:32
*/
( d" l3 F3 w  ?" d% Z7 p; e* j% dpublic class QuickSort {
! r. h: y) U5 T6 u
  P6 }0 j- [/ o3 l
    //快速排序
    public static void quickSort(int[] arr) {
2 Q  m7 L8 p4 r) g; A, i/ O( X        quickSort(arr, true);
. F% g2 [' C& \& H7 y/ e7 w5 E5 M7 `    }

: S6 h! v/ A! l) q  I5 V1 f& h1 T
5 b! |; W" P% I- @+ P0 i1 n: r8 `    public static void quickSort(int[] arr, boolean ascending) {
7 b. h$ O6 L$ e) |1 Q        if (ascending) {
( s" Z6 \. s+ m: b8 o" g            quickSort(arr, 0, arr.length - 1, true);
        } else {
            quickSort(arr, 0, arr.length - 1, false);
        }
) w  M1 E3 q5 e- B# Q" \    }


9 R; b* S' Y  ~* }' ?$ t7 |1 ?7 E    public static void quickSort(int[] arr, int begin, int end, boolean ascending) {
        if (ascending)
  M; B/ S& z# ]+ J) J            quickSort(arr, begin, end);
        else
. s8 r) v; W$ p5 D: d- a3 r% f2 x            quickSortDescending(arr, begin, end);
2 n; b4 D( R6 U% V/ t3 W' {( J! h1 s    }
, \$ z0 ^. d& x( H
; D# a2 M3 W! R
    //快排序升序 -- 默认
    public static void quickSort(int[] arr, int begin, int end) {
        if (begin > end) { //结束条件
. H' ~0 a8 e# O            return;
: ^% g- w" C  T0 p& U        }
        int base = arr[begin];
        int i = begin, j = end;
        while (i < j) { // 两个哨兵（i左边，j右边）没有相遇
. Q! B, `/ t+ _- _            while (arr[j] >= base && i < j) { //哨兵j没找到比base小的
                j--;
4 f! ]; e3 C9 ?& b4 S            }
, l, q1 e* Q, s1 [2 X$ l- |1 P            while (arr <= base && i < j) { //哨兵i没找到比base大的
                i++;
            }
            if (i < j) { //如果满足条件则交换
                int temp = arr;
  `/ D5 G$ g4 m- X4 Z                arr = arr[j];
                arr[j] = temp;
" v, p/ N3 Z/ p$ z- \  o            }
. @  v2 c0 Q* N; @7 D' N
  q9 P( x9 {7 n2 Y" J) Z
2 a" K- {; t/ t4 j- V0 J6 N' H! f        }
        //最后将基准为与i和j相等位置的数字交换
% y7 y% \5 {/ a1 w9 ~6 x5 v- N        arr[begin] = arr;
- k. j" q9 m- g  V+ L        arr = base;
8 K6 `5 Z9 [) }: s$ X* f        quickSort(arr, begin, i - 1); //递归调用左半数组
7 d- A$ m* K% W- F: o5 \        quickSort(arr, i + 1, end); //递归调用右半数组

6 \+ D/ ~" t  M" r
9 y- F! k& h- F) v: V0 o3 W    }


8 G$ |2 |* x) g7 v3 ^7 `, F; x    //快排序降序
$ P: h3 ]3 Q1 X    public static void quickSortDescending(int[] arr, int begin, int end) {
        if (begin > end) { //结束条件
( G4 I; f$ \( K) P            return;
        }
        int base = arr[begin];
        int i = begin, j = end;
1 Z/ ]5 D& c  I7 u. q/ g+ l        while (i < j) { // 两个哨兵（i左边，j右边）没有相遇
            while (arr[j] <= base && i < j) { //哨兵j没找到比base大的
; _. b5 h# T% N9 [# q; D' ]                j--;
% h: E! r: O  K( F! A: b            }
            while (arr >= base && i < j) { //哨兵i没找到比base小的
1 \6 P$ `& v# W                i++;
$ m' B/ ^( {7 n* v5 V1 }            }
            if (i < j) { //如果满足条件则交换
3 [" [2 }- B3 Z" q! i                int temp = arr;
                arr = arr[j];
                arr[j] = temp;
            }

8 V5 ?9 V0 [9 `% n
/ n0 n8 q; w2 u0 a/ M        }
        //最后将基准为与i和j相等位置的数字交换
( B& ]7 F. n8 c# p. R, g: E# s        arr[begin] = arr;
! u) w4 o# X0 b* ]        arr = base;
        quickSortDescending(arr, begin, i - 1); //递归调用左半数组
  V2 \+ _8 H- f        quickSortDescending(arr, i + 1, end); //递归调用右半数组

1 {! h6 o2 k$ R% I
    }
( H4 s, P/ `# P  m/ S  ~

}
1
) f$ l1 w  H# B2 R& V2
/ M, z) Z' A$ o( C/ y3
2 ~4 ~' p6 D! o) ^. i4
* C1 \' p$ |; D6 E3 t6 U: v5
. J7 H) _' }4 p- l8 D! h8 j; j* E6
7
8
2 z) O' F, D$ z& U9
9 C# \4 l1 j. i5 w7 k  |6 {10
& R' W- ?! j+ Y+ d: B2 Q6 Y4 E3 [8 d11
12
13
9 C, k3 x, E5 O& p: @14
* U# e: i2 Q; a8 s4 N15
" ]1 i' A$ Z2 ^1 Y: b& w, o# l16
8 V: Z2 Q& g% ]: E! C# o17
18
) o: P9 v. u5 q( k0 O5 S# s) ?+ m19
2 ], C. O- y& Y20
9 G* D9 G7 F/ `1 I1 r21
22
23
( [" P; w' ]' E1 K5 G9 g, h& U24
3 N$ T' \) y, _$ n/ C" I6 U8 ~* m' i1 {25
8 ?2 J  ~$ D& [$ ]  ^  ~2 A6 b; e26
* h4 C* W0 c7 F6 @4 z27
28
29
5 _. p0 `2 y: m- d8 u. g30
31
32
33
34
. B. a0 C* @% S35
* F2 G! b# T1 Q4 m  s36
* J+ Y  A: C4 V5 q0 ~4 C9 a% n' b37
  n4 `4 M$ i* l38
39
  x2 t% w, F  ~+ g' \& }40
8 `* B# T% n) `) S7 E, W4 c41
, q5 Y2 D( c! \+ M  _: g. \$ N1 m42
43
7 w; C, E7 C' V1 I  Q9 L7 J44
45
46
1 R9 y' n6 T1 a( h& Q47
9 {" f+ }+ v: j! J$ s48
+ l  b5 A  z- |/ E1 }/ D; Z4 n49
* Q/ C0 Z5 P$ A. {+ {1 Z50
0 h) R/ B, W: I51
52
53
54
55
56
57
58
( _) r% r, y1 A7 |' A59
! N" Z6 b# \& v8 ?6 C6 q60
4 j  V+ u8 Z2 a: e# N  Z+ q: h61
: v& l8 w5 Y/ r* p. o62
63
64
65
- G* X6 k" k' W66
; L  [5 F; \; j, T4 @67
& \1 J) r  x5 C- {. f& k68
% [. Z, k( Q5 _5 P# m69
. }4 ?* ]1 K* U70
71
6 Y1 Z! c9 M. b; I+ j8 x3 |. i72
+ @8 n; V3 A. T3 x5 J! P73
1 @. M2 {! f7 _* r7 @74
: I3 f4 |0 A# _+ n3 Z75
$ c& F% g0 P, ^+ g76
# K4 t, d5 X* u' P77
5 V  l4 X. @* a* d8 n78
8 w6 [9 }/ ~$ x, ^; M2 Z3 y- G9 U79
# g/ \: C- h9 s; o3 n2 P& u0 R* L80
; @( z! G: d* N) Y: F81
82
83
$ F9 x  Q* G1 ]/ o: @84
85
8 L3 w1 R2 p; W% d86
87
" L) Y5 S4 q7 F  T; N3 |  s  |88
  }8 u2 G$ C3 G- o8 I; X; v# L. I89
90
91
. F. g$ W- o% L8 A直接选择排序
% v( R# D. B/ a% k7 A简单解释：
数组分为已排序部分（前面）和待排序序列（后面）
第一次肯定所有的数都是待排序的
从待排序的序列中找到最大或最小的那个元素，放到前面的已排序部分，然后一直找，不断缩小待排序的范围，直到所有的数都是已排序的了






完整代码：
. }! ~3 p: x- R1 I, F  ?

) P6 O/ l  O. x1 ypackage com.keafmd.Sequence;
! G$ e6 H& ]- e, M& d

/**
0 a7 j' U, |  ]+ @" [- M* r * Keafmd
! w. R5 h6 \/ t, k *
9 N. m4 b# J5 ?* j2 }* O2 d * @ClassName: SelectSort
/ k6 ^1 G. a. {( _ * @Description: 选择排序
& h, I: q7 j% W, M% P# ?  r7 g * @author: 牛哄哄的柯南
# H6 k; N' v$ d( i& } * @date: 2021-06-24 10:33
- |2 n8 h: w9 @& [: j3 s" Q. [! y */
3 G* c9 c8 Y% Z: Z! H5 dpublic class SelectSort {
" n/ V% ^. i" I

    //直接选择排序
    public static void selectSort(int[] arr, boolean ascending) {
        for (int i = 0; i < arr.length; i++) {
4 F6 }+ M: [5 Y7 b1 d            int m = i; //最小值或最小值的下标
            for (int j = i + 1; j < arr.length; j++) {
                if (ascending ? arr[j] < arr[m] : arr[j] > arr[m]) {
                    m = j; //找到待排序的数中最小或最大的那个数，记录下标
                }
- y; g1 g; J. Y# b# O- p

& e' d7 J6 ~( I) n8 [/ |3 ~, ]* P            }
- N' f* w, y- H            //交换位置
            int temp = arr;
            arr = arr[m];
8 u- z; c  V: r  g  ~) v( A            arr[m] = temp;

* l7 Y1 I) d# K7 ?3 t
2 R7 ]# V# S& D8 J        }
    }

& O( N4 s+ S4 i( v
    public static void selectSort(int[] arr) {
* X$ I5 F5 R4 E4 G' S" f" R        selectSort(arr, true);
; x: |7 E2 v8 A0 j' V& R6 Z    }
* R5 \, j! y6 q0 I) C% t% S}
1
0 p. @, l/ D* I. c7 p  N9 f2 y* k2
7 \5 S+ K! l" C/ b3
4 U& s1 c5 n/ E8 ~4
# L' ^4 R5 @; t1 \# `1 u; k7 K5
6
7
6 v% Y) j- a8 h* X) H: |! x/ n( T8
  a5 \9 O/ g2 k+ J! C' Z  W9
& r/ O6 W5 L7 d, Z3 Y5 }% x+ z10
/ o# }& y( D; ?& w% J% p11
6 k+ t, o, {; v% Q) q12
13
1 ?  n6 n& D7 T! |/ H1 R9 i14
15
16
17
18
19
4 A, ]( J- }5 \/ V4 X$ Q( N20
$ o  s$ \& E% L9 E. W21
8 W8 d% y1 A4 \9 F- H22
3 G% i  {7 V. |: F1 j23
7 D% d1 i0 s9 L, `$ `* X0 _24
25
26
1 a  J+ G# a( b( A* L27
28
+ w# U3 L  k9 G; \- E$ S  s29
7 X; I4 Q  L, M( [' F4 v30
31
" g; U; r5 x' l6 Q32
33
. z3 ~& r4 U7 A5 y6 G9 h, g34
堆排序
% f. |* ~: I, t' \" @先理解下大顶堆和小顶堆，看图
大顶堆，双亲结点的值比每一个孩子结点的值都要大。根结点值最大
小顶堆，双亲结点的值比每一个孩子结点的值都要小。根结点值最小




简单解释：
构建好大顶堆或小顶堆结构，这样最上面的就是最大值或最小值，那么我们取出堆顶元素，然后重新构建结构，一直取，一直重新构建，那么最后达到排序的效果了。
* Z: |, e4 @3 L$ X0 \8 T* e$ J
7 q% W# e6 }1 Z


0 t! F4 q6 h) ]  A* Q+ C4 z& x

完整代码：
* f! z; O5 S% Y9 p- E# q
# N! o2 Y/ {# ]- L6 ^
package com.keafmd.Sequence;

. |) s& |5 |6 z! c2 j5 e; T- V
! v" {& X8 @1 ?  `/**
7 B0 G0 f: ]  ^; d5 c( K * Keafmd
*
* @ClassName: HeapSort
: ?1 i* M5 y$ T" \& f * @Description: 堆排序
* @author: 牛哄哄的柯南
* @date: 2021-06-24 10:34
*/
. j) l2 y* m5 `3 ?public class HeapSort {

4 `# ?6 E8 j: t
    //堆排序
    public static void heapSort(int[] arr) {
        //对传入的数组进行建立堆，这里默认建立大顶堆，进行升序排列
        heapSort(arr, true);
# A$ H& z; g( f5 }& H& p2 Q) h    }

, q- U& c* ]& Y1 `7 L. E
0 x  {$ o0 M! v+ `8 Y" i    public static void heapSort(int[] arr, boolean maxheap) {
0 q$ y5 `* ~0 a9 O" K* M; {
3 ~4 ~) q; `& ~/ ]# P
) T' a. m* O7 j. ~        //1.构建大顶堆
2 S& s/ X- M6 T* V$ Q9 l        for (int i = arr.length / 2 - 1; i >= 0; i--) {
, V2 o, r) q% c4 b+ q            //从第一个非叶子结点从下至上，从右至左调整结构
- o+ e# \% q. _$ ~" G1 M# n            sift(arr, i, arr.length , maxheap);
        }
3 ?6 j# f+ H8 R" h/ ~
% a# [+ j/ e$ Q4 h" n9 H
        //2.调整堆结构+交换堆顶元素与末尾元素
        for (int j = arr.length - 1; j > 0; j--) {
: ]5 G: d8 S+ t& f4 D9 [" r# P; I
- Z; c& ]8 j( Q3 _# U0 M- ~
            //现在的数组第一个就是根结点，最小值所在，进行交换，把它放到最右边
            int temp = arr[j];
: G  E$ f5 N3 I8 t            arr[j] = arr[0];
            arr[0] = temp;

5 }! `. z. S  t7 d, G) \  L
+ a% f7 r1 i7 [* ^& ^            //重新建立堆
            sift(arr, 0, j , maxheap); //重新对堆进行调整
9 I" I, ^7 w( o! f  x- M- D6 |) a        }
! L1 t+ J5 \0 J6 p    }
& C2 i, F# f6 F2 P) W9 V

7 k1 s6 t+ i. \! Z  d. |    //建立堆的方法
+ Z' @2 {1 A9 m3 y. f' O; Z3 ]* G    /**
     * 私有方法，只允许被堆排序调用
: n7 ]! D: t0 }     *
     * @param arr     要排序数组
. h/ ?; O# c( g1 t6 U     * @param parent  当前的双亲节点
     * @param len     数组长度
     * @param maxheap 是否建立大顶堆
' o' ]: ^8 _) r) E( j1 l     */
    private static void sift(int[] arr, int parent, int len, boolean maxheap) {


        int value = arr[parent]; //先取出当前元素i
8 a6 k0 B6 W. _+ b# I4 g; _) ~

% x1 d% f7 P8 ~        for (int child = 2 * parent + 1; child < len; child = child * 2 + 1) { //从parent结点的左子结点开始，也就是2*parent+1处开始
2 a( Q& H1 O. x8 N( q- m

1 Q- ?# f9 V: r            if (child+1 < len && (maxheap ? arr[child] < arr[child + 1] : arr[child] > arr[child + 1])) { //如果左子结点小于右子结点，child指向右子结点
: V- ^5 Z2 H! k) K0 l                child++; //右孩子如果比左孩子大，我们就将现在的孩子换到右孩子
            }
9 Z) [% l* K8 W1 {
! E3 A0 n& ^0 H/ B+ u6 ^8 X
6 a7 f1 H+ \, F9 j3 Q( b            //判断是否符合大顶堆的特性， 如果右孩子大于双亲，自然左孩子也大于双亲，符合
  r  ?+ O% N, m            //如果子节点大于父节点，将子节点值赋给父节点（不用进行交换)
            if (maxheap ? value < arr[child] : value > arr[child]) {
                arr[parent]=arr[child];
                parent = child;
            }
            else {//如果不是，说明已经符合我们的要求了。
, @* y* `" V2 D6 d                break;
            }
  ?4 f% n) D8 g( P5 Z+ U        }
        arr[parent] =value; //将value值放到最终的位置
  }! d3 g( J5 ]# @

3 N! D$ A5 @5 D5 M
, u! g; |3 i7 s$ J* n" I
    }
( i! {; \: v- t, i) ~
# A% w$ z$ }, X& a1 O8 V
' S' C' m2 A' k' X( r# S3 G}
7 |' N5 ~4 D; f7 s3 C5 P* X1
- i5 r( Q$ ^0 }- i( f3 H4 m) k7 N2
3
4
( y1 `9 J3 T/ f+ e7 Y) }5
6 P5 s& h! ~/ w6
7 \; ]' ^4 x# P7
8
0 A* `, t; Z  G1 k: }9
10
11
12
13
+ v9 E6 V: x$ m& N: Y; D( S14
15
16
( j$ U! m$ K$ i! C$ X7 p, x17
7 [! s# Z5 n  x8 T1 N18
19
: p0 e% d) C; z" J0 u20
2 Y1 }& j& O& p. c9 b21
22
  N$ m& y) ?( r4 o23
24
25
, _! W8 D( i0 [* @1 `2 R# f3 j/ N26
27
5 M' ^. W  o9 p2 L  D; Q* P0 i8 j28
29
- m- Q2 d/ p& w) H5 D7 o" v: f* [7 ?30
31
32
33
" H/ h- z/ D8 M4 _  T( G+ E, g! g34
35
36
# o6 x5 K4 M/ p# S! A4 V1 I37
, X$ i/ ~" c8 V' K* E3 n3 n; \- `38
# F0 m+ Y# J. g& }& a  U39
  ^% m/ S/ B" i. Z  Q2 `9 I40
41
42
  r( R2 _' P  T' f1 ?( R43
44
$ x, I% f) C& M45
" R! V0 P/ P7 o  E  [9 Q1 j7 t46
47
48
1 G$ p# ]! ~  T6 D49
50
% C( D* D$ K) v( @6 y51
52
53
54
& e0 D) _. W3 h+ t! {9 V2 c- t0 N55
( I" H# ~- z  Y+ f% _) T! c56
57
6 P" ?2 x2 l# B% V! }$ G58
59
# F+ U. T, J' Y+ l) E' G60
61
. O4 L& X) p" Q9 e. B2 p# m8 S62
63
' H- [8 q3 H0 N1 u  b* V6 k64
; T9 i8 R* @3 a+ q65
  r7 k6 I9 V/ c/ J& r; k# u5 l66
67
68
69
70
71
, T' m& L( V" M" \72
6 n) y/ Y3 \  m! }# c0 [" x73
74
2 e, P& k' f5 R. _% X+ i归并排序
简单解释：
该算法是采用分治法，把数组不断分割，直至成为单个元素，然后比较再合并（合并的过程就是两部分分别从头开始比较，取出最小或最大元素的放到新的区域内，继续取两部分中最大或最小的元素，直到这两部分合并完，最后所有的都合并完，最后形成完整的有序序列）
# C. ?& v' y: }$ l" Z7 c+ U  c- [
" K# A7 e# ]3 S% V0 o


! O+ u; Q6 a( {+ Q( E0 ], J
0 ]: r. b7 w3 z  W; C' D
+ J9 M3 B4 B- c9 D: B4 X8 N完整代码：
$ v! L- E9 s4 r0 [- T( t# X

package com.keafmd.Sequence;


/**
* Keafmd
*
* @ClassName: MergeSort
* @Description: 归并排序
- r$ ~( i& j8 d * @author: 牛哄哄的柯南
' j6 p' J) p$ J6 O* N6 B, V * @date: 2021-06-24 10:35
*/
0 P( F* I7 t) V; _public class MergeSort {

) B( ]+ u6 |$ l; i$ c# l, A6 w
    //归并排序
    public static void mergeSort(int []arr ,boolean ascending){
, N6 ?; m% \; H* c        int[] temp = new int[arr.length]; //在排序前，先建好一个长度等于原数组长度的临时数组，避免递归中频繁开辟空间
        mergeSort(arr,0,arr.length-1,temp,ascending);
3 b. J. B- d4 L; ?7 o- |    }
* h& e% i( G* Q6 m    public static void mergeSort(int []arr){
        mergeSort(arr,true);
0 y; ~, u* K* _2 Z- ?    }


    /**
3 J9 o1 J- T1 w0 H# I$ M     *
     * @param arr 传入的数组
     * @param left 当前子数组的起始下标
     * @param right 当前子数组的结束下标
     * @param temp 拷贝暂存数组
     */
! t4 a1 y: h- i! x* c5 A5 P    public static void mergeSort(int []arr,int left,int right,int[] temp,boolean ascending){
- q) {$ X9 r* E/ X  I6 O# t: k        if(left<right){ //这里是递归结束的条件，我们是对半分，那当left==right的时候肯定大家都是只有一个元素了。
& s/ R( X1 @; F' g

) ?8 i' u$ ~- |6 X, g- Y            //对半分，比如总长度是10，left=0，right=9，mid=4确实是中间分了，0~4，5~9
            //当长度9，left=0，right=8，mid=4，0~4，5~8
  A$ d* D0 Y9 y: P( }; O! p- G            int mid = left + (right-left)/2; // 防止越界的写法
# R  {6 m: }% i) [0 X$ w            //int mid = (left+right)/2;


* W8 S6 ]6 \; n) V2 Z) E            mergeSort(arr,left,mid,temp,ascending); //左边归并排序，使得左子序列有序
( Z+ f8 ~- o  I9 O. _* r2 p1 n            mergeSort(arr,mid+1,right,temp,ascending); //右边归并排序，使得右子序列有序
# n1 U0 G5 m0 _0 N' B8 Q+ p
. C* a, ~  H5 ^( M7 ?3 b
            merge(arr,left,mid,right,temp,ascending); //将两个有序子数组合并操作
        }
    }
" }4 r. _* D1 e& E& d

7 R2 D* U* d0 A    private static void merge(int[] arr,int left,int mid,int right,int[] temp,boolean ascending){
        int i = left; //左序列起始下标
2 ]  A9 p4 t7 s$ b# W, j        int j = mid+1; //右序列起始下标
, v: Q: T+ }, r# U/ _' R) c# ^        int t = 0; //临时数组指针
        while(i<=mid&&j<=right){
            if(ascending?arr<arr[j]:arr>arr[j]){ //比较两个序列第一个元素谁小，谁小先拷贝谁到temp，然后对应子序列下标加1
8 t0 x& [& }$ y0 @' O. ~& ]                temp[t++] = arr[i++];
            }else {
. q4 i: w/ g5 j6 C; N$ Y                temp[t++] = arr[j++];
" U3 |0 y! l, q; |7 v. {7 x            }
7 [6 J  n% R8 l        }

6 J9 \, O* D% c
- c3 r% W  F) i: x        while(i<=mid){ //将左边剩余元素填充进temp中——左序列有一些数总是比右边的大的数
/ s6 ]( f& D: k6 K" ~            temp[t++] = arr[i++];
; e7 \, v# x; E( M" @! r# g        }


        while(j<=right){ //将右序列剩余元素填充进temp中——右序列有一些数总是比左边的大的数
            temp[t++] = arr[j++];
; c  S( c/ ^& @9 V        }


3 ]9 C! W0 m0 x4 y; ^        t = 0;
% x) u$ c6 x$ l6 D( e! [) e
0 j' w6 ]1 E/ ]- l* ?0 }
        //将temp中的元素全部拷贝到原数组中
        while(left<=right){
$ y/ ~# w- {0 A+ k4 ?/ ?            arr[left++] = temp[t++];
        }
1 `& ?% M; f# f) h

& d2 Z6 u- \1 {6 Q! g    }
. t, J3 g7 p! ^8 F1 @

}
1
, {9 [! c) P4 {  q, ^  b! L. _2
3
4
5
6 y6 w( q; `' s6
7
2 B% D# P- r, b5 C: ^. b; H: P7 ?$ e8
9
10
: d+ C* Z6 }9 i$ p4 C11
, ?  f; b4 ?1 p7 n" u12
13
, v+ }; C5 e* X& Y* ~" w  v14
8 c) F- `% {) ^3 \6 p! A15
16
17
18
19
% J4 ]# S. K! U& Z' s9 G) K20
$ Z8 l. d% ^6 Z. {' w21
- s9 h0 r( m: U8 X' V; E7 A8 D3 a$ x22
23
; W# F- G9 W5 [) M24
! {# R/ Y  j3 y4 ~25
9 A: j7 ]5 r* U, x  n) {# ~26
: \. ]/ B6 U# k% M27
28
3 J% h. w8 T) n: n6 s9 f' C29
30
31
; U$ p9 f. L3 T, [( r32
33
34
35
3 s" k7 m: k- {8 o, L0 g3 K36
$ y; i5 Y0 Z( q: Y1 J8 Q/ B37
38
39
40
  u3 K& S) \4 S41
2 l8 v% @4 b/ O! b& g: g42
43
44
45
0 o3 G4 N& O$ |3 c+ m) q46
0 C; s) b% B& Y( i47
3 r) b! W: M; x& V4 z48
49
50
( c, _- Y& y& A, o& V) U1 i* Z51
52
53
54
2 Q# T0 O' \5 b/ B6 C55
56
, s6 j2 X: c, J  d4 Y57
" J1 ^' j) q) W, e" X$ ^" c! e58
59
& |8 m/ d% r3 M- F6 J- g- X- J60
61
62
63
64
$ F1 M, c. }% M5 w65
66
67
; t, B* U% d$ V/ X* P68
/ q- a. Y' ~& H# n. Z69
70
71
9 e9 r1 Z: R, _# Y$ A* T: F+ G" m. X72
$ g6 ]5 v/ f# l73
, A+ d7 _9 I" ~; ^/ x插入排序
! Q2 o, _' ?- b0 R9 M简单解释：
最简单的理解就是打地主时我们拿到牌后的整理过程，从第二个牌（假设我们拿起来这个牌开始比较）开始，（说下升序）从后往前比较如果比前面的那个牌小，就把牌往后移动，直到找到一个合适的位置（这个位置的前面的那个牌不比这个要放下的牌大）就把这个牌放到这个位置，慢慢的前面的部分变得有序，直至全部有序即可。

  c8 g' p! k2 G) I6 F

; W- {+ k' J3 j" h* Q6 p# x
6 b$ S( K9 g  e$ y$ j
# Y! ?% P1 ?* {/ G
% B" F6 F- w8 `( I6 X- @! y1 l完整代码：

# M1 V$ t8 i! D! P$ Q
+ f( [# y" H8 C- M2 ?1 Rpackage com.keafmd.Sequence;
* T$ ~) |# `" R; B1 o1 I7 b

8 Q# A% }. G7 Z! X/**
* Keafmd
*
" L* j* g+ v- p! S, }4 b* |! {9 L * @ClassName: StraghtInsertSort
4 V. g7 d: }% ^7 S * @Description: 插入排序
# Z' r5 p# w( H4 a+ [) S( F * @author: 牛哄哄的柯南
1 n1 y  o+ d6 l * @date: 2021-06-24 10:36
* n% I! W/ g% f& U# Y6 u */
; b2 g* v5 B0 |3 h* g: @7 e0 npublic class StraghtInsertSort {
    //插入排序
1 Q7 t1 [- X" H7 i3 g    public static void straghtInsertSort(int[] arr) {
* z+ P; B! F' d' e! _; s        straghtInsertSort(arr, true);//默认进行升序
    }
. j* d* ^+ T( L$ w6 a. V. x
3 J5 g7 |' n2 G3 `; e3 a
% O9 v) m1 C4 C  m( j    public static void straghtInsertSort(int[] arr, boolean ascending) {
+ q8 D# O( y' i, Y
* m# r2 C$ {) \+ \6 M! e; A
        for (int i = 1; i < arr.length; i++) {
            int temp = arr;
            int j=0; //这就是那个合适的位置
            for (j = i - 1; j >= 0 && (ascending ? temp < arr[j] : temp > arr[j]); j--) {
                arr[j + 1] = arr[j];
            }
            //把牌放下，为啥是j+1，
            //是因为上面的循环遍历到不符合情况的时候 j是合适的位置的前面的那个数的位置
            //有点拗口，但是就是这个意思，看图方便理解下
- J6 I5 @9 R1 F+ [            arr[j + 1] = temp;
# o1 D" f/ }: ?, @



8 n. y) _" ]+ ^: l  Q4 s        }

& \2 d" l& r, x8 E  ~, Y
1 W# X8 E  p# X  F4 b, L+ z    }
9 e- a" F4 p  d% g8 Z}
1
( ^7 Z  A- c. o/ Y" V: v: I2
* o1 X2 p- t8 x, [; ?! M# q0 X& C0 [3
4
6 n1 y  X& p' A* h5
6
# n& z# e# {* r! D7 o& Q7
/ a4 B5 k. T. H6 t6 X8
9
10
11
5 g, c5 X0 I4 _7 G  r* b12
& _" t7 M+ m. e' n& d) r13
8 Y+ l; G. f2 Y( F6 }) b14
+ X- j0 K9 q" K0 D: \' T$ ^. S+ Z* h15
16
17
18
' p- ^' a* P: q& S. s/ W, g19
20
. b; P. C8 N( V5 a21
' p; S) H) X# j- a9 x% a22
. ~' Y- `2 C+ P2 Z* P9 J/ f' j23
24
25
! w  w0 _3 p. e9 ]26
1 K0 A9 c! S3 M  ]' R+ S27
28
" L0 i/ n) Z6 J  c/ r  F4 S29
8 o& N* \' u' ]6 _* Z; H# R30
0 k' T7 Y% o/ Y8 {; o$ }31
32
1 g2 @% M0 _! \8 C5 h$ d$ ]' h33
34
! n2 C$ H' g. v2 a& w' S希尔排序
% D' I7 R, ~- f! A! f* a7 y简单解释：
希尔排序是插入排序的改进版，我们理解一个叫做下标差的的东西，也就是下面那个图中的增量d，初始下标差为arr.length/2，然后继续/2，对在同一下标差（相当于把这几个数单独拿出来了）的若干个数进行插入排序即可。



/ Y( L; ]  [7 G, i3 ^& [+ ?! `$ W
, D: w4 }) Y) x* }% q" x1 ?
9 d5 p+ M7 Q( y# S3 p
完整代码：


package com.keafmd.Sequence;


/**
8 @4 O0 F, O' L; d3 K2 p" g( Y& d/ \7 K * Keafmd
$ ]) [8 b. I1 e" P6 O *
* @ClassName: ShellSort
* @Description: 希尔排序
) J+ u/ F, b# |7 K% `9 ]+ v * @author: 牛哄哄的柯南
* @date: 2021-06-24 10:39
*/
public class ShellSort {
* a% W$ y2 L7 J. R  \( r
* E, _# K! y6 o9 n- Q- s
+ N& [* h* B2 S' F    public static void shellSort(int[] arr) {
* {+ C  l! S0 G+ R0 J; n: i        shellSort(arr,true);
    }
; j/ d( o8 {0 V1 v, d  V7 p

6 R4 o1 T" w/ R, q( ?    public static void shellSort(int[] arr,boolean ascending) {


' R" R% Y" {; ?# W  r; @- h        for(int d = arr.length/2;d>0;d/=2){

9 Z* q3 Z- Q. e& d7 ^7 `
, x* C' J& ^$ }2 H9 Z" `            for(int i=d;i< arr.length;i++){
                int temp = arr;
                int j=0;
                for(j=i-d;j>=0&&(ascending?temp<arr[j]:temp>arr[j]);j-=d){
                    arr[j+d]=arr[j];
                }
6 J4 q9 O( G5 R$ B                arr[j+d] = temp;
            }
        }


    }
8 f% Y, z. Z, C1 h}
% q8 X6 i( _" A$ p1
) w4 A/ U* R, l- {  R6 ?( V1 @% C2
5 h- P6 r$ ~4 u( m3
4
5
7 E% u8 ^% b& R) L! S, Z( W6
( Q# l& o# b% I; V7
8
+ ~  u8 U" W& F" I9
10
* L9 {% t; D- C+ o" r! s5 C0 z11
12
13
14
15
16
: n* }) M# |9 ~, j0 r/ I0 Y17
3 a8 i5 i( e4 [18
1 r; G  S# ~8 e! Z  J19
7 k% U$ o% k+ u7 |& h& F1 y" @20
5 h9 z  D# q1 v9 m* N$ A3 J" y21
22
23
5 z$ u" m, y) T- S1 m& }6 a( l24
& ?- n8 b" O' y25
- e  c9 d, Q+ B; E: a6 P9 S26
) n6 S8 n# S7 q6 [27
0 r3 U$ Y; ~1 Z4 C7 H7 |28
, X; B+ m0 K( X/ X6 R) o7 \29
: r2 T% O  x4 D% |8 V30
31
/ _5 `% {5 h' |) N( Q+ c32
' n' p) ~  g; ?  D" U8 n# S  f计数排序
简单解释：
这个排序算法看名字也很好理解，就是就是额外找个数组来计数，然后在这个数组从小到大或从大到小把数取出来即可。




+ [0 p- N) U+ E) i2 a5 c
% E" S3 ]. l5 r) K% H  }
! K* J" `9 J5 f, `  {完整代码：


package com.keafmd.Sequence;
- S$ o/ v+ l6 Z6 M2 X0 H
; k5 Q# U, [  G9 M' M3 h/ O
* ^2 h4 M3 ^( z% T/ C* ?0 {/**
( M" O* t+ \1 ~; }7 y * Keafmd
1 a9 ~, N- {- k7 ] *
: {* \8 C# o4 g2 { * @ClassName: CountSort
/ h- @2 J/ J" a+ X; N  b * @Description: 计数排序
* @author: 牛哄哄的柯南
* @date: 2021-06-24 11:31
( k5 [7 c0 a) R; z7 r5 \; p+ o */
( [) Q. H/ x; E5 D9 {" Q' upublic class CountSort {
) e5 u4 [. R& }2 w9 u# P

    public static void countSort(int[]arr){
6 E% B& X4 n9 \; N5 X        countSort(arr,true);
    }
" ?, V! |: E* U' ?" A  v7 Z
( D! {6 |5 Q! G6 \# O# i( Y
/ K3 K/ |  Q5 ^    public static void countSort(int[]arr,boolean ascending){
" Q; y" F6 R2 O/ u" `0 n, Q) K        int d,min=arr[0],max=arr[0];
$ b% O3 j2 |/ B( d- p& e& Z
4 T. o. ]8 I) v% M# R
& W, B8 U2 D- ^6 ?( q, O3 @' G        //找出最大、最小值
0 u' H4 J  L  s. Q1 d$ C+ D' i* m        for(int i=0;i< arr.length;i++){
            if(arr<min){
2 p, l4 i% ]* N                min =arr;
            }
            if(arr>max){
) h8 b2 C  `" K' ~                max = arr;
            }
- d$ x' ^9 `1 e6 H' n        }


) ~" ^$ O* f0 b3 z( m        //建立一个用于计数的数组
        d = min;
* s! _- [/ z; C4 q6 o( u* m        int[] count_map = new int[max-min+1];
! @3 W+ n" X4 V9 g        for(int i=0;i< arr.length;i++){
            count_map[arr-d]++;
        }
& F8 M" G6 H1 D% S( D. u# {: ?

1 N4 B: l; g  H5 b2 q        int k =0;
+ w' ~5 N$ `6 K9 l4 m        if(ascending){
6 X! u: ^5 G) ~% J/ b( l4 e: n3 o            for(int i=0;i< arr.length;){
% q1 c6 T' q+ J; S0 ]" @                if(count_map[k]>0){
                    arr = k+d;
                    i++;
' f1 U% i& c! h! Q                    count_map[k]--;
4 X1 h( f' H$ u: \4 d# e                }else
8 c0 V  w5 [( w2 q                    k++;
            }
% C. W: R7 D) Q; u) C        }else {
            for(int i=arr.length-1;i>=0;){
- C# C1 e+ i' E                if(count_map[k]>0){
                    arr = k+d;
9 u/ o6 E. ]7 ]' q! @                    i--;
; O1 I6 g" C6 }$ U                    count_map[k]--;
                }else
" u* r' c6 O( E                    k++;
            }
/ z% b" R+ ?! l! z        }

# z3 R9 g0 N0 t" `
: b& i/ v+ `, p, u    }
5 e7 p7 ^) ^3 a1 h7 @6 F}
5 V% Y3 |  X& |0 B4 ^, x1
/ C) y- \. [- L2
3
: C* i/ d! L5 a+ ~% ]0 ?4
5
6
7
/ O6 B: Z* p$ v- A8
9
) g2 Y$ k4 ^5 m% ?" q: O5 Y10
11
12
13
14
15
16
17
18
19
20
; e+ c% f0 P, y21
5 w- C- D* r1 H1 [22
23
24
25
% S( n4 T% t1 u8 u7 f26
27
, J0 j  H- v( X7 W9 ?28
29
30
3 U% o) f0 U- ]+ S  C31
32
4 S  S( V; g  |% p33
34
0 e) m6 ?5 O, W& Y: Y' N6 U# ~% w35
36
& D3 o; K' T5 U. ~% V37
$ }  X* r3 R, F0 @, B( P+ Q38
39
' @, H7 B8 P! c! P- E3 }7 ^40
41
42
6 @6 {8 I9 E# \* v6 M# K& i+ p) O( N43
( z, P1 ?( |6 K6 K44
45
46
0 J6 ~% ?; S+ d% `3 s/ H47
3 f5 w5 D; `( J, p* p' L48
! I7 C9 A  ?3 n# o- m1 O49
50
$ I6 p. L( `" J51
52
5 a, b. z' j. w. I; J53
. k  d: M; @9 |4 ?" |! }; \54
" M6 k$ t. N: |' y55
56
# _1 \7 T  D, Q" v% r; b57
58
59
桶排序
5 P& g: ?5 t6 n& n8 M简单解释：
就是把一个数组分成几个桶（其实是几个区间，从小到大或从大到小的几个区间）装，然后让每个桶（区间）有序，然后取出来放一起就可以了，相当于把几个有序的段拿出来放一起，自然还是有序的，当然需要是按照区间的顺序拿了。

/ a. C, ~( d/ s# x: u3 {* _- k
" K8 C+ Z& ^  x


' n: i$ ?9 l& X0 n
1 n9 R7 u  S& ~/ E完整代码：

0 M' n9 E$ [2 g2 }6 d  K
, ~/ ?' B5 Z& ^package com.keafmd.Sequence;


+ n5 D: a/ g$ Simport java.util.ArrayList;
( O. F- U7 r( m$ B  D5 Timport java.util.Collections;
) H& @; Z) h6 \' g
: T3 D) ?7 \$ T) ~
( G0 J1 h  t9 T5 m/**
# q5 T+ d% R/ R( g4 y * Keafmd
*
9 Y7 h7 ^& Q$ w4 B * @ClassName: BucketSort
; ~. F4 Y' Z4 g3 ]# [: b$ ^ * @Description: 桶排序
( k! N1 {( P5 O0 [  o* y7 u6 Z% z * @author: 牛哄哄的柯南
* @date: 2021-06-24 13:32
6 y5 w7 S# m/ k: A */
7 I2 ^) W( _* ]3 e0 c( a% U* lpublic class BucketSort {

: u8 ~; K: G& f: L5 R* `
0 Z  Y  t( q5 {2 ^" u- I1 d    public static void bucketSort(int[] arr){
( |" V" G, `6 ~/ D9 z2 i/ n3 A        bucketSort(arr,true);
* z" @! b9 N) q    }

( X# W+ O6 h) c" X5 Y
    public static void bucketSort(int[] arr,boolean ascending){
( v/ b! V% w) i' S3 Z        if(arr==null||arr.length==0){
2 o3 Z; ?% n% @' a( ^/ h& \( o            return;
        }
        //计算最大值与最小值
9 t7 T0 d& z4 j7 b        int max = Integer.MIN_VALUE;
- m3 |9 w( n: f6 I- l$ ?. `8 N+ T4 u        int min = Integer.MAX_VALUE;
8 i+ L0 e( F" m) {        for(int i=0;i<arr.length;i++){
* G2 l0 x& b; W% c( a) j1 K* ?            max = Math.max(arr,max);
            min = Math.min(arr,min);
, c2 r1 f, c5 q7 Y8 q        }


        //计算桶的数量
        int bucketNUm = (max-min)/ arr.length+1;
        ArrayList<ArrayList<Integer>> bucketArr = new ArrayList<>(bucketNUm);
        for(int i=0;i<bucketNUm;i++){
  ^% c1 n/ ^8 k            bucketArr.add(new ArrayList<>());
        }

) B/ f% j1 i4 j- D% [* x1 ?
        //将每个元素放入桶中
        for(int i=0;i<arr.length;i++){
0 K+ s. \4 `( X$ M1 M3 l3 S            int num = (arr-min)/ (arr.length);
            bucketArr.get(num).add(arr);
2 F6 K8 ^  e+ S" x0 l  h        }


- q4 ]' n% ^$ Y& P+ k        //对每个桶进行排序
3 F% k5 B9 {4 G! e        for (int i = 0; i < bucketArr.size(); i++) {
# X$ f% C( I2 N, L7 M            //用系统的排序，速度肯定没话说
$ k# X" n2 a( o            Collections.sort(bucketArr.get(i));
        }

6 J; I4 R& C0 P+ p& G6 L
        //将桶中元素赋值到原序列
6 N1 [! |$ v) L- ], b1 D, A        int index;
; ]; H& ]' }! D        if(ascending){
6 Q7 {9 b; |, ^" A, d            index=0;
        }else{
            index=arr.length-1;
2 w0 R; I# V% l5 J, A        }

' B" H5 K- x; R2 K- h8 G/ m
        for(int i=0;i<bucketArr.size();i++){
& x" Z7 m9 ]" \+ F            for(int j= 0;j<bucketArr.get(i).size();j++){
                arr[index] = bucketArr.get(i).get(j);
                if(ascending){
                    index++;
                }else{
                    index--;
                }
            }


        }

& O0 F" P1 M* G  v3 ]: K* \+ O3 x
- w4 s$ U+ w, s. ?- C# Z    }
}
( @6 q+ N6 T* u7 S' b2 h5 w% Z1
2
3
4
5
" V: E# g' i! x* j* h6
7
: W( n3 N) Z5 ^3 s6 x2 W8
( o' u* G, D- u9
10
11
12
" b  e7 M, x) r$ d6 P4 N13
14
15
16
9 g* x3 ^) o5 }" h3 X: M! H17
18
& s: C$ K5 i/ J19
, B1 u, U# K6 |+ t  |20
21
2 K! `) W2 D, F! O* t( h3 a22
23
24
5 ^7 S7 o: o8 D25
1 v, ~3 L& ?( y7 l9 F26
27
% f$ n' \. w$ C4 Z  `  U28
29
30
31
32
7 `( e4 G: ^4 l" C7 \, W/ U33
34
35
36
( n1 P3 k% N% X" e37
38
9 z2 p# Q: T. U# R39
40
3 Y$ |$ H3 K* r41
42
6 s. w2 v3 B' q( [% y43
44
. G6 n1 D" G( A+ [7 t; D6 u% N45
& p& `$ Z* y5 v46
% k! s! i+ [7 t" [& T3 Y2 h- c2 h$ O47
48
49
$ ~+ G4 }* ~4 h1 U* v50
51
52
6 p+ b. i' n8 k, Q53
4 O  z$ G* K3 l1 b# d54
55
% n- C& l8 V, q56
57
* g; }8 R. d. e. }2 i1 m* P) w58
0 H# \! N/ ~( a9 b; ?59
% o1 R% P; e5 ?2 W1 x3 p3 L60
61
7 D0 H6 g; y8 Q1 l' |- B5 W  J62
63
5 }& s: B5 ?! g64
65
. Y# k2 a& H4 o* w/ A4 C66
. n1 y0 I  I- a4 C" L67
68
$ s' S: G$ n, e0 R' C) ]+ J6 M6 K69
70
71
1 L* r2 i4 ~/ G. B72
0 `7 k1 M3 }7 ?3 F; g, a8 a9 x/ j4 n: l基数排序
$ p& u. G% D. ?. h' V* a/ C简单解释：
$ q3 M; S9 b( g% _# u3 X8 J首先说一下，我发现好多人写的基数排序只能排序正整数，其实只要处理下就可以排序含有负数的了，就是我们排序前先把所有的数整体变大（就是减上最小的负数，也就是加了），都变成正数，然后排序好之后，在减下来（加上最小的负数，也就减了）就好了。
* S! m0 U* a* P+ I# x, }5 ?基数排序就是按数位排序可分为LSD（从最低位[也就是个位]开始排序）和MSD（从最高位开始排序），下面写的事LSD基数排序。
% j) B, v6 u/ I% W' B& ^; T基数排序就是把数按位考虑，让后我们一位数只能是[0，9]，就是我们在考虑某位（个位、百位· · ·）的时候就只看这个位的数，放到在[0，9]相应的位置，然后顺序取出，最后再按其它位这样操作（上面说了要不从低位开始到高位，要不就是从高位到低位）
! c" |; K3 a; a' W/ g
$ Z5 e, o* I% n6 q; _( R2 n

9 y) H  m. r( B2 T; i2 B' L$ e
/ j4 u% E& I* R
  D- q: Y! W% v% z
完整代码：
( \7 L5 T+ Y4 i

package com.keafmd.Sequence;

9 p3 c' ~7 {/ Q; ^$ F& R
/**
5 ^0 ^$ N5 J0 [4 v) S * Keafmd
& V4 d5 |  R" _* ?( ^$ L- u *
* @ClassName: RadixSort
* @Description: 基数排序
; l7 b% x$ G1 g; |4 B: `' g/ e * @author: 牛哄哄的柯南
* @date: 2021-06-24 14:32
*/
/ [; X  }$ n. h; n* i% Y' h) `public class RadixSort {
    public static void radixSort(int[] arr){
        radixSort(arr,true);
0 A9 s2 f" q+ v' B- i    }
    public static void radixSort(int[]arr,boolean ascending){
        int max = Integer.MIN_VALUE;
        int min = Integer.MAX_VALUE;
        //求出最大值、最小值
        for (int i = 0; i < arr.length; i++) {
4 s; s1 z. [3 O# L            max = Math.max(max, arr);
            min = Math.min(min, arr);
        }
        if (min<0) {        //如果最小值小于0，那么把每个数都减去最小值，这样可以保证最小的数是0
            for (int i = 0; i < arr.length; i++) {
: O8 L! a! Q7 I" h( W8 b                arr -= min;
2 x4 f$ j& `# L6 ]- c            }
            max -= min; //max也要处理！
* Q) c% g0 P& W3 J- O+ C        }
5 P" F7 g9 n3 J: F" ^6 ]+ ?        //很巧妙求出最大的数有多少位
        int maxLength = (max+"").length();
        int[][] bucket = new int[10][arr.length]; //一个二维数组，一维代表0到9，二维存放符合数
$ w: M+ C) K9 N/ y/ Q3 B        int[] bucketElementCount = new int[10]; // 用于记录0到9某位存在数字的个数
& D7 Y: K, \" R* Y; J        for (int i = 0 ,n = 1 ; i < maxLength ; i++,n*=10) { //个位 十位 百位 这样遍历
            for (int j = 0; j < arr.length ; j++) {
  D6 [/ X2 H7 m                int value = arr[j]/n % 10;
                bucket[value][bucketElementCount[value]] = arr[j];
                bucketElementCount[value]++;
            }
3 a( |+ u" Q5 ~% e( \0 ~) y7 S
$ D5 Y. R& B9 [- F
& f0 s( f3 r% e! E- \" b            //升序
* c: l5 t, e; C$ ?4 n8 k            if(ascending) {
                int index = 0;
! ?+ ~" e. K$ k9 x5 k# l                //从左到右，从下到上取出每个数
$ x+ d' u$ W! d9 i+ W                for (int j = 0; j < bucketElementCount.length; j++) {
                    if (bucketElementCount[j] != 0) {
! b  x  l' ?0 Z0 Q0 E8 ?                        for (int k = 0; k < bucketElementCount[j]; k++) {
                            arr[index] = bucket[j][k];
                            index++;
                        }
                    }
                    bucketElementCount[j] = 0;
                }
3 {6 z+ d1 I  z* v- P* l" i            }else { // 降序
                int index=0;
- T2 H* u$ ^2 [. Y  G. O                //从右到左，从下到上取出每个数
0 r4 X/ ^5 ]. m8 }2 p                for (int j = bucketElementCount.length-1; j >=0; j--) {
                    if (bucketElementCount[j] != 0) {
                        for (int k = 0; k <bucketElementCount[j]; k++) {
; s- V; b: A( Y( C                            arr[index] = bucket[j][k];
                            index++;
% ~% k* I6 }" y; A- h) J" b, ]                        }
8 B5 }# N& b0 J" u- S' p% ?                    }
1 y& w1 D5 E& r7 W4 }                    bucketElementCount[j] = 0;
                }
            }
" f# Y& |  F5 I. G
; a1 L+ W7 W' A
0 s/ x2 D% K; ]

- S7 u6 B& ]1 w            /*for (int i1 = 0; i1 < arr.length; i1++) {
                System.out.print(arr[i1]+" ");
0 o, S+ _5 M6 K" |4 k: C3 e            }
1 ^! u, A4 X" N. P( t+ Y            System.out.println();*/


  a2 a; ?/ p/ g. O/ [8 l& q5 N


% G" O3 q2 F3 `4 n' E! F: J: d
        }
        if (min<0){
            for (int i = 0; i < arr.length ; i++) {
, a$ o0 p9 D! ]                arr += min;
            }
" V6 p, S/ E5 s" F        }
, ]3 s9 R% l! {7 P7 X
- z1 x! q& m1 D9 A4 P. s
" s5 N, S1 h5 l# P1 q    }
}
/ A) ~/ n, @1 \+ J$ J1
2
- c( \) O, O$ T; v0 j* B3
1 o! P0 B. D% C, l8 y. `4
5
6
8 O" e) H8 I% P, [7 Y: F7
) n% ~* `7 G: x5 N8
: L. w) F* q( E. k) F5 Y9
10
7 E1 v; A( L9 I1 z- n) Q11
12
13
14
15
1 x: r0 U/ v: k+ E+ k" J16
17
18
* @& p* l2 i# y19
! N# o# g7 v3 N) u20
21
22
23
24
( h& Y9 E: B3 ]25
3 k5 m4 e- s- O: A8 ]. M. r6 b26
1 z) \0 g: h7 x0 D+ M27
28
29
, @  I: {" ~: j6 L" |. |. ^30
31
" R. {- v" J4 w. Q- F32
33
34
35
, d1 T4 r& |# {- E) p+ V3 G36
* D5 R; D% r1 g( D$ F, M/ H6 u37
0 s% z2 @5 _# K. }6 E38
39
40
41
+ N$ C8 x( W  d) u42
43
44
45
" i& e4 F+ v$ {3 r+ g46
! \7 |# ^- o5 h47
48
49
+ c0 B3 }/ W3 F$ y* W3 a0 ^3 \50
6 M4 ~% k3 C9 e# }7 Y51
52
, Y. F) I. b/ L8 ]+ ~6 U53
; ]9 c9 T# t9 y: }54
- m) ~) A( P: h/ q( b55
, q+ o* a$ R; v& g56
57
58
" C# K4 f$ [2 q: j59
60
' k$ E7 H1 E7 I0 G) Z! n  N8 ~61
7 j6 v% q% G! Q) }) F" P$ Q# J5 V62
63
0 W  Z: Z" T: z64
65
" ]6 E6 s, G1 L0 [' J3 j; {66
0 v, A0 ~- d) K4 k) n67
: B7 S5 s( x8 b1 r8 @3 U# c9 D* ~68
69
70
71
5 x" B' {( f: ]6 }- W2 k72
* i+ s2 X, \; |  e* l' J2 R/ D73
74
( i( {0 [6 |9 e& {75
76
77
7 W( E# o$ s2 {' i1 V7 r2 p78
79
80
81
+ A" n$ T1 T6 m" [( E82
' P$ m6 [0 H- q9 `1 g) p9 f& E7 G83
+ h' y. h1 {3 z/ |* S9 @# D完整测试类
package com.keafmd.Sequence;
  g; Z2 Z" \: c) K7 `1 s8 v, _
  k; c" W4 M) ?
2 K$ |& v5 R. E9 C3 ^" R: p& s/ ?# ximport java.util.*;
6 Y7 s' d3 c7 `) jimport java.util.stream.IntStream;
- Y9 I( o* ~1 n, `( W6 Ximport java.util.stream.Stream;
: L- \" ~/ R' u
* z; v: m/ U' `4 ?$ P" o" P6 G8 N
/**
/ o# Z( m4 n( }9 d! C' `* c * Keafmd
# K$ _4 {) e7 T) H5 i* `- Z *
- J# k+ w' D7 v3 ~ * @ClassName: Sort
* @Description: 十大排序算法测试类
* @author: 牛哄哄的柯南
* @date: 2021-06-16 21:27
*/
4 W4 C& ~: Z) ^public class Sort {
* y1 w3 n' V8 l0 V
! h1 [6 y3 @7 R


: L4 ^+ F0 ~- Q    public static void main(String[] args) {


        int[] nums = {12, 4, 25, 47, 58, 34, 25, 9, 99, 26, 1, -13, 162, 10093, -66, -1};
//        int[] nums = {12, 43,56,42,26,11};
: @+ T/ o; @% @        int[] temparr;

! B- r8 {1 E0 J2 Y) }& F0 ?
        //利用系统Collections.sort方法进行对比


2 {$ L& R1 |( r, r4 a        //将int数组转换为Integer数组
        //1、先将int数组转换为数值流
6 E0 ?2 N) s: ?% D: q- z        temparr = nums.clone();
        IntStream stream = Arrays.stream(temparr);
        //2、流中的元素全部装箱，转换为流 ---->int转为Integer
        Stream<Integer> integerStream = stream.boxed();
        //3、将流转换为数组
        Integer[] integers = integerStream.toArray(Integer[]::new);
& ^  N+ g# e- q8 ?; I& }        //把数组转为List
$ |! M4 z% E. v0 ^        List<Integer> tempList = new ArrayList<>(Arrays.asList(integers));
        //使用Collections.sort()排序
9 i' z+ i) _/ w6 {& |: h/ U        System.out.println("使用系统的Collections.sort()的对比:");

; i% i, E& J. x% ?* Z& u; O6 j
+ i5 v3 _' v( ?  f" Q' [        //Collections.sort
        Collections.sort(tempList, new Comparator<Integer>() {
            @Override
; h  P) K9 R' Z6 s            public int compare(Integer o1, Integer o2) {
, f; l8 F' F2 |4 x, L2 ~                return o1-o2;
! C* r7 l; k" [" a. x# L  m8 t) K                //return o2-o1;
            }
! x% j! K9 I4 M( b( B        });
- V! `1 \  T2 ~1 `
8 h3 E  y5 {$ n, M8 e* n8 @
' o  P1 j# E* d2 E& p        //tempList.sort 也可以排序
       /* tempList.sort(new Comparator<Integer>() {
            @Override
            public int compare(Integer o1, Integer o2) {
                //return o1-o2;
                return o2-o1;
( u, {8 x6 ?6 _) _' |            }
        });*/
* d5 r% \. Y" L

% [  F) X, c! i# F& `        //遍历输出结果
        for (Integer integer : tempList) {
6 k3 d# ]$ Q* ^% d) [            System.out.print(integer+" ");
* N7 f5 v) l( E        }


3 d& e& h3 D' L6 Q& d- w        System.out.println();


        //测试冒泡排序
        System.out.println("测试冒泡排序:");
0 c/ r3 Z* g  u) O' B3 S        temparr = nums.clone();
( ]5 ~5 h3 J% }. M3 z) H" [

        BubbleSort.bubbleSort(temparr);
) e# V' A& {. \8 P8 p
5 L; a5 K" v" p+ ]% i& ?
6 x! Q" b6 F6 @        //降序
% e% f, m$ r4 f. a. k, L        //BubbleSort.bubbleSort(temparr,false);
2 ?: M: D  W* M/ M% f- x- o# y
2 J2 _* k8 p6 Q: S
, z) [& X/ ^4 `; ]8 O        for (int i = 0; i < temparr.length; i++) {
            System.out.print(temparr + " ");
        }
        System.out.println();

' ~3 @- }! ^' E# y1 D. q$ F  r
        //测试快速排序
        System.out.println("测试快速排序:");
        temparr = nums.clone();
        QuickSort.quickSort(temparr);
        //QuickSort.quickSort(temparr,false);
        for (int i = 0; i < temparr.length; i++) {
5 ^' \; x$ Q! V4 K) a' x            System.out.print(temparr + " ");
        }
        System.out.println();
& ^' N/ x" e, q& W

        //测试直接选择排序
        System.out.println("测试直接选择排序:");
, s4 d! k! R8 m, U$ M        temparr = nums.clone();
        SelectSort.selectSort(temparr);
        //SelectSort.selectSort(temparr,false);
        for (int i = 0; i < temparr.length; i++) {
7 Y4 f1 J* A* w  h1 K) W& Z            System.out.print(temparr + " ");
% q# G+ r0 a; Y        }
        System.out.println();
6 Q: C1 S6 h4 C4 j% ^" t, V

# @+ p. |& ?4 n* g! A        //测试堆排序
        System.out.println("测试堆排序:");
        temparr = nums.clone();
' P- d3 F; D7 |        HeapSort.heapSort(temparr);
4 C$ V6 O& ]7 r4 U        //HeapSort.heapSort(temparr,false);
6 ^/ b0 T7 S0 a  r        for (int i = 0; i < temparr.length; i++) {
            System.out.print(temparr + " ");
        }
2 U2 \6 ~* _6 G+ A/ X        System.out.println();
1 @) l% j" n' L7 A4 x2 O
5 S' k- L% r" ?  r. |/ C* ^. y
( K8 f9 S& H* B6 ]& w7 d        //测试归并排序
        System.out.println("测试归并排序:");
3 p6 }$ H2 a) K5 n  f. L- x2 h        temparr = nums.clone();
2 o' z- u+ m' r3 E. L        MergeSort.mergeSort(temparr);
* i) ~9 s4 P2 w6 ^  b% q        //MergeSort.mergeSort(temparr,false);
. P% o. C2 T6 f. h        for (int i = 0; i < temparr.length; i++) {
( q: ^0 H' ~0 _2 s; \            System.out.print(temparr + " ");
9 |. ^) R1 J3 N; j4 F* X3 ^/ F$ M        }
        System.out.println();

* K) b( P" E3 _1 r' C$ `
1 q% J9 r; Q6 g8 }, @        //测试插入排序
9 C8 T3 m3 ^8 J) O4 x0 s        System.out.println("测试插入排序:");
        temparr = nums.clone();
  K' K$ m+ E, ^$ K2 I        StraghtInsertSort.straghtInsertSort(temparr);
' L. ]+ S8 D0 M8 o        //StraghtInsertSort.straghtInsertSort(temparr,false);
4 s+ q( d4 v( n7 _- y        for (int i = 0; i < temparr.length; i++) {
            System.out.print(temparr + " ");
- O; L) N5 l9 I4 M1 X7 m        }
& }: h( q8 S  W: [5 ^4 n4 [1 B        System.out.println();

$ Z: Y5 b' C# I% S# n: X" R: l- `

, r8 ~6 v4 o5 r+ B# V+ O1 V
        //测试希尔排序
' i" W7 T" ^# M5 f+ r9 p# |4 K        System.out.println("测试希尔排序:");
5 B' O+ \* |$ z  S1 y( X5 v        temparr = nums.clone();
/ h* X$ a3 B6 F( s3 F$ k0 X        ShellSort.shellSort(temparr);
        //ShellSort.shellSort(temparr,false);
8 h: i( e$ `6 d7 }7 I4 R, |% b% z& m0 r        for (int i = 0; i < temparr.length; i++) {
, s0 l  F7 {/ e1 l            System.out.print(temparr + " ");
/ {% ^; W7 Q- m$ a& k! v8 Y        }
        System.out.println();

# S: A+ e7 Z8 M# w
+ t4 o) v- T, ]8 a+ q
0 Q  y* |4 l2 X
        //测试计数排序
        System.out.println("测试计数排序:");
. [0 X& _% ]1 ?/ p) {, k        temparr = nums.clone();
* \, X5 j, Q# e3 [5 K% f, L+ V2 D        CountSort.countSort(temparr);
        //CountSort.countSort(temparr,false);
        for (int i = 0; i < temparr.length; i++) {
            System.out.print(temparr + " ");
4 v+ m0 o" O3 q# A+ I% H. ?        }
        System.out.println();



0 M0 _1 ^( R3 \, ~
        //测试桶排序
- `, ]$ w, U  \" k        System.out.println("测试桶排序:");
        temparr = nums.clone();
        BucketSort.bucketSort(temparr);
/ l5 f5 y3 P: f* d# B2 Y        //BucketSort.bucketSort(temparr,false);
. X8 Q4 e/ [' g% ]        for (int i = 0; i < temparr.length; i++) {
+ Z- D" d# ]9 [# K; N) o& `            System.out.print(temparr + " ");
, L( y6 |& t/ Q; D  }0 X0 d        }
. n$ I# H6 K0 T1 e) E        System.out.println();
& I. C6 N6 [/ X
8 k: K: |7 R* I+ r
: {- K5 k* n2 ~( Y        //测试基数排序
        System.out.println("测试基数排序:");
        temparr = nums.clone();
        RadixSort.radixSort(temparr);
        //RadixSort.radixSort(temparr,false);
8 j0 F" ?: ~$ n/ q& B        for (int i = 0; i < temparr.length; i++) {
3 k/ g9 }1 U# N$ Y8 T& ^$ s            System.out.print(temparr + " ");
" h  V3 W8 O) ]        }
        System.out.println();
2 S7 n) p) `5 W5 ^2 G( {

    }

- ?" U& w/ W6 @
. @9 J7 f3 G3 c$ R* [}
1
2
3
9 n7 j; E% U. W- P4
5
4 ]% S  W4 J5 h0 B  L6
7
8
6 h2 ^% z1 g7 o' o  G9
5 n* s( g$ b  `" a0 n5 E# }. }  J10
1 s$ B; d6 T& H: q6 d$ Q8 n3 m9 C11
; a: `- u. u, Q/ J: {% U+ `12
0 d8 H, l+ {, A: b- q13
! i4 b* e# F/ p# R, }14
15
16
( l' ~! _! `5 P' C9 d17
18
19
! _& [6 b' U% W" Q6 @" c20
$ z: e* x2 U5 w: H6 A21
22
' b" ]0 r  I( f8 T3 v$ d23
4 l  R1 I6 P" B6 a; x24
25
) C/ R& I* b# K' x7 t2 ?- }, I- s26
27
8 k. B" ~' j- f& P28
1 Z# b8 A9 U& |# Z9 x( b29
5 k$ o1 s: Z2 K- k  ]6 X3 Y) R/ n30
31
32
33
. C* G2 g. F7 o6 I' }- E34
& D6 [8 ]  f. t' X0 X35
. X* K1 {% M# ~$ b2 f4 y/ `  y36
0 b3 P: B: k' X3 X2 G37
38
* x7 y9 K2 C. ^; m39
40
$ w3 Y, _' ?! ^! v# v; y" ?41
42
43
8 v/ O$ b; S4 R/ @; ~0 G2 l' I, O44
45
46
47
& Q  g1 ~9 a$ _! x48
" ^9 V2 x  S; V8 ]; X3 F9 Z49
50
: N; @' U' Y- U+ U51
( u2 r+ Z' u, Z/ ?4 }52
53
54
8 z1 V. U& n' r9 [& V55
56
57
58
6 g! L* V8 \3 z0 g9 G3 W/ N' O59
; N2 g! n3 v+ m; o4 {60
- r4 d' u6 q4 t61
0 _5 G+ K1 O9 }9 a; c. E4 t5 H62
4 W. I) {  v! E3 A63
64
65
66
67
3 H2 d* ?- {4 q# z, ?68
+ Y, G6 ?- f2 S) R69
70
9 q9 s5 d' C7 }, t7 e& w71
- Q, `5 S, B' F* \2 g( Y72
73
8 a1 D+ I9 b2 `8 _: {) \1 i: u74
75
% q" B. w- t7 Q# \" k76
77
$ ~* b  ~) V2 g9 t* u78
; j& E( E) l2 s* U8 U79
80
) R3 Z  E0 [) U6 Z81
- s4 O) U3 A6 Z  ?! S  {82
7 ~0 `4 q* r4 E4 D6 e" }83
9 t0 M) X+ C* ]$ Q7 @9 [84
85
2 p% s# H3 t! w/ q86
87
2 k( ?) j# k# q9 X% W2 m! x  d: h' z88
! P2 q1 {2 g! ?1 z. g, w89
90
9 |1 C9 P2 ]9 w$ L) g% }91
& i" C0 I+ V" ]* M- Q. t: ~/ l92
93
94
' k2 u( Y, _, L# A95
96
: O* g: N/ X$ q6 q0 R97
98
0 h& z& q7 g# v6 Z( X; Q99
100
4 x. G. ~1 L, _6 Y101
102
103
104
105
( X5 W2 I/ `4 j( U+ ^106
107
108
109
* N- Z4 j1 ]! t+ |110
111
  i! g8 R/ U8 l1 w6 u0 D% ^112
113
114
8 P& E: K6 l; B7 |: h6 C! ]115
116
117
/ I9 |! B8 C1 X' l( y& \& z118
119
120
! p4 k) D% i: c0 y' i121
% `# z5 k7 [. V/ a% |( ~( Q" k( `122
; W1 y/ h& M/ s123
, @* O% r! T8 [/ {: Z124
125
126
0 z, b6 W+ N7 Q8 o3 l( J5 E; r127
: f) f7 \% O/ q4 y. ]/ l128
3 B7 g& m8 i6 _8 e; k4 M  ^129
130
. r7 i9 }) O" H: G% W( b4 Z$ f131
! o9 m! m7 c' q: u132
0 V, |7 |- }- x133
134
* t% {( d$ l8 c" n1 \/ \135
136
137
138
139
7 Z) o8 H( d8 ?  m- z140
) m, h0 ?) v" C- o141
142
143
144
3 b7 v* p8 ~" w( k. ~8 s* K, M7 [145
146
5 }2 N# _$ d! t3 E, |$ n147
/ K$ a8 x* V; ~, p148
149
" `1 Z. K: U3 y) V1 {150
4 a  \9 t1 m  r0 D3 Y9 t% X1 u& x1 M, y151
152
; S6 D/ g2 h4 A1 n, d- B153
+ ?1 L, \4 b. V) \. i154
/ G7 e5 `: r# x* ~155
156
3 I- _  u# S3 @/ O" _: ?! q0 M157
: \, {4 v0 d' u$ X( _, J8 I158
159
6 i9 h& l1 I! T160
7 ?. y  d- K  O/ Z3 D$ U$ }161
162
163
164
165
- E' b: P" H0 O5 h+ ^) i166
( z  `+ C! {, Z! W: E6 x! C* v167
0 `% n6 Y% W% ]6 c: p, Y168
169
9 j) U8 E( Y  Y# D7 U170
& u1 M4 `$ n0 q$ @171
2 J: Q) T1 Q0 j172
173
7 ^& o! B, B0 L* h每天进步一点点！
不进则退！
0 g& \0 d7 u/ e8 }5 i
3 ~) o4 B; ?, s' `! A# ?& d" K0 q9 V
, c( p7 G# A. [; B- H; p版权声明：
: B' ^: V  k& f& o) @原创博主：牛哄哄的柯南
博主原文链接：https://keafmd.blog.csdn.net/
5 D: }3 G% A8 E0 ~1 [————————————————
, S2 F) ~2 R  u版权声明：本文为CSDN博主「牛哄哄的柯南」的原创文章，遵循CC 4.0 BY-SA版权协议，转载请附上原文出处链接及本声明。
原文链接：https://blog.csdn.net/weixin_43883917/article/details/118193663
: B# R; z1 y- N8 R2 _" ]5 b5 C
& i" X1 u! e) b

---

作者: 1051373629    时间: 2021-8-17 17:20
每天进步一点点！

---

欢迎光临 数学建模社区-数学中国 (http://www.madio.net/)

Powered by Discuz! X2.5