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

杨利霞

0 Y$ G4 T1 P9 e+ ~4 x# i( U4 E9 M经典十大排序算法（含升序降序，基数排序含负数排序）【Java版完整代码】【建议收藏系列】
经典十大排序算法【Java版完整代码】
; O  k; J- c" ]1 z# n写在前面的话
十大排序算法对比
; Y; ~: A" \6 h8 F& p4 w  L冒泡排序
快速排序
1 m- o* ^3 C; e' Q" _直接选择排序
0 O- p+ e/ H: E6 w5 f堆排序
5 f# i7 u: ^* d* H, U" u归并排序
插入排序
希尔排序
* G5 H' w3 P& I- j计数排序
/ h+ r0 z: {: ]/ J7 J桶排序
. X" H+ ]: w8 [7 M; Q8 e1 p基数排序
完整测试类
写在前面的话
0 K! X5 g9 {# `       虽然已经有很多人总结过这十大排序算法，优秀的文章也不少，但是Java完整版的好像不多，还存在某些文章代码存在错误的情况，同时也为了自己练手，决定把所有的写一遍巩固下，同时也真诚的希望阅读到这篇文章的小伙伴们可以自己去从头敲一遍，不要粘贴复制！希望我的文章对你有所帮助，每天进步一点点！！！

- k6 X* ^9 a5 \9 N& ]. K
) R5 T) S9 `* o2 Q       我用通俗的理解写下对算法的解释，对某个算法的运行过程不是很理解的话或者想看比较官方的解释的话，单独搜索某个算法，看几篇不同的解释，就可以有自己的理解了，这里我主要展示代码以及进行通俗的解释！整起来，再强调一次，一定要自己敲一遍，这样才能理解的更深刻！
" a4 q- G+ p! W# C1 ~
- z9 {5 b! `: s& q0 X
3 \3 t! K5 D7 y2 j. _+ L十大排序算法对比


. S2 M! |7 r' {

$ l8 a2 X. w+ S2 k9 C3 r% T5 b- e" N关于最后一列的稳定性，我稍微解释下，例如对序列：1 2 4 2 6 排序，序列中存在两个2，如果我们把这两个2标记上（让他俩不同），排序之后，前面的2还在前面，那么就称这种排序是稳定的，反之不稳定。


冒泡排序
. q6 o" i( y1 q& H+ L( c简单解释：
       原理就如算法名字一样，就像水中的气泡一样，每次我都把最大的或最小的放到最后面，这样总共需要n-1趟即可完成排序，这就是第一层循环，第二次循环就是遍历未被固定的那些数（理解成数组左边的数，因为每层循环都会把最大或最小的数升到最右边固定起来，下次就不遍历这些数了），两层循环遍历结束后，所有的数就排好序了。
       两层循环所以冒泡排序算法的时间复杂度是O(n 2 n^{2}n
4 r! z0 W+ ?) D* Q2
" Q' h8 ~) V& A/ T: S+ R )，是一个非常高的时间复杂度，我在下面的代码进行了优化，加了一个标志位，如果上一次循环未发生交换，就说明已经是有序的了，就不继续下去了，反之继续进行下一轮。

% G, Y& ?7 _% A* i1 C



5 }, Y. S3 n# t/ p4 I' W
: x4 t9 [  y% s: W本文的图片来源网络，仅用于大家学习，侵权联系删除！（下同）


+ q( w" S) P6 d! v) r/ K1 c完整代码：

7 ~+ g4 |6 U6 w& x7 w9 _
package com.keafmd.Sequence;


& A7 y# R$ M/ W: g/**
# d: g' u" o6 T& Z9 w * Keafmd
*
* @ClassName: BubbleSort
* @Description: 冒泡排序
* @author: 牛哄哄的柯南
! I+ ]7 x) y+ J# h * @date: 2021-06-24 10:31
4 X; M8 f' J, F; I' k */
public class BubbleSort {

! b  E3 [' V: R' s" o- X0 N
    //冒泡排序
    public static void bubbleSort(int[] arr, boolean ascending) { //exchange标志表示为升序排序还是降序排序

5 d$ b5 t. N  H
! Q* N: m8 y; n, o1 \  d) K        boolean flag = true; //加一个标志位，记录上一次是否发生了交换，如果是，我们则进行下一轮，如果没有，说明已经冒泡好了
2 E! U- t" {0 O

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


; X! v! [% D1 J( n7 j            /*System.out.print("第"+i+"次遍历：");
# [8 x$ h: h6 ]( G0 ]  @+ I: r8 \            for (int i1 : arr) {
7 F) @& D4 w" X1 t                System.out.print(i1+" ");
            }
) r6 _# j& G8 \1 C) F            System.out.println();*/

0 H2 j" v% W# ^  W, I& K: G
. z6 H- s  m2 [- r# O/ ?            flag = false; //假定未交换


) s& u& F5 h8 U; ]            for (int j = 0; j < arr.length - i; j++) {


7 u0 F& K& P; o- Z5 a; y                if (ascending ? arr[j] > arr[j + 1] : arr[j] < arr[j + 1]) { //控制升序还是降序
! d! _9 Q( J) x+ I1 s. `                    int temp = arr[j];
                    arr[j] = arr[j + 1];
* H' H# `& F4 \1 a0 c+ M! V' I; W' V3 Q                    arr[j + 1] = temp;
5 s5 m' r$ v* U' z, G2 l& u                    flag = true;
4 ^! y: T+ d: H" L5 N& M                }
6 d& w1 K) O" E. S
9 ?& M) q5 c3 F
            }
        }
4 i3 x" l5 m" A9 ]8 p, i    }


, f3 b! H. ?8 K$ m! H1 ^, |1 n    //冒泡排序 -- 默认不传参升序
# x2 T. G4 J! l% a9 c    public static void bubbleSort(int[] arr) {
! P: A( g- i) u0 [% ^) W) C        bubbleSort(arr, true);
    }
}
1
9 V0 d5 _- t2 _$ U  _2
8 M5 s  B. U( b/ M( o3 ]1 _3
; e  ?$ C: @/ b7 _" K" k2 h# p4
& }& t; _0 z- w( Z; c; c# r5
6
& k! Y- Q) ]$ Y5 q; e/ w" L7
3 O: {" a' Q9 H* Z0 `/ {8
2 N% Y3 A: s! `& y; N: B9
1 I; d" c4 e3 A10
1 i7 F, P2 A- r4 Y5 F11
12
3 z9 a/ c4 v; @$ o$ o9 ^13
14
15
( ]1 [3 x: `4 w  L) \16
: s0 a" k' l$ m$ ~! v+ j* G. F17
18
19
0 @0 H! y9 v4 k20
& J0 r4 o# g. N3 S1 X% O21
8 {+ r6 p3 z1 ~4 r: U; D  `22
23
( T! f0 p1 X3 j; m" y. m5 ]24
5 W( P9 d. p/ O. X4 w25
26
27
  u- _& k8 }0 I. i# n/ _) z/ U! A6 I28
0 T. Q1 g) c& A29
30
31
32
33
& Q! ]- J# a6 s, c$ \34
" D3 ~1 w/ y* l35
+ P% A8 L  q: W7 ~8 k36
37
- ~# X7 p( f% u38
39
1 {! F8 \9 D7 J0 [: }40
- m6 B% G& Z: T+ s9 E2 E! Q6 v+ f41
42
43
, r# L. G) i2 q, g3 s44
45
测试代码：


升序排序（从小到大）


package com.keafmd.Sequence;


import java.util.*;
! e  v3 B3 ], y) I0 j& Pimport java.util.stream.IntStream;
( u' O8 x! m. W0 n% O1 n, [9 x8 H7 nimport java.util.stream.Stream;


/**
( y. K0 ]* ?3 X  b * Keafmd
- G/ [* }1 c8 G( w. V- Z' Z *
* @ClassName: Sort
* @Description: 十大排序算法
* @author: 牛哄哄的柯南
* @date: 2021-06-16 21:27
*/
. J- X* D6 V9 {  y% x5 {- l  G. Hpublic class Sort {
4 g6 s: @# x# J    public static void main(String[] args) {
( z) ]" f; O* P$ M

        int[] nums = {12, 4, 25, 47, 58, 34, 25, 9, 99, 26, 1, -13, 162, 10093, -66, -1};
. \6 L0 B3 b5 p) f( b        int[] temparr;
) c* x. F  y9 E! c3 q

        //测试冒泡排序
        System.out.println("测试冒泡排序:");
        temparr = nums.clone();
" y- v; w; q9 u: R( K" r        BubbleSort.bubbleSort(temparr);
! p& q4 ?* X- N! Q$ Y  [        //逆序排序
7 |8 |. g) R+ h/ K        //BubbleSort.bubbleSort(temparr,false);
/ w% J" [8 _% b9 l+ }; _8 E7 O        for (int i = 0; i < temparr.length; i++) {
            System.out.print(temparr + " ");
) T8 a7 ]8 i% s1 Q! r        }
( ^! Z* E: n" c9 l4 N        System.out.println();
" t% `4 _3 _( w5 ]8 z
- P& q; _4 @, i  G- K7 q! F
    }
}
9 r, B0 e2 \( {$ A. `6 L$ K+ l5 I1
0 m' v8 i; f. C6 H9 H& ^2
3
9 U6 s; z$ {. q, I4
$ V& j8 H8 @" |2 x5
6
! ?2 Q+ j6 @% K5 [7
* v* V# l" c8 u- ?* y' g8
9
10
11
1 h% t) S% N3 H: B12
13
' G5 N. o* C: c. |5 I6 x3 k14
& F& `% {( g6 r$ ?* X2 y+ X8 _15
1 `% z. N6 x2 M) k  ~5 U! I16
17
18
& q% J) o& W7 ^- Z; r$ R19
20
1 v$ l- O0 W; g21
22
23
2 i8 H! a2 W: M+ P24
25
26
27
28
29
30
31
; V" K, ]8 `. Z32
33
/ G# V- @5 O8 z! [3 f& B' ?运行结果：

6 I3 z, x4 ]- ?9 p9 M
测试冒泡排序:
-66 -13 -1 1 4 9 12 25 25 26 34 47 58 99 162 10093
0 k$ x7 a2 O+ U: R5 a1
2
7 R$ m/ ~1 |+ N: s- f降序排序（从大到小）

7 }% j( h0 H5 C. U0 ^9 o: n
- p. L% {% V: @+ P//测试冒泡排序
System.out.println("测试冒泡排序:");
temparr = nums.clone();
9 Z% y' M3 I( j0 sBubbleSort.bubbleSort(temparr,false);
, J# Z8 H! ^0 r! C* t7 m4 i6 Lfor (int i = 0; i < temparr.length; i++) {
    System.out.print(temparr + " ");
}
System.out.println();
1
  E: m7 O8 o7 {9 {  [  b2
7 ~4 X% l4 _9 g1 o8 |3
/ Y9 o/ r! ~/ @" }4 y4
( `% n1 d% b; Y$ [7 d9 |5
6
7
+ u; m9 H1 r( t( s8
运行结果：
* b7 D7 d! ~. L5 Q' H6 ~- ]

2 i+ j0 f8 P4 w& g2 @: l测试冒泡排序:
10093 162 99 58 47 34 26 25 25 12 9 4 1 -1 -13 -66
1
2
2 ~# n- @: s' ^: C8 o下面几个算法的测试也就是换了下类名和方法名（换成相应的排序算法），如果想降序就在数组后面传个false即可。我就不一一复制了，我在最下面给出含所有算法的测试类，需要的自取即可。
, u1 Z, I' e5 ^2 B, _; N

9 }3 Q, p8 S7 o4 Q' @# V快速排序
简单解释：
快速排序就是每次找一个基点（第一个元素），然后两个哨兵，一个从最前面往后走，一个从最后面往前面走，如果后面那个哨兵找到了一个比基点大的数停下来，前面那个哨兵找到比基点大的数停下来，然后交换两个哨兵找到的数，如果找不到最后两个哨兵就会碰到一起就结束，最后交换基点和哨兵相遇的地方的元素，然后就将一个序列分为比基点小的一部分和比基点大的一部分，然后递归左半部分和右半部分，最后的结果就是有序的了。
4 ^+ c% E8 M. o  y
8 L- S1 O% I, H& O

7 }* C$ O$ ]  Y  [% M


4 ]# x  H1 z/ C  R& T* w3 R' @5 t0 l, K. K完整代码：
* N- W, x/ d" L3 M5 R+ o

package com.keafmd.Sequence;
. F1 a( b# S' ^) ]  Z5 _
0 g4 E7 F; }1 w; a  `; F
+ w6 q4 }' c: X' h1 L# x/**
1 w, _" [2 A) {- f" m! | * Keafmd
*
* @ClassName: QuickSort
! S: X' E% Q- d8 n * @Description: 快速排序
+ a- _/ n( ~. p! G. H! t * @author: 牛哄哄的柯南
* @date: 2021-06-24 10:32
*/
public class QuickSort {
  f7 M& k. W: n
/ \. D* K6 p6 V4 J! w7 F) Z
    //快速排序
3 D" S* n+ e4 B, |. W& }    public static void quickSort(int[] arr) {
' ]7 N3 s' V9 ^        quickSort(arr, true);
& E6 E* H6 T( i/ W    }

+ I+ H2 V' ~" K7 d) z. e
    public static void quickSort(int[] arr, boolean ascending) {
$ q' r- A3 Y: [: v- }2 D" `        if (ascending) {
            quickSort(arr, 0, arr.length - 1, true);
        } else {
            quickSort(arr, 0, arr.length - 1, false);
        }
9 Q0 [8 @* F. J    }
0 ?) {3 b3 f8 Y  L1 r' G" D
6 n! H, S- o2 w2 F+ N
    public static void quickSort(int[] arr, int begin, int end, boolean ascending) {
6 I( z& u( ^: L5 T' T4 i        if (ascending)
( J1 ?" i* Z" v# i7 {! {1 Y% b            quickSort(arr, begin, end);
        else
            quickSortDescending(arr, begin, end);
. r/ l7 `& a$ m$ T8 t    }
/ V2 l5 N8 z5 z" u
/ b( F& r/ m2 A1 ]2 _( }9 w% [: c9 j( W
* F* Q, u/ k( x# b    //快排序升序 -- 默认
9 S5 u# \* f+ @- @2 z& d    public static void quickSort(int[] arr, int begin, int end) {
2 ^; J9 s. `/ X9 e        if (begin > end) { //结束条件
" {6 F# l# F6 M* Y            return;
        }
3 A$ z  r% m5 ~0 Y9 w0 r. |        int base = arr[begin];
& d6 f  [+ Z$ H- n        int i = begin, j = end;
# m& H9 d+ v3 H6 D$ ~6 l8 T        while (i < j) { // 两个哨兵（i左边，j右边）没有相遇
# ^# S1 k& Q0 J            while (arr[j] >= base && i < j) { //哨兵j没找到比base小的
. c, I- U% h; R( S) l  n                j--;
            }
' T: w, [8 J9 U+ @; ~1 d% P            while (arr <= base && i < j) { //哨兵i没找到比base大的
                i++;
            }
            if (i < j) { //如果满足条件则交换
                int temp = arr;
                arr = arr[j];
8 e* j+ n; D7 I3 k2 w5 q% X                arr[j] = temp;
: E0 ?0 w% V6 w0 J( s            }

4 m6 R% Y7 v4 z- X+ r! c4 B3 @
( O: F; w+ _5 j% U4 p        }
        //最后将基准为与i和j相等位置的数字交换
# a% y0 O' O, e1 P        arr[begin] = arr;
        arr = base;
# l; I+ i: Z; m        quickSort(arr, begin, i - 1); //递归调用左半数组
, c2 e/ k( H# Z' Y$ g        quickSort(arr, i + 1, end); //递归调用右半数组

) N$ H" e4 Z8 I, p' `( ~9 v4 s% N* q
    }
* L* w% ]( ^: P( j( J; J# h; `
9 {* x, N9 g* T4 s$ t* x
    //快排序降序
" l9 E% _3 t- ]/ |) M# I    public static void quickSortDescending(int[] arr, int begin, int end) {
        if (begin > end) { //结束条件
            return;
$ n  `  C: @! I& F) F        }
" I2 z/ v+ q, ]        int base = arr[begin];
& ?7 |. u2 v. ?( r7 Y' q4 O+ H: r6 q# R        int i = begin, j = end;
" n7 l$ w! Y  x- Q$ g: B/ m% d7 V9 o        while (i < j) { // 两个哨兵（i左边，j右边）没有相遇
$ h) T7 W9 p3 c2 ~  ?: E            while (arr[j] <= base && i < j) { //哨兵j没找到比base大的
                j--;
            }
: n/ t( ~/ Z3 C& {: C            while (arr >= base && i < j) { //哨兵i没找到比base小的
$ {" G, R! m+ R1 z! T                i++;
: R: R0 n8 }2 {/ \  V            }
            if (i < j) { //如果满足条件则交换
( s0 y8 U2 Z2 s- V/ p                int temp = arr;
1 S, }6 h3 s2 \! \- g) X                arr = arr[j];
8 Q# ~+ x; `, Q$ X                arr[j] = temp;
            }


1 y+ b9 G, o& [, U2 t        }
        //最后将基准为与i和j相等位置的数字交换
: V2 A% ]* \; S) F8 j6 j) ~5 |: ^        arr[begin] = arr;
- _5 U" J, x3 a  d+ s1 }% H        arr = base;
        quickSortDescending(arr, begin, i - 1); //递归调用左半数组
8 t8 N8 [$ |0 ?' d7 }) R        quickSortDescending(arr, i + 1, end); //递归调用右半数组
' d" m3 j1 E4 r0 v) p* X
3 g$ T( Q) u4 T, e/ Q+ w7 V
    }
# [  Z+ o# i, @$ w& j2 Z
: g5 |- G3 }5 r, V4 e
}
- b  H5 F1 W  b3 P: W1
3 G2 Q& G" i, \2
3
3 L& X, z! U7 [* c; B$ \4
  M9 {" M; s8 |* m, \: l5
6
% o2 D' V5 j, \0 z7
8
9
% |) m% d! b* c. _8 c& v/ v9 Y10
6 E. ?* G3 N+ i4 {- n! x/ p7 [; m6 n11
9 m  P0 @0 c; w" e. w' I12
6 V. w" k  f/ c13
# p' ]4 Y8 @, T14
+ K3 R9 Q  B5 @0 r6 `15
16
17
' N% t5 O1 y* Z! r18
' t4 v1 ]& p. n3 S19
20
' `4 S  S) Q& T+ D9 R4 A* I2 A21
! z* u/ Z# y2 O% H1 w5 L1 A; H22
23
1 ?7 N0 R7 W/ E$ i# y* N6 I9 }4 D, L24
25
% U0 ?0 K* F. w. j' G* o% `26
& B' `" J( v2 T27
28
6 j1 l9 u# \% S: @29
# L5 \0 D6 \6 B; T30
! p. w9 b; Q% F. s# |, u. n31
32
33
& @+ j2 X6 g* F0 ~; ]4 [( P! I) \6 j34
35
36
. _" w+ P* M  u2 z& h37
38
39
6 N5 d- I+ s% R/ j) q' Y. ^40
41
42
43
44
% w: S; I( y" m2 _9 @. E$ h( z- ^" x45
9 Q" ^9 Y& m' y46
9 @* a, ~8 \& W/ g2 K( r47
) Y! e+ `% G1 b/ g  W- A48
9 A0 S% V; C- o' C49
50
51
; ~& Q9 f6 d( n/ B, f52
* b! Q/ V) a7 _6 O7 ^" a) Z! V( N5 [53
5 Z, ]3 y3 r  v0 ]$ k54
55
56
5 i+ b' Y) e! V# i2 Y0 N( l$ T. ~5 Y57
58
6 M1 a/ ]" w$ k) q59
+ F( Y$ _# D" ^; F1 x# r60
8 b9 k. a& c7 s4 f61
62
: A8 b3 K3 F+ V: p1 j, Y, L9 S# F63
64
65
66
8 k* ~, [# n% F1 m% [0 w67
68
$ r2 u% o; R) Q0 g9 O9 T' U/ @69
70
71
8 i9 f$ q# B; W) D8 X( y- O6 F72
73
74
$ n$ v  Q) I, I" h' h8 ~75
1 @$ U6 s4 R7 z* X76
( v+ o* V" f5 I  c! Q. F77
, L6 T0 M! ^4 V# E  y3 }78
79
9 A$ ~0 _; x8 g9 J, E5 \80
5 P, \5 n% |+ C2 H/ h! Q; [81
82
83
+ `, m; U4 E4 b! a8 w1 u84
) J6 }% n+ K! `85
86
87
88
; u, A- a5 W$ h5 q89
90
91
. G! \5 p4 d6 q( h6 H) ?* S直接选择排序
9 ]; x. z( b. k# S! u9 w简单解释：
数组分为已排序部分（前面）和待排序序列（后面）
$ L* T2 w; A; s+ ?) L7 q第一次肯定所有的数都是待排序的
从待排序的序列中找到最大或最小的那个元素，放到前面的已排序部分，然后一直找，不断缩小待排序的范围，直到所有的数都是已排序的了
+ |* ~- N- A0 v1 G


! t& ^# D" U' r
2 H# _- A, C0 H: m  N" f

完整代码：


0 w! G( B) u+ ~4 G+ C: d3 g7 q: E# npackage com.keafmd.Sequence;


/**
% _' s: C" P3 M( d7 I * Keafmd
*
* @ClassName: SelectSort
* @Description: 选择排序
5 n' J( _0 Y8 T/ [6 ?' D * @author: 牛哄哄的柯南
* @date: 2021-06-24 10:33
*/
" f* a( G0 R0 ^2 |( h2 U7 t/ Gpublic class SelectSort {
& @) s* o" v0 P" W4 l
1 v+ L- O8 |$ E0 T- r, [1 e0 {1 w
    //直接选择排序
, h2 K. i$ H7 h7 i2 j+ U    public static void selectSort(int[] arr, boolean ascending) {
        for (int i = 0; i < arr.length; i++) {
            int m = i; //最小值或最小值的下标
5 [  Q2 k" r0 c* b+ s, W1 n            for (int j = i + 1; j < arr.length; j++) {
                if (ascending ? arr[j] < arr[m] : arr[j] > arr[m]) {
  J$ Y- m0 ~- V! I" b                    m = j; //找到待排序的数中最小或最大的那个数，记录下标
                }
+ E2 L" G" _. S( d5 G

- H/ I. _7 ]1 e+ [            }
* J( _% U0 w! B            //交换位置
4 s  a1 s+ s1 `3 }/ t' D6 u3 E            int temp = arr;
) Q# I. w& Q( z5 ^+ M  X' ~% n            arr = arr[m];
            arr[m] = temp;
9 X6 O4 G: \4 K- m$ c5 v# V' t/ Z  A

+ H# `, e) ]: y        }
0 [/ x2 E1 Z, K- u; G0 s6 I    }


" T9 B( i2 S5 g    public static void selectSort(int[] arr) {
        selectSort(arr, true);
% s  E/ u2 p7 b1 X; C, M& h    }
" J9 h: k8 K3 `! y6 @0 z}
1
2
$ ^" E! `# m% ^* R3 w( t$ f  ?* z* q3
9 Q& s( p5 b8 U3 L3 H3 G, J+ P4
5
6
. S, `+ r9 J6 L% v0 o7
) s$ _( n0 M6 P8
9
10
3 e# k2 y+ A% ?7 N/ y11
12
) ]5 s2 k4 v) b1 x2 a# J, x13
6 v% y, K! o6 C; W9 _9 w14
2 d2 S/ ~0 S5 v# n( R: C, }15
16
17
1 u4 J$ _1 X; a9 z18
/ t9 `4 N1 n* b+ Q# i7 g' y19
20
21
22
23
" c8 i3 {6 m/ A24
25
26
6 F1 E+ \- i5 i* `# D) M27
28
29
* t& G4 ~7 h# ]30
" h9 T0 p8 D6 X/ o31
32
33
34
6 ^" \7 C: ^$ L: x' J& T7 q8 v堆排序
$ D2 q/ {4 N' h3 f/ }5 a) F( @先理解下大顶堆和小顶堆，看图
- n! J1 t$ D# `& w! x4 f: h大顶堆，双亲结点的值比每一个孩子结点的值都要大。根结点值最大
  V$ n! b: T' M/ i小顶堆，双亲结点的值比每一个孩子结点的值都要小。根结点值最小

; O0 w3 ^- v  q# ^

3 V8 v: X0 {  z( R# I
简单解释：
0 @! A5 s/ @( n8 I, O9 \构建好大顶堆或小顶堆结构，这样最上面的就是最大值或最小值，那么我们取出堆顶元素，然后重新构建结构，一直取，一直重新构建，那么最后达到排序的效果了。

' A5 A& t: ^# a; |6 F/ b1 }! y


; W5 B+ W) {0 R9 t4 k: u

' i  I# N0 E8 _完整代码：


$ X- [4 \& j2 ^- spackage com.keafmd.Sequence;


5 P) b6 H8 B+ I0 L+ F8 v( Z+ V) `4 [2 J* H0 n/**
* Keafmd
*
: ?7 N# H' `$ C2 N1 e  k0 I$ ^ * @ClassName: HeapSort
! m/ F, [, q9 Y/ D" s * @Description: 堆排序
! _' ~* n! E! A$ u: [, y * @author: 牛哄哄的柯南
* @date: 2021-06-24 10:34
3 H2 _; p, U6 E+ G' G# m0 b */
& n+ V% w7 r7 H" T" wpublic class HeapSort {


( b& }! F5 z/ a/ C% F0 D* m- Z/ H0 ~    //堆排序
% d  k% T8 T! z0 S7 D; F# A7 |    public static void heapSort(int[] arr) {
9 E" d0 J4 f. d" [3 K- K' n1 I        //对传入的数组进行建立堆，这里默认建立大顶堆，进行升序排列
9 i# `+ l9 T* ^$ g/ M& ]; l, n        heapSort(arr, true);
5 ?0 q# n8 x8 p; \  a9 z    }
7 I" G- ?# L, F0 W
* `* E2 `1 u" P9 ?
    public static void heapSort(int[] arr, boolean maxheap) {


        //1.构建大顶堆
: |, F: I' `; l4 c        for (int i = arr.length / 2 - 1; i >= 0; i--) {
            //从第一个非叶子结点从下至上，从右至左调整结构
            sift(arr, i, arr.length , maxheap);
        }
7 J" T3 a0 c  M. p, v& N2 X6 ]+ E

9 B3 p6 H/ e  V$ x# E6 e4 n& ^        //2.调整堆结构+交换堆顶元素与末尾元素
" V# J$ x$ K$ w6 g        for (int j = arr.length - 1; j > 0; j--) {
, L) B" H5 w- `' v. [5 c9 T
9 q( @$ z2 ?7 {; m. L. ^2 p
            //现在的数组第一个就是根结点，最小值所在，进行交换，把它放到最右边
            int temp = arr[j];
            arr[j] = arr[0];
            arr[0] = temp;


- K! o. o! j. Z# j% G( h' l; p" C( G            //重新建立堆
5 @+ v  p% u5 D2 v            sift(arr, 0, j , maxheap); //重新对堆进行调整
3 y3 g6 [) {0 T7 `/ q* E        }
    }

. Z" x) M2 _* x' C+ X
    //建立堆的方法
; P: U( i3 x# L) S( \& k" h* A2 S    /**
     * 私有方法，只允许被堆排序调用
4 V& \) D, |+ M; ^5 e     *
     * @param arr     要排序数组
     * @param parent  当前的双亲节点
     * @param len     数组长度
0 D0 s: i4 b) h8 U: y     * @param maxheap 是否建立大顶堆
) K- c: H+ j2 Q  G     */
    private static void sift(int[] arr, int parent, int len, boolean maxheap) {


        int value = arr[parent]; //先取出当前元素i


        for (int child = 2 * parent + 1; child < len; child = child * 2 + 1) { //从parent结点的左子结点开始，也就是2*parent+1处开始


2 W" K# w$ E: _; N5 s9 v            if (child+1 < len && (maxheap ? arr[child] < arr[child + 1] : arr[child] > arr[child + 1])) { //如果左子结点小于右子结点，child指向右子结点
' H, X' ~2 A# H! ?                child++; //右孩子如果比左孩子大，我们就将现在的孩子换到右孩子
            }

. ~. U0 s# R- m1 ^* O* q$ I
0 [) K' O) `& I$ o            //判断是否符合大顶堆的特性， 如果右孩子大于双亲，自然左孩子也大于双亲，符合
1 ?1 Y: }* b- A5 E/ o            //如果子节点大于父节点，将子节点值赋给父节点（不用进行交换)
% D4 s" C, D% ~            if (maxheap ? value < arr[child] : value > arr[child]) {
) |0 C# I/ r. [8 ^' K                arr[parent]=arr[child];
! e, c, c7 m! e$ |7 t! s                parent = child;
            }
9 E  v" G9 ~$ P. [% }3 H            else {//如果不是，说明已经符合我们的要求了。
! Z6 m3 D9 Y, x  q                break;
6 I0 \) p, F/ [2 V$ e1 n; x            }
        }
9 W1 B+ A0 \( R) A: m; R3 F        arr[parent] =value; //将value值放到最终的位置

% o: r9 M, h* ?# H0 I


. Z. r# T# N( R+ ?    }

' P0 _1 I( W# T* [( Z+ S% m# X- a
}
1
1 @7 z/ z% |5 g$ h2
3
4
5
2 G/ J. B) F8 B- ?' k0 y- k6
7
8
9
10
2 t" K) b4 Q# U4 |, u' F11
12
13
# K3 Y1 E6 ?! q" R- A+ u14
15
16
17
18
19
7 b2 B1 R! [  \# A20
$ d5 \! r* I7 }  q4 s& V21
22
23
24
$ v; G$ F( u: @( Y! X! C' b* R25
26
0 ?& B# J8 t- H2 Z. `$ s8 y+ {27
28
3 e1 s  }9 S4 H2 j4 N5 ~- D0 P29
30
31
, B8 P# L+ t) B; T' a! W32
- C, y2 ^0 T1 N' r1 ?! K9 \33
34
35
36
) b  f- t6 v$ `2 S& K4 C2 S37
38
39
: ?' b0 z) r5 G# y6 b, Q. b40
+ G) o8 }0 a, E% I% ^; `. b& s41
# w8 H! D0 ?' V7 Q& Y; @42
6 W9 u* z" y7 Y: F' v' b43
% C( ]8 ]# f! n) B- v$ |44
45
46
47
48
49
) ~, [. m  q) N* Z" x5 H50
51
1 c/ p3 l/ S' ^3 l, y7 X" E$ T4 H52
6 {5 x; h$ W8 _( O$ F6 X5 v53
54
55
$ U( e* n# j; z0 P+ G" c8 L56
& @7 X2 |- w3 R% @6 x+ l6 C57
58
59
! ^& q' e" w; s- v. R' J6 Q60
61
62
! c+ n6 C. j; C63
64
% b7 V( d! @3 U# Z65
66
67
68
69
# O( B! l! ~: Y+ {) j70
' V! q/ L3 F- ~# |& A6 o71
5 l  C* z; J2 d) o( A# \$ z* }72
73
74
; N, i, n8 ]/ M  o9 d4 W' _归并排序
5 L1 _& u! ^3 N简单解释：
7 h! a/ A: b: V. j该算法是采用分治法，把数组不断分割，直至成为单个元素，然后比较再合并（合并的过程就是两部分分别从头开始比较，取出最小或最大元素的放到新的区域内，继续取两部分中最大或最小的元素，直到这两部分合并完，最后所有的都合并完，最后形成完整的有序序列）



) b0 j: F' V1 W9 h! H

% A5 Z0 p$ I. [# L
5 _( y5 Z+ ~, m- @+ v7 K1 {完整代码：
& G! i9 _9 a; f8 u( z0 a

* i: [! A2 Q3 V/ o" jpackage com.keafmd.Sequence;


6 e! E. T' Y$ q6 {/ E8 ~/ D/**
3 ~; w" b, c1 g" w( G  L6 p! D. C * Keafmd
! ?  k- S/ J' H8 Y& {& e& t *
* @ClassName: MergeSort
4 Z  A; h: g# ?: _. i * @Description: 归并排序
* @author: 牛哄哄的柯南
* @date: 2021-06-24 10:35
; E5 H6 J, F" ^! V# @. N, f. K */
1 x* C4 Y, n/ }public class MergeSort {

/ f- ~, k! ~  |. L
    //归并排序
    public static void mergeSort(int []arr ,boolean ascending){
8 @& Z/ H* ^* @( I( v( a        int[] temp = new int[arr.length]; //在排序前，先建好一个长度等于原数组长度的临时数组，避免递归中频繁开辟空间
        mergeSort(arr,0,arr.length-1,temp,ascending);
! }5 ], Y) T1 K$ W# T    }
    public static void mergeSort(int []arr){
        mergeSort(arr,true);
    }


" z# f, y3 g; m; f. G    /**
     *
* |2 A3 f  \+ B. z     * @param arr 传入的数组
     * @param left 当前子数组的起始下标
     * @param right 当前子数组的结束下标
     * @param temp 拷贝暂存数组
: C, ?- |# \3 B5 s# I! z: s7 j     */
' ?9 h) _2 g2 v: s. g' w. J    public static void mergeSort(int []arr,int left,int right,int[] temp,boolean ascending){
2 j! a8 t: V7 t" c# c        if(left<right){ //这里是递归结束的条件，我们是对半分，那当left==right的时候肯定大家都是只有一个元素了。


$ B+ h6 D' O$ S1 |0 r+ G            //对半分，比如总长度是10，left=0，right=9，mid=4确实是中间分了，0~4，5~9
5 R1 G( t- c. q( Y            //当长度9，left=0，right=8，mid=4，0~4，5~8
            int mid = left + (right-left)/2; // 防止越界的写法
            //int mid = (left+right)/2;


3 I4 g7 _2 @" }& }) p: E            mergeSort(arr,left,mid,temp,ascending); //左边归并排序，使得左子序列有序
5 o; @; v( T  R' _/ D. h            mergeSort(arr,mid+1,right,temp,ascending); //右边归并排序，使得右子序列有序

# T4 {- N" v- ~4 P" p1 [( l
. \0 \6 c5 V& `% q5 r/ H            merge(arr,left,mid,right,temp,ascending); //将两个有序子数组合并操作
        }
6 `* W1 p; `; H' F    }
! g0 F! ?* Y9 G) C: U! V0 I
* I0 F) ^( U7 [
    private static void merge(int[] arr,int left,int mid,int right,int[] temp,boolean ascending){
        int i = left; //左序列起始下标
        int j = mid+1; //右序列起始下标
" t1 w4 A: [% @7 {        int t = 0; //临时数组指针
' m$ e. ?$ y  \  }0 ^  i+ j        while(i<=mid&&j<=right){
            if(ascending?arr<arr[j]:arr>arr[j]){ //比较两个序列第一个元素谁小，谁小先拷贝谁到temp，然后对应子序列下标加1
                temp[t++] = arr[i++];
            }else {
$ e' P2 l1 B( J# l% W4 J3 T                temp[t++] = arr[j++];
$ e- I" H2 ?" P1 k+ X& N            }
        }

9 a6 e& R& Y7 F& Q1 h. R1 J- E) K! U
& t9 N& q6 X5 H& u        while(i<=mid){ //将左边剩余元素填充进temp中——左序列有一些数总是比右边的大的数
7 K5 n' R3 n; H* V6 E4 u; o: f            temp[t++] = arr[i++];
1 a" B: b, W5 x& S        }
# W" z4 v3 c: q* E' Q
" o7 O! }5 @) g( ]! o( V+ k
7 u5 W. t2 i2 V0 d; Z6 q$ o        while(j<=right){ //将右序列剩余元素填充进temp中——右序列有一些数总是比左边的大的数
            temp[t++] = arr[j++];
        }
, \0 `$ U3 |8 w

        t = 0;
% L. ^+ y( L& U; ?

( L7 _- A+ W/ E        //将temp中的元素全部拷贝到原数组中
! r' Y+ I& t3 x        while(left<=right){
            arr[left++] = temp[t++];
        }

! X( f- z* z0 @0 ^& m
( Q0 t( A0 @# F- W2 L# Y5 x    }


}
6 z# t$ U0 d: e+ O8 m( |2 R1
. _- F# Z& G& h  ~$ l2
) a; ^- l5 \! {# Y( C( J  S" y3
5 {* W6 |! g' A0 K4
, v$ |% }5 [% S5
6
7
( Q. G) ~0 j  l1 M; h9 a( G0 k8
9
10
: v! k0 h% r* k! b- d1 T11
# O) S" Z9 q) ]! T7 H12
13
14
  C) T" f  c1 m# W$ Q7 F# G: g15
16
- _, v) f$ Q6 D6 y17
1 y2 L8 U! b- ~$ i18
19
/ K. c3 b; ^7 T20
  V: m! F; w7 f0 x21
- \7 b/ b" G0 W' d* f! c22
* u1 y% a7 ]/ s% b4 m1 Y# ]% E23
24
+ T1 Q- P8 d! k, `# L1 H4 Z25
1 v, J! `: w6 a26
; u9 z8 b9 M, o9 k9 e; Z: \27
/ _9 |, [  g' q28
0 M; P" z7 a9 s/ X29
30
31
* R2 K! v0 ]% e0 c. V32
33
4 y: g; @# w  }34
35
2 @& D- N% f  p36
! H( }- v0 I/ m2 ~: [37
7 ]: V% U  |5 J38
39
2 f6 _0 t! Y- s9 [! p6 V! `3 B40
# D: N2 u* P- Y( R- u9 Z+ i41
5 s$ J' ~3 F2 k2 ?6 [42
' I) ~3 v* q$ P% N43
44
$ `$ M6 A; R) v% g5 Y) `* ?45
46
47
8 I5 }9 b8 Q! q8 P4 T1 G48
5 T; j- |/ ^2 b6 h! P* Y: R8 I) s2 R49
50
51
52
$ P5 [# u  @" T$ B( d4 m53
54
55
$ C/ ^1 k+ W7 E/ X7 l56
57
58
59
/ N" B* H2 t5 i0 _6 R) `60
61
62
5 i6 W& r) }- X% a: z% @5 r63
' W6 Z! x9 e. S6 G9 {& ^64
65
66
2 h/ n5 m! Z; O0 [. o# X6 S67
' y4 \6 ^; x, b9 ]( O; Q+ f68
69
70
71
: X8 A7 U2 p! F$ l, c8 d* f" i) H72
73
插入排序
简单解释：
' p; x  k% n, U+ M最简单的理解就是打地主时我们拿到牌后的整理过程，从第二个牌（假设我们拿起来这个牌开始比较）开始，（说下升序）从后往前比较如果比前面的那个牌小，就把牌往后移动，直到找到一个合适的位置（这个位置的前面的那个牌不比这个要放下的牌大）就把这个牌放到这个位置，慢慢的前面的部分变得有序，直至全部有序即可。
" Z8 v- |' {' e% e1 `
( v6 i, R8 u, j/ ?, Q4 D
$ w( F9 ~# x1 {% f1 S. y& u
7 a  y( v, k$ _) |! T
) E# G; U/ d8 e% o1 J* l' ~

1 B* Z0 l. B" ?% J4 ~4 q完整代码：
0 y$ K' j, n- u2 b4 C

4 [' `' W, |9 upackage com.keafmd.Sequence;


0 J# V! y  @% V9 d6 ]/**
* Keafmd
*
/ h, p" D' l8 n6 v * @ClassName: StraghtInsertSort
* @Description: 插入排序
  S- e! v. V$ _" N' n * @author: 牛哄哄的柯南
7 ?3 q- F: c9 D * @date: 2021-06-24 10:36
*/
3 g' \/ E3 l  upublic class StraghtInsertSort {
    //插入排序
9 ]6 T1 ]; f1 [  K" _; y6 Z& V    public static void straghtInsertSort(int[] arr) {
        straghtInsertSort(arr, true);//默认进行升序
    }
$ ~$ [% [: R# p+ S

4 P& n2 H; W9 r* @& |/ x0 A    public static void straghtInsertSort(int[] arr, boolean ascending) {


7 u" Z& j* \: d% S% u        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--) {
; k+ S3 A$ }3 o/ I5 K2 |8 _, j. i                arr[j + 1] = arr[j];
- l: X0 Z, m/ m            }
            //把牌放下，为啥是j+1，
            //是因为上面的循环遍历到不符合情况的时候 j是合适的位置的前面的那个数的位置
9 a9 n/ U  b2 u' i( P            //有点拗口，但是就是这个意思，看图方便理解下
) m% \8 @, y0 ]0 m+ j# N7 M            arr[j + 1] = temp;
/ r; M; i: ?3 @

3 A* e  D0 u; v5 n4 b2 C  h$ |
+ m. D: I6 g+ G+ p
, q' z0 {) E) U$ o8 G! n+ K! C1 z        }

% C  h, e% }) l' w, `* n
    }
5 o" a% H- v) V6 n1 ~, ]}
1
4 e$ x8 K. Y7 r" y1 C# L; s2
3
% L' o: p7 p% ~- T$ E4
5
6
7
( |' }2 T! m' I4 u# I- ?9 q8
9
10
, {6 ^& f' q) u11
12
2 d* l* [5 z3 s9 }: _13
, F5 ^+ R. X7 m  T* b! z: V& F14
' v8 X$ h! F6 r: B/ x9 `+ J15
16
: T- @* \, u" C. P8 ^# u4 g- v3 w17
- c' }5 f0 |; P) O: W8 M  v18
19
& e% f+ w5 L3 Y. E20
( h; S4 o7 g6 Y6 e/ f, O21
  ?) v/ R$ x) z0 b& E9 \4 ^% y22
, d: k4 J/ v; W5 m23
24
25
26
# p0 O; g8 y1 m$ S0 k- S27
28
2 C9 k& x9 Q# u( B  Q29
) A8 t7 s6 _, R+ ]0 A6 M30
6 o1 F# X: s  p* z+ E! L1 R( k& A31
32
& k# X6 U6 p; G  M: F  K7 E33
& j  _5 C% D8 ]( `5 p34
2 o8 o0 E0 h* ?$ m希尔排序
# N9 D7 ?7 t7 g# K, @简单解释：
希尔排序是插入排序的改进版，我们理解一个叫做下标差的的东西，也就是下面那个图中的增量d，初始下标差为arr.length/2，然后继续/2，对在同一下标差（相当于把这几个数单独拿出来了）的若干个数进行插入排序即可。


, k+ j2 m. D* A1 d; F, K! v/ \/ e% s



" [1 }! }6 m: A7 U5 }完整代码：


2 u" G! ]4 r9 @7 jpackage com.keafmd.Sequence;
# |6 a9 s8 S4 w9 ]5 [8 k. s
  w2 Z8 f4 t9 `! K
. O2 T' y6 Z+ q/**
* Keafmd
*
/ |! B7 {/ o0 J3 b * @ClassName: ShellSort
6 Y. b: g0 x5 V * @Description: 希尔排序
* @author: 牛哄哄的柯南
+ {6 g! Z0 p9 ]* T6 [- s# z! t * @date: 2021-06-24 10:39
*/
1 n5 J* l% s' N3 I1 Ipublic class ShellSort {
$ u) e3 a' x% }0 h7 k
+ `5 g4 G# a( C/ S
, Z: I, v0 t. ~4 G4 d4 U! ?$ z& a" P    public static void shellSort(int[] arr) {
2 a6 C/ G- k( n: V8 s$ ^+ f1 E        shellSort(arr,true);
    }

2 _. v  C. i" {+ y% B
    public static void shellSort(int[] arr,boolean ascending) {
9 `& K2 E; N. v1 c+ g' i
, c" x6 T! p2 f( Y5 U: w
        for(int d = arr.length/2;d>0;d/=2){
% Q  n1 [1 _; n. X8 N
6 Y& S. y+ l& K% K2 U. D. o; p
' `  y$ [- K" ^! E3 ]* M9 q            for(int i=d;i< arr.length;i++){
                int temp = arr;
. h) F  s& b1 q( d9 D                int j=0;
4 k9 h8 f# `# j: Y; G, h7 S                for(j=i-d;j>=0&&(ascending?temp<arr[j]:temp>arr[j]);j-=d){
                    arr[j+d]=arr[j];
* ^6 j' V1 t3 K" m; X- |                }
$ C1 t% T  b3 A% x$ U" x" ]" ~                arr[j+d] = temp;
+ E0 l4 E( Y; A% J2 s7 {            }
( K. w- D) ]$ a5 t& `. e        }


    }
}
1
2
3
4
7 n' ?1 {2 O3 R- j1 p; E7 t5
6
8 u8 `  O5 R0 L# u7
* Y* `' U6 e. S! e  Z: ?% E8
9
* A) i* J- J3 O10
/ |. W% R+ O3 T$ [6 N$ B4 e11
12
13
2 }3 n+ o/ D7 n2 |14
  O) u* ?' ~. l15
7 k7 v# t( X# C5 M16
5 N: ?/ k3 I) A7 ?17
18
19
" o4 C: w% b( X20
21
22
23
24
5 b8 h% I% q7 L25
26
4 p! w+ @7 o: ~0 ^/ }/ H27
28
! d$ c! q% L! s1 s29
5 t, n7 X+ J+ m5 M, G6 Z30
31
32
. m! ]3 s; l1 O计数排序
简单解释：
6 p8 V1 u$ X0 L8 m/ a4 ^这个排序算法看名字也很好理解，就是就是额外找个数组来计数，然后在这个数组从小到大或从大到小把数取出来即可。



  B' K. X1 |* I% s7 [5 P
4 M. c* ?+ R3 F( U2 s8 X: X

+ e5 b* d7 b  s' ^3 I8 n2 S完整代码：

8 S% m7 j7 B7 b8 a0 j2 t' O
+ g  E1 B. i0 l" E. Y2 Apackage com.keafmd.Sequence;
8 b  U# N4 a% D0 d! t, N4 ?8 z
" `  x4 Q1 l3 d5 H' ]
; K" {$ [6 p% j8 u/**
* Keafmd
*
* @ClassName: CountSort
* @Description: 计数排序
. P$ E' u9 I3 d8 w. d4 l  s * @author: 牛哄哄的柯南
0 L  A( u# d7 v8 e * @date: 2021-06-24 11:31
*/
4 G2 X6 u- a3 Z0 N8 S0 }# epublic class CountSort {
# l6 p) V* l9 z& r' _# Y
7 U. N- w2 ~5 c& j  j; z% A9 r2 q
' f% @% K+ l; j& T- {" `    public static void countSort(int[]arr){
        countSort(arr,true);
    }
/ G" ^( _% O. c1 b1 ?5 E( Q

    public static void countSort(int[]arr,boolean ascending){
  K, H' J. T/ Z1 w  }4 E        int d,min=arr[0],max=arr[0];


        //找出最大、最小值
% N, u) z+ t) ?4 {4 S        for(int i=0;i< arr.length;i++){
8 ~( d) R8 f5 F; v            if(arr<min){
/ d7 Q( q: x  ?. h$ ]( s( a  ]8 j* j# b: k                min =arr;
/ S+ s$ i1 y+ q4 z2 W            }
1 y- I- {1 D0 ]1 d: e. S5 z            if(arr>max){
                max = arr;
, m- @1 E7 F4 M1 B            }
& i! u3 [0 M' i& \- W8 o6 M        }


# J# N% M6 @+ p- }: g( f8 H        //建立一个用于计数的数组
8 G+ x7 u  ]# G        d = min;
5 I% W/ K( E0 a        int[] count_map = new int[max-min+1];
$ w( n" {$ E+ L' Q        for(int i=0;i< arr.length;i++){
( K. |9 p5 r/ f            count_map[arr-d]++;
        }


* a( N( C( X0 u( V        int k =0;
) H& B6 j% p) U; W7 E  ~  U        if(ascending){
            for(int i=0;i< arr.length;){
                if(count_map[k]>0){
                    arr = k+d;
" t5 X# w2 N  @8 D                    i++;
6 r" w% B1 Q$ t0 i" v" _' j                    count_map[k]--;
                }else
                    k++;
            }
        }else {
            for(int i=arr.length-1;i>=0;){
3 M: y0 f9 J; `; U, f$ S4 I8 W                if(count_map[k]>0){
, ~! x- b6 L+ p1 G6 c: w                    arr = k+d;
                    i--;
                    count_map[k]--;
1 G3 q6 N  Y- q$ g* J, `6 H( C( n' n                }else
3 X  H1 Q$ U* x7 Z8 f/ ^2 f6 T4 z                    k++;
            }
        }

8 ?. V' z. p) a8 ]* G0 v
    }
}
/ R7 }. A( \* ~) y+ X1
2
1 x7 H! G- b* B: `! }! X& Z3
3 ~8 V2 B( f3 m7 f! a4
; K% x8 R7 }( r0 I! O8 v0 q5
6
1 Z( k. s: F8 z& V& q+ Q7
- k  [4 h, p' y1 f8
9
10
3 o# P6 T( J8 r8 P6 {( `3 r1 w0 V11
12
$ }& T! x% p& o3 s/ g( b13
0 r' l) G- b/ X* O14
% G5 R$ {: i* k6 U' F6 _15
16
17
18
19
20
21
22
23
24
25
. [4 }5 g0 J8 F/ i6 c+ w1 a! x8 t26
; a1 _! ~5 ?+ H27
28
# H, i# e1 e; u: j: A3 z  d29
30
1 B' X  F9 {3 x* X0 p" T% l$ B31
32
33
34
) g( T- w0 [9 E. x$ s35
8 s' x( z3 d0 B" o. N; \2 i36
37
38
39
6 }6 g8 ?  F' H2 P40
41
" [9 s$ g: o( b! Z! c9 J# Y42
43
+ b% Z. P& m% ~* i1 \9 y$ L44
" w; r  o+ n' Q( w* E45
46
47
48
49
50
* y" D+ F0 |  c9 I% L) ^51
52
# ^$ c% Q& B6 Z! `3 ]2 d/ }53
54
6 M8 [' D4 }' O8 I  }/ M55
56
5 S6 z" ]/ N/ ?57
58
59
: F+ I/ `1 L9 r桶排序
简单解释：
; i2 m$ J2 s4 _. \  w; Q$ T就是把一个数组分成几个桶（其实是几个区间，从小到大或从大到小的几个区间）装，然后让每个桶（区间）有序，然后取出来放一起就可以了，相当于把几个有序的段拿出来放一起，自然还是有序的，当然需要是按照区间的顺序拿了。
' w( m- {& v/ R8 m
8 }) p: G. _; ]* g/ Z4 K




, ^( |; ?% ]3 {9 X完整代码：
1 l" x6 v0 y( V# n& Y

8 x. \4 e6 F6 R1 O8 spackage com.keafmd.Sequence;


4 y) P8 J3 u  g1 H" U; i, Oimport java.util.ArrayList;
: r1 H( Q! I- O$ limport java.util.Collections;
5 H1 g+ _) m. |! y6 H
' z9 d. H" P7 M6 e  e$ d2 @/ i
! N1 [8 E9 S9 M3 _% q- ?. X  q+ v/**
5 c' T5 D& x6 g; Y. W * Keafmd
1 E/ W7 s( J3 J, Q2 c, j: g8 o *
* ]9 L6 q  F  \6 [7 \ * @ClassName: BucketSort
, B' p5 V; r5 a8 G- W. ` * @Description: 桶排序
2 u4 L, }) R- `. C7 M, b7 X. a * @author: 牛哄哄的柯南
+ c1 i0 [) F, O5 S1 e0 V0 r * @date: 2021-06-24 13:32
*/
3 `9 B0 K: `& m& G+ k; f7 tpublic class BucketSort {


    public static void bucketSort(int[] arr){
        bucketSort(arr,true);
  u9 ?+ \$ H( s* J, U4 O6 l: X7 q/ [    }
/ A; K4 x; F' x( Q6 k( S$ v) L

, E; G% e. c- _+ u5 ~1 ~    public static void bucketSort(int[] arr,boolean ascending){
& a( v  Z5 |% Z& Q5 {        if(arr==null||arr.length==0){
( `  Y- R8 z4 g/ Z: W            return;
% q. o  D+ q, d3 o" R- a        }
        //计算最大值与最小值
7 q8 c/ Z# C! r2 \3 i9 R        int max = Integer.MIN_VALUE;
: X5 `" q" V" A. }8 G2 }1 ~( ~1 S        int min = Integer.MAX_VALUE;
) S8 W% P  I2 _: Q1 ^" r        for(int i=0;i<arr.length;i++){
            max = Math.max(arr,max);
            min = Math.min(arr,min);
' G1 b; b1 r% \1 R2 B9 s        }

* R; _* c: S4 W" G! F( c
0 t& j, H* e; {9 _1 s- S  V        //计算桶的数量
        int bucketNUm = (max-min)/ arr.length+1;
0 `$ n9 M: V# q+ [        ArrayList<ArrayList<Integer>> bucketArr = new ArrayList<>(bucketNUm);
& K& U6 A8 O- \4 B& M+ W5 W" y/ }8 `        for(int i=0;i<bucketNUm;i++){
6 t3 |3 a+ p' ~            bucketArr.add(new ArrayList<>());
        }

1 p- O1 C3 b! A+ v& _2 p! G
$ M8 R, t: z3 ^6 {        //将每个元素放入桶中
        for(int i=0;i<arr.length;i++){
            int num = (arr-min)/ (arr.length);
# p$ x; ^' v5 A6 z5 m5 A2 Q            bucketArr.get(num).add(arr);
        }
" [0 h& @/ l& q( C6 O
# m! r$ l) [  r+ F) N/ N) t6 L
0 v! d- c6 b% q% f+ a- F# A: _2 i        //对每个桶进行排序
        for (int i = 0; i < bucketArr.size(); i++) {
  A% J1 J1 ~# c6 z- n            //用系统的排序，速度肯定没话说
+ v" B; Y# S1 m! O; v5 Z            Collections.sort(bucketArr.get(i));
& R. m* f+ L; M, `1 o5 L% t! ?        }


        //将桶中元素赋值到原序列
  F4 J' F& D% h* G: e* d8 s- K( F        int index;
        if(ascending){
            index=0;
        }else{
/ a# J: A! i- b. n            index=arr.length-1;
        }

2 k/ B! ^6 \5 B+ l8 z4 J9 K$ p: v
& H. B  `7 n/ L; \) K% W        for(int i=0;i<bucketArr.size();i++){
            for(int j= 0;j<bucketArr.get(i).size();j++){
: G5 P/ B0 E' m6 G% _4 v                arr[index] = bucketArr.get(i).get(j);
" @9 I4 H4 D, S; M5 f                if(ascending){
4 P* D7 }1 C4 U4 D8 i  ~                    index++;
                }else{
/ W1 Q7 E8 D. G' C- n" O2 m$ b' Q                    index--;
                }
            }


        }

) F7 H7 r9 V+ ^$ H2 W
2 G" x. k! \3 [4 P& B4 L, \    }
}
! m, T1 O  u* d7 A4 z1
) s5 h- e% g/ X2
- u4 q5 N4 L9 p0 i7 i- P9 Y/ r# G3
5 y* r  m% O7 X; ]4
2 U  j) A2 q3 Q( Y5
6
2 p) ]0 Z) b+ C& h: u6 k7
8
9
4 s, M2 U' g8 E- o6 s9 S10
. K3 d$ i& C3 s1 C4 J( e11
12
13
+ @3 a# G( _" \/ F14
) y% q6 ?* }2 }0 @% W' w& B15
16
17
6 F5 H7 H0 A7 i18
19
8 c7 N3 b7 h- U, j6 {20
6 }$ r, d' w# [; \1 r21
22
23
24
- L6 k' o' y6 y$ Z/ \( \: j6 ^8 J25
1 C" v: C9 B# L- R26
3 x' H1 M7 V5 Y27
: u$ {7 x. G& S1 R3 f: F28
29
6 B) D5 ?3 Y9 H- ^+ F30
31
32
33
34
35
- Z! n! Z& A: n" c" l. Z8 K; ]9 }36
" B, M- u$ g! l8 k; ^37
38
39
40
/ [5 w" T8 ?, v$ B1 T- e" `41
1 c3 Y$ N! x5 }) H$ c42
43
44
6 q4 {/ T) x! J2 f7 j- n9 O/ o' b4 I3 }4 K. t45
& O# ^8 {! w: ^3 y; g8 m1 a46
# t. T# n6 w% z$ J7 y/ z4 Q- e47
48
49
' Z7 x- d+ x- I: e3 |- s50
6 P8 @2 z- Q( x  P  a/ }51
, b! q1 e2 o8 o# A- a52
53
+ t; J* q, \, o% w) m54
' z/ ]1 U- l  _55
) @# `  N2 |3 u, K' D! F56
  _2 l- f& o- M7 m3 h6 a9 [5 h57
: _4 s+ U6 X+ l4 N& f( B- B$ D; X58
59
60
/ w# L- [3 u0 B, v/ L  Z+ c, H61
) ~4 d* f1 c- J: X4 V" v/ s. C62
63
2 w* h# ^3 d* V8 d7 a3 V4 A. [& N& U64
65
$ w) m& O0 r( y" v  o7 T66
67
4 i$ Y$ v0 F5 B0 ]8 ]. H68
69
70
: E5 L0 c# h# [* y71
72
基数排序
% z4 w$ M/ a+ \6 G简单解释：
首先说一下，我发现好多人写的基数排序只能排序正整数，其实只要处理下就可以排序含有负数的了，就是我们排序前先把所有的数整体变大（就是减上最小的负数，也就是加了），都变成正数，然后排序好之后，在减下来（加上最小的负数，也就减了）就好了。
基数排序就是按数位排序可分为LSD（从最低位[也就是个位]开始排序）和MSD（从最高位开始排序），下面写的事LSD基数排序。
基数排序就是把数按位考虑，让后我们一位数只能是[0，9]，就是我们在考虑某位（个位、百位· · ·）的时候就只看这个位的数，放到在[0，9]相应的位置，然后顺序取出，最后再按其它位这样操作（上面说了要不从低位开始到高位，要不就是从高位到低位）
6 l, G, u0 W$ k/ Z6 n& d
1 u3 a9 D/ ]6 S& o
' A; A7 f9 h& B; c" B6 q


2 Z0 A/ V. T- m, K, B
完整代码：
) {" {1 U- f5 H* H3 s. Z

package com.keafmd.Sequence;


8 C& _# q- }  p, [# u/**
* b1 _6 T) L* f# V! |0 l( e$ X * Keafmd
*
* @ClassName: RadixSort
+ x- y; X  L  B; Z * @Description: 基数排序
! ]9 n" w6 X7 @2 ^, R; v% V4 W * @author: 牛哄哄的柯南
* @date: 2021-06-24 14:32
*/
2 s6 _" U) ?: S6 y) r1 }6 D9 ]public class RadixSort {
    public static void radixSort(int[] arr){
        radixSort(arr,true);
: F4 j- C( g4 ^0 u    }
) O2 a( C7 c" i    public static void radixSort(int[]arr,boolean ascending){
& }& x' [7 n! h% [        int max = Integer.MIN_VALUE;
3 x: O" C8 `; t! ~6 A5 T        int min = Integer.MAX_VALUE;
        //求出最大值、最小值
  k0 O, _$ s. N; y        for (int i = 0; i < arr.length; i++) {
            max = Math.max(max, arr);
# x" O$ W' O- m$ P            min = Math.min(min, arr);
        }
5 I8 ]1 t6 y* Y* t, o7 N5 K        if (min<0) {        //如果最小值小于0，那么把每个数都减去最小值，这样可以保证最小的数是0
            for (int i = 0; i < arr.length; i++) {
% N3 [: Y- P3 r$ i7 Z7 x                arr -= min;
1 |2 V( k/ r0 Z            }
            max -= min; //max也要处理！
2 E! B# D4 o7 I. J3 x3 k        }
        //很巧妙求出最大的数有多少位
        int maxLength = (max+"").length();
        int[][] bucket = new int[10][arr.length]; //一个二维数组，一维代表0到9，二维存放符合数
        int[] bucketElementCount = new int[10]; // 用于记录0到9某位存在数字的个数
3 U! q% m1 e( I  H0 ^        for (int i = 0 ,n = 1 ; i < maxLength ; i++,n*=10) { //个位 十位 百位 这样遍历
            for (int j = 0; j < arr.length ; j++) {
2 z. _( E) w, ]                int value = arr[j]/n % 10;
                bucket[value][bucketElementCount[value]] = arr[j];
                bucketElementCount[value]++;
0 S3 g( C( i! H2 r            }
5 H. }! z0 O# ~: I

            //升序
            if(ascending) {
                int index = 0;
                //从左到右，从下到上取出每个数
                for (int j = 0; j < bucketElementCount.length; j++) {
                    if (bucketElementCount[j] != 0) {
6 I) Q  P6 T* |% K* Y                        for (int k = 0; k < bucketElementCount[j]; k++) {
  k0 e( n3 ^6 o! F6 X                            arr[index] = bucket[j][k];
                            index++;
2 V3 ]* p; X+ j8 T. ~# j2 O                        }
/ Y. l' U* I; u8 u2 }4 C                    }
! L0 G  s4 t7 M# {                    bucketElementCount[j] = 0;
                }
            }else { // 降序
                int index=0;
                //从右到左，从下到上取出每个数
  G8 A9 r; _/ q! {: S                for (int j = bucketElementCount.length-1; j >=0; j--) {
8 C$ r4 C8 c& s! P, y7 j, O                    if (bucketElementCount[j] != 0) {
+ F& W0 A4 J( L3 v; d- k                        for (int k = 0; k <bucketElementCount[j]; k++) {
4 E4 {- q5 C6 m8 ~                            arr[index] = bucket[j][k];
2 }% X2 [: \- ~                            index++;
                        }
                    }
, k" z, o$ I$ w8 y6 l, f+ B7 |                    bucketElementCount[j] = 0;
2 ]7 q/ y6 _* q5 \- q' S                }
            }


% i) d6 T( ]- i" _6 i

% e% ~3 z" V2 {4 H* {" i            /*for (int i1 = 0; i1 < arr.length; i1++) {
- W; v. w! W1 U+ U                System.out.print(arr[i1]+" ");
            }
( q2 \( k5 S7 `# K7 ^2 E            System.out.println();*/
! X& f+ C$ C. E& Y9 s" r' l# F


  U0 E  \8 a5 o+ ~& n6 [


        }
, f! C( x& c6 M0 p0 L        if (min<0){
. q3 P3 j0 K, V            for (int i = 0; i < arr.length ; i++) {
/ x8 R3 o; C+ W" q2 ~                arr += min;
            }
9 L6 ~0 ?6 I5 K! U# u        }

0 e7 S, J  v" m1 y2 U
    }
}
) d/ A- Z4 K/ A1 W+ q1
' I; d& s+ N" F# D+ r2
& g$ ~: c4 r) O" g3
5 S& X; z6 z' r, S8 M4
9 a) e3 l% i. p' u/ @5
$ e; M* T$ k7 x' G. @+ l1 `! D* E( Q6
% H& F+ m; ]' ^4 r7
  g$ V" g" g; i8
9
10
11
12
13
  ^$ z2 M# x* l3 o! `% s14
+ M) c7 B. J6 q8 _2 g' k15
: u9 B' D8 p8 y, b4 T& ?" c+ A16
17
18
. _$ `/ T/ q) p/ S! L( ~19
) F4 `4 d! |# s9 ]7 _* e20
) I; m9 A" k$ t" x1 W/ S21
  Z# e  |5 C+ m% h$ l- |22
. P6 F% o( k8 u3 f# w5 V23
24
/ q1 T% @+ ^( C; r2 S25
26
27
28
' f9 e; d9 v5 A) w) _29
7 g  b/ I6 z/ a* J' `, d7 U5 X30
31
32
33
/ @& n3 o7 e# W; c4 l34
7 ~' `$ A' y0 o, O/ _/ ]1 z35
6 r) A! L$ a2 i( p) Q4 K! F/ B. J36
37
) e9 n( n+ A& a) y, y38
2 e9 x5 y! o. X; j# s4 f39
40
! u2 ?7 M# J# ?41
; {8 k7 b  `; E& ~* Z$ L* S42
5 x8 h3 X% l- K& i- B43
44
45
: I: U/ t7 w! l46
* b( `+ ?+ Z8 C5 {" _6 \5 ]47
48
8 M7 k+ k/ o: j0 T2 b8 w49
8 _  a9 x& |6 d8 f50
51
52
53
54
6 P: X. D/ u9 i! e- v6 C55
4 i' [) H6 M% ]% c; k56
9 M% h9 ~  ]' u9 o( C  R- G6 k57
58
59
60
: p' u' r% L" u$ k" r61
62
63
' O9 X, ?. q0 |4 h" [64
! J9 x$ y- l  r/ k0 w65
" R& e, s% G% Y  g/ a66
67
68
69
- {1 T6 k; o  v70
. G" M; E( D# z; l' S6 r5 r71
72
73
74
75
76
; a) m- Q% u8 E& q77
78
79
& R# o! v7 v3 O5 z1 S& T2 P* z4 i80
$ u* @8 i0 z+ X81
82
& i4 d; X& k+ d0 d" y83
' v4 M" b. O- m7 @% m完整测试类
) r' [6 N# }2 v% Apackage com.keafmd.Sequence;
) x4 }0 m" R% @
) m  G( B2 ]% g$ E
5 F, z7 [! s( Qimport java.util.*;
import java.util.stream.IntStream;
) G" b, Y& ]2 d; x! Oimport java.util.stream.Stream;
( d# F4 Z( ?4 [5 U

' D' S0 r; y( F, ]7 h# ?/**
7 p9 y& a  o2 W/ A * Keafmd
# e* B! W2 ?, Z  R *
* @ClassName: Sort
* @Description: 十大排序算法测试类
( Z4 N9 H5 ?, O! K# B: H4 _1 h/ R! p * @author: 牛哄哄的柯南
- Y& p. n& `# f. Q( {7 M2 W7 z * @date: 2021-06-16 21:27
/ z* M* B! b" G" h */
5 Q, t4 p" q; n5 e+ Vpublic class Sort {
1 Y' [$ C5 I8 `& H, j& y
/ P1 y$ r3 O% r3 T4 G# ?2 _7 r/ e

7 }  W. c1 Q; {: F# @9 u9 X
% H9 v. g7 ~2 j# H$ F    public static void main(String[] args) {

0 j3 N$ f6 H" W" o
# j6 l/ r3 c# d3 L) I) P        int[] nums = {12, 4, 25, 47, 58, 34, 25, 9, 99, 26, 1, -13, 162, 10093, -66, -1};
# W0 [! q$ D$ Z! P//        int[] nums = {12, 43,56,42,26,11};
% n0 e5 g. ]9 b% @% M& n        int[] temparr;

% Z. D& e5 P. l. ~" R$ C
        //利用系统Collections.sort方法进行对比
7 M1 T0 N* p1 H7 m
; J  x# D9 J( w, _5 ]4 n
        //将int数组转换为Integer数组
        //1、先将int数组转换为数值流
" x. f/ }) y8 a& v# ?        temparr = nums.clone();
4 k7 ]) `9 H  a: r* f$ ?: a8 R: F9 u        IntStream stream = Arrays.stream(temparr);
        //2、流中的元素全部装箱，转换为流 ---->int转为Integer
" O( {+ h$ K! u        Stream<Integer> integerStream = stream.boxed();
' T. }2 |3 h% v1 O        //3、将流转换为数组
$ `# G6 ~5 N1 ~0 I0 G$ A; n        Integer[] integers = integerStream.toArray(Integer[]::new);
' g1 {, {4 D  h0 E" O0 }- k8 P; |- R        //把数组转为List
        List<Integer> tempList = new ArrayList<>(Arrays.asList(integers));
        //使用Collections.sort()排序
        System.out.println("使用系统的Collections.sort()的对比:");


, o7 Q& r9 _2 A! ]3 D) ~4 ]3 |        //Collections.sort
, \- ?6 i$ t2 n! [2 o9 @4 Z) |" d        Collections.sort(tempList, new Comparator<Integer>() {
            @Override
% ^  T& e5 K& z            public int compare(Integer o1, Integer o2) {
                return o1-o2;
1 l) G% H- R$ Y  |- z8 r                //return o2-o1;
# [1 m; W9 L5 V- O0 X            }
        });

) \0 X- E5 \* g, P
- m9 e8 m* `6 U" J( l7 s+ [4 a8 `        //tempList.sort 也可以排序
       /* tempList.sort(new Comparator<Integer>() {
            @Override
& ~5 D( Q; @6 J: G% h) @            public int compare(Integer o1, Integer o2) {
                //return o1-o2;
& f# @; _4 p. G2 ?, D8 O                return o2-o1;
            }
6 {* Q: R, m$ K4 x$ t3 \        });*/


3 Q5 X' q$ t7 s" }0 j" Z        //遍历输出结果
        for (Integer integer : tempList) {
            System.out.print(integer+" ");
        }

8 {1 M9 s" M0 y* C) r: A5 R
        System.out.println();
3 y" Z4 N  O8 A9 {

  u! O' V9 ?: q' Y        //测试冒泡排序
        System.out.println("测试冒泡排序:");
# D  Q% B: r. w, V        temparr = nums.clone();

, X/ k* C; O1 ~1 f3 }  l5 l! o( a
        BubbleSort.bubbleSort(temparr);
2 s& B+ B% V+ ~0 [* z
' X4 i2 \" Q* F  h/ O, S
( V+ S0 l4 f6 F+ Z% U/ [        //降序
: X3 p) u; ~' E: R: Y: C        //BubbleSort.bubbleSort(temparr,false);
0 b4 p; n. v0 C9 m1 v( l' Z
) x  q+ L" w: _6 @  p: s$ G3 Y  Y
        for (int i = 0; i < temparr.length; i++) {
/ P: _) |; v4 ]/ m            System.out.print(temparr + " ");
        }
        System.out.println();


        //测试快速排序
8 z2 P, C" w# K: Q8 _6 ^. {" e( `( N        System.out.println("测试快速排序:");
, H9 m4 B  m* O% v* @' F; K, Y. o$ h7 B        temparr = nums.clone();
* k  N5 d' i# D" C3 W: ]9 J        QuickSort.quickSort(temparr);
        //QuickSort.quickSort(temparr,false);
5 K3 Q0 N/ d# p5 m2 }. n1 e        for (int i = 0; i < temparr.length; i++) {
            System.out.print(temparr + " ");
        }
        System.out.println();
  T% Y' a9 K$ }/ f* p, G" o
: {+ O6 T, V- |- O
        //测试直接选择排序
5 T/ C  ~; ]4 P! v6 S        System.out.println("测试直接选择排序:");
        temparr = nums.clone();
        SelectSort.selectSort(temparr);
$ a* k+ s" k, [" T7 J: P8 X        //SelectSort.selectSort(temparr,false);
3 q: H5 T0 V* e        for (int i = 0; i < temparr.length; i++) {
            System.out.print(temparr + " ");
9 p( A. U2 p+ U        }
1 U, {( a. I! p        System.out.println();
5 i: g5 Q4 _7 u1 m9 _) I! q: L  c

5 k7 s; a6 Q  f: V2 B        //测试堆排序
- S3 b: N& V% v& A. B" n# K; B        System.out.println("测试堆排序:");
1 G5 G) R( F* E9 Q        temparr = nums.clone();
        HeapSort.heapSort(temparr);
        //HeapSort.heapSort(temparr,false);
+ l# C* u9 _1 M        for (int i = 0; i < temparr.length; i++) {
            System.out.print(temparr + " ");
' Z% V0 J1 d7 M2 I5 N5 C6 y* r        }
5 O4 |3 P' Z2 H6 n3 Z        System.out.println();


        //测试归并排序
        System.out.println("测试归并排序:");
        temparr = nums.clone();
        MergeSort.mergeSort(temparr);
$ j. q5 e# C- v! |7 q1 S+ z        //MergeSort.mergeSort(temparr,false);
( p0 t% y5 }- b, ?- |0 C4 L        for (int i = 0; i < temparr.length; i++) {
            System.out.print(temparr + " ");
5 _" u: J/ r; U9 t2 d  K8 u        }
0 V% f/ @% v% d7 C5 L, W5 L) `        System.out.println();
+ _% o9 s8 s" m7 k5 C# M  _: C

        //测试插入排序
, U& `. `$ j  ?5 j9 l" w8 |        System.out.println("测试插入排序:");
        temparr = nums.clone();
        StraghtInsertSort.straghtInsertSort(temparr);
        //StraghtInsertSort.straghtInsertSort(temparr,false);
        for (int i = 0; i < temparr.length; i++) {
            System.out.print(temparr + " ");
        }
        System.out.println();

, V+ f' Q5 F& t. e" X

: s$ ^" ~: C9 B; l
) r: L0 @) b8 X0 G        //测试希尔排序
        System.out.println("测试希尔排序:");
        temparr = nums.clone();
        ShellSort.shellSort(temparr);
        //ShellSort.shellSort(temparr,false);
* ^3 z- d: K% x( O' Q* F& v2 R, E        for (int i = 0; i < temparr.length; i++) {
            System.out.print(temparr + " ");
        }
        System.out.println();

% D3 U, s' c& J6 j( w  c$ i; M& C

. r3 k. z6 L3 g; c7 B( J1 E2 _
" u/ X* ^, U7 B, R# O9 Q        //测试计数排序
        System.out.println("测试计数排序:");
        temparr = nums.clone();
7 f/ h! ^3 o2 |$ D0 d7 x" @1 F        CountSort.countSort(temparr);
        //CountSort.countSort(temparr,false);
7 G* k1 J* l( j( R1 a        for (int i = 0; i < temparr.length; i++) {
! O2 V! ?/ b7 m            System.out.print(temparr + " ");
        }
; U* z5 |( e8 f9 S        System.out.println();


: ~1 g1 S1 G) V. _7 Y
1 m  R( U- E/ C+ t
: T- |& o# E+ [  x        //测试桶排序
* |+ G* R1 x; u/ `2 j$ O* _/ S        System.out.println("测试桶排序:");
        temparr = nums.clone();
+ E- Y/ }. z( l0 d        BucketSort.bucketSort(temparr);
" ^# @8 ^8 f8 ]* z+ k5 b        //BucketSort.bucketSort(temparr,false);
- y4 G5 u- c; P: V2 F        for (int i = 0; i < temparr.length; i++) {
            System.out.print(temparr + " ");
4 O, W  }$ k2 I! l        }
: M9 x0 o5 D# g. z" o( g3 s        System.out.println();
  X- u/ h2 _" Q" L* B
. w; Z& h9 O+ g, Z4 J
        //测试基数排序
$ @  H9 S- A5 e: W: C6 C$ f* n        System.out.println("测试基数排序:");
" h3 p" r+ c  N        temparr = nums.clone();
) ?% h! x2 g0 R4 v: p% r, @$ ^9 i- N        RadixSort.radixSort(temparr);
        //RadixSort.radixSort(temparr,false);
' O3 K; S5 [- Z7 y( r# r        for (int i = 0; i < temparr.length; i++) {
            System.out.print(temparr + " ");
        }
        System.out.println();
+ H* v! a8 u( Q! p1 n4 m- `
, x$ m, t  t: x5 Q- f
    }
# m1 c# o) `8 u1 ]' ?! M. D8 Y
7 m0 {& X/ n: h5 f9 w: }) @2 W+ b
1 B, m; X" X% ^}
4 _# \9 r7 d. `. M+ _) Q1
) M# [+ M2 ^) R( E2
3
4
# S- U& Y: Z( Q+ J& {5
6
7
8
9
10
6 i, _' S0 `& a11
12
; s! q0 |& |. [! j. _13
( c' g& w: H4 J3 X6 n% }6 u& O14
15
16
17
18
19
- i/ d$ P3 |& M) v" q20
21
# C% E2 O+ h& r22
23
- k3 E9 \# U' P' Z# q24
( w' H, x0 b& X" `& C5 R25
1 a! ]# ?5 H/ V26
27
# ]5 b9 l4 O3 k8 J28
$ y8 ^+ J2 Z* F7 J; X29
30
31
) Z% ~( F, I2 X- T0 X( Z32
: C# V# G# L2 G: J+ }& @& R33
34
/ l& |. Q1 R& N9 I35
( i" U2 G7 v3 K6 B36
8 T: w, n1 ~- \37
38
39
40
( L+ @; M9 d4 O41
42
43
44
45
( R  P6 |& K. o3 P4 }! X7 [46
47
: O4 r- }- x" y- A6 E/ d& X4 ^48
49
50
0 k2 o' S) V/ [1 D5 V( k% d51
52
53
54
' D# @7 j/ F) _) f3 ~( }55
* O1 ?/ m) S1 f$ P$ v# |7 U0 x! d56
9 ?: i# U1 a1 o0 b+ J% X5 u) o0 w57
" Z4 ]* p  m# D  n$ H( o58
8 C; a  F  v2 \59
( N4 ^4 R+ j& }$ G1 f7 j4 ~4 ~: k) n60
. Q  U8 _' ], }6 j# l61
62
! X# j+ E: u  B; Q4 u1 s  I63
% V1 p  S( c1 @7 I7 ~) e& Y" D64
0 m3 [3 O4 w" V0 M4 k65
  q$ `4 I" ]1 h# n7 w. K66
9 A3 V6 M/ C/ S67
68
" p/ w( O. I: g8 v7 g8 X$ E; e- @; @69
* Q; ?2 i. d! N2 J! |2 f7 u70
71
/ n/ o5 d- k* D1 P% y: l72
73
74
* `; ]: C# @; B75
76
" s" t2 E0 ]3 p' V" S+ J, N77
78
& \9 o' t* c! S79
80
81
5 y  d7 f) K8 V9 y" K82
83
* O, f" U; p& r! p% ?7 {84
# m% p2 d. v* `/ M8 Y+ |3 X85
86
87
5 x- r. }( i9 `7 T+ v/ T88
89
) L* f6 B1 g) x: [90
* `+ v' ^, }2 ]/ P; ^91
1 K& z* p! N. w4 H: U. {92
93
94
95
3 |9 C# }! l  K$ j  _96
- B" p, D; ~, ^' L9 t- E& a97
98
99
100
101
102
103
104
105
106
107
108
109
6 N/ }5 z/ n* `110
111
112
( t6 p0 N3 g* R# a( _& c7 A) F113
114
7 v- y7 C+ P4 Z, k115
  m  r# V( Y( f5 Q/ g7 m% d9 S1 Z116
117
118
119
120
121
122
1 U+ h) O3 m% c! b6 J; |123
5 k3 g& a6 T( ~' v124
0 n. Q- o; i- t125
126
, C. S$ U+ a7 I' D2 j5 P% i127
' V; M# H# j- v$ R- V128
129
130
131
132
, c" I/ x; ?" T( _7 `133
9 H; }) U/ I& }8 E1 N134
% x: I. O7 M0 e135
; f& t( _. F4 `- S' f136
137
138
139
  x1 H; d7 k- r; O( \3 }140
4 z- z# P2 E3 g141
142
143
144
145
146
& }8 t* D1 A+ B6 Q0 \' H147
- O& s6 p- k% P0 Y; b: ~/ @148
149
* }& X  @5 I3 x( D! [150
: c2 Z; x4 B% ]# c& q" D151
& P1 ~& s& \2 n152
& T$ h% F' e( _+ o+ J153
7 |& F4 I: N" s# Z7 a9 f: _154
155
156
. P$ {1 j. M9 h1 t157
* ?) l* P; f9 T( S, v( V# Y158
& Y% l# [% d( G7 s  o" K  Q! f159
4 G# L$ O) \/ ~160
161
162
163
% o* ?' X, A. x% R1 M& y: H( C6 o164
165
166
2 F" f: t$ t  [167
# x" Q: q$ u5 Z! M. Z+ E168
169
4 m( q: ?3 b/ q2 d* z9 K9 q170
" C% Y+ }$ x- H; M" u) q171
172
173
. L/ _3 G; Z* ]$ Q* B" ^& J. U每天进步一点点！
+ w) R/ R) I+ J% W! Z不进则退！

1 Y% N% h) ^% R- l) e3 K7 ~7 x
* G2 {3 i% @0 `1 J+ h9 \/ h+ q版权声明：
" F0 B- `) o- M2 N  v2 S原创博主：牛哄哄的柯南
* O6 E. [( l4 P  W8 \) H博主原文链接：https://keafmd.blog.csdn.net/
————————————————
. t  P1 y3 a' `版权声明：本文为CSDN博主「牛哄哄的柯南」的原创文章，遵循CC 4.0 BY-SA版权协议，转载请附上原文出处链接及本声明。
原文链接：https://blog.csdn.net/weixin_43883917/article/details/118193663
0 N' x+ t- s- @! L3 J& c2 I1 d
, z( v" W, P2 p/ X
  E- _. _5 g  g6 {$ S

1051373629

每天进步一点点！