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

杨利霞

经典十大排序算法（含升序降序，基数排序含负数排序）【Java版完整代码】【建议收藏系列】
经典十大排序算法【Java版完整代码】
写在前面的话
十大排序算法对比
冒泡排序
% i8 n" h8 M9 J/ {8 h! A快速排序
, p+ {) S" r. T6 l$ I2 i; M直接选择排序
堆排序
5 [3 M* a6 |4 e2 k' B归并排序
插入排序
5 `0 R6 c5 J. A; I1 r希尔排序
, t5 J+ P6 Z8 n' {- i; h计数排序
& L( N1 w# O! h" a1 U桶排序
基数排序
完整测试类
. [5 Y* O% c0 f写在前面的话
       虽然已经有很多人总结过这十大排序算法，优秀的文章也不少，但是Java完整版的好像不多，还存在某些文章代码存在错误的情况，同时也为了自己练手，决定把所有的写一遍巩固下，同时也真诚的希望阅读到这篇文章的小伙伴们可以自己去从头敲一遍，不要粘贴复制！希望我的文章对你有所帮助，每天进步一点点！！！


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

) \' f7 ]$ O2 [  u6 K+ Q
十大排序算法对比
+ i" M$ q( ^' R$ x

/ P/ H2 z+ S" c8 S3 ^4 d
5 q3 m4 T8 S6 s
关于最后一列的稳定性，我稍微解释下，例如对序列：1 2 4 2 6 排序，序列中存在两个2，如果我们把这两个2标记上（让他俩不同），排序之后，前面的2还在前面，那么就称这种排序是稳定的，反之不稳定。
2 d4 ?  C% N7 c; n" B$ [# z
1 ]2 X. k9 W. b2 G* g( X
7 s+ K; s5 F2 `+ h/ J冒泡排序
简单解释：
9 H, B8 R6 e( `1 Q, y+ H4 z       原理就如算法名字一样，就像水中的气泡一样，每次我都把最大的或最小的放到最后面，这样总共需要n-1趟即可完成排序，这就是第一层循环，第二次循环就是遍历未被固定的那些数（理解成数组左边的数，因为每层循环都会把最大或最小的数升到最右边固定起来，下次就不遍历这些数了），两层循环遍历结束后，所有的数就排好序了。
7 W$ h0 ]& J% m9 y* Y7 b* r       两层循环所以冒泡排序算法的时间复杂度是O(n 2 n^{2}n
/ h' }* E1 N/ Y3 e8 ^! W2
)，是一个非常高的时间复杂度，我在下面的代码进行了优化，加了一个标志位，如果上一次循环未发生交换，就说明已经是有序的了，就不继续下去了，反之继续进行下一轮。
9 u9 ]4 Q, X% Y) T+ \" {




  }. g  U% I6 i2 i) Q1 R. {# F
& k# v, U$ ]/ j5 |本文的图片来源网络，仅用于大家学习，侵权联系删除！（下同）
" d# Q5 H; i* e* ~: A9 v0 k6 X* Z# b

完整代码：
7 j$ z* j, F* _7 j, i# {3 Z

$ A  A; j, G+ f+ npackage com.keafmd.Sequence;
* P. }: A' I$ l! Z' [$ R+ d
! U4 V' {- I+ Q  p: [1 h! O+ r
: a+ V/ A: I% ?+ d& y$ l/**
3 v2 l$ d4 r$ m5 w  l4 l * Keafmd
*
0 H. k; x) ^4 D/ V" I * @ClassName: BubbleSort
* @Description: 冒泡排序
5 h( H; m2 R7 Y6 X! B- M * @author: 牛哄哄的柯南
* @date: 2021-06-24 10:31
*/
; ]2 D- j, a+ t: kpublic class BubbleSort {


. F" ?0 B# F0 o- {( F/ M" x$ Y    //冒泡排序
$ t3 A: h0 \. s, t    public static void bubbleSort(int[] arr, boolean ascending) { //exchange标志表示为升序排序还是降序排序
3 `" t' V7 v( w) u9 m! @

' g  D0 U, ]* A/ B5 z7 v4 }        boolean flag = true; //加一个标志位，记录上一次是否发生了交换，如果是，我们则进行下一轮，如果没有，说明已经冒泡好了
  j, ]* M* }8 K

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

! B( u5 ^) y) v            /*System.out.print("第"+i+"次遍历：");
            for (int i1 : arr) {
                System.out.print(i1+" ");
            }
4 G# r' I- Z! r            System.out.println();*/
, o9 n( x* _% ]1 G- e

            flag = false; //假定未交换

5 v9 ?0 N( H% o: g0 I
7 f* C8 ^6 ^" ?+ d            for (int j = 0; j < arr.length - i; j++) {

  Q  q( {( d& H
                if (ascending ? arr[j] > arr[j + 1] : arr[j] < arr[j + 1]) { //控制升序还是降序
                    int temp = arr[j];
; ~' R" w( _: ]' m% e- `3 r                    arr[j] = arr[j + 1];
                    arr[j + 1] = temp;
4 j6 t6 f2 b  u: {) i/ L6 |                    flag = true;
) w" P& h8 y$ q$ k8 q                }
" V% n0 g8 T& R) A) D9 ?: U7 c8 P7 c
4 |( e. L! J6 f$ f9 R2 l5 x* N) `
" y  s# }0 {8 F' l& b# ]            }
/ N1 k; M; {# X! g4 D* K/ J        }
    }
1 v5 b! i9 C: X6 o5 p+ ?

5 \7 Q6 S. }* _$ L' M0 k. c5 U    //冒泡排序 -- 默认不传参升序
    public static void bubbleSort(int[] arr) {
7 c4 K2 R& u' d  f. W* C        bubbleSort(arr, true);
    }
}
1
6 m( R' e9 _* p' c) G1 g* @2
3
4
* k1 j# l2 u2 p! u3 K6 y( o! h5 J5
6
7
  z/ O$ \  u  Z' P* b8
3 I* v  W& X! G" `+ ]2 z9
10
11
12
$ W" f9 H7 O, R  S) J13
14
% f! f7 t8 ^9 ]9 X  ^! d15
' r9 R! B7 L* _16
17
18
19
20
. n' ]$ p! l( y% B# ^  G21
% e3 ?& f2 D* ?' |, g! o1 r- E7 F' P2 j# I22
- r: q: `+ Z% t' f5 Z' P23
24
25
! y; {* x8 ^3 B( o26
27
28
: Y1 G7 E% M  a. s29
30
31
9 S! |' t  x( G  i32
4 D* c- N- S1 o9 A1 X6 {; l33
: a- _& W% @6 ]2 f. X3 ^9 I34
35
36
8 E7 o  z5 ?  l) f: e37
  f8 v( i* Y& o, J3 x; f38
39
5 z7 k# v7 U5 ?6 T) C9 j40
$ r9 f( R' s! J$ q2 U  y+ j41
42
; }; a( y6 a4 c; l8 A43
44
- o7 t' t! U$ i/ R9 R45
测试代码：


1 F" A" {: h0 W! a. B5 b2 D: d升序排序（从小到大）
- `& d  {" z# _/ V

: X6 O- K9 F9 A: v, \& J, P, Ypackage com.keafmd.Sequence;
7 h7 L, Z+ N/ l! w( A: k0 n6 M

import java.util.*;
import java.util.stream.IntStream;
import java.util.stream.Stream;

! w) A8 k. }' y' \% |
* s- i. I( T( f/**
7 e; O, m* o% n7 S6 Y% f+ J * Keafmd
*
8 L8 [# i7 Q4 y4 Y0 k1 n * @ClassName: Sort
* @Description: 十大排序算法
* @author: 牛哄哄的柯南
* @date: 2021-06-16 21:27
" Y* ?0 {5 \; B/ V! N */
. f6 z+ z2 ~# R1 v8 apublic class Sort {
. Y+ @' l( v- ?5 ^# p  d0 Q1 k: O    public static void main(String[] args) {

5 }& ^& {6 X* Z1 q) m# W/ X; w( i) e7 d
# R2 V9 {7 B+ q3 p& J+ v. t4 j. g        int[] nums = {12, 4, 25, 47, 58, 34, 25, 9, 99, 26, 1, -13, 162, 10093, -66, -1};
7 N$ m/ V, {; e        int[] temparr;


0 I% M+ s; b* r( M/ R. x& z3 |        //测试冒泡排序
& S7 O- }' i- G        System.out.println("测试冒泡排序:");
        temparr = nums.clone();
# G5 O- i! ~/ I( S, H7 d6 F# a        BubbleSort.bubbleSort(temparr);
        //逆序排序
. ]# ]8 Q' b5 i& x        //BubbleSort.bubbleSort(temparr,false);
4 b& @, v* m2 L) @        for (int i = 0; i < temparr.length; i++) {
            System.out.print(temparr + " ");
' Q; c6 m4 D4 _& Z; _6 S$ u8 S        }
        System.out.println();

& b) G2 q6 \( U5 G
3 j; U: e" v4 }8 o/ D& G    }
}
1
. L: Q/ g% O. ]3 K2
3
3 ?1 r) A9 F" {2 g) p4
5
2 t& R/ l/ e5 p0 E  S% g6
/ j1 S( S5 d1 D3 q7
( ]4 k9 o% W* v9 X8
( ^1 }0 P& L( k7 e+ F! o/ _9
10
6 f( E+ ^+ ?; O! p11
. J# P/ z) S. K6 {% i+ z1 k% v- E12
13
14
( p, [. \# O7 I6 P15
8 e9 ?$ F# m. I0 f5 [5 P0 W( f16
17
18
19
& \/ x! {; L, m6 Z9 E20
21
22
4 t$ Z. u: x7 N8 y3 e  M2 H/ r1 D23
24
25
26
27
) \; X0 D7 u0 w' ^28
29
5 c3 n8 \5 C! _  v8 e0 u' m30
+ P2 y6 Y8 _4 D8 q  N' x$ l0 m31
32
' j9 _% Q  K" I! R33
运行结果：


! Z% q" U% S( s测试冒泡排序:
, J& q, e5 P, x) c7 g3 _! t1 O1 t-66 -13 -1 1 4 9 12 25 25 26 34 47 58 99 162 10093
1
2
; b/ _) G; x/ j6 @降序排序（从大到小）
+ J3 E, d8 T  v) s& d
1 S* q# w( E; N$ l
4 Q" e& I, u1 S! i//测试冒泡排序
! E. l* N3 W" j' K% D/ G0 dSystem.out.println("测试冒泡排序:");
  z8 ~7 T$ J2 Ftemparr = nums.clone();
BubbleSort.bubbleSort(temparr,false);
6 |9 q0 x2 t6 n  s% ^8 Tfor (int i = 0; i < temparr.length; i++) {
( A. q: m0 v) i# R0 o0 L, ?& M    System.out.print(temparr + " ");
}
6 k/ v3 Q' I: z, @- eSystem.out.println();
1
/ e: H  O9 N! |7 ]; L8 F) }7 P2
0 N6 ~/ s# m" c- r# @4 q+ D2 w3
4
5
6
7
3 D( k) R2 ?; W: Q' ?, ^8
5 U; J) M  O& x" V* z; }; ?运行结果：
6 |4 u$ ?. |3 e+ ?# F7 j

' F7 p$ y& q! W6 H  ~  X# b测试冒泡排序:
10093 162 99 58 47 34 26 25 25 12 9 4 1 -1 -13 -66
1
2
5 f! A, K- z; w( @6 ^+ Q下面几个算法的测试也就是换了下类名和方法名（换成相应的排序算法），如果想降序就在数组后面传个false即可。我就不一一复制了，我在最下面给出含所有算法的测试类，需要的自取即可。


+ {, e7 T4 o" y* k% s快速排序
1 {- \, |" e$ O' g+ s简单解释：
: N3 I3 g* M4 G+ o) ~快速排序就是每次找一个基点（第一个元素），然后两个哨兵，一个从最前面往后走，一个从最后面往前面走，如果后面那个哨兵找到了一个比基点大的数停下来，前面那个哨兵找到比基点大的数停下来，然后交换两个哨兵找到的数，如果找不到最后两个哨兵就会碰到一起就结束，最后交换基点和哨兵相遇的地方的元素，然后就将一个序列分为比基点小的一部分和比基点大的一部分，然后递归左半部分和右半部分，最后的结果就是有序的了。
/ `. K# X  E5 H) ?3 g


! ~4 f' B7 a- {/ C

" F! V1 W, S& X9 _
" I0 Z& s) m8 |: U5 _/ _! ^1 [) L完整代码：

7 ?9 ?% h. L, I/ B0 p
9 Q; h: _, A- x1 Q' T9 z. opackage com.keafmd.Sequence;


! {% Z8 B7 J. d0 p' v/**
* Keafmd
*
* @ClassName: QuickSort
* ~& l' T/ f" H& H/ V( h * @Description: 快速排序
* @author: 牛哄哄的柯南
$ ~( w# I# L' [- N; \" G * @date: 2021-06-24 10:32
/ q; z# y" }3 |9 t8 g" h */
! m/ S7 b$ Q/ `: ~* Ypublic class QuickSort {


    //快速排序
    public static void quickSort(int[] arr) {
8 K0 D. \4 r7 H6 ^1 q        quickSort(arr, true);
; b" c9 }' T" D9 d; M9 Z" }2 a" J    }
- s  W- C  v+ i$ n
) a! `+ v& {1 q  x" Z
' E1 z3 [6 `# |1 K7 `2 G    public static void quickSort(int[] arr, boolean ascending) {
' J5 r* o% U, o        if (ascending) {
            quickSort(arr, 0, arr.length - 1, true);
        } else {
            quickSort(arr, 0, arr.length - 1, false);
        }
    }
5 N  }1 i" K2 R3 b3 X
/ j( g0 t3 z. T. P# J
8 m/ u& H5 L; m8 a    public static void quickSort(int[] arr, int begin, int end, boolean ascending) {
$ K7 Z& ~# j$ l0 r# L        if (ascending)
4 }6 m# @# {2 ^& ^6 B- j: }            quickSort(arr, begin, end);
        else
            quickSortDescending(arr, begin, end);
    }

& y4 x2 @3 q. v+ [, i" d) Q
    //快排序升序 -- 默认
) m1 h! s- A) o    public static void quickSort(int[] arr, int begin, int end) {
- }0 ?  @. Z  ~        if (begin > end) { //结束条件
' _! |/ U, U3 T3 x. K: j" B            return;
        }
        int base = arr[begin];
, J- [( x: q5 R/ }  M3 y6 X        int i = begin, j = end;
        while (i < j) { // 两个哨兵（i左边，j右边）没有相遇
            while (arr[j] >= base && i < j) { //哨兵j没找到比base小的
                j--;
4 `( L8 y; Z& _7 u1 E; J8 h            }
! U4 e. \) H3 ^3 o* l8 G            while (arr <= base && i < j) { //哨兵i没找到比base大的
                i++;
            }
            if (i < j) { //如果满足条件则交换
+ d0 N+ w# v: u8 q" r7 G                int temp = arr;
! e0 C) j$ T! h% Q4 y; Z7 T* U                arr = arr[j];
                arr[j] = temp;
5 C! K" ]" d0 a4 r8 F- C+ `" q6 L            }
1 \3 C# I  H( t. r% _* J/ P

        }
        //最后将基准为与i和j相等位置的数字交换
        arr[begin] = arr;
        arr = base;
7 m1 j8 |6 S9 G$ U( D5 c6 |        quickSort(arr, begin, i - 1); //递归调用左半数组
        quickSort(arr, i + 1, end); //递归调用右半数组

$ Z. v5 u% u5 S7 ]
0 ^" J) i" V8 s" [    }
' r' W- ]( r" w7 p0 ^' m
( J! h) m& d, m. q, Z
3 g, `3 K) K9 j% {    //快排序降序
* }. A3 M) B( ~: [" X- w9 Y  R    public static void quickSortDescending(int[] arr, int begin, int end) {
9 L- s6 V$ i; h  E  w9 }        if (begin > end) { //结束条件
* l" Q4 j: Y' f6 S            return;
        }
        int base = arr[begin];
        int i = begin, j = end;
& x5 L1 b$ E! _6 u2 j8 m        while (i < j) { // 两个哨兵（i左边，j右边）没有相遇
            while (arr[j] <= base && i < j) { //哨兵j没找到比base大的
                j--;
' j. u; m5 @  t, Y* E( O            }
            while (arr >= base && i < j) { //哨兵i没找到比base小的
2 t/ Z- g. f4 v$ X" R) q                i++;
7 A+ [$ [# c0 S) l% W$ o  B            }
            if (i < j) { //如果满足条件则交换
# b/ j0 |" m# N1 }                int temp = arr;
                arr = arr[j];
                arr[j] = temp;
            }
# e- x5 o& t% R* t; }) W
$ @. Y' ], I# V6 L
( u0 @1 h2 ^8 I        }
1 E# E& d) U7 ?$ R' H+ \7 g7 S        //最后将基准为与i和j相等位置的数字交换
" W4 O0 Q8 G- t3 ^        arr[begin] = arr;
' t8 b1 I! V# h/ e        arr = base;
        quickSortDescending(arr, begin, i - 1); //递归调用左半数组
4 _$ T7 f  _2 l! A3 t7 N        quickSortDescending(arr, i + 1, end); //递归调用右半数组

& h# J4 `2 y. s5 E4 \
    }


}
1
2
3
  a9 F9 p* Q7 R5 t4
6 r7 g8 T  |! ~8 q% Z- X# H5
6
7
8
9
0 g3 ]. S9 @8 Z10
' H' O" o4 b5 x7 i11
12
3 L. n  M, A6 ]& N& R& @( x13
9 E2 G( {5 g' W# l) u. t3 r% u. v14
8 m5 \( M) q+ k0 e" N' W* B5 X7 R15
7 h% U1 [" W9 U  G; p% v1 G16
17
18
19
20
$ f4 u& }: y# b8 z$ x5 Q" q) _* g21
22
23
24
25
/ n6 g0 l% _' [6 F* L26
27
0 N- ~! P! O  L0 O3 f28
29
30
; ~) v# ^# E( A6 S: a31
- m8 M/ I, }  x8 l* ?6 W4 `32
7 \) u; @. x8 L) A. K33
, F4 e) s4 X! ^! |34
35
+ d5 U6 |+ m, F% x2 o9 U9 n1 U36
37
" b$ k% |% c2 l; s0 @5 v  a& L1 [38
39
' S/ L9 m) T# E2 K. z6 a$ z40
41
42
  \% [3 N. n) I: [! j* g43
5 s) ^( K8 l3 `# n# I44
  D% |4 r9 R2 ~3 o2 M( t45
8 h0 q2 s; Y0 p: [46
, J$ k- C/ X9 c( p& w' C/ y47
48
49
5 _& C5 G) S: P2 M& }9 M1 L50
51
- l3 `% |7 e' K& u2 l' a3 a" n  c52
53
54
55
5 J- O; R) L2 Z7 n2 y56
57
2 `+ r. n& S$ r2 a( }58
0 A! U* W7 f1 e& q2 w+ r, t59
" ?7 A7 g: p, y60
! [/ G& x# n, ~) g7 p61
- T9 e1 \5 P  \8 v2 A+ M62
63
64
65
66
1 E: [7 R: e2 F/ p* I+ C& S67
/ W2 l" O& \' u& T4 O68
69
, Y5 R: ^1 L$ f+ s9 ^6 A1 L9 G+ d70
71
' ]- m# a4 l& b5 J$ G& I72
1 ~& g6 y, Y7 c7 B73
8 o% Y9 e; {* _+ u# h4 \- V74
$ G; V7 S/ N* q6 H$ V75
76
' ?6 I& d! b2 D( n) Z77
78
6 b$ w$ B/ ?* N3 h6 k: `4 j79
80
81
82
: O/ W1 q& c  x. k% K4 Q" }83
& `  w" K9 i& I, q0 a8 u84
85
$ r/ X4 H3 l- B3 i  [86
87
88
9 n6 @- k) e3 H- ]' z/ {89
90
# F, Y% R  ^) b; W91
直接选择排序
  F2 V3 |6 m; a+ H1 h简单解释：
数组分为已排序部分（前面）和待排序序列（后面）
第一次肯定所有的数都是待排序的
从待排序的序列中找到最大或最小的那个元素，放到前面的已排序部分，然后一直找，不断缩小待排序的范围，直到所有的数都是已排序的了
% A1 R9 K2 r: U6 a( G/ O
1 Z- M  h! i1 R1 r* q! L! {# u
- t# t  [/ o8 w' T) u
) Q# k( j0 @% v6 O/ v2 x


完整代码：

) ], [3 h0 h- F" S. T
; w8 E' \; O* U( t+ I) T- n4 fpackage com.keafmd.Sequence;


/**
, W4 u( u; J; c- D  s * Keafmd
*
* @ClassName: SelectSort
1 Q/ \$ ]+ N% m  q1 t8 i7 p" G" @ * @Description: 选择排序
4 w& \9 a3 [/ a  W * @author: 牛哄哄的柯南
* @date: 2021-06-24 10:33
*/
public class SelectSort {
. h# [% i0 r1 m* i  J! F& b
4 x# ?& B# A' b4 A2 d
    //直接选择排序
    public static void selectSort(int[] arr, boolean ascending) {
+ H! z. @6 N" q/ d        for (int i = 0; i < arr.length; i++) {
            int m = i; //最小值或最小值的下标
            for (int j = i + 1; j < arr.length; j++) {
) W9 @' C4 e" x4 _/ B6 }! ]                if (ascending ? arr[j] < arr[m] : arr[j] > arr[m]) {
                    m = j; //找到待排序的数中最小或最大的那个数，记录下标
                }


            }
            //交换位置
5 _( u- V# ]/ o/ q( q) H' |            int temp = arr;
, `$ w) X) b2 n$ D. B4 T            arr = arr[m];
            arr[m] = temp;
1 p. @, T  [4 e7 b1 o* G

        }
    }
; j* y  P2 M4 c: x4 [- R
/ R; p. k6 v" ~6 R* ?
. M) U& @1 k2 I+ W8 E& C2 L    public static void selectSort(int[] arr) {
6 ?. c7 m1 N# s* n$ I# o, f! h) M9 E        selectSort(arr, true);
3 p7 a9 j+ e0 m; E  Y' ~' N    }
; F7 n& ^' D6 \/ O}
1
2
3
. y$ w0 _5 i: s1 M+ d$ V4
5
6
& r# j0 b3 d6 D" M" ]7
8
/ _$ [0 S9 M% L' O( J( c9
10
6 @+ r3 v8 @" ^$ s5 j4 c. G: ~11
12
/ O: A, }3 N2 |  ?; p) M3 p. U% L% {. D0 i13
14
' _$ H( g2 m! Y2 `% H0 N9 d15
1 g( w% }" q) c% M16
* ]) B/ R7 I: o5 H. J7 U17
18
19
* {0 ]" y$ c9 j& a- ]5 w$ c, j20
7 b8 }: @/ [" J# ^) E# y21
22
, E2 u/ v1 W+ \8 G0 _; m8 V23
24
25
9 [& ~; a' U% A. V5 a; m! w/ H# k26
27
28
8 X/ e7 ?* P+ ^7 j, r, Q& W7 X  s( d29
30
* B" O2 M: V+ d31
/ j6 q5 }! X, D. K32
33
34
堆排序
' t9 v" ~5 s% T2 N先理解下大顶堆和小顶堆，看图
大顶堆，双亲结点的值比每一个孩子结点的值都要大。根结点值最大
小顶堆，双亲结点的值比每一个孩子结点的值都要小。根结点值最小


6 T: j$ t- c& {
3 M: N  n8 @( @0 ^) T
3 @2 d# D& f! q* \" Z+ P0 k- p4 Z简单解释：
+ V9 q, x* L& ?' J构建好大顶堆或小顶堆结构，这样最上面的就是最大值或最小值，那么我们取出堆顶元素，然后重新构建结构，一直取，一直重新构建，那么最后达到排序的效果了。

* w  f; C, s" `; U9 ^2 B3 y" e) y

" B5 R, g; R" T  m# e

+ r+ ]) {7 _! ?
完整代码：


' A. l' n# d2 _5 u# o5 j1 A+ kpackage com.keafmd.Sequence;
5 k6 D: x9 h! z& @: c) a
( E, p4 B' x/ S5 Y3 L
/**
) w0 s4 H0 k  X+ ` * Keafmd
( D) h6 p1 ^( C/ f *
* @ClassName: HeapSort
* F7 W0 ?6 U% f( E) v * @Description: 堆排序
7 T7 h( G8 Z/ J, _- n6 Z: ` * @author: 牛哄哄的柯南
* @date: 2021-06-24 10:34
*/
& ^# L9 _$ p5 [2 [% g, h+ r0 Rpublic class HeapSort {
- q$ {! w; h' H" w. r( D$ V7 q+ l2 D

; u" z$ V$ t+ W, f3 U3 x    //堆排序
    public static void heapSort(int[] arr) {
0 [$ W! F. }! ~; j, T5 L! C        //对传入的数组进行建立堆，这里默认建立大顶堆，进行升序排列
" R4 {5 G9 R+ A9 b( k* D- U        heapSort(arr, true);
    }

. F" ~; R- N) A0 p, C4 k
    public static void heapSort(int[] arr, boolean maxheap) {

5 ?/ P0 B! a7 O9 d2 M: F+ q- |
" s8 `' c( ]4 x0 d* \2 q        //1.构建大顶堆
# d$ d& }1 \# u+ C/ y        for (int i = arr.length / 2 - 1; i >= 0; i--) {
            //从第一个非叶子结点从下至上，从右至左调整结构
            sift(arr, i, arr.length , maxheap);
, l: ^  b4 Q; {% U  C; {) r# w! K0 i        }
6 i( ]7 p/ D" |5 Y
. M+ O. T$ u$ T$ s) N
        //2.调整堆结构+交换堆顶元素与末尾元素
        for (int j = arr.length - 1; j > 0; j--) {

+ B! s  M% s/ W2 b
            //现在的数组第一个就是根结点，最小值所在，进行交换，把它放到最右边
( J) j. F7 c( W8 U4 z9 s3 W            int temp = arr[j];
) L# R7 v' r: [, e9 I            arr[j] = arr[0];
; h+ {. n" a& p7 t0 u2 N4 I  Q2 `            arr[0] = temp;
- [$ N( q7 N: b

% ?6 M% o+ y" Y3 C  X5 y/ `4 N& e' u! c            //重新建立堆
            sift(arr, 0, j , maxheap); //重新对堆进行调整
. G- N+ \- p0 d8 [4 Q) U  G        }
$ l& F, ~3 d9 J% G2 _7 k    }


! ]8 K" T1 S" g2 p, R+ R  S    //建立堆的方法
# Z6 R/ K  r. w! r% _    /**
( ~  ~& a  Y" x$ i9 C; T7 ?5 J# o     * 私有方法，只允许被堆排序调用
7 n+ A5 r+ w  O4 {/ t+ P     *
3 P! w( G0 _) p8 a+ D     * @param arr     要排序数组
     * @param parent  当前的双亲节点
% r( H3 X5 w3 o2 r* P$ }3 O- B$ k     * @param len     数组长度
     * @param maxheap 是否建立大顶堆
6 Y! q' d& T6 x     */
. c3 L  [. g( o    private static void sift(int[] arr, int parent, int len, boolean maxheap) {
0 s# V' c: z0 |

        int value = arr[parent]; //先取出当前元素i
0 `; w. j+ d* Q$ w5 M' j1 e

8 g" m1 x& D" B        for (int child = 2 * parent + 1; child < len; child = child * 2 + 1) { //从parent结点的左子结点开始，也就是2*parent+1处开始
. K# l& i/ C9 h

            if (child+1 < len && (maxheap ? arr[child] < arr[child + 1] : arr[child] > arr[child + 1])) { //如果左子结点小于右子结点，child指向右子结点
6 G+ L- \! S4 E3 t# I1 a                child++; //右孩子如果比左孩子大，我们就将现在的孩子换到右孩子
3 ~' j( v/ Z( I+ H            }
  s$ E6 v% t7 L3 h
# M* [& _/ `! c3 ~
2 l0 i# e7 m0 y1 S* a: q            //判断是否符合大顶堆的特性， 如果右孩子大于双亲，自然左孩子也大于双亲，符合
            //如果子节点大于父节点，将子节点值赋给父节点（不用进行交换)
            if (maxheap ? value < arr[child] : value > arr[child]) {
; B2 x* Q5 |9 o& J8 c                arr[parent]=arr[child];
                parent = child;
            }
            else {//如果不是，说明已经符合我们的要求了。
1 a% \) a  o  i6 x: }                break;
            }
( i1 }1 r& j6 Y4 |$ U9 C        }
        arr[parent] =value; //将value值放到最终的位置

5 Z9 t" z3 R2 V  C


    }
$ D' v" v' p- p. h0 L' ^
+ n' p% i' L. j, w( p' c* [
( f& i3 E& R! p- |8 {" O}
5 P/ Z# V( s) v( A9 Z6 h1
2
; l# Q% Y, A2 ?+ u  T5 ?7 ~3
4
4 M- Z2 t+ g$ A6 a! F5
6
5 x5 \/ M' [$ a: t7
: Q8 A+ V7 W$ d- C1 R8
9
10
& y) G1 D, U, }" V1 L11
+ s! g5 n/ C; c* H12
13
7 \+ Z* k  m9 T+ \6 L14
15
0 s1 x! p' G. F5 o16
/ h. g8 X* [" g( `2 ^1 j17
% }9 b5 D) S) ]18
8 ]! t7 i( g& J  P. f# Y19
: ~) I8 M7 p6 p( j, A7 h* O: ?20
21
22
9 q$ @' z$ B8 x! a23
. o( _. W7 |+ [8 Z+ {  [24
25
& e3 A' t1 s1 S( n, I26
9 \- d) Q; Q, N27
1 E6 L, G" {3 M* @) {3 n28
29
) ^" G! U- S( [' U( C  Z6 j" O5 X30
31
32
" [  @& V9 \! h3 y8 }9 A7 J% X33
2 K7 B. W: F$ x34
35
" A7 k. ?  U. L* I( x36
( l. S1 h7 z- m8 _! u. Q. }37
) t6 l0 g& D; \0 g& V7 d38
39
40
) ~; g0 g8 C7 s) |# U41
- i& [; D; N! ^3 g; d! }42
" e* h0 w# w: s0 l- Q43
44
45
46
; h6 J9 {# f7 H7 N+ q47
48
49
) Y0 V# v" F  n% M- ]7 |- ~3 ^50
51
- Q  b0 }# u$ n' R5 a# X; q52
: b7 A; f8 P, y! y/ J2 K) C53
54
55
56
7 y5 _2 |8 u/ |6 [% W: X3 ?57
58
59
60
61
; x0 R$ j% W8 Y62
63
64
  D1 K0 T8 [6 F" @4 k2 K- M* v65
66
67
68
. y1 ~# o$ B& O69
4 g4 D6 B9 S5 y0 }. p70
71
, d0 s. |# v7 |. L72
73
; _! t- T5 q3 z74
归并排序
简单解释：
该算法是采用分治法，把数组不断分割，直至成为单个元素，然后比较再合并（合并的过程就是两部分分别从头开始比较，取出最小或最大元素的放到新的区域内，继续取两部分中最大或最小的元素，直到这两部分合并完，最后所有的都合并完，最后形成完整的有序序列）
; |$ d* W1 r8 ?3 I! x+ q0 W
: e3 S; S6 `4 E8 `5 P/ Y6 ]: `
' Y: t+ E% i( C# |& G
- [4 _. n! v. q) ]2 y* ]& h
6 @( n, C$ E' L2 B9 N

: m5 P4 T' o1 \2 f; }完整代码：


package com.keafmd.Sequence;


/**
8 Y% i3 l/ o3 w1 N: Y- \ * Keafmd
*
( Y" M" V% X$ H * @ClassName: MergeSort
* @Description: 归并排序
9 W0 Y) x0 @1 e! u3 D * @author: 牛哄哄的柯南
( q. W+ j& E7 f! j- } * @date: 2021-06-24 10:35
7 N* t9 h& h+ V7 ]$ t */
public class MergeSort {
( m" W$ R& M( w( Y: I+ ]4 w. X

# e) ]" r6 n: Z* W' |0 E" o    //归并排序
% e6 [* T& b+ C7 p$ E) T  d9 S  G    public static void mergeSort(int []arr ,boolean ascending){
        int[] temp = new int[arr.length]; //在排序前，先建好一个长度等于原数组长度的临时数组，避免递归中频繁开辟空间
. }9 K/ J* x5 w. S        mergeSort(arr,0,arr.length-1,temp,ascending);
' j/ i. Z% \" x, f9 |    }
: ?% w2 o4 v: R    public static void mergeSort(int []arr){
6 b% A3 m5 t  k5 w7 N9 n        mergeSort(arr,true);
) k* L2 ~4 g* F    }

# x/ M6 F5 W8 F
    /**
" P: Z. Q6 U4 j2 P$ ]     *
     * @param arr 传入的数组
     * @param left 当前子数组的起始下标
) k6 ?; {: ~! q0 L; C- t     * @param right 当前子数组的结束下标
     * @param temp 拷贝暂存数组
7 h! F( U- c& f3 i     */
    public static void mergeSort(int []arr,int left,int right,int[] temp,boolean ascending){
$ D9 Q% v5 \! y5 K. v8 ?5 i        if(left<right){ //这里是递归结束的条件，我们是对半分，那当left==right的时候肯定大家都是只有一个元素了。

3 R( p7 e, k* o) \# j3 o/ R( u
9 R% D1 h) L, P. I3 W/ n            //对半分，比如总长度是10，left=0，right=9，mid=4确实是中间分了，0~4，5~9
, K7 t% f3 i0 c7 O8 y, y7 @+ M( i            //当长度9，left=0，right=8，mid=4，0~4，5~8
; P  \* R  @- |+ X, w            int mid = left + (right-left)/2; // 防止越界的写法
            //int mid = (left+right)/2;


/ \- |' M3 m0 }            mergeSort(arr,left,mid,temp,ascending); //左边归并排序，使得左子序列有序
" H* l* `4 K: G0 z2 q5 k9 r$ O+ p$ a            mergeSort(arr,mid+1,right,temp,ascending); //右边归并排序，使得右子序列有序
# C1 D: }# y' H: V
& k/ X" m0 N6 g% _$ @( D
            merge(arr,left,mid,right,temp,ascending); //将两个有序子数组合并操作
        }
2 N0 E6 ^  F; k+ l5 L$ b( _  K4 P    }

" @# H. {9 l3 J+ r- z. x) D
    private static void merge(int[] arr,int left,int mid,int right,int[] temp,boolean ascending){
        int i = left; //左序列起始下标
: [$ n6 b: g' R* `6 g4 F        int j = mid+1; //右序列起始下标
; l3 s  J. W' L7 O: F        int t = 0; //临时数组指针
/ q3 N5 G( U/ c# D9 T        while(i<=mid&&j<=right){
5 ?2 p7 E  X5 L& `' L            if(ascending?arr<arr[j]:arr>arr[j]){ //比较两个序列第一个元素谁小，谁小先拷贝谁到temp，然后对应子序列下标加1
* L/ \" J2 K) l: G2 [9 q                temp[t++] = arr[i++];
0 @) j% H. ~. G& N5 v            }else {
' a7 @" t& S# }2 l$ l                temp[t++] = arr[j++];
            }
, B" z$ a& W, L9 c, R0 |- |        }
! X0 v2 ]5 S* ^, S" ?  c& y+ H

* g3 y; U/ u0 W  F        while(i<=mid){ //将左边剩余元素填充进temp中——左序列有一些数总是比右边的大的数
            temp[t++] = arr[i++];
9 h" y1 K- O2 d. u& e        }

" Z0 V- i; v/ i$ W! m. P
        while(j<=right){ //将右序列剩余元素填充进temp中——右序列有一些数总是比左边的大的数
            temp[t++] = arr[j++];
        }

1 W  X3 P- F9 A  O( B* X* d* }7 T' v
; L! u4 @& `1 |        t = 0;

2 R0 L- j# I+ Z0 a1 {
        //将temp中的元素全部拷贝到原数组中
; F) ?* K; _% N; Z        while(left<=right){
            arr[left++] = temp[t++];
        }

: T' y" \; A. n- q0 W. C* t
1 k1 E) s* U  c3 r5 \5 {  A    }


- `- T- z+ Q( O3 ?8 G) y; A8 E}
9 r5 L! {1 u2 g/ |; V8 E1
3 ^& R9 }# |" O$ U) D2
3
4
5
6
7
8
9
10
11
6 |/ Y% {. D5 s+ ]6 z7 {12
0 x. c6 J; j6 H( a& g" V13
14
+ e3 g0 @/ q  J* M3 Z; M15
16
6 u) A5 M$ x" K1 Z* h+ Q17
18
19
2 @/ f: z+ |7 a4 N3 j20
; i0 a- I0 q. V- @21
22
9 h2 z3 p- s' i& G& t) t- h' S23
24
  h/ v5 T; i+ @' R( ~& |6 d25
26
27
' X# T4 `, H2 M5 B2 r4 C7 K& y28
0 D4 W9 f( q  L8 |29
30
31
32
33
9 I1 K! {8 u1 E( h0 \34
5 O! j3 J! |+ |) f. s35
/ w: b# Q; p$ ]2 A4 [5 q36
* H' F0 S5 a: W$ f1 D$ I  z5 E37
( b; p8 A8 Q1 N  i8 ]$ T- W, i; U38
5 \  B7 c6 J& ?# a" {$ m4 M6 d2 Y* N39
! q+ a6 x3 Q- I5 D, t+ v# i40
- `. o( `) V  V& E) T41
42
43
+ ^4 c2 n2 g! G. Y  _( v. v  L44
, v) w8 w( B7 r3 m45
46
) K5 \1 B+ E" @! g% q% A3 r/ R47
% k  v* `& ^5 ?- h$ E7 v48
49
5 ~; H4 a! f( G! ~4 A+ b* l2 ~  r50
51
7 P; ?1 Y0 l* \- P3 ?; c3 M/ T2 I52
. ~1 D# ?* K& }0 A. X6 b53
8 N# ^  X+ o7 v54
1 ~! p8 ~; c2 v5 h* W* R! r55
8 T. S4 g7 ]! K3 \56
57
* x; T! T7 z( T4 G# t: @; A' c58
1 F$ ^* x! l) p3 z$ M: l" a59
60
! d, q. R$ M1 v& O5 D61
62
63
64
) Y; s/ c( f, _8 S8 e, L65
) J* S+ u0 T2 J6 C1 Z; S3 z66
2 \: k( e) |7 e6 ]67
68
69
2 u: @3 o8 r4 P0 o) |) y; \" ]- t70
71
% r( g5 \6 V, g" `( S4 B( @9 U$ Y72
5 Q; x2 n" ]5 t/ x' Y$ P73
插入排序
' v/ a' {1 @, a& h1 x( r$ l3 z9 l& t简单解释：
最简单的理解就是打地主时我们拿到牌后的整理过程，从第二个牌（假设我们拿起来这个牌开始比较）开始，（说下升序）从后往前比较如果比前面的那个牌小，就把牌往后移动，直到找到一个合适的位置（这个位置的前面的那个牌不比这个要放下的牌大）就把这个牌放到这个位置，慢慢的前面的部分变得有序，直至全部有序即可。





0 i0 y1 [) W. T6 n
完整代码：
5 w4 i& [* ~# k2 e% E0 ~- p
! d% M- ]1 _/ s4 [6 d& y2 j
' [5 D  k6 f# ^4 }package com.keafmd.Sequence;
3 h" F# m( {) {  D: v# x  k
8 j1 }3 K; p! t
/**
1 I/ h6 E/ b, n% z: u- ?3 M * Keafmd
! b  c8 w5 f" }8 o' J; x *
* @ClassName: StraghtInsertSort
* @Description: 插入排序
* @author: 牛哄哄的柯南
9 T2 o; W4 B# u$ r$ Q1 z) e * @date: 2021-06-24 10:36
*/
8 t. W/ T& ]. w3 {0 ^: k/ F; Rpublic class StraghtInsertSort {
    //插入排序
( G" w9 ?& ?, J0 ~    public static void straghtInsertSort(int[] arr) {
        straghtInsertSort(arr, true);//默认进行升序
6 {# r7 Z6 B, B& Q    }


    public static void straghtInsertSort(int[] arr, boolean ascending) {
: F2 ~! x, J9 x7 f( a8 s3 C7 e
7 h' ^9 M' S; c2 c
8 T  s0 w, k' g: M        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--) {
2 d% r: o/ s. W                arr[j + 1] = arr[j];
9 B7 w) V2 D- v5 ^6 l& g# Y1 W6 T            }
            //把牌放下，为啥是j+1，
+ d1 c& j, y2 ^# a. k, x$ ~            //是因为上面的循环遍历到不符合情况的时候 j是合适的位置的前面的那个数的位置
            //有点拗口，但是就是这个意思，看图方便理解下
            arr[j + 1] = temp;

% H9 @5 S% i" A, n+ T
/ d6 J) Z# C8 @" @- Y2 ~. S/ i! u( A

6 k4 ~+ }( a" ?0 L( s- S        }
( f8 C& w% _& ]% q) Y# Q; y

* n: X" u" U' `$ I& h7 M    }
+ \  [- b5 }, S0 [" a}
1
2
  L( Y3 {4 L. Q$ n3
' F) ^! ~7 Y4 A8 @" O) J7 ?/ ]) R, u$ X4
5
4 H- R7 {5 g8 C1 F1 o0 l6
1 A. X% a$ J% h4 Z: O7
0 M) q( h4 z0 L# U  N; n6 ?8
( a. L& M# z6 S9
2 S" X6 l* C/ P2 L# X6 v- y2 ~10
11
12
. y. R7 ~# O1 m8 T5 D) S- _& s13
* J7 |# s( s- c: Y14
! w5 H5 {6 Z! R) }: c: v% I15
16
17
18
19
20
, W: j$ c3 X& U/ w# v  c6 m21
22
23
24
25
, s! E& D, E/ a0 o26
- [7 }6 V* o0 |3 p7 h' H27
- s8 x  K" h7 y28
29
30
7 z* |8 r2 n9 p0 M6 v31
32
3 ?4 A3 r8 |% u' U33
, h; p% W7 s* d. l* s. I34
, V6 d! R/ ?+ I7 r* F希尔排序
+ @, n' q/ Z2 q* D8 U简单解释：
# f7 W, R! d6 f# p+ S4 J( e& S% V希尔排序是插入排序的改进版，我们理解一个叫做下标差的的东西，也就是下面那个图中的增量d，初始下标差为arr.length/2，然后继续/2，对在同一下标差（相当于把这几个数单独拿出来了）的若干个数进行插入排序即可。

! g" t4 W1 L' C0 e8 F0 S/ B
. ]4 f/ x! ]; N6 J' j
/ ]$ A* P3 e" P4 G
  I* e, m; T, C( t

完整代码：


package com.keafmd.Sequence;


/**
* Keafmd
* u% p0 N/ E* R% x4 Y *
* @ClassName: ShellSort
* @Description: 希尔排序
* @author: 牛哄哄的柯南
* @date: 2021-06-24 10:39
% ?2 N1 T8 g) T' t- G$ w */
5 O8 G6 W: j8 f) b% t2 p+ ?/ ~/ cpublic class ShellSort {
: i/ i6 Q5 C* a4 R

8 Z6 u  i( O) }2 O  Q+ N- e    public static void shellSort(int[] arr) {
        shellSort(arr,true);
    }
* b. h$ R+ L. f: ^3 p. a  c% h1 A

& \3 M7 x( \- b/ l8 L2 v, V" F    public static void shellSort(int[] arr,boolean ascending) {

: i5 T& Z" t: h( `' |
        for(int d = arr.length/2;d>0;d/=2){

$ q! i4 j: l! C2 e" X
5 N) J$ S$ B* M- x: y8 o* U6 j, |            for(int i=d;i< arr.length;i++){
1 Q3 b# d( `8 v2 P, ^2 _5 _# K4 P                int temp = arr;
                int j=0;
$ H" v- d1 Y2 j                for(j=i-d;j>=0&&(ascending?temp<arr[j]:temp>arr[j]);j-=d){
8 R8 d% }- c! `: a! j                    arr[j+d]=arr[j];
                }
                arr[j+d] = temp;
8 H' u9 F2 Z- T2 D* y, q' t. D% ~' K            }
' l/ q9 l# J" O" K, M, R. g        }
$ y* |+ S  U# }

& Q# H; P- u5 ?    }
) a. L4 u) `+ y}
1
2
( X" J! p0 s- d. @0 i3
/ D1 b+ f9 R$ v. m4
0 }. r1 v& V& u7 }+ n3 I( @! Z( l5
; u4 L; j% d1 [: O6
2 u0 Z3 ^! X4 [2 n% w* ~+ k7
8
9
# `- o1 O! x7 \, i2 s10
- h- l1 W( w4 `11
. g; T$ G6 W; o/ x12
13
, l+ `  U% y7 u6 `$ x+ f14
' k* s- T2 w% o/ @; I15
, X  d" n' ]& K/ N! [6 i8 M" x16
, ]5 D7 A9 B) g" g17
0 \! e$ N& f9 S18
" ?/ a$ V  y5 u19
20
8 K8 I& T  U: d/ x# `0 l! _6 J21
6 a' b& s( V4 \% U- {22
7 w  `5 ?( W0 I' ~8 l23
24
& N- L0 h# _) I& k0 |  Q* R25
$ k# {# l2 O& v" b1 k9 s26
27
# `$ b6 ?# d8 }8 E( k- M28
29
30
31
32
计数排序
& }3 q  U' D3 `1 k简单解释：
7 }( w8 U, ~/ L3 u这个排序算法看名字也很好理解，就是就是额外找个数组来计数，然后在这个数组从小到大或从大到小把数取出来即可。
4 p1 U  z# g/ R5 ~: N4 e. }

0 C  W" o! a8 F! K) P0 O
& e5 M$ Q, w9 i  L3 @  U


完整代码：

! y1 H6 P0 R3 q% g7 H9 j
. n* k. r1 J% e; o+ }6 B0 Npackage com.keafmd.Sequence;


, X  L; T6 @; j, J- n3 e) v/**
5 t! F9 `  V2 }: m7 j * Keafmd
) ~( R" q% t/ K" D" G *
% l* U: y7 d6 ^/ _  \5 D2 | * @ClassName: CountSort
* @Description: 计数排序
4 |5 \2 A) D* z- m2 ?1 G * @author: 牛哄哄的柯南
* @date: 2021-06-24 11:31
*/
5 n1 D# S0 V# k" Y' @% Spublic class CountSort {


    public static void countSort(int[]arr){
        countSort(arr,true);
; S/ C8 K" ]; {* e) @    }
* i0 A6 }$ j( E& B. j5 ~) Q
2 s, Q' Z3 Y, U/ d2 z' Y8 g
    public static void countSort(int[]arr,boolean ascending){
# D  R4 {: {' C5 X8 q+ g        int d,min=arr[0],max=arr[0];
9 S% n6 T0 [! h0 S

/ O. o  L9 M% ]  l/ ]* T        //找出最大、最小值
; t& j5 Y3 _/ K! y' I0 @# B5 A& Z        for(int i=0;i< arr.length;i++){
1 x3 F& G1 S$ P! a6 Q/ m, W' P  @            if(arr<min){
* \6 x* A4 a4 X                min =arr;
0 q) }; C2 d1 h) D            }
+ O& h2 U* Y0 X  E$ f% X% q5 F            if(arr>max){
' ]7 N' |1 ?8 `5 c4 q; B                max = arr;
            }
! d8 H" w* B0 J$ L# L        }
" \* C% U; K% _" ?: u

6 A  |2 E* ]8 S# N; d        //建立一个用于计数的数组
        d = min;
        int[] count_map = new int[max-min+1];
        for(int i=0;i< arr.length;i++){
' G* T* {& a0 G+ i9 `  T            count_map[arr-d]++;
$ ?) w; \$ j! u: Y) N, v6 ^        }

, B+ s3 H$ y) K6 t
        int k =0;
        if(ascending){
% w) M8 ~  I1 K. A7 s            for(int i=0;i< arr.length;){
                if(count_map[k]>0){
                    arr = k+d;
                    i++;
, C# S- T% d5 y7 H8 ^! [8 W  k                    count_map[k]--;
) V- z- f: O: T, H& I                }else
                    k++;
7 Z  ~' R& u7 G1 }8 v" B            }
        }else {
3 P' t. f2 t( K            for(int i=arr.length-1;i>=0;){
                if(count_map[k]>0){
4 z6 c# c8 w7 d) f! P* I                    arr = k+d;
                    i--;
5 A8 `* ^& b% q2 Y) D! N                    count_map[k]--;
                }else
                    k++;
7 s8 U: \5 o6 i/ x* Z$ Y& y/ q            }
0 o$ D4 [% R; B2 S8 r        }


    }
}
1
; M2 `7 r/ q6 A. o! s! ?6 _: o$ j2
3
% r% Z# U. x/ ~- l4
5
3 Y9 c: Q+ E6 ]& C3 L6
: ^- }, o, E) B2 z6 u7
/ ^! e4 O  a( N1 x8
) v! Q3 J+ o3 i9 J3 X0 |9
1 T0 R$ e# O& |' O4 q# U# B& M+ X10
11
0 m" _- @7 B/ K4 w( _12
$ c' g4 a  _, ~" F13
- ?$ m3 `" o: g5 N8 g; o14
15
. U! U2 s& a! H& `. K16
17
18
19
20
4 X" @" v  h( _  b21
" S! V: `* _) _! x3 |% [8 H' \4 W22
23
24
& J' G7 c. e, t& y25
26
27
( N: a2 z3 L1 I7 Q1 C28
29
0 V+ n# b1 x* H+ O. S  W30
31
32
( {' s5 ^2 _+ B* W" J33
34
35
. {0 I$ Y( L6 j. V, A: j36
$ t, o; U3 k" F0 h37
38
39
% t" c8 J6 W& d* a2 }; i40
41
& k$ o. E: E9 K$ z* S42
43
44
0 y" }2 D+ a2 Q# I45
46
47
. e9 n9 P: e6 l3 |48
0 A* T% W" b8 ^( M. J: j# j$ h49
8 Z+ ~+ `  [# D6 Y50
( z* y/ y: ^9 G/ a5 j4 Z2 o8 }; y/ l51
52
53
54
55
56
$ C7 N: ^9 W# W, M6 L0 u57
1 g7 e! m2 i8 P! ^3 b5 H: U; F58
* C) U6 w3 x. m5 L6 E0 M1 F9 a59
: c% e; U# X* I' r% g桶排序
+ H, c% e5 ~! u- O* Z) K( p8 n简单解释：
& Y" U; X0 x, G就是把一个数组分成几个桶（其实是几个区间，从小到大或从大到小的几个区间）装，然后让每个桶（区间）有序，然后取出来放一起就可以了，相当于把几个有序的段拿出来放一起，自然还是有序的，当然需要是按照区间的顺序拿了。



( T' x# m+ s+ q
5 Q. g& E" a5 h) }
! p7 ~, }" y2 d1 k
% x, `6 N4 H% f+ ^2 H& }* Q# d9 i. f完整代码：

- q5 J0 {4 b3 _& \6 L2 B  L. P
package com.keafmd.Sequence;


- X0 t# {* y7 i- P0 s! t+ y# Cimport java.util.ArrayList;
7 `4 ~) J5 a7 s9 T, Limport java.util.Collections;


/**
* Keafmd
0 ~0 M# \  ]- ~6 c *
* @ClassName: BucketSort
* @Description: 桶排序
* @author: 牛哄哄的柯南
* @date: 2021-06-24 13:32
1 U5 t! e) P# b: K0 z" O */
public class BucketSort {


    public static void bucketSort(int[] arr){
        bucketSort(arr,true);
3 ^1 M/ f; |7 p; f; ]! O    }

9 A, ?! V; n0 ?; X3 j9 x9 [
    public static void bucketSort(int[] arr,boolean ascending){
+ U* i5 O- E& M! L        if(arr==null||arr.length==0){
4 j- f; \& G; h0 X7 Z+ d            return;
7 @7 N5 R# N3 C$ x& ?3 [        }
        //计算最大值与最小值
- l/ V5 A1 \/ b7 f+ }- H4 v        int max = Integer.MIN_VALUE;
! \( a' Y/ N& F' k6 A  G3 _        int min = Integer.MAX_VALUE;
        for(int i=0;i<arr.length;i++){
            max = Math.max(arr,max);
            min = Math.min(arr,min);
  B4 ?2 O# R# L        }
3 q0 }; x; i# E. H9 c

        //计算桶的数量
3 e+ h6 y3 b" z6 P2 l# c# H        int bucketNUm = (max-min)/ arr.length+1;
        ArrayList<ArrayList<Integer>> bucketArr = new ArrayList<>(bucketNUm);
8 |# W8 L) l  C+ s6 ]        for(int i=0;i<bucketNUm;i++){
* S) ^. |* B$ E; X0 _' y            bucketArr.add(new ArrayList<>());
' b! M; [; C* h        }
) a+ R' |* y. k$ Q, X, [

        //将每个元素放入桶中
3 S1 ]! B  h/ l        for(int i=0;i<arr.length;i++){
+ q" E  x6 t1 K            int num = (arr-min)/ (arr.length);
0 E2 M! R9 n( H# b# r            bucketArr.get(num).add(arr);
4 r& R  v( r& q/ f+ _% P3 A7 }        }


1 D! @2 o1 E/ G# a7 d% p        //对每个桶进行排序
        for (int i = 0; i < bucketArr.size(); i++) {
8 z* }6 ~2 B1 `            //用系统的排序，速度肯定没话说
            Collections.sort(bucketArr.get(i));
* [+ f# c- ~; y6 I  B9 M        }

' j* h, C& p7 p& M9 D" [
        //将桶中元素赋值到原序列
        int index;
1 V# a) t4 q9 ~4 H3 n5 v; f2 b/ J        if(ascending){
            index=0;
        }else{
            index=arr.length-1;
        }

, k6 w7 W6 p2 @6 X+ q
        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);
                if(ascending){
$ \! m/ H9 ^$ {2 l                    index++;
; J& f) ?' ?$ {1 L& G: f# Q                }else{
                    index--;
                }
            }


        }

# _- ~+ u5 t+ Y
2 }' Z2 s5 j( U( P    }
$ B: g0 f* ^+ o5 |: H}
1
, Y$ \# ?7 N- j+ m7 w2
8 l, f( X# A5 R7 E/ ~" w, f6 v3
, c3 U( n( R3 V5 A$ E. Q4
5
. d" [0 r: }) h( B, B. v- e5 P) r6
2 y& g5 F& A2 t$ l2 D7
! `- j1 g1 t4 h/ e' n8
2 n5 t. Q7 f# d5 [, |0 i" h- x# m% s9
10
11
12
13
3 Q  W+ e1 S$ y) a14
15
16
8 ~: u6 C; R. W1 |$ @4 F17
% N& w; r9 Q1 Z, z18
' _4 E4 Q; w  V, E: ~19
9 P9 d' W' F/ e6 r$ H6 E; Z% z7 m& n7 n5 L20
8 @! t5 Z: w+ k9 Q: s21
22
23
24
: {  c) R! A: U, g. z. \( A$ X25
' O' L3 x" [* j! k7 O26
6 p7 C. S* j. L% k+ m8 ^- ]0 H27
28
) V' \. C1 J" d% V* H# P5 y29
30
31
32
33
34
& R* D; G, f! u: V1 c: ]3 V35
& X2 ~7 O/ n0 \( u36
37
3 n: B. ]0 N/ U2 v38
39
" x" Q9 n3 v1 e0 P5 Q# c40
41
42
1 x  Q( v8 K$ z& p+ y43
! B* b% p1 [9 c- M& v. j, X: T44
45
46
47
48
2 C% t3 T# c, J& H, M+ Q49
50
0 M5 B. x9 m! @% p51
4 h+ X/ w3 ^0 G" ?* [3 w52
, S+ f) E! `; s# Q# t! N53
54
55
56
57
58
59
60
! a0 f. v' e* P' W7 r0 s% T61
$ {- S8 q3 z$ o6 |$ t4 W6 q! X62
* K0 N  [9 f! T# A1 b63
! o9 X2 |; u6 U' z64
+ l- P. I3 L' S$ N/ C7 G, s65
4 {0 Z& k, R, q4 d/ R8 |66
' K; d5 ?# Q$ \3 f67
68
69
: W4 F9 B# }# D) ^5 R- ~. T70
. l. e1 `5 E4 J7 S! a71
' z! ^' o4 `( P7 H, M1 S72
9 C0 s$ s9 K! ~7 }' e& v7 y' Q6 [8 G基数排序
简单解释：
首先说一下，我发现好多人写的基数排序只能排序正整数，其实只要处理下就可以排序含有负数的了，就是我们排序前先把所有的数整体变大（就是减上最小的负数，也就是加了），都变成正数，然后排序好之后，在减下来（加上最小的负数，也就减了）就好了。
基数排序就是按数位排序可分为LSD（从最低位[也就是个位]开始排序）和MSD（从最高位开始排序），下面写的事LSD基数排序。
' Q  H4 |2 I, j* k基数排序就是把数按位考虑，让后我们一位数只能是[0，9]，就是我们在考虑某位（个位、百位· · ·）的时候就只看这个位的数，放到在[0，9]相应的位置，然后顺序取出，最后再按其它位这样操作（上面说了要不从低位开始到高位，要不就是从高位到低位）


( h  S! |  M8 {- ~



' ^% q7 M' d# Q  Y$ r5 u) Q8 S完整代码：
' n+ I" D9 M) K: k
/ @7 Z+ K; v& C
6 H5 O( M4 f0 I9 V; Zpackage com.keafmd.Sequence;
% J' @6 k6 d- j  {. _
6 m6 k' b9 O$ L2 \; R) `
/**
* Keafmd
*
$ d/ F- r+ ?) Z  K/ F * @ClassName: RadixSort
  j; ], {; |8 [! M7 n5 L * @Description: 基数排序
# O  y/ M8 a- C, P8 l * @author: 牛哄哄的柯南
* @date: 2021-06-24 14:32
*/
5 H4 q; K0 e4 W1 rpublic class RadixSort {
8 Y% g+ H# Y7 z& i    public static void radixSort(int[] arr){
        radixSort(arr,true);
# q" A  j5 ]+ ?    }
0 C9 g! X; @  a1 T; e" z' ?* U    public static void radixSort(int[]arr,boolean ascending){
$ \$ h8 R/ I5 D3 @( G( {" c        int max = Integer.MIN_VALUE;
        int min = Integer.MAX_VALUE;
        //求出最大值、最小值
* \$ k& H$ ~8 Z        for (int i = 0; i < arr.length; i++) {
& c7 F& G/ H1 t1 x( c! ^            max = Math.max(max, arr);
! H; h, E1 x7 E9 I            min = Math.min(min, arr);
8 L, b# N8 A8 u5 B  [/ V        }
        if (min<0) {        //如果最小值小于0，那么把每个数都减去最小值，这样可以保证最小的数是0
. }( O( U- B! C+ j* @2 C/ _            for (int i = 0; i < arr.length; i++) {
                arr -= min;
            }
2 _2 W2 T/ ?/ h3 ]# w+ x            max -= min; //max也要处理！
7 D1 M8 j9 z+ n# I        }
& @5 w; n  x' q( v9 r        //很巧妙求出最大的数有多少位
  K+ g  z# j6 P1 Q        int maxLength = (max+"").length();
        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) { //个位 十位 百位 这样遍历
0 \5 j/ C- e7 A7 K            for (int j = 0; j < arr.length ; j++) {
1 {$ ], c, A6 S. h: k5 _& ?) L                int value = arr[j]/n % 10;
                bucket[value][bucketElementCount[value]] = arr[j];
                bucketElementCount[value]++;
            }


            //升序
            if(ascending) {
6 q5 e$ A" ?1 N                int index = 0;
                //从左到右，从下到上取出每个数
, }% {8 E3 d/ L9 K8 V) _                for (int j = 0; j < bucketElementCount.length; j++) {
                    if (bucketElementCount[j] != 0) {
: Q0 [9 D+ P. e5 C4 Y8 b$ J                        for (int k = 0; k < bucketElementCount[j]; k++) {
1 }# t5 Q6 _3 s( l4 L5 d+ @+ |7 n                            arr[index] = bucket[j][k];
: `( N1 [, V% e$ M4 J                            index++;
                        }
                    }
                    bucketElementCount[j] = 0;
                }
. U( O1 q$ z& Q  E( A( p            }else { // 降序
                int index=0;
. |! v  _5 v% g% R, F. r3 e3 z                //从右到左，从下到上取出每个数
, T. Q6 ^6 w' U9 k2 m- K7 H                for (int j = bucketElementCount.length-1; j >=0; j--) {
                    if (bucketElementCount[j] != 0) {
                        for (int k = 0; k <bucketElementCount[j]; k++) {
                            arr[index] = bucket[j][k];
                            index++;
                        }
                    }
                    bucketElementCount[j] = 0;
                }
3 e: [/ c( ?) _5 S, t+ z            }
8 _7 q% r5 c, A  Y, H
: q( {% V$ F7 `0 B! ?6 |" Q) M# Y


            /*for (int i1 = 0; i1 < arr.length; i1++) {
                System.out.print(arr[i1]+" ");
            }
            System.out.println();*/
. F0 w  u# N& k1 I. {8 E. C





. d6 V5 r. v, Q3 z* v        }
; ^* f% Y, x: l$ E' z. o: z3 K        if (min<0){
            for (int i = 0; i < arr.length ; i++) {
                arr += min;
            }
* `8 C3 A" }4 k+ \: \. w        }
& n/ s' u! h' m- X' B8 z) k' P
+ P/ T- q* n* R6 H& O
$ r8 {; R, I$ L7 J% v: _; U& Z. S    }
. f5 i+ a5 j% o  M9 f) w# `}
1
2
3
4
5
" \" L; v8 d+ c+ t5 A2 i6
7
( x" g8 U0 v* Y* |8
# ~. s' N+ h  _  X4 |& y! m9
. d% c+ p4 {- U0 [1 U10
: e; D: U( A+ F3 I! {( ~11
" d" A: h! e! \1 |; _12
13
+ M$ u$ d( R5 q# P, p. w5 u14
" z5 |( [, A, J% X; V8 t15
4 c9 c- z/ ]% U, ~& ^- _4 g16
17
18
19
20
21
! |0 n' H6 ], a7 j% R22
23
# D' t+ \. x; y& ~2 t, h24
25
/ M# _. S7 e; p1 @7 c  ?, M/ M26
; V2 S( X' |' L$ X27
28
29
+ y3 B3 o% u3 z" t& `+ n30
31
. P9 v# v' H1 h) v$ w6 W- {! I32
. c4 y: U. p6 z7 m# a, j33
9 l, i7 F) ^- p; _0 _3 P34
35
: L" R- q; n# ~4 k" ^. y% D4 w0 Y36
37
, z6 ]1 I) D8 x4 n0 n0 s4 B$ I38
39
40
0 }- K0 `6 n5 ?41
. J. w& P" q7 x42
43
44
. a2 ]0 a& U0 ]  v3 P: ]2 @! F0 ~45
5 S" k! q/ o+ V+ N: T46
3 Y! |; {# y  N4 D* h/ S47
48
49
50
51
$ a/ T7 r$ U. t- O) W% l$ O5 e! [52
53
8 ^. U" g) ~1 U5 S4 z" |3 b  i54
55
56
57
/ Y: C' G& i& N' J% t4 Y" c58
59
60
61
62
63
64
: Z: H3 Z9 y" J6 S0 V65
8 \! T) F# X3 r( l, e66
3 }; y% A1 R' E67
; R/ u- w. E' O. s68
69
70
71
: B* v5 J3 F: J4 n; p/ {72
1 N$ L8 w( j) d73
74
. E+ B4 @4 m* U+ C75
# i1 `. v2 H- v6 R% B76
77
78
79
80
81
- c. v" u1 |; ~5 q; H- T" a) d. m% B82
$ ^- T" @- E/ c( H- m6 p+ i' ~* H83
2 s1 D0 Z: k" y' b9 O$ s# C+ D: |完整测试类
package com.keafmd.Sequence;
2 D9 M  {* |0 i1 E  u0 L
6 H3 ?) }; R; M/ X/ V" s
+ n( C: c5 |$ R$ a2 l0 ?import java.util.*;
import java.util.stream.IntStream;
+ z$ R# J- @4 Z. cimport java.util.stream.Stream;


( {+ r* _- A. L' R/**
& p- h) P4 |( M; A  k, q/ C * Keafmd
5 t% U! r2 F/ O3 Q) T1 C! q1 g. q *
% [4 O6 Z# G  ~! f% a4 H * @ClassName: Sort
* @Description: 十大排序算法测试类
) E- ]; s' f$ P# [( v, j& j * @author: 牛哄哄的柯南
* @date: 2021-06-16 21:27
- i% H: i* r  Z0 P */
3 b" k/ A) z; B2 X# Z$ vpublic class Sort {

( Y% B0 V) g( P9 B  N4 P

4 L- |4 u: {' z/ D
    public static void main(String[] args) {


        int[] nums = {12, 4, 25, 47, 58, 34, 25, 9, 99, 26, 1, -13, 162, 10093, -66, -1};
; Q- A% \% e9 K2 e3 a: x//        int[] nums = {12, 43,56,42,26,11};
        int[] temparr;
# A" ?0 W3 k+ g" H* r
0 G; K& m, D; T: @
        //利用系统Collections.sort方法进行对比

  z4 I0 b0 J, v( Z6 ?! u
        //将int数组转换为Integer数组
        //1、先将int数组转换为数值流
5 N) n. H4 U( W8 P. U9 T        temparr = nums.clone();
        IntStream stream = Arrays.stream(temparr);
        //2、流中的元素全部装箱，转换为流 ---->int转为Integer
3 h- y- \6 X* J( Z        Stream<Integer> integerStream = stream.boxed();
        //3、将流转换为数组
        Integer[] integers = integerStream.toArray(Integer[]::new);
. ]2 U4 F- g. o4 f: A: u9 [6 \# r        //把数组转为List
        List<Integer> tempList = new ArrayList<>(Arrays.asList(integers));
8 T8 L  k8 p/ E6 a/ L9 K        //使用Collections.sort()排序
        System.out.println("使用系统的Collections.sort()的对比:");


$ w( u9 ?* S* [        //Collections.sort
        Collections.sort(tempList, new Comparator<Integer>() {
            @Override
& ^2 z5 ]7 |# \6 \7 L/ L2 x- D            public int compare(Integer o1, Integer o2) {
                return o1-o2;
  V- f6 R" K" I6 E" W* s8 }* v7 a: _                //return o2-o1;
            }
8 C! o# a" O4 d& i# ?2 q4 h* N        });

* y" A: r7 b# S; V1 H0 i" c' V
" d2 g% e6 H4 k        //tempList.sort 也可以排序
5 r9 V4 T# v" {       /* tempList.sort(new Comparator<Integer>() {
            @Override
0 R! X: f+ H! j0 `, J/ e0 H- R* E0 @            public int compare(Integer o1, Integer o2) {
                //return o1-o2;
" W4 h% `% y) E6 h( v                return o2-o1;
0 Z/ M! H- a4 A. }; g            }
        });*/

* J, s' y( Z3 g! f" W8 H$ d, c$ ~
: X0 p9 Z+ c" f        //遍历输出结果
        for (Integer integer : tempList) {
1 {3 |1 T8 @) L' W% g1 y            System.out.print(integer+" ");
2 e5 V) t6 _! H( @5 [" H        }


        System.out.println();


        //测试冒泡排序
4 |! L' B! }, @, v" o8 e        System.out.println("测试冒泡排序:");
2 r: X& M# E8 o7 t, u1 e        temparr = nums.clone();
( Q$ P' G- v, X+ o: c/ c4 b; o
# c! m+ P" M/ L2 D3 ^: R# O5 m. C
        BubbleSort.bubbleSort(temparr);


! @, g. M- d) W6 w        //降序
        //BubbleSort.bubbleSort(temparr,false);
( s9 O( L0 `  n2 l2 d# p; T. I% D
: B7 L, N) x. i+ i4 [
% J9 w9 R& v7 t        for (int i = 0; i < temparr.length; i++) {
            System.out.print(temparr + " ");
        }
/ l1 _) c+ {+ ?        System.out.println();
2 L1 a2 n$ _9 p! @0 b: z* q2 X
! v+ F5 j: ^4 V8 m
+ r- {; O0 [4 p        //测试快速排序
+ q8 A) Q0 N% F2 u* W0 S        System.out.println("测试快速排序:");
        temparr = nums.clone();
$ Y; \4 I8 ~/ C        QuickSort.quickSort(temparr);
& h, U" N, D2 a- J        //QuickSort.quickSort(temparr,false);
        for (int i = 0; i < temparr.length; i++) {
# B5 F: l, b0 b, l1 f# B0 ~4 i* d            System.out.print(temparr + " ");
! F( y$ Y$ u1 v/ O        }
        System.out.println();

3 N( o% Y9 Z" l  J) [# b
1 l6 _1 y( v( S        //测试直接选择排序
        System.out.println("测试直接选择排序:");
9 Y/ u; X( L' Y% W( t, s        temparr = nums.clone();
5 c% v4 X6 f9 P" f        SelectSort.selectSort(temparr);
, }0 s7 b* u8 P        //SelectSort.selectSort(temparr,false);
, M3 d8 @. h% h5 m9 G- M) ^' H9 t5 e! F# @1 ?        for (int i = 0; i < temparr.length; i++) {
  f- T/ l; H: |& T; @            System.out.print(temparr + " ");
. b/ o- ?4 E% P6 F  P1 I& G        }
7 A% ^! c7 S, d5 u        System.out.println();


        //测试堆排序
- k' v) l/ W, T  U        System.out.println("测试堆排序:");
9 ~, O2 {4 Q7 ^% v' Z        temparr = nums.clone();
/ S+ V( P( p/ E+ [5 i        HeapSort.heapSort(temparr);
1 S5 [3 b) Q/ P1 ^9 F        //HeapSort.heapSort(temparr,false);
        for (int i = 0; i < temparr.length; i++) {
            System.out.print(temparr + " ");
        }
; \! d" y+ `2 z1 F        System.out.println();

. @2 c  [8 U  q7 k" |' l2 f
9 ?7 [, Q0 U# H; U* i/ y        //测试归并排序
' y2 i4 k. `) ]7 z2 l+ X. h        System.out.println("测试归并排序:");
        temparr = nums.clone();
  W4 u  S! I; Z" B2 c9 ?) u( S        MergeSort.mergeSort(temparr);
" i! z1 v) i* {        //MergeSort.mergeSort(temparr,false);
% p! e" v7 P0 Z: d( U7 g3 d! V( S        for (int i = 0; i < temparr.length; i++) {
            System.out.print(temparr + " ");
1 M: w& `; a. R+ ^- e        }
5 C0 R+ X3 P; J% p& T' s        System.out.println();

) I3 P$ S; \6 _, U# z
        //测试插入排序
        System.out.println("测试插入排序:");
- }! \; z7 v7 T7 h' f7 [        temparr = nums.clone();
7 l) k- h8 U* k2 F- d6 [        StraghtInsertSort.straghtInsertSort(temparr);
        //StraghtInsertSort.straghtInsertSort(temparr,false);
0 X3 g) P: [( O  J$ e        for (int i = 0; i < temparr.length; i++) {
            System.out.print(temparr + " ");
7 |, E/ s0 F% v0 F$ h9 ^2 J        }
        System.out.println();
  E6 q, O* U: K) u- v' P& y8 ~


+ ^: l  p' v7 f- |
( ~: ~8 ~8 J5 W        //测试希尔排序
        System.out.println("测试希尔排序:");
" l6 w% I* j& S# G& O        temparr = nums.clone();
        ShellSort.shellSort(temparr);
        //ShellSort.shellSort(temparr,false);
( C! Y* ~9 x$ f) A" u        for (int i = 0; i < temparr.length; i++) {
            System.out.print(temparr + " ");
        }
& g+ W! V  o0 p. T: [% v" J( i/ v. q5 Z        System.out.println();


* Z' x- D2 T& D5 b7 w# p% T

( C% V& `/ }) `        //测试计数排序
/ W; e/ x% z4 ?- E, }        System.out.println("测试计数排序:");
        temparr = nums.clone();
3 ?* {# M# [8 ~' ?5 B        CountSort.countSort(temparr);
8 U! b* X" {! C: i1 A2 P        //CountSort.countSort(temparr,false);
        for (int i = 0; i < temparr.length; i++) {
2 n$ O( P; Q% v. r. S            System.out.print(temparr + " ");
% t3 ~" G. k$ K" H8 S2 Q        }
* `- B7 F" I4 C! z  m/ N        System.out.println();

# T, e( {/ T! M) E' z. f
$ B6 Q: Z8 }" q/ X5 h& ?7 V

        //测试桶排序
) c3 b" |3 B: I2 Z$ U  W        System.out.println("测试桶排序:");
        temparr = nums.clone();
; D7 C( @! c2 J1 r- c4 e        BucketSort.bucketSort(temparr);
        //BucketSort.bucketSort(temparr,false);
! A. f3 t0 k' f/ n$ T0 d        for (int i = 0; i < temparr.length; i++) {
9 c, ~& A  v; M8 l+ L            System.out.print(temparr + " ");
        }
        System.out.println();

# H" X* ~5 i5 l6 g" g4 |+ o& L
- y) Q7 a8 ^+ @' ?        //测试基数排序
        System.out.println("测试基数排序:");
        temparr = nums.clone();
; {: h5 T3 N+ \- F6 b" {        RadixSort.radixSort(temparr);
        //RadixSort.radixSort(temparr,false);
        for (int i = 0; i < temparr.length; i++) {
            System.out.print(temparr + " ");
        }
        System.out.println();
( ?! [/ b7 z, I; Z! ?

    }
7 P% `% {2 j4 I
/ K$ j7 ?4 O. ^3 r
0 @+ ~# `9 ]/ c& F! W* S( I' V& P}
1
/ U" E$ w4 w2 g, E2
/ Q% s* E& M5 m* w% N5 }( k0 Q3
  b8 W1 O6 Z- S) j. |5 |" L% H/ ?4
5
% }& X6 j) P4 x$ }+ z$ @6
7
7 V$ d" J5 E2 Y( B7 E% P3 q8
9
9 m1 I: h; v; V, Q  M10
. `' W9 X9 v2 |11
- k3 W  w" z3 ^7 P6 s: o( z: ]! H% G12
13
14
5 b+ M4 D& H+ _: R2 b) s% ^% Y15
16
3 `' Y+ a6 ?" r* K17
( P5 A' q9 Q. t18
8 G, u, {! g" v6 i  v, {6 O( d6 `! F19
20
21
/ }: p3 g# D4 l" p2 s3 o5 b22
23
% T3 U! S9 R9 \24
25
26
27
& i6 [9 B# r2 e28
29
30
' [4 h9 \9 b, {' m$ ?  @# @) T6 }31
$ p8 f, V* ?. W4 A& v8 b32
2 Z8 O. A0 G4 {* s* H; n; {( N33
34
35
36
+ \9 Q' x( z0 ?* Y37
+ S3 z" H# K+ ]5 O0 q2 H38
2 N* D  [7 E+ ]5 A) D/ A; z39
% k6 ~9 h% j# @: y" B40
' z7 S1 V( n6 K( {2 E41
42
43
44
7 a( D7 m: P% }' L3 J7 [' k. O45
46
47
* g  z" |  Y, A48
49
! w+ ^4 `& W" o* V, k  d- O) h" z50
51
52
53
54
55
3 _, v- E9 ?7 B+ ]2 R2 l& x56
57
  C9 h4 W" q5 f* k0 R58
59
* A' B: m( J" R60
& @' {$ m# ~) c61
9 P( U& ~2 f( I4 Y( N8 o+ j9 w62
9 ^0 E1 x% q' `9 Y; |63
9 U8 B; i" \& t64
" x  c6 o" h5 m6 F" K0 K65
66
67
68
69
70
) ^; O7 l1 F- _6 F3 }71
3 g4 R, v, N* u0 k0 D4 M72
73
74
# N, z" U/ N$ X0 X, s0 F! _; l75
1 M, o6 _1 ~9 Q76
& a  X" \0 N1 R3 ?) S77
78
1 a9 ]! t( V2 E0 N79
80
3 F  {# w! w% w1 M# a81
: H% O. l3 g9 I# L82
1 ?% C5 E+ E; z+ k83
84
85
$ V4 d8 M2 ]' G6 {86
- L( X; _% n! {$ z87
88
89
) D" E: E5 q% W* g90
91
6 {, I/ U" ?$ V9 q4 H92
93
% ~4 k) l  ~, c1 ~" I- y94
, N+ Y" w* ?$ T( n8 l95
96
- @3 Z) m- {0 K( L; b97
98
99
1 ]" `3 N6 U+ [+ S* X100
) R* e3 J5 ~7 {  [) p101
102
# Z5 `8 r- f+ s0 A2 }103
104
105
& m3 D% P$ r7 `3 Z106
107
, k7 ]! i: b, v3 E& z  K1 Z6 w108
: {) _1 _/ i  p! f109
* ^) \) {/ t! W* g9 N' p* O110
111
7 s( [, c8 V- q/ ~' Q: m. C112
113
114
115
! Y! [5 h. Y1 {( g+ {& ~; c6 L116
117
/ d1 |# V$ |7 _8 {7 S118
. I; M7 ?! q/ A# y$ [" w119
120
$ u; y/ u, `& n! L: I121
% I# ]. M$ D5 C122
; f% t3 X; ?$ G0 w- B, K123
124
125
126
( m' z0 u% a% Q, M! S127
128
) N% w: n4 ?' x; s9 A( R( M1 O129
130
7 x( n! _5 z( N' K' u7 ^+ J) w& _, j131
/ }7 \" Z# O0 G, I2 J132
* v: K. S; O! J& e; N* P. g133
' h5 u( Y0 W- k% {8 S134
135
, k/ |+ m7 Z: W- N6 S; x136
137
138
6 W1 w1 q) p! e& L/ H' r/ `139
1 c' X4 h; O8 j" |7 V- P140
141
# C9 d+ q, \) B& Y" l; W142
143
144
145
$ P% i  h! t' |146
" O& t7 r4 l9 c1 M9 x% e% Q5 \8 b147
148
149
5 Z' N5 D8 k) N1 h7 P0 B% C150
7 o  N: t+ b9 h. s2 V" b5 X$ l151
; y. t  t/ ~  ^8 `% X2 U152
153
154
4 v! k3 G$ y2 G$ P8 m155
156
157
158
159
; I" c2 j- _6 A# d* x% w160
5 h# L3 I- ]* w; Z161
! @" R9 N$ n$ z162
8 k6 V6 D0 b' ^  z9 n. |& F! w163
164
% j, a: m4 D' }  ?8 F+ o7 w$ D5 g165
166
. k$ X2 O8 k2 {0 W& ^% Y167
168
4 M, G( a; A, c0 C# ?; Z! `3 n169
" Y# s; K8 f% e3 D) O" a4 q170
171
172
173
; Z/ z% A$ e7 E* c每天进步一点点！
  Q, h* {: b/ \( W4 g; S6 [不进则退！


6 J6 G& a1 z% Z1 O版权声明：
原创博主：牛哄哄的柯南
博主原文链接：https://keafmd.blog.csdn.net/
* @) c1 o4 e1 n————————————————
版权声明：本文为CSDN博主「牛哄哄的柯南」的原创文章，遵循CC 4.0 BY-SA版权协议，转载请附上原文出处链接及本声明。
原文链接：https://blog.csdn.net/weixin_43883917/article/details/118193663
" x) L; V6 q. l. z6 L- t4 F
) Q* h0 C+ F9 X$ H7 v

1051373629

每天进步一点点！