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

杨利霞

: s. V$ Q. p/ t$ ~( Z6 \经典十大排序算法（含升序降序，基数排序含负数排序）【Java版完整代码】【建议收藏系列】
经典十大排序算法【Java版完整代码】
/ o0 e" }* ~. @5 E9 u7 T写在前面的话
十大排序算法对比
2 e# D' _. c8 U5 G. C! b冒泡排序
快速排序
9 m" |$ S% k7 f: S. P7 J4 S* ]直接选择排序
堆排序
5 K: b' N8 I; L- m1 ?% V归并排序
插入排序
# j- R& G# X# ]3 u希尔排序
计数排序
5 @" I& o, j! L4 x+ ]桶排序
基数排序
完整测试类
写在前面的话
1 s5 B# @% f8 o' W3 K6 @+ k       虽然已经有很多人总结过这十大排序算法，优秀的文章也不少，但是Java完整版的好像不多，还存在某些文章代码存在错误的情况，同时也为了自己练手，决定把所有的写一遍巩固下，同时也真诚的希望阅读到这篇文章的小伙伴们可以自己去从头敲一遍，不要粘贴复制！希望我的文章对你有所帮助，每天进步一点点！！！
$ A. q* i: ^& Z+ x

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


% {8 a' C, L0 N0 m5 {十大排序算法对比
! N( C' }1 {4 J" `5 e
% A! f2 m* e& R% [4 |
5 [8 }. J+ A& P2 o
5 x3 b' i/ i  M) e1 {1 b& Z
关于最后一列的稳定性，我稍微解释下，例如对序列：1 2 4 2 6 排序，序列中存在两个2，如果我们把这两个2标记上（让他俩不同），排序之后，前面的2还在前面，那么就称这种排序是稳定的，反之不稳定。


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


1 R# Z/ _+ [2 A
9 c6 a+ M7 ?  J" ?

2 Q4 E7 [# {6 o; b' b% }' p" i4 W
本文的图片来源网络，仅用于大家学习，侵权联系删除！（下同）

2 e) B5 X" |, B, d( v/ q/ h
完整代码：
2 ~4 L# A- g2 T

6 k" _+ h9 g; _1 \2 @& x$ f. Opackage com.keafmd.Sequence;
+ X* ~* D5 j: ?* r8 C& m
' K% O& I* T; f% f, U) U9 I
/**
$ I/ ]1 u4 F: @ * Keafmd
*
* @ClassName: BubbleSort
* @Description: 冒泡排序
- m0 I2 k, Z: e4 H! o * @author: 牛哄哄的柯南
* @date: 2021-06-24 10:31
*/
public class BubbleSort {


    //冒泡排序
: I% r" e0 _* b/ U6 @& H- Z- T# _3 P    public static void bubbleSort(int[] arr, boolean ascending) { //exchange标志表示为升序排序还是降序排序
4 B4 i- M- ]/ A+ R
8 e9 z9 |- k8 s
        boolean flag = true; //加一个标志位，记录上一次是否发生了交换，如果是，我们则进行下一轮，如果没有，说明已经冒泡好了


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


/ {. z% T! b: `. Y            /*System.out.print("第"+i+"次遍历：");
, A8 N5 ^0 k- B            for (int i1 : arr) {
! |  c/ ]& P2 g                System.out.print(i1+" ");
$ u; u4 j% e! s8 K0 }. A( h7 e) }            }
$ {) K  R5 y1 T            System.out.println();*/


# D7 k6 m4 X1 k3 q            flag = false; //假定未交换
6 F1 k$ q- ^; }0 ^) {9 p8 f1 B
: b1 ]: r/ \5 @0 D% M
            for (int j = 0; j < arr.length - i; j++) {


                if (ascending ? arr[j] > arr[j + 1] : arr[j] < arr[j + 1]) { //控制升序还是降序
                    int temp = arr[j];
                    arr[j] = arr[j + 1];
7 W  {  |  H! F$ ^* z( b' g                    arr[j + 1] = temp;
# K) u- y+ U# Z+ z& }; ?                    flag = true;
$ r' h9 T6 T% B7 n1 L4 c                }
* ]+ _5 {. |3 ]" E

8 D( X& ^( U# k) r" Y            }
        }
( w1 _9 |6 R  O( D5 I    }


    //冒泡排序 -- 默认不传参升序
    public static void bubbleSort(int[] arr) {
        bubbleSort(arr, true);
    }
}
1
2
" m3 d7 \% W# ~! ?2 x3
4
5
6
7
* N, X" ^8 I% n# V6 l8
; [' U1 n" v' _, I9
10
11
& b- p  W1 p- v  u" ^7 t12
6 j: z1 Q! s* F/ n$ h0 w  C13
* s# V( b/ S& N14
/ [. w8 o, m9 ^) C5 N# i15
16
17
( b& y! x$ i9 ~; u6 d18
$ D# ]7 @0 L4 b. ?2 p5 g; V19
8 Q+ Z- ]! L/ G) V20
8 S% q5 z* @5 r4 g) C0 n  d21
22
2 Y* g; [0 }& R9 E6 |23
24
( r# B, f) l  K* p- ~, K25
26
27
- J& Z8 E4 G% v) _  v; S! I( _) w28
29
$ }: _+ f4 Z  D/ D30
% j0 _; V1 P8 }4 I2 S+ q31
* @8 H3 N2 k& D8 a' G1 r; R! z32
" j/ H* j# n' i9 I, L33
34
35
+ Q" E6 f  `7 y4 ?36
) d% U- _* Y8 o9 o37
" e" b) `8 S  L38
) Y& R; N* k# |$ g3 A$ M$ c& {39
40
6 y; T4 G9 A7 I; T1 Y7 ^* x; ?! i41
4 L; v4 {" W- _3 C% C7 P7 I; g) F+ [42
43
5 ~) H' g6 L6 L5 K; q+ {$ C/ q$ N44
- A1 Y( @- J( y; |" c7 _* m, I45
6 {( w3 C& s$ h3 O  c, t7 y3 Q测试代码：
  R! T" W# k. [4 D$ N

升序排序（从小到大）
9 {0 k0 {) f: b" U# N" j2 O
$ w9 f. S- j3 Q
package com.keafmd.Sequence;


# P- j8 }8 E0 J6 ^* qimport java.util.*;
import java.util.stream.IntStream;
import java.util.stream.Stream;
9 ~8 o! v. s1 u3 T, h3 V

4 t1 R: y5 m0 O  s3 x$ @/**
/ K/ n! a2 i, U1 x- l * Keafmd
*
* @ClassName: Sort
* @Description: 十大排序算法
6 z+ c9 E+ U" d. M( c) G7 P * @author: 牛哄哄的柯南
* @date: 2021-06-16 21:27
+ T" n/ R5 }6 d% g6 _' x */
public class Sort {
0 ]! Z# k% [, y. A/ e/ f% N    public static void main(String[] args) {


8 R5 x- S5 E! Y  i# p' R3 c) b        int[] nums = {12, 4, 25, 47, 58, 34, 25, 9, 99, 26, 1, -13, 162, 10093, -66, -1};
        int[] temparr;
, t+ c7 A& X: q& a/ Y+ P+ L
9 |& s9 F; r  b, A1 D
        //测试冒泡排序
        System.out.println("测试冒泡排序:");
! T# B8 ~# b% X; i/ ?0 R        temparr = nums.clone();
) M' z, @5 d* y, N7 m        BubbleSort.bubbleSort(temparr);
2 \/ @! h4 r! Q. R+ e        //逆序排序
        //BubbleSort.bubbleSort(temparr,false);
: b+ f+ {7 c! z4 E2 w) ~/ o        for (int i = 0; i < temparr.length; i++) {
" B; B! e9 J) M% Q6 y* F4 W            System.out.print(temparr + " ");
        }
8 `4 J3 K8 u% y/ h. D4 Y' E* a) i        System.out.println();
/ i, E+ |  y8 H. S3 j
1 K- E) g+ Z4 |& j
    }
}
$ A0 q" M, \2 L! M1
2
3
" j; c$ E/ U: a3 g' q, z, I4
; B. S& k0 `  j3 n5
6
7
3 g7 [4 {& o, B' p8
9
10
' F! L, X$ M- T* |: h: U11
12
13
14
15
6 k0 q6 X& \! k2 e16
17
  k: M/ d2 `: [4 i! T( F18
% ]! ?; w; }6 ~0 J  h19
20
21
22
23
24
25
& E& P* T, W2 o6 c9 w& w$ I26
7 Y. P" @7 ]+ S! m' j27
28
29
30
31
+ w- k: b8 }5 C, n32
/ h8 n: h3 x- |" C& [7 }8 h33
4 e2 c/ z  _7 ]; u# n0 [运行结果：


测试冒泡排序:
-66 -13 -1 1 4 9 12 25 25 26 34 47 58 99 162 10093
1
: i/ }" _* Z( x- |  b! k! ^  I2
降序排序（从大到小）


//测试冒泡排序
System.out.println("测试冒泡排序:");
temparr = nums.clone();
BubbleSort.bubbleSort(temparr,false);
; e% k8 v9 W+ N: c6 Gfor (int i = 0; i < temparr.length; i++) {
    System.out.print(temparr + " ");
! a: U" H. d9 `$ @3 I0 g}
: R" o$ ~) r' w% k& sSystem.out.println();
1
2
3
, d0 s/ Y' j. _  D' A4 l4
5
6
7
( u  P& J5 o4 p0 I7 k8
运行结果：

9 h# w/ l& S+ q0 M
0 x1 t) P# g' P# M* \9 I测试冒泡排序:
+ Q) a& c' R  z$ c# k/ X2 X) q2 j10093 162 99 58 47 34 26 25 25 12 9 4 1 -1 -13 -66
1
5 n: s) ]% z/ L" ^' R2
- p, b. A& k0 D5 K: O" R( x  P1 h+ u下面几个算法的测试也就是换了下类名和方法名（换成相应的排序算法），如果想降序就在数组后面传个false即可。我就不一一复制了，我在最下面给出含所有算法的测试类，需要的自取即可。
1 ]: x; M! `& V4 M) _
8 m( W6 q  p0 p
快速排序
4 S' m1 h3 G  l, O% N/ n# g. ?简单解释：
快速排序就是每次找一个基点（第一个元素），然后两个哨兵，一个从最前面往后走，一个从最后面往前面走，如果后面那个哨兵找到了一个比基点大的数停下来，前面那个哨兵找到比基点大的数停下来，然后交换两个哨兵找到的数，如果找不到最后两个哨兵就会碰到一起就结束，最后交换基点和哨兵相遇的地方的元素，然后就将一个序列分为比基点小的一部分和比基点大的一部分，然后递归左半部分和右半部分，最后的结果就是有序的了。

) M: V8 p: x1 v7 T+ L6 e2 d




完整代码：
+ s. F7 N: D5 e7 A, ^2 [* Z) x

! g6 S+ o  s' f0 B' L2 @package com.keafmd.Sequence;


/**
9 H7 P( W, y, r+ R$ d5 L * Keafmd
*
1 c: m$ E  x; R; C9 F7 ] * @ClassName: QuickSort
* @Description: 快速排序
* @author: 牛哄哄的柯南
* @date: 2021-06-24 10:32
3 ^- l7 l* K. z */
; B/ y( m1 L7 jpublic class QuickSort {
/ ~* w% z9 E6 D
8 [& Y5 H% u' i: D+ B# [
    //快速排序
5 M7 W& d: [- M5 w' |    public static void quickSort(int[] arr) {
. c3 p6 y+ u. {+ B: W3 L- A        quickSort(arr, true);
    }

! B* W1 ^- E+ D. j4 o1 f9 D
    public static void quickSort(int[] arr, boolean ascending) {
0 C+ S: d8 C+ \) G; J; H: d/ Z        if (ascending) {
            quickSort(arr, 0, arr.length - 1, true);
        } else {
1 f! W. q1 n, D) }* t            quickSort(arr, 0, arr.length - 1, false);
, [6 |; ?; s) H        }
    }
+ L* ]2 F' E7 g" X* k/ h
& J% F. y: Z$ e
    public static void quickSort(int[] arr, int begin, int end, boolean ascending) {
        if (ascending)
# L8 A' b4 i( A+ Q0 o& {' r1 ~            quickSort(arr, begin, end);
9 y9 U: ?4 D% [1 n- r        else
6 n3 S. e1 f9 A3 X; D! a            quickSortDescending(arr, begin, end);
1 G& `# F6 C3 q; I  |3 ]    }

8 r; ^2 [% m0 z/ Y
    //快排序升序 -- 默认
    public static void quickSort(int[] arr, int begin, int end) {
5 j% I% G* ?4 j! ~2 m6 W" |7 W" Z; l        if (begin > end) { //结束条件
            return;
+ z' K6 u* Q* ^% Z* v: I9 _$ D        }
& L% ~9 D/ G9 z4 m        int base = arr[begin];
        int i = begin, j = end;
/ i& e2 f. h3 {& w# K( s6 @( g        while (i < j) { // 两个哨兵（i左边，j右边）没有相遇
# E; K. |8 n) {$ N: E% C            while (arr[j] >= base && i < j) { //哨兵j没找到比base小的
  F2 C7 M* {0 `( B4 u                j--;
2 a8 B6 K3 P3 u" N7 I6 L8 d            }
  L" T! g9 x; e$ ]            while (arr <= base && i < j) { //哨兵i没找到比base大的
                i++;
            }
! N6 G7 v8 Q1 f8 j0 h8 p            if (i < j) { //如果满足条件则交换
                int temp = arr;
                arr = arr[j];
$ Z' t0 G: y" ?! K' M$ \, k% u                arr[j] = temp;
            }

# E1 l: i( R8 s- J! t, l! v" h
        }
5 l. ^9 y) {  ^9 h9 y( c        //最后将基准为与i和j相等位置的数字交换
        arr[begin] = arr;
- a9 Q1 v% J; N2 ?        arr = base;
6 m! F; Y- [7 b. o3 }/ z        quickSort(arr, begin, i - 1); //递归调用左半数组
3 F, U: v% C5 Y! I- e        quickSort(arr, i + 1, end); //递归调用右半数组


    }


+ p$ j0 O& e* m+ r) p    //快排序降序
) c: e: @* L9 G0 C8 v    public static void quickSortDescending(int[] arr, int begin, int end) {
        if (begin > end) { //结束条件
6 ^" Q$ m# ^' M            return;
" f* t! q$ ]( v        }
5 H3 u+ b2 q" G% A        int base = arr[begin];
        int i = begin, j = end;
        while (i < j) { // 两个哨兵（i左边，j右边）没有相遇
/ I% l+ Q% W6 Y) J8 o2 B& \8 F4 K            while (arr[j] <= base && i < j) { //哨兵j没找到比base大的
7 O; @+ k: j/ N9 q1 w                j--;
3 }* z: u! B4 y2 t* g9 b7 o9 E            }
            while (arr >= base && i < j) { //哨兵i没找到比base小的
: Z9 k9 e9 U. p3 w( [5 e                i++;
            }
* Z4 K. k8 e- I( P- _            if (i < j) { //如果满足条件则交换
* K. F/ M- j( X4 l' B0 M& r& q/ F                int temp = arr;
' F5 h0 m, d1 }4 s9 P; U                arr = arr[j];
                arr[j] = temp;
& d' y. Z4 u$ d- e& a            }
- ~% b; L9 G; Q
" a: Q( T$ p$ `9 f( P3 F
        }
( F/ z2 S' i- K4 E1 b        //最后将基准为与i和j相等位置的数字交换
        arr[begin] = arr;
        arr = base;
, o5 y5 G- K+ g& h1 ^  F* P  s        quickSortDescending(arr, begin, i - 1); //递归调用左半数组
$ B* W* H0 c" `+ _( {, r: I+ N: n        quickSortDescending(arr, i + 1, end); //递归调用右半数组
2 L8 X- m+ V6 P9 V

  }" w! c/ P/ l7 t( I$ |" V    }
8 v' ]- T% W3 Y6 K! U9 c: ]( j  s3 }
8 E8 n" R; H! Y8 R
}
, q, W1 _: }; o, Z8 F1 B2 a& A0 S3 T1
" z2 P$ O) w8 h2
3 _' t* @8 j. C6 r% W/ }. k3
3 s) Z9 g$ x' v! @8 h' s4
' ?! G) O" H# G6 i' _2 C# b5
6
7
8
9
; U1 T0 s) D, h/ O10
11
12
13
14
6 i+ m$ o! r% ^' P( V, s1 a15
16
17
18
19
" K  [/ [. u! q" \# Q7 |' ?' X6 r20
5 O: z- W2 \1 I/ c: {# h21
22
23
' q9 m: p& {: T. A! K& ~6 R24
3 L  F9 L# f: v1 f7 ]- x25
26
) N6 m9 Z) d) [7 V27
! q% c, m; J- L' e& ?' O28
0 S1 |* k+ {( D; N0 B% \29
7 N9 G* s6 Y3 f/ n" Z6 \6 C: H30
31
32
# s2 w7 V0 O9 n7 S$ t9 t3 m33
5 P. F# o% c( b* q* s/ W34
' A. c) n& H; L  W6 ~+ ?( r! x" m- s35
36
37
. L% j/ B! S* R9 g  j1 y! j38
* R+ b; F" I- R' A# K4 |6 v4 t39
* _( C1 g# }( m2 J40
41
4 W0 u6 E$ o" ~6 L42
0 ]" i. `6 h* S43
44
45
9 t% J/ t+ _1 {46
" h! a( x  m8 ?6 d8 U) z. V+ G9 f/ X' S47
* z# z( P) S' f# |7 e48
49
50
51
52
53
7 z+ Y( O5 j  u2 R3 K" p* d+ R! u54
55
& y' x& X; w" \& Z' J56
2 g8 B- @6 K1 o& i6 ~* _% b57
5 m9 F& q0 d: d! n, x' y58
59
60
* M- z* o. _& v. h* @) ?61
# G4 |. k+ q! m+ v- p6 x- g62
63
! w* q' n+ G. W: R64
65
. w9 c, E, X) w5 a( @9 E66
67
. @  w5 a0 [* |2 t68
69
! Z8 K+ `3 _) O70
: U  w# d& B$ `* G3 }8 ]# @$ W- j71
3 W/ o/ n" H% x6 t4 R; P72
73
74
75
76
" z* k& D1 e- M; D0 S! P77
78
79
. R/ i4 s; n* f, b: R80
81
82
83
84
85
86
8 m; Y, p9 `* y87
88
89
90
+ ?" Y7 q( Q3 `9 x" E- e91
直接选择排序
; U$ a- h' ?1 S% M( N% c1 _简单解释：
数组分为已排序部分（前面）和待排序序列（后面）
* F% G% p* F, f9 c$ o% O第一次肯定所有的数都是待排序的
从待排序的序列中找到最大或最小的那个元素，放到前面的已排序部分，然后一直找，不断缩小待排序的范围，直到所有的数都是已排序的了

9 g9 {1 \! K8 }
3 e# P  K, n! A6 [. [/ Q7 C
2 p! ~' A7 M# M& i' t1 ~/ n! \
8 B" Y0 B" H6 w5 i; b1 k
) F0 f% T2 ^& Q* u
# T1 G* b1 L7 X# u& ?& P; C. b完整代码：
9 a2 S+ x* L9 f. j( C3 U2 M7 ]4 o8 d

package com.keafmd.Sequence;
# b! Z- K1 [1 l  R+ c. B
# |4 }3 N9 \% D1 L6 }
/**
* Keafmd
8 W) N+ F* E. E8 S4 T *
* @ClassName: SelectSort
* @Description: 选择排序
* @author: 牛哄哄的柯南
4 d: H  ^' _. y2 c4 |, s * @date: 2021-06-24 10:33
*/
public class SelectSort {
' o( a9 e& h1 m0 {' F* _
7 o  v) J" Y3 b/ P! J* S
    //直接选择排序
    public static void selectSort(int[] arr, boolean ascending) {
/ G! v; V9 P) s5 C        for (int i = 0; i < arr.length; i++) {
: k/ O$ \% R1 c: o" @/ L$ p            int m = i; //最小值或最小值的下标
: t+ P: F8 A) p7 d            for (int j = i + 1; j < arr.length; j++) {
+ H9 u0 {3 ~( R# l! a+ z                if (ascending ? arr[j] < arr[m] : arr[j] > arr[m]) {
  n* D! M& C2 W' t  I3 j$ ?% S! H                    m = j; //找到待排序的数中最小或最大的那个数，记录下标
: w# Z( h$ V0 S6 G                }

& h! I4 D4 t: ?8 ^$ U8 G" M/ S
            }
            //交换位置
            int temp = arr;
% G' F% B# l7 A$ V$ p% @            arr = arr[m];
- h. y' c& i& Q5 W+ E            arr[m] = temp;
: Q, q8 I3 U8 Y  E
1 D9 h$ U; O$ |9 c* [
        }
0 j- b" j: Z) Y6 r4 B    }
' p* E- I* E5 V& ~; v
& O9 T" V, [* x. j1 P9 S
& L) p4 ?/ P  q) v$ Q" I% S    public static void selectSort(int[] arr) {
2 S# x/ C& b# N8 F: L        selectSort(arr, true);
    }
}
1
2
3
. P) }! R/ _% O6 L/ ], b; m4
( V2 y. A" b0 _+ ^$ m6 L0 `5
6
7
8
9
3 c; d6 a( M& s10
11
12
  w) ^( w4 Q+ Q6 I6 r4 Z13
14
15
( c, Z  J  }4 @2 Z, Z- K! l16
17
# V2 f% F- d  _5 w' K- Z18
9 C0 K; K, [: T: g0 V19
  e: O# S" e3 Y  r7 T, N: S, s20
21
22
23
24
! |) [  ^! V6 w8 C# d0 I+ g$ r$ D* a25
26
; H- D# V. F# A27
/ K# @/ D' o1 R" e28
29
30
31
32
33
34
堆排序
先理解下大顶堆和小顶堆，看图
大顶堆，双亲结点的值比每一个孩子结点的值都要大。根结点值最大
8 S+ _& y/ t, Y. Z小顶堆，双亲结点的值比每一个孩子结点的值都要小。根结点值最小
1 c) b  w+ _$ ]5 A; [



简单解释：
构建好大顶堆或小顶堆结构，这样最上面的就是最大值或最小值，那么我们取出堆顶元素，然后重新构建结构，一直取，一直重新构建，那么最后达到排序的效果了。




8 m: r" [: D! i7 k+ t) A
3 V, K- P- D5 r# C1 u
完整代码：
" d* }$ \* ~! k

package com.keafmd.Sequence;

7 W$ b/ e% }6 S' @, k# x4 |
/**
* Keafmd
" h; F$ T' i1 \ *
* @ClassName: HeapSort
/ S% J* o% N/ S; `4 f! z * @Description: 堆排序
* @author: 牛哄哄的柯南
* @date: 2021-06-24 10:34
; X$ s9 \6 v9 B( n9 Q  G4 { */
public class HeapSort {


    //堆排序
    public static void heapSort(int[] arr) {
$ k) \9 X7 x7 ]1 s9 l        //对传入的数组进行建立堆，这里默认建立大顶堆，进行升序排列
/ x+ `# ]1 Z7 |0 `+ p6 y% u* h5 V        heapSort(arr, true);
; c8 G: K# x# N% w% E% A    }
: p+ h1 h, \7 a

    public static void heapSort(int[] arr, boolean maxheap) {
' q5 ?8 U7 C4 M

        //1.构建大顶堆
        for (int i = arr.length / 2 - 1; i >= 0; i--) {
            //从第一个非叶子结点从下至上，从右至左调整结构
6 P( P& c" J+ i6 O4 e; {8 P" H' |            sift(arr, i, arr.length , maxheap);
        }
- B7 }2 M( a( y1 B! l7 E

6 k4 s6 t! [, `7 P, |4 s+ _        //2.调整堆结构+交换堆顶元素与末尾元素
; _5 y0 M, G$ }) A5 ]        for (int j = arr.length - 1; j > 0; j--) {


, ?, L; \& @  `, j/ `            //现在的数组第一个就是根结点，最小值所在，进行交换，把它放到最右边
5 v& w5 e  F/ ~$ B            int temp = arr[j];
            arr[j] = arr[0];
            arr[0] = temp;
4 \/ r; K. J+ z! ]) d" _
( i2 R' F- |, O, I3 Y, D, @" \) P
            //重新建立堆
2 @+ M6 e+ W( O/ m, p            sift(arr, 0, j , maxheap); //重新对堆进行调整
        }
. p" O+ F3 m; O3 ^& Z3 _    }


    //建立堆的方法
    /**
& S* O3 v' a, k9 N$ o: i) I     * 私有方法，只允许被堆排序调用
. Y- }" E, o! y& H& X: F4 d% o1 k1 _     *
     * @param arr     要排序数组
     * @param parent  当前的双亲节点
     * @param len     数组长度
     * @param maxheap 是否建立大顶堆
     */
7 R9 }. L6 q' h4 t    private static void sift(int[] arr, int parent, int len, boolean maxheap) {

4 z$ f. }; x, b0 b% m$ D# z
        int value = arr[parent]; //先取出当前元素i

7 W; I& p: |& e7 y$ Y6 [, j
        for (int child = 2 * parent + 1; child < len; child = child * 2 + 1) { //从parent结点的左子结点开始，也就是2*parent+1处开始
2 q9 @' D* ?4 P; Q* \2 T" h8 ~' j
; I) F9 I8 J) l" n
            if (child+1 < len && (maxheap ? arr[child] < arr[child + 1] : arr[child] > arr[child + 1])) { //如果左子结点小于右子结点，child指向右子结点
5 Q2 N8 N2 ]# W                child++; //右孩子如果比左孩子大，我们就将现在的孩子换到右孩子
- ^5 S! d& T7 ^- Y& [: h            }
" A2 B3 ^' J" z5 {1 ^
% `3 }2 D( V# k, j8 U0 q; ~# i
            //判断是否符合大顶堆的特性， 如果右孩子大于双亲，自然左孩子也大于双亲，符合
! g  }! p$ _  y6 L            //如果子节点大于父节点，将子节点值赋给父节点（不用进行交换)
            if (maxheap ? value < arr[child] : value > arr[child]) {
                arr[parent]=arr[child];
, B" E* O) W. [! Z# \, y                parent = child;
            }
            else {//如果不是，说明已经符合我们的要求了。
4 n% W' h% R. J% }" O- C- I                break;
            }
  n& Q7 N/ A) t! t% N  P        }
! ]3 S) ]$ _( o" i. M' n1 ]        arr[parent] =value; //将value值放到最终的位置
& P* y. t! ]1 [! m
/ v% c2 c% A3 [# f+ k4 V: j2 g% A


6 W4 a/ b5 N! a( w1 w& F$ `) y    }

/ W1 F9 n' C( J1 W7 X/ d' [
}
( u& H  E: r  r/ |1
4 Q' d2 J- n* H% X* s2
3
4
+ ^. H! X2 o# w3 |) X5
& a# v, p5 I6 F* s6
' I* A/ C# J) x! G% z  }) _7
8
! P1 I* l. G2 h4 i9
9 K' P! T6 @0 i10
# C: Z2 l" }: Q+ M9 P4 E: U& S+ m11
3 B" n6 I$ u, |3 [8 k9 V2 p12
* o) }. C$ T) H! k3 v13
3 W3 v) \' F& J% e6 B$ G14
15
; {) {& o6 c4 I" o2 H- z16
17
" F9 B/ ?- H. @2 M; o/ v18
$ Y. z+ T0 d) a2 S# O8 W4 Z* h19
, p( H) K8 ]( R5 L3 Y20
& Y& y. w# f6 M5 k0 f  I' A21
22
0 f* y- C0 ~. E& ~% w: n23
& a% S8 P: o4 i3 P$ b2 P) B5 m24
5 a' W# ~7 n9 ^/ g/ [/ ]25
% j$ o$ `0 ^+ V& _6 O/ [) e# |0 |0 x26
& P3 T& p' E/ q5 p4 T: \- o8 j27
28
8 a" Q: |/ ?  j, p+ h, q29
5 H* P' ]! ]- r- F0 W4 b30
$ K- }% P5 B$ b5 {( q1 i31
* w" q9 d+ h1 ~5 T32
33
+ g* q' ^! @% [; ?+ ^34
0 Q- _+ _# D; M) [; H35
9 C* J: q* X, N0 X7 p6 K36
: x) Y: }9 \! a, i$ E) p37
38
; F/ o( k1 g+ Z) G39
40
( a5 ^6 h2 p: H, T! N41
4 W4 X2 w2 v3 o# S6 J) n42
43
44
45
+ u7 Y) z8 ?5 K5 t; w8 R4 O8 c% X) W46
47
48
4 H; X$ ^( k: ?3 y2 q9 h" \) S49
) Y0 N  C' v" ]9 G# J) a50
51
52
2 f; S4 ?- p, P  Q8 m0 W/ q( c53
54
: ?* i+ y% s: N: W& H6 X55
56
# D4 o) m+ b; l$ g" W: s57
58
7 b$ X! b1 n( }4 y2 {. n3 ]8 M' b59
60
( v% t, n8 ^' f2 K3 F61
& y! s0 e7 S- ]4 [: \' K9 s62
$ H# {& n  m" N+ N63
  C+ k% e8 G8 D' O+ K/ H64
65
- O" w1 q! t0 c9 R8 `* G66
) U/ E" i2 C2 X6 \' X  |2 ]67
68
69
' ?' w9 O: A' g5 |5 h70
5 c. R& x5 ?( D0 N! R2 Y2 C$ ^71
72
73
74
归并排序
9 Q2 Q2 `  h0 R5 Q0 A简单解释：
该算法是采用分治法，把数组不断分割，直至成为单个元素，然后比较再合并（合并的过程就是两部分分别从头开始比较，取出最小或最大元素的放到新的区域内，继续取两部分中最大或最小的元素，直到这两部分合并完，最后所有的都合并完，最后形成完整的有序序列）

4 H/ N7 v9 e: A. Z

$ ^1 W1 \4 [' N! M" N  Y) B  _
3 _. s4 L7 f6 X5 Y) d
( }0 w8 W1 H0 n) K
完整代码：

- P$ b- j+ b! o
package com.keafmd.Sequence;

( O$ J8 C" ]$ ~
/**
; f7 u. {' q, N* d$ i- d  l * Keafmd
3 y6 F& m5 W* a% | *
* @ClassName: MergeSort
* @Description: 归并排序
* @author: 牛哄哄的柯南
9 r( W: c) A/ O' @, B * @date: 2021-06-24 10:35
*/
9 Z6 k7 T) \8 o; D7 J5 L0 h6 j" hpublic class MergeSort {
( J& ]6 {. J8 c! F  r! \
: _$ ~8 K7 g' Y& S$ g& `
    //归并排序
    public static void mergeSort(int []arr ,boolean ascending){
        int[] temp = new int[arr.length]; //在排序前，先建好一个长度等于原数组长度的临时数组，避免递归中频繁开辟空间
        mergeSort(arr,0,arr.length-1,temp,ascending);
    }
    public static void mergeSort(int []arr){
        mergeSort(arr,true);
, Z' _' }. v1 Z/ l( A3 J    }
2 C7 y* W- b. m
+ h3 r: `4 v6 `, o+ {4 t
    /**
- V0 M- j3 h1 n% y2 f( }, g     *
( l5 t: _2 r, H/ [* _5 _0 R1 O     * @param arr 传入的数组
     * @param left 当前子数组的起始下标
     * @param right 当前子数组的结束下标
     * @param temp 拷贝暂存数组
1 S& O) W, t$ |6 x     */
" e3 F. J8 T5 f( p0 O; `0 Y3 Z" O% ^7 s! ^    public static void mergeSort(int []arr,int left,int right,int[] temp,boolean ascending){
6 p; W8 l, n0 s$ \5 O        if(left<right){ //这里是递归结束的条件，我们是对半分，那当left==right的时候肯定大家都是只有一个元素了。
* Z- M2 K6 c1 c

            //对半分，比如总长度是10，left=0，right=9，mid=4确实是中间分了，0~4，5~9
            //当长度9，left=0，right=8，mid=4，0~4，5~8
            int mid = left + (right-left)/2; // 防止越界的写法
            //int mid = (left+right)/2;
! M% K1 \2 U. Q4 a

7 q$ s8 P0 P4 c) n% C            mergeSort(arr,left,mid,temp,ascending); //左边归并排序，使得左子序列有序
            mergeSort(arr,mid+1,right,temp,ascending); //右边归并排序，使得右子序列有序


            merge(arr,left,mid,right,temp,ascending); //将两个有序子数组合并操作
: D, {, `. M- V$ u- }        }
    }
. l* R: q+ s+ U% [( W% F, y5 K8 P: a
' J6 c0 x- \: V
4 _7 G9 s0 J1 C    private static void merge(int[] arr,int left,int mid,int right,int[] temp,boolean ascending){
' F$ i' q; r, Z  D) h8 |3 O+ v        int i = left; //左序列起始下标
        int j = mid+1; //右序列起始下标
        int t = 0; //临时数组指针
        while(i<=mid&&j<=right){
" M! h' d4 t" d. \( }$ ]            if(ascending?arr<arr[j]:arr>arr[j]){ //比较两个序列第一个元素谁小，谁小先拷贝谁到temp，然后对应子序列下标加1
8 k8 O. P# R' o" Q  n3 {( J. ^                temp[t++] = arr[i++];
            }else {
                temp[t++] = arr[j++];
9 m% M8 J+ B2 n9 m3 e# h! A( A' `. S            }
5 p/ {' `' l% j        }
! q. V4 B6 G4 B/ `6 A4 N& r4 ?

        while(i<=mid){ //将左边剩余元素填充进temp中——左序列有一些数总是比右边的大的数
) p) h( D) G6 o+ @5 {: N            temp[t++] = arr[i++];
) W  ^0 N% e* }  ~) ~1 O        }


        while(j<=right){ //将右序列剩余元素填充进temp中——右序列有一些数总是比左边的大的数
            temp[t++] = arr[j++];
. t) y1 m/ d' s        }
- p8 W* I% T" P( A7 K

% @6 F  D; H5 N, b; b% a' D        t = 0;
" v0 @% `- C/ C. R5 A( A: z: L# [
5 G' z& d8 i! {
* x% r0 l/ T7 E! p: d        //将temp中的元素全部拷贝到原数组中
/ T3 a3 L0 M+ R/ l) W0 [1 Q+ l        while(left<=right){
            arr[left++] = temp[t++];
        }

/ U) H" U& ?5 X4 W; v2 C: v
$ k9 ?* Y+ M( O) K! e& Q. K    }
+ n# m; n" e) I2 c* C7 _3 E
9 ?6 s" x7 H! W1 C/ M$ W0 E1 r
}
% E: c8 W& f$ {6 g, q) K+ o/ }1
. n& e* X8 E- ]2
, P9 Y0 I3 U" L- F& Q3
4
5
; ^: F" {8 r  B2 b6
7
4 o( V. I% g& q+ ~8
# n6 m" B/ L/ G  W- G. k( m" a9
10
11
12
9 y" A7 z+ Q7 C  w, s, e13
/ b3 n7 c6 B1 W1 _) `& G14
15
16
17
18
19
20
% H0 h, k/ D1 A2 x' O21
% Y: ?& H; o& z% `22
23
- C) f$ Y  D7 B24
, d5 e3 S' o1 u1 `/ ?( G25
26
/ D" D# M4 u  h( h0 Z27
28
29
30
31
/ ^: n/ b( O: q6 N2 R( A" i32
9 I4 N# ~* @% o! e9 N33
34
35
& z, Y8 A2 ?+ a. F2 V, t5 |36
37
38
% d8 r) j3 |  O% R5 C39
40
( z' g7 k- j" x* [  {2 g! x41
42
9 ?& z* @8 e+ J0 e* V, N# I$ \43
44
45
8 }6 a# M: W7 k! ~  {1 |3 w. C46
47
48
+ L6 a5 j, w7 ^2 g5 T% N2 a# D49
50
7 [7 w2 w8 \/ h' F% @51
52
53
54
0 j* j. r9 @/ I# V9 s55
5 e5 k& R1 Y& C- g6 i( }56
57
' o( \# @. B) p' Y' ^% ^& K5 k1 c58
, d" B5 o- h, E% S59
60
61
62
, k" F4 x  u7 [7 V+ l63
64
0 n: s8 }# d0 Q8 r0 v65
66
67
68
. ^+ V* g6 Y$ ]" t: v6 u; t69
  }2 Y% L8 _6 C3 [0 l70
71
72
73
" p; i7 f. r; ?3 [插入排序
简单解释：
& s  K  M& F7 g) m6 {最简单的理解就是打地主时我们拿到牌后的整理过程，从第二个牌（假设我们拿起来这个牌开始比较）开始，（说下升序）从后往前比较如果比前面的那个牌小，就把牌往后移动，直到找到一个合适的位置（这个位置的前面的那个牌不比这个要放下的牌大）就把这个牌放到这个位置，慢慢的前面的部分变得有序，直至全部有序即可。
& D0 s/ l7 h( k6 Z- C* h& t. p

! z- _8 }, e& r2 ]1 _


# w# d1 M, q3 r: R$ C8 D4 E. e: W
& J5 t5 w4 R5 F完整代码：
  E. h! j* [. N8 i2 \

# V1 D; A5 J& b; }: \0 qpackage com.keafmd.Sequence;
. E( p: f- K7 S( I& v; F
6 P. H) Y9 s8 W9 [+ I
; s& ^; ?5 l% K) o2 O( L( p/**
' Q/ Y" Y: u6 [& q2 | * Keafmd
5 R! k6 H* z8 {1 L# y9 ?9 x. c. F *
* r  h. V7 M2 I% f% M, G- ~3 a, p3 w * @ClassName: StraghtInsertSort
8 t! T+ q( L) _; U * @Description: 插入排序
* @author: 牛哄哄的柯南
% f, ]6 a/ Q' H9 o+ \ * @date: 2021-06-24 10:36
*/
public class StraghtInsertSort {
    //插入排序
* b6 _/ }- k: G4 F+ f    public static void straghtInsertSort(int[] arr) {
        straghtInsertSort(arr, true);//默认进行升序
    }


: B2 L4 i2 n  x7 T$ F% S    public static void straghtInsertSort(int[] arr, boolean ascending) {
% K' L, E& |" }: X0 X6 T' ?

# v3 b- p# H4 m        for (int i = 1; i < arr.length; i++) {
            int temp = arr;
            int j=0; //这就是那个合适的位置
            for (j = i - 1; j >= 0 && (ascending ? temp < arr[j] : temp > arr[j]); j--) {
                arr[j + 1] = arr[j];
, o9 b7 n% h$ c' o! s            }
            //把牌放下，为啥是j+1，
            //是因为上面的循环遍历到不符合情况的时候 j是合适的位置的前面的那个数的位置
            //有点拗口，但是就是这个意思，看图方便理解下
            arr[j + 1] = temp;

, k. h1 ]4 P! |


; I  ]' H/ q; \% c1 b  t        }
3 W3 N9 x5 O- d

0 s! q3 a- L/ L- a0 P    }
" L, U' ]' _( T, F9 l}
1
2
3
4
: i5 Q" l3 u. p5
6
7
8
9
10
* U8 g$ I# F# _% O6 q: `& I11
$ Z' `5 ?4 S  h12
" N1 Z# F: A( @- h) L13
9 S+ y& ~/ k3 T9 u; F# }& q/ \: G9 N14
15
16
7 Y# A  U% t/ U" }17
18
19
20
# T" ]0 z9 m: W0 h+ j8 D' r) Z: V1 i21
22
) r! i+ L. x3 R% T, Q+ j23
24
25
26
6 V( m) D2 U' F6 z27
" w0 m2 N7 s2 l8 E: f- n28
29
' Q4 q( }( n9 J+ G8 G30
31
32
( N, j. L& ~. d3 l2 h% b6 r6 [33
' r$ |# Q  W. K34
2 S& c" \& h* p1 F  D! t希尔排序
简单解释：
希尔排序是插入排序的改进版，我们理解一个叫做下标差的的东西，也就是下面那个图中的增量d，初始下标差为arr.length/2，然后继续/2，对在同一下标差（相当于把这几个数单独拿出来了）的若干个数进行插入排序即可。

! d, Z# [0 Z4 p3 M% [6 \
5 E! ]$ H6 b" C' Y/ q2 h. u

+ y, \- R- Z" x: Q0 N

完整代码：
/ d1 x% e% H5 t/ U! Z3 z1 d4 v
3 e0 T" Z$ i- Q, ?9 c4 f; b7 w
package com.keafmd.Sequence;
# D$ x. O; [4 d$ M1 p

/**
* Keafmd
*
* @ClassName: ShellSort
* @Description: 希尔排序
* @author: 牛哄哄的柯南
* @date: 2021-06-24 10:39
7 L/ I6 M) F) `) [% U  V. C */
. O& V$ s& v3 m2 }public class ShellSort {
$ [# m( ?8 P+ h$ ?/ z" Y8 o5 b

8 [4 a0 w" B  x) _    public static void shellSort(int[] arr) {
        shellSort(arr,true);
3 T8 W9 J6 V2 F$ X    }


2 @0 c: y# _$ q    public static void shellSort(int[] arr,boolean ascending) {
. ~: s: R3 a0 y; ]9 y% u
5 d5 X: v& c( X/ L% k0 J3 d
7 k. D) u/ H& `$ d0 p8 Q5 {        for(int d = arr.length/2;d>0;d/=2){
  i  U6 `3 {- K# q3 v# {) u

8 [8 E: Y3 N0 @) _# X2 d# C            for(int i=d;i< arr.length;i++){
                int temp = arr;
" R3 I! r5 c+ V; b                int j=0;
1 }! ]; G5 n6 p                for(j=i-d;j>=0&&(ascending?temp<arr[j]:temp>arr[j]);j-=d){
) v* I3 P8 u1 {                    arr[j+d]=arr[j];
% K( O/ A; [, L. I. ?0 J( U, E9 X, j                }
                arr[j+d] = temp;
            }
        }

" H% |# f% @" y8 V( f5 P  g2 A) ?. `
    }
}
- b# }$ P1 w, m9 v  k5 l1
; @, I! h- a% p; V( {" ~  L2
3
4
) m4 O6 g9 y" j& Q' U4 [( v9 s5
2 f% {* I7 e5 b6 ]: h  P7 r6
( \$ v! S% P& M7
8
9
& S, T. d$ E9 T( a10
11
( g. t) r8 i; c0 S( H12
13
14
15
16
  S6 ^8 j! r' r8 z% P2 E6 `" |# r& ^17
18
19
' N; B0 T6 `. ]& l( M9 Z20
" R2 u, [9 p: [6 H21
22
23
24
25
26
2 j! o. p$ s7 g27
4 X4 ?5 D$ F: O) {0 l; {8 K28
29
1 t2 V. [" Q* p) X8 j/ x$ @5 R30
8 T6 P! c5 a9 y6 ~1 i3 g31
32
) y, J1 E& K* Y# U9 i计数排序
, v- s5 y) N/ o7 x简单解释：
( j2 s( J) _: V这个排序算法看名字也很好理解，就是就是额外找个数组来计数，然后在这个数组从小到大或从大到小把数取出来即可。
8 I; U6 w4 a/ m





2 {; K, P" a6 b% e! l完整代码：
5 d! C/ Q  z) f+ f9 @  u
7 v! H) q2 z" o5 K6 a6 e
package com.keafmd.Sequence;


( o# s0 T1 e% M' D4 o7 A' |- @3 _5 w/**
* Keafmd
7 i, a8 e( P# ]/ I& f5 \9 R *
* @ClassName: CountSort
! y+ M  c. t$ l  J * @Description: 计数排序
* C# ~% [# D6 ?. A( x# \ * @author: 牛哄哄的柯南
* f5 l  H7 z, Z: t( c * @date: 2021-06-24 11:31
*/
public class CountSort {


    public static void countSort(int[]arr){
        countSort(arr,true);
    }


* ?1 Z# L. g7 @" Z    public static void countSort(int[]arr,boolean ascending){
        int d,min=arr[0],max=arr[0];

, @; G! f: m' ^8 G+ Y3 `+ q8 s
/ G: @+ {: S3 O        //找出最大、最小值
        for(int i=0;i< arr.length;i++){
: e4 A& `0 j/ z            if(arr<min){
" y4 }# i: G5 L                min =arr;
6 N/ [& ~" C. m- [) P. u' N            }
            if(arr>max){
                max = arr;
            }
3 E' q2 J! R) F+ U        }


6 o8 P" n. |9 O6 K1 I& M        //建立一个用于计数的数组
! l* |1 P, f1 {* Z( q  q        d = min;
$ O( A9 u  I  u4 m6 o6 M# A        int[] count_map = new int[max-min+1];
        for(int i=0;i< arr.length;i++){
            count_map[arr-d]++;
1 N0 C' b$ l0 M. C. L5 S0 _        }

4 _: H& b" Q  n' g- D% w2 O3 K
        int k =0;
        if(ascending){
; [4 R9 {% p. z2 a8 Z" P+ I            for(int i=0;i< arr.length;){
; ^0 {( J- J9 f+ j7 D0 x                if(count_map[k]>0){
                    arr = k+d;
/ i5 D+ U% \* Z* S                    i++;
* x7 E: x0 R- @+ |5 f  n5 F5 I/ U) K                    count_map[k]--;
; w" C. a7 X  j" K                }else
' I0 n7 X& r/ V! Q* K                    k++;
8 n) ~' E3 y: H  ^3 t            }
        }else {
            for(int i=arr.length-1;i>=0;){
                if(count_map[k]>0){
/ F& @5 `' {0 z4 m                    arr = k+d;
                    i--;
                    count_map[k]--;
$ U/ l  c' ?2 T! }% ~                }else
- t- ]( ^' u( g4 O( v                    k++;
            }
: X/ X% w9 F# B. s        }


    }
* Q/ X' n- i) D3 K, p, U" f. @}
1
2
3
4
5
# Q! v+ H( Z3 u1 Q( @6
+ j7 [# D/ {( g4 Z1 l/ p. s7
' U3 z( g4 J. A4 J" M# p) X' J8
+ y9 j/ s5 v# c" Q5 C5 Z2 G9
$ K" Y( X. L; V4 h* }10
0 p/ D# K% G% H* N0 I: A11
12
13
- }- _* W  J8 Z( g! l14
15
9 L+ E8 l) U. [" w8 l* Y16
( J) ^. ?' d* o, ]2 r: \17
6 n1 ~# u9 N/ I3 t: @# ~18
' _% M3 h% Q- h6 j1 _19
20
21
4 [0 U9 ]7 ^/ o! d22
/ W+ E& Z: H8 B$ |+ g3 e23
, Q1 C2 O: Z% |0 b) Q% K4 r24
25
26
# @0 _4 }' _1 I2 b+ I0 S27
28
29
30
31
6 @0 R# J9 q* L8 L/ x0 @32
33
4 F- {# ?, Y0 ]* Q34
35
36
37
38
39
9 F0 {# Q$ l) v8 C* F40
, ]! d& }- s: ?41
42
' r/ _9 \+ }6 e7 |43
& s7 x# |- V+ _. w44
45
' Z, H% M6 H9 j6 I; w+ k46
47
7 f1 `8 }4 r- g) E% q48
49
& d3 E" K# Q7 Y5 v- c* a, f50
6 [5 l5 E, D0 [# i9 k51
52
9 ~9 n. @* F' {53
& t2 s2 b9 G. x8 q2 j" O  k54
55
56
7 y$ w  B( \$ r( r- t$ r57
58
59
桶排序
简单解释：
就是把一个数组分成几个桶（其实是几个区间，从小到大或从大到小的几个区间）装，然后让每个桶（区间）有序，然后取出来放一起就可以了，相当于把几个有序的段拿出来放一起，自然还是有序的，当然需要是按照区间的顺序拿了。
! @$ V2 }; ~% D7 R4 ^+ G/ @9 }
0 g+ T+ w, ^& t. O# b, l. ^
' h% H( R2 b+ G8 b' }7 u

, x" R, {) `1 _
+ O% N5 T+ U( X5 l# D: y: w; l/ L7 R7 b
( z! I; E* Y+ ?( Q- j- P完整代码：
& G) ^0 Y. x/ t2 h/ f1 K' p* K
1 V" I7 R7 j2 f. |1 q
* c9 a; f4 A; O5 p) @3 L$ Spackage com.keafmd.Sequence;
" R% @6 Z9 v) d0 r$ P) C

( x: S0 n9 L; q6 b4 ^import java.util.ArrayList;
import java.util.Collections;


2 k% ?5 ?# N1 a7 X6 b/**
* Keafmd
/ [! f0 |3 m/ z *
* @ClassName: BucketSort
, T" S; h4 j1 v8 C/ B * @Description: 桶排序
! j8 F' {; M6 x * @author: 牛哄哄的柯南
* @date: 2021-06-24 13:32
*/
public class BucketSort {


    public static void bucketSort(int[] arr){
        bucketSort(arr,true);
0 L- {* |; k$ z3 l" W( V    }
5 Q" q" |* U# ~) p) \2 v

    public static void bucketSort(int[] arr,boolean ascending){
5 v1 S, {5 L& m/ g        if(arr==null||arr.length==0){
8 J0 L" w5 S9 e( h" Z: u            return;
: ], ]$ d9 I1 ?% f; j        }
        //计算最大值与最小值
        int max = Integer.MIN_VALUE;
        int min = Integer.MAX_VALUE;
        for(int i=0;i<arr.length;i++){
. [6 E- Y! M* s6 L, @. R! U            max = Math.max(arr,max);
3 I) O) ^, h2 r/ ?1 r, ^; S2 Y4 z& A, l* A            min = Math.min(arr,min);
        }
* @$ x0 p4 n( T9 R, S6 Z; g, q
" S/ X# i) s, t  I4 k) L
2 G6 h1 z5 e3 y' N, @4 ]* D        //计算桶的数量
  H3 ^& m: X; ^0 J; h        int bucketNUm = (max-min)/ arr.length+1;
        ArrayList<ArrayList<Integer>> bucketArr = new ArrayList<>(bucketNUm);
        for(int i=0;i<bucketNUm;i++){
1 A4 C7 d% R0 \; |! ]  x            bucketArr.add(new ArrayList<>());
        }
7 D! `% s1 F; H3 F
( m! x1 L1 d$ v' U* E6 C* Z5 c4 l
/ G8 ^+ Y+ M) b6 \4 L' s7 M2 ?        //将每个元素放入桶中
( o0 `+ I* I$ ~. W& \        for(int i=0;i<arr.length;i++){
            int num = (arr-min)/ (arr.length);
; Q4 z' F6 l% {9 O6 Q* y' r            bucketArr.get(num).add(arr);
: |& x2 g# ^; ^" G! m        }
1 q0 x9 \9 x, K9 i

8 F* Y9 f" a$ e  E6 |        //对每个桶进行排序
0 G, B/ m1 L# N% d& K& E        for (int i = 0; i < bucketArr.size(); i++) {
% J1 }! l5 {+ B! F            //用系统的排序，速度肯定没话说
            Collections.sort(bucketArr.get(i));
* i0 Y2 e$ i! C+ y6 }; R1 N        }
/ V% H' z$ Q& s" G, r# U4 q

& c! `6 f5 z3 C9 ^9 O        //将桶中元素赋值到原序列
        int index;
        if(ascending){
            index=0;
5 ~' T$ d0 F8 c2 I) E  V9 c- q& [, x5 X        }else{
            index=arr.length-1;
        }
% \" r( n) s! v, K5 G) J) u" p
8 |, Q5 Y  @1 }5 O  W, F
3 e! {" ~1 A/ V  a) u9 \        for(int i=0;i<bucketArr.size();i++){
3 R& P6 n) m0 T4 U2 w! k            for(int j= 0;j<bucketArr.get(i).size();j++){
                arr[index] = bucketArr.get(i).get(j);
( |/ P* V7 V2 I; Y  i$ o                if(ascending){
                    index++;
! h  d3 W5 R7 W5 _                }else{
9 r1 G& ^2 `9 O5 [5 k7 x* v+ l                    index--;
                }
- a5 Z1 }, q( H. N' n. ]: s# q            }
' y  A5 Y$ ?; x0 z: e# U9 i

        }
3 j! C% r/ q0 @) j

    }
}
7 T; f' X0 H* d  @1
( n6 k- b& }; ]5 ]) v2
3
4
1 W) x9 z, O0 }7 o5
6
* A8 C$ m' Q" O; C2 y( |/ v7
8
6 h+ {% d) k. [  p' y0 b' v9
% y4 N4 \" F: t* u10
11
12
3 j* l/ `$ A' f. E$ A13
" l& r& P9 Z0 K3 M8 _& @7 L14
" {, I) V* U. i5 z0 S5 H7 \15
3 T9 d* [- s$ I6 I/ E+ |% O1 ~% M16
17
2 A$ v; N3 W: |$ e# y, u18
19
20
9 y" E, @# g: B+ ~* [& ]21
, b8 ^, A: v; z, f9 F( d/ X0 n0 ~* Q) z22
23
- p8 R) d$ s3 ^  Q3 A" a24
" Y6 U6 Y& T% I, Z4 {25
26
27
. a/ I! v+ A& w- p28
29
! s& W% N' w' }: i8 B. x30
3 B) ~% g& f9 I& L# q( Y, x; k, F& G31
32
* v7 y2 f" p3 U& M* U33
34
  [/ d! s6 I* Z; }4 W. \  U+ |9 x8 w35
. l1 i/ }5 G% a7 H7 r36
% A* p3 H$ }/ e. N' T) e37
' [7 O/ }, ?9 o- U0 u* F0 a5 V* J38
# }2 H# |$ L" A39
) k6 @4 `" S8 x* d; b40
41
42
, j7 L7 t9 `0 }1 Q! Q/ C43
) y& F1 Q& s0 U4 [6 I44
7 N4 O% r' z0 `) y: m7 V0 q% @2 D' X45
46
47
48
49
6 m: E, J0 E: j4 H; E! A, y  s50
9 ^1 W& e% Y# N, F51
52
53
54
0 o; E) Y* q7 d+ k2 l, O55
( U6 y/ w& q9 X56
57
58
59
60
4 C% Q+ [0 z. D. L# W- f61
62
63
2 M( M" z7 w# I% k$ J- E64
65
66
3 G5 y6 g, D$ b+ U# _67
5 n  b) o' q0 S( t1 f68
69
: c8 ]" o6 W# p) H- f70
71
72
- {4 c; k( G9 \, q: R+ g. o基数排序
简单解释：
首先说一下，我发现好多人写的基数排序只能排序正整数，其实只要处理下就可以排序含有负数的了，就是我们排序前先把所有的数整体变大（就是减上最小的负数，也就是加了），都变成正数，然后排序好之后，在减下来（加上最小的负数，也就减了）就好了。
' f, E7 x! Q5 |) M* k4 f# S基数排序就是按数位排序可分为LSD（从最低位[也就是个位]开始排序）和MSD（从最高位开始排序），下面写的事LSD基数排序。
基数排序就是把数按位考虑，让后我们一位数只能是[0，9]，就是我们在考虑某位（个位、百位· · ·）的时候就只看这个位的数，放到在[0，9]相应的位置，然后顺序取出，最后再按其它位这样操作（上面说了要不从低位开始到高位，要不就是从高位到低位）
0 D$ ^9 m8 _. b: d# \0 W
# W7 }% Y$ V4 ^% Y0 k2 [! u& m6 N9 @
6 t" F5 k& ~" F+ G" @1 C% }
1 g, F( j* h4 e. y0 p
( @2 F/ I  ]% \5 `9 E* L* I
6 E. z- o& e( ~* p) R- x
6 a. a( w. S6 i5 u7 [完整代码：


package com.keafmd.Sequence;

$ p, ^% j* s* f( b8 `9 C; C
/**
2 u) R9 ]; X( R+ J  m4 d * Keafmd
' g3 J9 G8 m3 a9 N6 c  a *
7 Z# H9 M- V; ~# I; P) D% v5 t * @ClassName: RadixSort
  `- [1 p+ Y0 D" e * @Description: 基数排序
* @author: 牛哄哄的柯南
* @date: 2021-06-24 14:32
/ L8 h, E. G, e; C */
- g+ s3 }4 W9 t/ [! M) E9 gpublic class RadixSort {
# s# Z: [7 L3 S1 C: D! f    public static void radixSort(int[] arr){
        radixSort(arr,true);
    }
    public static void radixSort(int[]arr,boolean ascending){
        int max = Integer.MIN_VALUE;
' U# N& ~) K2 s6 ]/ e* u        int min = Integer.MAX_VALUE;
8 |$ q- l) n) b/ e0 |' x        //求出最大值、最小值
4 g5 c3 h% z7 W" H! v        for (int i = 0; i < arr.length; i++) {
            max = Math.max(max, arr);
            min = Math.min(min, arr);
        }
5 h1 g* d4 D; B$ @        if (min<0) {        //如果最小值小于0，那么把每个数都减去最小值，这样可以保证最小的数是0
  H. D* a2 k9 |: {1 [5 S, j# o            for (int i = 0; i < arr.length; i++) {
                arr -= min;
            }
) s! F. p0 |  T$ e            max -= min; //max也要处理！
4 L2 a$ q+ K! A        }
        //很巧妙求出最大的数有多少位
* Y' B8 @# v4 A, V7 D' Y( T        int maxLength = (max+"").length();
        int[][] bucket = new int[10][arr.length]; //一个二维数组，一维代表0到9，二维存放符合数
        int[] bucketElementCount = new int[10]; // 用于记录0到9某位存在数字的个数
9 o7 z7 S4 n+ M% b        for (int i = 0 ,n = 1 ; i < maxLength ; i++,n*=10) { //个位 十位 百位 这样遍历
8 {, O2 Y- [* U9 U" ]* p            for (int j = 0; j < arr.length ; j++) {
                int value = arr[j]/n % 10;
: q$ {' W' W/ S                bucket[value][bucketElementCount[value]] = arr[j];
                bucketElementCount[value]++;
            }

/ C' w- H! L7 Q2 ]
  m' s  L2 Z4 K* L2 O; e( @            //升序
: J/ r& A, s' f5 I2 Y3 _            if(ascending) {
, j+ N' g$ |% [* Q# t- @4 y# ~  ~% o                int index = 0;
" I* S% ?+ Y% S. `$ Y+ c- d, N                //从左到右，从下到上取出每个数
1 J" d- ]2 C$ F                for (int j = 0; j < bucketElementCount.length; j++) {
8 p7 O) y- ?% D& M7 y) f' B                    if (bucketElementCount[j] != 0) {
                        for (int k = 0; k < bucketElementCount[j]; k++) {
                            arr[index] = bucket[j][k];
                            index++;
                        }
                    }
7 @! u, ?3 i$ [1 E                    bucketElementCount[j] = 0;
                }
# @& Q: i" {" `1 I            }else { // 降序
6 N5 L5 k! M( g' b- H                int index=0;
# U* f0 Y: _3 F* f3 E                //从右到左，从下到上取出每个数
$ {5 j# h1 P0 r, v. f0 k. f- T; m                for (int j = bucketElementCount.length-1; j >=0; j--) {
                    if (bucketElementCount[j] != 0) {
                        for (int k = 0; k <bucketElementCount[j]; k++) {
% p+ ]# I' ~- m% _0 W                            arr[index] = bucket[j][k];
! I0 u" |& D$ d% Q) s- T                            index++;
, j# i. q' e: Q: \9 Y                        }
                    }
$ ^5 `; Y' ]2 s2 [                    bucketElementCount[j] = 0;
                }
) J! M: F) g+ {3 v  f            }

4 b3 y& N0 o  s6 `' r, o" L
: Q. i  n1 Y; n/ x6 r: t
5 j, b7 o6 P4 R1 k/ ?
7 l. Z# `8 ~' @0 C) e            /*for (int i1 = 0; i1 < arr.length; i1++) {
. K- U/ N/ V& M! O                System.out.print(arr[i1]+" ");
/ Y# K# m; J  I& P  v            }
            System.out.println();*/
+ e1 ^. K! O- W* h# u" k; D( o  F


4 ?: i6 w+ G& ?6 Q5 y

3 N4 X8 f- Z1 q7 N+ N
        }
" B3 X" m. z/ q        if (min<0){
' g( j3 V. ]) y' h$ t0 l: [            for (int i = 0; i < arr.length ; i++) {
                arr += min;
! O- l8 z' E: m/ D            }
7 i* U. i: [2 X" W' x        }


: d7 Z1 Q/ O. r  y! L    }
}
1 K) I& M" q& X/ h+ |. z* ^3 j1
8 i- _" Z$ I( }; x1 h2 b2
1 X5 T! o# B' ]. F3
3 j5 u1 v0 W% \4
5 l* w- Q) b/ w8 |0 t4 V5
6
/ i' B' r& S  _0 ~* \0 p$ B. ~7
8
9
, d$ u, @4 @  W- P10
: ~+ y2 C- A3 D6 L11
12
13
14
; s; M& m2 V0 p* s$ C15
16
17
" E4 C0 R; v9 G4 T5 B( \. |# S( k18
+ _: k% u. ^# A6 r. ~1 b. f19
20
1 _% X  y/ i" P$ y+ \/ D21
3 p0 G" J+ R' x22
23
24
25
; B# `; l/ P5 D3 k26
- Q! l3 s' G) ^* ~( ~27
: C  M4 B/ E* S; J  i- W: L28
) X9 n/ l& X6 W& J; P2 Q1 W: v29
30
5 W" r8 H9 T' i$ x0 a- _31
32
) Z3 [" a- D5 |2 G! R, ?  E33
7 R0 ?0 B0 L" |  C# X3 `' u34
! k5 k7 D: j% K6 z& H35
  }. M% k3 I) Q2 W, ]36
37
38
* G7 c; `" h: X6 R5 `2 [+ m' a9 p$ m39
40
41
/ Z  i* ~" _1 z. o) @42
1 O0 n* b$ U  f43
: y/ a+ R! v. u) q- j  Q44
45
0 ?! b) J3 k( H! v1 m) U5 q46
47
48
) I% Y" i) {; m  o0 ~49
50
/ r% r; F+ W5 b* @/ p) S3 j51
52
53
7 ?6 N( ^( G; Y+ l54
55
56
8 T% y, R6 j6 x2 d  G! B) E57
58
59
+ {5 ^( a, L' }' {+ [$ w; f60
" U& G& |  b* K6 ~- D% D61
# b9 z$ c) k6 ^( P: O/ {62
63
64
65
0 ?1 H- I2 g+ c66
67
68
5 D: |) l% V# f& i/ b69
70
( v; o+ q, s1 x" J& m71
* }% {9 L% X, {& J% [72
73
74
. r9 Z3 w) M7 ~' g) z75
( W+ {, O" x  L# I" m76
! U1 O. F  ?, B9 R. t4 G, _77
78
; C* @* m% A$ w' Y79
80
81
82
) D& t0 ?6 Y# z$ w  X83
完整测试类
package com.keafmd.Sequence;
: j- r0 K) t' ]$ C

" K# z/ T& g( u; B( }5 K3 pimport java.util.*;
, @1 F2 o0 T3 Bimport java.util.stream.IntStream;
import java.util.stream.Stream;


/**
* Keafmd
*
* @ClassName: Sort
* @Description: 十大排序算法测试类
4 L8 R! n, ^; U: f, q" l3 p * @author: 牛哄哄的柯南
6 U/ d% ^) [* o/ | * @date: 2021-06-16 21:27
*/
public class Sort {



3 u$ l* s  u& p# T. _: n
    public static void main(String[] args) {
! n2 @, w9 r$ f+ S8 B1 B

        int[] nums = {12, 4, 25, 47, 58, 34, 25, 9, 99, 26, 1, -13, 162, 10093, -66, -1};
5 m, [$ }( O8 q( w) C//        int[] nums = {12, 43,56,42,26,11};
        int[] temparr;


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


        //将int数组转换为Integer数组
        //1、先将int数组转换为数值流
        temparr = nums.clone();
        IntStream stream = Arrays.stream(temparr);
# [4 D* `8 e" m( H3 Z! n8 Q6 y        //2、流中的元素全部装箱，转换为流 ---->int转为Integer
; n6 X1 P. W6 k        Stream<Integer> integerStream = stream.boxed();
        //3、将流转换为数组
        Integer[] integers = integerStream.toArray(Integer[]::new);
        //把数组转为List
: Z8 P1 [3 j- ?        List<Integer> tempList = new ArrayList<>(Arrays.asList(integers));
1 [- M: f: Z# B: H/ [        //使用Collections.sort()排序
        System.out.println("使用系统的Collections.sort()的对比:");
! h% W/ E& R5 Q  Z5 ]( C9 X. r
& V/ F4 l/ v; Q8 w) c
1 ^! v5 K7 |5 p# k: t5 R        //Collections.sort
$ \& u1 J$ D: U: X* e        Collections.sort(tempList, new Comparator<Integer>() {
$ D  Z) s! F" _0 B& n            @Override
            public int compare(Integer o1, Integer o2) {
  G( ]3 k/ T% L3 l# a                return o1-o2;
                //return o2-o1;
( [$ z. L9 d* S% g& f; J+ [" D& H            }
" ?* q$ P( b* b% r' ?        });
- {3 u+ @+ h6 b; U1 s5 H8 d$ t: ~" g

  X: T, o" ^6 i1 L        //tempList.sort 也可以排序
       /* tempList.sort(new Comparator<Integer>() {
            @Override
            public int compare(Integer o1, Integer o2) {
                //return o1-o2;
                return o2-o1;
0 B: [0 p" ^6 o. K  ~' ^8 k            }
        });*/


        //遍历输出结果
        for (Integer integer : tempList) {
0 j9 D/ T9 H5 o7 |7 Q            System.out.print(integer+" ");
        }


        System.out.println();
  Z: M5 A, E% ^9 [

4 o, @$ l2 n8 y- p# w: g, X( j        //测试冒泡排序
! ^0 }: q# ^6 I  k        System.out.println("测试冒泡排序:");
  p9 Q( t  O- g; M' D        temparr = nums.clone();
# k7 E: X; Z1 O6 j2 p
  w& v6 Y8 D# q" c: u
- \7 h( Y: C- I1 s- b1 }/ s        BubbleSort.bubbleSort(temparr);
! y! d! ?$ M6 w

        //降序
% x3 O6 h. R0 I! }! ?3 l        //BubbleSort.bubbleSort(temparr,false);


        for (int i = 0; i < temparr.length; i++) {
4 f2 p) g5 _& N; k            System.out.print(temparr + " ");
" ~7 S! x% D+ F6 [/ |& r        }
) L" d5 v6 ^+ T) b7 v        System.out.println();


        //测试快速排序
/ Z8 N! y" B; _1 O        System.out.println("测试快速排序:");
- H+ O' q6 J1 M/ o/ J7 {  n        temparr = nums.clone();
  C6 o- i6 I: s3 w        QuickSort.quickSort(temparr);
9 u! `" c! n4 H  q        //QuickSort.quickSort(temparr,false);
  c, ~0 `' h# }2 t        for (int i = 0; i < temparr.length; i++) {
6 ~9 F6 r& K- I4 N% B            System.out.print(temparr + " ");
  w( ]- u' `1 l1 r        }
        System.out.println();
  J+ A2 v& j5 N$ X/ c& P/ \& y
( Z3 C0 y6 C1 [: u
        //测试直接选择排序
3 b4 D5 w! [  F6 I2 F" K        System.out.println("测试直接选择排序:");
        temparr = nums.clone();
        SelectSort.selectSort(temparr);
        //SelectSort.selectSort(temparr,false);
        for (int i = 0; i < temparr.length; i++) {
0 G. |7 Z3 a7 W: x3 A+ ]. {4 v            System.out.print(temparr + " ");
        }
        System.out.println();
& M: l+ P8 K( y; K, q
; s4 ~) G6 d+ X0 @8 O- d
, _# C9 a/ z; N! t        //测试堆排序
$ Q9 y5 @! p9 n" _        System.out.println("测试堆排序:");
        temparr = nums.clone();
        HeapSort.heapSort(temparr);
/ V* g: {  R( t$ [4 D& p        //HeapSort.heapSort(temparr,false);
1 L% ^. R% N) X$ O; V, i0 E        for (int i = 0; i < temparr.length; i++) {
7 e# R. \1 x5 b* s% p- `            System.out.print(temparr + " ");
6 v: R& }9 G# {, C        }
4 n# t9 Q! k& ?: N9 T( d" t1 H- H        System.out.println();
! u% }4 \' d$ {( s. e

. j3 A3 o' n+ w1 l        //测试归并排序
0 |, q+ l& u+ T        System.out.println("测试归并排序:");
        temparr = nums.clone();
        MergeSort.mergeSort(temparr);
        //MergeSort.mergeSort(temparr,false);
" Q1 n5 N9 X5 L        for (int i = 0; i < temparr.length; i++) {
/ O$ k- b- q$ u! x2 ]            System.out.print(temparr + " ");
        }
- o9 ^& |; {( {) d* `        System.out.println();
$ j* A1 _2 ]  D

- s- n8 O7 B$ p0 F6 {* b7 G: t        //测试插入排序
        System.out.println("测试插入排序:");
" f! h% Z* S+ z8 D' G( m0 q        temparr = nums.clone();
        StraghtInsertSort.straghtInsertSort(temparr);
        //StraghtInsertSort.straghtInsertSort(temparr,false);
7 M5 {2 `; `% S0 q  |9 P6 L8 r        for (int i = 0; i < temparr.length; i++) {
' ]% g$ L! c4 P3 y+ {            System.out.print(temparr + " ");
/ ~- q+ e6 V' M0 a- q- c9 s, ?        }
. A- x' _1 a, k1 A- [        System.out.println();



0 d3 n( w; z8 U9 C9 y! @: R* O
' |4 c$ V* b3 d( l. W        //测试希尔排序
        System.out.println("测试希尔排序:");
        temparr = nums.clone();
+ e( R" Q- B! W; m        ShellSort.shellSort(temparr);
        //ShellSort.shellSort(temparr,false);
5 w4 d9 P4 Y) P" Z3 [% d2 N        for (int i = 0; i < temparr.length; i++) {
- S. G7 y) E' ^; [% J            System.out.print(temparr + " ");
1 F+ d. z; H& u8 H  M- c; F; z        }
! m, i+ H& _( N; k( w        System.out.println();




* ^- z+ ]! H. |4 L5 j# \        //测试计数排序
, M% s9 I/ S' q$ B  e  b, o2 P2 F        System.out.println("测试计数排序:");
6 a9 L: W7 p  R( {, c0 Q5 J$ R        temparr = nums.clone();
        CountSort.countSort(temparr);
        //CountSort.countSort(temparr,false);
        for (int i = 0; i < temparr.length; i++) {
2 D" j1 ~" |3 I            System.out.print(temparr + " ");
0 X9 e: y4 \- N/ p        }
, ]' E  D% ?* N( [        System.out.println();
9 T) z+ L7 f7 B% \
8 A( O( ]0 r% G2 r9 d
4 J. p( Z$ r' y+ r, s" e0 N, v

        //测试桶排序
2 M% B' j8 s! Z- V        System.out.println("测试桶排序:");
        temparr = nums.clone();
        BucketSort.bucketSort(temparr);
% U: \8 X5 p1 K+ @/ [        //BucketSort.bucketSort(temparr,false);
        for (int i = 0; i < temparr.length; i++) {
' k* o  m; f: h' w9 h  c. u' }            System.out.print(temparr + " ");
- A9 d" v. ^/ T        }
" g/ o9 P# p% ?) E        System.out.println();

: I+ N' J) p7 P* u; k5 K* \
2 g; Q% V( \; N! k$ q6 I, F        //测试基数排序
        System.out.println("测试基数排序:");
& N+ U& |$ O% a2 d1 U        temparr = nums.clone();
        RadixSort.radixSort(temparr);
        //RadixSort.radixSort(temparr,false);
& k, f5 f4 g+ ^8 E        for (int i = 0; i < temparr.length; i++) {
            System.out.print(temparr + " ");
4 d0 ?! t3 ^3 i        }
        System.out.println();

' [* |5 n# {5 x
    }
. Q; M9 [0 y8 m4 K

! B. F* ]. j0 @7 g$ p8 n6 {}
1
2
3
8 w1 \3 i3 t+ m; x! K4
5
6
0 k1 s  c6 j  i! b" e7
8
9
7 C' o5 Z" [0 x& d1 `# M# {. y10
11
12
) q! h! T" F: Q& h9 J0 J" I13
( X) F3 o9 s+ e14
15
16
17
18
% |) P) `1 G+ g; \) F19
20
21
22
8 o+ {/ U' Q* I0 R: g/ n0 Z23
24
25
/ T- _3 x. b: J& [: u- S26
27
; N0 q& {: {% f: h  d3 N: G28
! E! b/ M2 m3 |  F% r* h9 A" }29
/ g# E4 E: @3 O30
31
. t! o" Y$ T' i$ A32
) J# j4 ~, a1 }33
) N( p4 }, k$ e1 w3 P! ]34
35
! \7 Z5 @7 T" y; G36
37
2 @, `9 y; e: R) @/ \38
% j, n, v; M! y! L8 P+ J. X39
40
5 z  b, |4 U! k* C" b7 h% \41
1 I0 N. ]5 \0 T; R& j$ ]8 j42
43
2 @. q9 U  P  J3 _! ?5 H: U44
45
5 v' T( B4 W/ f! n$ v9 {1 h46
47
! [0 E$ p4 M: c' M48
49
50
& E) _0 O9 X2 ?8 f0 \51
  ^$ U) x' u; L2 p: A1 ^" v: f52
53
54
* T, w" o* \; Y55
56
57
: ?. |& R8 n8 n8 y1 m7 e58
59
- I0 N" I- t# o7 P8 C% E! m8 ?6 v60
61
  K9 T! C6 c& e62
63
64
' h3 V& _% ]6 p! t65
66
' n2 N& B* G0 h0 |7 K! t7 K( X67
68
4 V- L8 L6 s- g4 p: _# g69
70
2 J: `2 y! H  a! E: l71
9 m. o; h/ g$ _9 R: w72
73
8 g) ?& j- c+ Y# W74
; Q8 Q: x9 P, D1 T0 i% _% H75
' |, \, n+ y- L. y! {' M76
77
78
. @+ P0 x  G$ B/ ~) {79
" @0 p( _7 _: X- R) u' K" p( c80
# P( s7 o5 d0 A81
82
' L0 T+ h9 |" W1 n83
2 X2 p* v7 d) t  d% v4 N) b84
& \% @  a1 D+ B; q/ m* H. b. |85
. ?2 `" ]$ x  q0 C2 ~$ ]" ?8 p86
87
88
89
& o0 S6 G* P# N9 U/ _* F, N90
91
92
/ o  r" v2 @* e. v8 E93
94
1 `' x$ p) N, y: ?) D95
96
97
9 E4 V; d- z5 z6 F6 S8 G/ k7 j" y7 n98
99
" m' ^$ a6 f2 [" x4 y( {  }! s, N100
  b( O. r' i2 ]6 b101
102
103
104
6 X4 U. @' |2 L/ W. }/ c105
106
107
; a1 k6 S  N) m# y" N108
# G# z# m$ h# a; ]109
5 H: ]5 N6 S( V. X3 e3 h9 w110
111
112
" g* r$ F- O$ o" R: V113
114
# D$ W& l4 a  f$ D. l115
* v$ x, z! W) [* Z3 ]0 i116
9 t' a2 m  M6 x; t5 q117
' Q  R( e! v3 v  p118
119
  B/ E6 i, C" W; C. t# L120
121
122
2 G9 V* ?8 h# F; n& h, y6 W0 @' _123
124
6 |! n, d# }' q125
126
127
  ?$ T' f: t$ d+ p128
129
7 z0 p( {7 M2 g" b+ }& H130
131
2 E' i8 J. y# z; p" B. [+ u3 k132
$ _+ F" X7 \2 s% V/ [; I8 `133
* l* O6 U9 J% [9 \8 n134
135
" A5 @5 `) N- M7 o; ]! `136
0 ]$ U/ \* `  _. G; K+ K137
138
  v1 `2 E) O2 X. S139
140
5 X% h' ~6 T% k  r141
, L1 d+ E  L5 N6 w8 N142
7 q2 c1 U) y6 d+ a! D5 ~4 o" L143
144
$ J) D& G% E4 C' l145
9 m# l! y; t& p- ~' t3 k1 K7 `146
5 l& x$ A! Z3 Z& O6 N147
! j& p( |: e0 T2 d6 T148
149
150
# t' C" G0 w" U+ f5 e151
; t3 o- Z0 H4 D8 e8 _+ n3 x( k# D152
9 c7 p8 g9 \1 Z& f/ z8 e* I153
+ U0 ^' c( \7 R. X8 \' j/ \. }( l154
- T3 a  s6 Q% U8 A155
! X) C9 I/ h5 q156
/ I. t( n# S( p3 _$ B$ S: s9 c157
158
2 d# Q2 u& L/ v) E* [- h5 w1 _6 X159
160
5 R, `- O2 T& V+ _9 ?- W161
: D& S& l9 z! U- N162
! s: ?; \" F  d/ ^: f, }& d" T+ f163
" f4 I$ o" ~, z% D: R  K164
, `6 s; I: Z- Z+ ]' V165
166
167
2 _1 N6 }- V9 X  k4 l168
" f5 f+ C! I9 s5 n- M/ F: i# O169
170
171
; e9 P0 F& u: N: Q8 C+ x172
8 {7 B1 }9 U- X( V173
每天进步一点点！
1 B) |2 n- {1 j1 G不进则退！
0 w# _0 f: {0 N9 [. k! h

版权声明：
' T0 \/ b; f: q" W6 j原创博主：牛哄哄的柯南
& j, p3 @. p7 @/ Z: @+ \; p博主原文链接：https://keafmd.blog.csdn.net/
————————————————
版权声明：本文为CSDN博主「牛哄哄的柯南」的原创文章，遵循CC 4.0 BY-SA版权协议，转载请附上原文出处链接及本声明。
* Y1 L. n! m8 X9 o5 e3 X原文链接：https://blog.csdn.net/weixin_43883917/article/details/118193663
7 a% D! ^9 w5 H! U* k
; Z3 [' r5 E- X4 W
; a: G" c+ q$ _3 O

1051373629

每天进步一点点！
( o% z3 ^6 y6 Q3 b' Z