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

杨利霞

经典十大排序算法（含升序降序，基数排序含负数排序）【Java版完整代码】【建议收藏系列】
4 p9 L9 n5 f. d# H, ~' U' s  Z经典十大排序算法【Java版完整代码】
写在前面的话
: K5 n5 ^+ y7 f+ m8 E十大排序算法对比
冒泡排序
+ O: l( U+ ^' R5 e7 Y0 A快速排序
$ s& Q6 Y  B3 D( [" j直接选择排序
, I  B, V0 b, i4 i( b9 E; O堆排序
# O$ E  O1 o6 W, G& u归并排序
插入排序
希尔排序
计数排序
桶排序
7 |' U! w8 D1 H4 b9 A3 \0 N; H+ S8 l基数排序
2 l. e, b- Q. b9 M完整测试类
& _2 J6 X# S6 P2 k3 ?  E8 b写在前面的话
       虽然已经有很多人总结过这十大排序算法，优秀的文章也不少，但是Java完整版的好像不多，还存在某些文章代码存在错误的情况，同时也为了自己练手，决定把所有的写一遍巩固下，同时也真诚的希望阅读到这篇文章的小伙伴们可以自己去从头敲一遍，不要粘贴复制！希望我的文章对你有所帮助，每天进步一点点！！！
, c; {7 I" R1 O* k' e6 G1 }  b% B+ m! W

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


0 U% @' d3 f6 [' O, L十大排序算法对比

1 U6 x) U; C$ A. R. k( P  P' w
  C' S. g' \  s& }0 h
  D2 }* X5 b3 _* g3 R" l1 `9 N1 a
6 y' l; E  K9 d' o) {6 P: K- c4 b4 W关于最后一列的稳定性，我稍微解释下，例如对序列：1 2 4 2 6 排序，序列中存在两个2，如果我们把这两个2标记上（让他俩不同），排序之后，前面的2还在前面，那么就称这种排序是稳定的，反之不稳定。


冒泡排序
  C9 B& ?1 p  K简单解释：
( w' V1 q) @' Y       原理就如算法名字一样，就像水中的气泡一样，每次我都把最大的或最小的放到最后面，这样总共需要n-1趟即可完成排序，这就是第一层循环，第二次循环就是遍历未被固定的那些数（理解成数组左边的数，因为每层循环都会把最大或最小的数升到最右边固定起来，下次就不遍历这些数了），两层循环遍历结束后，所有的数就排好序了。
       两层循环所以冒泡排序算法的时间复杂度是O(n 2 n^{2}n
7 H/ Q/ `9 g; {# w2
)，是一个非常高的时间复杂度，我在下面的代码进行了优化，加了一个标志位，如果上一次循环未发生交换，就说明已经是有序的了，就不继续下去了，反之继续进行下一轮。



! V8 ~6 y) ^0 d
5 b. d" C4 }5 t; x! D

, R: v2 y) m+ I/ |本文的图片来源网络，仅用于大家学习，侵权联系删除！（下同）
+ y6 I3 x  G' D) V" G( T$ c

6 w( C, p- W6 `! P! @完整代码：
- T0 ?* Y3 Q& y8 P

" [0 ?/ ~3 o2 q/ d8 Z$ Xpackage com.keafmd.Sequence;


/**
% G) h8 _9 p7 Q8 D! H * Keafmd
, T, K* v! l: y( e  }; c *
& e4 R* @3 M& x * @ClassName: BubbleSort
* @Description: 冒泡排序
* @author: 牛哄哄的柯南
+ A# J* Q9 {( E7 E% F% F * @date: 2021-06-24 10:31
& ?3 F+ g# ]5 _8 K */
public class BubbleSort {
5 e- {1 N- R( |6 p2 z
/ R, K" F) w& Y7 ~# X; I
    //冒泡排序
    public static void bubbleSort(int[] arr, boolean ascending) { //exchange标志表示为升序排序还是降序排序


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


, r* B4 {% x2 Y- i" B, N, i0 C7 k; Y        for (int i = 1; i < arr.length && flag; i++) { //控制次数，第几趟排序，只需要n-1趟，有交换时进行，只有flag=false就说明上一次一个元素都没有进行交换
8 }; @3 C: C0 n7 S! G( ]" A
% v4 y6 A% K  _  G7 C2 [1 I
  K3 n& x! ]! ?" s5 c5 o! U            /*System.out.print("第"+i+"次遍历：");
, W" M$ i/ F) E3 f2 W2 P- ?9 l            for (int i1 : arr) {
" Z4 B: K5 W9 M" Q) ~  Z* c! t$ \1 u                System.out.print(i1+" ");
/ W7 `+ ~# e4 Y4 ]: _9 f            }
5 D) x5 ^: {( h$ p  c            System.out.println();*/
/ |+ |$ c4 D- K) v# \: p4 w

5 ~1 V( G8 z. Z/ p8 p! E            flag = false; //假定未交换
/ M, e/ }7 Z+ v% e4 }0 l- P/ F

; p, c% i: R( A0 S# e            for (int j = 0; j < arr.length - i; j++) {
5 ~. `  E- f! I+ k3 l; j. G( m+ V( X& w8 F
  @- B- s) ?: N
. v* ~6 h5 _$ q, S! I                if (ascending ? arr[j] > arr[j + 1] : arr[j] < arr[j + 1]) { //控制升序还是降序
                    int temp = arr[j];
                    arr[j] = arr[j + 1];
2 a! L# C7 c' r9 L0 J( ]. g& R                    arr[j + 1] = temp;
                    flag = true;
                }

2 t3 r3 J/ q! S3 A
            }
" t8 f+ t8 I9 ]: y* S# m6 E# e! }        }
    }

- X( A7 `+ q( X7 y9 r" l
, ]4 i4 C/ C% \0 F9 @3 g' |& x    //冒泡排序 -- 默认不传参升序
    public static void bubbleSort(int[] arr) {
        bubbleSort(arr, true);
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
  Z# a) D6 R" W) C; @5 |18
. T/ l+ X5 R4 t- s$ J1 u0 M( Y19
6 h3 G& B) A. |; |3 l/ b2 ^1 v20
21
22
23
24
25
; t" k! o4 I) z9 o26
27
28
29
30
# X: b; F. {& G5 J: L4 N3 v31
32
; }- F: G! J1 X, R# t% F3 U7 Q33
6 U. t% ~3 O$ g$ w34
, B0 L' Q5 Z9 j, m2 S9 \# o+ K9 j35
36
) N1 ]! [2 \; |" w! [0 Z8 h0 d) V37
38
39
* |  V: `# {; E( v& \5 r: @0 a/ ~40
  T- }9 O" v% {' O) I! N* B41
2 P2 G$ C) N! I* m4 H, C* B42
7 L% P: M# q7 i" s$ J# \43
+ R8 s# B- U2 r% a, V) O44
2 Q$ r- H6 a* a! ?; {45
测试代码：
1 e9 X& v* s! {. O0 v# E2 [& w

升序排序（从小到大）


- A; W, x4 Y! O, Y$ K. J: }package com.keafmd.Sequence;


! v" I7 e; z6 Z7 {# D, h; uimport java.util.*;
7 ^, F  I( {% Zimport java.util.stream.IntStream;
import java.util.stream.Stream;
0 N' E  G; f9 @! F
8 N3 O+ G5 p, c
" R9 W$ d6 f+ l* Y- m) ^% z/**
* Keafmd
*
* @ClassName: Sort
* @Description: 十大排序算法
* @author: 牛哄哄的柯南
7 m! B: u) N( E) B$ ^, o * @date: 2021-06-16 21:27
- A+ ~) `3 S! h# w */
* |. E2 p( F6 qpublic class Sort {
    public static void main(String[] args) {


        int[] nums = {12, 4, 25, 47, 58, 34, 25, 9, 99, 26, 1, -13, 162, 10093, -66, -1};
        int[] temparr;

) H! `0 H( g7 B' k
% C, ]5 c' p# D8 v# M- V: x        //测试冒泡排序
        System.out.println("测试冒泡排序:");
# m! d  L1 X/ V        temparr = nums.clone();
        BubbleSort.bubbleSort(temparr);
        //逆序排序
        //BubbleSort.bubbleSort(temparr,false);
; Q8 K9 _4 ^, L. `( O6 {        for (int i = 0; i < temparr.length; i++) {
            System.out.print(temparr + " ");
        }
# B8 g9 a3 p' i! y: o        System.out.println();
  t+ ?: b0 p1 Z' \; Z. D* J

    }
8 I3 Q; n" X* A' ^8 i; d( d; F}
: {" c+ T2 \9 G2 }& t1
2
6 y8 A+ Z* B4 _6 H8 l6 b, t. S3
" K& y  N" W. z; ~1 \. ?4
2 Y" L* s2 S" H/ V5
' X7 V% l' h; }6
7
" i) w) @1 x; U, z# U8
( K. j6 l  I$ F+ _9
+ r8 [: m- Q" L9 m" O10
11
12
13
14
15
. T3 T  c2 _2 F3 q) n16
! Y6 F6 T+ [6 ^17
18
* {" y% P* \; @" D9 h- E19
* A( a8 J3 J# i' Y1 c  v20
21
  O4 B6 d' T1 U0 ^0 b22
* Z2 G6 T6 P: w3 i) Y: A) m. f23
" [( {' s9 p6 S, A# R24
25
26
27
28
29
30
31
6 |2 d9 f8 U# R4 ^6 h; B" k32
' a" D/ H6 d5 f* @. R33
4 I1 S/ J3 R+ F" s; Y6 D" A运行结果：

# {: l" B5 W# b' _
测试冒泡排序:
2 U0 k7 m, q9 d- J# s! U-66 -13 -1 1 4 9 12 25 25 26 34 47 58 99 162 10093
0 Z/ F1 b3 x# Y: N6 m' v% l1
2
降序排序（从大到小）
' `7 u1 ?9 `9 z% \* N

* X: O( s# G' N1 }//测试冒泡排序
$ a1 o4 a( ^4 {' o( H; dSystem.out.println("测试冒泡排序:");
temparr = nums.clone();
BubbleSort.bubbleSort(temparr,false);
7 m1 n2 E8 Z7 Y& [for (int i = 0; i < temparr.length; i++) {
9 M! T" h2 C9 U( h    System.out.print(temparr + " ");
8 s/ ^; j% _) Q}
0 J. N" A3 ?) Q4 pSystem.out.println();
1
2
3
, S! T2 P% u) `& }( J6 p4
5
$ k' Q& w* G( Z! L% P0 V6
- K$ D: r( o, ?4 l& I7
8
2 l( O7 i8 E8 i  i运行结果：


" {: d! n5 W+ J  ]8 ^- B" v2 u测试冒泡排序:
7 e2 |  s- X2 C% V* B- _, x" G2 {10093 162 99 58 47 34 26 25 25 12 9 4 1 -1 -13 -66
, `4 t. k- W  D& J( T1
) {( }/ |  N+ V, X0 t( u& m+ N2
下面几个算法的测试也就是换了下类名和方法名（换成相应的排序算法），如果想降序就在数组后面传个false即可。我就不一一复制了，我在最下面给出含所有算法的测试类，需要的自取即可。
) ^  j- [0 ~2 a0 l3 P
0 g2 B0 [$ A+ x  N
$ \# Q2 ]# }7 X  P& R) X+ H& M快速排序
7 f2 E# H, \2 O& G. G, h, I, f简单解释：
2 ~4 h3 H9 l% b' [9 K5 b! i快速排序就是每次找一个基点（第一个元素），然后两个哨兵，一个从最前面往后走，一个从最后面往前面走，如果后面那个哨兵找到了一个比基点大的数停下来，前面那个哨兵找到比基点大的数停下来，然后交换两个哨兵找到的数，如果找不到最后两个哨兵就会碰到一起就结束，最后交换基点和哨兵相遇的地方的元素，然后就将一个序列分为比基点小的一部分和比基点大的一部分，然后递归左半部分和右半部分，最后的结果就是有序的了。



1 l7 ~; b, F" Z. W9 i


完整代码：

6 q2 e* j" b8 V' f; e& c& m% Y- z& M
package com.keafmd.Sequence;
7 Z/ X6 z( R' R) O) |0 g

  c5 l7 x" i) J/ ?6 Y/**
& N6 D2 X$ k/ h3 C * Keafmd
) S6 _! R. F! @; P$ G *
6 g! A6 T' l7 O# h5 v * @ClassName: QuickSort
* @Description: 快速排序
1 ]! L2 W- a/ A' D3 W * @author: 牛哄哄的柯南
* @date: 2021-06-24 10:32
*/
6 C5 ~; o% L' |: J/ Z' W. C- v1 T4 _public class QuickSort {

: H8 Y  C6 m) c7 J% y+ n% D
    //快速排序
3 R  f1 m; k! @  v' [    public static void quickSort(int[] arr) {
        quickSort(arr, true);
" Q: L" H  F4 }- g: t! H    }
' u' x) C; n4 ]8 d6 {3 V/ N6 h
0 T4 r9 L# L9 B
    public static void quickSort(int[] arr, boolean ascending) {
, N( l. l- e0 x. s        if (ascending) {
/ ~6 u5 m) ^" a8 o& J            quickSort(arr, 0, arr.length - 1, true);
+ M3 X6 D% G% c3 v# I/ i9 S( m        } else {
* i+ y0 i# W6 J2 N, X            quickSort(arr, 0, arr.length - 1, false);
8 L( W7 ^1 ^2 T' W; r$ E. x% W        }
. b2 @2 h) V0 L3 \8 M$ @    }
/ W% x3 q5 ^. {, B

    public static void quickSort(int[] arr, int begin, int end, boolean ascending) {
        if (ascending)
, z1 t7 ~* q% q/ }) R            quickSort(arr, begin, end);
        else
- m/ p9 c" Q" F& t# w            quickSortDescending(arr, begin, end);
    }

, [3 c: u% O* b7 z: u  I
    //快排序升序 -- 默认
1 p$ B6 H; Y5 R+ h    public static void quickSort(int[] arr, int begin, int end) {
        if (begin > end) { //结束条件
; P% A: }0 ^% @3 h9 x            return;
        }
        int base = arr[begin];
2 S' ?6 ?& @8 b        int i = begin, j = end;
8 K2 j6 H; e4 p: u( v- Z: Y6 O" ?/ z# w        while (i < j) { // 两个哨兵（i左边，j右边）没有相遇
            while (arr[j] >= base && i < j) { //哨兵j没找到比base小的
                j--;
1 G! O# x& y3 ?2 M# G1 r* x            }
4 N$ B( U* k- n3 D            while (arr <= base && i < j) { //哨兵i没找到比base大的
4 B5 v* D5 E$ k( `* C+ \                i++;
; Q8 v5 c+ `$ e9 h/ k            }
" X9 L) u4 i$ o/ m            if (i < j) { //如果满足条件则交换
  u" v* ^* C6 X" Y                int temp = arr;
6 m4 @7 w3 P) ]* i+ b+ O7 N                arr = arr[j];
: ^+ y/ W9 J# d4 n* _% j                arr[j] = temp;
* d; c, t; @$ ?8 g9 d            }

! A& g- ~: w7 l
9 ], |6 G9 t: K2 L, g( e        }
1 s2 J$ a# E# M& _        //最后将基准为与i和j相等位置的数字交换
        arr[begin] = arr;
        arr = base;
/ }* }& K8 [7 y9 ^        quickSort(arr, begin, i - 1); //递归调用左半数组
        quickSort(arr, i + 1, end); //递归调用右半数组


    }


; i5 w6 T; U% z7 V6 D1 {" _7 j$ l& S    //快排序降序
# `. `" j# Z" \# D- Q9 b    public static void quickSortDescending(int[] arr, int begin, int end) {
        if (begin > end) { //结束条件
1 R: @; j- m8 J            return;
        }
# V( n' }' U( l8 g) ^; C& [  b% q        int base = arr[begin];
4 B) B) d. ?3 [6 e) V4 b( j" l        int i = begin, j = end;
; O8 F! e6 s% F" D4 w# Z/ m1 @) }        while (i < j) { // 两个哨兵（i左边，j右边）没有相遇
* T; s/ O: \/ m+ _$ Q            while (arr[j] <= base && i < j) { //哨兵j没找到比base大的
' |. W, k, c9 D0 g* Y                j--;
) _/ q9 J, T5 Z9 m6 b            }
            while (arr >= base && i < j) { //哨兵i没找到比base小的
                i++;
! X6 y$ \) i2 U8 {, R8 B! N( l$ z" k            }
+ w5 r: [6 v) ]* |- t4 r' ~            if (i < j) { //如果满足条件则交换
  W/ F( A. ^2 z6 \6 `                int temp = arr;
                arr = arr[j];
                arr[j] = temp;
9 b5 S% f6 x% {5 N1 n0 J            }


  F2 W* h% e9 _  m6 k- Z        }
& e0 k. j7 \6 y3 c* u        //最后将基准为与i和j相等位置的数字交换
        arr[begin] = arr;
+ c% ~& R' z) I1 c3 W        arr = base;
        quickSortDescending(arr, begin, i - 1); //递归调用左半数组
        quickSortDescending(arr, i + 1, end); //递归调用右半数组

% T, G6 J/ j# C" x& `( q
    }
* q+ J; A; h8 a$ H' d4 t
$ R8 O, \2 o4 P+ b6 ]  f
, }8 @, ^4 Y; y, w}
1
" B, b1 s" M6 d  b- o2
3
4
5
( Y9 m7 O, \0 l; _  P6
/ d" R5 C( F5 {* W3 _7
, x1 V& Z( N0 }, S/ T  I$ s  t8
9
; c" h$ x+ G2 k3 r7 Q10
11
# ^. f  U$ a4 g12
13
. _, v( g3 w* O1 w14
15
0 N$ T6 R) ~( @16
17
18
4 e# o2 }6 K. f2 }+ y8 X+ ~% R19
! v. |, @" L& K) f0 g20
21
22
23
+ n  O4 t! [/ U+ N+ f24
6 d) o% n0 n2 [& [/ I' a6 N2 L% f25
  x1 `$ d4 c, x/ t0 Q26
27
7 V; d( }# Y3 K: U& \. c' @/ v1 U* p28
29
! M# [5 ^4 ^1 y, `30
' P& E, Y# `  m- `2 F0 V  e31
32
33
% \$ w8 i$ s" i# J" c/ ]1 W' k& m34
# h7 e$ v1 Q0 N* D- W! ~35
36
37
38
) T+ H4 b" R8 h* E39
40
. x! `. ^" I5 b$ p41
+ m, k+ a6 F7 W1 ?/ ~42
5 H- p5 E! {+ f% c7 e43
" u0 v7 S% |  {) K0 [% {. v9 B44
45
46
1 n8 C( i: ?3 h& G2 `7 \1 \* a47
48
1 o, i+ j% d9 K49
50
0 X+ B3 S% Z& O' I. Y) }8 e+ @( T51
52
53
; ]6 E) e% A& y* z1 V54
55
56
; P3 E* j+ k: w3 C57
58
59
60
61
/ @6 F: ~2 m5 l& U62
1 T" {6 O  t. i9 A63
& ^2 v) W% M- f  S" H9 C64
7 Y* f7 b; u4 f( }1 f7 K9 e3 r4 s* n65
66
67
- {7 }, j7 y' J; ^% B' K68
69
7 ]6 Q  j$ R+ D) q! M70
71
72
73
74
75
1 R8 f8 {5 j! L6 e) N6 Y  D  R1 L' Z76
77
  x& B- p8 E' v0 I* K% [: t78
/ f3 x& O5 K1 H79
80
6 V' G+ c, n% Q2 Y0 z8 _81
5 b5 b  q  l( c82
! X! s) n. G/ f+ t4 R) }" {83
84
) q0 W0 C0 h3 M" E2 R8 g85
" O7 \* X+ l! p* j9 I( l5 _86
" F3 L- C- i7 D8 k4 c+ v* p9 Z$ {87
1 Z9 ~" ]1 N- R1 D: c88
89
90
" k; {+ }" F; _6 O: {1 k* M91
直接选择排序
简单解释：
$ p9 V6 ^) U& ~数组分为已排序部分（前面）和待排序序列（后面）
第一次肯定所有的数都是待排序的
0 v4 g8 Y0 P" k( r4 P从待排序的序列中找到最大或最小的那个元素，放到前面的已排序部分，然后一直找，不断缩小待排序的范围，直到所有的数都是已排序的了
/ B5 f+ U( Q- _6 c' N+ i
' c. N7 m5 [2 I3 ~- p
" c+ H4 O5 o& @( g- I, a9 h
& @8 b" @+ H: z

/ H3 m- B0 l* E) C+ l- F6 H
) D$ o7 o6 A3 T0 p/ ~完整代码：

" Z- P- X( P6 ], G) Z, r
8 C  m/ f; t  Q5 U  n) g( o" Cpackage com.keafmd.Sequence;


# l- m- r( c" i1 O5 D8 L/**
* Keafmd
- r+ d9 I( ]7 \$ a/ G& X *
7 _& X) {% P5 P( Z" h8 i$ z0 G * @ClassName: SelectSort
. J. d7 J. J! U, R * @Description: 选择排序
3 r1 ~  A6 z# j# a/ L( t1 y5 { * @author: 牛哄哄的柯南
* @date: 2021-06-24 10:33
; B$ |$ Q: [* v% f# } */
public class SelectSort {


    //直接选择排序
1 g) J3 v' }! F4 R6 l$ h! C. h( \    public static void selectSort(int[] arr, boolean ascending) {
( K" ^# q) R; H- \, D8 ?        for (int i = 0; i < arr.length; i++) {
            int m = i; //最小值或最小值的下标
( \' U7 |: s( g! F. ^' p            for (int j = i + 1; j < arr.length; j++) {
                if (ascending ? arr[j] < arr[m] : arr[j] > arr[m]) {
2 u0 K, E, D, ]( r: E% i$ J                    m = j; //找到待排序的数中最小或最大的那个数，记录下标
$ g# ?4 S- E8 m7 |4 C6 E                }
0 j  c4 f5 I& a8 U4 N
+ L# Z. {, M6 M* v
, D; G* [6 h1 s$ a" d' Z            }
9 y% d/ O+ U7 Q0 h) {2 g            //交换位置
            int temp = arr;
: r. R- z+ \, R# Y- `            arr = arr[m];
            arr[m] = temp;
* ^% t0 ]) L: q* O' i
# O- X: Q9 S& _% f$ S" z
+ X0 |+ e9 f# Q7 _, D* c        }
    }


    public static void selectSort(int[] arr) {
: H) m! @8 l* \        selectSort(arr, true);
    }
: K+ b$ Z' \. Y) _+ ?}
1
2
2 L' Z2 N6 y' o9 ]  C& r3
& G3 A' U& P; K5 G3 @4
5
6
0 d- e8 l7 \9 q# P7 C7
8
/ O8 V3 P$ ^  P3 a+ E9
10
2 |& v7 c' h' k; H& h, F11
12
- |* X; F! ?7 u' Q  H+ ^! f$ W13
% s( H( `6 M* k! X, Z14
15
; i- n6 b/ ?$ `16
& R) e, }4 E: I/ z- q  a% {17
) V" R" s! G8 X* _2 h18
2 S6 ^; G4 y! M: q0 H. a; s19
20
21
0 m: S4 y# z5 ^6 ^22
7 z; C6 E. O8 k! G4 q* {6 g1 ^23
% N5 n; L9 K1 f% W. K24
% q8 Y/ u) p: K1 Z8 v7 f$ S4 @25
4 I) ?5 w# j) Q1 M26
! \5 P2 D; D+ R- I& l27
28
29
& }7 d* a% R9 {6 `30
31
2 p! j! W" g4 O32
5 I& Q; J$ b8 {+ U& I33
) h: ^6 z6 p7 t, D0 A34
堆排序
先理解下大顶堆和小顶堆，看图
大顶堆，双亲结点的值比每一个孩子结点的值都要大。根结点值最大
- [; v0 D: N* W0 J5 `小顶堆，双亲结点的值比每一个孩子结点的值都要小。根结点值最小
& B+ p( c0 j  i. M8 e! q# o
1 W3 d6 F9 q% `8 `4 C


简单解释：
$ {8 c6 m; D8 U8 p. w' m% f' Y构建好大顶堆或小顶堆结构，这样最上面的就是最大值或最小值，那么我们取出堆顶元素，然后重新构建结构，一直取，一直重新构建，那么最后达到排序的效果了。


% T" u( U9 B2 g0 R" L

6 V' h4 E' D( T+ m4 v) G

完整代码：

6 ~& G! j3 f, @+ I  [1 |
# A$ {  ^) y: s* lpackage com.keafmd.Sequence;
5 a8 z( L+ Q/ n

/**
& l/ S4 _. h# E& s2 j * Keafmd
*
8 e- d2 d. T1 r/ w/ W  v% `$ j) ] * @ClassName: HeapSort
* @Description: 堆排序
' A" `2 ?' I* Q# k# c * @author: 牛哄哄的柯南
* @date: 2021-06-24 10:34
, L  N( f: b! j# s; B& M */
public class HeapSort {
( G) e1 O% T9 v4 \, l
$ X, U/ G( E3 z: l9 y! h" B6 i
    //堆排序
( T( I1 p7 w8 B7 d) X* s# B1 `/ d    public static void heapSort(int[] arr) {
7 X. V. e6 U  d0 T9 B' v( ]        //对传入的数组进行建立堆，这里默认建立大顶堆，进行升序排列
, e  c, v' z1 P; j/ v        heapSort(arr, true);
1 E( e9 _4 `% G8 f    }
6 T5 o  ?9 s1 ~8 t( V8 B
5 B, Y, a! r$ m2 n$ l, p
    public static void heapSort(int[] arr, boolean maxheap) {


        //1.构建大顶堆
9 v* s  `, F1 U7 b' J! T        for (int i = arr.length / 2 - 1; i >= 0; i--) {
            //从第一个非叶子结点从下至上，从右至左调整结构
6 P; b0 `# |' n: O+ G8 \9 F            sift(arr, i, arr.length , maxheap);
        }
% o5 C( ]! A! ?$ d7 W

        //2.调整堆结构+交换堆顶元素与末尾元素
0 c; G8 T% i" V5 ?        for (int j = arr.length - 1; j > 0; j--) {

7 }4 m, X8 g2 _6 d. O( ?
  ^4 e9 P* I& {! Z# Q3 A            //现在的数组第一个就是根结点，最小值所在，进行交换，把它放到最右边
) T9 Y+ ]+ Y/ q0 ~! w3 M) a* i            int temp = arr[j];
            arr[j] = arr[0];
            arr[0] = temp;


            //重新建立堆
4 e% C, r1 c! g$ E  S9 r            sift(arr, 0, j , maxheap); //重新对堆进行调整
        }
    }

$ o0 o& O# D" Z5 u8 O# [
    //建立堆的方法
8 m% J! k# }1 c1 T: h    /**
3 ]# E* E7 M6 q- Z$ X. P( y# x     * 私有方法，只允许被堆排序调用
8 s! P8 q: M) q7 ?" s     *
0 ^6 i1 ]8 r1 j! Q     * @param arr     要排序数组
  H5 W" h* D+ z" }5 u9 D     * @param parent  当前的双亲节点
     * @param len     数组长度
     * @param maxheap 是否建立大顶堆
" W/ J' @" ~' ~: t  K+ t     */
    private static void sift(int[] arr, int parent, int len, boolean maxheap) {
( L6 P0 z; x! Z: |9 R! [* t
# I" x3 p. ?4 s+ }/ x
. @0 v- q( j/ v# N        int value = arr[parent]; //先取出当前元素i

, O  d: I5 p/ V0 `. S# l
3 H' G; ?8 o8 E9 ^- q        for (int child = 2 * parent + 1; child < len; child = child * 2 + 1) { //从parent结点的左子结点开始，也就是2*parent+1处开始


            if (child+1 < len && (maxheap ? arr[child] < arr[child + 1] : arr[child] > arr[child + 1])) { //如果左子结点小于右子结点，child指向右子结点
                child++; //右孩子如果比左孩子大，我们就将现在的孩子换到右孩子
3 O5 _6 i4 \! R5 \" `            }
9 F5 q% B; m  B% A

  @* c% C4 J% W7 P5 ~            //判断是否符合大顶堆的特性， 如果右孩子大于双亲，自然左孩子也大于双亲，符合
            //如果子节点大于父节点，将子节点值赋给父节点（不用进行交换)
$ E7 u# L/ ]5 B            if (maxheap ? value < arr[child] : value > arr[child]) {
8 l" G; K9 S) n4 s' {  K                arr[parent]=arr[child];
) [0 N3 X' d. c3 I) V* W7 `  A                parent = child;
* S6 e% p9 h  y8 s            }
0 G! l5 ~. W4 K) v2 J6 I            else {//如果不是，说明已经符合我们的要求了。
  U% l; E: k, N* b8 s) P                break;
            }
: f- ^5 j5 S7 U! w4 K' B        }
        arr[parent] =value; //将value值放到最终的位置

# J5 E" ~0 u  [6 P9 ], q7 I7 F


    }


}
1
2
3
( V8 W7 _, e( u2 u* D0 R) n4
8 P# e5 a- R4 B# ]0 m1 S9 W5
6
7
8
; N- r, v! N2 H6 u9
" {9 A0 ^% \4 ]- H. `10
# l/ m8 K& U( t11
12
' z- r/ X, }. y- @, ^0 `3 I  B13
14
, N6 V: J, f8 q5 B15
16
17
: A9 M  ]' o, b, Q$ ^6 L" T, R18
19
7 q4 p; c. O( }, Q1 A. H) Q* ^3 U20
4 {3 k0 Z( {5 A1 G; g7 e21
22
* _' e1 t: G, E6 [7 Y7 m23
24
25
26
/ M% |; z; z( q+ r3 x1 e27
28
29
30
31
32
# c7 O5 A# f) a3 A* b% ^) `33
34
35
3 w9 M( `3 b; @5 }# P( g36
37
7 L: Z3 P$ R  z- V# K3 e38
39
* u' I- X2 v( P! i/ E; u2 V; n  J40
41
! R& @4 G% j+ C7 }6 D) w42
43
44
45
46
  S' D# A; x7 o% M) _# \47
48
, i' `  }6 i/ g49
. O4 H4 \8 F8 k  A50
3 i4 |$ b0 \& d& B  Z1 S0 {51
52
53
54
55
56
57
58
7 S# C) t. I% @, ~/ B$ W59
60
. f5 W* I8 H5 m, M. M4 x: R, u$ M61
62
- V" e! ]: c2 g2 c5 `6 c) K5 l6 Z63
64
65
' Z; Z5 s' t) h2 x1 b4 E( F66
* Z) Z; Z, O$ k5 D. p7 M0 C- w" [4 A67
68
% ~. ?& s9 l& a( H- ~' O* H# q' [69
70
71
4 J% A" e* e0 X  ^72
9 \8 H9 s: l+ p* v" R, v/ H73
74
6 l0 I$ v; S9 m& K归并排序
简单解释：
该算法是采用分治法，把数组不断分割，直至成为单个元素，然后比较再合并（合并的过程就是两部分分别从头开始比较，取出最小或最大元素的放到新的区域内，继续取两部分中最大或最小的元素，直到这两部分合并完，最后所有的都合并完，最后形成完整的有序序列）
- b0 E8 J; ?+ n' T; T4 O
( G; q3 y9 ~6 r

' I3 i+ _; G! o% P) H. o, N& E
$ `# r8 L0 m# H! r0 U! r: B: I9 l
, W2 E! u" Q  z4 s( a2 K' j
完整代码：
$ r' {8 q" v; Y& r
# D6 B  Y* T) M  I) U% J
7 e6 b' `5 R$ D6 k( Hpackage com.keafmd.Sequence;


/**
* Keafmd
*
* @ClassName: MergeSort
5 ~8 v" n) u' |$ G+ M+ Y( K! h * @Description: 归并排序
' n  R8 \4 K0 l2 v- ~0 O * @author: 牛哄哄的柯南
* @date: 2021-06-24 10:35
*/
4 O8 c7 z( [$ E' O8 R- xpublic class MergeSort {
. \1 Y( @1 \8 [5 o+ z% ^
0 J  J  o- O% N. B4 l6 q9 V& _
    //归并排序
% d& j/ O& }2 z- [3 X/ n    public static void mergeSort(int []arr ,boolean ascending){
' t9 n2 P  \1 R5 B        int[] temp = new int[arr.length]; //在排序前，先建好一个长度等于原数组长度的临时数组，避免递归中频繁开辟空间
& Z( ~8 L9 ]. x) H; ?+ r: Z% b        mergeSort(arr,0,arr.length-1,temp,ascending);
    }
    public static void mergeSort(int []arr){
. ?0 l' M& h0 ?) J9 y; m  u        mergeSort(arr,true);
    }
' L) h1 U3 U& N+ `, j% g

! S% i( J# R" ?% J, Z6 R/ m/ J" X    /**
     *
     * @param arr 传入的数组
     * @param left 当前子数组的起始下标
     * @param right 当前子数组的结束下标
     * @param temp 拷贝暂存数组
; u4 O& ~1 S, @! ?6 |+ Q     */
    public static void mergeSort(int []arr,int left,int right,int[] temp,boolean ascending){
: u! A* }4 Q) ]/ [2 d        if(left<right){ //这里是递归结束的条件，我们是对半分，那当left==right的时候肯定大家都是只有一个元素了。

2 r5 n0 H  ?. S* ~
            //对半分，比如总长度是10，left=0，right=9，mid=4确实是中间分了，0~4，5~9
& V3 g: N8 u1 |8 [; O            //当长度9，left=0，right=8，mid=4，0~4，5~8
            int mid = left + (right-left)/2; // 防止越界的写法
, m" c# K* c0 L            //int mid = (left+right)/2;
- w; ?& o9 a/ f9 N+ h% p- w* ^4 @: a, q- |

            mergeSort(arr,left,mid,temp,ascending); //左边归并排序，使得左子序列有序
7 u) K- I4 [) U8 T! k6 d3 ~  S4 J# L            mergeSort(arr,mid+1,right,temp,ascending); //右边归并排序，使得右子序列有序

, ]5 Z, e9 p  |/ }7 I) s$ C
            merge(arr,left,mid,right,temp,ascending); //将两个有序子数组合并操作
        }
# P. q2 G. X: i    }

$ F0 d& q% h6 i! E) e( y+ I% t. u
    private static void merge(int[] arr,int left,int mid,int right,int[] temp,boolean ascending){
        int i = left; //左序列起始下标
        int j = mid+1; //右序列起始下标
1 x( J- h& t( ^0 r" i        int t = 0; //临时数组指针
        while(i<=mid&&j<=right){
5 |& u  |9 S0 }0 g% D            if(ascending?arr<arr[j]:arr>arr[j]){ //比较两个序列第一个元素谁小，谁小先拷贝谁到temp，然后对应子序列下标加1
                temp[t++] = arr[i++];
            }else {
                temp[t++] = arr[j++];
& ~7 }& c0 A) b2 W: O            }
        }


3 V0 ^. P1 ?. f% [$ ]+ j        while(i<=mid){ //将左边剩余元素填充进temp中——左序列有一些数总是比右边的大的数
/ W1 Q7 B# ~* g            temp[t++] = arr[i++];
        }
' T2 h2 f8 K- C1 j- H
) p7 S% V  j1 S( n" }
        while(j<=right){ //将右序列剩余元素填充进temp中——右序列有一些数总是比左边的大的数
            temp[t++] = arr[j++];
        }
( [  X5 V& j0 v5 C3 c; a. Z: x
0 t' X7 a4 a& k/ Q, Z# Q2 b
        t = 0;
: M4 y  f7 _8 H; U" ^2 }# w/ M

4 x; t6 z1 `0 i        //将temp中的元素全部拷贝到原数组中
5 W  j, @& _- q8 b        while(left<=right){
            arr[left++] = temp[t++];
        }

% }7 ^- I& [+ B( _
4 K3 }; A& B! b5 i2 K    }

. P* t) T" Y& L: ~- k/ j
. t7 M, w! Q$ t: b0 j" c2 [+ o}
9 [" {* D  X* _3 }) z1
2
3
7 Q& P6 J- Y/ x, ^2 \& H4
5
6 m: _, w. y" i+ ]4 j6
7
8
9
% U3 ^: R/ j& S' c10
9 P1 D7 ^9 Y  S/ M11
+ \- @8 h  T7 \12
# T( k* k) D% x% r7 I: Y4 w13
' h+ E% x2 R# a3 t) x5 }. }& C14
15
16
17
18
19
20
0 K' W0 D0 {8 ?+ X6 w: D' @4 V21
- v9 x, U* u' e  I- L+ K22
, P0 O" b8 f# a' C6 T- ?23
24
: U* {8 U. M: C; |25
26
27
/ O3 k2 K$ Y# z8 N, P28
29
30
% `0 G/ ?3 j0 k31
32
- x4 l$ ?" ^2 d6 k. D: q3 }0 I33
34
35
6 W/ G7 m; U8 k: k/ t; A. f36
+ G. X0 J/ }9 G( c  {37
38
39
4 `# q9 i- C6 b( Y: P4 l9 z# ~) M40
41
. W) G& L. p! F0 q42
43
44
) d- O/ l- @; j, c1 l9 U6 N" M45
46
) V( l' z2 j4 ^4 x5 a47
48
49
50
51
' U- N8 T, s$ t5 C9 p52
$ b( k$ e* K: z1 A53
54
55
56
57
5 U$ \* L4 E9 P9 ?  d58
1 t1 M3 W7 p, M+ {59
. Q, F) m) e8 q60
: c7 d7 _+ k  P% X61
; @1 p2 h( u" `/ e1 g) V4 ?1 a8 O62
63
2 Y6 @/ m3 C) s64
65
9 p. J1 I* J2 Z! N/ P& @2 V  m8 ~! b66
& w9 v8 @% f+ P/ n6 {* {$ w- _: D67
/ Z/ p% N2 E* e0 D* H5 O8 |1 T68
69
70
( `' k- e& U' {/ \71
9 o4 }. g. x) X4 [  W* F& e5 k72
/ I7 g, T5 T6 E# B( W0 _( s73
插入排序
& ^4 w. T. W) `& g8 h简单解释：
最简单的理解就是打地主时我们拿到牌后的整理过程，从第二个牌（假设我们拿起来这个牌开始比较）开始，（说下升序）从后往前比较如果比前面的那个牌小，就把牌往后移动，直到找到一个合适的位置（这个位置的前面的那个牌不比这个要放下的牌大）就把这个牌放到这个位置，慢慢的前面的部分变得有序，直至全部有序即可。
: G, a# z7 }; T" h! ~: ~, V5 M
5 H; f2 `8 w2 ?" m


4 M5 T+ K: e% q7 `6 c. b

完整代码：

1 B( \8 L8 q$ Z5 k. A5 r5 f
package com.keafmd.Sequence;


3 L( D' w/ F3 m  X/**
* Keafmd
*
+ P' V9 W8 u: b * @ClassName: StraghtInsertSort
* @Description: 插入排序
* @author: 牛哄哄的柯南
* @date: 2021-06-24 10:36
*/
2 [1 f: L& A7 Apublic class StraghtInsertSort {
+ h( a7 V, D+ f  C, u0 _    //插入排序
9 \3 w  ~+ [3 b0 ], ~    public static void straghtInsertSort(int[] arr) {
+ _. F  U( u* l4 D0 d/ W        straghtInsertSort(arr, true);//默认进行升序
. t5 p, l2 L* {# T9 w3 ~  c  m    }
. O7 N6 u2 G0 r& Z$ y/ _
( \7 s5 X* p" s
% d- @2 f2 P$ D) U7 m2 X5 V+ w    public static void straghtInsertSort(int[] arr, boolean ascending) {

6 ^0 B# e7 e9 s+ Z+ I- w! @  m
        for (int i = 1; i < arr.length; i++) {
- F+ {' u' j) w$ c& k            int temp = arr;
, G0 |7 B" \6 \' l7 `            int j=0; //这就是那个合适的位置
            for (j = i - 1; j >= 0 && (ascending ? temp < arr[j] : temp > arr[j]); j--) {
                arr[j + 1] = arr[j];
7 B9 h( b: j+ j# c* F& U) D            }
            //把牌放下，为啥是j+1，
' h8 b& a# K1 d/ b            //是因为上面的循环遍历到不符合情况的时候 j是合适的位置的前面的那个数的位置
            //有点拗口，但是就是这个意思，看图方便理解下
8 P7 d( H; s. c+ Y. z4 ^            arr[j + 1] = temp;

' Y, @4 E# }+ r! \" J8 e
  A; s; P; M: W, _0 g, E
7 ?, D. m9 p0 p
        }
$ z  a6 O: j: s: y+ _
3 q% t: _) h2 @/ z9 c
5 Y( }. N- ]2 }+ r9 G: z0 @. l& \    }
( A7 N3 P1 l7 `4 C+ X}
1
4 k; w' b! F3 x2
( H! p" p' }, R1 A' ^9 `3
# I8 K* p- D2 |: ^& [* r- h4
5
, E* R# |, |- Y; ?, C' K" K0 x6
7
/ p% C1 E* |1 j0 K' @) v8
7 g0 r+ ]5 x' {# f0 D# M5 l9
) p8 Z: ^: \8 C& N4 W. f10
11
3 K- z3 u% V+ g6 P12
13
2 D+ ~! g' w; n) f1 D3 j0 n14
1 k) m6 g+ L1 ?8 m" L) D3 c4 B; ~' ~15
16
17
, v; k+ e- J2 U! K/ A/ h18
; _! P" b7 y  d19
) @. S, a: A6 q; D0 J6 v; ~20
21
22
23
* y& U0 b6 \2 Z. N, W8 l24
6 ]2 q" i0 ~9 M: R, W0 N25
4 ~$ \1 J8 X% |26
2 _( F/ |; A; T1 h& h! u) x/ x27
28
29
5 ^9 A1 T1 W, d2 i. P: ^. N30
31
32
33
34
! I" Q: S# b& J0 Y希尔排序
简单解释：
% g, K! d) W9 K; ~4 \希尔排序是插入排序的改进版，我们理解一个叫做下标差的的东西，也就是下面那个图中的增量d，初始下标差为arr.length/2，然后继续/2，对在同一下标差（相当于把这几个数单独拿出来了）的若干个数进行插入排序即可。
! }% d3 I( h- @
2 m; |* w$ k2 q# e7 u" S$ Y, E
+ W7 ~& v) n. N* `( C5 ?6 M* |
1 R) l% M; v4 [( Q2 m+ P


  q8 V' a) L1 i2 `6 o4 `" `9 X完整代码：


package com.keafmd.Sequence;

0 c# q5 P1 s  r( {7 y% \* u
/**
* Keafmd
*
2 d% W% ^- B0 O( K: I; w2 m2 |7 F * @ClassName: ShellSort
( x6 Z( n6 r. |" O$ N' q * @Description: 希尔排序
* @author: 牛哄哄的柯南
* @. c" ]0 {7 ]2 ?4 \7 ^: E1 F, V * @date: 2021-06-24 10:39
/ n! b" P; k( h */
, r  X+ q/ U0 g2 |6 b# o) cpublic class ShellSort {
) z, T+ q$ ?- S* E6 e  C1 M3 w

    public static void shellSort(int[] arr) {
( E4 t9 L9 U6 s. C1 h0 O        shellSort(arr,true);
, {2 w- `) g" r! \- ?- i    }
! e/ ?7 O0 b; k" x: d) B- _

8 T" m" w/ K* V    public static void shellSort(int[] arr,boolean ascending) {

$ Z. m2 R* I1 N, `$ T9 O) l# f1 q
& J1 N) i% Y  G) _        for(int d = arr.length/2;d>0;d/=2){


            for(int i=d;i< arr.length;i++){
                int temp = arr;
                int j=0;
" i- Z" |5 B0 L/ x1 L6 s- q! I# C4 g                for(j=i-d;j>=0&&(ascending?temp<arr[j]:temp>arr[j]);j-=d){
% i$ C" d* E. c) P" s                    arr[j+d]=arr[j];
                }
                arr[j+d] = temp;
            }
        }
5 N1 ~2 R7 ?1 O
& q- q) m% l4 Y7 D. r. {* `7 W
4 Z/ v4 ?! |9 h5 z/ V3 d    }
}
: q. [  U: _! U8 u+ x$ }$ z& P1
2
3
4
/ Q2 w! Y+ {6 v) r% F% o1 E8 c% V5
0 n; w% {# Z1 x, ], d. I5 K# S6
4 ]' S) {) P# W8 g( e7
8
9
! Q: u9 ]' g5 X4 p1 W& ]10
9 l  `6 d1 \6 k1 d$ W11
" z$ o/ t& i, D1 P3 l- [  ]7 U12
13
14
15
; q* L4 Y+ `  v  @, _4 w16
17
9 P7 v: }' v6 F- f18
19
20
21
: p9 L- Y8 ^% {" M7 G22
+ p. h  a) I; R1 J4 |2 d) ]) H& c23
24
9 g/ j* }9 t3 X0 z& P25
26
: X+ q. r* o. g27
28
/ a) q4 A" z, H$ P; @/ X29
1 Y- n6 ^2 L* X0 x30
31
2 L0 G+ |, ?6 M$ u7 `. w32
5 z* ?" W$ S% b# |' `( \计数排序
简单解释：
: R- @8 Y$ Q& _0 T( }这个排序算法看名字也很好理解，就是就是额外找个数组来计数，然后在这个数组从小到大或从大到小把数取出来即可。


: L! s  N# p  R% A4 K* B) V* e/ U

2 k% i9 R# }; t4 p
: J% W& p! a4 _9 j' `% H4 i
完整代码：
( [! n8 z+ q) X: F# ^5 m
) f3 L- ^2 z9 ~2 W2 i
3 b$ W% Y3 _9 t% k1 B1 @' P) npackage com.keafmd.Sequence;


9 l2 b' ]  M$ @+ _/**
) R, D+ z' z. E  E/ T8 s * Keafmd
( ]- H4 k  g6 a  p6 v6 Y( N *
; r* U6 r' n. U0 G. H* n# l. q) d * @ClassName: CountSort
* @Description: 计数排序
# h  R. T% S; n* a$ o, S; a * @author: 牛哄哄的柯南
* @date: 2021-06-24 11:31
2 l5 F0 M; \5 S# N */
- C3 L! n% `, Rpublic class CountSort {
& M' ?, u5 Y; Y$ x+ U6 R
& M" x. u/ k: j9 ]- n, m+ C% u  @3 P! `
    public static void countSort(int[]arr){
        countSort(arr,true);
4 l6 J$ m1 w; J, W( Z0 z    }

; ^6 c5 |1 R/ c
    public static void countSort(int[]arr,boolean ascending){
        int d,min=arr[0],max=arr[0];
6 i+ |9 m. f6 i, e( X+ C- l

% y/ D, q+ K6 [- o6 n" M2 a        //找出最大、最小值
        for(int i=0;i< arr.length;i++){
            if(arr<min){
# _6 C3 a1 x. g+ [5 o) L                min =arr;
            }
# v  ], p/ U- {            if(arr>max){
                max = arr;
            }
. a* h% Z4 g9 O; z+ P: ]1 I. h        }


: F2 M0 h$ ^* A+ `5 T; Y        //建立一个用于计数的数组
$ ]6 q* m* A% |+ N! j/ e  E# X; H        d = min;
        int[] count_map = new int[max-min+1];
        for(int i=0;i< arr.length;i++){
' h2 S. T' N" }8 g; N! ]2 m. T4 \7 Q            count_map[arr-d]++;
  N4 M# h; y' K        }
$ [) y  W: s" c4 E

        int k =0;
        if(ascending){
            for(int i=0;i< arr.length;){
5 \4 x3 c& w/ V: f- N$ i7 }; k9 Q/ r' O                if(count_map[k]>0){
3 _0 ^1 I' o) p, H+ s6 E                    arr = k+d;
                    i++;
                    count_map[k]--;
! T/ s  D) v/ C6 Y                }else
                    k++;
6 J# e/ j, y  z5 ^$ R) P            }
        }else {
            for(int i=arr.length-1;i>=0;){
                if(count_map[k]>0){
                    arr = k+d;
. B5 v& ~) Y6 {5 }8 |" w                    i--;
                    count_map[k]--;
7 x2 K' ]' O1 j# J1 J  R                }else
                    k++;
0 ~4 D' \6 d' ^$ G; N2 J4 V$ y            }
; c9 w' N3 @* Q; j& Y0 _2 z/ |+ S) K9 @        }


    }
4 P. {6 v0 D8 u0 W}
1
, D7 Y+ A2 m  F. `. E3 g; R6 N" [/ w2
2 v! G- ^2 U" Z3
4
+ L! W+ s- c% v6 [% U2 K0 x5 a% R5
# H0 I  Z7 Y: b6
, p; ^" M9 K+ j& r1 m& s, q7
8
9
9 J0 `# R: Z0 t3 y: [3 U9 K10
11
6 @+ Q; t, d6 J, N4 f12
' {* o" ]$ V' j% i/ X/ F13
14
8 G: t8 e5 s/ [: C15
16
4 S# n1 ]6 ?1 n17
18
' q& O: `, X/ u8 Z- _! x* w19
20
21
22
23
/ `) P# V- R% Y; c24
3 k$ P2 M. i9 o' R! ^25
26
27
3 G" M" O. K/ Z4 ]8 F8 K$ I28
29
1 V- m) H' y! C4 c, w$ S30
31
32
33
- ], n- ]: e- Y. D# Y9 e34
+ m. p2 @/ G4 {3 h3 `. `35
/ i! L( c# l$ {* v) ~) h36
37
% V! s: Z9 l- M. ^- w+ X, z38
; v' r3 \- r4 P2 o39
40
41
42
! J: x, h+ V* A& _- M" `43
4 a5 ^% F+ N8 g: r$ x44
45
46
47
48
8 m! p& q/ A. R4 U0 U49
3 |9 a: T" ~& C7 [! d% x50
51
52
  v' f  a; X) J2 h7 c6 q53
54
55
56
5 }$ v$ M4 h+ r# ^3 d57
7 F- e' T: w) o: b58
59
桶排序
简单解释：
就是把一个数组分成几个桶（其实是几个区间，从小到大或从大到小的几个区间）装，然后让每个桶（区间）有序，然后取出来放一起就可以了，相当于把几个有序的段拿出来放一起，自然还是有序的，当然需要是按照区间的顺序拿了。






完整代码：
6 P, H( i! D1 i" |& w
1 n% ?9 O3 x- h3 ^; \
7 e. c$ s8 A5 L* I% Kpackage com.keafmd.Sequence;
& E' a3 x) `! |. x. [  u. c$ y

4 l7 V! V* G. u+ c5 p3 ^import java.util.ArrayList;
8 U  T3 S9 v3 ?1 R2 [import java.util.Collections;
2 {* j' X) y) e' J" R
- J: D+ I0 ]! J; M" I5 W
8 @/ ^9 `! p7 Y' p: `& G/**
* Keafmd
*
) L6 Z# }* \, w* @2 F0 M$ Y * @ClassName: BucketSort
1 y+ N: C8 A, T: [* m * @Description: 桶排序
* @author: 牛哄哄的柯南
* @date: 2021-06-24 13:32
1 c+ P6 f* N2 o0 }. O) K */
public class BucketSort {
7 W. s7 A5 V7 t% k; r

# }% T4 {" S9 M! u- z    public static void bucketSort(int[] arr){
1 S. ^) r' O" {" ]; ^1 D, e. K3 g        bucketSort(arr,true);
    }
; {- @2 y( [4 j

    public static void bucketSort(int[] arr,boolean ascending){
1 c3 I- o& v8 T# z        if(arr==null||arr.length==0){
            return;
        }
        //计算最大值与最小值
        int max = Integer.MIN_VALUE;
        int min = Integer.MAX_VALUE;
+ z2 Y7 F# Q+ E% _6 `2 ?' L  X        for(int i=0;i<arr.length;i++){
2 t$ f9 u& e1 z4 ~! F- D            max = Math.max(arr,max);
# w2 N, H6 f% P            min = Math.min(arr,min);
9 t; k) P. G7 p# _. D        }
% U+ `# }. g( x- }3 d
( B" v& w" |+ [8 B# [5 `
        //计算桶的数量
        int bucketNUm = (max-min)/ arr.length+1;
2 U$ ^# p9 N' ?: H: F        ArrayList<ArrayList<Integer>> bucketArr = new ArrayList<>(bucketNUm);
- C9 Q, {  \' g1 ]+ U) e4 ^. h. K" ?        for(int i=0;i<bucketNUm;i++){
/ z9 N, d& ~5 b. l: s0 C            bucketArr.add(new ArrayList<>());
        }
5 U  I/ l5 C  Z( B  b1 Q: C: ^
5 F0 H7 O' J# z' N# Z4 N2 F; A1 t
! r5 m, j( ?* W5 P* e0 P3 g9 I8 k/ B" y        //将每个元素放入桶中
        for(int i=0;i<arr.length;i++){
            int num = (arr-min)/ (arr.length);
            bucketArr.get(num).add(arr);
        }

* m: D$ G0 ^( W1 ^  b  `% p
/ s5 C- {7 \2 i" U+ x: S        //对每个桶进行排序
/ [; E# F. j+ d  S7 x/ p  W& ?1 h        for (int i = 0; i < bucketArr.size(); i++) {
            //用系统的排序，速度肯定没话说
% e4 C0 v4 `( Q: Q% ~            Collections.sort(bucketArr.get(i));
        }
2 C0 K0 {) G# U3 c' o

5 s' r0 p. h2 [* G  ^, M        //将桶中元素赋值到原序列
' m# d, B/ G6 e3 P        int index;
        if(ascending){
            index=0;
        }else{
8 |' v6 e- @, o5 K$ a            index=arr.length-1;
7 v' Q: Y- A8 A  j! S) T' P        }


% i1 \3 q/ D/ W- B  g) W; J        for(int i=0;i<bucketArr.size();i++){
            for(int j= 0;j<bucketArr.get(i).size();j++){
                arr[index] = bucketArr.get(i).get(j);
3 y  J# d4 X# C  B' M, v                if(ascending){
                    index++;
9 P2 b& p- g3 }: J                }else{
                    index--;
                }
/ J# J6 N/ f1 H! n" L            }

$ S- x" j& ^( W0 J
        }


    }
}
& N5 c3 @$ w  F% {: B! O( r1
% _4 W6 J1 ]4 O9 ^9 c* S! a) m/ V2
: u  r. `6 c% H0 _0 k7 F2 N3
& [5 f8 n4 x+ @& k# r0 a1 h4 G4
+ U8 a. p9 w4 k7 z; a( F& U9 X5
& {" u( J/ j' o' d- L. _1 ]( D3 }6
" Y5 t& \! B' q" K; {" O7
, X* k9 v3 C+ ^8
9
10
  \3 ~5 y: _  ^3 J7 p11
12
1 H) x* y$ y" F13
14
15
16
9 b( N, t( V3 T! n. L% z; a. T. `17
18
19
20
21
1 s- m7 X2 h) p  ~22
23
! n6 a6 S" b! G7 O24
( v& F. i( r; p8 _25
+ n6 [0 w& ]# d- |4 Q+ X( E( Q26
27
7 P: p( a3 m  h6 X, Q* C% y28
3 }  k! y9 n$ V2 Z0 I7 X29
' Z% l$ Y% v. X1 f6 n) J- v. u30
31
32
33
34
3 I3 D% B2 \# ^' {0 ~' h35
" P/ n! Y. `% M/ Y36
37
1 \& o' d3 v+ C, F% p4 W( X: c+ m38
! e0 i9 p9 P4 R6 {39
40
41
42
43
* r; L9 `2 m. b' Z: S. c( j6 ?4 s44
45
46
5 F9 a3 W* T3 G5 `. o6 Q- v, t47
. C) v5 ]8 C: [. L. i) F0 O48
49
50
51
52
53
54
' [$ D. m2 w% e+ Q0 x55
56
" z; x) K, @7 H9 g# ~* u( w57
' o  @  l2 [( J0 d- q58
* Y8 ~  O7 G! G: @% \' \  O2 ^59
; w! Q3 J- t( K1 t3 P60
61
  H+ T. [; t% U' Y8 U1 _0 D: K* @62
" a+ j; z% ~/ h" u$ W63
' D. k, Q0 A$ y- Z64
) r- m$ P8 F: H2 {8 {& h65
66
4 q% J" W+ b7 M, k67
68
69
70
; g& z; p8 P5 L; K71
72
5 a9 j& `* t; U基数排序
) N6 U. q6 b  ^$ B7 X& d简单解释：
/ i& E- k/ b/ L+ t* M1 X首先说一下，我发现好多人写的基数排序只能排序正整数，其实只要处理下就可以排序含有负数的了，就是我们排序前先把所有的数整体变大（就是减上最小的负数，也就是加了），都变成正数，然后排序好之后，在减下来（加上最小的负数，也就减了）就好了。
基数排序就是按数位排序可分为LSD（从最低位[也就是个位]开始排序）和MSD（从最高位开始排序），下面写的事LSD基数排序。
基数排序就是把数按位考虑，让后我们一位数只能是[0，9]，就是我们在考虑某位（个位、百位· · ·）的时候就只看这个位的数，放到在[0，9]相应的位置，然后顺序取出，最后再按其它位这样操作（上面说了要不从低位开始到高位，要不就是从高位到低位）
; h, X1 m1 b; u7 o% M: Q& _


& h4 l8 ^: L9 Y  x* J

" P! t+ r( ]. T6 k9 ^
完整代码：


package com.keafmd.Sequence;
  y8 D/ J; x! l0 w. G+ ?! j
7 K2 z& y: i7 o0 q$ m; D1 n
/**
$ {/ Z- f7 D6 j0 s * Keafmd
7 U; r) T+ G3 [# K' L4 h *
* @ClassName: RadixSort
* @Description: 基数排序
! a8 o3 }' b4 _; t * @author: 牛哄哄的柯南
4 c! e# ?) p6 m+ Q; V  F0 q * @date: 2021-06-24 14:32
( ~1 i+ @8 H8 b1 C* B; G  r" h8 Z */
public class RadixSort {
    public static void radixSort(int[] arr){
2 \8 h! G4 K7 @5 F1 [        radixSort(arr,true);
2 g8 Q2 z6 ?3 `* {+ }9 z    }
* v- W' v6 o0 N" j# B: }    public static void radixSort(int[]arr,boolean ascending){
        int max = Integer.MIN_VALUE;
" a; n) s3 ]# ?6 Y+ i        int min = Integer.MAX_VALUE;
        //求出最大值、最小值
        for (int i = 0; i < arr.length; i++) {
            max = Math.max(max, arr);
            min = Math.min(min, arr);
. \. c% s4 [! w9 |* N        }
4 ^- b: O; k# \$ f; |        if (min<0) {        //如果最小值小于0，那么把每个数都减去最小值，这样可以保证最小的数是0
            for (int i = 0; i < arr.length; i++) {
                arr -= min;
" h: e2 e7 E& N+ B            }
            max -= min; //max也要处理！
        }
3 M# g; }) e8 Q8 r/ {        //很巧妙求出最大的数有多少位
7 k; n0 ^( i+ A) G, H        int maxLength = (max+"").length();
9 }0 G% K. {9 z9 J1 s+ V( {. Q        int[][] bucket = new int[10][arr.length]; //一个二维数组，一维代表0到9，二维存放符合数
        int[] bucketElementCount = new int[10]; // 用于记录0到9某位存在数字的个数
        for (int i = 0 ,n = 1 ; i < maxLength ; i++,n*=10) { //个位 十位 百位 这样遍历
9 p8 j0 f  P. T; u. l            for (int j = 0; j < arr.length ; j++) {
6 Y7 Q' |' v# \+ K                int value = arr[j]/n % 10;
% K5 x$ r. ], [* J# M) z4 r/ {' B- |                bucket[value][bucketElementCount[value]] = arr[j];
                bucketElementCount[value]++;
3 [- u7 N( ]% `7 J% x  O% S/ D            }
4 B# m; |  j. r
, s# r5 u: C% d  b, x/ F/ @
9 O) ~+ t6 K6 m3 R8 q            //升序
; [& p( T! Q, y$ N* x' `# O            if(ascending) {
                int index = 0;
9 @. K$ ^2 O6 |% A" H                //从左到右，从下到上取出每个数
                for (int j = 0; j < bucketElementCount.length; j++) {
1 ~: k# P% a8 a/ U  l! q                    if (bucketElementCount[j] != 0) {
5 L% `, T1 r' E$ @" K! Q5 I                        for (int k = 0; k < bucketElementCount[j]; k++) {
                            arr[index] = bucket[j][k];
# u4 S! G7 w- a0 U                            index++;
5 z8 Y) |8 u3 z8 M! K                        }
                    }
                    bucketElementCount[j] = 0;
                }
0 u$ f+ R' l) a            }else { // 降序
                int index=0;
                //从右到左，从下到上取出每个数
                for (int j = bucketElementCount.length-1; j >=0; j--) {
                    if (bucketElementCount[j] != 0) {
- t! a, W" {# C) z' _+ @7 R" D4 O                        for (int k = 0; k <bucketElementCount[j]; k++) {
                            arr[index] = bucket[j][k];
                            index++;
9 o, \" D) e( L: e2 B: t% ?. q9 P. h                        }
; S2 D0 y6 i; f1 @5 q  K                    }
; \; H% a6 E9 r7 u+ x% S                    bucketElementCount[j] = 0;
& B& q( W4 G/ R                }
            }

; ^8 n! o. L# B( t
" z5 i9 F6 f( X; J' \

            /*for (int i1 = 0; i1 < arr.length; i1++) {
                System.out.print(arr[i1]+" ");
/ }8 _5 ^3 d7 J0 _7 c* Z  C            }
            System.out.println();*/
) |. s( o- P; n0 B& T; j, k- @" a
9 F! X! n3 ]! ^: y! u: c0 G; [' `6 I9 s! {
4 ?7 C8 L" ?1 T4 w$ I& {

2 T* e; t8 P: u( @( R

- ]& d0 O- w  l5 K1 I1 k2 |. G8 O        }
        if (min<0){
! R6 V8 t1 d% Q% a. Z            for (int i = 0; i < arr.length ; i++) {
5 M! K; A' S% k                arr += min;
( q' d) O) ?$ `" q* a            }
        }
9 _) g; f! @- o8 `" q3 r: v

) y6 h0 }! `0 i8 s8 L+ a$ }) M    }
}
: v  D+ M# B; t1
; v) {; O1 f  |$ e2
3
; Y3 x! N* A% k0 U2 ^! ]4
& h4 O# _, S& p- C& l, Z5
6 ~4 w. V  S" a2 n# b0 p" n6
7
8
9
5 M, y' D; A) ?( N3 i( [10
8 y2 E) K' d, N  a11
12
13
14
15
16
17
18
19
20
21
. d# D0 c* p% r! s2 Z, s3 S22
& V% M' J  m  K1 c; s23
24
9 E$ i5 c( C6 q# E. Z) u25
( p' d* I; w1 q, q$ n! E26
27
28
% I# z+ V7 l* `2 y- s2 w$ S29
& w* Y3 ~+ x4 I30
31
32
33
34
35
$ j) c7 ~+ U. m5 u36
+ p9 ~. O/ E" n- `" ~37
38
39
5 c- p6 ]' Y0 f8 y1 G40
+ r  ^3 W( r) ^8 d3 E- P41
42
# J" P3 F; N  s" \+ J43
44
; y7 F' c: ]5 q; x45
% r/ H+ n/ A3 Q2 z) M( e) s% a46
! \$ ]) X6 g" ]8 f  }/ @47
* Q! u; Y2 S* O# a3 k& a( \48
0 k  \' o3 ]/ ]49
50
9 k& `' |* M6 x7 ^8 ]0 v" }* W51
* r: {+ E) }+ ^& i# C52
53
" m8 N" E$ h0 ?% H54
55
; J+ O4 q* X- ~7 c; w# D) E56
57
5 ]1 m' x0 ^4 s# c" t5 p58
5 L$ U( ]: I& E1 {7 ^+ I2 t59
1 o0 |& G* o8 I$ h% D6 v) p! F% s60
3 g8 q, k2 ~' g$ [61
8 |8 h) g& R9 T  ?9 V62
% @& R* v, z* |4 Z* l' W7 x63
6 a, O" ?3 E1 Z% v- q' `64
* r  i; @2 R9 C( E! I) w# j65
66
67
68
8 ?9 Q6 ~  p7 s( {4 @) _69
- u- @$ {' h4 s7 P  h& [  I70
4 Q' u1 N8 a9 X$ M6 q71
72
/ x5 p6 e+ k! @; P  Z/ d* A73
' m& A: y5 |6 X5 M5 p+ Y& R74
$ a. Q, E, @0 g7 g# ~. Q75
76
77
78
0 u( m5 P& E: s/ }4 M- b8 w79
! B$ S* Y; Y0 G1 H0 a5 O, G: _80
' }- ]$ E* u) O81
82
83
3 R2 w/ [2 ?& G完整测试类
& I. ~! U4 b* T$ _, c" Cpackage com.keafmd.Sequence;
' p5 P; t5 s! J/ \! F: K; D

' c. b4 a9 N9 `7 Z! [import java.util.*;
# P/ J" [0 ?* d! J+ S* y# Dimport java.util.stream.IntStream;
+ @8 a  k% k4 c& O+ w5 m4 Wimport java.util.stream.Stream;


0 ?& Q% ]! ?2 W/**
* @% z2 i' Q: v * Keafmd
. h0 d. D1 R5 A *
- ^5 {+ c: }1 f" M9 t * @ClassName: Sort
# p7 S8 b3 M8 L' _ * @Description: 十大排序算法测试类
# K4 t* m* P; {% |7 ? * @author: 牛哄哄的柯南
* @date: 2021-06-16 21:27
*/
public class Sort {
# |. P+ @+ ?  ~7 ]0 ?4 ]



    public static void main(String[] args) {
; l4 ^) |0 _4 Q, ~. }" [0 }
5 _6 f; I* X# \1 N4 G  P
        int[] nums = {12, 4, 25, 47, 58, 34, 25, 9, 99, 26, 1, -13, 162, 10093, -66, -1};
//        int[] nums = {12, 43,56,42,26,11};
        int[] temparr;
+ s. @% f7 o: [2 p" ~
% |- H1 i5 v  v2 z$ S+ H9 S
        //利用系统Collections.sort方法进行对比


        //将int数组转换为Integer数组
        //1、先将int数组转换为数值流
6 c8 ]+ n- ?! p  [6 y  q6 S/ y  g$ s5 o        temparr = nums.clone();
9 a: E; S- T$ y  C        IntStream stream = Arrays.stream(temparr);
# }$ b* ^( P& \" ]  \  `. ?3 N        //2、流中的元素全部装箱，转换为流 ---->int转为Integer
        Stream<Integer> integerStream = stream.boxed();
. R* P1 h# f) D- l        //3、将流转换为数组
        Integer[] integers = integerStream.toArray(Integer[]::new);
        //把数组转为List
        List<Integer> tempList = new ArrayList<>(Arrays.asList(integers));
        //使用Collections.sort()排序
- u& n7 C" z8 z: T8 C* W! V        System.out.println("使用系统的Collections.sort()的对比:");
0 u% K+ k# c( ]# N/ R% K/ G( z2 r

. j% J) {+ u, M- h1 Z        //Collections.sort
+ @! y9 ^) U, {6 i+ i# a; S( j        Collections.sort(tempList, new Comparator<Integer>() {
            @Override
            public int compare(Integer o1, Integer o2) {
                return o1-o2;
                //return o2-o1;
' a$ F, F$ f; Z            }
        });


        //tempList.sort 也可以排序
0 Y  K! p7 N; E# G$ ~  c* g9 {, f       /* tempList.sort(new Comparator<Integer>() {
            @Override
            public int compare(Integer o1, Integer o2) {
                //return o1-o2;
5 h. F1 M/ _/ g8 G. N                return o2-o1;
& d1 t1 @0 ?/ S% W/ |% y- d            }
$ l! N- Z5 B' p  |( f        });*/
  z& h" W9 c, O) O& Y5 l

+ d3 T/ r) _, _2 V9 L3 I        //遍历输出结果
        for (Integer integer : tempList) {
            System.out.print(integer+" ");
        }
8 u& o3 R% i7 _. o* Y  Y" z

# x: m3 E. V# G3 E        System.out.println();


& M8 p4 ]5 e0 q4 G* [        //测试冒泡排序
) [* C# |5 f6 U. J& t# u# L6 t' ^        System.out.println("测试冒泡排序:");
        temparr = nums.clone();


( V4 w! v, N0 ~6 J, z/ r7 M        BubbleSort.bubbleSort(temparr);
) u) i, @, k+ |- e6 ?% I
0 [! Y5 U  K7 @+ z. ]7 c, o
        //降序
        //BubbleSort.bubbleSort(temparr,false);


$ y0 q( _/ ^4 g, d1 t        for (int i = 0; i < temparr.length; i++) {
0 k6 M- Q8 s9 J            System.out.print(temparr + " ");
, D. z  l  V" G2 ]$ E        }
        System.out.println();
) V' P2 K: ?( J3 `) D
8 y6 \( @( |4 l7 r2 {& Q- T# v) J( M
        //测试快速排序
        System.out.println("测试快速排序:");
2 |: I% t% u) ~9 W! ?3 V( e        temparr = nums.clone();
        QuickSort.quickSort(temparr);
8 Q! U* L! E- z; i        //QuickSort.quickSort(temparr,false);
5 Z! l3 g  h  Y0 C, b        for (int i = 0; i < temparr.length; i++) {
            System.out.print(temparr + " ");
        }
7 B/ ^6 f) ?: o1 S        System.out.println();
4 m1 O5 m+ S7 F; I! ^) |

1 g! c( i' x! u2 h: V        //测试直接选择排序
+ Q. R$ l4 N6 M3 H        System.out.println("测试直接选择排序:");
" `$ F2 c. Q3 i' e* F        temparr = nums.clone();
- |* N8 J$ U) l0 m- K' S% G% T        SelectSort.selectSort(temparr);
        //SelectSort.selectSort(temparr,false);
+ }# y1 I  v1 A0 V  M) ]        for (int i = 0; i < temparr.length; i++) {
! p- S2 m+ Z; T; N8 O9 z2 u            System.out.print(temparr + " ");
        }
6 m5 K! Y" f' b        System.out.println();


        //测试堆排序
        System.out.println("测试堆排序:");
        temparr = nums.clone();
        HeapSort.heapSort(temparr);
4 y3 I. T+ I1 \$ [- J; i3 ]        //HeapSort.heapSort(temparr,false);
        for (int i = 0; i < temparr.length; i++) {
6 k( a# B" p9 z  ?            System.out.print(temparr + " ");
2 s1 h" X# ?, h# S        }
2 A$ b8 N: G" G7 s- V$ U        System.out.println();
' s3 {1 [2 D7 A4 J3 X; f+ C
- A5 c! K/ X+ I: _" k2 C8 f
        //测试归并排序
        System.out.println("测试归并排序:");
        temparr = nums.clone();
' Y1 X" Y, v- \- u4 C! j5 b3 [8 C, c        MergeSort.mergeSort(temparr);
: e" T9 R! m% T  u% o        //MergeSort.mergeSort(temparr,false);
! R- X- d) @4 d8 J# u# [        for (int i = 0; i < temparr.length; i++) {
" z! L; B: t% {/ A            System.out.print(temparr + " ");
# a) D! M) f! A: y' h( G        }
9 d) v" l2 O, b5 i- m, R. `/ f        System.out.println();


3 O9 `! d7 k* ]& s! ]* P        //测试插入排序
; J! G) H; y9 D% U! L' ~        System.out.println("测试插入排序:");
: e5 C( i" s" G3 i        temparr = nums.clone();
- y" P" ?$ m" M% R8 S! C0 r        StraghtInsertSort.straghtInsertSort(temparr);
        //StraghtInsertSort.straghtInsertSort(temparr,false);
! }0 q+ Y& S2 T# V1 p. ]  `2 ^        for (int i = 0; i < temparr.length; i++) {
            System.out.print(temparr + " ");
        }
7 {4 g4 _0 ]: D# b2 A5 S8 `        System.out.println();



  l4 O/ I/ H5 L* Z$ }
        //测试希尔排序
- Y1 m" A' _# _; w/ P; o, D        System.out.println("测试希尔排序:");
  X# F& Z3 e7 E        temparr = nums.clone();
        ShellSort.shellSort(temparr);
) K. K% e0 J% P2 _7 D% x4 L  H        //ShellSort.shellSort(temparr,false);
8 ^1 O& Y% W9 D- u2 ?        for (int i = 0; i < temparr.length; i++) {
  @8 y! Y. e7 _            System.out.print(temparr + " ");
0 v& `: ^! ?; S        }
        System.out.println();

6 n( [  Y+ |- @3 z, l
4 V3 n4 m0 F* U* t

        //测试计数排序
        System.out.println("测试计数排序:");
3 [% I: n2 @9 ]) V) X4 s/ A        temparr = nums.clone();
1 M. q& X2 i  ~& j, f6 W        CountSort.countSort(temparr);
        //CountSort.countSort(temparr,false);
) p  Q* h' _; k        for (int i = 0; i < temparr.length; i++) {
            System.out.print(temparr + " ");
# V6 F( ?" m& K; n        }
        System.out.println();

7 `4 ]- c* b3 M' ]7 {0 c

: e; S/ u+ J8 }5 L
        //测试桶排序
        System.out.println("测试桶排序:");
3 b) n0 g+ \6 |5 x+ c/ ~+ P        temparr = nums.clone();
        BucketSort.bucketSort(temparr);
% Q! Q* L% L9 L2 a9 j/ k! G, E" X        //BucketSort.bucketSort(temparr,false);
        for (int i = 0; i < temparr.length; i++) {
            System.out.print(temparr + " ");
' N4 t1 h$ F3 V2 g4 W! ]. L        }
+ ^# @9 l5 ^$ w5 ^5 S" c: _, w        System.out.println();


/ z3 m4 @8 i' k" N1 f        //测试基数排序
        System.out.println("测试基数排序:");
! @+ @/ M8 u  T% x8 k  F! r8 f        temparr = nums.clone();
        RadixSort.radixSort(temparr);
. H* R' V+ J! O        //RadixSort.radixSort(temparr,false);
        for (int i = 0; i < temparr.length; i++) {
            System.out.print(temparr + " ");
        }
        System.out.println();
# _; V- t! R$ U/ o2 ?/ A

3 w' ?; I3 e) w1 e' V7 `; B    }

1 p2 \1 B, U+ r0 _# d" P( l
, j' x; n& C" c- U}
1
' J' Y9 \) S4 v2
3
2 Q1 f% i" A, u$ l! f5 ~4
& E1 }) b( P. y- I1 Z# s( E5
6
7
/ ]% J# E  F5 i9 t8
9
10
* p; W6 K6 n0 Y+ D  U) H; U11
12
7 e; R" m. s" }- Y0 D. n. |13
14
+ x) n* `& I0 o15
: ?6 O9 j. }. }$ Y8 R1 X# x" F7 S16
$ W* G8 {' V0 j2 T( f! ]17
18
+ ^& h$ g  T2 w4 n) O2 S: w19
3 A* U& e/ L8 ~, t20
21
22
" b; ?# @5 H6 L: Q+ ~23
24
25
26
27
28
0 p0 v( q$ n* m3 a% E* [- C29
1 l- s4 U9 S4 M" P% T: P3 f* c9 {30
31
32
6 V1 P' ?6 b1 L1 Y33
34
35
36
: Z- d! D2 ?0 l4 W- v/ Y37
2 i- U8 T1 p0 K( j1 ?3 S' E38
& C- I$ |1 @' n( T- S* K39
- w; v* O% }4 Z. s40
41
3 e3 a  f9 G7 K2 y+ Y0 V( t& \# Y- l42
43
44
4 d- h  }! `( `6 O( g45
46
, [' l% c9 ~% P: ^$ Y0 F( z47
48
# q7 P2 |' M( a49
50
& u+ W$ i, @9 t: q51
52
  X( H% Q* m. d+ g2 B  ]* h53
# T' G6 [  f. J/ T1 X5 T% D54
" J, j- I$ Q4 x- t& K7 m) v55
7 x( @1 A; B. M! r+ I' K56
57
) S5 `8 P0 q0 N+ h+ G58
* v8 A9 z/ i9 d59
60
61
( K! b* S; g# E/ l  z! s8 T62
4 w& q- ?1 o0 Q1 T! s63
64
65
66
67
68
: f6 V+ G) F+ l2 S6 N4 ]69
70
: W( ^" V) B  u# E( h5 g" B1 k71
72
73
74
75
76
6 b% H. d: }3 ~$ b/ X4 y( F77
/ y  d" ~6 C2 m' P2 H6 J78
79
, ^; C2 s, R  ]& u- P% \80
81
82
7 r/ W. s8 u  o7 ]8 I# a, d8 f4 _% a# g, s83
3 P- z& ^2 p4 k4 B! Y3 \" d84
85
1 }; e: h: C& |" _6 q86
87
* L" Y' J, W" S) P; f88
89
( D5 j$ G1 M" |90
6 ?3 }  ~& E/ U* v" f7 `91
4 C7 [1 w/ o7 {3 x" `" z92
93
2 \: h" O* C# o8 o! ?* h8 ]! C94
. f5 F' X$ Z* o4 e" h1 T. s3 r95
7 @# T# M% U1 {96
" e9 c! f5 ?9 h7 N+ E97
98
- Y. ?- Y; j- Y2 R3 W) k" V( O99
( l; A+ p) \! Y3 k$ A# p, S) c100
101
  x9 o5 n! f* F4 I102
103
1 V8 _, X* x9 ?3 p% P/ _: p) |104
/ S: K' L3 f1 z8 R105
106
107
108
5 y- D8 I/ C" O9 B' [109
, I2 V8 ~* L1 ]+ k; [110
* j7 w/ K- X/ N& x* |, p111
5 l* r. q$ j5 h, z9 v. X4 V112
+ p1 K( @4 G! M* Y; a# M% ~113
: u: j" P) H) D( R6 s0 V) d114
& A- A$ I4 Q$ H! `  ~3 i# }115
7 a! Y$ {4 |# q# I' z116
: o4 P# m3 r+ t: k) d0 @117
' \0 \8 u: S- Y118
119
$ F$ Y- r: Z5 V120
121
+ i5 I" b% ~4 N- P6 p122
123
124
125
126
& M, W* S) Q$ _/ |4 C. n) L! N8 B127
128
* o6 r7 O$ ~9 u  m4 X1 Y2 \129
7 D; t6 Z6 T" f130
131
) v; E& ]' A6 o132
1 [! T. P2 `& o) W7 m/ ~! I, I9 h; q133
6 {+ L6 J* k8 Z" k+ Y134
4 [  p6 X8 r2 N1 ~3 ~135
136
5 ]& n* C* ]* j% X137
138
139
7 `9 B3 n3 J5 p1 U3 R1 N3 X- X140
  X  a& W8 E% g  `1 c141
9 `) ~1 f& q; h, o, B6 D142
+ J$ L, C' [+ Z& M/ q0 ]143
144
145
146
1 Y8 H; X- R/ i! _5 j3 V3 R147
+ [4 c$ s9 P/ e6 K148
149
: E6 E4 B) C0 r* a1 E) w150
) f" T' |/ U6 N* X9 D151
152
8 @& B2 t  f5 R/ T- F* B* A# q153
2 ?2 X3 \* A) P) ^& C- H1 H4 c154
% t! W) S* Q6 ?; B% D0 o) e155
156
157
158
159
" A. G) Y) ^6 i$ y* c& t160
( q+ s9 u, H2 V4 A9 S( `161
% w2 X1 E$ U' p2 b8 M8 s% K162
163
164
165
6 Y' v2 u, g/ `0 c166
167
168
169
170
171
$ C5 G7 e) m7 u  P172
173
) M' H. N) k! c9 k  G* q每天进步一点点！
不进则退！
% ~' C' R, a1 f' E2 B' l

# H8 k8 d2 @, H* G版权声明：
) ~, l6 z* V; A' U* ^原创博主：牛哄哄的柯南
1 X  t9 D! _! \# }* b3 ~1 p; G# p: d博主原文链接：https://keafmd.blog.csdn.net/
————————————————
版权声明：本文为CSDN博主「牛哄哄的柯南」的原创文章，遵循CC 4.0 BY-SA版权协议，转载请附上原文出处链接及本声明。
5 k- K" h- l) Z6 m, \! _/ d7 E5 R原文链接：https://blog.csdn.net/weixin_43883917/article/details/118193663
- ^0 U" I+ [' g3 p$ U- y/ [6 ?

1051373629

每天进步一点点！