数学建模社区-数学中国

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

---

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

经典十大排序算法（含升序降序，基数排序含负数排序）【Java版完整代码】【建议收藏系列】
经典十大排序算法【Java版完整代码】
写在前面的话
十大排序算法对比
2 i; x3 c9 v2 X4 ?  h% e5 v冒泡排序
! z# f( L; n4 K快速排序
直接选择排序
堆排序
- a1 ^( j! F* z& A5 Q; m+ a& e归并排序
" C: Y8 H. |3 \插入排序
希尔排序
计数排序
- N: I4 a3 H! t6 N桶排序
基数排序
完整测试类
写在前面的话
: J2 c/ I: L( v) w, @       虽然已经有很多人总结过这十大排序算法，优秀的文章也不少，但是Java完整版的好像不多，还存在某些文章代码存在错误的情况，同时也为了自己练手，决定把所有的写一遍巩固下，同时也真诚的希望阅读到这篇文章的小伙伴们可以自己去从头敲一遍，不要粘贴复制！希望我的文章对你有所帮助，每天进步一点点！！！
1 ^% w! u' G  M. P5 U
4 W% T( j  w( L8 e# t, ~( c
       我用通俗的理解写下对算法的解释，对某个算法的运行过程不是很理解的话或者想看比较官方的解释的话，单独搜索某个算法，看几篇不同的解释，就可以有自己的理解了，这里我主要展示代码以及进行通俗的解释！整起来，再强调一次，一定要自己敲一遍，这样才能理解的更深刻！


十大排序算法对比

  @# T- [  i& H  P. k. F
' E) `' V$ J( w0 v1 m' ]' F: X
* E, t$ k3 ^% T5 A
; L( T, t* P/ S: z: p- d$ A关于最后一列的稳定性，我稍微解释下，例如对序列：1 2 4 2 6 排序，序列中存在两个2，如果我们把这两个2标记上（让他俩不同），排序之后，前面的2还在前面，那么就称这种排序是稳定的，反之不稳定。
2 ]* I/ v" p4 X5 X4 k! j8 x

+ h4 @$ P+ n% s# @8 u0 F5 a冒泡排序
5 h+ ~7 [; A5 G6 t  |0 w! F简单解释：
' p0 ~0 @! b# }' E' `1 [       原理就如算法名字一样，就像水中的气泡一样，每次我都把最大的或最小的放到最后面，这样总共需要n-1趟即可完成排序，这就是第一层循环，第二次循环就是遍历未被固定的那些数（理解成数组左边的数，因为每层循环都会把最大或最小的数升到最右边固定起来，下次就不遍历这些数了），两层循环遍历结束后，所有的数就排好序了。
3 a3 d+ j. A" J       两层循环所以冒泡排序算法的时间复杂度是O(n 2 n^{2}n
  j" |" V) ]% H* {2
)，是一个非常高的时间复杂度，我在下面的代码进行了优化，加了一个标志位，如果上一次循环未发生交换，就说明已经是有序的了，就不继续下去了，反之继续进行下一轮。


  `, |; l" ?/ b( D1 C  M, X: ~
7 `' i$ v2 n% D/ B( V) g, `* _  z


' O" z. r3 k7 q0 S* M2 B本文的图片来源网络，仅用于大家学习，侵权联系删除！（下同）

1 p) n+ @; P% J9 p
* P% [# N9 d8 K, K( z7 y0 E2 o完整代码：
3 M$ \$ K* c" a

1 {0 u0 U( D0 x, N$ U, Apackage com.keafmd.Sequence;


/**
* Keafmd
*
* @ClassName: BubbleSort
& Q/ A5 V( H4 G5 L+ t * @Description: 冒泡排序
* @author: 牛哄哄的柯南
* @date: 2021-06-24 10:31
*/
% ^& [2 L( K/ j, Q0 |public class BubbleSort {


$ j$ Z' d& s1 D9 o    //冒泡排序
5 v2 f6 }, L7 @& q% }    public static void bubbleSort(int[] arr, boolean ascending) { //exchange标志表示为升序排序还是降序排序

" Z' r3 l8 h! r/ N9 K
" z& x2 a6 ^. ^/ M: F/ E% W        boolean flag = true; //加一个标志位，记录上一次是否发生了交换，如果是，我们则进行下一轮，如果没有，说明已经冒泡好了


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

            /*System.out.print("第"+i+"次遍历：");
            for (int i1 : arr) {
: A' j6 x: }0 I( p* S& {                System.out.print(i1+" ");
6 b5 u4 M* j: j, \2 H  f1 h1 q1 a            }
            System.out.println();*/
* ]- M0 J! V( }( t* B2 t6 d
1 T" L. u+ x8 g
            flag = false; //假定未交换
3 {# f/ z# k$ ~* t; ^
5 `2 u% y* y) n
, p( I% l/ s! L' ~9 t" p8 l& n1 m. X            for (int j = 0; j < arr.length - i; j++) {
% N$ c( X4 L" j+ d! h4 m
' G3 a* _4 S1 a
                if (ascending ? arr[j] > arr[j + 1] : arr[j] < arr[j + 1]) { //控制升序还是降序
! a' y8 I. X7 W$ O% |1 r3 V/ m                    int temp = arr[j];
                    arr[j] = arr[j + 1];
                    arr[j + 1] = temp;
% W3 r: ?$ Y5 T                    flag = true;
                }
' Y$ ]+ f9 u) a# `' J" h9 h
2 X) l( _$ V- \  ^% d' d) O) M
            }
        }
+ h$ Z6 |; E& l! Y6 B8 p# ]    }
$ A' D% r% L9 t& W( o6 V$ x

    //冒泡排序 -- 默认不传参升序
) M9 Q8 Y" r; k5 S9 x    public static void bubbleSort(int[] arr) {
: V  H: l' Q9 C' L1 K( l2 h1 K        bubbleSort(arr, true);
3 H% F" f8 Y7 \5 S: n. \- ~    }
}
& L6 s0 z  f. l+ j: C  `1
2
$ [) ]. y- m7 x) D7 [3
1 a0 x  Z/ ~! f! e6 [* y, c4
5
1 M. `% H' e2 g7 C6
' {! Y# y, p3 g* l* d. H) x7
8
9
10
. a. x! {+ m" e0 Y. L4 M  @11
12
13
14
, L7 X) n8 d. s* M0 h: [15
16
; }$ a1 u+ p, q  W( R- @. d17
; e8 Y# ^: U% W0 R! V18
2 N8 e! z# Z! s- N/ I- b! O, E19
20
; M* \* X, R' s) H# x3 ~( Z21
22
1 _; c  ]) ], S  ?2 ^23
4 e2 q9 K- K3 }9 _5 M) r5 c- T" o+ |24
) ?* u& d( K9 o: l6 H25
5 [$ d' D* X4 n: D26
27
6 M1 {  \5 _$ h; B28
$ b* M/ A" ~( l! t; h29
30
31
32
0 n. E9 J6 k& M* ?" M33
! F! n0 Q& L8 n& i34
35
36
( H* S" o$ z2 L+ e# L37
38
% L8 h% V2 D# [) ~. r) B" j39
40
41
42
; `: q! j5 O$ A# b43
44
45
测试代码：

" i9 v) I/ b0 B+ [2 ], o
3 P" O' G5 s6 ?3 _升序排序（从小到大）
9 N* n. q5 E4 [. Z+ J8 ?, i
; u& O8 h8 T, f# @& K, h9 p
; Q7 N: ]6 h- j/ `% U0 t: S9 fpackage com.keafmd.Sequence;
; G# F. T$ d( r2 }. U9 @9 v. S
' s/ g( _' p  L
% |8 [2 L+ I$ ~0 p. Yimport java.util.*;
4 V% ?# x4 {2 u8 Kimport java.util.stream.IntStream;
3 w0 y, i0 Q2 B. G/ ^: cimport java.util.stream.Stream;
" i( v5 {9 s3 O" v3 u5 f9 U" D9 l
1 Y* t/ _2 [  Z- m; f/ B% e5 i
/**
* Keafmd
*
0 H! Q1 \* u- c * @ClassName: Sort
8 N# p- u" M+ Z- r& X4 P- P * @Description: 十大排序算法
+ L6 ?4 a6 T: t * @author: 牛哄哄的柯南
" C* q8 s* g1 e+ a) X * @date: 2021-06-16 21:27
4 c( d; u- }9 G) `! l */
public class Sort {
7 l" @: A' ]' Z: |  r0 D    public static void main(String[] args) {


& {7 d. G' ]% P9 P$ {  i+ u1 n        int[] nums = {12, 4, 25, 47, 58, 34, 25, 9, 99, 26, 1, -13, 162, 10093, -66, -1};
: `' d# C% l% ?1 P  D# B' a" t9 P        int[] temparr;

9 c& D1 ~3 ]& q. U5 M
        //测试冒泡排序
        System.out.println("测试冒泡排序:");
        temparr = nums.clone();
        BubbleSort.bubbleSort(temparr);
        //逆序排序
4 x- Y  U# q3 T! ^9 A) c        //BubbleSort.bubbleSort(temparr,false);
        for (int i = 0; i < temparr.length; i++) {
; ^& \% F, N! r" }) ]2 M+ [$ F            System.out.print(temparr + " ");
& {# }3 @. F# o, q# w        }
        System.out.println();
5 `6 x( H. q) a
6 y& z, x6 Y4 V  m: k
    }
}
. k/ _" s$ z% X! l$ J) F1
0 s; O. y" O, E: E2 @2
3
1 w0 b! ^4 T. s# W5 c7 R- Y4
5
& O% @0 u9 j3 Q+ U6
# O8 e+ e' z, @7
2 Z. n$ z/ w8 o2 E6 r3 n* T8
9
10
( m/ g6 R* |+ ~+ @) p( e( r11
12
13
14
  E6 i: r- \. j: B+ z% J15
3 b5 ]5 D7 }. Y% e16
17
2 `, X; c6 o4 P" Z: N. i7 x18
19
20
21
22
' M) I  T9 s, ~' k* n' z23
; F% J( s( _/ ^- U' L24
25
26
27
28
3 v% U) @2 N  {29
& |6 \+ a$ X) Y, z4 i' M+ z30
% t* o/ e; z+ m7 r' e7 y! G31
+ U2 v7 L$ n$ b& w( ~* a- h32
33
运行结果：

6 s  d- ^4 P+ B5 h# b9 q0 g
6 }$ U9 v: R7 |  d! K  g测试冒泡排序:
-66 -13 -1 1 4 9 12 25 25 26 34 47 58 99 162 10093
4 n0 I7 {% O3 I* r# g# q1
2
降序排序（从大到小）
; D( B8 ?5 w+ d/ D2 j" M

//测试冒泡排序
System.out.println("测试冒泡排序:");
temparr = nums.clone();
BubbleSort.bubbleSort(temparr,false);
7 M3 q! M( [) k: {9 gfor (int i = 0; i < temparr.length; i++) {
    System.out.print(temparr + " ");
0 r  q  h) G" }. k  _) B}
System.out.println();
1
% J' R! @* U! f# {; ^5 G2
, {) t0 e. @( X5 a  m) q3
( j# `( V6 [4 F' b  E9 j- O3 n  h- D8 [4
5
6
  J: Z- n  V* \7
/ `9 ~. {1 }2 R) W& J1 h' d/ ~4 e8
+ R* X1 a' ^' x' l5 r0 w( I- Y运行结果：
8 z+ {6 z! T' D2 C; C/ a

! f7 Y! r, U7 q3 o# z, c& o测试冒泡排序:
; X0 X) [# v7 B10093 162 99 58 47 34 26 25 25 12 9 4 1 -1 -13 -66
1
: I( x) N. j2 A& H" u2
下面几个算法的测试也就是换了下类名和方法名（换成相应的排序算法），如果想降序就在数组后面传个false即可。我就不一一复制了，我在最下面给出含所有算法的测试类，需要的自取即可。

1 V+ b8 d" R8 F9 U. P# A
快速排序
* I' |; f8 {  r) X0 L" i1 j简单解释：
; R  O. i5 }1 V+ F) h$ D4 r快速排序就是每次找一个基点（第一个元素），然后两个哨兵，一个从最前面往后走，一个从最后面往前面走，如果后面那个哨兵找到了一个比基点大的数停下来，前面那个哨兵找到比基点大的数停下来，然后交换两个哨兵找到的数，如果找不到最后两个哨兵就会碰到一起就结束，最后交换基点和哨兵相遇的地方的元素，然后就将一个序列分为比基点小的一部分和比基点大的一部分，然后递归左半部分和右半部分，最后的结果就是有序的了。




, M* p9 `; F, K5 g3 r
; u4 @: v2 c* a6 j* A; ~& w. z3 @
& E. d2 ^2 T/ X7 U! L完整代码：
# ]. X) |+ `  z

package com.keafmd.Sequence;

! _# M7 r/ n$ i8 \  x
/**
* Keafmd
! p9 u1 Z' f0 y9 B7 F/ a& O4 m *
* @ClassName: QuickSort
* @Description: 快速排序
6 H& t3 p$ E% @1 X2 Z * @author: 牛哄哄的柯南
) C9 Y- E+ n! q0 m( ? * @date: 2021-06-24 10:32
* F& C+ ?1 `% y6 e1 U9 g# z */
7 c3 Y* q! D' ^( p4 C2 {/ Qpublic class QuickSort {


    //快速排序
    public static void quickSort(int[] arr) {
/ _. `) H9 p; x% V        quickSort(arr, true);
- {9 O" s& Z! u/ ^    }


( j2 y2 S" H+ ], w# @: F$ h! X$ W    public static void quickSort(int[] arr, boolean ascending) {
        if (ascending) {
            quickSort(arr, 0, arr.length - 1, true);
; y8 H0 `5 b% |  Z  m        } else {
0 [4 r: `9 g0 ?) E- f  ^  k$ q            quickSort(arr, 0, arr.length - 1, false);
+ ^4 [' w4 e* i        }
    }
  h- [4 ~4 n: J

    public static void quickSort(int[] arr, int begin, int end, boolean ascending) {
        if (ascending)
1 e9 h1 b6 U) s" {* ]8 `9 r            quickSort(arr, begin, end);
        else
            quickSortDescending(arr, begin, end);
    }

6 T: K; o5 {1 Z+ G) }: x
    //快排序升序 -- 默认
3 \1 ]  W' k3 w& g! Q7 R    public static void quickSort(int[] arr, int begin, int end) {
        if (begin > end) { //结束条件
            return;
        }
        int base = arr[begin];
        int i = begin, j = end;
7 g- X* j5 u  F9 O/ V        while (i < j) { // 两个哨兵（i左边，j右边）没有相遇
            while (arr[j] >= base && i < j) { //哨兵j没找到比base小的
                j--;
            }
            while (arr <= base && i < j) { //哨兵i没找到比base大的
3 Q6 g) y9 _# E1 z3 A3 @                i++;
& }0 D# B+ t" v/ a+ Y! T            }
            if (i < j) { //如果满足条件则交换
                int temp = arr;
9 M! p6 y& B1 X: i                arr = arr[j];
7 h! G$ z2 ?: M6 r                arr[j] = temp;
8 k: t  I2 U2 |            }
+ L5 c) D, ~7 T* m; m

        }
        //最后将基准为与i和j相等位置的数字交换
" s7 H+ ~* y  d8 c+ R! N& a        arr[begin] = arr;
/ p8 U; B1 V+ M: @! g3 {" t        arr = base;
4 a' Q( ~% d* I* b3 [        quickSort(arr, begin, i - 1); //递归调用左半数组
        quickSort(arr, i + 1, end); //递归调用右半数组
/ L6 P  Y& v# f, K) h% _, J
* n+ j2 x# z8 m
/ p% p; f: E0 B3 H) F    }

- M* o$ f  H4 H# G% F; O( ~
    //快排序降序
6 F$ r8 j( l& I0 h8 y6 }, h, l0 Q    public static void quickSortDescending(int[] arr, int begin, int end) {
: ^( b8 N  r& o) W" Q8 u( b        if (begin > end) { //结束条件
+ l7 S) t* D  [4 j2 |            return;
        }
7 q$ S2 O) g0 j        int base = arr[begin];
4 }* B1 d( ]* ~0 V% ?# e2 D        int i = begin, j = end;
        while (i < j) { // 两个哨兵（i左边，j右边）没有相遇
8 X9 _! X1 L9 k1 X- M  f            while (arr[j] <= base && i < j) { //哨兵j没找到比base大的
                j--;
            }
            while (arr >= base && i < j) { //哨兵i没找到比base小的
                i++;
& H& s' x( q5 r+ N! Q" W/ ?            }
; @$ j, w) U. J' k+ Z  R            if (i < j) { //如果满足条件则交换
                int temp = arr;
                arr = arr[j];
3 H  }6 Z+ d; U6 @" x                arr[j] = temp;
4 J6 O, L$ b" H" `2 v+ L            }

/ w8 O0 I3 r) Y- t6 ~
        }
        //最后将基准为与i和j相等位置的数字交换
        arr[begin] = arr;
        arr = base;
. I' `; y# Y4 C' x) k3 a        quickSortDescending(arr, begin, i - 1); //递归调用左半数组
        quickSortDescending(arr, i + 1, end); //递归调用右半数组

8 _  ]0 r& `" ]3 q3 ?% z/ O/ J
    }
" K2 u( E' I5 d/ s

( b4 m" Q( X, y1 n. B5 B1 W2 ]}
1
. D, m% `8 n4 c# |7 e2
, \* P- L! A2 u6 i: w( L& ]3
# b* ^# [, N; t9 w! [1 b4
9 I" H0 o8 g  R5 n+ R  ]5
# s" ]6 u8 q. i( b6
* F/ y6 K. Z; |1 K: t7
8
: i2 i2 a  v+ Z* B4 L. k$ \9
10
! T- i/ x* f( B$ |  ~2 R+ ]& s. D& v  M11
) s1 {& u* ~% |" U& ?12
9 S8 N  p) C5 L) \+ L! K13
14
. r. ?( m+ d% i. C* k( u15
16
17
) Q% H3 j3 C- R; U9 o6 M1 w18
19
20
! n/ l; D/ O# p: e' c7 h$ E6 h3 u21
22
23
24
25
26
; K, T, ^8 I5 [3 u. _27
28
29
, n' r! B8 m& y* [' a5 U* c4 d30
9 }! T' L7 u8 h# i- z31
32
+ b) r9 i& D; M; g7 t) K- ?' B, g33
34
35
+ Q# Z% B' b4 F. ~36
37
& E7 P% }1 O4 A38
5 D: P$ G* G% l+ v! c9 d; L39
. a* ^. I: _: o4 K6 P40
41
8 p- X  V5 E+ B  v4 Y42
( w+ ~. a$ E5 Q2 x: E9 K( a$ I43
3 u$ _8 y+ U7 j3 }" r; b44
45
2 {( \+ f8 i/ c46
+ b% x, ~- D' L0 e47
48
49
& F8 h9 u; V/ Q0 U: i% @50
& |& ]" d, g7 V8 A! f3 c- r2 K1 F# c51
; G4 P9 f. A' b* ^( l# h6 ^( _52
; C6 P2 K) `9 a( B/ k3 |+ t53
54
55
( s1 u/ @8 Z8 x+ Y( {6 v56
, c& ^0 q0 T$ U$ a; `# C57
" @. H- f$ H) Y( H2 l58
59
60
" k3 q1 s% |2 b3 z61
62
7 E! T3 C& w7 q5 y$ F' o3 }4 ?63
64
65
9 h( J0 j' O0 n, E66
67
68
69
' ?) D' _5 l% @" f1 C, N70
71
  _. ?8 i; H/ B* D72
2 R, w' X9 S' |) _73
74
75
76
& W4 B; W' p" i+ E, q/ p77
9 m( ?- e  _2 ~( Q; d78
- {$ |7 G, H# T) `9 ^79
80
) l; `+ d, A& O' @  d9 a81
; }1 Y2 {' ?7 T; ~1 O3 b% F4 |82
7 `8 w5 H/ K3 ^: k83
% r( t: _4 r4 K5 z, C84
6 O4 Z7 U8 p, r" o- j+ J, E85
+ ?! A3 S, E4 q# j; o" X86
87
! h$ U, T0 R( ]88
# x8 m; Q* N& J6 ]& R& s& N89
90
91
$ v$ v) _3 Q8 T- x8 K直接选择排序
简单解释：
数组分为已排序部分（前面）和待排序序列（后面）
第一次肯定所有的数都是待排序的
+ J1 m. L# M- g' C5 p5 X& j从待排序的序列中找到最大或最小的那个元素，放到前面的已排序部分，然后一直找，不断缩小待排序的范围，直到所有的数都是已排序的了

6 E6 J4 x) ~; x  V
! r5 Z7 @4 D5 A" x
9 m4 ~* s& s0 _0 x' b9 f' c, z


完整代码：


' [2 c. \$ R1 ^- ~) @package com.keafmd.Sequence;

9 A- h  C5 [* B* i5 z* c
/**
* Keafmd
*
* @ClassName: SelectSort
* @Description: 选择排序
, k7 M0 \* k9 I8 C0 G* b$ I * @author: 牛哄哄的柯南
& ]1 Y/ ^) _) X' u' q; ~5 J9 N * @date: 2021-06-24 10:33
*/
public class SelectSort {
9 ?  q/ V. l' s2 O% [6 [
8 m9 S5 s% T5 t" g
    //直接选择排序
    public static void selectSort(int[] arr, boolean ascending) {
  W- u/ ?# E8 J$ z$ h        for (int i = 0; i < arr.length; i++) {
$ J( ~% s. j9 s7 o& j! h) ^            int m = i; //最小值或最小值的下标
            for (int j = i + 1; j < arr.length; j++) {
% K* |- X4 [! x! e% F                if (ascending ? arr[j] < arr[m] : arr[j] > arr[m]) {
                    m = j; //找到待排序的数中最小或最大的那个数，记录下标
                }

( H! z7 N5 c' r9 S/ w3 c9 |
9 z# M3 l0 k% b% h. k) x            }
            //交换位置
& K# S/ `& Z: ]( \            int temp = arr;
" x& u$ i0 V5 R) N  ?& w; ^            arr = arr[m];
' p* o# b7 g; u" Y# ]" M9 x. T  \% [            arr[m] = temp;


        }
: b8 k1 ?4 s8 ?4 q. }9 l  C    }
) f. t9 D$ ?4 A

    public static void selectSort(int[] arr) {
2 Q0 j* `  s/ N        selectSort(arr, true);
# t+ \$ a4 q2 d4 p  N    }
3 m6 t/ \" n5 b/ R# r' B8 M}
; D+ P$ [6 O! r& I# g0 L1
2
- Z8 y; q* w  k5 h3
4
3 K+ _) P; L  `  l6 Y5
6
+ f7 l7 z* C) Q; w+ r" B2 [4 |0 |0 Q7
8
8 T) [. j9 O: Z# q  p4 K9
10
11
12
13
' F( I* a! |3 ]9 ?; R14
15
16
17
) g2 ^" s  A2 N- ^  g18
) V1 Q/ s; \5 w+ H2 r) S19
20
. i# n. T* J! s2 }# C9 o21
22
23
24
25
26
! N6 z) `- Y! E/ `" o27
28
- ~+ U) l  X3 q( d$ f29
. c" ?; D3 t/ [' r: ]30
31
32
33
" L9 `0 G& g+ F) ^9 [' q1 ^+ G# U34
堆排序
7 o+ \/ W; `" C; V先理解下大顶堆和小顶堆，看图
大顶堆，双亲结点的值比每一个孩子结点的值都要大。根结点值最大
0 B+ a8 Y9 e, C小顶堆，双亲结点的值比每一个孩子结点的值都要小。根结点值最小



  Y" P. p% Q1 m8 D9 |: a! r7 i
简单解释：
$ E. X) J8 ~9 w# J: j构建好大顶堆或小顶堆结构，这样最上面的就是最大值或最小值，那么我们取出堆顶元素，然后重新构建结构，一直取，一直重新构建，那么最后达到排序的效果了。
1 @1 @" d6 U. o6 X
/ H; s+ h! i# m
: V5 o' _* f6 t



完整代码：
: I  \$ _4 r6 ]! w8 `% \

  u! ^2 `9 e/ Z- [package com.keafmd.Sequence;
" R( z! I7 c9 N
7 t1 C0 Z! F3 Q' Q  N
3 H8 w0 i8 o* ~/**
- g% o/ w" v' S3 W) E  M/ h * Keafmd
3 }% Q! X: P1 K/ U *
* @ClassName: HeapSort
7 b2 e9 M) N, Z) \, ] * @Description: 堆排序
* @author: 牛哄哄的柯南
/ `+ ^3 K8 G) T& m * @date: 2021-06-24 10:34
" ?9 O1 ^* C# [9 t# T4 q" H */
$ o) D$ P, a" ^7 x1 Q2 c% u" upublic class HeapSort {


5 n* t# }- y& ~  E( t& N0 @    //堆排序
    public static void heapSort(int[] arr) {
6 t. E- `$ w3 v: e! @4 h9 G: ~        //对传入的数组进行建立堆，这里默认建立大顶堆，进行升序排列
        heapSort(arr, true);
    }

0 g, N# s. }7 j1 b* \3 H' N. H
    public static void heapSort(int[] arr, boolean maxheap) {
" l0 g. n2 e1 D

        //1.构建大顶堆
        for (int i = arr.length / 2 - 1; i >= 0; i--) {
            //从第一个非叶子结点从下至上，从右至左调整结构
            sift(arr, i, arr.length , maxheap);
, I& j8 l% j+ E9 v" l        }
+ L$ ]# i, y& S( ~* ]
. F) w' A+ O$ O# J' G# q& D0 b
        //2.调整堆结构+交换堆顶元素与末尾元素
; g( n# m$ q: n& m( S0 p' r& c5 o8 A        for (int j = arr.length - 1; j > 0; j--) {
& \+ b- c- u) ?% Y( \4 [* H/ H1 Y
7 y" Q8 D& }: `9 t
            //现在的数组第一个就是根结点，最小值所在，进行交换，把它放到最右边
            int temp = arr[j];
            arr[j] = arr[0];
            arr[0] = temp;


, i' H( _8 m- |( |# Q9 Y: W0 Q            //重新建立堆
8 T! M5 `/ f$ ~" X5 @& ~            sift(arr, 0, j , maxheap); //重新对堆进行调整
        }
+ S3 `, A. h% X) n' o    }
( F: {& o$ E5 F( C, u, r5 u- H

& Y: {' J( ^8 C1 W' ~7 w8 e    //建立堆的方法
8 t2 W" U' D6 i7 u. b    /**
+ d* k, w! {& i7 {) G; Z$ ~8 K     * 私有方法，只允许被堆排序调用
     *
- [5 [5 K7 \5 X" y, m     * @param arr     要排序数组
& K8 o9 l& U3 u! H, [3 g6 B: q# Y     * @param parent  当前的双亲节点
2 I4 z2 W9 z& y- s" g3 G% Z     * @param len     数组长度
% Q* g" @) c  }8 E; R8 u, d  _     * @param maxheap 是否建立大顶堆
     */
9 n# H0 S% r' s    private static void sift(int[] arr, int parent, int len, boolean maxheap) {
9 I4 L" j% [( e. A. F$ D
3 Q$ r% g' i: T, _4 A0 S( U. H
8 A3 O$ Q, ]) u/ `3 |# G) e        int value = arr[parent]; //先取出当前元素i
5 L9 v( e* c( ~. m+ |  Q3 y* A" ]
. P1 G! C( {' L+ K3 [
        for (int child = 2 * parent + 1; child < len; child = child * 2 + 1) { //从parent结点的左子结点开始，也就是2*parent+1处开始

! W  x, A* S6 g+ Y
9 N, }5 Q/ D% z, M3 N% n+ Y8 E            if (child+1 < len && (maxheap ? arr[child] < arr[child + 1] : arr[child] > arr[child + 1])) { //如果左子结点小于右子结点，child指向右子结点
                child++; //右孩子如果比左孩子大，我们就将现在的孩子换到右孩子
% p8 D) t5 P& q0 c            }
  ?6 ?1 y3 o) X% T$ g

            //判断是否符合大顶堆的特性， 如果右孩子大于双亲，自然左孩子也大于双亲，符合
            //如果子节点大于父节点，将子节点值赋给父节点（不用进行交换)
. y/ p* f+ H4 }0 L            if (maxheap ? value < arr[child] : value > arr[child]) {
                arr[parent]=arr[child];
; a4 L% S: o- `1 G' u                parent = child;
& l1 P9 C/ Q$ G7 k7 a  t. f& o            }
$ @- P' w! R, o, }2 e$ R            else {//如果不是，说明已经符合我们的要求了。
9 T$ U' c0 O- `6 R                break;
' s7 e9 E' y& M$ i            }
        }
        arr[parent] =value; //将value值放到最终的位置

. l' w. N& J$ n7 r! Q

% `5 z( r$ h( N) Y* s8 ^
% _3 j( o0 d5 O8 i/ U% H' y    }
- T+ A! p3 n+ N: n* h# t7 t
( [) U/ A: R4 a+ {: d0 t2 i4 X
}
1
2
3
1 }3 O3 G4 d, h5 W' u1 [9 F4
5
1 a; \3 X! F5 j* Q6
7
8
+ @+ i( f; I3 N5 E9
10
11
( K" E  V- |3 l- Z$ J" C6 d0 B12
& ?- r* p$ E" Y13
14
8 A4 q; l$ j( J3 v8 @, e15
- q( r4 E+ f/ u: [; @16
17
18
* d# r, J9 z; x9 M% ]& g19
20
21
7 O- F4 c8 h. `6 X2 \3 X22
23
24
3 s( n+ G* q( s$ B3 ?25
26
8 V# c; l  V: D, t# Q0 Z! t27
28
29
30
31
/ W2 d# X8 i1 b2 e. e/ K7 P- i32
; q2 K+ U. Y' [- f' Z; K/ ]33
! n" C) ^; f! r6 E- q* V; s34
35
# {& C, O) {( p36
37
+ c( l$ r. o# E38
$ P3 K4 Y9 M& J; T  u$ i: u% a2 h39
3 G( R7 P1 i- P+ R) c$ |6 I3 p40
41
  x) L2 ]5 c4 I3 Q8 W8 ]+ s42
43
44
: l% c. R& q" X4 J4 m9 u45
! h/ f) Q. J+ X# B6 ]4 t46
47
48
49
  U' J" J/ L; X, I: G50
& h' `6 e  C/ [% [1 }" w: f5 y51
5 U5 s2 _2 M2 B" V0 U+ s! Z52
53
" Z* `& F! U: z( T54
8 H) i+ V5 b* ]/ F! m: _( n  i$ K% v) p3 z55
56
% u0 q, p" w& x! {: t57
# O% @) |6 C1 ]; I58
59
8 k' F; L+ w. k5 t/ K0 }60
* Q9 }7 B6 p% N& p  ]! l( c2 n61
62
63
64
65
66
2 x) T( u" Q5 O  R& `  n- k67
68
69
70
71
# c$ N3 Q8 P" s  c8 }$ l3 U72
73
3 Y5 T3 }7 }0 a' C  P9 Q( P' {74
! z( A% Q; j5 F8 P( f归并排序
- W) U; @, j/ H: Q' N4 H简单解释：
& a( [5 O4 t- }3 v3 S  V' `该算法是采用分治法，把数组不断分割，直至成为单个元素，然后比较再合并（合并的过程就是两部分分别从头开始比较，取出最小或最大元素的放到新的区域内，继续取两部分中最大或最小的元素，直到这两部分合并完，最后所有的都合并完，最后形成完整的有序序列）


8 {6 o% `: X' e3 _& c
& I' l6 W" R6 e4 {7 J) z7 V0 ^


. `4 d- ]2 z3 S# w& p0 y完整代码：
* K0 m9 c9 X" M/ y7 V* `
2 e& Q8 |7 W( V" {' I- c) }
package com.keafmd.Sequence;


, q2 p6 U9 {& C/ a3 i; o6 q/**
* Keafmd
$ y& C+ f7 V4 \! U9 E *
9 m; O3 @. O+ K0 A: S * @ClassName: MergeSort
* @Description: 归并排序
. H$ ^3 M  |. n$ H" [' J2 x * @author: 牛哄哄的柯南
4 h* M; e/ b) y * @date: 2021-06-24 10:35
( }+ T7 M# s: L. u& `" e. g0 C */
public class MergeSort {


    //归并排序
    public static void mergeSort(int []arr ,boolean ascending){
9 J- y( I3 s8 j        int[] temp = new int[arr.length]; //在排序前，先建好一个长度等于原数组长度的临时数组，避免递归中频繁开辟空间
        mergeSort(arr,0,arr.length-1,temp,ascending);
    }
    public static void mergeSort(int []arr){
        mergeSort(arr,true);
    }
. F1 @; f. A: d9 a/ p0 {) h! t

    /**
( s5 p4 [+ L3 u+ Q7 M     *
     * @param arr 传入的数组
5 e% w& G* W! g& [! J6 `     * @param left 当前子数组的起始下标
     * @param right 当前子数组的结束下标
     * @param temp 拷贝暂存数组
     */
    public static void mergeSort(int []arr,int left,int right,int[] temp,boolean ascending){
        if(left<right){ //这里是递归结束的条件，我们是对半分，那当left==right的时候肯定大家都是只有一个元素了。
- ?/ _& B# V/ D

            //对半分，比如总长度是10，left=0，right=9，mid=4确实是中间分了，0~4，5~9
% Z- t7 o! i6 T4 K* L. L            //当长度9，left=0，right=8，mid=4，0~4，5~8
& z8 Q3 t" d* x" _* g; k            int mid = left + (right-left)/2; // 防止越界的写法
% ~$ U0 F5 y5 d# Y1 [            //int mid = (left+right)/2;
! b: ]: x9 s" H2 b$ z( `9 F& N

            mergeSort(arr,left,mid,temp,ascending); //左边归并排序，使得左子序列有序
            mergeSort(arr,mid+1,right,temp,ascending); //右边归并排序，使得右子序列有序
4 Z& v' t6 ~% v$ g

; [" |5 ~8 y5 l! V  D            merge(arr,left,mid,right,temp,ascending); //将两个有序子数组合并操作
- p" j- J+ ~- c9 b' F: F8 e+ Q: y        }
    }
- g  ]* Y+ F, q# N9 H! \

' g5 c3 r% |: Y( Z    private static void merge(int[] arr,int left,int mid,int right,int[] temp,boolean ascending){
        int i = left; //左序列起始下标
+ t$ {$ Z" d$ x        int j = mid+1; //右序列起始下标
        int t = 0; //临时数组指针
3 C- K+ Y) Z$ [' r. p/ j" t  [        while(i<=mid&&j<=right){
            if(ascending?arr<arr[j]:arr>arr[j]){ //比较两个序列第一个元素谁小，谁小先拷贝谁到temp，然后对应子序列下标加1
                temp[t++] = arr[i++];
& O, {$ m; C0 k            }else {
                temp[t++] = arr[j++];
" W0 }2 `" |1 _/ E9 }" q2 h            }
        }
2 V) ?( m. @* q& O
$ L- Y3 Y$ ^% X, V
        while(i<=mid){ //将左边剩余元素填充进temp中——左序列有一些数总是比右边的大的数
" V( A9 X* E; `) \1 d            temp[t++] = arr[i++];
( k- u' ^/ v, G        }
# f& z0 y  O9 L" P
* \7 y3 S' T+ q3 C- U
        while(j<=right){ //将右序列剩余元素填充进temp中——右序列有一些数总是比左边的大的数
- W: g; _2 H: z0 C$ u            temp[t++] = arr[j++];
/ {: Z( T7 B, r$ Z8 b        }
, e5 M9 [, _# Q8 |) Z& Y; b4 K

        t = 0;
; J/ t  v! a/ A( D. P9 q4 j5 u
/ t9 H. G8 V, @! M4 S6 B/ L
        //将temp中的元素全部拷贝到原数组中
        while(left<=right){
            arr[left++] = temp[t++];
; T  J2 l) O" n6 l% v1 X3 z        }
/ J; R/ @2 N4 O6 e* p0 V0 Z
  i4 S( X/ }5 B) z! {
    }


}
: h5 |; @# D3 o. q4 Q1
8 o- ~: Z& f9 q6 H2
3
) @2 m* B; q! g9 ]9 P0 Q3 z& A0 j4
: d2 n! f: K9 H5 J  \5
6 H: |1 t" h) s- t  B6
! w9 W7 z0 H: G# k! v7
& t! n7 c! m7 f- e  f# `# D! k& H8
9
10
5 r; x/ z7 f% L# @$ G: y: }5 A11
) Y- G# c0 }6 b7 _5 J$ h2 l* j/ a12
: t1 p: K; a. Z5 a13
14
, d5 U. O9 V+ [% j5 i; n15
16
8 _, C$ n' x8 _0 I17
18
+ `0 l  h; `7 T4 g0 I19
) X% O* v3 w( K, F: M' X20
) X! c4 K* D5 D21
. u) }5 \0 l! a8 ~* O22
+ {; B3 a; P/ j. I9 @  R4 A23
24
5 J1 Q* Z- a/ }" ?) w" X* D0 o  D25
26
27
4 E- ~7 _( u5 v- S& A" p7 R+ e28
29
  c7 l! K0 S* v% d" K4 ?30
31
32
33
34
6 F' w7 F+ h8 V# s2 n35
- k) W5 t% H6 E9 ~* p) G* Z36
37
38
39
3 I. Q4 ?+ c1 V1 U1 S40
  z- [& L, d- z# W41
42
; x% b6 I+ V3 m2 J+ [' v( x& U0 s6 i* G43
7 w* \6 T2 v* A  ~4 @0 z) M% w44
45
46
47
6 {, Z% _( r! P; f! I  n48
/ K4 k; O9 e' o. u49
50
$ r2 {, Q& d( w& U) |- a. o51
52
53
54
55
56
$ T6 d) C' w% p* w$ _) \0 y3 ~57
58
4 _0 }- }1 P9 v" S. |" ]( h8 C5 v59
60
2 d$ m+ w" U: z6 f! |! L2 m( h61
62
% x& a% a8 w# c; Y+ V4 H) D63
2 c( @3 _( X1 z4 p$ o64
3 ]8 y, e8 @% u  Y6 I65
66
, M: l, K, f3 ^8 {67
68
69
70
, ~) g9 ]9 i9 f$ u* p8 V; Z; N71
1 V, E; l# [0 p% z+ a0 }72
, p6 N: W: q7 ?8 [* c- `73
+ Y. b" Z7 f' G  E# \% u插入排序
1 ~! C& N: R, O/ c" Q简单解释：
最简单的理解就是打地主时我们拿到牌后的整理过程，从第二个牌（假设我们拿起来这个牌开始比较）开始，（说下升序）从后往前比较如果比前面的那个牌小，就把牌往后移动，直到找到一个合适的位置（这个位置的前面的那个牌不比这个要放下的牌大）就把这个牌放到这个位置，慢慢的前面的部分变得有序，直至全部有序即可。


  X. m. _  ?" }) _  |) j
- T5 C+ ~( e1 l$ C1 o5 E  i


0 ], t+ w  x* q2 k6 a% a  B$ b$ X8 H完整代码：


# I/ e5 f2 e1 h# G. |' Tpackage com.keafmd.Sequence;
1 t& \* s! E8 c1 T
& @8 i1 _& }' G/ D3 Z) ~8 i. k
: ~( U! T- B. f% V+ ?  P9 Q0 T1 K6 K3 ~/**
/ P1 X% H, I' H$ V5 k" D' U" a7 ?9 P * Keafmd
- Z1 k$ l3 x/ m *
* @ClassName: StraghtInsertSort
* @Description: 插入排序
* @author: 牛哄哄的柯南
, N6 Z. m7 m7 c3 a: b: u * @date: 2021-06-24 10:36
*/
' l2 Y0 [+ y! n% w! Upublic class StraghtInsertSort {
    //插入排序
4 V: f* i; X0 y    public static void straghtInsertSort(int[] arr) {
        straghtInsertSort(arr, true);//默认进行升序
    }


    public static void straghtInsertSort(int[] arr, boolean ascending) {
; Q+ }9 w" I1 [+ D" x( @

$ v  Z; D; N% j) W4 k) Z0 h        for (int i = 1; i < arr.length; i++) {
9 ~  K; a7 }+ [5 `            int temp = arr;
            int j=0; //这就是那个合适的位置
' @  ~, ^( \  I  o/ C, Z# H# O0 }- i            for (j = i - 1; j >= 0 && (ascending ? temp < arr[j] : temp > arr[j]); j--) {
" ~/ o# p0 a  c& j2 L$ W                arr[j + 1] = arr[j];
; c& {5 U( [  X7 J8 h3 n            }
$ G- A7 t/ c$ ?3 {0 [3 \6 t            //把牌放下，为啥是j+1，
            //是因为上面的循环遍历到不符合情况的时候 j是合适的位置的前面的那个数的位置
            //有点拗口，但是就是这个意思，看图方便理解下
6 V- b1 a7 x$ _4 Z            arr[j + 1] = temp;

7 k# F: e. W0 ~

' \; G" w' M5 V" Q
        }

2 R6 X3 S# I& \; z" X. U
* S8 W# n  @6 J' k! ~  }    }
}
% Z, i) {# l& v# \! s1
( {# {! B* `. w" z2
% |# H0 U1 K0 t6 w3
4
5
2 m  w' J6 s; ^4 Z6 d! h; a9 z- ?6
6 x: F; l* P4 A7
8
9
9 |+ G! Y# a4 j7 ]  t10
' \5 x: k2 C+ R7 U0 B11
12
13
, _& l6 \2 [: h/ @14
) {; k3 m6 ~7 L! c15
; @2 P, L6 F, `7 {  m: L+ D16
17
, u' f# U! H9 b18
% f% g. e; k: d9 D4 x( ~19
9 U$ P. L% ]( \# w5 ~4 B$ x20
# O7 x* Y% m- |21
+ ]! _* E0 I' w  G  e! \22
23
7 R* w1 U2 A) D, p24
25
2 K8 |1 |% D  O2 n+ `+ y7 D: I26
27
28
29
30
31
32
+ _) Z0 G, o5 X5 F) }33
) w' L  e9 p/ K$ X7 |34
: u5 x0 `0 @: D; T( b希尔排序
简单解释：
希尔排序是插入排序的改进版，我们理解一个叫做下标差的的东西，也就是下面那个图中的增量d，初始下标差为arr.length/2，然后继续/2，对在同一下标差（相当于把这几个数单独拿出来了）的若干个数进行插入排序即可。
4 f. D+ A/ d# y# V3 N, v1 d( z
3 U; a" D( X. J- _8 o2 [4 w4 d
( P1 k$ m9 A" _( ^; T


  ~' h  K( D2 ~$ k3 M9 T9 }
; |8 i* C# v/ }: J完整代码：


& Q  x4 i" ?2 cpackage com.keafmd.Sequence;
; T' V) e* N: I' z7 B1 f

/**
* Keafmd
*
* @ClassName: ShellSort
/ a, S, M4 F: l * @Description: 希尔排序
* X8 J, \$ Y; r5 k * @author: 牛哄哄的柯南
7 E. }- z! `5 O0 H' s2 m( ` * @date: 2021-06-24 10:39
6 g! _7 O  L" f1 {" m# s  n */
# o- T4 x. g- W/ _public class ShellSort {
$ G4 Y+ t; v% g9 W8 A

) m' z+ P' [; X6 y' R    public static void shellSort(int[] arr) {
        shellSort(arr,true);
5 D$ ^* D. ~5 u, o  Z6 _    }

8 z6 P! ]  ~$ t+ A! j+ H. E1 ]( a) `
# g; C% l- o  O6 \$ Q, G; h5 f/ S    public static void shellSort(int[] arr,boolean ascending) {
* }2 B* C& z5 i1 c2 k+ f. A
* i3 h+ g' E* p* ?/ o. ^
        for(int d = arr.length/2;d>0;d/=2){
8 i5 t/ Q! p% `" f! M

            for(int i=d;i< arr.length;i++){
, E3 a/ P3 K, k2 U% l# v: J                int temp = arr;
' h: ^, V8 ]' z: i7 ^4 M2 I& B                int j=0;
                for(j=i-d;j>=0&&(ascending?temp<arr[j]:temp>arr[j]);j-=d){
9 c) F% o0 x8 S  \                    arr[j+d]=arr[j];
                }
3 i6 p# e6 K9 U" Z! n1 u2 ~7 I4 h                arr[j+d] = temp;
            }
% t$ a/ E3 |: Q. d        }

& X& q) X; f5 c" N; w3 X1 t
1 T; a0 M/ A) Z# w4 U9 S8 s1 t    }
; i- G( Y& O1 [8 ]. ?& W}
  k8 a8 m/ l: _) L  M1
2
/ P; x" v+ O! U# q  X" g3
9 A! ~: E- w$ I) \4
5
6
7
  N. G9 }- Q. V* S& p1 ~8
/ H9 P* M% G& O) O" q; I1 x9 [- K9
10
11
* o/ F- d" q  k2 E' o12
13
14
: e  r0 ~( T5 q. @. [+ {8 _15
8 q7 m, {# ?3 X# h! E/ G1 d+ U16
% c# W( w- ?0 F% m0 S( ~. |17
18
19
2 t( J3 P! {0 t8 E& J20
21
  h$ |, O4 A( l7 ?9 t" Y7 q5 _8 e22
23
24
25
26
27
28
29
) _& G3 p/ u! Y0 V30
3 `4 E) Q2 a. v; Y31
32
计数排序
简单解释：
这个排序算法看名字也很好理解，就是就是额外找个数组来计数，然后在这个数组从小到大或从大到小把数取出来即可。
, b/ R3 T$ W% D3 j& j! w/ u
' B" u9 h9 j/ Q- I7 H0 p
3 r2 s: m  {1 D  n* G+ t# P

" A' n4 p2 [. X) x

完整代码：

/ L- `4 E3 w  }5 K9 I: E, E; q2 J0 i
package com.keafmd.Sequence;
9 ?( q+ x" ?7 {) L* {
! p9 C3 h& M* N
/**
* Keafmd
*
& ?* W( E# W+ D2 X- _/ T * @ClassName: CountSort
+ Q% K# m- K3 v, Z  I * @Description: 计数排序
; W' R+ v7 B0 f4 r+ q1 C, W) n * @author: 牛哄哄的柯南
* @date: 2021-06-24 11:31
8 l! \5 J* j; y$ `( D( n */
public class CountSort {


* g, p; v# J* g2 H' I    public static void countSort(int[]arr){
6 v% f( k" W6 V  `        countSort(arr,true);
    }
$ O: w: ?% y" p' y% E( j; f
2 \& A4 p$ a1 p2 u" V
    public static void countSort(int[]arr,boolean ascending){
7 k( e9 }6 v* d! Z7 y        int d,min=arr[0],max=arr[0];

: c. G: \% W/ S" b  ]  v
1 k* C* B5 _7 J0 S; M$ e        //找出最大、最小值
' }$ h, [+ W7 ~% s3 \% O        for(int i=0;i< arr.length;i++){
) N, K" ~. S, b, D" Z7 t; j            if(arr<min){
                min =arr;
            }
4 u+ b. @! S5 D) H5 _            if(arr>max){
* ^8 s. t$ o3 U7 y/ F, ~                max = arr;
            }
        }
4 B3 K; W+ H$ X' ]
) \+ X5 ?' k- j1 ^% C
# g  N5 ~# Y! X. V; L) w2 X9 y, E& o) H3 D        //建立一个用于计数的数组
! B" B7 I6 L1 h) Q( m        d = min;
: `8 b  n  E3 L" v        int[] count_map = new int[max-min+1];
, ]6 Q/ M* Z0 r3 `        for(int i=0;i< arr.length;i++){
$ m9 M' _/ q( |8 L3 E            count_map[arr-d]++;
        }

! v% E! N* T# f& b0 h, N
        int k =0;
        if(ascending){
            for(int i=0;i< arr.length;){
5 R0 O% J9 N0 ], r2 }1 d) ^9 ^/ I                if(count_map[k]>0){
                    arr = k+d;
- u+ h! n" S3 u# J  ~5 Q0 V                    i++;
# I; C, [! j6 f; C                    count_map[k]--;
                }else
- A) h; B: o+ g                    k++;
9 X, C9 m% I+ {            }
4 ?# p" A0 m% |6 N# j' W' I        }else {
            for(int i=arr.length-1;i>=0;){
, o4 n0 M9 s- n+ d( R/ x                if(count_map[k]>0){
) p# I  a2 P$ [                    arr = k+d;
  ~  @  [: `' n0 F6 ]7 k                    i--;
                    count_map[k]--;
6 [/ j+ }8 S2 }1 d4 N                }else
5 y+ R( E. u8 `: D                    k++;
            }
        }
; j, H/ q- @: j% A, j' j

( ^2 C$ q! P0 ~* S& r4 @    }
& e) c  A4 V9 ?- S- y}
1
; K3 K5 o+ v  w0 o2
3
1 T3 U4 v! X1 W/ V. a+ Y4
5
1 A' m+ b# T: p; H) _) J9 }  g6
, P! C. @" `9 F5 t8 T0 E/ d7
3 X1 v  Y6 I3 k' G5 F) O- Q: p8
' i9 ?8 ~( V3 ^  G# V9
10
11
12
13
9 ]+ \* \) K& t  K8 p' Z14
! f0 e  B& m1 S& x15
16
! ]3 }9 L* L" x9 B* Z17
2 d! j/ h8 u4 F5 y. W( W! i; g0 S18
2 }& D. a& b4 E' u  Y) W1 e: R19
20
21
& {2 P1 U1 q2 m( a+ [% f4 @22
23
24
25
26
3 [# O$ G* [# @/ ?5 u27
28
/ D7 K% J0 U8 I) n- M. S29
% K5 P# U. f* n  U, R0 @30
31
; E8 S! a! `1 `  \  X" ?! o32
5 c0 W+ k$ c% \* Y" h& A* C$ S8 D33
/ Z% ]) d- H3 X; ?- L34
35
36
37
38
39
40
9 c" S& ?; h( _9 |& m! w1 ^% f' i7 R41
' P* c8 W) |/ r6 h! O/ V: b+ a42
+ I# [  c. p+ `43
) S, V1 a6 ~) W$ p" [% v44
4 T5 k. ^# H2 J9 _# `3 |45
9 x* P( T* z/ G46
& m* f' o7 b. o47
5 W' c+ V. B$ n$ q48
' H7 [/ c* s& N2 ~7 O49
50
4 @! U6 l; Y0 ?51
52
53
54
55
56
! ~* V1 P' k( K2 `+ X0 u57
58
5 `* N  T! D' f; I% a59
! r: e5 r# f3 ~" _- v7 L桶排序
. V" m8 z( e/ P- J4 B- c  D简单解释：
9 I( D. a( y% S/ ~就是把一个数组分成几个桶（其实是几个区间，从小到大或从大到小的几个区间）装，然后让每个桶（区间）有序，然后取出来放一起就可以了，相当于把几个有序的段拿出来放一起，自然还是有序的，当然需要是按照区间的顺序拿了。

' M. R; D. U% h8 t3 {$ y) s

3 {9 B, H; U  W* F# m+ n

) d/ E/ @: F* W' L# H; K
) i- o; g' p# S完整代码：
1 _( A+ j0 O2 l* z) ?
! {& m6 r& y: H. V3 J: \- V
; H: a8 d1 H4 P& }package com.keafmd.Sequence;
* }2 q% M; M; Y+ V  ~6 s

( B" J9 ]  c2 W# c: S2 E, ]import java.util.ArrayList;
* r1 @$ I. K9 U- O2 j: p, S6 O# Iimport java.util.Collections;
# {! J  G: n: P& C0 p2 D
$ V4 r3 w$ h( u: M, C- Y
/**
* Keafmd
1 I. M' R) b- V0 a4 [; q *
% @& N4 f% J4 H" y * @ClassName: BucketSort
* @Description: 桶排序
  N& ?3 @% b0 B. o * @author: 牛哄哄的柯南
* @date: 2021-06-24 13:32
*/
1 W3 B+ j  A+ ^# w2 Wpublic class BucketSort {
  d+ I/ i% {$ l3 o) l9 W/ A8 _
4 _) l& o5 P; o( t% n
3 P+ C" S6 s# P% U  t    public static void bucketSort(int[] arr){
+ e4 F- M( L3 h- B1 V+ g        bucketSort(arr,true);
    }


) I+ V! f$ F6 [" X. G7 m( _    public static void bucketSort(int[] arr,boolean ascending){
3 S% K; J' Y/ _/ ]        if(arr==null||arr.length==0){
            return;
0 h" p% ?, N! Y- O- k# _: o/ E. ^& v1 o        }
        //计算最大值与最小值
5 i# h. w3 u! w- [. B& v8 G, V        int max = Integer.MIN_VALUE;
        int min = Integer.MAX_VALUE;
, C6 C' u7 {7 {, }/ b/ t5 q/ A3 R        for(int i=0;i<arr.length;i++){
3 l7 C2 A! e# E+ ^0 a0 f& O! t            max = Math.max(arr,max);
            min = Math.min(arr,min);
        }


; N$ ~2 O* X1 ?( t        //计算桶的数量
9 [7 o) z. o9 R, @9 W- Y  k( \        int bucketNUm = (max-min)/ arr.length+1;
: ?9 ]9 }0 F$ N  ?1 G, R! H# g9 G        ArrayList<ArrayList<Integer>> bucketArr = new ArrayList<>(bucketNUm);
        for(int i=0;i<bucketNUm;i++){
            bucketArr.add(new ArrayList<>());
( G+ B; \8 X* p        }
0 |: `* b4 q# s/ b! t

" P% u  J! v. U3 W. q9 N" H( E4 [        //将每个元素放入桶中
& ]  c/ s% ^7 ]5 [! w: _        for(int i=0;i<arr.length;i++){
) o- o# |% R! H4 N# H3 E7 [            int num = (arr-min)/ (arr.length);
            bucketArr.get(num).add(arr);
$ R! F4 y/ ~/ a  y. Z  [        }
3 Y. U* n8 H, A/ B) f5 G

9 u4 n8 N% x  s! ]1 C        //对每个桶进行排序
+ ^  J, h6 _8 I4 ?* T' [        for (int i = 0; i < bucketArr.size(); i++) {
6 y# {- h& g  J! A( V9 f            //用系统的排序，速度肯定没话说
) R+ g4 e/ h3 O% a' r8 V, e            Collections.sort(bucketArr.get(i));
        }


! S2 \* y3 l, {" i        //将桶中元素赋值到原序列
        int index;
        if(ascending){
            index=0;
        }else{
5 m$ l0 u8 X. ~6 C            index=arr.length-1;
        }

' _9 l+ t! e6 E
        for(int i=0;i<bucketArr.size();i++){
8 l6 l' `% t+ z$ Y1 ?  h" y            for(int j= 0;j<bucketArr.get(i).size();j++){
                arr[index] = bucketArr.get(i).get(j);
* {, ~- W  P$ ^9 I7 g                if(ascending){
                    index++;
                }else{
                    index--;
                }
  f2 _" w. E6 A. F" W8 t            }
% s7 ^8 ]9 j  L: r" H/ D9 n3 T' |

  E. J6 X0 b* N        }
4 U6 k, R% E# R0 O
% D/ k2 x! u- ]% a$ w
6 T$ {( P* W  x/ }3 @( D% }0 N; X    }
" x9 f! \0 h  N}
/ h# P7 H0 G. g- l* H1
# F( w- I) e1 y7 V) g8 \2
3
4
/ I. K# c& A9 H& t1 N8 V& I: G5
6
, S1 `# W4 @4 \4 `  l5 `+ D) T7
8
9
  }# u! M; }, z9 K9 J4 m* `7 K& z10
11
12
1 A5 I' R' q0 `, E$ E$ u) M13
14
! }- {3 q& p, u0 J/ Z* R15
  u& j& @( G" r! h  X6 x* O16
* N& q* ]: E) A17
& W; O3 m- _6 B18
6 Z- j# M5 _" R" l19
20
# N: |; w) W* m' @6 l4 @21
+ g' c" m% r& z( P( \3 s+ p7 V0 b- F. W6 p' y22
23
24
25
! I2 D( V, x2 p. c; w8 W4 y26
27
28
29
+ ^( v9 ~; u* l: S30
31
* a) W8 i. z3 F32
  k6 _; c! f, s33
34
35
36
& N: l; e* O4 d37
" C1 n( c/ c% V38
39
40
' [, h1 `6 n* L+ Y9 p7 n6 k3 B; P41
& {& H+ j. \# J/ O9 z42
43
44
45
46
+ {) k+ F) N, u! b. A0 H47
* m( Q: w/ o1 q2 T* \; }48
49
50
51
( A8 m* R' W+ j3 H) v) C% h( r52
53
54
1 v) u: _8 |5 l& _# u" U55
4 [  Y% L' W* Z6 X5 E" _56
* I( ~1 P( C, M) t" V  o3 n57
58
59
" D/ t  n: Q$ O5 P$ S* {60
) n3 t3 d2 R: u1 [6 J61
0 ]3 N; C1 b. V* Y62
* L$ E( u9 c: f63
1 Y& F0 K( t/ k- P( ?6 j64
65
66
67
. j1 m: N# S; w! V& w68
69
70
, [% C2 }( n. T71
! A% W- {  P+ M# {$ u( V2 S72
基数排序
简单解释：
首先说一下，我发现好多人写的基数排序只能排序正整数，其实只要处理下就可以排序含有负数的了，就是我们排序前先把所有的数整体变大（就是减上最小的负数，也就是加了），都变成正数，然后排序好之后，在减下来（加上最小的负数，也就减了）就好了。
基数排序就是按数位排序可分为LSD（从最低位[也就是个位]开始排序）和MSD（从最高位开始排序），下面写的事LSD基数排序。
) c1 B  e( {3 C! P基数排序就是把数按位考虑，让后我们一位数只能是[0，9]，就是我们在考虑某位（个位、百位· · ·）的时候就只看这个位的数，放到在[0，9]相应的位置，然后顺序取出，最后再按其它位这样操作（上面说了要不从低位开始到高位，要不就是从高位到低位）
' h; s$ v9 P7 d9 D: }6 ?+ ?
: H8 o; h4 D& X5 X% {9 g, C
1 t3 `5 j/ u3 D' k
* I3 U7 f! d- u9 @3 G


完整代码：


; e! _* e3 P% k" L4 ^# K6 fpackage com.keafmd.Sequence;


3 F7 Y2 F, f) V6 C  u' p. }/**
* Keafmd
3 b, i4 o+ [* D* [& R! J *
# f  S+ `: Q; F- u  w * @ClassName: RadixSort
* @Description: 基数排序
. e4 s. j4 }0 x" { * @author: 牛哄哄的柯南
* @date: 2021-06-24 14:32
4 ^" ]* G7 B; d* }. s/ F( L */
public class RadixSort {
* _9 |, J+ X" f, X  j    public static void radixSort(int[] arr){
        radixSort(arr,true);
& H; O. ]5 n, d0 ~: ~    }
    public static void radixSort(int[]arr,boolean ascending){
        int max = Integer.MIN_VALUE;
        int min = Integer.MAX_VALUE;
/ B* N6 R; O  l/ J1 |& W6 G        //求出最大值、最小值
) G/ F: D! ^9 o7 Y  t        for (int i = 0; i < arr.length; i++) {
            max = Math.max(max, arr);
0 ]: v& J" i/ E# P) [$ y# g5 g5 e            min = Math.min(min, arr);
        }
; o. f- {: v9 W& ^4 g2 J        if (min<0) {        //如果最小值小于0，那么把每个数都减去最小值，这样可以保证最小的数是0
6 e0 y7 f) k8 G) }            for (int i = 0; i < arr.length; i++) {
                arr -= min;
            }
  ?6 n( [* Z0 U2 s; f            max -= min; //max也要处理！
% B4 _$ C; M! D1 b+ H        }
/ `6 m' r; E/ M. j9 ?        //很巧妙求出最大的数有多少位
        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) { //个位 十位 百位 这样遍历
) g" k: `% R( I( ?  y            for (int j = 0; j < arr.length ; j++) {
                int value = arr[j]/n % 10;
, I! `' {7 s! k# B* `' B; K/ d                bucket[value][bucketElementCount[value]] = arr[j];
                bucketElementCount[value]++;
3 s) v& ~1 ~) }            }


5 F; |; q! J+ J6 \5 n. l: P            //升序
            if(ascending) {
' v  z2 F! E  U0 }* u- f                int index = 0;
! c9 ?8 I% s$ |) U2 I0 O# ]                //从左到右，从下到上取出每个数
                for (int j = 0; j < bucketElementCount.length; j++) {
                    if (bucketElementCount[j] != 0) {
                        for (int k = 0; k < bucketElementCount[j]; k++) {
                            arr[index] = bucket[j][k];
                            index++;
/ Y. M/ ]& v( F) }7 M) L/ p9 e                        }
) b, o2 @5 Q" H, F  g                    }
                    bucketElementCount[j] = 0;
# a- f9 n- }- h5 r, Q" P4 t9 [                }
            }else { // 降序
                int index=0;
. H9 c4 J5 e0 o! c                //从右到左，从下到上取出每个数
/ U: n8 n7 C, t, h, C/ ^% m2 o                for (int j = bucketElementCount.length-1; j >=0; j--) {
1 O* w' e2 t! E: Y- Z                    if (bucketElementCount[j] != 0) {
                        for (int k = 0; k <bucketElementCount[j]; k++) {
                            arr[index] = bucket[j][k];
                            index++;
! E' u! M( D  k6 b& G                        }
                    }
2 y. V6 N4 c6 J4 T) E* X" u                    bucketElementCount[j] = 0;
: c0 k0 a0 [( x# u: N                }
            }
5 d. d% r% @( }



/ G4 H; @& X3 N$ H9 P/ d            /*for (int i1 = 0; i1 < arr.length; i1++) {
                System.out.print(arr[i1]+" ");
            }
2 n' G. X; X$ u% p- a! a: _            System.out.println();*/
! S1 B* C% w3 m6 I: f0 u
: F% x7 m/ B/ m
" p8 Z" G7 r" h- X2 ]$ g2 E1 Y



' Z0 D: c- n+ [# _! P- w; a        }
        if (min<0){
; }7 N$ S: o+ b            for (int i = 0; i < arr.length ; i++) {
                arr += min;
            }
* b* m  M) o/ X; N8 s1 A* c        }
  x: X- B- _7 l1 i* c

& K2 r: g+ v7 j    }
}
" ~# X. a; ~$ q1 @4 O' a) @# a( \1
$ X; N/ s' @2 C% v( b. [7 U( [2
% g1 h5 P6 T3 k; g3
. I  k  z3 P) `: F7 w4
5
5 b' y5 G* a5 H3 N4 k4 X5 N1 b6
7
8
9
10
' |5 A6 u: K% K: z& a+ I; k) T11
12
13
14
$ r, q! r1 A# ?" Y. k% R! `" K! h3 @15
3 B, @/ Q2 _9 f7 k- ^. i# x16
17
18
- k2 Q/ ?1 F# p' X. t5 |19
8 T& z  ?2 `5 U7 L) t2 a9 N20
: P' D( i# b) u3 Z4 ?% _9 e21
22
23
- s2 |3 }! V! U( I3 t24
25
26
+ |( q1 e* g1 G* [1 M" v7 I$ m& U) D0 N27
6 k, D* f# s6 _28
' U4 Q, @4 j: L4 y8 @2 ~. q3 |) y29
30
31
32
33
! o0 [' F- B+ G# H34
35
" ?3 R) E6 L3 x- F/ g, ~3 _36
37
, a  Q. N7 ^, V0 F4 H% N38
39
40
41
. P2 M( V* f9 a/ y' o. A) ~3 g- v42
: j1 i7 O# y6 H43
44
8 N3 g, u2 U3 h45
46
47
48
& w  R( `$ ^* Y( c1 p" V; ^6 F49
50
/ M1 e3 D- n3 s4 i51
52
53
54
4 H6 h! [. n, `* M" d55
56
57
. K% s* J% q$ H2 J58
59
60
0 Z) O" o( d* Y. I61
62
63
5 }& ?" Z  H2 s. T, B64
# x; y6 K, r# p65
4 _! S# T: o1 A. T) ?66
67
9 d, C7 J  g& T1 I# u7 a0 T/ r68
69
8 d* A: X( r) N70
4 G' z7 z3 i" b+ N, `& A4 i71
# G& t8 N/ u) V7 v8 ]/ U& Y72
73
3 ?' U$ D' M, o7 n! ^74
75
! f+ [, Y+ d; F9 g: y! y  d. h" [76
77
78
79
80
3 W' x( G' s# N81
82
83
完整测试类
package com.keafmd.Sequence;

- Q1 _' }, P% @
& U  M1 O" i, ^3 Aimport java.util.*;
. ?/ x" j% a/ B1 @import java.util.stream.IntStream;
import java.util.stream.Stream;

) ?. g  Q( D$ \
' t2 |9 _2 R: A/**
* Keafmd
*
* @ClassName: Sort
* g1 q! [6 r6 t( X * @Description: 十大排序算法测试类
& W' s1 V; ~2 B * @author: 牛哄哄的柯南
* @date: 2021-06-16 21:27
*/
public class Sort {


. [4 I, W/ t3 q. T4 j- p% H
+ N5 L& k  Q6 N6 q# x" q' x' w! m
- g8 t" o! D' m/ F3 T    public static void main(String[] args) {
" J6 P5 l0 e' k
5 a4 n7 j. i$ U1 r. G+ ~
        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};
/ C" I) V2 z) a' |( f' J        int[] temparr;
- P: }( b" k% S, a3 r% n
6 x6 k# y  Z3 q
        //利用系统Collections.sort方法进行对比


( o, ?/ Z3 ?: R4 h7 |        //将int数组转换为Integer数组
        //1、先将int数组转换为数值流
+ @% u6 ]( X0 G3 F        temparr = nums.clone();
+ Y9 z" b1 _; C! |, ]& F7 j2 _        IntStream stream = Arrays.stream(temparr);
4 w7 W; `/ ?) C" S8 t8 Z        //2、流中的元素全部装箱，转换为流 ---->int转为Integer
        Stream<Integer> integerStream = stream.boxed();
        //3、将流转换为数组
        Integer[] integers = integerStream.toArray(Integer[]::new);
# U2 Z$ S5 b. F% J% G% E" o2 O8 E        //把数组转为List
( f. L2 N; V2 O7 z$ F/ ?        List<Integer> tempList = new ArrayList<>(Arrays.asList(integers));
        //使用Collections.sort()排序
; E. q& s- P- \& P        System.out.println("使用系统的Collections.sort()的对比:");
2 h' }: F+ p- b7 Y$ o. p

        //Collections.sort
        Collections.sort(tempList, new Comparator<Integer>() {
            @Override
            public int compare(Integer o1, Integer o2) {
                return o1-o2;
                //return o2-o1;
3 \2 c$ c/ A' D) S$ k1 U            }
        });

3 O' W, x% G, K. q
# X- B. n$ L$ s! {* `+ T+ b- W        //tempList.sort 也可以排序
* B/ v* e/ I, I  w8 y* ]       /* tempList.sort(new Comparator<Integer>() {
6 u5 z0 v; b/ g3 F% @7 m9 `4 V" z            @Override
- x: N) r9 d6 C! V8 U0 A            public int compare(Integer o1, Integer o2) {
                //return o1-o2;
                return o2-o1;
$ O& q$ d- l) S( J7 e% S% d( [' n            }
- F' |) H+ M) {. i# p        });*/
/ W6 v  k+ U) R; Q& I1 b
, U) _) S1 L  c
        //遍历输出结果
        for (Integer integer : tempList) {
            System.out.print(integer+" ");
        }


. R- g+ j: W$ C8 {( ?0 K4 L        System.out.println();
) u5 Z7 ]3 a' F& g# Z5 R
* N1 g- t* D5 e' e; Z
1 _; O& v, e" q# E( r4 e        //测试冒泡排序
        System.out.println("测试冒泡排序:");
        temparr = nums.clone();

1 l0 v# B4 G. X( i/ p# i0 X/ j
        BubbleSort.bubbleSort(temparr);

8 c% r& r/ H! v3 {( c. s) T
8 u/ r4 i- @( Z6 J: j        //降序
        //BubbleSort.bubbleSort(temparr,false);
6 D. @9 D, S7 c1 i; J% n
; q7 K( c! f, Y$ T
        for (int i = 0; i < temparr.length; i++) {
8 R, w/ k8 I4 g1 j: b8 j            System.out.print(temparr + " ");
        }
        System.out.println();
7 Z( N/ D3 s8 n; x

        //测试快速排序
, H- D- G/ }# h9 V        System.out.println("测试快速排序:");
        temparr = nums.clone();
& i( S( F/ G5 K$ ]        QuickSort.quickSort(temparr);
        //QuickSort.quickSort(temparr,false);
        for (int i = 0; i < temparr.length; i++) {
! f: P/ v. e, T1 k" }/ @9 Z            System.out.print(temparr + " ");
        }
        System.out.println();
) `8 Z% ~/ U" z* e) y/ h6 g
5 o0 H& J. V. |- x0 P  G% h: H
        //测试直接选择排序
- Y, {5 Y* u) h/ ~+ f+ i        System.out.println("测试直接选择排序:");
        temparr = nums.clone();
; ?/ w+ R" y4 T( ~3 k: H( q        SelectSort.selectSort(temparr);
0 S/ a1 P, ~+ r+ u3 [( O' [4 [        //SelectSort.selectSort(temparr,false);
$ j" t! X8 m# l) _9 _9 Y        for (int i = 0; i < temparr.length; i++) {
            System.out.print(temparr + " ");
        }
        System.out.println();

8 t( b* T; d! v" W4 S6 ?" b* i
        //测试堆排序
        System.out.println("测试堆排序:");
! P6 U# n6 y, r4 E$ i        temparr = nums.clone();
        HeapSort.heapSort(temparr);
: k( x4 Z0 P$ y1 r        //HeapSort.heapSort(temparr,false);
) N/ D/ |: }; e( [$ o        for (int i = 0; i < temparr.length; i++) {
            System.out.print(temparr + " ");
: B5 j  m+ g; D; Y5 s! T/ o        }
        System.out.println();

1 ?# w: U6 [" }1 j
4 f0 t6 ]& H7 X        //测试归并排序
! ]* h* h% h' {% O, c        System.out.println("测试归并排序:");
        temparr = nums.clone();
        MergeSort.mergeSort(temparr);
        //MergeSort.mergeSort(temparr,false);
% i% Q9 G+ ]2 ]7 l; U/ G& Z        for (int i = 0; i < temparr.length; i++) {
            System.out.print(temparr + " ");
$ F% \4 k$ C7 g* D- R% a+ v/ w        }
8 a7 v' ?) l/ s) g        System.out.println();

0 Z& w& E# P7 u6 M
        //测试插入排序
- {% [; R9 Q% n4 m# |6 O9 N        System.out.println("测试插入排序:");
# ^1 ^) J& A9 [        temparr = nums.clone();
        StraghtInsertSort.straghtInsertSort(temparr);
1 o( x7 ~7 Q# a2 ?+ ?' v- P        //StraghtInsertSort.straghtInsertSort(temparr,false);
        for (int i = 0; i < temparr.length; i++) {
9 _. Q8 A) V( C1 b3 p$ g4 K            System.out.print(temparr + " ");
        }
        System.out.println();




$ T% g. ~! t3 \: Q8 X+ }        //测试希尔排序
        System.out.println("测试希尔排序:");
" Q4 J7 T7 G6 W! {; z        temparr = nums.clone();
        ShellSort.shellSort(temparr);
+ V% y) m1 n2 ~: z        //ShellSort.shellSort(temparr,false);
* D- B2 C, s' v, ?& j0 ^8 j6 w* y        for (int i = 0; i < temparr.length; i++) {
            System.out.print(temparr + " ");
  P3 W" E1 V6 T" C/ L/ [  \        }
& n( y2 ~! f2 p0 H4 M5 @        System.out.println();
- A* n8 Z. k* J" W2 W3 J


; j8 l5 J: N- N# a& x+ |. T" o. ~
        //测试计数排序
        System.out.println("测试计数排序:");
        temparr = nums.clone();
  |7 q" f2 o/ }7 X! Z        CountSort.countSort(temparr);
3 b3 C  }5 o: G  w' T        //CountSort.countSort(temparr,false);
6 n5 d5 w+ G* K! B. J5 p! e        for (int i = 0; i < temparr.length; i++) {
            System.out.print(temparr + " ");
' ?8 v5 G# m) Y/ j        }
2 X2 L8 `8 a) B0 p        System.out.println();


# {) C% H$ L- Y7 c* z- T

3 ?, h+ S+ e0 Y- w        //测试桶排序
        System.out.println("测试桶排序:");
        temparr = nums.clone();
        BucketSort.bucketSort(temparr);
        //BucketSort.bucketSort(temparr,false);
0 Q( _9 ^+ O/ @        for (int i = 0; i < temparr.length; i++) {
; U8 @+ }: i4 }            System.out.print(temparr + " ");
# H4 F' R3 R, x        }
        System.out.println();


        //测试基数排序
. \- H5 L& ]9 p; |* _$ {) e/ b9 O- C        System.out.println("测试基数排序:");
* B& j  o2 P. o7 m# J        temparr = nums.clone();
; O4 U* B! ^4 X$ i        RadixSort.radixSort(temparr);
! N/ ?+ Z4 S" m  u/ K        //RadixSort.radixSort(temparr,false);
        for (int i = 0; i < temparr.length; i++) {
            System.out.print(temparr + " ");
* a: l  k9 k/ `4 @0 c+ ~        }
) |" q* l6 a# M$ V5 w        System.out.println();
' P$ n! H& N7 n7 A3 a

* A+ b2 T' g) ]" G9 |8 N/ V1 M    }
1 U9 w% D$ x: ]* S
( `" ^! T( ]8 s
0 i/ O8 @5 _7 _( Q}
1
2
1 J- L) n! ~' ^& Y6 W3
4
4 b5 X0 f1 q" p, J- z" ?! Z' |5
! u7 ^+ v7 z( ?* |) n" ?/ U$ w5 J6
) Z: I! ^2 t7 l5 R7
8
9
10
11
12
! f7 M; V4 g2 j- f13
14
  |' y8 A/ Y/ H% Z, g' ~& X15
16
& K0 e) H6 T# I6 |17
18
19
5 @5 f, @$ v+ m. C$ _( T* w" b20
21
22
23
' i$ Z; ~/ B/ J24
25
! m( ^/ K  e7 k' F# `26
27
28
29
  L6 p: b9 K! s. M30
9 x0 r" w: J. ^3 v9 W/ q" ^. `) X! ~2 f31
32
33
34
35
5 c9 w' t& _" ?! W9 G36
37
38
3 W4 `3 P# A( A. N, F5 ~8 t4 B39
40
7 D4 {  P8 p) t" M$ j41
42
43
44
45
0 K" Z, O1 f" y46
4 Q4 M" s, |9 ?3 i2 J  r6 k47
; f$ ~' S5 h/ u! D, k48
$ Z7 i% \' f$ y; n& ]* Z49
) g7 Z& d# j$ h: v0 a) y( p1 ^5 [50
51
52
53
" T' J" {4 x  j! {54
55
  F6 m+ ?8 h) i* d+ f9 \56
57
4 d# b2 o! C# s58
/ I3 R+ c* K0 H# M, o( P59
60
/ w# J  @$ |3 z' R61
62
7 `4 l) K# T- p+ @/ s% a63
4 |3 k( a) _9 f5 ~! U6 Q64
65
" ?" G- p$ c$ l6 B7 R$ b66
1 D( L; B6 D. n, T9 K. S0 x67
68
69
70
71
72
0 V/ l' e( P- m* U0 a/ Z# ~73
74
75
76
3 w# B- M* O7 M: I4 T: |: A77
78
79
80
81
82
3 y( D, ~6 P0 j83
84
5 _: H  E0 L8 q3 l, B& X85
86
87
0 m- ^) p9 y  M; n88
1 i6 M7 _6 I: n: p89
90
$ h' r) w8 o: `91
92
, ?$ p. N: G: l% t93
94
! m2 |- @- f9 f0 d  s* k95
96
97
98
99
' v3 O" a6 H" m+ \. m) N100
101
102
! K. |7 |" N" x" T6 h" I  h. @103
+ w4 w% {( _; `104
8 @. i3 W- T* B$ \) n105
106
  w/ O8 ~  F+ }6 W+ U' s107
; A4 O5 c- w! I6 n1 j* I. {. D108
- r8 K' `) e1 N8 i109
110
111
" D; L: Y0 ~4 i112
2 ]5 O: _# n% R- J. h8 \/ F! l113
114
* ^, G% J: ]1 |; O+ R% f" ]' b: t$ [115
116
" c& t% H# A# L( k5 w# `. f( r117
! d( J7 F" f5 P# J$ C118
; f; N* d' k; S9 Z0 |+ c  q; y3 Y119
120
! }4 A" T7 u/ A% n) ?) d121
) q+ F1 G; F+ ]; X/ e  ~122
0 b& {, y2 A, i' @( }9 \$ y123
8 T$ w4 t9 O" S124
/ `/ f/ J; n5 c, g) ]125
: _' h, B& B: l2 g6 p126
- s! q2 V  x7 n9 e  `127
128
+ s7 ^8 \9 X3 j: o) D129
130
131
1 G( b% p7 P9 o+ |132
* ?- k( n* T/ N0 R1 n133
; s9 d9 j1 L* V, A) M5 y5 Q7 X134
" d6 e5 _; c# f' i: @, h135
) K+ w. Z! `* F' e: F136
137
- w8 t# s/ q: C+ Y138
139
140
/ {; B: }+ z- ?% K* Q- y/ `0 \/ N- v  I141
142
& x( O% a$ @4 y: R9 B- h7 _143
144
145
) \$ G# V9 u/ `, d4 j! z146
1 w+ Q/ T) O# X" |+ |/ F147
148
4 i& y7 O- J9 o2 v- X& u149
150
4 ?- T( l' ~. Y3 U151
' \& r: B7 c* W5 W0 D% p152
153
6 j# f3 a% _0 }- L0 K6 s154
& N9 v  X& b3 P155
+ `* a$ h) |( s5 ~. l( ]6 v156
% @+ G! z! [6 B: d157
# ?! z- l4 t; t$ a158
% {9 F3 m& `( C# W0 C" S1 N3 }159
0 ^; {! Q7 h/ O0 E" M! j6 \7 u/ z160
% k8 o- |) [, O" k$ [1 Y, B4 o161
. t- U( E# N; x5 l8 J5 E, `162
0 V) j1 p% [9 e- R# t3 l163
164
" A5 S' I% O6 U, U& V, p" c0 k' [165
166
4 ~% p5 S8 a3 n7 f- j167
# D4 ^0 |9 @/ W- x5 ^- ^+ @* g' B168
169
5 B* ?8 H8 d3 w* `# O: q0 l) G170
171
172
5 c, S3 E( A" o  Y173
, i+ ^' m3 j/ V每天进步一点点！
不进则退！


版权声明：
原创博主：牛哄哄的柯南
6 Q: n+ s3 c2 l7 n博主原文链接：https://keafmd.blog.csdn.net/
3 E7 T: U/ S0 K* Z' Y  H————————————————
版权声明：本文为CSDN博主「牛哄哄的柯南」的原创文章，遵循CC 4.0 BY-SA版权协议，转载请附上原文出处链接及本声明。
, ^( d! c. t( v) Z( y; M2 D: `原文链接：https://blog.csdn.net/weixin_43883917/article/details/118193663

0 S7 l( E% L3 E) f* ]4 r& |' }, c) {
% e: T$ l/ Q  }, L

---

作者: 1051373629    时间: 2021-8-17 17:20
每天进步一点点！
5 A) p( P* X  t- H% v( d* s

---

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

Powered by Discuz! X2.5