数学建模社区-数学中国

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

---

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

% ]' [7 p: H! b+ S经典十大排序算法（含升序降序，基数排序含负数排序）【Java版完整代码】【建议收藏系列】
0 r& ?8 l% L9 i. R% p2 n经典十大排序算法【Java版完整代码】
写在前面的话
十大排序算法对比
冒泡排序
$ Z  y( q) x1 N, u2 ?0 I快速排序
% Q% {+ |" h5 F: D3 F直接选择排序
堆排序
归并排序
插入排序
$ }2 S, R$ i  w2 h希尔排序
计数排序
+ [8 j9 b" r5 J5 @桶排序
% S8 |3 M% `8 ]: L7 i基数排序
+ p. V9 C1 _$ e/ R" c! @完整测试类
写在前面的话
       虽然已经有很多人总结过这十大排序算法，优秀的文章也不少，但是Java完整版的好像不多，还存在某些文章代码存在错误的情况，同时也为了自己练手，决定把所有的写一遍巩固下，同时也真诚的希望阅读到这篇文章的小伙伴们可以自己去从头敲一遍，不要粘贴复制！希望我的文章对你有所帮助，每天进步一点点！！！


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

, P& @+ Z! O0 `/ G& D十大排序算法对比
  S, j! N4 [- H: Z) W) D$ J
( Q( }4 F) M' h0 Q; N
# J4 u9 X/ y+ i/ y

3 W& T$ @& @. }/ u. b7 a关于最后一列的稳定性，我稍微解释下，例如对序列：1 2 4 2 6 排序，序列中存在两个2，如果我们把这两个2标记上（让他俩不同），排序之后，前面的2还在前面，那么就称这种排序是稳定的，反之不稳定。
  J0 w2 E0 C' H
; g1 H4 `; d+ j  a
冒泡排序
简单解释：
( W. h2 S7 u  V/ R; }# F- y       原理就如算法名字一样，就像水中的气泡一样，每次我都把最大的或最小的放到最后面，这样总共需要n-1趟即可完成排序，这就是第一层循环，第二次循环就是遍历未被固定的那些数（理解成数组左边的数，因为每层循环都会把最大或最小的数升到最右边固定起来，下次就不遍历这些数了），两层循环遍历结束后，所有的数就排好序了。
       两层循环所以冒泡排序算法的时间复杂度是O(n 2 n^{2}n
" \$ f6 W7 Y+ k1 c7 ~& r2
)，是一个非常高的时间复杂度，我在下面的代码进行了优化，加了一个标志位，如果上一次循环未发生交换，就说明已经是有序的了，就不继续下去了，反之继续进行下一轮。


' N  I$ b( |: _


1 `% c8 I& K& x) f# p! F( r, x2 o
本文的图片来源网络，仅用于大家学习，侵权联系删除！（下同）
% v" E) [  R: S& x7 `, v+ d

% }* B; w3 m, x完整代码：

+ o/ D! o, `. q: N/ u6 N0 V
package com.keafmd.Sequence;
/ F  l9 h0 Q+ t6 y3 |: }

3 ?% L& W5 g3 N" R- ]4 P. A/**
% V1 [9 {( J9 I * Keafmd
*
* @ClassName: BubbleSort
* @Description: 冒泡排序
" T" _  V* R% U! S$ g! e * @author: 牛哄哄的柯南
* @date: 2021-06-24 10:31
*/
# d' d4 {& ]7 [7 N2 Ipublic class BubbleSort {
' ^3 a3 Y8 J' w8 _

! x0 o( n& Y- s4 F8 f$ B  h; F    //冒泡排序
$ X* X5 P2 P# R& m& S    public static void bubbleSort(int[] arr, boolean ascending) { //exchange标志表示为升序排序还是降序排序

" g. Q, |$ z% d) ]8 I. t
        boolean flag = true; //加一个标志位，记录上一次是否发生了交换，如果是，我们则进行下一轮，如果没有，说明已经冒泡好了


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

: n6 I* F: m) f
            /*System.out.print("第"+i+"次遍历：");
. c; f: {" \% o$ K! U4 L" V$ T            for (int i1 : arr) {
                System.out.print(i1+" ");
( Z+ q' H+ r/ j/ n% E            }
            System.out.println();*/
; `/ n1 f# p5 {0 D2 X' Z
% y9 {3 p$ T" W5 g& i: ~
            flag = false; //假定未交换
; K6 u; l& K9 C4 X' j3 k8 T

: r- Y1 w/ g& d2 z& O6 A            for (int j = 0; j < arr.length - i; j++) {


" k. ?& W9 P  {) n* B, @                if (ascending ? arr[j] > arr[j + 1] : arr[j] < arr[j + 1]) { //控制升序还是降序
- w+ P: }4 n& B4 b                    int temp = arr[j];
! u4 G/ }/ O0 K# \8 r* n                    arr[j] = arr[j + 1];
; s. f5 J3 ?3 o' z2 g$ T# K                    arr[j + 1] = temp;
                    flag = true;
                }
. v/ q1 g4 f6 d  T5 c
8 T3 H% O2 F8 r- O% X0 A' Q
2 U8 u5 e% H( W2 E/ x' }7 m- {' i            }
        }
  N& a, M! Z7 |7 s1 p    }
, `! J, q! @/ e5 L' [
( _) V' P5 X1 V" D6 |2 M
) e7 f: c  q2 g+ O0 G: [8 k    //冒泡排序 -- 默认不传参升序
( o) B- K6 V8 k1 B2 |$ G% n    public static void bubbleSort(int[] arr) {
' b' J3 h5 R0 e  A; j: Z        bubbleSort(arr, true);
4 N4 L1 \2 Z/ L+ D! Q( _    }
}
1
2
: A8 c8 c4 M# x9 P$ U, {3
4
, A+ e  d/ G' S1 X, c5
6
7
8
9
/ b3 X$ J4 P. Q: q10
* F( ~" B2 R" @: a' ?& @11
4 d* Q- }! k9 s" ^/ ~0 v5 c4 d8 }5 @& K/ Q5 h12
0 F' }9 c5 }/ d+ E; ~! _13
14
15
+ U0 P/ t! Q6 X7 d0 r16
17
18
19
20
' r3 m' m( g7 T$ e4 K3 l; N21
22
23
24
' g5 {! ?8 h* t5 J* G  X25
% ~  ?/ C  f' W; L" Y26
4 @/ l9 G! X) E+ z27
28
29
/ _3 v- \) N) C, x1 g' l% z: _* S& p30
31
32
33
34
  P) e+ c: Z- f' Z35
! J/ s$ ~. }$ c, J4 `; B* C" x/ n0 H36
3 P5 k. [  E) ]& p3 P6 {4 S& j37
1 |0 q( @/ U; v- m5 @* n38
39
40
6 D/ b  S& ^# H6 J- a9 B/ d41
42
7 c4 `& L0 @  P- Z43
44
5 H2 ?! u# ]- J1 g, t45
' w; B* [% R2 C  U% ~" {测试代码：
2 d9 X9 _2 _; ~& Y
) V2 X" o" C. O2 ]4 j/ `/ @
2 C% [0 {( |  [2 v8 `: v升序排序（从小到大）

3 C" n( C; z7 U
1 Q" R- \  a9 i5 M% F  z: |( \package com.keafmd.Sequence;


import java.util.*;
, u$ H6 G2 J+ aimport java.util.stream.IntStream;
import java.util.stream.Stream;

+ F* S+ w( m3 ~: }9 f% `) a7 U
/**
* g, d. |' K$ J8 \- a5 _* N * Keafmd
*
* @ClassName: Sort
9 Q/ h# A& J& r& ]& |* A- m * @Description: 十大排序算法
* @author: 牛哄哄的柯南
9 K8 S* X" H' V: p  N; ` * @date: 2021-06-16 21:27
' E( }4 N2 [5 T1 q0 B */
) X1 ]2 P' J% d# ?. p( ]* Ypublic class Sort {
    public static void main(String[] args) {

6 z5 T7 @* K7 c* K
' V/ n! m4 |) i# R: `5 o        int[] nums = {12, 4, 25, 47, 58, 34, 25, 9, 99, 26, 1, -13, 162, 10093, -66, -1};
        int[] temparr;


/ Z$ S3 v& I( w- Z' ~        //测试冒泡排序
        System.out.println("测试冒泡排序:");
        temparr = nums.clone();
        BubbleSort.bubbleSort(temparr);
9 M  f: W- J7 A; w5 Y0 ]% ?        //逆序排序
( R7 p1 }; L2 O, W        //BubbleSort.bubbleSort(temparr,false);
! o3 K+ u) y# ]" X3 G1 D4 q& `        for (int i = 0; i < temparr.length; i++) {
# y- F+ E1 ]: F( J  }7 g            System.out.print(temparr + " ");
+ q0 y, L2 Z, t4 ~) c: f        }
% x' q# d9 |1 i4 A4 U0 ~4 y: X. I% W        System.out.println();

. M9 D+ N% O0 P
    }
}
1
3 v$ F4 w) E, y' u2
3
4
5
6
; w9 ^6 z( p, q9 g0 c& ]: W, f7 V7
& j, u  C/ S# J  {1 q7 b; L: m( T" j8
- m$ f4 Z' t* v* R$ K3 f2 y9
10
11
8 ]" q7 o, w7 F2 l- }- A12
13
: ]4 Q9 w- g4 l9 `- F% N14
! W9 E1 }$ L1 \! s2 R15
16
3 s+ W: y( j7 k8 H5 w# \17
" f' m7 `& X% R9 s18
19
# m7 h( y! C# S0 w' \4 [20
21
22
23
24
8 e: a* b2 ~! {) _25
0 m; U# F! }' Y9 h! J, O7 X26
27
28
29
30
31
3 S0 H3 T! o' E3 W' I; M2 o32
) V; A# U1 [, x  }; z5 b+ ^/ A33
* F& A( G4 `/ A3 ]2 T9 U运行结果：

3 O7 g) T7 T; N
测试冒泡排序:
8 S3 A9 s  j- o# q3 }. {6 A9 {5 t( e-66 -13 -1 1 4 9 12 25 25 26 34 47 58 99 162 10093
4 T2 @( J) J3 W1 t# f* ~1
4 H# A$ r- q- U2
降序排序（从大到小）
6 G5 p1 w8 T# Q% }( ^% C
. d# L" d0 i3 x2 d6 Z
//测试冒泡排序
System.out.println("测试冒泡排序:");
$ y4 T2 ]8 W* ttemparr = nums.clone();
" I: q6 t* |2 _BubbleSort.bubbleSort(temparr,false);
for (int i = 0; i < temparr.length; i++) {
. r9 `) V5 G1 |" S/ U* l  f7 B) R    System.out.print(temparr + " ");
}
! X# x. @& k" [9 DSystem.out.println();
/ q! b+ L2 N" P! X1 l1
2 [3 I8 S0 _" m/ R$ P2
. J0 x+ J# V: D+ u9 L0 V3
4
! }- A, r8 M: l% L0 P- x) y8 V2 j9 Q( j5
6
7
8
运行结果：
3 k% P* ~: G8 Q6 E
  \7 ^. l( v. F3 H8 W
测试冒泡排序:
10093 162 99 58 47 34 26 25 25 12 9 4 1 -1 -13 -66
# B1 a1 H+ c* @1 D1
2
* g  |' @3 U9 s4 i5 Y下面几个算法的测试也就是换了下类名和方法名（换成相应的排序算法），如果想降序就在数组后面传个false即可。我就不一一复制了，我在最下面给出含所有算法的测试类，需要的自取即可。

' k, q% o; O6 E, |2 e4 t% J
- j5 A; i, @4 c; J( p2 j, w& k! h  L快速排序
简单解释：
快速排序就是每次找一个基点（第一个元素），然后两个哨兵，一个从最前面往后走，一个从最后面往前面走，如果后面那个哨兵找到了一个比基点大的数停下来，前面那个哨兵找到比基点大的数停下来，然后交换两个哨兵找到的数，如果找不到最后两个哨兵就会碰到一起就结束，最后交换基点和哨兵相遇的地方的元素，然后就将一个序列分为比基点小的一部分和比基点大的一部分，然后递归左半部分和右半部分，最后的结果就是有序的了。
' ?; x& K0 N1 p! i2 o) O
9 M# q+ R. l2 d& Z2 D" B
2 x* ?7 ]& \+ _% }  V
% B& s* p3 W: z. U. P6 ]


/ m5 S' J8 m! H' ]7 q$ Z6 X+ L4 \. ]完整代码：

, B+ k; A; X: Y6 R3 Y1 C+ r
7 s& l4 m+ x9 l! @4 ^  F9 z/ a7 ]package com.keafmd.Sequence;
1 x9 X# Z3 a0 N9 z  W

/**
* Keafmd
*
0 }) G, i% F$ `3 \5 Q  |2 F2 m * @ClassName: QuickSort
: y5 L9 ^5 ]6 z& H2 M; b- p% y * @Description: 快速排序
* @author: 牛哄哄的柯南
* @date: 2021-06-24 10:32
*/
9 Y7 z; a, d3 spublic class QuickSort {

7 ^1 Q* k" Q' P. M" L
    //快速排序
% f% o4 o( f: }    public static void quickSort(int[] arr) {
; D! r! p% b& |, w        quickSort(arr, true);
* I7 G+ i. i! j. w% G% D0 H    }
% T+ x( M" ?2 x+ A' E+ }+ j- I9 e
- K+ L7 \2 F, F- r% U4 d
    public static void quickSort(int[] arr, boolean ascending) {
        if (ascending) {
            quickSort(arr, 0, arr.length - 1, true);
        } else {
7 g3 Y6 x( J& y  I* C/ V0 e* U6 C            quickSort(arr, 0, arr.length - 1, false);
        }
& E8 }2 P' p( Z' u    }


    public static void quickSort(int[] arr, int begin, int end, boolean ascending) {
0 G$ l% m/ Z4 l; M6 g' [        if (ascending)
: X, ~/ {8 H/ q! U4 B% B) A* t/ J            quickSort(arr, begin, end);
+ R# G# m) F. n/ ^! H/ J( ~        else
            quickSortDescending(arr, begin, end);
    }


    //快排序升序 -- 默认
    public static void quickSort(int[] arr, int begin, int end) {
. Y$ E  g2 m* m; p- m3 y  D        if (begin > end) { //结束条件
            return;
        }
        int base = arr[begin];
, w9 N) p6 }' \/ N8 U' @) S$ E        int i = begin, j = end;
        while (i < j) { // 两个哨兵（i左边，j右边）没有相遇
            while (arr[j] >= base && i < j) { //哨兵j没找到比base小的
                j--;
            }
            while (arr <= base && i < j) { //哨兵i没找到比base大的
                i++;
            }
1 |6 G& l- d+ `1 D) P            if (i < j) { //如果满足条件则交换
                int temp = arr;
                arr = arr[j];
  ?7 y3 ~7 M, y: @+ {  ^                arr[j] = temp;
            }

" W; J( [% ]" W& D2 B
        }
; D- _) N( G4 Y, Y9 [! X" G0 I        //最后将基准为与i和j相等位置的数字交换
        arr[begin] = arr;
* O, b: H2 ]! ?- l        arr = base;
        quickSort(arr, begin, i - 1); //递归调用左半数组
        quickSort(arr, i + 1, end); //递归调用右半数组

" y0 M! P$ R# M! E9 @
    }
7 G( I6 Y& m3 @  H2 @& y
, L: M0 A! G0 A7 s5 ]/ S" e
+ t1 ]( M1 ?' R/ h6 V8 O    //快排序降序
/ G7 l) P5 m! ]; U8 x    public static void quickSortDescending(int[] arr, int begin, int end) {
        if (begin > end) { //结束条件
            return;
        }
        int base = arr[begin];
        int i = begin, j = end;
        while (i < j) { // 两个哨兵（i左边，j右边）没有相遇
            while (arr[j] <= base && i < j) { //哨兵j没找到比base大的
                j--;
            }
            while (arr >= base && i < j) { //哨兵i没找到比base小的
* t& N% Q; ~0 s- X/ G' d2 o                i++;
* y% w! G7 V  C- e, ]            }
8 B( u) D5 t& f5 B6 r2 C            if (i < j) { //如果满足条件则交换
) v& h* e' w2 s% d& q. q5 H: \                int temp = arr;
                arr = arr[j];
: L9 V" O' _$ J" ~) ~                arr[j] = temp;
/ U- s, J( N4 s; D0 a            }
5 u1 c8 Q! z  ~
4 ~6 p( s6 f, \. D
8 a) E+ B8 Y: y# p1 U7 f        }
: `, b& p* J! k. p3 y3 |- `        //最后将基准为与i和j相等位置的数字交换
  ]; }, U: S, g/ v2 ?% _        arr[begin] = arr;
# [2 p/ |, }! ^$ w        arr = base;
        quickSortDescending(arr, begin, i - 1); //递归调用左半数组
! B; P  m& e; M2 K9 l6 K/ W$ o7 t        quickSortDescending(arr, i + 1, end); //递归调用右半数组


    }
; ~- W* }! g4 j
( B; M) O, w1 p: _0 b5 i7 [
}
1
2
3
4
6 S; b, ?  L. z: W& e+ Z! T5
6
7
8
0 q- v( C# F2 l6 k9
10
4 q% V. y, i% E" X11
12
6 A# @& Y( _- C' O: B' o13
$ r# r0 f# v8 a% M5 A! `14
15
" I/ y  M- }4 I1 W2 f  U! v16
17
9 F3 N( q2 d$ Q1 E, q# _18
19
20
21
22
8 r7 e; c, S4 q1 h0 O; J8 S$ k23
24
) ~4 G9 n2 q2 }0 p3 d7 G3 w, k, f25
26
27
8 o5 U! U9 t* Y* E9 K; h28
! X/ Q4 [6 g; l29
3 H6 t% A  e& o8 W3 i( j30
4 g) v0 }8 H( `5 h. ?31
, @" h  t$ y  t3 F32
33
( w3 t  y* a: }7 z0 y6 ?4 U# V34
35
! u7 _7 E1 h6 j# p36
# U0 A9 U& Q- E1 }; F37
. Z! D4 z5 D2 J5 b) B; P38
9 E; }. `( t5 ^7 q& G6 u39
40
, Z" v$ @' d8 L41
! r9 O- O" c# y$ p( \3 r4 e* S9 n7 T42
. A  Q; Q& j. v* t7 W3 g43
44
45
46
47
1 |' o, w6 `% h% P' n$ A- i48
% v; w7 S2 l. e3 |1 }% i( d49
9 @" [* r9 d3 ?50
51
" ]! \/ u) A( K+ d  _" q52
53
0 Q2 y8 t" ?1 S% V, i" R+ j  L54
55
56
! v( }9 z0 T4 ~/ S: d; v, j! P57
% n/ o9 M6 }7 P4 h5 \58
59
/ M6 \; G0 b+ f; F: A60
61
62
63
3 N7 X' W3 k' g' m6 @9 k; D! K! @64
65
1 H. O. C4 p; H66
! m/ q# k& }3 `! s( J5 F9 P+ H/ ^67
68
69
70
71
& c$ i9 Z/ I/ O  t; f72
73
74
$ q# X- j% R: M% |7 S, K  o% I75
/ z" f4 P, r7 u* b  g$ k/ `, S76
8 ?, e# j3 c5 W77
78
79
# J# Q1 o4 [3 F# f9 I  w4 a80
81
5 w1 ]9 v& _0 b. p" F82
83
84
85
3 c2 W7 P! E- k86
+ J0 p% `5 S+ g' }0 Z# h  [87
+ f, ^# P; H  R; o0 H' W88
, s6 K) y2 }- `89
90
91
# g/ J. W1 W0 D7 ?  [7 G- W& r直接选择排序
" j& a! n9 a, l简单解释：
% N5 X" I2 a- ~2 w2 P  m) J' [数组分为已排序部分（前面）和待排序序列（后面）
第一次肯定所有的数都是待排序的
0 a* o+ d" |# G" k+ ~3 s- g从待排序的序列中找到最大或最小的那个元素，放到前面的已排序部分，然后一直找，不断缩小待排序的范围，直到所有的数都是已排序的了
/ c& |6 c' L; a9 q, v/ t

$ w8 ~5 r* ^$ n4 V- a1 Q


! h( F- U! F; x# a2 I% Y5 d  a
完整代码：
( s& z- S" m6 h2 H

package com.keafmd.Sequence;

0 i( b6 `9 c# R+ t
5 d& G- m0 U2 I$ n/**
* Keafmd
* y% D/ d; e% [! ]/ T8 L *
, {% @3 U3 G  u0 @* I * @ClassName: SelectSort
* @Description: 选择排序
* @author: 牛哄哄的柯南
7 t. P; T* V4 i1 I: Q6 X* V+ _ * @date: 2021-06-24 10:33
*/
public class SelectSort {
9 R- h; V$ |0 R8 v7 B- Y
: @# c  X; o, v; L8 {9 L
    //直接选择排序
" o( b# M% n9 @7 ~! @, T    public static void selectSort(int[] arr, boolean ascending) {
        for (int i = 0; i < arr.length; i++) {
. [6 P3 P' W  a$ m0 V% J- ^! Y4 x, u            int m = i; //最小值或最小值的下标
            for (int j = i + 1; j < arr.length; j++) {
+ D7 e( K' T% @                if (ascending ? arr[j] < arr[m] : arr[j] > arr[m]) {
                    m = j; //找到待排序的数中最小或最大的那个数，记录下标
/ r, {+ j' ]/ P9 n                }
  x+ W# d) i$ T

) c- \+ `) k7 Y7 t9 p; L: H            }
, a6 a6 o, }( @$ M            //交换位置
            int temp = arr;
; W7 r/ P' o! f' k! d            arr = arr[m];
            arr[m] = temp;

. `% R; T) ?) D
        }
9 D- S4 [8 |. ~3 _! `    }


    public static void selectSort(int[] arr) {
8 X1 N" ~- e0 w- N& {2 T; V        selectSort(arr, true);
    }
" B/ e  J. {8 `8 ]* r0 p0 L3 Z3 i}
* W2 O( W7 D# r/ o$ b% c! w1
; Z( |% M: W" D  K8 Y1 {( @2
0 i3 s& X- q- [3
4
- D; [! l9 L( r5
6
& d/ c2 ~5 ~4 N- J: ^$ O$ B( U7
; m, G- H& u* j8
9
10
11
12
- S' t* O* H1 F  G5 e- ~13
14
* K! X. l( u0 i% N% f) p: ?15
16
* }6 V( a& r' i17
& I5 u# \+ g3 K  b- u& J18
/ h2 R, R( s5 ?; N2 D( n- E19
* g) R! E/ i* e: Y2 v20
+ o0 c9 [9 v% z6 i5 @' T6 }3 M/ d) ~21
22
23
# u2 e( q4 E$ _/ m" D, g8 h. [24
/ {, q; a0 _8 H% {0 h: \/ O+ g25
26
& V4 n/ p9 o  ?6 u7 Z" H27
, _; g+ f1 R, y. F4 Q28
. N- E, R  t6 ]; O, l/ K7 J6 v29
2 z) X) @% e5 e  C  _3 a30
7 q8 m) B$ a% N. d! z0 k31
8 G' l. z  W) T, s4 f$ t32
! W  f# s& s2 O& B# q! X' ~9 _33
34
堆排序
1 N, H& ^2 c' ?先理解下大顶堆和小顶堆，看图
大顶堆，双亲结点的值比每一个孩子结点的值都要大。根结点值最大
小顶堆，双亲结点的值比每一个孩子结点的值都要小。根结点值最小
# `# y7 d+ |6 _& w( u! o- P; [
6 W0 m8 W' t0 J0 ]0 T5 }5 A9 l
  _# n3 q+ y; _
3 H) T8 D! ?+ d# h4 C
简单解释：
# U! w. O% K) h2 T6 p. u/ q8 I) A构建好大顶堆或小顶堆结构，这样最上面的就是最大值或最小值，那么我们取出堆顶元素，然后重新构建结构，一直取，一直重新构建，那么最后达到排序的效果了。



$ W/ h+ ~* f  D4 {6 p# b1 ~7 P& Q

# G3 r. c+ L9 q5 x. g+ d: G1 v7 N0 g
1 n" R0 I9 H4 k  o; {完整代码：
3 C1 ~, d2 T5 l% b" }' u
3 G& c  z' B; r8 Y) m$ p. ^- {
  y. Z1 t- g8 e6 R$ Cpackage com.keafmd.Sequence;
6 |& e& c  a" I) \

/**
2 _2 ~& F* @4 Z4 U$ G. I * Keafmd
*
3 c6 Z* V; g# N! |: ~  ` * @ClassName: HeapSort
+ H2 `8 l0 H( z( a% n  Y * @Description: 堆排序
* @author: 牛哄哄的柯南
* @date: 2021-06-24 10:34
*/
public class HeapSort {
/ ]4 q3 U! ~. O8 ]7 m

, T  u1 O  ^8 \' W( W& N6 o    //堆排序
    public static void heapSort(int[] arr) {
- X( `) ^2 E2 {" I, \        //对传入的数组进行建立堆，这里默认建立大顶堆，进行升序排列
        heapSort(arr, true);
- n" {! s8 V6 y/ o6 k! t. N    }
3 k/ b2 w1 h' ~) d  A/ \

( c1 k) D* F2 q. I; C: \    public static void heapSort(int[] arr, boolean maxheap) {
* P: W) f2 q8 Z$ ?& g0 `* O6 h

        //1.构建大顶堆
- E, u: S! s0 B& `        for (int i = arr.length / 2 - 1; i >= 0; i--) {
            //从第一个非叶子结点从下至上，从右至左调整结构
            sift(arr, i, arr.length , maxheap);
        }

8 S3 l" O- h# H/ ?- t% X, ^3 ]
        //2.调整堆结构+交换堆顶元素与末尾元素
        for (int j = arr.length - 1; j > 0; j--) {

/ Y3 m! ?5 d& h
- l- o  j' ^0 c% l' z0 I            //现在的数组第一个就是根结点，最小值所在，进行交换，把它放到最右边
            int temp = arr[j];
            arr[j] = arr[0];
            arr[0] = temp;

. C, u& E, y9 r2 x
" A2 {7 i1 x: e% s% X2 U* O( H            //重新建立堆
7 S# j  }) ]7 a6 b# O5 }0 D# M            sift(arr, 0, j , maxheap); //重新对堆进行调整
0 g2 K$ @* b% @  `/ ^5 l9 }/ x        }
    }

% I: S  t7 k5 q& K) \4 q
1 u1 A- N3 G4 a& d    //建立堆的方法
8 O2 S; Y4 M$ d    /**
+ u8 d( b/ m, L) G$ ~4 O  X' v     * 私有方法，只允许被堆排序调用
     *
     * @param arr     要排序数组
! J* u. y2 v0 f# U# O     * @param parent  当前的双亲节点
     * @param len     数组长度
. k  ]& D) P2 t) c" ]% m! Q     * @param maxheap 是否建立大顶堆
     */
    private static void sift(int[] arr, int parent, int len, boolean maxheap) {


        int value = arr[parent]; //先取出当前元素i
  D5 I3 O  V# l9 r
; |. x) `5 h$ t( L
        for (int child = 2 * parent + 1; child < len; child = child * 2 + 1) { //从parent结点的左子结点开始，也就是2*parent+1处开始
8 ^' c+ B  L" ]

2 ^5 Z3 j4 P  S3 k7 A7 L! G            if (child+1 < len && (maxheap ? arr[child] < arr[child + 1] : arr[child] > arr[child + 1])) { //如果左子结点小于右子结点，child指向右子结点
* J7 z' M+ X$ N4 N5 X9 x( R                child++; //右孩子如果比左孩子大，我们就将现在的孩子换到右孩子
9 Z0 Q1 }  P; B8 A/ l; u/ S/ R% C            }
% L% s3 }; \! ]* f
# J# U2 G: h' w
( y# k2 v6 Y# L. H) S. a7 @            //判断是否符合大顶堆的特性， 如果右孩子大于双亲，自然左孩子也大于双亲，符合
, F+ ]. ?6 l/ m3 L  n& t. a6 w            //如果子节点大于父节点，将子节点值赋给父节点（不用进行交换)
            if (maxheap ? value < arr[child] : value > arr[child]) {
+ q- v. F; |2 S9 W                arr[parent]=arr[child];
                parent = child;
: d' [, Z( v. t+ L+ P            }
            else {//如果不是，说明已经符合我们的要求了。
                break;
$ X6 y9 S% A, H  o$ I  a4 n            }
# R2 E, g* Q* r! W        }
) s- j# K- |$ t        arr[parent] =value; //将value值放到最终的位置


6 J! G/ y! N* P) v0 R
5 Y4 h8 h, b8 ]
    }
1 C7 b, q2 J( I( b' D! W2 m

$ z3 c1 L/ f7 T- m- J0 }0 Z& q}
1
- Y6 K7 l1 ]; v8 H; X( N$ j2
, O* x% a, ]5 ]9 B6 h3
4
7 V3 ]6 r  P+ ~, m3 A2 C9 P5
6
5 _4 ?( W# }& y, q7
" K+ j# N0 `9 b2 S( \8 m8
4 U5 Z5 u- {- i$ s9 \9
7 k3 P% t# G6 b  p4 I10
11
12
# \- i4 ^% A( }13
14
15
16
1 v* g; M5 C& s! d17
- w/ O& Q8 D5 I18
& N: @# D& F4 y% ?8 o19
20
& O& k# b8 ^. h) Y! @; }21
) `6 G) k$ w3 ~  o- [# O; d22
23
24
4 H) c8 [2 e" s0 K25
' z- N6 o+ k* T26
5 b& G8 Q8 s+ j; v# |27
28
' a4 I/ c! {5 d% R3 @29
* \! W4 X# v1 {+ X, H9 S30
% T. }" j, ]( g3 J31
. {0 f! \9 B1 ?- L: S* E& @& C8 |32
33
  r9 F! ~6 b9 B' q4 M1 A  w34
35
36
37
38
/ ]( f4 n2 l7 c. ]' Q) g  `39
40
41
42
43
44
45
46
4 a" x4 }) j, p; [1 M47
0 E& V- p! p8 q48
49
3 `# d- u: Z. ~5 @- g: y. a50
51
52
2 G$ n' |6 {/ {* T3 F* R: l) M! a53
9 ?8 V( b% \- {" ^' Z. g) U54
2 k6 b* q. Z8 ?! X0 Y" l8 l+ w2 e) G55
. N7 W/ j3 z: d) R/ u56
57
* ~$ u3 n* t4 a- {' Q58
4 U3 B: W8 B3 C) b) j, `. M59
60
61
62
" a2 j* @4 q1 H( L1 n- M7 h63
64
, k% v' w/ J: n  Y/ J: t9 F65
66
67
6 ^7 \3 C* l* {68
  t; z+ e; G3 X8 p! ^69
: b" e: _1 R, t9 F6 K70
/ I" e" u' Y! ?' O9 i71
; y: K4 y" ~  G/ `' g% ^72
% L( s1 K( m6 G# d& Z73
# i; ^4 h8 {( i2 a* W8 Y# S5 s74
归并排序
简单解释：
6 ?8 Z! [* `* N' _1 I5 ^' F5 I; I" B该算法是采用分治法，把数组不断分割，直至成为单个元素，然后比较再合并（合并的过程就是两部分分别从头开始比较，取出最小或最大元素的放到新的区域内，继续取两部分中最大或最小的元素，直到这两部分合并完，最后所有的都合并完，最后形成完整的有序序列）


8 _+ c9 U( R/ e! L% e2 d/ q
, `! Z2 y* T- p8 U" W. a

0 @' H4 N; z- _0 o+ R8 h9 N. j
完整代码：

; H2 V+ `4 p1 Q5 Z1 T  Y0 _
package com.keafmd.Sequence;
0 z$ h3 r- D" z8 U2 H
7 O; D, O' m8 S) R( a+ R1 Z. N" ^
/**
% Y7 D' w& O7 e+ s( ] * Keafmd
*
9 U- B/ T9 G5 k * @ClassName: MergeSort
* @Description: 归并排序
* @author: 牛哄哄的柯南
" I% `' M' L! b& t * @date: 2021-06-24 10:35
: i( c, U. b8 V- g7 V */
public class MergeSort {

& m, ?. f. J" d% w4 J
8 h- E5 y3 o* U* U1 C4 {    //归并排序
3 {5 o- ]3 [' W3 f% f% {4 S    public static void mergeSort(int []arr ,boolean ascending){
3 ^3 Z* K. O- ~- K- p        int[] temp = new int[arr.length]; //在排序前，先建好一个长度等于原数组长度的临时数组，避免递归中频繁开辟空间
        mergeSort(arr,0,arr.length-1,temp,ascending);
: G! }+ t5 J4 \. l    }
    public static void mergeSort(int []arr){
        mergeSort(arr,true);
    }
2 s) b' \* ?3 |! |0 q/ S  I

    /**
     *
     * @param arr 传入的数组
6 S" S9 I3 C& N( M# V     * @param left 当前子数组的起始下标
     * @param right 当前子数组的结束下标
3 a* r7 D" T7 T$ R2 b; l) m, i     * @param temp 拷贝暂存数组
' d% W, W& [& [# x9 i     */
    public static void mergeSort(int []arr,int left,int right,int[] temp,boolean ascending){
9 e6 v% N0 u& d8 ~+ T0 b' ]        if(left<right){ //这里是递归结束的条件，我们是对半分，那当left==right的时候肯定大家都是只有一个元素了。

! `! c8 t( s2 ~5 |: g% D/ L" H2 L+ U
$ Y4 j8 `# _/ f7 E  ~            //对半分，比如总长度是10，left=0，right=9，mid=4确实是中间分了，0~4，5~9
- V2 j! S# T8 }+ h  _( b            //当长度9，left=0，right=8，mid=4，0~4，5~8
            int mid = left + (right-left)/2; // 防止越界的写法
            //int mid = (left+right)/2;

; Y& l6 Y4 V% J) Q
            mergeSort(arr,left,mid,temp,ascending); //左边归并排序，使得左子序列有序
) s; T3 ~# y+ k4 F4 O; @$ p            mergeSort(arr,mid+1,right,temp,ascending); //右边归并排序，使得右子序列有序
6 H% B* t5 t+ D/ J/ f, M! Y) `
- P" i( \! }: M. r
            merge(arr,left,mid,right,temp,ascending); //将两个有序子数组合并操作
        }
    }
, i; |$ i: j, O* t" I7 a
' ]0 b. u6 P- Z' N
3 @- N( A# Y5 I' @6 T/ ]! _6 d: E    private static void merge(int[] arr,int left,int mid,int right,int[] temp,boolean ascending){
, e( t" O1 W- S4 u        int i = left; //左序列起始下标
( t/ O+ d8 q( m. w8 U% R        int j = mid+1; //右序列起始下标
: p! s0 r! z0 x% h  Y- y# w        int t = 0; //临时数组指针
        while(i<=mid&&j<=right){
& Q: l, ^2 h1 o$ V8 b9 s            if(ascending?arr<arr[j]:arr>arr[j]){ //比较两个序列第一个元素谁小，谁小先拷贝谁到temp，然后对应子序列下标加1
! Q; E) l: e1 V& d) D                temp[t++] = arr[i++];
2 K2 O5 U. p# O0 ^% E3 r5 I- M            }else {
' ]- W, e/ c) Z* N& O- g( x- K                temp[t++] = arr[j++];
            }
6 _0 H) V, A+ v# `* @, D        }
4 U/ o4 @  x1 o4 L
& P) B9 W( c: d+ `* e
  {. D9 V7 r7 _9 k        while(i<=mid){ //将左边剩余元素填充进temp中——左序列有一些数总是比右边的大的数
' j9 K' @6 {. d+ u            temp[t++] = arr[i++];
$ b4 Y9 p& ]& W* z1 V& D        }

, a5 e0 G0 t' x% K$ I/ ^
& `4 W- H; b  X! |- {! `3 s        while(j<=right){ //将右序列剩余元素填充进temp中——右序列有一些数总是比左边的大的数
  k) s. q! u) ~            temp[t++] = arr[j++];
        }

- m/ P( U# I# x7 v
) \% y, \. G: `        t = 0;
- I/ K& P. z, c6 ^- e3 v% n
6 I4 Y; h4 V' p6 {+ p2 n
        //将temp中的元素全部拷贝到原数组中
        while(left<=right){
            arr[left++] = temp[t++];
  x* ?, m( u- h" x* h$ q' R! ^        }

0 O/ R$ o2 c) I8 {& @1 v" [8 h, M
# y: G' L1 a7 z$ z    }


3 h+ v! S6 z7 A}
4 z/ `8 Y: n3 t- L3 [4 ]1
2
7 O( z9 i! M8 L3 a( X+ t* M! |3
3 x* D( x# I. i, r6 I3 G4
5 b# |' \0 D/ \+ B/ m5
6
7
) n7 G0 r1 X- F8
9
10
7 `7 E8 T2 a3 \$ ], F* H2 D11
12
; O, d5 e: x' [, Q" P- R13
14
15
5 H, e3 \2 @, s& K6 F16
17
/ m: M( U' f, E2 A* h6 B6 r2 \18
19
' K7 e' h+ Y9 k$ ]# g20
% f+ |/ w7 s1 z: P( W21
22
23
4 d- Y1 \$ E4 w* [- t: a4 t, @24
/ t# l* a- ^6 t8 L25
26
27
# H+ S8 U$ d4 [5 O; v& j28
29
+ O9 S6 Z  z0 \5 I' [+ E30
; X: Z) Q& S/ q31
: o5 O& v) r' T9 K) u- @32
33
1 @/ R" F' O1 F, Z9 H  x34
35
36
37
  l: b$ }" V, S0 u38
39
40
2 g. w7 T& B9 Q# ~41
9 P3 F7 `  `+ h42
43
44
45
; f9 `1 _' S# f( H46
) r7 ~; h! [2 @7 I) s# E0 r47
  H: H% D+ j+ d( U( d48
49
50
51
# d: S. J5 M& E: v. P# K52
* y! E6 E; l* j+ |& m% K53
! ?% Z$ F# w- h7 ^! f' k54
/ Y4 B" ]2 Y' u$ ^1 ?55
2 @4 P0 E/ w. G- m( F. a+ G56
, `& q; g5 Y5 d; V3 R57
58
59
7 I0 ^3 b; a8 w5 S60
# i+ I4 S8 r' ]61
62
9 F( G6 o, w1 c/ k: j63
6 S# S# P" p6 M2 R9 r6 Q  W64
7 E( ]" V1 T& Y4 f& Z! |  q/ O65
) L8 A2 E. |% K  A66
' n* x; L" q5 h0 f* N67
, ~8 S  t/ y/ P! m' p# D0 K2 N68
69
70
71
72
0 H1 Q/ b+ z% V6 V/ l% |73
插入排序
简单解释：
3 }* j9 W1 O6 K$ L最简单的理解就是打地主时我们拿到牌后的整理过程，从第二个牌（假设我们拿起来这个牌开始比较）开始，（说下升序）从后往前比较如果比前面的那个牌小，就把牌往后移动，直到找到一个合适的位置（这个位置的前面的那个牌不比这个要放下的牌大）就把这个牌放到这个位置，慢慢的前面的部分变得有序，直至全部有序即可。
! ?7 O. u/ }" q3 D


+ [3 C7 u4 e# w! D2 F+ _

3 t& c' }2 D+ q4 g" L) g- [& k8 ~
完整代码：
( H/ [  i' [! }4 f, G( D* _9 V$ Z
9 Z% w0 _1 W% [, Z+ Q
package com.keafmd.Sequence;
+ |% E3 n' J( ]# x
$ R6 ~$ `. e* ], R9 o+ w
  q" k0 d2 ?- s* o" d. f. t/**
  P) T2 {+ a) L; r8 P+ e8 w * Keafmd
*
7 e% v0 K6 a1 r- i+ @$ h * @ClassName: StraghtInsertSort
6 h4 |5 p& c! n * @Description: 插入排序
$ c* w! @! n- }' _8 [ * @author: 牛哄哄的柯南
9 u& J! i, {8 q, j# j; { * @date: 2021-06-24 10:36
& `2 e, O  ?4 p. m4 { */
' h) V: N' o( Z. {" ]- X) Opublic class StraghtInsertSort {
) l4 ]9 ?+ Z, L/ v" i    //插入排序
: R  [7 D. a* a: B# H. \/ z2 R" L    public static void straghtInsertSort(int[] arr) {
        straghtInsertSort(arr, true);//默认进行升序
    }
" H3 o5 [$ r6 Z
5 {( M3 W/ k5 V0 X
    public static void straghtInsertSort(int[] arr, boolean ascending) {
/ k$ O/ F2 k: q; E2 F
( e; O1 j" I5 F3 `
        for (int i = 1; i < arr.length; i++) {
2 G: m$ Z/ c# C. y) `! u            int temp = arr;
            int j=0; //这就是那个合适的位置
            for (j = i - 1; j >= 0 && (ascending ? temp < arr[j] : temp > arr[j]); j--) {
                arr[j + 1] = arr[j];
            }
            //把牌放下，为啥是j+1，
% a! p0 d2 F# Z  A            //是因为上面的循环遍历到不符合情况的时候 j是合适的位置的前面的那个数的位置
/ Q& k+ b( R3 l; x            //有点拗口，但是就是这个意思，看图方便理解下
2 E4 `) k7 N3 L' h4 d. b' z            arr[j + 1] = temp;
# V! g. Y3 T0 {# {. o
# K, T$ M  _/ O3 a/ C
3 k7 {) n/ n+ E: z3 L& H$ n: h$ ?5 I7 t
) v* C; J2 f0 f! a  G# t% X5 c/ X' F
        }
/ W* v5 w- b  a: E
9 e. ~& ^# Q9 Y' G1 l/ m& L
    }
}
1
, v, q& ]+ Q/ \$ n6 D! G2
3
4
4 U) i0 i: |2 ^, P5
6 n7 A' b8 ?, e# }6
7
9 G) t1 e/ S! u) ^8
- D4 b: y! g3 e4 ~3 v9
10
: a* _% V6 l6 V! w( W3 \0 x9 d11
12
) ]$ J9 G7 C- u9 N13
" [! \7 p: O8 F9 U) `& `5 E14
15
/ K$ L$ i1 {. N16
17
2 f0 g( F1 H6 o4 a( f& P18
19
20
1 n3 D9 H7 w  h9 H6 s21
, Q6 ~7 p! e1 Z- e( [22
23
24
25
26
27
. L: ]7 C6 T1 w' h1 E3 i7 Z3 @28
29
* Z8 a$ W# [) r& j; G30
0 i( R: r0 z  V4 j( S* K) E31
32
6 A. w+ U! V3 X1 t33
34
( C4 Z/ x+ u* B/ ]希尔排序
简单解释：
; B7 w* @, f! H! y1 |! T: f* F希尔排序是插入排序的改进版，我们理解一个叫做下标差的的东西，也就是下面那个图中的增量d，初始下标差为arr.length/2，然后继续/2，对在同一下标差（相当于把这几个数单独拿出来了）的若干个数进行插入排序即可。


4 g' j- H% G8 u0 N' r
! m* ?9 b( L/ U3 x
7 K2 _# X8 F( b" x- w( M

完整代码：
! ?3 q/ D( b( e
3 [7 z0 S- s4 |9 |) V
package com.keafmd.Sequence;

/ h; r" Q0 Q+ {% D- H- U( W, K
/**
* Keafmd
*
* @ClassName: ShellSort
* @Description: 希尔排序
6 G) D3 h: E0 o1 r$ f) v4 l * @author: 牛哄哄的柯南
+ v/ f' ~% A% o* D * @date: 2021-06-24 10:39
8 [: E9 {9 L% k7 v( H% S7 T) }$ j9 N */
/ V, F1 {" g/ \# J  ypublic class ShellSort {
' q: i; a$ {% |4 M! m! M1 E

    public static void shellSort(int[] arr) {
        shellSort(arr,true);
" n; A4 i; ?/ N2 u    }
) R2 g" l5 X0 S9 Z* s
5 _" f# L9 |5 \% _) [. a7 {( ?$ A4 u
6 Y; f& Z- X) S. t0 X    public static void shellSort(int[] arr,boolean ascending) {
; s! `) N0 Y9 [1 M7 n# B

0 r. }* G5 B2 e  M! r: o% S1 i" v        for(int d = arr.length/2;d>0;d/=2){
' N) H; O( S7 |' C# P( l. G
/ E$ u8 t( R& H8 e3 f8 x
            for(int i=d;i< arr.length;i++){
! R1 `, v7 p5 D) {                int temp = arr;
0 H6 }, q& S. @- u' z! Y                int j=0;
                for(j=i-d;j>=0&&(ascending?temp<arr[j]:temp>arr[j]);j-=d){
& h7 L: c& j  p8 s+ D* I                    arr[j+d]=arr[j];
$ r& D* P# J0 B0 F0 m                }
) N" ^# m0 ]" s0 f                arr[j+d] = temp;
4 K0 O7 f: u; h( u            }
        }

- r, _. V' o' X7 D
3 e4 ~! \- p8 o" J% f    }
5 N7 b2 N) v# M( |0 S; {. a4 b}
1
% }. I( H/ u. T/ b9 W2
* r) ~. h' d8 X) R9 E, v3
9 {* O' l+ H) n. Y4
4 _) k1 W* W1 U( T* r5
. k0 y# J( b  q" z6
% k3 c5 @& D7 F( V% [6 l7
4 ?; y) w& Z7 t9 e7 O7 B# W" e1 }" e8
7 p9 O! ]  Z; j- r' n0 M# ?8 C' L9
, N8 l- F) {  x! r  c5 s10
11
12
13
" o' g' a& d) F5 c) v' d: L14
) {" w* Z' C1 |15
16
  T0 C: N& a; e3 R3 _17
3 W  c) u* l2 l# p18
3 m* _8 j1 [; X/ H- z; Q8 M+ d19
( K; b6 ~3 `0 w. X3 z2 z5 {20
( l& K) u1 U  O21
# f' M0 @# x& v6 |9 w22
3 m; @; j) l0 I3 `8 C2 A( Q' ?23
! @5 q4 u9 g: V1 b" `24
# d, C9 c$ d: j* E, D0 j25
26
6 d# s, O" r. e! W9 G5 q2 A3 E& x27
) v/ N* W+ v% O1 b28
29
. `0 T5 @3 H+ J; @+ c3 L# s30
31
- `; r8 b  B! D, i3 A- V4 v32
计数排序
' |7 }) J6 L& h* B4 @简单解释：
这个排序算法看名字也很好理解，就是就是额外找个数组来计数，然后在这个数组从小到大或从大到小把数取出来即可。
  d; a8 g* {! G2 X

4 |: {8 ^& _5 V  ?2 o; e, k7 d9 c- i
; Y: S* o2 x' T

: W5 ]7 N& v/ ]0 A' L
" A0 k6 V' }/ x- y( i完整代码：


% v) ]9 J; d% S! X7 F4 spackage com.keafmd.Sequence;


. w  e# `) V( ]2 I) C: w/**
* Keafmd
*
* @ClassName: CountSort
* @Description: 计数排序
- n1 i' e# f: c, F# T. Y  b * @author: 牛哄哄的柯南
$ _% R: B8 ]5 D1 q7 d9 e' f * @date: 2021-06-24 11:31
*/
; y  n0 M2 N6 }. c( D1 ypublic class CountSort {
* Z' [5 k. ]8 b' v" L8 U% C
, g/ j& p) C% ]( T3 f
    public static void countSort(int[]arr){
        countSort(arr,true);
5 g; Y8 Z9 M, k7 o8 ~& n    }
5 @! g7 f' U/ ]; r7 {5 o3 Z

    public static void countSort(int[]arr,boolean ascending){
) v5 a  d7 I( j- j# E" k& F) t( z        int d,min=arr[0],max=arr[0];

3 b# B2 ~0 t7 P# v7 Y
        //找出最大、最小值
        for(int i=0;i< arr.length;i++){
            if(arr<min){
* {% K8 c* p7 W) e1 s6 G/ z                min =arr;
            }
# z; ~; m+ F  w3 j1 a            if(arr>max){
7 L. D+ @8 \- {! j                max = arr;
" v$ W7 \1 H' h1 X" P* M6 d            }
        }

  f; a0 t' E% N) `/ g8 u
6 y+ \" k) R; {- e2 Q3 ]) q        //建立一个用于计数的数组
        d = min;
        int[] count_map = new int[max-min+1];
$ p$ [5 g4 R8 T3 j# b6 w        for(int i=0;i< arr.length;i++){
            count_map[arr-d]++;
        }

6 {' P. O# o( p) ]' A
        int k =0;
        if(ascending){
3 n7 m5 Q7 C, q9 V3 c7 w            for(int i=0;i< arr.length;){
                if(count_map[k]>0){
                    arr = k+d;
                    i++;
                    count_map[k]--;
  _7 |- R; h4 C0 ]1 P1 q$ C                }else
7 k5 |- d! ?: J: q; ~% O                    k++;
( s: t. A9 A3 C+ u  O6 N( R, E            }
1 H; d  A9 y% E        }else {
            for(int i=arr.length-1;i>=0;){
- a/ K# ^( A" T                if(count_map[k]>0){
" }% C5 h8 b$ o& q7 X9 m+ b                    arr = k+d;
2 c+ V( L3 {; ~; ^6 }! V4 L                    i--;
                    count_map[k]--;
' b) v* O' q# D- i$ Q, ^( _% ~+ l( e                }else
+ Y8 E6 T% O& x% S                    k++;
            }
$ y# A0 }6 T8 Y7 y4 ?% w        }


. Z& k9 O- h7 O# C. [' J" k    }
9 P. w/ A' o1 ]" T6 R( p}
. n0 c4 A% B  A0 \6 ?, l  v* p1
! y$ p4 |# }# i; x9 J2
3
& \. m5 w7 y% ~* I: l8 v4
" F1 k+ ~& Y$ {( m5
6
! J, \3 \& n( j& u$ r7
4 O7 W- R$ h5 S5 f+ |. X1 I5 `. o& x8
2 o( a4 c8 P5 }1 b  m% q0 U9
5 X! R; F9 t' ]8 p! _1 Z1 ~10
3 ^$ n/ k. v8 D8 D# }( h+ J11
12
13
' b4 \6 c) t% Z# `14
15
16
17
18
19
20
21
22
23
( C3 F+ b, a  d: |4 s24
25
7 u7 K; W" R/ H" q/ f7 O26
  S2 i" F. U! H# a27
28
29
30
2 ?+ c" i; Q- P) H7 a2 i31
32
" d( @9 g  R2 A5 @! L$ ]# N7 M7 t3 }33
34
35
; z6 H) j; S! Y! U$ X* ?36
37
! R4 ~) }: o4 S38
39
40
5 E( W7 H" K* U( L" z8 s41
42
43
9 M3 ?6 k6 I( `3 ^44
45
6 H( k4 v  E) \0 P! }9 }46
5 P7 ?2 [2 j, h; f47
48
3 [. j9 D3 o0 r  o$ j8 i49
50
3 o1 y  [# t3 w& F7 L* W51
52
53
7 c/ T8 G6 j# U9 x0 |, q54
55
+ D* Q+ x: z1 q& m3 ]/ P% P56
3 j! A5 q9 _* m2 s8 O9 H) f" P1 j57
0 ^% A; }2 y# j58
7 ?, U. z* U9 y4 L& t59
7 V" o& g+ B+ M* C桶排序
- u) Q& ~% P5 W- @- F1 [7 c7 ~5 ?简单解释：
就是把一个数组分成几个桶（其实是几个区间，从小到大或从大到小的几个区间）装，然后让每个桶（区间）有序，然后取出来放一起就可以了，相当于把几个有序的段拿出来放一起，自然还是有序的，当然需要是按照区间的顺序拿了。
$ B# I& D0 ^, e' A" m/ l( ]
% W( y' D8 d+ b$ r* Q1 T( V


) f' t# O/ Z' n7 H
6 A* |' A& J& \. Y
# G5 C: ?3 y- B: ]; Y5 a完整代码：


package com.keafmd.Sequence;


$ h1 @8 x" p5 v; t5 aimport java.util.ArrayList;
import java.util.Collections;


4 L5 Y* l3 R5 h" C. i4 T/**
0 h* P! q% F& O# I7 |& z8 C * Keafmd
*
* @ClassName: BucketSort
$ O7 N, m0 j6 l$ `+ g * @Description: 桶排序
* @author: 牛哄哄的柯南
8 Y5 ?. [8 k9 m% o. ` * @date: 2021-06-24 13:32
*/
public class BucketSort {
) P' c0 H: {5 `& R" h# ~

; i4 }8 b; M' F5 r  A    public static void bucketSort(int[] arr){
* ]% x0 I9 g- \/ }        bucketSort(arr,true);
    }
4 z. u- K' |  o& \; W' {6 ]
7 G  C/ `  j- P! ?# v1 J1 W! N7 h
    public static void bucketSort(int[] arr,boolean ascending){
4 t0 W2 B, K) L2 h# l        if(arr==null||arr.length==0){
! c+ o- _$ w3 T$ @# k            return;
1 X; R" ~8 }+ E" B        }
* X  a8 x7 e& u9 ]        //计算最大值与最小值
9 J$ N' F- [+ A6 K9 |        int max = Integer.MIN_VALUE;
        int min = Integer.MAX_VALUE;
% i2 z( Y0 R% H) ?  L5 u, j8 T        for(int i=0;i<arr.length;i++){
            max = Math.max(arr,max);
            min = Math.min(arr,min);
        }
; {# Z& P7 x- _7 S  o, R

8 X- Y8 f  w. W5 R6 U        //计算桶的数量
" t% u  j+ d$ ?4 U        int bucketNUm = (max-min)/ arr.length+1;
        ArrayList<ArrayList<Integer>> bucketArr = new ArrayList<>(bucketNUm);
        for(int i=0;i<bucketNUm;i++){
            bucketArr.add(new ArrayList<>());
' [+ G, K% v) {        }
* a5 a* A, L! r$ |

. q! ?) I7 }( g        //将每个元素放入桶中
, C* R' ?9 n5 o* b% k        for(int i=0;i<arr.length;i++){
- o  O2 ~$ @1 m5 X4 r            int num = (arr-min)/ (arr.length);
            bucketArr.get(num).add(arr);
        }

, `/ T5 A! ~  k8 o& S1 {) S
4 C& }( V7 |0 N        //对每个桶进行排序
" y- {4 m5 A* z0 h: m3 w        for (int i = 0; i < bucketArr.size(); i++) {
            //用系统的排序，速度肯定没话说
: ~( `) g% j! _* y5 E6 L            Collections.sort(bucketArr.get(i));
3 N( h/ I2 [% |" U& K        }

, u. ^9 M. G" q; w
        //将桶中元素赋值到原序列
  K; \3 z6 M9 y) H, L, d4 \0 o5 t( r8 n' A        int index;
        if(ascending){
            index=0;
        }else{
            index=arr.length-1;
$ Q/ e$ Y) U6 z1 U8 d& @        }
# L" e  o* L  T3 d6 ~7 j5 ?

        for(int i=0;i<bucketArr.size();i++){
            for(int j= 0;j<bucketArr.get(i).size();j++){
                arr[index] = bucketArr.get(i).get(j);
! j) g# k; @/ ?                if(ascending){
                    index++;
                }else{
                    index--;
                }
7 A' \* Q. s6 f) {+ w            }
5 O7 H1 D. e+ F! R* X% U

: A- F: y( ]$ V/ n        }
2 Q) O* y# h; [$ d* j- B$ x

! n$ R+ q5 n4 d1 y" X: Q    }
3 T- D1 R: b7 M0 u}
1
7 o4 P( [$ P& ]( ?  a; ^3 V2 f2
3
4
5
6
7
8
9
- G( R) r3 M5 V  n2 z" f4 ]5 B10
11
& u8 T4 C. C& D% m12
13
14
/ s) P3 _) w8 m; y5 o5 Y15
16
17
3 N/ F3 C" g% ]  {: w: y18
2 z' t3 G. E2 H; X* {* ~. {19
20
21
1 O8 v/ W- @6 ]# O# U22
23
* D8 H$ A/ \& L8 f0 Y24
25
26
; j3 f/ ~, g: z, v/ n) f27
28
( d1 W6 s6 Q6 w5 Q' M29
30
7 F9 a& @) b( b31
32
33
34
35
36
7 M/ l3 Y, j$ W: B) `- A7 ?37
38
39
" K! f7 o2 t/ N0 J# g% }/ k40
- l$ n6 X7 ?. J$ i, o41
* r3 U% }3 c+ d$ t. N$ K42
43
+ E# g" Y0 [7 t" g: v. X* ~5 a44
45
& k$ q- I0 ]+ @9 S46
  V6 ^  o/ f% K) x' K- s& k" d2 ^47
48
49
5 I. ^* X# V& e50
51
52
53
54
55
56
) t- d) G8 H8 p# M9 D) r57
58
59
6 W7 o' {) i; ^60
61
1 n3 L0 A) [0 k# F4 `& x- v0 n1 M62
63
64
* W6 K# m1 m6 ]! Q" z65
# N* B" T+ ]* ]5 |* C, _! u66
! I0 k; \  C8 X! p( i& D67
8 F& W. t6 E% P- \# s68
69
70
- \* }6 j5 I0 W% e5 a, r7 `71
& e) B& W- }9 F' n, b/ O72
基数排序
3 g( }/ q$ _+ ~4 z简单解释：
( `, D4 B5 M5 T/ k% ?0 W" T) Z首先说一下，我发现好多人写的基数排序只能排序正整数，其实只要处理下就可以排序含有负数的了，就是我们排序前先把所有的数整体变大（就是减上最小的负数，也就是加了），都变成正数，然后排序好之后，在减下来（加上最小的负数，也就减了）就好了。
基数排序就是按数位排序可分为LSD（从最低位[也就是个位]开始排序）和MSD（从最高位开始排序），下面写的事LSD基数排序。
+ r* F0 y4 _+ M/ @8 ]' n- K基数排序就是把数按位考虑，让后我们一位数只能是[0，9]，就是我们在考虑某位（个位、百位· · ·）的时候就只看这个位的数，放到在[0，9]相应的位置，然后顺序取出，最后再按其它位这样操作（上面说了要不从低位开始到高位，要不就是从高位到低位）

1 m: E4 u- M3 Y
  P2 C/ _# r3 a* }' [  i

9 }: w+ J- \% M" G; b7 r: I) J1 z6 A

9 V. d) Z; @; N) g5 b; y5 P完整代码：


package com.keafmd.Sequence;
$ T4 g& i7 }3 p* w- X

/**
* Keafmd
*
* @ClassName: RadixSort
* @Description: 基数排序
* @author: 牛哄哄的柯南
* @date: 2021-06-24 14:32
" Q3 `( W0 k: k */
public class RadixSort {
    public static void radixSort(int[] arr){
1 Y% }# I/ [& E6 |/ ?        radixSort(arr,true);
: m: y* L4 N" |+ k    }
    public static void radixSort(int[]arr,boolean ascending){
        int max = Integer.MIN_VALUE;
; R( g: L% d% Q' s( `        int min = Integer.MAX_VALUE;
3 O9 N( [5 C* C* f        //求出最大值、最小值
$ q$ S2 V" B. H' @# e. _        for (int i = 0; i < arr.length; i++) {
            max = Math.max(max, arr);
2 {0 |4 K9 B/ m+ U! c            min = Math.min(min, arr);
        }
        if (min<0) {        //如果最小值小于0，那么把每个数都减去最小值，这样可以保证最小的数是0
; f; |# ~4 i& g& r2 u            for (int i = 0; i < arr.length; i++) {
6 }% F6 t7 r5 y' D% u" |% }, F) \                arr -= min;
& L. Y  @4 ?1 z1 M/ j2 D            }
  t0 W) {3 Y# Q5 J' g            max -= min; //max也要处理！
2 [4 [+ n4 _' i+ v" V- F2 B        }
        //很巧妙求出最大的数有多少位
        int maxLength = (max+"").length();
/ z* j% ?% C$ G  ~# a+ M% S        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) { //个位 十位 百位 这样遍历
            for (int j = 0; j < arr.length ; j++) {
* }. Z3 _0 R5 \% t; l' U& X                int value = arr[j]/n % 10;
                bucket[value][bucketElementCount[value]] = arr[j];
                bucketElementCount[value]++;
' ^8 K' Q: i% W& r( A5 c2 l# P0 c; h            }
* f+ z6 @" j1 ~- @

            //升序
            if(ascending) {
                int index = 0;
, J. @; K$ j# l$ D! g. y; ~                //从左到右，从下到上取出每个数
1 [! m+ N" O# q                for (int j = 0; j < bucketElementCount.length; j++) {
5 P6 [% E' U5 Q                    if (bucketElementCount[j] != 0) {
( |: k* m: v  J1 ^# V5 y                        for (int k = 0; k < bucketElementCount[j]; k++) {
0 H) s$ a" Z0 z                            arr[index] = bucket[j][k];
                            index++;
                        }
, ~5 I% W  O' J. Q" i- D4 m                    }
2 W' D3 h" @( K( o                    bucketElementCount[j] = 0;
                }
  u1 ?7 i1 e3 P7 T( e0 R            }else { // 降序
                int index=0;
; `+ a, g1 x6 f; `                //从右到左，从下到上取出每个数
                for (int j = bucketElementCount.length-1; j >=0; j--) {
                    if (bucketElementCount[j] != 0) {
                        for (int k = 0; k <bucketElementCount[j]; k++) {
4 w) P* [! h9 }% v8 _8 N                            arr[index] = bucket[j][k];
                            index++;
                        }
                    }
- O, Z4 C; G9 B% s5 L/ D: Z                    bucketElementCount[j] = 0;
                }
            }



0 S" [0 F* @& t
            /*for (int i1 = 0; i1 < arr.length; i1++) {
2 ?1 I9 P* |4 l: q" @                System.out.print(arr[i1]+" ");
5 i$ ~3 `8 c8 e5 M: m8 `$ K            }
6 s0 H; W  n5 O+ R1 Q            System.out.println();*/

6 a  R# b( p8 |% }




! X, K7 g. t- a9 x/ c1 {4 Z: ]# f        }
        if (min<0){
7 k( y5 s5 P% h, u( t            for (int i = 0; i < arr.length ; i++) {
                arr += min;
            }
; _8 O! r" K" S2 V1 r# {9 E        }
3 ]. {- r, p& ^+ A
! i- Y- e8 E* x3 u$ [
    }
}
1
2
3
0 z# d, l/ r, ~$ E4
5
, L- Y! f2 L7 M. S# G: l! G6
: M" ~, J5 ~* k% J, T: X, S0 G- y7
8
# d2 C0 d: d' X* O2 F9
10
  D* L' L5 m0 ]: t+ y, c0 ~2 j11
12
( m- k5 Q, z$ m( o  w6 n13
- z* `8 }( l( W( Z5 C14
15
3 r7 r: D' n8 n+ P1 O8 V16
# B& F7 M7 K0 S& `0 V+ _17
18
19
, n1 ]% v9 b0 l* b7 u20
' P9 D$ y. ?7 O& `6 I5 V21
22
9 Y/ n9 S! N. @' j4 [23
24
- f$ }; e( ?/ _5 s25
* h1 B  E$ u0 ]8 j  Q. S% a26
9 @  F4 R  }/ G) m' v27
* m) a( z7 G9 v" B; I28
4 a) w6 R& G% w' D5 D  `/ p29
30
" R( s7 L% R5 t: i31
32
& v' J+ o3 i& m2 v0 y2 }33
  D- v$ f7 [0 e7 w34
35
- d( _3 w2 W1 M3 O1 b% x. w  W36
37
38
/ t9 K* ]0 M5 ?' `  \% P7 T, m39
40
41
' _$ J4 Q$ `7 \' R2 H42
0 w! X1 U# x2 z/ |) Y6 L43
44
45
* [$ {) _. c9 \0 h0 W8 r9 |8 z- {, L, G46
47
48
49
50
$ I3 Y' Q4 F( P% _$ z7 ]6 p51
52
& x3 N/ {9 [5 G, F; ?' ^53
54
9 M+ u1 ^  y, w2 E' E55
56
, ~4 _) Q' f9 Y: K+ T57
* z( c0 R, a# p  V7 p58
59
60
61
62
& H2 H: @3 V* l$ v) A& ^63
64
  o/ V& L4 k9 |' U1 L) O/ g65
66
$ B8 T5 b2 @% |( ]9 W' H) E/ a67
68
69
$ O/ z/ W1 U7 [/ f8 G4 G70
71
( s, _7 q5 q* O6 f8 l) A72
* x+ p. d/ Y6 z, g7 U73
74
75
. V% @& n7 y. y0 e  q1 q76
77
78
) |4 F# R7 i4 l; W3 |( ]8 R79
80
81
82
83
完整测试类
package com.keafmd.Sequence;
5 O" O; {: Z& C8 }# w
2 D( K$ H$ t: E# H, K
6 Y: ^1 z( [1 ?  z/ Eimport java.util.*;
import java.util.stream.IntStream;
import java.util.stream.Stream;
4 J' P3 m- \3 U0 V3 {' U% m
7 p0 Z" f" K$ s2 L
/**
+ \; g. o0 l+ P  W7 J1 w8 [5 ~9 _ * Keafmd
5 R& C  M* n) c) [/ M# D! e8 e6 r *
- w; D) v) {8 p: b1 C' t5 e * @ClassName: Sort
* @Description: 十大排序算法测试类
' a/ G+ C5 j7 X/ u5 D! a- _ * @author: 牛哄哄的柯南
* @date: 2021-06-16 21:27
*/
% A6 s0 z" B! C; M5 f* C6 n  dpublic class Sort {




    public static void main(String[] args) {


3 W+ p$ a! n# B5 R8 f* L/ Y. t1 ~        int[] nums = {12, 4, 25, 47, 58, 34, 25, 9, 99, 26, 1, -13, 162, 10093, -66, -1};
5 H. v' H7 K. K0 F$ C1 I5 G( s//        int[] nums = {12, 43,56,42,26,11};
/ K: B3 k) D3 M3 o        int[] temparr;
' Q, r/ D6 S  F4 y, Q

        //利用系统Collections.sort方法进行对比


        //将int数组转换为Integer数组
; I8 s4 S  ]1 E  z7 X; B& I+ t        //1、先将int数组转换为数值流
        temparr = nums.clone();
        IntStream stream = Arrays.stream(temparr);
  d: i3 e: V" ?7 v' u9 u9 P3 u        //2、流中的元素全部装箱，转换为流 ---->int转为Integer
        Stream<Integer> integerStream = stream.boxed();
        //3、将流转换为数组
4 B+ M; L4 x7 w9 O/ f& D+ z/ ~        Integer[] integers = integerStream.toArray(Integer[]::new);
        //把数组转为List
/ A  d" |9 b! j$ C' K        List<Integer> tempList = new ArrayList<>(Arrays.asList(integers));
        //使用Collections.sort()排序
        System.out.println("使用系统的Collections.sort()的对比:");
' x9 W# s4 d: a8 o0 ^* u

# P. z$ C* Q8 r+ ]" H. ~        //Collections.sort
        Collections.sort(tempList, new Comparator<Integer>() {
            @Override
, R$ n/ j: R- I1 H9 R0 r            public int compare(Integer o1, Integer o2) {
* L3 \" E: t3 ~                return o1-o2;
. ?9 n" L+ F( L1 |                //return o2-o1;
            }
' V. `" N% n9 v! c- n* V        });


" S, {. S, i( S' f        //tempList.sort 也可以排序
$ ~, ], Z% a0 Z       /* tempList.sort(new Comparator<Integer>() {
8 g4 W  {% S7 j6 X            @Override
6 n8 Y% v. y/ O: J            public int compare(Integer o1, Integer o2) {
                //return o1-o2;
                return o2-o1;
            }
+ U" s% S; t2 A0 b& i6 V        });*/

8 ^9 P0 T( k7 d
        //遍历输出结果
7 s4 X6 a) \. ~" o' C7 c# Z        for (Integer integer : tempList) {
9 B8 d% n' R+ g3 L# \! w7 G( o% Y" i3 N/ n# {            System.out.print(integer+" ");
        }
% q- ?( H+ n! C3 y' x
4 }( z4 L  d& s9 n8 O# u' n
        System.out.println();
; u  J! V# C! U; |5 C; g/ b& s: ]

& b- p. J8 U, f7 g5 R8 H# s* B        //测试冒泡排序
        System.out.println("测试冒泡排序:");
        temparr = nums.clone();


        BubbleSort.bubbleSort(temparr);


        //降序
        //BubbleSort.bubbleSort(temparr,false);

4 p7 \' y. P, c  e9 Y* x
5 I! c$ B5 B/ Q# G        for (int i = 0; i < temparr.length; i++) {
9 }! J; r0 @6 r! G            System.out.print(temparr + " ");
        }
7 l* o2 c# a5 G0 ~/ }2 L7 L        System.out.println();
  `7 d' W: E% E2 D

" Z4 u$ F. a5 t3 `        //测试快速排序
        System.out.println("测试快速排序:");
        temparr = nums.clone();
        QuickSort.quickSort(temparr);
) J  S6 {$ }! l. m- O% v; R        //QuickSort.quickSort(temparr,false);
        for (int i = 0; i < temparr.length; i++) {
2 l5 Q1 P' n2 M, P. @7 u            System.out.print(temparr + " ");
        }
* y' Q! Q* ]& _  d& Q+ ^6 T* C5 v) S        System.out.println();
5 Z& @, P: a  q1 _1 q3 G9 n/ t: X* M1 n
9 i/ |1 l1 q+ k5 S) Q% {
        //测试直接选择排序
        System.out.println("测试直接选择排序:");
& Z' ]* e9 @# e3 j3 Q        temparr = nums.clone();
2 w  I' A  S: N1 U  ?/ [& e        SelectSort.selectSort(temparr);
        //SelectSort.selectSort(temparr,false);
7 M8 l2 D3 q4 _( p  ^, ?' C        for (int i = 0; i < temparr.length; i++) {
            System.out.print(temparr + " ");
        }
        System.out.println();


        //测试堆排序
, H# P" V, J" t5 y! Y- O# l# [4 Z        System.out.println("测试堆排序:");
- y8 u5 l$ g- ]6 m        temparr = nums.clone();
        HeapSort.heapSort(temparr);
        //HeapSort.heapSort(temparr,false);
        for (int i = 0; i < temparr.length; i++) {
0 x8 ^6 ]/ W$ x; _            System.out.print(temparr + " ");
        }
        System.out.println();
" b9 d$ q1 V: @: g. O' M6 o4 K% r

        //测试归并排序
        System.out.println("测试归并排序:");
        temparr = nums.clone();
        MergeSort.mergeSort(temparr);
        //MergeSort.mergeSort(temparr,false);
        for (int i = 0; i < temparr.length; i++) {
& w- X( r% g; \2 O" L            System.out.print(temparr + " ");
+ _8 n9 N2 Z. u& f8 t, J# @        }
        System.out.println();

/ |' Y. J! W' V: W2 h
        //测试插入排序
        System.out.println("测试插入排序:");
        temparr = nums.clone();
2 r/ U# u9 @2 C5 ~  ^2 H" _, `  `/ m        StraghtInsertSort.straghtInsertSort(temparr);
        //StraghtInsertSort.straghtInsertSort(temparr,false);
        for (int i = 0; i < temparr.length; i++) {
  {) }7 S  u/ g- \5 U6 Z            System.out.print(temparr + " ");
        }
- H7 I2 I/ O7 P        System.out.println();


0 Y( z' h) _$ }4 _$ k9 B) `
8 j- K; z6 _, }! H1 `" E
% U8 |% y' @6 W) P- R        //测试希尔排序
. K  P8 S$ s1 G" L! e        System.out.println("测试希尔排序:");
        temparr = nums.clone();
        ShellSort.shellSort(temparr);
0 _1 {4 q4 V5 T+ P        //ShellSort.shellSort(temparr,false);
        for (int i = 0; i < temparr.length; i++) {
            System.out.print(temparr + " ");
        }
        System.out.println();
8 J) ^& f6 T/ k/ _' ]+ ]# ~
3 E; L+ R5 W9 E+ l0 k; W+ T! [

$ T$ Z7 Q/ I% j
! g8 e: ^" t: _% E, j  l; K        //测试计数排序
- h' ^$ O0 b, s        System.out.println("测试计数排序:");
, k) Q2 u) r, H        temparr = nums.clone();
5 K* v" C/ h1 y5 i" }: L4 z. Y9 w0 N6 U        CountSort.countSort(temparr);
        //CountSort.countSort(temparr,false);
        for (int i = 0; i < temparr.length; i++) {
8 Y) x3 Q3 P, F            System.out.print(temparr + " ");
7 l/ f& u9 J/ T& |$ V9 o3 ~- y0 O$ X        }
+ x+ T7 x' {  O1 M        System.out.println();
+ W% K, L% ~( |
+ @( |; A& X7 ~7 f- R  Y$ L$ I* u
4 W* Q) g* R! Z' j0 Y* M' Z

        //测试桶排序
        System.out.println("测试桶排序:");
* |5 r' N$ o% t  m$ d% N5 n        temparr = nums.clone();
        BucketSort.bucketSort(temparr);
: f* C1 w+ b: g' ~: h5 ]! C: K        //BucketSort.bucketSort(temparr,false);
4 |& \3 z( d6 Y( }        for (int i = 0; i < temparr.length; i++) {
& t+ q9 {/ q7 l3 `( q) }            System.out.print(temparr + " ");
        }
        System.out.println();

; M2 Y9 d3 ^$ _
        //测试基数排序
6 O- t6 Q9 [( L* \. y        System.out.println("测试基数排序:");
0 Q0 ]# N" W- G        temparr = nums.clone();
        RadixSort.radixSort(temparr);
, ~. f( N" J+ ~2 l7 _9 q3 L        //RadixSort.radixSort(temparr,false);
  F" `! Y  r* N        for (int i = 0; i < temparr.length; i++) {
0 m4 C! e+ I5 P+ N& P            System.out.print(temparr + " ");
        }
        System.out.println();


    }
) E0 I7 t9 b3 f
; R9 e9 T, N: a
! m1 U. a* O( }7 O}
4 M" W! }" s7 o# z  g& `3 ?1
2
0 i1 _! |" L" N( w3
4
7 x. Y+ z) W7 @) w; o5
  s3 G+ h- \/ U6
7
8
9
: _0 A; e* D5 s% {6 U/ }10
' h; B4 }) O) g2 `9 S+ R6 {6 v5 S11
12
13
14
15
! `" Y  }7 Z* a5 ]5 K6 H16
3 b: R- ]1 i2 f  u  Y17
5 }8 Y- v3 w6 L  L, X18
3 v8 o' z5 N; R( c* g7 ~19
: t) c8 F4 D  Y20
21
% E/ [3 c( s1 T2 O/ B% O2 ]22
7 Y7 H- I$ l" \# g% X23
24
25
  M. y3 i6 k. ^26
- `, {& H! f/ Y) ?* a% T' O27
4 u- V* x, O: }3 f28
+ [9 \7 p9 L/ G! D3 \29
30
. c) S+ k( [2 x8 N31
32
33
34
% f( h) Y- @6 W3 H9 r- x35
/ g5 b% w) D' w: ?% g/ p36
37
7 X* t* {5 b% _/ s! L: y9 l38
' |+ v! S- Y( p- `39
40
8 n5 W2 f, s1 y2 K$ ~( }) C" q  Q& I41
42
3 W1 o& Q( \( U3 A: [! T8 \# V43
/ h+ t: A; Z7 R7 |0 t44
1 B; a* d# [% x0 A; s) d45
46
47
% v9 Z+ \8 f4 Q1 l1 D48
49
50
51
. {& _8 K) B1 v7 E9 K6 b52
53
. ?$ V. [3 |  J" o6 ^0 F3 `# g54
( a2 @  t; t  Q3 M7 g& M7 v55
56
57
58
/ h- O" @, }9 K  X* [59
8 ]2 o: v, r3 [8 ?' A) Z60
5 B- o3 v; F0 ?4 P3 ]9 i9 @5 `61
62
63
! K7 J4 \, l8 n; S2 ?9 y64
3 y/ h' l* O8 y# A) d4 |- \65
66
' w) F1 K! C( y67
68
69
70
71
' |( ?* @  b1 I% U1 T, U9 v72
9 m% V" m6 X8 R  `* ?73
3 n+ ]& m" b( T3 j) p0 w3 P74
75
" J9 ^; {; D  k/ ^( E76
$ F7 k5 p+ q  g% R! b7 C+ E77
1 v! @' _- O5 i1 y6 X7 C78
79
80
81
; T, `' E& @' _+ \- _82
83
84
, C% ]; [+ C# A- b85
86
* l: `: l+ h% L$ i( c87
88
89
" v0 H, L; w: I* @  f: G8 B90
) {' ]+ M4 @8 h& ?$ L$ l91
92
93
94
5 ^7 y2 s7 d1 R& h' e5 q# W95
96
6 ^" U! b1 U1 q  ~' r97
98
99
3 c! s7 j# Y. f100
8 m7 r& l. a) p) H101
/ p) a8 G& ^4 v6 Z5 O5 M102
103
  K3 _7 p1 ?/ S- m8 }& @. k104
105
) M8 L9 @2 S; b106
107
6 R6 ~! _) S' a108
109
110
  F2 J; q' f8 q; ?$ n. L111
112
0 s) s* T0 I9 w% T5 I113
& K( M, I8 T: O" R$ l( t114
* U* ]# t" G1 l1 E3 B115
116
117
118
119
; d5 I1 {& a0 F" o  a120
121
) z1 _- {, E6 D) f: N0 a# J122
123
  F5 g: ~* p4 a124
' U. I4 q9 j, a4 ~1 [125
126
3 K; P, E' q$ F8 {$ n" d" Q127
128
. A3 l% I. w' @4 v, T129
130
: ]8 X' L4 d; i131
132
' W. Y2 F* |6 n1 h+ s' s133
$ g& g2 l6 j4 H2 O7 [! ?134
135
8 c1 l* }* s+ f" ]* _0 h136
137
: W% n' D/ g+ O1 v& f138
139
140
; p) e2 ]2 |: d" K7 g% D# X9 p0 T141
142
- J% Z4 R) \/ b% k2 M& l143
144
145
146
147
148
149
% U- y3 o+ C7 j3 y8 Z' U4 F: ]2 P150
151
- B9 q$ o" }! T! u3 D152
- p9 }3 a8 P* Q  P153
154
155
# B' V# n; J3 h* f7 K% {5 {, J156
157
158
159
160
161
162
2 o2 v% }. L0 p- d163
3 A/ |: _: S; N. v9 e  W# u164
: L( c  V# K6 x  D2 l165
166
' I& P1 T0 `% [4 r* x8 q167
168
- P+ `6 E7 k4 ^169
" Y( o4 G4 ?1 u, T# A" q2 y4 l- Q170
. x' U+ O6 g/ F1 s. \( C! N7 K171
2 m. @) B' I# v6 Z172
173
每天进步一点点！
( J5 C" e6 N6 [0 H不进则退！
8 V/ D" w: H) a% ^
# g& G1 u8 Y: [, O: s  Q
版权声明：
* F" H3 u1 A, S: z0 h原创博主：牛哄哄的柯南
博主原文链接：https://keafmd.blog.csdn.net/
————————————————
版权声明：本文为CSDN博主「牛哄哄的柯南」的原创文章，遵循CC 4.0 BY-SA版权协议，转载请附上原文出处链接及本声明。
原文链接：https://blog.csdn.net/weixin_43883917/article/details/118193663

: T! j' x% h! g/ ?0 v) k' ^

---

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

---

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

Powered by Discuz! X2.5