数学建模社区-数学中国

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

---

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

" G8 ]7 t% f! q1 m+ y. u3 K. S% s经典十大排序算法（含升序降序，基数排序含负数排序）【Java版完整代码】【建议收藏系列】
经典十大排序算法【Java版完整代码】
( v0 W* E6 p( V  X! w0 ^写在前面的话
. P  ~, q7 s$ k十大排序算法对比
冒泡排序
5 G( x* W2 T, ~  {快速排序
0 ]5 B6 Q2 z. v) x# y* h8 t' [直接选择排序
" `  O6 s' ?8 F2 @/ _堆排序
% w+ Q( _( j: u% m. S  R归并排序
) g# P8 N1 z0 _* w6 l插入排序
# c# V" _! R# u, ?! ]希尔排序
计数排序
8 M; V& f$ U  v桶排序
基数排序
完整测试类
0 s5 K) j# C7 W3 L写在前面的话
6 H8 x* O& c* e9 g8 {" u       虽然已经有很多人总结过这十大排序算法，优秀的文章也不少，但是Java完整版的好像不多，还存在某些文章代码存在错误的情况，同时也为了自己练手，决定把所有的写一遍巩固下，同时也真诚的希望阅读到这篇文章的小伙伴们可以自己去从头敲一遍，不要粘贴复制！希望我的文章对你有所帮助，每天进步一点点！！！
% d* X) k* p! ]' V- L( f
5 S  q% Z6 n8 i9 k
  n% K. g# W1 e. a       我用通俗的理解写下对算法的解释，对某个算法的运行过程不是很理解的话或者想看比较官方的解释的话，单独搜索某个算法，看几篇不同的解释，就可以有自己的理解了，这里我主要展示代码以及进行通俗的解释！整起来，再强调一次，一定要自己敲一遍，这样才能理解的更深刻！

  ^* x* g1 L: g7 B. Q- F/ |( Q
十大排序算法对比
4 x( d. h2 A. Y% U

" f. E2 J% ~- r' ]7 Z; H- L# x1 V* w

1 @& H4 Q2 B4 K+ Z关于最后一列的稳定性，我稍微解释下，例如对序列：1 2 4 2 6 排序，序列中存在两个2，如果我们把这两个2标记上（让他俩不同），排序之后，前面的2还在前面，那么就称这种排序是稳定的，反之不稳定。
" @1 W; e5 y) ~/ Y8 r! a5 ?9 }/ j
+ q' e; }- b& L) A0 X/ k! r: o
冒泡排序
简单解释：
9 u4 {) u% M/ z       原理就如算法名字一样，就像水中的气泡一样，每次我都把最大的或最小的放到最后面，这样总共需要n-1趟即可完成排序，这就是第一层循环，第二次循环就是遍历未被固定的那些数（理解成数组左边的数，因为每层循环都会把最大或最小的数升到最右边固定起来，下次就不遍历这些数了），两层循环遍历结束后，所有的数就排好序了。
       两层循环所以冒泡排序算法的时间复杂度是O(n 2 n^{2}n
  h" W; K+ K. `% R4 v2 s- ]% @2
. I8 e" c5 k$ h3 |" ` )，是一个非常高的时间复杂度，我在下面的代码进行了优化，加了一个标志位，如果上一次循环未发生交换，就说明已经是有序的了，就不继续下去了，反之继续进行下一轮。



$ _$ ^( Q- w) b5 u
( o: Y# [7 n, n6 @3 U' R

本文的图片来源网络，仅用于大家学习，侵权联系删除！（下同）


完整代码：


: y  E. z% j! m; m& wpackage com.keafmd.Sequence;

! Y. |: B  T0 |4 ?
/**
* Keafmd
*
* @ClassName: BubbleSort
* @Description: 冒泡排序
* @author: 牛哄哄的柯南
# M) D! u- k6 {. \% _ * @date: 2021-06-24 10:31
% w7 E% [' Y4 C, G) C, N( h5 k */
public class BubbleSort {


! E6 p. A( L! p- h3 `    //冒泡排序
5 j3 I# x1 I5 v# _; s8 o  Y% I    public static void bubbleSort(int[] arr, boolean ascending) { //exchange标志表示为升序排序还是降序排序

( y1 d5 i( N% P! o. g5 P
; Y- N3 V- |$ a0 E& V; G0 k, Q        boolean flag = true; //加一个标志位，记录上一次是否发生了交换，如果是，我们则进行下一轮，如果没有，说明已经冒泡好了


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


7 b" o8 E* F. \$ T8 A            /*System.out.print("第"+i+"次遍历：");
            for (int i1 : arr) {
* z; m! t; b9 |! F6 o5 W                System.out.print(i1+" ");
            }
6 _$ G; }' N: U+ u6 x            System.out.println();*/
+ A) a5 o! |, f5 k8 ^7 b% E
$ f" a0 g. Y5 ]5 o9 c% f
' D- u  [) E$ i1 B9 e6 x            flag = false; //假定未交换

. v- \* {+ h6 N' k3 \+ O
            for (int j = 0; j < arr.length - i; j++) {


: a3 _: \- N* \) I$ r: z                if (ascending ? arr[j] > arr[j + 1] : arr[j] < arr[j + 1]) { //控制升序还是降序
                    int temp = arr[j];
% _, f0 y9 G( _) W                    arr[j] = arr[j + 1];
                    arr[j + 1] = temp;
! `4 @) l' t* U$ v                    flag = true;
" h/ o& H" V5 j; n# T                }

/ F* F: s! T" E. w, }7 M0 N/ |; z) G
            }
        }
    }

3 N. E: Z. U$ E0 ^2 d) G
" m/ G& P+ v8 ~. k; m' t    //冒泡排序 -- 默认不传参升序
    public static void bubbleSort(int[] arr) {
        bubbleSort(arr, true);
4 r9 K6 D1 R; p/ ^) M9 F    }
7 y8 U# U! Y5 o$ j7 Q3 Q9 g}
1
2
& `$ k6 F& G& Q( t2 C7 c% I, ^3
4
5
6
7
5 r* |" j3 H* i5 f; c# Q' H8
& b2 w) |- `0 b0 c' Y$ K, F) j9
) v8 M3 I! g3 Y) P10
6 l( }' W% _4 [: n5 C( s% a11
$ L) k# j: @) I" {6 ?' j4 K: w12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
; h& O0 V& k# i% C. ^6 t32
/ ]: y- l# d3 W' A3 u& N3 y/ Y  l33
34
  ~6 c6 U/ o- Y4 q: W35
" {; O: c" C5 O( S& U36
: ]- t3 T! g  t8 [) r; B37
38
4 A3 b/ A# n- B2 D" D. N& [39
40
  _% r3 k# P( g0 W& E+ F* j5 N41
" @  u9 i: `" x" \3 n0 ]  j42
43
44
45
5 t8 s/ l* b- _  q5 H3 B; e测试代码：
7 e6 T. u5 P6 s4 {; l
% L) L! s" _& o" ^6 f  a5 I
+ r: N" A" s/ U  I; ?# r! V  D. T升序排序（从小到大）
: _# s9 g) W6 w
  n/ L* g, B" n- N
package com.keafmd.Sequence;
% F* ~  X& O; _5 G
7 S8 t7 T9 [0 S3 b
: s  G' f' L1 G2 l; k6 Ximport java.util.*;
import java.util.stream.IntStream;
import java.util.stream.Stream;
9 m; ^2 M5 v" Z% D3 S4 H/ L

$ I9 s$ x& R" v" t/**
* Keafmd
; M& d6 s7 ^& ~! y+ t/ O *
" `) F$ j3 E! P* l- W1 l * @ClassName: Sort
& ^2 {7 R9 i# \3 Z- b * @Description: 十大排序算法
* @author: 牛哄哄的柯南
* @date: 2021-06-16 21:27
*/
) w) Q3 @" }6 g! i6 upublic class Sort {
    public static void main(String[] args) {


5 M: |$ o2 ?4 D        int[] nums = {12, 4, 25, 47, 58, 34, 25, 9, 99, 26, 1, -13, 162, 10093, -66, -1};
        int[] temparr;


4 |: @, R6 C2 a2 T0 e$ F4 h        //测试冒泡排序
        System.out.println("测试冒泡排序:");
        temparr = nums.clone();
! _  T0 N& H, z        BubbleSort.bubbleSort(temparr);
- R) g% z. U9 k: Y9 S$ f( X9 v        //逆序排序
5 z' U. |- i! A7 x8 u        //BubbleSort.bubbleSort(temparr,false);
        for (int i = 0; i < temparr.length; i++) {
7 w4 `6 a# W& p/ \' _$ g8 n9 f            System.out.print(temparr + " ");
  g0 I3 t7 A3 R' k5 q! L) z7 N+ ?        }
1 Q9 a# n9 O7 C+ a' H8 w. t* d        System.out.println();


    }
}
1
2
: z: h8 t3 Q' p/ j3
  }+ n) ^* B" E7 ~0 [& [. }4
1 f/ [3 r1 j" p+ r5
! ~4 A: K3 z3 @) L6
7
. X# t; t2 _2 S  o& j% f8
% S4 n4 N! R, u+ l7 O/ f! s5 v9
& X7 U% l# H- I* `( _' t& f, R10
6 a+ {/ ?  u. ^) J. Z11
12
13
14
& I6 ]- I% H( m. Z( K# P6 F5 N15
16
, G1 P/ _1 a) Z" a17
- G0 W$ A/ h2 x; d- T. b18
19
20
: h4 j; H1 V, \* g5 b! ]) }6 f9 B, n21
0 W+ ?3 i5 j0 J) P22
23
: z) a) r3 A* ]! @2 d# ]24
25
( ~- ?! e' R  G" [7 r+ A9 J8 G26
27
4 I3 Y- [+ w/ w28
29
30
$ B1 C  `; X) C4 }. Z1 C& B31
32
33
' c: x6 v& k+ B, R2 d, ]8 T运行结果：
- e. Q; w. m6 w& k( o1 r* t5 ~

( p9 N: {; s0 z测试冒泡排序:
# R) [* U; B2 e7 \3 s4 {- A-66 -13 -1 1 4 9 12 25 25 26 34 47 58 99 162 10093
: l, e: u/ {4 l/ w9 S5 c  H% V  S1
2
: @8 _) D. M# U9 e降序排序（从大到小）
8 _# Q6 ^. Q, e  b% ^  h! E4 P3 x
0 \$ ~8 a- `4 e! g6 D
5 `8 P! N: e! H  Q  ~6 g//测试冒泡排序
8 g7 c6 e7 K: |! Q' K% E0 L* PSystem.out.println("测试冒泡排序:");
temparr = nums.clone();
2 g- h) _% ^0 p4 xBubbleSort.bubbleSort(temparr,false);
( ~! x' y! b% g3 N- ^4 N+ M: O! yfor (int i = 0; i < temparr.length; i++) {
    System.out.print(temparr + " ");
+ [7 Y$ ~3 h  _7 @* F/ m# X}
System.out.println();
% S2 C, `. O$ A, W+ f$ B  d1
8 c: P% s0 \' _  S) C8 J2
* J, f% l2 \- o# m: \2 V3
5 A- [; u. X; l/ g4
5
  A- u! E- X  J9 h3 h0 S" X6
7
9 g7 V$ E2 c- A8
运行结果：

/ C2 W3 |0 v$ F9 W- U3 Q/ [
5 [! ^: _" m1 Z5 E: d* Y/ W测试冒泡排序:
: [0 g& V) ^' u8 o* T10093 162 99 58 47 34 26 25 25 12 9 4 1 -1 -13 -66
1
  M% W* L$ b, Z8 l2
; E- }. I0 Z" S下面几个算法的测试也就是换了下类名和方法名（换成相应的排序算法），如果想降序就在数组后面传个false即可。我就不一一复制了，我在最下面给出含所有算法的测试类，需要的自取即可。


( T6 K8 B" O! R- X* i, S快速排序
6 v, G/ w: L0 ]+ S简单解释：
快速排序就是每次找一个基点（第一个元素），然后两个哨兵，一个从最前面往后走，一个从最后面往前面走，如果后面那个哨兵找到了一个比基点大的数停下来，前面那个哨兵找到比基点大的数停下来，然后交换两个哨兵找到的数，如果找不到最后两个哨兵就会碰到一起就结束，最后交换基点和哨兵相遇的地方的元素，然后就将一个序列分为比基点小的一部分和比基点大的一部分，然后递归左半部分和右半部分，最后的结果就是有序的了。
$ ~" z8 ^$ n9 D. R' j
* U' T0 W. e$ \0 _; h! n


; E3 T+ o+ D; }- \' O( @

" n1 j& G  B$ a+ r7 B$ H8 J+ K完整代码：
4 v0 G2 u8 i, t9 X7 ~" O

$ Z6 E$ v, Z" x4 I- p# _! ]package com.keafmd.Sequence;
# Q5 D6 c# F5 q1 ^2 x2 k; }; D

2 L: K, e- J7 S/**
4 C) @; r- q: [; x  x' s * Keafmd
7 h* o" m9 U0 ?2 s' J% v5 F *
7 ?3 P$ K# k! t * @ClassName: QuickSort
* @Description: 快速排序
/ c7 V1 g( ]- i3 R: i * @author: 牛哄哄的柯南
% K5 d/ Q: `1 f, {% @) H+ b4 r * @date: 2021-06-24 10:32
*/
! v/ Q' c5 I$ c; u# D) R1 gpublic class QuickSort {
: N/ I8 U, ~- l3 y+ j& |

    //快速排序
! L5 S; \8 t  I) }    public static void quickSort(int[] arr) {
1 r' `3 x5 |8 p- V% O1 \0 @. b        quickSort(arr, true);
! K  N0 }- j# ?, k0 n    }
+ B7 k) C. p) q4 |% n& u# s
0 e% _5 ~' ]4 g  P, u) Z
    public static void quickSort(int[] arr, boolean ascending) {
8 P  N; u$ ~" X) B4 t& b        if (ascending) {
            quickSort(arr, 0, arr.length - 1, true);
  [" o8 I6 Q$ U8 u        } else {
            quickSort(arr, 0, arr.length - 1, false);
: j5 Q+ ]  m3 M3 M+ M4 n# T        }
    }
# i6 W% U6 G+ F7 l: ]" y
6 X7 F$ l: X; w) B! ^0 U1 w
    public static void quickSort(int[] arr, int begin, int end, boolean ascending) {
        if (ascending)
            quickSort(arr, begin, end);
5 G2 R  H* M5 J5 w& h) z7 x        else
            quickSortDescending(arr, begin, end);
    }


    //快排序升序 -- 默认
2 L% L* C6 Y$ y6 ^1 [  o6 e( ]    public static void quickSort(int[] arr, int begin, int end) {
        if (begin > end) { //结束条件
, u4 X- d2 u/ G1 h) Q            return;
. |, }! D% U1 E2 I        }
1 h. }( @& N) p* }        int base = arr[begin];
) R3 Y9 x( B5 i- \. j, l) d$ o        int i = begin, j = end;
4 v( Z% o" v5 D1 [" a% J        while (i < j) { // 两个哨兵（i左边，j右边）没有相遇
5 f1 I6 w" ~3 }5 H+ L            while (arr[j] >= base && i < j) { //哨兵j没找到比base小的
+ }( Z' c/ F  v5 J, s+ f                j--;
            }
            while (arr <= base && i < j) { //哨兵i没找到比base大的
8 M- J$ h$ J- B2 v                i++;
! G3 n! t. R2 k0 `5 t            }
2 C1 T/ ?0 Z& G- Q# l            if (i < j) { //如果满足条件则交换
                int temp = arr;
                arr = arr[j];
% T( a7 {/ k3 |8 Q% u                arr[j] = temp;
/ W; v" c8 Q9 J            }


        }
        //最后将基准为与i和j相等位置的数字交换
        arr[begin] = arr;
, o4 E* i  j  N        arr = base;
* q: a1 v5 i& |, H% H        quickSort(arr, begin, i - 1); //递归调用左半数组
        quickSort(arr, i + 1, end); //递归调用右半数组
0 \# t: n; ?2 Z1 Q$ u" p$ `: w
2 v; `) z( I2 v: v3 l6 p5 j- X5 L
" {5 z4 ~) [: T% d9 R    }
  g, N) Z0 x. s) r2 C8 ~

2 s( Y% z' v( B3 l4 [8 o    //快排序降序
    public static void quickSortDescending(int[] arr, int begin, int end) {
        if (begin > end) { //结束条件
            return;
        }
        int base = arr[begin];
        int i = begin, j = end;
. T/ [( |% S- u6 d+ a        while (i < j) { // 两个哨兵（i左边，j右边）没有相遇
8 S. p; k$ Q3 Y) m            while (arr[j] <= base && i < j) { //哨兵j没找到比base大的
                j--;
            }
) B3 d" y! d+ K8 _4 t            while (arr >= base && i < j) { //哨兵i没找到比base小的
                i++;
            }
            if (i < j) { //如果满足条件则交换
$ M; y) k6 S( N& |, H5 I- u                int temp = arr;
                arr = arr[j];
+ B7 s3 p/ H; ~7 w' n: T1 N                arr[j] = temp;
' ?# I) n/ H. B6 c            }
4 i3 Z! {( a4 d& I9 N& q

5 {3 C0 I4 a9 b  z, \        }
/ `. ~) N, j$ T8 p" h0 M        //最后将基准为与i和j相等位置的数字交换
& M5 p8 F* Q1 E; T# a        arr[begin] = arr;
5 Y) D3 V: T; m5 k0 ]        arr = base;
        quickSortDescending(arr, begin, i - 1); //递归调用左半数组
7 U, p1 f  B2 X3 h8 s( ?# D        quickSortDescending(arr, i + 1, end); //递归调用右半数组
8 y4 A. ^0 e  @1 q) `. F, |
/ i. M$ I' E. \- N9 R
    }
# o4 ~1 T0 }5 d5 e3 g8 i1 A* O

/ `; }- s3 W' v  e6 S}
1
' u  c5 T: N( b5 A, [+ X; N/ s. H2
3
4
! c1 r) s3 w! j7 D5
! I5 m  c3 w2 @) \' Z! o$ W' Z6
; F7 i; B& r$ C/ R) ?) P7
8
9
! P2 p- M2 C7 r. ~" j10
11
! D) [- r2 e# |) S3 n' v12
0 k# M( Z0 |: q0 q13
3 _: _+ e! |, a4 V  m14
15
16
17
18
19
4 A! o6 M9 \. M( D20
+ Z7 I2 [" O$ S4 |9 D21
7 R: `8 h0 d% [( s, X1 [  I0 p  `5 L22
+ ?/ Q: i  d# b4 X23
24
0 g! j0 S% e2 C: D25
26
; u. q! G- e# G  z27
+ g) j' _' l6 I$ A) r- U28
29
3 S! b0 P6 D* l( k: P7 T0 Q4 e: Y30
! q8 {; |( Z* z0 E* Q31
( o0 ^. e6 G* `! }7 K, |2 u( @- s32
, j3 e' {, W  m; {% e& i' y33
34
1 C" j0 ^% i0 N" w0 n  I  N9 u35
36
$ Z8 o" `* }: `5 E9 {: @37
38
$ |, j$ p- L$ u: P1 F  v) {9 _39
40
0 u' w3 H7 K7 @+ P6 l% v# k41
- Y& H* R% |; x& r" v. E) J* ]42
43
44
0 ]9 D6 ~4 M' b+ s. `' v7 s45
1 w. c" s9 p3 |6 r46
47
48
49
* \5 q! Y/ p6 P3 ~$ @) T50
) O3 x1 \" o  z) M# c51
6 d( x) h5 a; `52
53
+ ^, H+ T. K$ o4 ]) ]) U/ R$ \$ w, I54
+ P; n& q) B/ E! G4 s- ?55
) I5 a  Z% L& G: B# m56
" ?( v# z4 K' N! O57
/ W9 c4 p6 m) e0 X: J# S  R58
59
5 b* [5 q' u1 ]; Q- ^3 w60
61
* s4 h8 _! j: |  d$ p- A62
* s  j. l. ^5 s9 ^; i3 c: K  P' s63
64
65
1 |6 e6 P6 A$ S66
67
/ L  {$ ^& f) M& p6 E( p9 }68
0 E$ p+ i+ w0 ?- X) f69
70
# q8 a6 M# E1 W$ E71
72
3 o, k. N- {. @. T73
. v, y. _. A7 s8 U' @/ G% a74
75
5 L; a, s  j0 [76
77
: P- s+ W5 T! k78
79
80
81
82
83
84
85
86
87
$ U+ v2 X: V+ _: {88
89
90
91
4 R) `# A4 I, v8 Q8 o* _6 x直接选择排序
简单解释：
, n4 R" [! V4 [8 L/ I数组分为已排序部分（前面）和待排序序列（后面）
第一次肯定所有的数都是待排序的
从待排序的序列中找到最大或最小的那个元素，放到前面的已排序部分，然后一直找，不断缩小待排序的范围，直到所有的数都是已排序的了
& K: a) K8 A' {' P* `2 D
5 l' a2 M7 {1 D' F" C
) c$ e( M$ e8 R! O4 N: r
/ q& n1 Z. _; l0 s$ ]* z' F
8 {) g- \6 S. N: ]6 D/ D

完整代码：


package com.keafmd.Sequence;
; ^! N" u* Y+ e, k' Q5 P
* j" p8 ]; P) O- U' {5 Z
/**
) g. {7 L6 x% B0 L * Keafmd
*
* @ClassName: SelectSort
! H$ ]3 Q) L- Q- y7 ^ * @Description: 选择排序
8 s4 e9 e' y0 Y# t8 \ * @author: 牛哄哄的柯南
* @date: 2021-06-24 10:33
8 a; C/ N; [4 k$ |$ P9 }) B  }* d */
public class SelectSort {
7 j# V, c& W- d" f$ h  ^, U! o
5 F! i  x$ [( s" G  v* k: q8 q( A
2 Q3 Y# s, H! s9 E4 f. c    //直接选择排序
    public static void selectSort(int[] arr, boolean ascending) {
        for (int i = 0; i < arr.length; i++) {
( F2 c# T1 q+ y( z! K* ]4 w            int m = i; //最小值或最小值的下标
            for (int j = i + 1; j < arr.length; j++) {
7 [8 X2 N. p/ h3 s: j0 }' k% C( Z                if (ascending ? arr[j] < arr[m] : arr[j] > arr[m]) {
) a, E8 ^# H; w7 R0 I6 o                    m = j; //找到待排序的数中最小或最大的那个数，记录下标
                }


: D5 W' f' i- F: {8 {$ |+ R) p/ R            }
            //交换位置
            int temp = arr;
            arr = arr[m];
            arr[m] = temp;

6 a  k8 n3 q* y# z4 Z" p
# K' q4 b% ]" `! c" m) [$ r' F6 B6 l        }
    }
3 i1 E" h' ~/ _

    public static void selectSort(int[] arr) {
1 m& i* w" @8 j& j  r, U% j8 w" h3 }        selectSort(arr, true);
    }
6 b  R3 B$ }- M1 O$ s5 W8 Y}
8 X9 ?0 X0 F% H" y- L9 v1
) C% W0 ?9 j( B2
3 A1 z6 x1 s/ O! O0 I3
4
9 ]# D3 o; w% E5 l, i  `9 I5
6
7
8
8 h. n6 W6 d+ i1 |# r4 d/ d/ _9
4 r6 s1 j5 P; G" p2 o0 u: j: H10
& a5 n7 F1 m# s- Q11
12
+ ~' ]( Y- ^) J2 D6 I( \13
14
15
16
17
* X3 ?& X0 f, J& P3 a18
19
$ |  q6 V  r2 e% L- Z% b4 |/ u$ H20
21
" t) {6 ?" g# p22
23
24
/ m" s, \; l* F0 d" F+ W25
26
: ~) Y+ w! P) I# v# o: b' y9 N27
28
29
6 K' q+ ?9 z* A6 W) c' n30
31
8 Z, K3 L2 B( t, W) D0 G2 J32
5 ^% q4 N5 R" Y1 Z( y$ o: |33
34
7 P/ e, q/ `' t# j堆排序
先理解下大顶堆和小顶堆，看图
大顶堆，双亲结点的值比每一个孩子结点的值都要大。根结点值最大
1 }! c2 y! U; J& C: z7 ]% @小顶堆，双亲结点的值比每一个孩子结点的值都要小。根结点值最小


( z1 K" {2 `& r  |
* ]; @- U* z  ~. m0 D& j
简单解释：
构建好大顶堆或小顶堆结构，这样最上面的就是最大值或最小值，那么我们取出堆顶元素，然后重新构建结构，一直取，一直重新构建，那么最后达到排序的效果了。

& h3 \" k" Y7 n' K) G0 \
6 L% \% k. R0 F- F2 Y
& _. g% x" y! p& F/ v
5 z0 w0 Z: m4 \' C$ d

完整代码：
/ G* H4 [% e' e. U

. Y& `- j9 S5 J1 Fpackage com.keafmd.Sequence;


/**
+ R, k: A3 x) Z% o5 T# N6 o * Keafmd
*
+ D3 z+ v3 \1 ]4 X, X1 @ * @ClassName: HeapSort
$ B% Z! Y. d0 b# y * @Description: 堆排序
* @author: 牛哄哄的柯南
* @date: 2021-06-24 10:34
*/
" Q; ^6 u6 H7 wpublic class HeapSort {

$ D8 X/ W0 C* i
    //堆排序
    public static void heapSort(int[] arr) {
        //对传入的数组进行建立堆，这里默认建立大顶堆，进行升序排列
/ E. ]/ {+ r# L- V, z; z5 `        heapSort(arr, true);
4 s" }1 k! l; B5 o4 P    }


    public static void heapSort(int[] arr, boolean maxheap) {
/ l) a+ i0 n# S- _. G
) W9 O) O5 x, \, R2 e! b0 A5 T* D
        //1.构建大顶堆
9 A& x3 l& D# d! @& Y% D* N3 \        for (int i = arr.length / 2 - 1; i >= 0; i--) {
$ Z; E9 W( i) H            //从第一个非叶子结点从下至上，从右至左调整结构
            sift(arr, i, arr.length , maxheap);
& f5 D, F! z$ Q" c- o# N$ W( j, G        }


- M$ s  c! N( i        //2.调整堆结构+交换堆顶元素与末尾元素
% t7 H. ?4 @- i; J3 ]% {7 }/ u        for (int j = arr.length - 1; j > 0; j--) {


            //现在的数组第一个就是根结点，最小值所在，进行交换，把它放到最右边
            int temp = arr[j];
            arr[j] = arr[0];
1 [+ r! i3 D1 `            arr[0] = temp;
. r! S( g+ O  Z' p4 O/ r' |5 B
' p2 e; N; ], P. G8 o' K% R
            //重新建立堆
4 q' |$ P  A) h$ r# @8 m            sift(arr, 0, j , maxheap); //重新对堆进行调整
6 A! h, U# M8 P, U2 Y8 o: H        }
5 K# E1 e$ f6 ?) [  v4 Z5 y/ ]    }

; S8 I% L# \! `+ o. z6 u; d
( x0 l+ T& Z* P0 i' Q& ^    //建立堆的方法
# \" V( ^+ _* ~* O8 V8 _5 C    /**
     * 私有方法，只允许被堆排序调用
2 x$ K8 L- j$ j2 g2 |     *
. Q3 X2 ?. G* l: l, M, i* V* |5 c     * @param arr     要排序数组
% p! U- w6 r7 j0 O     * @param parent  当前的双亲节点
     * @param len     数组长度
     * @param maxheap 是否建立大顶堆
     */
    private static void sift(int[] arr, int parent, int len, boolean maxheap) {
) S5 G  b6 F5 s" v) b

2 d& }# M% n: {( \: l: Q: T- i$ B        int value = arr[parent]; //先取出当前元素i
( w" n( v9 p- q+ b

        for (int child = 2 * parent + 1; child < len; child = child * 2 + 1) { //从parent结点的左子结点开始，也就是2*parent+1处开始
, N4 Z& J: x2 E: R$ {1 s3 {

; @) E( X3 Q' ]0 {            if (child+1 < len && (maxheap ? arr[child] < arr[child + 1] : arr[child] > arr[child + 1])) { //如果左子结点小于右子结点，child指向右子结点
                child++; //右孩子如果比左孩子大，我们就将现在的孩子换到右孩子
& k( w0 q; j/ ^& f$ }' W            }


# H/ N. J1 f" Z4 |            //判断是否符合大顶堆的特性， 如果右孩子大于双亲，自然左孩子也大于双亲，符合
6 t' Y6 ^! Z0 O# R9 B            //如果子节点大于父节点，将子节点值赋给父节点（不用进行交换)
8 ?5 k3 w3 s) c, N" c! ]            if (maxheap ? value < arr[child] : value > arr[child]) {
; X& }+ L: _, ?8 ~                arr[parent]=arr[child];
                parent = child;
' X2 ]. t/ D% M: B6 |            }
            else {//如果不是，说明已经符合我们的要求了。
! D$ b( H8 Q1 _; |8 k' S% C                break;
            }
        }
, W$ T/ h0 W2 c3 G6 A        arr[parent] =value; //将value值放到最终的位置



' ~  @$ F' p0 W# |0 A
& ]8 Y5 m# {; i  _, H* ?) [    }
+ S$ `% E$ {* |

}
" q! L: T, I2 z1
2
3
) F" O! z4 f: \# l- g5 c% K% o4
1 l$ ?* M& T! O& k; B5
- V* p+ K" F5 Q  P* N6
7
8
& M4 p, p6 w  r$ P& c9
10
7 h& F4 E0 S3 K% G% v; W11
12
5 P9 V; [1 h# d& z1 ]3 S13
+ Q7 \" }' |$ G. T- R, z- y14
3 b2 m: u3 P8 z! `& A6 y15
  o9 d1 U8 Q& C3 z6 {) q16
5 e! F4 F& o4 l6 F8 [7 A17
18
19
20
9 \  @% ~% i+ l# S; |21
22
, c! Q: C% t5 B; x23
24
25
26
27
5 L1 o, m! o) C5 d9 _28
- M- e; y7 l2 ^* ]: Q/ @8 G29
: z* _* K& G  F: m; H! n30
* z0 h* ~1 s% I" l& l8 t31
2 w. {% n: y+ I# e+ A+ K32
33
  ]9 d5 ~; J6 g& _9 @* R, t34
( c7 z( i. z. v! c) e35
" F2 F" J7 Y+ k  P36
! n- {6 n% ]9 l1 m37
9 y# |; Z1 u0 e" a% W& u38
39
40
41
42
43
44
45
# o! y, H3 s2 K: c9 O- f, J46
0 I  Z7 f: |7 a3 L- P/ _  \* G47
48
49
50
51
52
) i7 ?5 _" R3 H* V/ e% }' C53
5 @% y. ?/ A& A' l+ ?/ D. Z54
+ S, m1 K) \* R/ n9 @8 T3 s55
56
57
( y$ i% T+ b" h, \58
6 b- M( X) ?& d" q2 i& W59
60
61
: l0 j, {/ ?2 b, M# _* n9 c62
$ E  C2 L3 n! Z5 T3 a63
% o5 s2 C; i- h64
65
, X$ L& t) q% x66
4 k9 Y4 r) R2 q$ }67
, i3 p6 Y0 f. _" l! b68
69
70
, D0 o2 m: v& G) c/ j6 g& r! \71
72
& Q- i" C. I6 j! ?8 t73
74
1 O1 y$ U" }8 u7 s# j% k归并排序
1 U( C8 m+ K- o0 U8 _简单解释：
该算法是采用分治法，把数组不断分割，直至成为单个元素，然后比较再合并（合并的过程就是两部分分别从头开始比较，取出最小或最大元素的放到新的区域内，继续取两部分中最大或最小的元素，直到这两部分合并完，最后所有的都合并完，最后形成完整的有序序列）


1 u1 _3 {5 ?5 e) {+ ?7 J. x
( {6 a& k8 q$ y% D


4 Q4 [$ |/ M" U* L完整代码：
" h! d7 w$ `8 V+ _% P( v

+ t. N; [0 n' J4 H+ a* [& Vpackage com.keafmd.Sequence;
* p/ ]/ v* @& i8 g7 s7 {8 b1 e
/ G) w3 Y+ q; q+ k: @( I
/**
* Keafmd
*
+ s$ ^9 d; y3 u5 c * @ClassName: MergeSort
* @Description: 归并排序
* @author: 牛哄哄的柯南
3 e7 o9 b7 }' i0 t * @date: 2021-06-24 10:35
' G* d: f" v9 ~8 d */
public class MergeSort {
. V; r. D) s3 F* F% x5 y

( U& B* L3 I" m2 ?/ m    //归并排序
    public static void mergeSort(int []arr ,boolean ascending){
        int[] temp = new int[arr.length]; //在排序前，先建好一个长度等于原数组长度的临时数组，避免递归中频繁开辟空间
3 g  p9 N2 y! B2 j6 H8 A% N8 o        mergeSort(arr,0,arr.length-1,temp,ascending);
    }
    public static void mergeSort(int []arr){
7 j* S% @' }. s$ o        mergeSort(arr,true);
1 J# P* w6 m- X    }
3 p0 F; r1 ~* D
# z0 I( E& K. g( P  u' S8 A3 Y
5 W) C+ h6 x' ?7 E9 g( B) {4 T2 B    /**
     *
- X0 [3 e8 y2 g& u* V     * @param arr 传入的数组
, k6 P+ _; F$ c5 ^     * @param left 当前子数组的起始下标
     * @param right 当前子数组的结束下标
     * @param temp 拷贝暂存数组
" Q; F7 f) [- q3 @     */
1 h/ ?4 |3 X' u* F    public static void mergeSort(int []arr,int left,int right,int[] temp,boolean ascending){
* Y% ?) u, X4 q- v/ L$ k        if(left<right){ //这里是递归结束的条件，我们是对半分，那当left==right的时候肯定大家都是只有一个元素了。

% r" H9 P+ X- i) z: H9 |, }
            //对半分，比如总长度是10，left=0，right=9，mid=4确实是中间分了，0~4，5~9
8 A: e+ s' p' {. I+ V' a            //当长度9，left=0，right=8，mid=4，0~4，5~8
            int mid = left + (right-left)/2; // 防止越界的写法
0 |4 S- I) y* m  w0 t  O0 q6 J7 z- ?            //int mid = (left+right)/2;


            mergeSort(arr,left,mid,temp,ascending); //左边归并排序，使得左子序列有序
            mergeSort(arr,mid+1,right,temp,ascending); //右边归并排序，使得右子序列有序
% s; y8 z) S) m- e  d- l% v' w

            merge(arr,left,mid,right,temp,ascending); //将两个有序子数组合并操作
! O0 R. e4 r9 q- ?+ l) ]' T        }
    }
8 A4 o: Z' e# ^# d* X
/ |( R7 \: U- }/ T4 R1 X" l
    private static void merge(int[] arr,int left,int mid,int right,int[] temp,boolean ascending){
- F; T2 n/ @; Y  b- h$ Z$ ~& ~& h        int i = left; //左序列起始下标
        int j = mid+1; //右序列起始下标
& r; V! l" n2 f% o, P/ F. l        int t = 0; //临时数组指针
        while(i<=mid&&j<=right){
            if(ascending?arr<arr[j]:arr>arr[j]){ //比较两个序列第一个元素谁小，谁小先拷贝谁到temp，然后对应子序列下标加1
) j2 S5 J- p. G+ y( O' H# H                temp[t++] = arr[i++];
            }else {
) V9 f3 t0 a' N- O                temp[t++] = arr[j++];
# U5 v% j/ @0 \8 G! _            }
        }

) `2 a" x; _; F7 k0 S7 O6 N
$ q/ B7 `' d2 w1 O2 ?0 [        while(i<=mid){ //将左边剩余元素填充进temp中——左序列有一些数总是比右边的大的数
9 ^) t9 t0 n5 j. S; z; X            temp[t++] = arr[i++];
        }


" b/ p/ T8 X( ^+ l        while(j<=right){ //将右序列剩余元素填充进temp中——右序列有一些数总是比左边的大的数
: k1 ~( d" L2 @$ z( d6 ~            temp[t++] = arr[j++];
        }
9 J% q; A& T1 q$ V" @' v
$ L7 Y& t- t4 |& L
        t = 0;
6 n: k+ t3 ~! h" ^/ B, K

6 M4 l' \- z' S        //将temp中的元素全部拷贝到原数组中
# k' |* W; v5 e0 T* l+ y/ V/ P        while(left<=right){
: ~4 }! V+ p* L1 Z! z- }! b7 J            arr[left++] = temp[t++];
6 I( l0 l: ?- ~- e) i        }

2 |! c/ N/ V% M) `  H8 y' t4 d9 A
+ v+ Z- {/ `2 J" A; Z! T0 i    }

2 [& y4 H: W5 m5 g/ z
1 \. r- _1 b( h) m! F7 `}
: ?/ Q2 i7 u# ~$ V4 {6 n1
( c" t0 G, p" }! T, T9 O+ S( n2
3
+ m6 F& L, Q" x4
5
2 T1 l0 F2 Y- F6
7
8
9
10
" d& j- F2 y+ p% `11
  F* @+ k$ u2 L0 u$ T12
13
( {/ F' A: K: K% b, w* k! a& y14
9 g( C3 F7 R1 h4 k3 S15
* [5 j( o; N5 K/ W4 X16
# z  c& {) G  X" l' v1 q17
. e- m7 x1 F# `6 `18
19
* w& R$ A* p$ c5 n( Z) Z20
21
22
23
. `% x4 I4 |+ G& i# p& H+ R2 m24
6 o+ ~4 Z3 `2 M8 c25
7 m/ l/ {# |: Y- u26
27
6 E( H3 J' E( @, G4 ?$ y28
29
30
7 i. B/ R8 h  }: [+ R! U31
32
: P6 h8 @1 _6 t" B5 Q* z7 n33
) \+ {# x, X/ r9 ?8 u; J. a' `34
35
36
. b4 V9 k  o' w37
38
) L8 B4 n& s+ ^39
: I) e# |! [; b3 B& d2 f, K40
% M7 a, v) I. A) G0 n41
: @- K" z0 i0 a) P0 ]: y42
43
44
45
1 S& @2 m- F0 g+ o- S% r* H; }46
1 b1 `1 G' c  m, ^2 f- _" @* [47
48
" o% c$ }; A9 f% q( k! Z6 A49
50
  w" o, R- d1 @8 p* _; n51
, y% e  j, s2 j! F! m7 m52
& `  X- H. e1 N, d. p% k53
7 s1 |( Z' b9 e  [: R/ }9 f54
55
8 Y) P8 Y# A2 y$ g56
& ^5 g4 G* C1 `/ z. p/ }57
58
7 Q$ m2 h2 W- }9 O$ T2 ?59
4 G  a& Z1 g+ R" j. D: `60
61
62
63
. ~0 R: p8 t& e7 e64
# l( I( k( l  i" Y65
8 \' c! H$ R0 o+ R: p/ K5 m# C66
67
68
! z. P# `8 G$ s. k. e9 W6 n6 j69
0 N6 x6 A( O0 R# {+ u70
3 _1 u* @* [7 C* q/ Y" f* S- R5 _4 U71
5 y' g+ `7 T$ \0 x4 o& h* J72
8 h% _2 _8 d; K* _73
/ n+ N3 J$ Y& Q插入排序
简单解释：
最简单的理解就是打地主时我们拿到牌后的整理过程，从第二个牌（假设我们拿起来这个牌开始比较）开始，（说下升序）从后往前比较如果比前面的那个牌小，就把牌往后移动，直到找到一个合适的位置（这个位置的前面的那个牌不比这个要放下的牌大）就把这个牌放到这个位置，慢慢的前面的部分变得有序，直至全部有序即可。


, N( w6 ^. C2 {' F( ~2 q* f/ X; j
6 `" j3 X+ e, {5 m) S- n


8 n4 s" a# p# m; K0 \) Z完整代码：
1 ~% h3 D9 E" ~) \; A% {' d

package com.keafmd.Sequence;

2 i! j9 ^0 t+ E$ Y/ f6 d
/**
' a9 |6 C' @( I! Y5 l * Keafmd
* `" {: N  g  R! b, } *
# I4 J0 e5 Y( W# o( ` * @ClassName: StraghtInsertSort
* @Description: 插入排序
7 U* l5 _' [' S. d% `4 ~ * @author: 牛哄哄的柯南
( ~$ J5 ^# f, t0 K5 D3 ?( [7 q * @date: 2021-06-24 10:36
*/
public class StraghtInsertSort {
    //插入排序
    public static void straghtInsertSort(int[] arr) {
4 A& B* h* q1 T& z6 C: d- g" J, n        straghtInsertSort(arr, true);//默认进行升序
    }


1 c% h" z: N' n+ j  G    public static void straghtInsertSort(int[] arr, boolean ascending) {
; g. b# L: ]1 t

. M! J- ]3 \/ [7 T        for (int i = 1; i < arr.length; i++) {
            int temp = arr;
+ X* a! F1 _6 C' m" E: i5 e* d$ D            int j=0; //这就是那个合适的位置
            for (j = i - 1; j >= 0 && (ascending ? temp < arr[j] : temp > arr[j]); j--) {
" G# k+ W1 F$ ^3 T" J                arr[j + 1] = arr[j];
& g; \% O/ s3 @0 `: c" q7 r) p4 t$ k            }
2 {. ?4 F: t. V6 V            //把牌放下，为啥是j+1，
            //是因为上面的循环遍历到不符合情况的时候 j是合适的位置的前面的那个数的位置
            //有点拗口，但是就是这个意思，看图方便理解下
            arr[j + 1] = temp;




' P9 O+ t9 y  B3 t2 W# l        }
$ S4 E2 B$ J1 S8 B! D

    }
0 O6 x5 g) c- ]' {}
1
2
" [' F6 X2 U$ s+ \3
4
7 F* k8 k$ m/ l6 Z5
6
7
4 {0 J* S+ `$ l+ R7 B8
9
: |6 _& P% Q  a  ~! _10
) M1 G' W+ O) E. X11
12
13
3 E7 X  c* J# w8 |' h14
$ o; e" q) p* A: b+ r# K3 w% {15
/ M! G5 G: L6 {/ [16
17
% t1 S2 ^9 t& M18
19
20
21
5 ^7 I: S2 ?  C22
5 Q/ A8 W- ~- e$ B0 ~/ G9 Q23
24
+ m% V* b' @: C! L! B% o25
7 ]) S. z. @! @/ Q. S26
1 y) b6 Q, |# _27
9 Y( N# O% G$ D, R; l: c28
29
30
31
32
! {( |; }% _* C7 X- ~; B33
' _1 N0 c+ W# i9 ]5 k34
希尔排序
简单解释：
希尔排序是插入排序的改进版，我们理解一个叫做下标差的的东西，也就是下面那个图中的增量d，初始下标差为arr.length/2，然后继续/2，对在同一下标差（相当于把这几个数单独拿出来了）的若干个数进行插入排序即可。

6 l- }2 @  B, W+ F& c

4 ]0 T$ ^4 n3 I9 s4 i1 y- [& X) C
2 N) L2 Q" ^& i/ |1 w. ^6 O
; E+ s' I6 n3 W+ }7 r! {, n& T- V
完整代码：

/ O6 V- W; A9 c$ e0 J5 j0 U  V
' N4 _9 d8 s7 ?2 d$ kpackage com.keafmd.Sequence;

4 Q* [4 {9 E, r$ {& w
. y9 [, [9 y- H; ]) D: K5 ?/**
0 V1 u0 x$ M8 o# w& o * Keafmd
*
* @ClassName: ShellSort
* @Description: 希尔排序
* @author: 牛哄哄的柯南
" F9 l0 h8 U- W$ V# |: @ * @date: 2021-06-24 10:39
2 C4 h3 n- Q& u8 M */
2 Z* w' s! \) P% M. I4 hpublic class ShellSort {
" ?) m9 Y) ]3 [

% q( S8 o1 h4 _. D9 X    public static void shellSort(int[] arr) {
  n* j- d1 k, N4 u- L        shellSort(arr,true);
' `' _, w( S* x+ P3 _& A. B    }


# r/ C- d* ?$ h  F5 }    public static void shellSort(int[] arr,boolean ascending) {


        for(int d = arr.length/2;d>0;d/=2){

7 Q# ]7 r3 K5 i, \$ H3 [& e
  b7 z2 Y4 [. ~+ o! C7 n            for(int i=d;i< arr.length;i++){
- p) k) e* p/ q+ t, _                int temp = arr;
3 n- ]( J( F* P& V4 k                int j=0;
/ w* A2 a4 `' d* n) ~" x                for(j=i-d;j>=0&&(ascending?temp<arr[j]:temp>arr[j]);j-=d){
                    arr[j+d]=arr[j];
                }
7 \  e: p! p7 ]% S& w' X# |                arr[j+d] = temp;
            }
# B2 Q* Q8 ]% s: D& e$ @0 |7 o        }
& a& k+ D# b' Z+ e- N

    }
}
* Y9 \, {1 y* d/ z: K+ [6 x1
2 k/ ^( ?  F# T5 {$ C9 H" G+ V2
9 p, J9 v/ H: R4 l! M3
4
0 l0 t8 S4 K. Z4 k6 h5 G5
6
, @& }3 S4 m- B3 Y  n7
8
. I5 m6 @, J( Z2 v& ]. _9
10
  ~1 f9 G8 D8 Y# I$ W) x$ G11
% p3 ?9 ~6 N7 o! R1 p" `( I/ Q- y12
; ~* `! J* k2 x, J* Z. Q4 j13
, y% w$ j: Z2 e  B' [$ V& c% @; e14
( }) c: q9 ?& n3 y15
16
17
18
19
7 C: b& @' V. A  v2 m20
; O, h# a6 V1 p. Z5 z9 |+ B21
22
& p$ X# t1 B% V& k) g7 s23
' ^( h( C9 ]+ y) l6 _24
& h& Y& D+ D7 y8 }$ V" h5 D25
26
: \& C$ I4 x( l; T/ E+ N* I27
28
29
30
31
; m$ }% M$ s) z, \# e8 T) X; [32
计数排序
简单解释：
这个排序算法看名字也很好理解，就是就是额外找个数组来计数，然后在这个数组从小到大或从大到小把数取出来即可。


0 U, q' u; K9 M1 r0 q
  s. M5 k* q- k3 a
; G1 u7 d0 R! W# V
* A0 P% f, Q$ Q2 N' t5 g
完整代码：
9 q* g3 s4 y* W" Q
- f) E; Y2 w, [8 X* J* o
. y2 S$ C% n  Q1 T4 D% R% S7 Gpackage com.keafmd.Sequence;


/**
6 @) A# _1 h% t$ p/ L& u, b * Keafmd
*
* @ClassName: CountSort
* @Description: 计数排序
* @author: 牛哄哄的柯南
! m$ G1 ^" M3 g( o9 T, X * @date: 2021-06-24 11:31
% o& ]' V5 u& m */
) l: v' Y" \- E1 Ppublic class CountSort {
8 p$ h8 r; X6 A* D

; n. G2 W9 \" @0 b, g0 [    public static void countSort(int[]arr){
        countSort(arr,true);
& m/ q2 I* k5 k5 J3 ^! Q    }
$ V* j# c$ n, p- F

    public static void countSort(int[]arr,boolean ascending){
        int d,min=arr[0],max=arr[0];
& o' r& e& ~( l

        //找出最大、最小值
        for(int i=0;i< arr.length;i++){
& h$ L1 R7 m5 a% @2 J& z$ |            if(arr<min){
1 g! x6 }/ b" m# i+ Y% G; Q0 I* z                min =arr;
            }
& D: Z2 b' D! [0 i  \1 y  r            if(arr>max){
                max = arr;
            }
        }

# H3 h. B* I: e. h, D) m' x
        //建立一个用于计数的数组
        d = min;
- ?6 h; x: _7 W0 }/ T        int[] count_map = new int[max-min+1];
        for(int i=0;i< arr.length;i++){
            count_map[arr-d]++;
        }
% R* }6 ^0 g: G: X$ _

9 U1 }! r/ u# C8 w7 [        int k =0;
/ u! f+ m% l+ T( m% g* D        if(ascending){
4 O5 H( ]/ A$ D. k0 @& Y& L            for(int i=0;i< arr.length;){
' z1 l' }$ l3 s7 c5 m* U                if(count_map[k]>0){
, Q6 j/ r9 [9 }5 {7 H                    arr = k+d;
                    i++;
                    count_map[k]--;
3 d' g* G2 @9 A6 E                }else
5 y  I/ M+ ^+ f: H# Q                    k++;
            }
- L$ y% n. k0 R: Z6 z        }else {
            for(int i=arr.length-1;i>=0;){
                if(count_map[k]>0){
3 y* w/ V, A' @0 o( [                    arr = k+d;
1 N+ t. Q# v* d% H4 Y4 `                    i--;
7 }. q: }# {+ [+ m                    count_map[k]--;
                }else
                    k++;
# P: a% `5 i, c! b1 X3 U. a* m            }
        }
; v$ }; u  h* M2 I+ }0 p2 l

    }
}
6 I5 C! u& }1 D1 V: z. Z' g+ Q1
2
9 F0 B( S) L  `, z( H: |# E5 c3
4
/ z7 O! }& z3 U- I9 `5 z) J% N5
6
7
8
" ]5 M. o$ x9 G* G& Z) J- M% c9
10
11
' t0 Q2 T: e9 P5 [& i# S5 q+ `12
7 G. z) G- B( A: d13
/ m' w' q8 h5 X) e8 e3 t14
0 F. i! I5 L. p; u- y15
! c1 k8 o/ {0 N; u16
17
) q2 _% s3 Z- M0 o! u$ q18
19
20
) o+ y7 w! n3 N7 ~; n$ ^+ z21
0 J' ?# ?! Q1 K. f7 R- S22
% |. ^1 }& v4 ]/ T, |  _; w23
24
25
26
% J. \6 O( L% j27
8 c  w; Q$ Y* t6 _/ E: b/ z. `28
" B- R- q6 B  x2 `/ A+ u: X29
3 ~6 j' i. ^) b5 o$ \% ]30
6 R8 V; [1 {" z1 R31
32
33
34
, s- }; i  S8 S$ j4 y6 L35
36
37
38
# `2 b  C4 p! s  P39
% [, {4 _: z. _* k6 s8 z9 ?40
9 k' w% \0 n2 n41
3 R2 ]0 G% \" [2 V42
& A/ Y& @' c2 E: s5 Q! \43
44
; `: a+ p6 p% g  I5 p2 s45
46
5 j/ p( [$ M% A- j& g47
" Z- K3 h7 @1 j3 `- P' X- ]5 y48
: _4 A- h5 R& ?" r6 y/ d1 Q! o* D49
50
% C4 ?2 Y1 }/ d( \51
/ |, w- ?! R! n52
+ q* }# E1 |+ F2 m53
0 d: u7 p* p8 q- i) J54
55
% j) M. ^, K: r% I  b$ S; l! R56
' k$ l5 W+ }: C- c+ `* b0 i57
58
59
3 S6 X! Q4 }8 O! k桶排序
1 ]6 t+ y1 a5 i- L$ f简单解释：
就是把一个数组分成几个桶（其实是几个区间，从小到大或从大到小的几个区间）装，然后让每个桶（区间）有序，然后取出来放一起就可以了，相当于把几个有序的段拿出来放一起，自然还是有序的，当然需要是按照区间的顺序拿了。






+ B9 ?1 v0 S/ f# F( @& x. @+ Q! s完整代码：
1 e! n  {" l. s
- H& Z* Q* x7 e* y7 e9 C
" |9 s7 Z. y" K) fpackage com.keafmd.Sequence;
" e# R% ]- \# M" [9 j) L) E

( G7 }/ P( s( u) u+ f3 Kimport java.util.ArrayList;
5 f7 U4 H% q( p# d3 |import java.util.Collections;

2 l4 l  f1 V8 s: \
/**
* Keafmd
*
; W8 I7 O% Z$ E& Z * @ClassName: BucketSort
* @Description: 桶排序
. B/ m7 O5 Y9 f3 M4 u# { * @author: 牛哄哄的柯南
* @date: 2021-06-24 13:32
" _0 i, ~$ J/ W2 ] */
# W) J$ E5 y& V0 m9 X( s6 S, ^% w. Fpublic class BucketSort {


( G% U" R2 k( S    public static void bucketSort(int[] arr){
9 }" }" {" l/ R1 n( n. I5 o  c        bucketSort(arr,true);
6 ~4 K  t* T5 S3 m/ Q, |4 [/ n    }
- O# Y- T5 h9 h9 O( X* }& M. `7 Y
% K+ C8 @, b/ A7 R% C# a0 a7 v5 p
/ @3 `3 j5 i) j) b4 Q  x  J% v    public static void bucketSort(int[] arr,boolean ascending){
        if(arr==null||arr.length==0){
            return;
        }
1 V+ ~( I# n2 z  s        //计算最大值与最小值
        int max = Integer.MIN_VALUE;
        int min = Integer.MAX_VALUE;
" Q  G8 F& c4 U0 j8 e        for(int i=0;i<arr.length;i++){
$ [% ?( r0 T! Z) Z# k' }            max = Math.max(arr,max);
            min = Math.min(arr,min);
; y6 t( L+ V  P; `0 t; q3 q, I9 z        }

9 n9 B0 R; F& M% o& f+ O
        //计算桶的数量
        int bucketNUm = (max-min)/ arr.length+1;
( j9 T; f$ D, S; I. Q' g. y( |1 E        ArrayList<ArrayList<Integer>> bucketArr = new ArrayList<>(bucketNUm);
        for(int i=0;i<bucketNUm;i++){
4 r# ?3 I$ t% ~' w" I/ d            bucketArr.add(new ArrayList<>());
        }


        //将每个元素放入桶中
# V1 v9 A4 G+ ?; r. U; n8 d        for(int i=0;i<arr.length;i++){
            int num = (arr-min)/ (arr.length);
8 R3 c# ~! K. Z4 R! E            bucketArr.get(num).add(arr);
        }

* `7 T/ D9 y) f: d- b# ]
        //对每个桶进行排序
! m9 |# k5 r; C( r        for (int i = 0; i < bucketArr.size(); i++) {
) D2 n2 o) f5 [            //用系统的排序，速度肯定没话说
5 ?1 _2 k( z; Q( E            Collections.sort(bucketArr.get(i));
- G* @) J4 s& r* q        }

9 s9 b# b1 C0 a5 u( ]
        //将桶中元素赋值到原序列
        int index;
        if(ascending){
            index=0;
        }else{
            index=arr.length-1;
        }
3 G# s/ t9 q2 g1 b% H

" S& q5 C' \# R8 t2 w        for(int i=0;i<bucketArr.size();i++){
            for(int j= 0;j<bucketArr.get(i).size();j++){
! u. |3 T. c. r5 [% ~                arr[index] = bucketArr.get(i).get(j);
) m1 }/ a# k# o- Q                if(ascending){
                    index++;
) i/ N4 y" c' k& D+ |; g* v/ X                }else{
5 f( Z  P: |5 ~# m. l7 k* b                    index--;
                }
0 F3 b  k, G5 R8 t3 @  E2 k) p            }


        }

; i# P% W0 X7 o  O4 A; p! T2 T6 R. I
, }" }8 ?$ M2 M8 x# |    }
4 Y1 [* l8 e( {6 `- _}
# C3 R' m; A- ^7 Q* z/ z7 `1
' Y4 `/ _# U. }# t0 E$ ~2
3
4 y9 V( [* W* Q! F: `$ {" k4
( B0 Q  e) C* S4 {6 e5 e5
2 L: w. _6 h0 O% S) Z3 ~6
2 k( y. x; [+ D$ H7
8
9
10
9 `  ^) x; l" L2 o0 u0 R11
: F( M* Q# {9 E) V12
9 X7 L8 Y2 f- L5 c' O13
14
15
! N% u* g  `1 _+ A) i% L16
6 F+ Y. }2 [: A3 ^! z17
) [4 K8 D' `" r: L18
! B$ I2 S8 N+ |2 E8 f% ~19
/ R3 m, M' A' H$ W% m' t, A* c$ S20
' G9 |, {2 I; |8 h5 [& U21
% V- s4 ~! `5 Z* a* X3 B22
23
9 D# `4 Z. D, ^! H3 _- I24
9 ^+ R; n7 D' ~& H+ g25
3 G& |0 [) O% Y/ g0 v! P26
27
28
) m+ o) [# s$ s! u7 `7 ~' f29
30
31
32
' G, m3 n- @- ]% i33
34
35
36
37
3 F" X; `2 d, l. ]) \38
39
40
41
% U% h; c0 D& ?) L" ]42
43
44
/ v; k8 c7 s2 m& F. y45
5 {, C6 K2 `% q46
5 U/ x# ~+ g  T0 U' P47
7 Z! G- l% `2 l+ v& q4 I48
49
50
51
2 S3 L* z3 {% h- t: ^52
6 ^+ F) @5 P& @' b5 y  {53
1 D( P  A, F; ^9 i; i54
55
( q: F6 t# B# t7 I56
57
58
0 @  E& U7 \( H7 Z: @# G% ^59
+ q  q$ X6 d# a5 w' q% l' l60
; a# }% q& d: J5 X61
& Q1 i! v2 g7 ]6 L62
63
/ f5 j- p; A. j64
. i; }! F. z  ?7 ~- K0 t' l8 ^65
+ I: P/ M; s0 U8 |" i66
67
8 }3 V1 x; J4 D8 y( J* r# Q68
69
70
! {, P6 Q% d$ Z  k5 N4 ?71
72
基数排序
2 V# C- J: M% A* o简单解释：
首先说一下，我发现好多人写的基数排序只能排序正整数，其实只要处理下就可以排序含有负数的了，就是我们排序前先把所有的数整体变大（就是减上最小的负数，也就是加了），都变成正数，然后排序好之后，在减下来（加上最小的负数，也就减了）就好了。
8 y8 C+ U2 _2 Y) |基数排序就是按数位排序可分为LSD（从最低位[也就是个位]开始排序）和MSD（从最高位开始排序），下面写的事LSD基数排序。
基数排序就是把数按位考虑，让后我们一位数只能是[0，9]，就是我们在考虑某位（个位、百位· · ·）的时候就只看这个位的数，放到在[0，9]相应的位置，然后顺序取出，最后再按其它位这样操作（上面说了要不从低位开始到高位，要不就是从高位到低位）

' O# r- Y6 l1 y# P) U! w+ l
+ M# b6 U1 S0 w' k) h



完整代码：
0 v9 n% a; S6 f( X+ G

2 S7 ^  T4 i/ ~% `9 Q6 ppackage com.keafmd.Sequence;


9 m/ N" J. v- B) H- f) V( B/**
9 c5 R9 H6 {8 j- @ * Keafmd
3 Q" a6 W: d+ m# k1 l *
* @ClassName: RadixSort
. C4 O$ Z7 c1 ]( s0 p/ J" C2 ` * @Description: 基数排序
* @author: 牛哄哄的柯南
* @date: 2021-06-24 14:32
*/
, F# D$ J' M) s7 {public class RadixSort {
' Q% ^) L' K3 R2 M) ]7 x    public static void radixSort(int[] arr){
7 e. x8 q4 O  D% T4 j. {" c/ R        radixSort(arr,true);
) h+ M/ M1 }/ ]8 U( K7 v    }
2 Q- R; X% b+ `+ Y% h1 u    public static void radixSort(int[]arr,boolean ascending){
        int max = Integer.MIN_VALUE;
        int min = Integer.MAX_VALUE;
' e* M1 \" ^* E- W        //求出最大值、最小值
" g4 x. x4 l, R$ C2 {2 D5 K- B        for (int i = 0; i < arr.length; i++) {
            max = Math.max(max, arr);
            min = Math.min(min, arr);
  f7 e4 F, O; L9 e" Y1 M' ?        }
$ @& h5 ^4 h' _9 `7 @  u        if (min<0) {        //如果最小值小于0，那么把每个数都减去最小值，这样可以保证最小的数是0
/ M* s8 G  K  T7 e8 Z            for (int i = 0; i < arr.length; i++) {
                arr -= min;
            }
7 m* ]& W5 U# F5 j            max -= min; //max也要处理！
1 ]1 J" m! ^+ ^+ z$ U( R        }
        //很巧妙求出最大的数有多少位
6 ]6 a) @7 r/ T9 {: h6 S        int maxLength = (max+"").length();
        int[][] bucket = new int[10][arr.length]; //一个二维数组，一维代表0到9，二维存放符合数
5 j7 R3 Z8 B* Q/ ~$ N& g4 b        int[] bucketElementCount = new int[10]; // 用于记录0到9某位存在数字的个数
        for (int i = 0 ,n = 1 ; i < maxLength ; i++,n*=10) { //个位 十位 百位 这样遍历
            for (int j = 0; j < arr.length ; j++) {
2 J) t  U# O& }2 [- i8 D$ d6 ]                int value = arr[j]/n % 10;
                bucket[value][bucketElementCount[value]] = arr[j];
                bucketElementCount[value]++;
( l8 T" X6 \, M6 K0 n            }

6 U/ Q! o! e+ h8 j
            //升序
5 w  }0 d! T: G( G5 t            if(ascending) {
                int index = 0;
, l. z/ F: n! n( ^3 M- G                //从左到右，从下到上取出每个数
5 L8 @/ D- G6 ?: A% O                for (int j = 0; j < bucketElementCount.length; j++) {
                    if (bucketElementCount[j] != 0) {
5 _/ l9 Z5 a* b" B6 i8 |4 H+ J                        for (int k = 0; k < bucketElementCount[j]; k++) {
8 H4 J# r! `: w                            arr[index] = bucket[j][k];
                            index++;
5 K" }1 m8 F. o" R8 V                        }
1 l. \3 ~2 y, P( n                    }
                    bucketElementCount[j] = 0;
' U' w; i4 y: O7 l: x                }
            }else { // 降序
                int index=0;
                //从右到左，从下到上取出每个数
                for (int j = bucketElementCount.length-1; j >=0; j--) {
' S& O, r* W# Q- x- w                    if (bucketElementCount[j] != 0) {
                        for (int k = 0; k <bucketElementCount[j]; k++) {
                            arr[index] = bucket[j][k];
                            index++;
                        }
                    }
5 o6 `/ _, k) x" e6 Y& ~                    bucketElementCount[j] = 0;
                }
) K& E- D4 ~5 J8 v            }
( Q" X& I. B: J9 i5 V0 W6 Z: ]- V

$ l) H5 P2 `/ Q5 R( k
9 y/ g0 K; `' R6 J
! o0 T5 C/ B! P; i            /*for (int i1 = 0; i1 < arr.length; i1++) {
                System.out.print(arr[i1]+" ");
( H( `4 N, e# }. V% `0 H            }
            System.out.println();*/

; I7 m  z/ ~) D, m' C* n- v/ ]0 L
. r+ `6 X+ H3 \' s  w9 v


' C# k9 ~$ o; x% m; }5 Q
6 [* W# }3 n5 D# V, t7 x        }
        if (min<0){
. K5 m& ~' W# n) C  r            for (int i = 0; i < arr.length ; i++) {
' M* M9 e  Y( f8 f+ O4 q                arr += min;
% G* f8 p: b/ b0 G; w- ~7 Y$ H            }
        }

; |. {6 A% T" j4 @; m' @6 e
: F& O+ d. s; U! l6 `8 _: {    }
9 e' ?& \% x, G& s% B% z4 ?5 L3 W}
1
! x0 Y- v4 q& `$ E3 h) J. w- w- ]2
3
& E0 i: d: a0 [5 [4
5
6
, K6 R1 Y  h9 g1 P! W* J4 |7
6 x2 L: _' x. S, M9 s4 X8 m1 j8
9
10
11
12
1 L- K% Y1 I$ \7 j# p  O; p13
* c+ a0 G5 f' ^, W1 c14
1 ?  u8 `7 e- \9 S; v4 p15
  m3 R; ]# U3 v- [/ ^& U16
17
18
19
20
21
22
23
24
( k4 o+ l$ s; T8 k25
26
27
+ b  j) x8 S6 G28
+ P$ N8 u' I. B  D+ l, D8 ~7 ~6 H- E29
30
31
, c) v$ L" k0 |8 ~* C32
/ V1 Q$ T3 `3 T' @, u$ x33
34
35
36
3 N+ x8 y% `  b4 y37
& Q! M2 F* i7 c; i0 J9 p6 \( E38
4 {, W. I" Y- X: g8 x7 y& G39
+ d0 ~' i. H4 [0 m5 M4 q40
41
42
! T2 @/ G! ^4 ?9 y* m43
44
6 X' e0 \, p: o45
4 I: h. F. G- E/ k2 Q46
47
48
* j- I# V. t. \3 F$ @8 ^49
9 |9 T% ?6 p' L6 {- H6 l50
51
52
53
54
55
& ~  H" F' f( M) m2 E% {6 C56
) X6 r! W4 \3 r57
) p/ b0 _% Z. P. s4 g( z$ g0 L6 q58
6 D: [- X# x% K" p# J! U59
+ T( v6 t3 m- U  h, u8 ~0 I60
7 w4 G" R, B# S. {. l1 N5 k+ L61
; p/ n& H: D: x62
63
2 t4 l4 c9 C+ w; p3 [& W! Y64
65
6 i# {) x: @  J66
  }3 N8 o7 G8 u. U; r2 r67
" ?: A( a( s5 A9 i' D( l68
/ T% ?  C% }0 z# k69
7 @4 A" m) e* f* }70
6 y5 o1 l% |" _9 D) H# c2 Q& X" B71
72
73
5 P3 L- V9 ~( \4 i3 p; x- d1 X74
75
76
, U% w1 {8 Y4 D; w. t0 K77
8 g7 }. y& n# d. u" j; W+ B78
; |! x  @3 T: F$ [8 s; d79
  Y% C( n+ w( _0 s) ~5 U/ x3 m80
81
$ s( f+ V9 S! i1 O: v1 {- u82
83
完整测试类
& q4 n4 b1 g2 U3 f7 h% ypackage com.keafmd.Sequence;

  s' ], R& v& |5 `7 W. U' {
, B2 V& [8 n: ~8 b* K3 v4 iimport java.util.*;
import java.util.stream.IntStream;
import java.util.stream.Stream;
$ A0 f! L0 a( J+ B' }8 p
" d& Q1 ~; h* W+ s' s, ~$ |
$ V) ?/ h* Q! v( w; i/**
* Keafmd
/ z9 ~: E, t& ~  r! ?& i *
% ]  A  }& `/ O/ J: V9 I6 I * @ClassName: Sort
4 P5 y/ a. q; Q% c: h * @Description: 十大排序算法测试类
: w2 Q; X) w: k1 t# s5 {5 `: S- @4 d+ T+ } * @author: 牛哄哄的柯南
* @date: 2021-06-16 21:27
* c# U( j( e# o- k0 b! E( L3 \: A */
public class Sort {
0 a! u% b' [  Z6 O$ V

" N# A0 N. T1 S

    public static void main(String[] args) {

5 E1 x" Y* C$ d) 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};
        int[] temparr;


( t& Y3 F7 J) L- ?        //利用系统Collections.sort方法进行对比

0 P+ s' a: @! G. y3 b
/ g& M$ b" i9 B4 n        //将int数组转换为Integer数组
& Q9 H: p: v- J3 G4 Y6 S$ S$ h        //1、先将int数组转换为数值流
        temparr = nums.clone();
/ b5 E5 o% T% X( g( ]        IntStream stream = Arrays.stream(temparr);
+ K6 x4 a% V9 Q# B; v' h+ ]        //2、流中的元素全部装箱，转换为流 ---->int转为Integer
: N/ Y) L" d/ w( [  |& E        Stream<Integer> integerStream = stream.boxed();
. r8 N0 T& }- b        //3、将流转换为数组
! x! }* }. ^5 S, F        Integer[] integers = integerStream.toArray(Integer[]::new);
        //把数组转为List
! y: N, a2 g/ @+ Z! D8 x7 i$ N        List<Integer> tempList = new ArrayList<>(Arrays.asList(integers));
4 R" b4 \! b6 ~2 E$ Z# x        //使用Collections.sort()排序
        System.out.println("使用系统的Collections.sort()的对比:");
8 X( r  C8 M/ @9 `7 @) k

3 @2 ?( b( l! K, b        //Collections.sort
        Collections.sort(tempList, new Comparator<Integer>() {
            @Override
$ u- H4 P7 S; K  H5 u# }0 E            public int compare(Integer o1, Integer o2) {
) N* F9 y% D9 N; w/ o1 [                return o1-o2;
                //return o2-o1;
1 z, L6 _9 [+ |! ~  {            }
        });
3 j5 Y0 q) `3 }
, D9 {; \7 y9 Y$ D1 l7 z" N4 j2 W+ W( i
        //tempList.sort 也可以排序
: I, F  X* M- w  J$ g# r! h       /* tempList.sort(new Comparator<Integer>() {
, I( ~: E' \" L. d) U0 m            @Override
            public int compare(Integer o1, Integer o2) {
                //return o1-o2;
                return o2-o1;
            }
        });*/

( u9 Q$ @, q0 F# i. {! A" h' \
        //遍历输出结果
5 O4 p# {% p$ A5 ~2 }        for (Integer integer : tempList) {
            System.out.print(integer+" ");
        }
  f  Z" J. u8 C0 f4 s2 o% n

4 E+ ~) T+ x) ]+ Q' I8 S6 j        System.out.println();
4 ?0 C1 ]7 P) R

        //测试冒泡排序
3 u) m' e0 @  [( m2 e8 N) B        System.out.println("测试冒泡排序:");
( N. j: L( p" K6 [  G7 T( @% \; S        temparr = nums.clone();


2 v5 Y" Q# {) z; m! i        BubbleSort.bubbleSort(temparr);
+ H  h0 T) F6 R4 m3 M
5 m! `  R  \$ d% N
$ F6 B  Y: j- s6 D3 Q        //降序
        //BubbleSort.bubbleSort(temparr,false);


% ~* Q6 n7 Q, E1 \, Z9 b2 A        for (int i = 0; i < temparr.length; i++) {
5 ~2 d+ M7 [9 S6 c            System.out.print(temparr + " ");
        }
7 a6 y3 ~0 `7 ^. K: K        System.out.println();
! ^* m2 |4 t7 k  q
& V* D# {- K2 H$ C- ]
        //测试快速排序
        System.out.println("测试快速排序:");
        temparr = nums.clone();
        QuickSort.quickSort(temparr);
        //QuickSort.quickSort(temparr,false);
        for (int i = 0; i < temparr.length; i++) {
            System.out.print(temparr + " ");
- p" h' o& }% }$ R. A        }
( E/ }# G, x3 L+ i, [3 J        System.out.println();


        //测试直接选择排序
        System.out.println("测试直接选择排序:");
        temparr = nums.clone();
7 M( p  e/ Z0 C8 w2 N        SelectSort.selectSort(temparr);
% D) x5 ^. b- ~: w4 k9 L$ ^        //SelectSort.selectSort(temparr,false);
        for (int i = 0; i < temparr.length; i++) {
            System.out.print(temparr + " ");
/ ^6 b. G/ r% h        }
6 E1 y+ {" r: G& g, z) e, {/ g        System.out.println();


        //测试堆排序
        System.out.println("测试堆排序:");
5 O, e2 y5 k) J. O        temparr = nums.clone();
        HeapSort.heapSort(temparr);
+ Y8 o- p- d5 Y+ q        //HeapSort.heapSort(temparr,false);
        for (int i = 0; i < temparr.length; i++) {
            System.out.print(temparr + " ");
; j: p/ t5 ^9 r        }
- z. p) P: m) q% |; h        System.out.println();
5 n/ _. |7 J* b6 L* q/ w

        //测试归并排序
        System.out.println("测试归并排序:");
  n4 G$ A" ?# o3 X2 q  F        temparr = nums.clone();
6 ^9 K; I) Z4 {        MergeSort.mergeSort(temparr);
" g) L7 h" L3 V; [        //MergeSort.mergeSort(temparr,false);
. D5 l! k2 a5 B1 e        for (int i = 0; i < temparr.length; i++) {
& b& X( s) s$ ?9 E- a            System.out.print(temparr + " ");
        }
        System.out.println();

  ?; E2 q% `2 y6 c, c( ?3 {7 j
* j* [. C1 c3 p; x$ F        //测试插入排序
        System.out.println("测试插入排序:");
  y7 V- j- y% d9 I! {0 |6 Y        temparr = nums.clone();
        StraghtInsertSort.straghtInsertSort(temparr);
        //StraghtInsertSort.straghtInsertSort(temparr,false);
4 _! z% P' ]" _# ?        for (int i = 0; i < temparr.length; i++) {
            System.out.print(temparr + " ");
        }
2 T1 K) O0 H( k. k        System.out.println();



& A: t6 f1 X. R8 h9 V
1 v+ e0 |: U* C2 K6 g, F# ^, M        //测试希尔排序
        System.out.println("测试希尔排序:");
. l, J) |3 D2 b0 F7 O7 G        temparr = nums.clone();
        ShellSort.shellSort(temparr);
4 k9 X) b! b! n, n/ J* A5 {        //ShellSort.shellSort(temparr,false);
  E2 T& _. |7 w, i( t: T        for (int i = 0; i < temparr.length; i++) {
            System.out.print(temparr + " ");
        }
* n3 J& w" [  E! _( O+ f        System.out.println();




        //测试计数排序
; d  `% o7 A% h3 V. s        System.out.println("测试计数排序:");
        temparr = nums.clone();
/ E# Z8 B& W: y/ m        CountSort.countSort(temparr);
        //CountSort.countSort(temparr,false);
8 d7 O% ~; I: t7 _) `        for (int i = 0; i < temparr.length; i++) {
            System.out.print(temparr + " ");
( l# @8 {% X* \2 k/ b2 E% N        }
, J1 M; R; c& G, t        System.out.println();

7 Y9 d+ e9 e) T# f
' J# y$ O$ T2 p* G

  [. s) U5 F' h        //测试桶排序
7 j: ?2 ?% O0 o* G, S  X' ^) ?( L        System.out.println("测试桶排序:");
        temparr = nums.clone();
! }9 H9 A( t. \& |4 K+ O3 ?        BucketSort.bucketSort(temparr);
1 ]; N0 o' p- p- n' @# p# Y9 [* N        //BucketSort.bucketSort(temparr,false);
        for (int i = 0; i < temparr.length; i++) {
            System.out.print(temparr + " ");
        }
        System.out.println();

7 T" L2 q) ^# O8 x. C9 K' I% i
        //测试基数排序
) m! b- ]$ f, R, {: r2 ~        System.out.println("测试基数排序:");
        temparr = nums.clone();
        RadixSort.radixSort(temparr);
$ z5 [8 r+ z& d8 u7 ~7 H# B        //RadixSort.radixSort(temparr,false);
; ], n* X. y$ k* I* q& C7 \6 O        for (int i = 0; i < temparr.length; i++) {
            System.out.print(temparr + " ");
0 ^' \( p; L: c3 G% [! ~        }
        System.out.println();


+ F( z8 ]0 ]$ u! `: K/ t3 d; o) J    }

- z* i2 B1 b# V. m
}
1
2
3
4
5
, |; h( K0 z" `" t8 a& m6
. x" V+ `3 x8 |/ _7
8
$ s# ]/ ]# Z+ p" ]) u8 X5 t; f' }9
10
$ N: r; \6 @- p2 o11
12
13
9 u5 j9 T) Q7 L& e, R3 r14
15
9 U6 S9 g% @. O+ H3 b  H  y16
, Z2 l. r! p/ E7 P' e- F17
7 W/ U0 X% \3 _5 f4 d$ H- t: e1 T18
2 \7 ?- t7 r3 P$ @19
20
  @3 I& z6 h) l$ x3 ?! F% T( }21
22
7 S5 q* c) E7 d5 U) z' C5 K23
! e* X( K: N5 ^24
25
26
7 _; n+ S9 _- p% I& n1 A) i. J% [$ M) B27
28
( G) F+ s* b9 L: {' a! C% q29
: c. L) @6 E6 T" b1 ?! c30
31
32
33
34
35
) Z" E+ E) v. ~) q+ V3 H1 f. y7 o36
$ b4 ]+ P3 N1 W% N$ F+ [: Z9 R37
38
" u; V2 O- z8 V- V0 F/ z39
2 W, ~8 N, H. ^5 ]40
41
7 e% p5 u6 T5 k, r6 v8 _42
& T" L1 G9 n+ o4 t43
44
3 m5 L8 T  c' e+ i45
46
47
48
1 b2 ?7 M9 |/ ]* O' t) n49
50
, E; J% I* a: U# H' }1 ~- i' \5 m2 p51
52
53
2 \6 W( c6 w, z' X, g54
3 T6 j& N8 N" ]- k$ P! \& e% E55
56
57
58
59
1 s; B" |# o+ G) I5 C60
61
! D3 b" o1 }$ p4 E1 Q62
63
  \6 P1 t3 G) N9 d64
65
66
# o  D& U( U' z- h  q/ d67
9 P4 f1 O1 B( y0 |. r, U68
69
70
" T+ e9 }. }$ }, s% Z0 E# ?71
72
3 M/ N3 l! A# s) i+ ~  Q73
; f4 G8 I& m( R* {: C74
, i4 M8 N( U& m2 {+ u5 G75
2 y/ }4 b, s! q7 r- ]7 w76
77
78
79
80
" }7 P" Y# \# L81
7 [. N8 I- }( D, A* q+ m82
83
84
85
/ i% v, e$ w& ~2 p7 V, B$ \" {: x/ ^86
) o' R" k- }+ _1 W0 B! u87
88
8 q0 D+ U8 D+ c89
90
+ s) C& b+ y! ~7 Z4 E6 p+ h! |# {9 o3 N91
92
" O4 Z; Q7 y1 T  L; q% y$ o93
94
95
" g1 S- G/ ~& Q8 D# E2 D2 ~6 r96
97
98
99
100
101
2 g( ~: p5 q+ R/ [* e0 P102
103
5 |6 d  e4 \1 q1 d) D: W* Q% `$ O104
* h; ?7 Q3 I7 n0 s105
106
% ~& k- N0 `% C9 k- f+ b$ h. R107
4 r" Z4 D; g( T% U: \1 p3 Y  F" \108
6 [5 Z; U! [2 u6 @2 u! w109
110
$ D4 S& `( _/ H* k$ V111
) p2 i' Y1 S$ P7 U& z112
113
114
% |) J' X* Y* ]/ x115
) Z7 j/ }' Z0 Q) Y3 s- S" @116
9 r! `' t+ b7 n; C117
118
119
# n6 e9 S! H4 I# Z+ k) e7 X$ A120
- E' a- t' s) a2 [% }2 C4 D121
( w# o: D& K% P6 d$ Q2 Y  B* d122
123
& Z" n( u* o0 q- T: Y124
( ?4 F, T2 ?9 e. C' j125
/ ~# W$ B1 Y, o) i: `' v6 |" A126
% C% H9 v1 c$ Y" ]$ ~8 n. T6 @127
' A, M: b$ ?/ i2 J128
6 ]1 m: ^* x8 [, c129
130
3 |( J. T" b) l: f131
- E' K7 h. I. X! `; {/ a132
/ m$ r! V1 r& r4 X133
134
135
136
137
138
8 t6 c8 }2 ^. H* m' I/ [139
" G, F& @$ {7 k: X140
% b. i/ v" X8 ~9 c- V) D141
" ]; l) B) q; S142
143
144
145
) c2 t# X$ A, d1 B146
7 n* y# @$ S  B, R8 A. a4 x6 g* r147
148
' ]3 A* O6 i) a1 B  g149
150
151
152
153
# b) \9 U6 L: J$ y' \154
3 _5 F; y5 X* O8 t155
156
157
: b7 R3 ?  Q# Z1 X2 i158
159
160
161
162
163
$ x7 l. G6 q* X9 b, |- f  i: f; l164
165
166
167
( M! [; G! J1 a168
169
170
171
172
173
每天进步一点点！
不进则退！


版权声明：
/ C# w. F/ G1 Y4 H3 _原创博主：牛哄哄的柯南
/ i9 g; W! M) P8 i博主原文链接：https://keafmd.blog.csdn.net/
+ ^  X. {# |& n8 S) D————————————————
' V# Y' `& g) `9 V8 M版权声明：本文为CSDN博主「牛哄哄的柯南」的原创文章，遵循CC 4.0 BY-SA版权协议，转载请附上原文出处链接及本声明。
原文链接：https://blog.csdn.net/weixin_43883917/article/details/118193663


% x% ?: Q7 s* r* x  L

---

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

---

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

Powered by Discuz! X2.5