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

杨利霞

- e) R' O' u& K3 t: N经典十大排序算法（含升序降序，基数排序含负数排序）【Java版完整代码】【建议收藏系列】
( O, j1 ]: A$ U8 r. J; ?经典十大排序算法【Java版完整代码】
写在前面的话
' s7 r. C% b! _2 q5 u8 H! X十大排序算法对比
冒泡排序
4 ~1 _. t, W4 f$ n" Z快速排序
直接选择排序
$ h( o$ f2 c6 f" R5 s堆排序
归并排序
插入排序
希尔排序
计数排序
桶排序
, l" q( S8 i# z# [. |% n3 N基数排序
' d$ a: r( r" |# M/ b) r7 v完整测试类
写在前面的话
       虽然已经有很多人总结过这十大排序算法，优秀的文章也不少，但是Java完整版的好像不多，还存在某些文章代码存在错误的情况，同时也为了自己练手，决定把所有的写一遍巩固下，同时也真诚的希望阅读到这篇文章的小伙伴们可以自己去从头敲一遍，不要粘贴复制！希望我的文章对你有所帮助，每天进步一点点！！！


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

十大排序算法对比



( |& D1 q8 E, ~7 \  V
关于最后一列的稳定性，我稍微解释下，例如对序列：1 2 4 2 6 排序，序列中存在两个2，如果我们把这两个2标记上（让他俩不同），排序之后，前面的2还在前面，那么就称这种排序是稳定的，反之不稳定。


# ?2 C9 m, |& q冒泡排序
简单解释：
       原理就如算法名字一样，就像水中的气泡一样，每次我都把最大的或最小的放到最后面，这样总共需要n-1趟即可完成排序，这就是第一层循环，第二次循环就是遍历未被固定的那些数（理解成数组左边的数，因为每层循环都会把最大或最小的数升到最右边固定起来，下次就不遍历这些数了），两层循环遍历结束后，所有的数就排好序了。
- ~# u: A1 N- Q+ s       两层循环所以冒泡排序算法的时间复杂度是O(n 2 n^{2}n
2
; Y( m4 B3 G8 @0 p8 f )，是一个非常高的时间复杂度，我在下面的代码进行了优化，加了一个标志位，如果上一次循环未发生交换，就说明已经是有序的了，就不继续下去了，反之继续进行下一轮。
+ I5 Y$ J# o( x7 y# y

* Q' s$ T9 w6 x* I2 h5 ?
; o; u3 _( `" O! Z  G# z5 n1 O
6 m0 ?7 f% A6 n9 s% d: l0 ~7 }. q

本文的图片来源网络，仅用于大家学习，侵权联系删除！（下同）
$ Q4 p1 y( M* Q+ E) ~; v

& Q* E$ h+ j6 G3 B! K0 X9 q完整代码：

! o( x  l: ^( Q. e" k! T
package com.keafmd.Sequence;
+ ^! J2 V# m6 }3 X
6 `5 d: w- }+ c+ R
- P2 z4 S4 ^  h/ ^5 @6 H# V/**
  W* G2 m3 X) j! _; { * Keafmd
*
& g# o% A9 q7 a& ` * @ClassName: BubbleSort
* @Description: 冒泡排序
3 B5 H( \$ C3 Y% k7 ` * @author: 牛哄哄的柯南
& q/ R8 Q4 g8 Z. P1 J; ` * @date: 2021-06-24 10:31
*/
public class BubbleSort {


8 v7 t. I/ `! t; s5 X    //冒泡排序
    public static void bubbleSort(int[] arr, boolean ascending) { //exchange标志表示为升序排序还是降序排序


- ]; ^# E8 j  e9 l9 y) ^        boolean flag = true; //加一个标志位，记录上一次是否发生了交换，如果是，我们则进行下一轮，如果没有，说明已经冒泡好了
) O1 ~, T7 t9 W' ~2 Z5 b
4 Q) o1 W; ^1 W( h  T4 X$ n
$ j9 \% T  V0 [, Y8 k' D# V        for (int i = 1; i < arr.length && flag; i++) { //控制次数，第几趟排序，只需要n-1趟，有交换时进行，只有flag=false就说明上一次一个元素都没有进行交换

- x( W& X2 @0 c
+ F+ J- V* ^* e/ U7 P- w; t            /*System.out.print("第"+i+"次遍历：");
            for (int i1 : arr) {
                System.out.print(i1+" ");
8 M( s$ D4 I5 m1 f. o& A; r            }
  _2 @- A& s/ w  U# z            System.out.println();*/
6 a: H/ }' I& L8 F/ @

) @$ m8 M- B9 [! q            flag = false; //假定未交换

2 t* o7 k0 F" E
            for (int j = 0; j < arr.length - i; j++) {
' H* p9 ?- q9 ]
0 d; D& u) c, q% x0 }& h& K
8 z/ m; j2 n/ F* p; E                if (ascending ? arr[j] > arr[j + 1] : arr[j] < arr[j + 1]) { //控制升序还是降序
, P( X. b+ O, @& |                    int temp = arr[j];
                    arr[j] = arr[j + 1];
                    arr[j + 1] = temp;
                    flag = true;
- c; Q2 _! {4 t* B: D                }
! S+ e4 F7 k. `' z9 Y1 {/ y

5 W2 k1 I. S# U8 q- e            }
! _/ {; [5 e# A4 _0 d; y3 Y, _( O        }
$ K+ E- _4 _! _, w) C  p  m& }    }
4 o. a. \) ?) Z: h! x
; m8 G0 D9 A7 j  @- f
    //冒泡排序 -- 默认不传参升序
* G2 n& `6 f4 R2 ^. X1 K1 M    public static void bubbleSort(int[] arr) {
* o% |3 `4 o' d2 e# f3 c- E        bubbleSort(arr, true);
& Y5 `6 G3 j; r+ W    }
}
1
& X! W+ t5 K/ G2
3
4
' Y/ f+ C& k& K  k( f5
8 o3 T- F2 W) h0 G( F6 C  X4 `6
7
# H# }- L) ~, `5 @! P% Q8
1 S0 e! ^& }% e7 a! i5 g" j2 Y5 c) ~9
10
6 u0 r  b* P( E11
# N: G3 Y: f2 l! R2 j, ^. t12
13
% H0 h; d. {/ [) i# L2 z' U14
15
16
17
18
- ]- I9 [- Z1 S! e4 p19
20
21
" |  h9 f# w* A& P, f9 s2 E22
. H% n0 Z. ?6 c23
24
25
$ C! S. v' p% I5 P7 R$ x( v9 A& Y26
27
28
29
" @6 c. o( W5 X30
31
32
33
34
35
36
; D' D  j! q5 q) M7 ]# b! z37
8 G0 x, L' J5 N38
39
1 Q0 B6 M' x% d) ~4 y40
; f6 Q7 V8 J5 m41
42
43
  P1 e* r0 a% t6 J8 C44
3 i: k* ^2 K/ O+ B1 a45
/ ?' G# {( L/ K测试代码：


升序排序（从小到大）
4 D0 d/ }1 o9 {5 A) x

package com.keafmd.Sequence;
# O2 {# @; Q* l2 s; Z

import java.util.*;
, m' @: P4 ~/ N6 limport java.util.stream.IntStream;
import java.util.stream.Stream;
" b  T* y; i/ b6 W4 N
$ g; B5 I' ?7 a  ?4 ]* j
/**
* Keafmd
*
* @ClassName: Sort
* @Description: 十大排序算法
( r; q0 A8 [" V * @author: 牛哄哄的柯南
* @date: 2021-06-16 21:27
0 F$ k& b5 z2 @" l */
% L' P$ E3 N& }* M, {public class Sort {
    public static void main(String[] args) {
9 A. N! {3 g+ T1 r
8 _9 |8 ^% R* t
        int[] nums = {12, 4, 25, 47, 58, 34, 25, 9, 99, 26, 1, -13, 162, 10093, -66, -1};
        int[] temparr;


        //测试冒泡排序
  T; b6 B! p, [0 Z% P        System.out.println("测试冒泡排序:");
+ @! |/ p* L" w+ |$ Y3 e/ G        temparr = nums.clone();
        BubbleSort.bubbleSort(temparr);
6 n2 {( x6 p+ ~3 @        //逆序排序
        //BubbleSort.bubbleSort(temparr,false);
        for (int i = 0; i < temparr.length; i++) {
4 Y. F. \. p4 G            System.out.print(temparr + " ");
        }
3 K2 x8 f: f% ]. X+ t$ q# L; w% E- @        System.out.println();


    }
}
# z$ c6 V9 U* @: q! o1
* G  g* j5 v4 p0 p1 E7 D2
3
4
7 t2 Y5 {2 W' f) P5
1 F+ ^- c% g! d% D6
+ D# c, R+ |5 ~  v% e- n7
/ o5 c8 B/ H8 G- V( o# Z8
9
10
" a) D  _, ]+ Z; d4 ]$ ^11
12
13
: J: p/ D% k9 D# Y% n$ C  j14
15
16
  s! ^' L' i: L7 K" Y17
, F& M" U# W) g8 k18
19
) m7 E* O2 g5 Y20
# C) N2 M7 G! |21
. W1 v' e# l, a) n22
23
- d- A2 a& w! @4 N2 m* e, R24
! _3 y$ G0 o% H3 A  a25
26
27
28
+ s4 F0 J  [+ E7 R& s8 D29
30
& p- n* v5 A: l" y$ c31
32
33
! t( O1 `) {% I2 Q. K( o运行结果：


测试冒泡排序:
8 r5 g# B, o! {-66 -13 -1 1 4 9 12 25 25 26 34 47 58 99 162 10093
1
2
. ^6 m/ S3 Q( S! g降序排序（从大到小）

5 M/ S" \" Q9 i/ J4 r5 A2 q) \
  @6 N1 K) A7 ^$ |! x$ w1 J3 r. ?//测试冒泡排序
" S& K2 W, t" HSystem.out.println("测试冒泡排序:");
temparr = nums.clone();
5 F! p) S( P8 j; ^% \8 YBubbleSort.bubbleSort(temparr,false);
for (int i = 0; i < temparr.length; i++) {
    System.out.print(temparr + " ");
3 N. ^+ Z. [9 R8 |0 w$ W" v! j# ]}
System.out.println();
1
2
, q5 e( a# @/ _" p8 D5 I; E4 R+ x3
6 F' _8 D. b3 u4
* y/ F% e5 q( Z# J. x$ n5
" q3 I- M* q$ R9 b  m6
+ Q  w" {5 |% F8 [2 X7
8
1 w4 f- @: T3 ]( K- z0 t7 K/ {& T运行结果：
" ]" |* Y; o8 ?9 L! C$ Z
3 K% i) C# T( f- d0 M5 D- Z
测试冒泡排序:
10093 162 99 58 47 34 26 25 25 12 9 4 1 -1 -13 -66
/ r& t8 h% ~. S1
( R2 R% L+ ?: {# t+ L* V' E- X2
% g/ k4 c) B( |6 s: S8 J下面几个算法的测试也就是换了下类名和方法名（换成相应的排序算法），如果想降序就在数组后面传个false即可。我就不一一复制了，我在最下面给出含所有算法的测试类，需要的自取即可。
5 U) w7 M/ q" C8 G! P
) J- _( l) a. i0 R  r
: L; o$ ~  b3 e. g" ?( L# g8 R5 b快速排序
简单解释：
快速排序就是每次找一个基点（第一个元素），然后两个哨兵，一个从最前面往后走，一个从最后面往前面走，如果后面那个哨兵找到了一个比基点大的数停下来，前面那个哨兵找到比基点大的数停下来，然后交换两个哨兵找到的数，如果找不到最后两个哨兵就会碰到一起就结束，最后交换基点和哨兵相遇的地方的元素，然后就将一个序列分为比基点小的一部分和比基点大的一部分，然后递归左半部分和右半部分，最后的结果就是有序的了。

/ ^; g( d; `: l- j+ g2 [

4 |- p6 }  P- v. f4 ~/ c( B


完整代码：
' W- X4 T! G* H% N  h
- [& i8 h: O- _4 E' @* X1 ^7 o$ u
package com.keafmd.Sequence;


/**
! H1 y$ N, F% p * Keafmd
! h. r/ z# `3 s% A5 E1 Z7 i0 l. W+ b *
* @ClassName: QuickSort
( n9 h- _* G' p" [7 |# _. x * @Description: 快速排序
* @author: 牛哄哄的柯南
* @date: 2021-06-24 10:32
5 o$ V2 B% M2 Z* E2 C" V4 d */
$ W) y% d4 K3 Bpublic class QuickSort {


    //快速排序
    public static void quickSort(int[] arr) {
        quickSort(arr, true);
. r* @# D8 k/ q7 B- }  ^+ E  j7 S    }

  E' ^7 K7 ]) e2 q3 G
    public static void quickSort(int[] arr, boolean ascending) {
! h3 |1 B7 n- j" ]. D1 A        if (ascending) {
/ c7 K5 s$ ]" o. V            quickSort(arr, 0, arr.length - 1, true);
        } else {
. j% e" s; i1 x$ G$ v: U            quickSort(arr, 0, arr.length - 1, false);
( A. ]9 i. Q" \. [4 S* Y        }
. c  t. D' G4 S8 z    }
2 U! X! j5 _% C/ X
$ f. L! g6 R- I& |* e+ f! ~
    public static void quickSort(int[] arr, int begin, int end, boolean ascending) {
        if (ascending)
1 b% z( o% z( ~5 e            quickSort(arr, begin, end);
6 `' J8 I  v, L' H        else
6 `' _  n  ~6 ^- [            quickSortDescending(arr, begin, end);
  B. ?9 S% \& P" z' h8 W; U/ q5 f& Z    }


* k! [5 n$ B  P. T  y( Z    //快排序升序 -- 默认
    public static void quickSort(int[] arr, int begin, int end) {
        if (begin > end) { //结束条件
            return;
        }
3 u* r1 ]! C# y) U" B        int base = arr[begin];
        int i = begin, j = end;
6 J- c% V: E" Y; b% i        while (i < j) { // 两个哨兵（i左边，j右边）没有相遇
8 o' N$ M2 W+ \: ]            while (arr[j] >= base && i < j) { //哨兵j没找到比base小的
6 B# t) C! [: g$ q& r" H) C                j--;
8 _# D. n, {" U! Z) J/ r- r            }
! C. T3 _$ Y1 j' b8 {' c8 [7 K. l            while (arr <= base && i < j) { //哨兵i没找到比base大的
, t* x7 I/ a( v- `) q+ t                i++;
            }
7 l. n5 J9 U$ |& E& a; r            if (i < j) { //如果满足条件则交换
! [% m5 L: @5 Y* _* m, z" x                int temp = arr;
' |( K' b' S$ x# Y- B                arr = arr[j];
                arr[j] = temp;
+ E  Z2 n- ?- O+ B6 A: |& v0 [& K            }
/ }) d3 _2 ]. S4 f3 S

/ M' a+ x' b, S7 K% p        }
4 x) E( x/ [6 K; h        //最后将基准为与i和j相等位置的数字交换
+ ?# P# D/ o) l' _" C( O        arr[begin] = arr;
        arr = base;
        quickSort(arr, begin, i - 1); //递归调用左半数组
        quickSort(arr, i + 1, end); //递归调用右半数组
$ v8 @2 d- g$ I: U
3 k. Y, w, @# u0 T# c! r
. q7 ]- I+ [9 B4 J/ v6 [& U    }

) _+ _5 L: b! f% ~+ _( z; r$ o/ |/ |- P
" E' g( o' v3 N& f    //快排序降序
+ Z: g: n+ A0 l2 F    public static void quickSortDescending(int[] arr, int begin, int end) {
3 \/ s5 s* {+ U: q" U; {        if (begin > end) { //结束条件
. K! o" s! a6 z& }" f4 C: p            return;
        }
& L3 r3 T3 v( s. h        int base = arr[begin];
3 V4 L6 z% h: [8 `2 {        int i = begin, j = end;
  L* X, @. Z$ L! e  g* |        while (i < j) { // 两个哨兵（i左边，j右边）没有相遇
, [2 f% M& p) {2 d" ?- o( S$ ^            while (arr[j] <= base && i < j) { //哨兵j没找到比base大的
$ e/ p! k1 F6 R9 p  J                j--;
            }
- F. ~; \3 K8 k- m% Q$ g            while (arr >= base && i < j) { //哨兵i没找到比base小的
                i++;
" e$ y  w4 `, d            }
            if (i < j) { //如果满足条件则交换
                int temp = arr;
* |+ j' `5 ]$ t; x                arr = arr[j];
, k; R- x% w7 R                arr[j] = temp;
            }
8 l: Y  t# ~! C& F6 \" F

        }
: I! k# I: b: y) N* O/ `        //最后将基准为与i和j相等位置的数字交换
        arr[begin] = arr;
0 R! J( z5 @$ p        arr = base;
        quickSortDescending(arr, begin, i - 1); //递归调用左半数组
        quickSortDescending(arr, i + 1, end); //递归调用右半数组

1 W) p5 q2 x) y
    }
( T% r7 _% H6 I" A' E) ]' C9 B; F
" L) }# K. @) m6 I
; K* t! V  o& l}
1
" a5 N5 u: ^) j* F' j2
3
' b" U& _& q8 s4
5
6
7
/ A0 N8 ?( ~% V! P- @2 o8
9
10
2 X8 `' R" k5 Q6 f' c11
12
; j, Y/ V! ]* T  F! C* u13
14
! e4 z" u7 V5 c5 O* m15
7 S* q1 K4 i1 l" W: z16
17
0 G# F# V5 p8 W; A( z4 F18
# e/ N3 w  Z6 i1 ?/ N19
20
  x9 L& w! R5 l+ F5 d21
22
23
24
25
- r9 @. z% \; V" k. }' G8 P& p26
27
28
5 R0 ~# Q" a* W( h' ^' U29
7 g  g# g3 G0 O30
- M. C5 Z) ?; R& n31
# t, H1 F# l  P9 s1 b8 u# A7 ?32
33
9 o7 L/ k7 ?! j34
8 g! m" u- N: e) ?8 N35
7 t  I( i& `$ g$ |5 \$ D- y36
37
38
39
40
$ p/ o+ ~, E% v8 [41
42
1 O: O% n' c5 D4 V4 Y43
1 X* w4 K9 J1 p: F& ?- ?! \44
45
46
47
3 s' q% V2 r7 [. N+ Z48
49
50
* s$ p2 w6 N% f: L  U51
52
53
54
55
8 z" W+ u+ N) z8 m7 q! ]56
57
* Y7 V  Z& I, a, J58
59
60
61
62
63
64
65
66
67
68
69
70
' ~8 Y/ h2 y# J2 h7 b71
72
" r7 f( r: n9 S& g+ Z73
" |4 Q; \8 }" l2 b9 T! b! i74
75
76
# z4 x4 X6 X/ a7 e* u" X) m8 F77
, F& p. T' E- X78
! d' l4 e6 q* h  `79
80
81
0 [+ ]- d& g9 S, ~82
( j* l. x4 Z  ~' T- J. C% r83
84
+ N/ R4 ?( \! }/ }' ]' B3 z85
86
+ V; J+ m0 p9 h" u- I! j87
88
( z# ^1 j8 u2 Q$ D5 t89
' O1 e1 C! \9 K+ m90
' v; w: C7 x- ]9 Z5 T. p9 C* a91
直接选择排序
简单解释：
. ^1 r# _" b! v; b1 X  a数组分为已排序部分（前面）和待排序序列（后面）
第一次肯定所有的数都是待排序的
$ Y) A) I& ]7 z) Q% [从待排序的序列中找到最大或最小的那个元素，放到前面的已排序部分，然后一直找，不断缩小待排序的范围，直到所有的数都是已排序的了

+ u  F, V9 v2 ~. Z* n/ C3 _. D, z: r
; n) P2 z% P: n, b- L

7 o: I/ O2 v0 [% f9 {

& t. ?& T& t  s6 X完整代码：
% n* X0 A" F( f: {9 \5 F& b6 g
. f2 F, Z3 o% ~* y8 k
$ b% L7 W! n0 T1 b) fpackage com.keafmd.Sequence;


% Q$ Z8 h0 Q# W; v: a/**
. ~1 r2 [/ d- @; b1 j * Keafmd
*
* @ClassName: SelectSort
* @Description: 选择排序
  O# O9 H* G9 [  | * @author: 牛哄哄的柯南
* @date: 2021-06-24 10:33
*/
public class SelectSort {

3 j' P/ ?3 q: U% p, ?
    //直接选择排序
    public static void selectSort(int[] arr, boolean ascending) {
* L" {3 Y' E2 b1 m  [        for (int i = 0; i < arr.length; i++) {
/ i) U0 B, T" Y/ f            int m = i; //最小值或最小值的下标
            for (int j = i + 1; j < arr.length; j++) {
( P& b. u$ B4 s" V                if (ascending ? arr[j] < arr[m] : arr[j] > arr[m]) {
$ k# n* t1 x. E, v0 }                    m = j; //找到待排序的数中最小或最大的那个数，记录下标
0 _. D; K, q% r1 s; D                }

7 w/ K1 I% W- v3 q
" C: I) w1 f: D9 G! M            }
& t+ ]# r$ ?  W1 K9 t5 V            //交换位置
3 i5 V2 W4 {- B) V            int temp = arr;
            arr = arr[m];
; p/ v! p& m/ k0 d            arr[m] = temp;

# s; z; n5 P' n& @
6 i$ w! U7 c6 z+ |/ g' q" T) C9 ^        }
    }


: x6 X) l) H% |  h, N! ]    public static void selectSort(int[] arr) {
        selectSort(arr, true);
, N. t; t& B+ S    }
5 v% |: z. ?6 y- G' Y}
, _5 J2 @* c' U9 x1 a1
2
3
4
  y% E: Q0 }% e- o# b* S& K: ]5
6
* L- S2 k; V5 w9 Y7
8
% ^1 K& s0 w( X$ ?7 ~2 t9
10
11
12
13
" e* |1 c% u- y6 f1 [2 S' V14
15
16
17
/ q. `& ~; p* B) o18
19
# m9 ]6 B# ?  q5 i1 ~/ s# Z20
21
22
23
4 V  z* D/ M% }( K# ~3 X& a24
25
$ s. x- ^- _8 {& e/ ^5 `( }# L26
. u4 J, w# ]) ^- I27
: |6 f4 b# T" {/ z$ G( V  D28
29
30
, i. |, w* v* `: R- N( o% k) i% {31
32
: v  q/ Z3 z3 r/ Z% C" L33
34
, \# N4 i* t% }6 {. u* {" I堆排序
先理解下大顶堆和小顶堆，看图
大顶堆，双亲结点的值比每一个孩子结点的值都要大。根结点值最大
& z, u9 v, `2 U& L+ ^9 y小顶堆，双亲结点的值比每一个孩子结点的值都要小。根结点值最小

( [7 W/ r$ H! U; C$ D# @  Q


简单解释：
$ k# o! X7 R8 [! V% l构建好大顶堆或小顶堆结构，这样最上面的就是最大值或最小值，那么我们取出堆顶元素，然后重新构建结构，一直取，一直重新构建，那么最后达到排序的效果了。
1 [! `% Q7 K( V6 ~$ k0 r; i$ C; [

4 ^# a& I2 t0 m& l4 W% o* [
; O. v. J4 |; J5 {( f4 r


完整代码：
+ l* h4 U/ ~0 S* M% P3 F) E0 P
+ T0 G7 j" F* T: z
' x. X! x  x0 i" Z6 apackage com.keafmd.Sequence;
3 V: w6 J. n7 J
) ?7 ~2 R0 S9 n6 {' k( a
/**
  u; c; U+ T) W. J/ R) ~& F * Keafmd
*
* @ClassName: HeapSort
* @Description: 堆排序
* @author: 牛哄哄的柯南
, W) o) R# @5 o * @date: 2021-06-24 10:34
' j0 M9 m5 A$ c  w  Q' f  S */
: b4 k( R7 q  ?public class HeapSort {


0 P6 ^+ i" M+ T  Z' h    //堆排序
    public static void heapSort(int[] arr) {
        //对传入的数组进行建立堆，这里默认建立大顶堆，进行升序排列
        heapSort(arr, true);
    }


; [4 X6 N* z5 u2 R- V2 b    public static void heapSort(int[] arr, boolean maxheap) {


        //1.构建大顶堆
0 K; [9 Y% Z1 W- O. ?8 n  O* ~        for (int i = arr.length / 2 - 1; i >= 0; i--) {
            //从第一个非叶子结点从下至上，从右至左调整结构
% L8 g9 e2 b% [! w& {            sift(arr, i, arr.length , maxheap);
0 c4 T( n2 Y% u6 Y        }


        //2.调整堆结构+交换堆顶元素与末尾元素
        for (int j = arr.length - 1; j > 0; j--) {

+ q, z% ]" C1 k( ?) r( T! Z, }
: d7 f1 X; p, z4 p7 Y            //现在的数组第一个就是根结点，最小值所在，进行交换，把它放到最右边
1 f4 g3 ~7 U) u; R# _( {4 P            int temp = arr[j];
            arr[j] = arr[0];
' S9 j: W+ S& N" w            arr[0] = temp;
. F* V: s- I# c( p; E/ ~
% }  s& u9 ?" w+ L( j+ m! T8 }* t
            //重新建立堆
3 O7 [  B0 W! p            sift(arr, 0, j , maxheap); //重新对堆进行调整
        }
    }

# p: \! P8 N  b3 @
  [( b  C( s9 ~; ^9 D1 [    //建立堆的方法
% l8 `5 [. d# Q2 d# \% [/ j    /**
! K( h8 k7 l) h# B     * 私有方法，只允许被堆排序调用
     *
1 l7 {: G; D: @: E$ P     * @param arr     要排序数组
     * @param parent  当前的双亲节点
; N, p0 K; v; Y1 H/ i& C     * @param len     数组长度
2 y6 r6 X2 p9 b8 ^     * @param maxheap 是否建立大顶堆
     */
    private static void sift(int[] arr, int parent, int len, boolean maxheap) {
4 F" l+ ~* T2 p" `. E

% p2 u4 L; A1 Z( N* k        int value = arr[parent]; //先取出当前元素i
  a& R9 X# V' _, \( I
( `/ l+ Y  i3 a8 c
! T% E7 A, v9 i# g        for (int child = 2 * parent + 1; child < len; child = child * 2 + 1) { //从parent结点的左子结点开始，也就是2*parent+1处开始


0 x/ K& R+ {- X- r            if (child+1 < len && (maxheap ? arr[child] < arr[child + 1] : arr[child] > arr[child + 1])) { //如果左子结点小于右子结点，child指向右子结点
2 {7 t" n8 W8 l, x                child++; //右孩子如果比左孩子大，我们就将现在的孩子换到右孩子
            }
0 D$ J7 n0 ]5 t* o# D+ W

$ M+ @/ g# |- @; v+ ?            //判断是否符合大顶堆的特性， 如果右孩子大于双亲，自然左孩子也大于双亲，符合
            //如果子节点大于父节点，将子节点值赋给父节点（不用进行交换)
            if (maxheap ? value < arr[child] : value > arr[child]) {
8 _- c5 H* H% A3 O( a                arr[parent]=arr[child];
, z" n8 @) V' ?& b( J                parent = child;
% E# i+ b8 d" W, A- }5 y            }
9 A5 Z8 k; q+ B7 p3 g. x( ]            else {//如果不是，说明已经符合我们的要求了。
                break;
1 e2 F7 X2 ]* i            }
        }
        arr[parent] =value; //将value值放到最终的位置
' a4 ^; d' f) B2 i, q. j# b. p- W- W

  A4 @* k7 p) x% n0 u
4 k7 B! p* v% w
    }
' v  H& D& B+ f: W5 e

}
1
* ~' d6 z4 ]; ?3 r' B, h. K5 p5 J2
3
4
  V) X  J" Z9 e: Q5
6
7
8
9
6 w) q% g( [6 L10
11
12
13
14
15
16
. h) P$ B" _* T. F/ |17
18
19
20
9 f* `4 o. Z. d# D$ j! A21
/ i$ V' F2 N  [; V3 f) J# @22
+ S6 t- W1 ]% D8 w23
+ k% h7 g/ S) X24
25
26
27
28
29
30
31
; x. ]+ b' w8 g: }, b: L32
33
! K- O5 o5 b+ T# }9 y, y34
6 v, z6 s8 y6 N- t; g9 s, e35
; V4 o0 R  J, O4 U0 \5 r( `36
# ~. K1 _8 p: j4 s+ w8 m& s37
1 q( @  o: q' K  b38
39
40
/ k" ~" n0 t5 n+ k41
42
43
; i$ d' y6 z1 W' D6 b44
6 g; H; O8 V2 i9 g! m+ \45
46
47
8 T* _, \/ o0 x4 Q48
49
50
51
52
$ L6 @& o3 s2 {% s$ U. f2 Y53
54
55
  i( \1 o- G# {' M56
57
58
59
60
  Y' C4 J5 j3 \- c61
" y, f9 f  x; b62
63
3 H( \2 v3 {1 K- G( {( [) E64
: N: w+ K- e) Z/ \; V* a5 r65
; C  t2 g) B' Q  G66
67
4 Z" ]9 ~% j' W2 T68
+ d6 T- r' R! A69
70
71
' D$ L, O8 t& G# g2 ~# n/ x72
3 w- U  I3 Z# H; B# m- O73
74
归并排序
简单解释：
7 M0 C1 Z% K; q% Q4 a3 Z# F该算法是采用分治法，把数组不断分割，直至成为单个元素，然后比较再合并（合并的过程就是两部分分别从头开始比较，取出最小或最大元素的放到新的区域内，继续取两部分中最大或最小的元素，直到这两部分合并完，最后所有的都合并完，最后形成完整的有序序列）

5 Y: |# d. W" _" l
; C6 a  {6 y) B# _- s
6 x2 b+ P3 v% R# q

6 B5 H1 @! G* e6 A2 d+ f9 v/ g
" A( ~0 w' b& P1 e# \; E完整代码：


3 S1 ~) L* |& e7 Kpackage com.keafmd.Sequence;
$ }( N9 {  i: b3 ~
% Q0 s  g  Y& b1 u9 D' H6 n
/**
* Keafmd
# A* d# A2 ~0 t; E *
* @ClassName: MergeSort
* @Description: 归并排序
* @author: 牛哄哄的柯南
: h2 Q4 j2 I5 M6 I, {+ \0 R2 A3 k * @date: 2021-06-24 10:35
! i: E! s' S0 C8 W6 ]$ f */
public class MergeSort {
' a4 r  ?( q. L6 R& p: g! l* n

" q7 y% v  d' F6 e% B    //归并排序
    public static void mergeSort(int []arr ,boolean ascending){
        int[] temp = new int[arr.length]; //在排序前，先建好一个长度等于原数组长度的临时数组，避免递归中频繁开辟空间
        mergeSort(arr,0,arr.length-1,temp,ascending);
: R( {5 J+ ]4 x) W! Q    }
    public static void mergeSort(int []arr){
% R& j$ t" W. d# x8 N7 C        mergeSort(arr,true);
/ y- Q( g( k- t$ Y, ^: n    }


( B; D. o  _6 j) y) H- V6 {% h    /**
     *
     * @param arr 传入的数组
* N+ B: l, Z7 `' E* M5 |     * @param left 当前子数组的起始下标
2 t; E1 x2 }% c% d  [6 H9 {! r$ S     * @param right 当前子数组的结束下标
     * @param temp 拷贝暂存数组
     */
( |5 {: S, Q! j/ o/ o8 F    public static void mergeSort(int []arr,int left,int right,int[] temp,boolean ascending){
        if(left<right){ //这里是递归结束的条件，我们是对半分，那当left==right的时候肯定大家都是只有一个元素了。

7 B; m6 \9 q' T; t8 A" N! j6 q
, g  L3 }* \; g3 z            //对半分，比如总长度是10，left=0，right=9，mid=4确实是中间分了，0~4，5~9
' g* k* u1 r( G! K            //当长度9，left=0，right=8，mid=4，0~4，5~8
+ S6 d8 O2 z1 j3 |6 S: x8 [/ d            int mid = left + (right-left)/2; // 防止越界的写法
            //int mid = (left+right)/2;

0 |+ k4 E4 l) V0 e& G1 q# y
: `# r* `- m& x. Y8 Y" O            mergeSort(arr,left,mid,temp,ascending); //左边归并排序，使得左子序列有序
            mergeSort(arr,mid+1,right,temp,ascending); //右边归并排序，使得右子序列有序
- S+ l- z+ W0 s3 X* U

            merge(arr,left,mid,right,temp,ascending); //将两个有序子数组合并操作
        }
    }
5 t! [6 G9 i5 H$ y  G7 z2 R
1 s2 t. N5 g9 V# c; R
    private static void merge(int[] arr,int left,int mid,int right,int[] temp,boolean ascending){
; u" O% k( {  o3 ?/ Z5 V        int i = left; //左序列起始下标
        int j = mid+1; //右序列起始下标
9 u" E; O: F* E1 ?7 F( o* [        int t = 0; //临时数组指针
        while(i<=mid&&j<=right){
            if(ascending?arr<arr[j]:arr>arr[j]){ //比较两个序列第一个元素谁小，谁小先拷贝谁到temp，然后对应子序列下标加1
                temp[t++] = arr[i++];
$ q9 C8 x  V, w; J2 L6 R            }else {
                temp[t++] = arr[j++];
            }
( t! m- Y8 Z9 a4 K6 x8 N0 r        }
$ e) S' V! b$ Z

        while(i<=mid){ //将左边剩余元素填充进temp中——左序列有一些数总是比右边的大的数
            temp[t++] = arr[i++];
        }
- G& T4 N- L: G0 f

        while(j<=right){ //将右序列剩余元素填充进temp中——右序列有一些数总是比左边的大的数
) g: O  R# e6 b8 d* E            temp[t++] = arr[j++];
( i$ [  |' c: I$ j9 M* X6 U% S* j        }
4 ~, Q; S8 E& d8 Y+ u7 G) |

        t = 0;

  t( |' ]; F5 Q- c5 U/ l+ x. B! @, g
3 y; u& S) ^, k& U! B        //将temp中的元素全部拷贝到原数组中
4 H. Z& z" R( P8 s* I/ ~" a        while(left<=right){
            arr[left++] = temp[t++];
        }
4 K; R  U* o) s0 F  \5 d, N' M9 c
  u  W! G% l% |# K$ A
    }


}
) \' `; J# F- S3 E1
9 K+ M* C! z# h( [$ Q& u2
3
4
& C( b- {2 j3 q* \; x8 A5 m5
0 h1 m2 E9 D: l: d- P: N! c6
7
$ E8 b- g- [1 G" L" u) \6 Q3 c3 w8
* |" u9 ~5 U$ L7 ~4 x# D9
10
11
- S1 y. s. H! j) [12
/ j1 [, Q5 b0 ~13
4 x' y4 [5 C7 j. c# k14
15
16
( `; i$ {9 S* ?1 `, Z17
- P% s) @7 B% E18
19
20
21
1 E* V' a# z+ O' U22
23
+ e9 T, d% a( \' U. ^9 o7 H24
# r) D8 K: p/ g  @- L6 \- A25
26
27
28
1 V" H6 {* O4 b& K29
* Q0 {% e; F4 ?2 h& M. M30
2 n# g) s) k- _31
32
33
% u- K- P& P) i34
35
, M- H9 ]7 i8 r36
37
2 q" r0 L2 d  t38
39
4 V6 s+ K& W. U  n$ ^$ y40
' O" C: H9 o0 O  C41
42
) c) ?- I$ O3 ]43
$ }9 o! m/ K+ `! T- _* {44
45
# U9 p+ E; C! d; j' S46
/ [& M+ I, R8 ]' T0 v- b" b47
48
/ \$ D. [9 U; i5 ], Z49
  R' Z3 X. Q+ b" G50
51
7 B+ a# ~& a$ a' z52
53
3 i6 s% K. v' V# o( I/ q54
1 X) V' [( G% B, e6 ^55
56
57
  E: l+ Q8 [# E# u6 I1 k58
1 F( b2 F  @1 g' a59
60
' G4 ]* C. o8 y: P  f61
3 r5 y# U! U. W7 ]62
63
64
. Q3 Q& q  f& y/ a- S5 s9 G65
( J/ E& H! Z0 [* V66
67
68
) z5 I9 a5 w) c; |% S% O9 F4 w3 H: J69
% p/ n0 c5 e, M70
71
/ J4 @8 b: b; ]  Q4 [5 ?! g6 h72
; _* P5 c+ ]  h73
插入排序
$ p6 J1 [; s& t1 J简单解释：
最简单的理解就是打地主时我们拿到牌后的整理过程，从第二个牌（假设我们拿起来这个牌开始比较）开始，（说下升序）从后往前比较如果比前面的那个牌小，就把牌往后移动，直到找到一个合适的位置（这个位置的前面的那个牌不比这个要放下的牌大）就把这个牌放到这个位置，慢慢的前面的部分变得有序，直至全部有序即可。

% g' N9 @  I) }9 e3 o1 {: X


' v; h# [, V' P( Y# y" D( g

完整代码：
2 W0 V. k' Z2 N, N- ^% n
* S. i) Q0 I. ^$ K6 r& ~" H+ u
package com.keafmd.Sequence;
7 a% I& W  ~( S

/**
+ U3 @- t5 M) F! I. q/ e) [4 ~; ]$ g) R * Keafmd
*
# t6 c' ?$ `5 p* i1 J7 U' O: L. s * @ClassName: StraghtInsertSort
* @Description: 插入排序
* @author: 牛哄哄的柯南
* @date: 2021-06-24 10:36
*/
: Z5 b0 u8 u; q( c+ Y( E/ Y- xpublic class StraghtInsertSort {
    //插入排序
& z8 {& D- Q5 ]  }7 F! X    public static void straghtInsertSort(int[] arr) {
% a8 S( Q5 T) ^" [5 ^        straghtInsertSort(arr, true);//默认进行升序
9 K" V6 P8 o, p3 J4 l9 X( s5 }2 h    }

* m2 T/ o# L. @% n8 u" R
( q+ P- u" C: ^6 {& h: Q, r    public static void straghtInsertSort(int[] arr, boolean ascending) {


        for (int i = 1; i < arr.length; i++) {
4 F5 {' z: U5 }( ~            int temp = arr;
6 u! |! y& u" D- m            int j=0; //这就是那个合适的位置
/ m( ]( \) `: d            for (j = i - 1; j >= 0 && (ascending ? temp < arr[j] : temp > arr[j]); j--) {
                arr[j + 1] = arr[j];
2 s* o4 e- Q0 v5 V            }
* v$ i+ y+ Y- M0 T            //把牌放下，为啥是j+1，
% t% G, _" c$ d- J            //是因为上面的循环遍历到不符合情况的时候 j是合适的位置的前面的那个数的位置
. C5 z& K8 V( ]4 w* S            //有点拗口，但是就是这个意思，看图方便理解下
3 u$ w1 b) s4 B/ Y4 Y5 S" x7 ?            arr[j + 1] = temp;




        }

1 n6 \, T& M) B! C- v; V
    }
+ h- [# _9 A5 {5 J1 [}
1
2
3
6 y% ]$ t' S6 W( c! M2 f4
5
6
7
8
9
/ r# }- f4 Z1 l8 o! K: P10
& ~7 H  Q9 i0 V7 F" b11
$ `) C5 R3 Z& B12
13
14
15
0 D5 M, b& ?8 p# g16
17
18
19
20
; E7 t3 ?3 x9 R, v# h21
22
23
. C3 n/ H+ P6 F7 ]8 l% A3 j24
25
26
27
28
29
30
) `8 l0 Q3 L$ f0 M9 R! b31
1 k+ r9 o; o& c7 ]4 I# a, W0 P( C& H32
33
) f' t2 G1 b+ N/ }! d0 r. [34
希尔排序
简单解释：
7 E6 C3 F1 m' z6 t; ]0 p希尔排序是插入排序的改进版，我们理解一个叫做下标差的的东西，也就是下面那个图中的增量d，初始下标差为arr.length/2，然后继续/2，对在同一下标差（相当于把这几个数单独拿出来了）的若干个数进行插入排序即可。

9 q# y& _5 C2 r2 ^

6 w6 ^3 e2 K' r
6 o  m  t6 L9 s- Q; B' S3 a0 y
4 }+ m6 v. R: ^. U$ F
完整代码：
. U) |4 [" U) v; m& W% Y: C

/ H* D) ?8 k$ R& m5 apackage com.keafmd.Sequence;
$ j& r: j" m+ c: w/ o

1 }7 [* q; t( F/**
8 ^: j' J1 W% V7 n( G * Keafmd
2 r. E. Y; c8 Q# q *
: r7 q! K$ g. d/ L! x * @ClassName: ShellSort
$ o- Q/ ?: L9 c. i2 l; B( w * @Description: 希尔排序
) m- b7 K! O5 I7 X' c7 d+ B3 c- B * @author: 牛哄哄的柯南
* @date: 2021-06-24 10:39
*/
/ M( ^6 x, p- J% Y) h8 v! qpublic class ShellSort {

" L- J7 I6 b( C# S! ]  `
    public static void shellSort(int[] arr) {
        shellSort(arr,true);
7 w$ s" ?/ Z; `' o* |    }

9 ]0 |# P2 q! V$ o* y* _
    public static void shellSort(int[] arr,boolean ascending) {

* |6 A0 x3 r1 t0 k
        for(int d = arr.length/2;d>0;d/=2){

3 G3 O/ {. t# c# N7 I6 I* R
            for(int i=d;i< arr.length;i++){
, T0 r' ^: F, c* h; ~2 ^                int temp = arr;
0 \& h/ h' J5 F$ o* n                int j=0;
                for(j=i-d;j>=0&&(ascending?temp<arr[j]:temp>arr[j]);j-=d){
                    arr[j+d]=arr[j];
                }
                arr[j+d] = temp;
            }
. A1 o5 d$ W! I2 \        }

$ S+ C  E8 e: R7 s5 s3 D1 _
    }
}
1 @) n" e/ L+ t. K  ?" x1
2
3
4
5
* o1 ^( }0 D: }) U6
7
/ K$ w# k# G. [9 R5 i$ W9 f8
2 v: q9 f/ H( m" o7 W" r9
& x3 \" Y; f) i3 \/ k8 v! y- U10
11
" B2 i$ {, s5 Q6 A" m! R+ Z12
% ?+ }3 V* b, o( v* V13
14
+ T2 m$ I; Y- V3 E0 ]# M$ J15
16
/ ]7 ]  Q1 E- }& w17
18
* a/ y* g6 \3 z! J0 l0 Q8 O19
, v# L# b" `. Y, T; \! y20
& y1 q, J/ S" U! Z# `4 N$ t! _21
22
7 I, b* t/ X5 h- w  B% {5 a23
) e8 ~7 A' y/ O24
( e- [( z5 P# l5 J% `25
- o" A! s2 ^/ o4 h( r26
' ^; K6 H9 {5 G/ \27
% S4 o% M0 _6 q5 D28
29
: w' q- S% c! P: e8 S3 n30
31
/ J0 ^" V& Q, o- J# M9 m! H32
计数排序
简单解释：
, K/ h( q- d, _2 Y( x9 V8 y( ]) l, ]这个排序算法看名字也很好理解，就是就是额外找个数组来计数，然后在这个数组从小到大或从大到小把数取出来即可。
+ {/ C! t; H, \% ~" w, B/ T  Y; b



3 J* F+ A4 ?. S1 t* f
) b) D+ P  `: q8 q0 Z3 Y
! F/ I$ c' q" Y. n完整代码：
2 k- V. a  y! W9 C
4 o$ R6 n# }8 Z" {+ q1 g7 S
package com.keafmd.Sequence;


/**
* Keafmd
*
* @ClassName: CountSort
( x& V# h" D0 p) x * @Description: 计数排序
* @author: 牛哄哄的柯南
6 M6 G# m" |: U * @date: 2021-06-24 11:31
*/
public class CountSort {


    public static void countSort(int[]arr){
        countSort(arr,true);
    }
- E& W1 w2 o$ M2 t
- f. K8 J0 @. H, f# p. r! q
+ e) O( D' v: f7 y, m, T    public static void countSort(int[]arr,boolean ascending){
+ _' B8 q8 J  {. v6 z5 j$ C" p        int d,min=arr[0],max=arr[0];
6 e3 Z' V$ ~" {( O. l0 j4 f
/ k, {$ l( e6 E
5 l- n& V  |: C) C: n        //找出最大、最小值
+ f0 [2 p0 s, a, C2 g. Z* f        for(int i=0;i< arr.length;i++){
" {# A. l5 N4 C  r: \7 Y            if(arr<min){
                min =arr;
/ [7 `0 X+ F( t$ B) _9 j* i5 t* Q            }
4 ?3 F, c2 p% Q" I) Q  k            if(arr>max){
                max = arr;
; n/ `8 n" b; s/ g" i# j, l9 l            }
0 d' k/ r9 K; A' q# A% b& w# u        }

, S0 C# h% t: i" b9 x+ t
        //建立一个用于计数的数组
: S  _* t  s" d: U( R& i  _) S        d = min;
        int[] count_map = new int[max-min+1];
8 C8 D3 G# v( C4 o0 r2 c/ z6 [        for(int i=0;i< arr.length;i++){
4 z! u5 B+ w% B/ w! f            count_map[arr-d]++;
5 N4 y6 M) V* [% P1 u        }
% J0 d9 |' j+ f# }. a" M0 W9 K

# [) w% J% e, `. ~' S" O        int k =0;
! F6 f# T* k) I& c( t/ ~        if(ascending){
5 ^( L; J5 d# b9 r            for(int i=0;i< arr.length;){
3 X! C5 r: G  {: Q) Q                if(count_map[k]>0){
                    arr = k+d;
- s  s) n- a% v1 S. `                    i++;
) y4 s! ?" m' Z9 X5 m6 @7 I                    count_map[k]--;
                }else
                    k++;
, S$ [5 F6 s5 \# d0 P, P            }
) T' w2 W: k! C; d, X! v8 |) b        }else {
            for(int i=arr.length-1;i>=0;){
  O8 L) ?1 p9 b                if(count_map[k]>0){
                    arr = k+d;
                    i--;
* X  M  {2 j: ]0 d% k                    count_map[k]--;
                }else
4 c9 C8 x0 q3 b4 c+ i! }                    k++;
9 |- ]/ j; K4 \5 o; h- |" _            }
+ E  U7 ?+ L6 `, z        }
; |& ?9 f5 X/ }
7 ~" ?" ?0 J; [, |* _
    }
6 t' Z; q& d& c4 i0 _6 |}
1
2
4 J  |3 f, r5 C1 F; @6 d3
4
2 B& o; @( I0 z0 _5
' f6 F3 H+ \7 v5 b  U6
8 `- Q" a, O1 ?: F' H% Q7
8
- d, z+ ~/ u% H) g9
10
  p/ `) w, ^+ \2 Y4 o11
12
13
14
( b* m4 V8 o3 r/ H0 n2 |: |15
16
17
6 s6 [7 |6 W" }7 S18
+ b8 z5 U8 k' _3 y% m" F19
20
21
22
  y& h) j( v- i( |2 S8 C( Z/ Q23
24
25
26
27
28
29
. S% n3 W; U/ [) N3 [( L30
31
' x' O0 L, w5 V* V32
33
/ V$ b( c/ q: Q! T' ]34
35
36
! W6 ~2 H( N# w' I1 U  _( P% q  m37
38
39
40
41
42
2 D+ ?7 ]" p" x' N43
44
45
# p( c9 w! {8 N2 d' O46
47
48
+ ^2 L2 ?4 ]8 b49
1 g. f- |, j5 q50
51
4 Q) U9 R' M4 k52
53
54
55
: ~4 m5 D3 i0 H3 @- Z, @56
57
58
59
桶排序
% @! |8 ^1 H/ F$ y1 y  {简单解释：
就是把一个数组分成几个桶（其实是几个区间，从小到大或从大到小的几个区间）装，然后让每个桶（区间）有序，然后取出来放一起就可以了，相当于把几个有序的段拿出来放一起，自然还是有序的，当然需要是按照区间的顺序拿了。
- U8 h: y' U5 l8 _1 j
9 T  a  O! o( v2 c2 a1 b- b9 ~
7 B. D9 r0 |. w7 P4 I

* G+ `; u' [8 G  O3 X+ r
+ x# v4 i! @* A& q+ y
完整代码：


. w6 @- ]$ z2 spackage com.keafmd.Sequence;
2 i; L" i, p0 `+ Z
/ M  O  ]) X0 h! x) n# f; L
9 `; }! f3 R5 ~+ V, ]- J9 Dimport java.util.ArrayList;
import java.util.Collections;
; H9 g0 \9 n) Y) H% H9 d* J# c
9 U+ @5 B8 \2 _/ n/ F
4 Y2 f* c6 S$ N/**
* Keafmd
  D( W% f5 w0 a- H *
* @ClassName: BucketSort
* @Description: 桶排序
  m: `# \2 i. _" F0 F * @author: 牛哄哄的柯南
* @date: 2021-06-24 13:32
*/
public class BucketSort {
# p# A3 \# T" @5 h. @

    public static void bucketSort(int[] arr){
6 u. ?* w- n6 r- O        bucketSort(arr,true);
    }

: }0 N' X, z/ r/ ]) X$ [
& d; I2 S# ~' k' y0 W1 ?' p/ a. O    public static void bucketSort(int[] arr,boolean ascending){
; p$ ?' S/ L3 m( B' J0 b% U        if(arr==null||arr.length==0){
  y+ H0 E6 A1 k" I3 e            return;
        }
        //计算最大值与最小值
        int max = Integer.MIN_VALUE;
; e* [8 Z2 I% g* ?( f/ F. c  R        int min = Integer.MAX_VALUE;
        for(int i=0;i<arr.length;i++){
7 C4 k: X' }$ T$ J: i% p+ G3 e            max = Math.max(arr,max);
            min = Math.min(arr,min);
        }
' X6 r# r1 C0 w/ C/ r

6 V. C/ J& Y6 i  Z" g        //计算桶的数量
        int bucketNUm = (max-min)/ arr.length+1;
$ g# n1 L0 O& _0 \0 H        ArrayList<ArrayList<Integer>> bucketArr = new ArrayList<>(bucketNUm);
; j$ f% J8 U6 g3 g# A1 s- Q. a6 W2 u& W        for(int i=0;i<bucketNUm;i++){
            bucketArr.add(new ArrayList<>());
5 E# F5 R- J" I" D% a        }
  ?2 p3 `. w6 g7 w

" a" J) I0 Q5 Q, `# }* b% f0 ~        //将每个元素放入桶中
        for(int i=0;i<arr.length;i++){
            int num = (arr-min)/ (arr.length);
            bucketArr.get(num).add(arr);
7 S4 Z2 h+ u9 }1 C. d$ G! S        }


        //对每个桶进行排序
        for (int i = 0; i < bucketArr.size(); i++) {
9 d# C: y5 X  g0 x8 P- i            //用系统的排序，速度肯定没话说
            Collections.sort(bucketArr.get(i));
        }


( N' Q7 m; A1 M5 k* {# M( g        //将桶中元素赋值到原序列
& w) i" \8 X; i$ h# G2 J        int index;
) S; w8 d. f1 k0 [& |+ J- a7 H        if(ascending){
( Q4 X+ w1 v( T/ S1 z1 T            index=0;
        }else{
& L9 a( h/ D+ |( M            index=arr.length-1;
8 H/ P) W. F/ y3 Q  o0 A        }
& q  T8 ?3 Z7 y6 l5 j. G
2 y$ G$ X/ h9 B' \9 l3 u- G
        for(int i=0;i<bucketArr.size();i++){
            for(int j= 0;j<bucketArr.get(i).size();j++){
8 F; [) @) q+ Z) h& W# Y! |                arr[index] = bucketArr.get(i).get(j);
                if(ascending){
; n7 m7 q+ |% P: f- z+ c                    index++;
& r: |$ A6 I' h) O6 h                }else{
  f4 F  ~5 w# P; O. x. A                    index--;
3 p7 P% X/ [$ `9 X                }
            }

& e4 W; w2 y- B* a% v
        }
3 l8 c# Q" y; F" |

" T1 p# {$ h, g3 b  h3 ?    }
}
! L+ ]) h1 x7 s" ~3 W3 B  e1
. |# p$ U, `" Q3 ?& V* \8 i# t2
3
4 g. w7 ?/ [2 ^9 e4
5
6
  ^. b4 T6 I! x8 y( }) A6 c7
, K4 R! K% N7 Q8 z8
' Q" W0 X- x5 N% s9
, w. `& `- B" ?5 P6 I/ d/ j" }9 w10
11
12
' q+ |7 t; @3 O' g13
14
" g' [8 O5 O4 i' g15
16
17
18
19
20
21
" ]  X6 ?5 Q' Y7 d22
23
" k, f- @+ B: ^24
25
26
5 F, x# }( V5 G( K! u& L27
28
29
30
6 r  ~7 R5 O. [- c. x+ N31
32
. s- w" D. D0 i) A0 N, X33
34
35
36
( U5 T; h0 j' N. f37
38
39
1 k8 x* m5 U& C: ^+ u40
41
( ?  k* [. u. R- T9 y* G42
: L9 {; {  J# l6 ]$ R43
) [) b5 T" g$ E( j2 |3 C3 U3 ^44
& o: O! b" r7 P" Z  W+ @45
; X* E' }* K  i46
47
48
49
50
' R0 A+ W  v3 d. o) ]2 x. s8 T' w51
  m/ Q4 C  Q6 D4 R* l4 C# }1 x4 Z" ?9 F52
53
54
55
56
57
58
- Z( e# ^7 \* A& Z' Q: @59
60
61
  @" f$ f' S1 {$ S& p" u62
3 E. D9 a' k; o1 n. S$ |  v  ]63
' ~( @( ?' _% b; `4 B3 w! C  r64
5 Y, G1 t  [7 j, w# f1 p8 Z. H; C65
7 S' t5 O. n6 ?0 @* B66
67
/ J' W4 ]* g, c/ ^68
69
' ~' M* G+ A. k  w" J# t. d70
71
) [  c1 y. a) W" g* `1 \8 t72
基数排序
简单解释：
9 q# f+ k. h0 K7 C( @首先说一下，我发现好多人写的基数排序只能排序正整数，其实只要处理下就可以排序含有负数的了，就是我们排序前先把所有的数整体变大（就是减上最小的负数，也就是加了），都变成正数，然后排序好之后，在减下来（加上最小的负数，也就减了）就好了。
基数排序就是按数位排序可分为LSD（从最低位[也就是个位]开始排序）和MSD（从最高位开始排序），下面写的事LSD基数排序。
基数排序就是把数按位考虑，让后我们一位数只能是[0，9]，就是我们在考虑某位（个位、百位· · ·）的时候就只看这个位的数，放到在[0，9]相应的位置，然后顺序取出，最后再按其它位这样操作（上面说了要不从低位开始到高位，要不就是从高位到低位）
6 w1 P9 r5 N. Y/ p2 r# P

# ?9 {! d. n4 F  i( w



完整代码：
1 q; P* _, Q9 S4 \6 {

6 Q) w% s1 U) Bpackage com.keafmd.Sequence;
3 o& A* m6 Q/ V/ {& B

/**
& \! F: p0 @3 ~& {: ]" m" X1 j' \ * Keafmd
*
* @ClassName: RadixSort
( r7 C) J: b: x2 A% _8 _4 } * @Description: 基数排序
* @author: 牛哄哄的柯南
/ A, q. O/ |5 s( d$ N. y * @date: 2021-06-24 14:32
) l8 ?0 s9 o8 ` */
public class RadixSort {
3 Q. X2 H9 f4 K& K4 }  v) n    public static void radixSort(int[] arr){
        radixSort(arr,true);
    }
' T  b$ }/ k2 B! c$ t    public static void radixSort(int[]arr,boolean ascending){
        int max = Integer.MIN_VALUE;
        int min = Integer.MAX_VALUE;
; D9 v: O4 j2 Z: u* @        //求出最大值、最小值
        for (int i = 0; i < arr.length; i++) {
- e# o) t4 S, e            max = Math.max(max, arr);
            min = Math.min(min, arr);
8 E( A% X' m$ a8 T( G9 T! U9 @5 J        }
        if (min<0) {        //如果最小值小于0，那么把每个数都减去最小值，这样可以保证最小的数是0
. i: M0 S  ~- D( n2 I) ~( t            for (int i = 0; i < arr.length; i++) {
/ y- L- k( k" ^# {6 x: L                arr -= min;
4 c# a1 D( F. g; j            }
5 a  \* g7 g9 M* Z) Y; X' N/ r            max -= min; //max也要处理！
) o- r1 e; W& d        }
& W$ v0 V; ]4 r. w* X9 _7 J        //很巧妙求出最大的数有多少位
) w  j  I5 ?, O& }  c        int maxLength = (max+"").length();
        int[][] bucket = new int[10][arr.length]; //一个二维数组，一维代表0到9，二维存放符合数
" F! J$ j6 n. ~. Q- S        int[] bucketElementCount = new int[10]; // 用于记录0到9某位存在数字的个数
        for (int i = 0 ,n = 1 ; i < maxLength ; i++,n*=10) { //个位 十位 百位 这样遍历
  A5 e9 D' d+ a4 u4 |            for (int j = 0; j < arr.length ; j++) {
                int value = arr[j]/n % 10;
! D$ T0 i8 y( D7 p4 G8 e                bucket[value][bucketElementCount[value]] = arr[j];
                bucketElementCount[value]++;
            }
4 z6 J0 B6 @6 [0 L

6 M/ R$ X& K: C* b# x            //升序
            if(ascending) {
; H# q1 ?( p" c8 e                int index = 0;
                //从左到右，从下到上取出每个数
6 _5 C- V( G5 d/ b& w% y                for (int j = 0; j < bucketElementCount.length; j++) {
                    if (bucketElementCount[j] != 0) {
                        for (int k = 0; k < bucketElementCount[j]; k++) {
                            arr[index] = bucket[j][k];
% Q  B8 k" v# w( p) V: f/ A                            index++;
$ o- S4 ~' W, `/ h/ m% `                        }
1 g6 Y( Z: Q' H8 f. w7 R1 y! m                    }
                    bucketElementCount[j] = 0;
                }
3 O* v0 r% f2 Y+ o+ S9 e+ t            }else { // 降序
                int index=0;
                //从右到左，从下到上取出每个数
                for (int j = bucketElementCount.length-1; j >=0; j--) {
4 _* W" G& |, ?7 x1 t                    if (bucketElementCount[j] != 0) {
                        for (int k = 0; k <bucketElementCount[j]; k++) {
                            arr[index] = bucket[j][k];
                            index++;
                        }
; F" ]2 c& ^+ K" i                    }
- J% y: n- x1 {/ t: k% i                    bucketElementCount[j] = 0;
+ h- K6 w' v% j                }
( v) r- p6 E. b: M3 `0 P# |/ Z            }
2 W7 I. G$ M: P

- w* c4 P' R6 X3 ^" o1 f. I

            /*for (int i1 = 0; i1 < arr.length; i1++) {
                System.out.print(arr[i1]+" ");
            }
            System.out.println();*/
  _+ A& E6 r2 s

7 T* E# z* U9 \

, Z/ K4 Y% c" Q4 i5 x
" m( M4 `! P) e
        }
8 M  ^( V+ t8 {( d3 f        if (min<0){
            for (int i = 0; i < arr.length ; i++) {
                arr += min;
            }
. P6 j" z5 n/ k3 g* i1 }2 a        }

$ u7 _: R6 N' O$ ?! u! M; I
/ B! |4 E, c# `9 R3 M7 p    }
}
1
2
4 T& }9 \" @' Y8 m; j3
; S: A. ]  R+ d7 h7 y+ R$ p4
5
- B/ O6 ?" N: y! R6
7
8
9
& {6 O7 B8 O" n, v! t0 S# d10
11
9 N5 S, l6 \8 q  J12
13
6 v+ X( f# r4 e: W14
5 f- u, M9 l$ Z15
16
17
18
7 K' T/ I) s3 @7 }5 G) [19
20
21
22
( V' ]( B, b- i5 b8 l9 x23
) a: C0 H( [1 j9 \4 P1 f24
25
* G% E' H( X# v' S, V6 _3 Y% p( K+ K26
1 H: L; i* r: p$ r$ k3 X27
28
8 F7 W, r0 X6 f29
30
0 W, U3 y0 j  r' u5 x31
5 f  I$ S$ Y6 h8 _32
$ o6 e) X. M1 _33
% |% l3 ?1 i; M, ]( H34
35
36
37
7 `$ E0 ]5 @: t! _38
/ P% j7 Y1 h0 G39
40
41
! t3 h3 }* \& w# e' J8 K" T42
6 X4 H) ~+ s/ L1 G* R( |4 _  ~43
44
45
46
47
4 Z2 a( h7 l& @; D+ J% C48
5 I7 u  }3 t- s0 c- C3 j* C6 @" c49
1 o5 h0 _% {& s0 m6 D" f* Z50
8 n! I+ k' l0 [% w3 M% T51
& }4 A7 Q$ S& P% P52
53
54
55
/ v, \5 L  Z7 O9 M$ `56
57
58
1 u$ a3 y* d, m% e59
60
61
' O! d; i( i5 Q62
6 }& P2 C. S2 @+ C63
64
65
66
; ?$ Y- u* z" P3 z1 L1 l; l67
. C% C  s1 j: i$ e68
69
; Z' _" \/ `: E& y70
71
72
% J5 v! W( }5 [/ D) J' m73
2 J$ ]( A: ~! @/ |, K9 `74
* j! H; ]4 V  Y3 E3 L1 v5 y75
" y* k7 o; T( w, C: ~76
: K! E- d. V$ z. I& O7 @77
78
# v+ S1 w$ c( u. {# \4 Z1 i79
80
# V2 p- j/ q! e' n; b6 f4 u  l81
: G  k) Y8 a/ F! d# S82
1 W; \. u* }9 j2 c83
完整测试类
package com.keafmd.Sequence;

" l" P9 V; Q* Q" ^
1 C0 V* T: _' r9 D  s5 I4 C& bimport java.util.*;
import java.util.stream.IntStream;
import java.util.stream.Stream;

. m! S6 B9 l/ d1 p& a
5 o8 M( g5 R' p2 F8 U+ Y/**
* Keafmd
*
0 p+ Z' m- m0 a! T * @ClassName: Sort
# B/ Y. e2 C7 V. }. D7 Z, J. P * @Description: 十大排序算法测试类
* @author: 牛哄哄的柯南
0 s3 k7 a/ U. C5 L5 ^$ @ * @date: 2021-06-16 21:27
* ^8 m4 n1 Y* U& o3 T5 T */
public class Sort {

7 E0 F. M1 Y& c0 |- F/ r6 V; Q9 O
8 W" s/ {- `% Z! b7 O8 F
" T4 N" D2 B+ A/ |, p3 Z
    public static void main(String[] args) {
5 E7 {& K* E! Z. z

        int[] nums = {12, 4, 25, 47, 58, 34, 25, 9, 99, 26, 1, -13, 162, 10093, -66, -1};
//        int[] nums = {12, 43,56,42,26,11};
        int[] temparr;
  ]9 ^' i  I: D2 z7 B$ W" t

+ n% v& h$ b  k" S7 u& h        //利用系统Collections.sort方法进行对比
* k* l5 {) Q' C+ I+ |
  @" w. [; S' ?  D$ c5 t, @* v9 F
        //将int数组转换为Integer数组
, A9 L+ o( G5 x5 d! M5 Z+ \2 C        //1、先将int数组转换为数值流
6 @- ^: Q; w& N; h% ]8 x        temparr = nums.clone();
        IntStream stream = Arrays.stream(temparr);
9 ^$ J/ B9 S/ Y        //2、流中的元素全部装箱，转换为流 ---->int转为Integer
- I; D8 x8 D. |2 E5 u5 ]. f        Stream<Integer> integerStream = stream.boxed();
        //3、将流转换为数组
6 Q; H/ x, Y* B) P8 l. o( O6 ]        Integer[] integers = integerStream.toArray(Integer[]::new);
. ^+ Y% I* w0 r# G* \: p( k, x        //把数组转为List
- n1 o. A' p5 }' n/ I: Q        List<Integer> tempList = new ArrayList<>(Arrays.asList(integers));
4 w) L9 l8 T0 R* z        //使用Collections.sort()排序
! K: w3 |: p( Z+ V/ v" n6 I( }' m        System.out.println("使用系统的Collections.sort()的对比:");
* J3 M6 {3 [+ f5 \
% c8 @% ?( q8 X- Z3 @
        //Collections.sort
9 K) x# t7 a3 U. S        Collections.sort(tempList, new Comparator<Integer>() {
            @Override
            public int compare(Integer o1, Integer o2) {
, |# v8 I9 l' ^, Y" V  R) j0 e& d$ J                return o1-o2;
                //return o2-o1;
            }
        });

! j- C- m( X: ]+ a4 j% ^
        //tempList.sort 也可以排序
* p; O. O1 s1 n' O       /* tempList.sort(new Comparator<Integer>() {
            @Override
: W$ c+ H% k1 W) U2 v/ h            public int compare(Integer o1, Integer o2) {
                //return o1-o2;
" V$ y9 n( Y6 Q4 ]7 Z0 R- q$ |                return o2-o1;
            }
! f" L2 P: M# x. t) p  L% @        });*/

$ q- |$ @0 V: i* h/ t8 A" t( e' l- x
        //遍历输出结果
        for (Integer integer : tempList) {
% A* x+ ~: d6 @. |$ w# B6 W            System.out.print(integer+" ");
        }
# @/ L9 X. U3 ?) o# t5 O

3 v0 S7 j  W: ]        System.out.println();


2 ?& k/ V- z2 \, ]        //测试冒泡排序
        System.out.println("测试冒泡排序:");
        temparr = nums.clone();
6 a6 }; s6 E: V" }; u. D+ H+ _

        BubbleSort.bubbleSort(temparr);


        //降序
) r5 D4 L/ i$ @$ ~        //BubbleSort.bubbleSort(temparr,false);
0 a* W1 R5 \. f1 ^- }% t0 \
: x1 c- }+ O$ G
' Q" U$ K% v4 w( U2 a' [        for (int i = 0; i < temparr.length; i++) {
. |& U: b, E( m9 U* Z            System.out.print(temparr + " ");
        }
        System.out.println();


        //测试快速排序
0 j* o; M9 O( a2 O8 J2 ?8 v        System.out.println("测试快速排序:");
) u  ]9 k2 _1 d* Z4 h7 J; ~        temparr = nums.clone();
        QuickSort.quickSort(temparr);
; R  P. z) G$ n+ N3 [        //QuickSort.quickSort(temparr,false);
        for (int i = 0; i < temparr.length; i++) {
            System.out.print(temparr + " ");
        }
        System.out.println();


        //测试直接选择排序
5 I  q4 F0 E$ e5 u8 z9 X+ L        System.out.println("测试直接选择排序:");
        temparr = nums.clone();
        SelectSort.selectSort(temparr);
" I1 [. H, ]8 \# N        //SelectSort.selectSort(temparr,false);
$ S! f$ }5 V6 F# H, B  T; d        for (int i = 0; i < temparr.length; i++) {
4 u+ O( c3 Q" z! c            System.out.print(temparr + " ");
        }
  Z% E7 c( K, R1 ]0 P' f' I0 a        System.out.println();
/ X' U% T8 c- k: C$ ?, z/ Z

        //测试堆排序
) v3 h7 H8 L/ V        System.out.println("测试堆排序:");
2 h2 X1 |! w, y7 ^. t/ T( A' D        temparr = nums.clone();
2 t! V8 o1 ~* \( f" \        HeapSort.heapSort(temparr);
( m$ K2 j, ?. ]        //HeapSort.heapSort(temparr,false);
1 Q8 N' ?% v- ^7 _4 U        for (int i = 0; i < temparr.length; i++) {
9 ?" N/ _$ z1 @; `) O" C9 `            System.out.print(temparr + " ");
        }
* i* _3 B) \: M6 H        System.out.println();


# j3 L9 z/ t5 Y; v' {6 y) `        //测试归并排序
        System.out.println("测试归并排序:");
        temparr = nums.clone();
& M; q3 D6 M2 ]) Z/ W3 t9 o        MergeSort.mergeSort(temparr);
        //MergeSort.mergeSort(temparr,false);
        for (int i = 0; i < temparr.length; i++) {
% c. e* ^$ q9 L5 U5 v* @            System.out.print(temparr + " ");
  D# u6 W' ~8 ]' {) H  L- J. S        }
3 [6 o4 D) g7 X- x( v/ r$ ]        System.out.println();


' C' }; }9 m1 ?) x5 n& m        //测试插入排序
        System.out.println("测试插入排序:");
        temparr = nums.clone();
        StraghtInsertSort.straghtInsertSort(temparr);
        //StraghtInsertSort.straghtInsertSort(temparr,false);
        for (int i = 0; i < temparr.length; i++) {
            System.out.print(temparr + " ");
        }
, k- c' S4 }. \& i$ J7 T+ p' W        System.out.println();
) H! s- J+ l% s; p

# G5 r5 ^9 W; Y( o& ?1 y

        //测试希尔排序
, {9 M9 b+ V4 B# ~, B* N8 Z        System.out.println("测试希尔排序:");
        temparr = nums.clone();
        ShellSort.shellSort(temparr);
        //ShellSort.shellSort(temparr,false);
) A3 g( e& L8 T. k5 f8 K6 [        for (int i = 0; i < temparr.length; i++) {
            System.out.print(temparr + " ");
1 e8 ~8 ~( b8 _/ |0 I( g        }
# T3 H; l; A$ A( }  q( R        System.out.println();
0 I. u, z6 A, Y  s6 P8 \
( [4 `. c4 S. t6 Y

; |# N: Q* y( d2 M1 R" X
+ I5 ~4 k7 t2 G$ K. \: E        //测试计数排序
        System.out.println("测试计数排序:");
        temparr = nums.clone();
. g$ y9 N( L3 M        CountSort.countSort(temparr);
        //CountSort.countSort(temparr,false);
0 @& K0 r; \# I0 j% q# S1 m, h& m        for (int i = 0; i < temparr.length; i++) {
            System.out.print(temparr + " ");
        }
        System.out.println();
7 w1 z% P2 H6 G! G

( P' P+ O5 M8 s# F

        //测试桶排序
        System.out.println("测试桶排序:");
        temparr = nums.clone();
        BucketSort.bucketSort(temparr);
5 V. U6 J. ~2 s! O        //BucketSort.bucketSort(temparr,false);
        for (int i = 0; i < temparr.length; i++) {
4 x: g" O5 l8 ?+ O            System.out.print(temparr + " ");
) I3 o+ i$ u7 `- w- Q1 g        }
' Z: a( Y" h2 X2 _        System.out.println();


1 F! d0 {  i+ z& H        //测试基数排序
        System.out.println("测试基数排序:");
        temparr = nums.clone();
- b2 Y, Y9 T- U. p* L) h- n. J        RadixSort.radixSort(temparr);
; [+ R2 p: B) Q6 ]! u4 o& s        //RadixSort.radixSort(temparr,false);
; s1 e: V- Q* y3 l, M, k7 U4 R        for (int i = 0; i < temparr.length; i++) {
            System.out.print(temparr + " ");
4 r/ ~7 U+ k& Y9 J( Q$ L        }
        System.out.println();
- `' O. S" r) v: e# m# Q

5 I- ?4 U. D, R+ P* b5 |' c    }
8 ^+ L# _7 [/ t1 e, s+ v- {

}
1
. p3 W1 B' z. Z9 s2
3
4
5
! Y# I( ?" P3 u3 U6
$ v$ `: m* O2 M7
- }+ @6 W+ E8 b- Z* E3 Y# P8
9
10
* g# Q# k1 n' V+ O2 a. w: k1 N5 f11
12
) F2 V6 }% E; J7 ~0 t# d! [13
14
5 z) i0 O" Y1 Z% T15
16
17
18
19
20
5 I/ I" m# C3 z- k) [21
22
. t" d& D7 D5 o% `23
& l+ n+ S/ |) A$ e( U24
- X$ m' O! W; X! R25
26
9 M, }% g, Y: q4 L# i% }: [4 [( _3 g! Q27
28
29
30
0 `4 G; z/ R" N) a# x31
32
33
4 K! q3 j3 p3 H. R% t34
) u* Q1 ~) O/ c  k35
8 S9 w8 y" b& l, r36
0 k5 }6 ]6 }# M. n* b( {37
38
; `; u3 R' b. ~0 J' J* a" J: g39
40
41
- R2 k& b2 g6 l42
5 E6 Q3 V) {3 e$ R43
& j) h) t+ _- E44
45
46
47
48
49
7 l, `# y* k( o) W: i; C- G50
51
- r2 e# {9 W/ ^% U0 k: N( p3 x: {! P52
53
54
55
1 K4 j$ d: k5 p56
57
58
59
( t6 T. {( X  w& |! Z4 [2 O8 Z. G60
; C# U6 f5 L# _' u/ u! z61
62
63
64
65
$ {1 I& H8 G. J! I* F66
- H& K# U3 U4 U) U8 ]( U67
68
2 h' M% |3 Z" {5 |% N69
70
6 F( P  K% Y6 m1 X( J71
* d4 j2 J: Z: L6 R) A* b+ ^72
' v0 I. Q+ [# r- B6 A8 U) h73
74
, a  T* M2 ^. n' \75
' f' v7 @1 X' g* Z$ O) x76
77
78
79
5 s- _" A6 w5 N% M0 l* Y80
81
82
2 B) ~& l. [- b' [1 F# l83
& Y+ M& ~" `6 R$ s( [84
+ W# a$ U* T" t  f' @3 \85
. Y+ y; Y" k: [) A% N( N86
87
& }+ k1 _/ w' s, K; g- J88
89
90
0 ~( m- Z0 n" t- m, |+ U, S. N91
92
. i2 O5 H# b8 t  h  K. h6 l93
& X" q4 M# W3 A/ f8 p0 l94
6 k1 P# e1 d* R5 M  N) ~95
96
$ L# K4 g1 ?, m: R97
98
6 L9 h! x: |) _7 d5 B99
; g! H! p9 r0 i+ z100
101
102
, F* x# T1 A' x* `; A: J103
1 h+ j" M2 E+ X2 F9 d- l104
105
, _8 {: W* k0 i% G) w! q106
107
, _  v8 N# D, i$ I1 t% H108
* P2 F) V0 ]7 J$ S8 a  y109
( L4 ~! [9 K7 N# e& I5 I% n110
111
112
+ I6 o* X3 e. n" w5 g113
: l; Y3 n9 s3 x- _# K1 D5 b2 M114
115
116
7 r; I9 }: H& w117
( r* e3 |: y" M( p/ g. ^! A- J+ }118
/ C( ^" R+ @  G1 r) ~1 a119
120
. `8 }+ |1 V: h5 Y5 `121
122
123
' F* H# g' c- b6 J124
125
+ c* W+ c5 U4 h  U6 N126
127
128
129
8 E* n: |( u- j: y' l3 R130
131
132
  t6 j. y- x# \% {2 J5 K! {133
5 n( ?% H8 F- y* U8 h. I2 u7 }134
& P8 O3 |$ L3 t% A# S135
2 \! ~, ~3 _2 v: {  Y2 ^136
3 I. m, l) J5 h" j' f7 K' [137
138
139
. r) p3 ?7 X- X140
* V+ j$ L- S% W+ }141
6 a+ F1 v7 M, ^( {* r' W142
143
144
$ o3 o& b; l0 X4 A1 N145
$ s8 N" }. x8 }6 y: P8 p4 A146
* ]6 V: b) E' L+ W" b4 @147
+ ]& f; Z( A6 w/ c4 |2 U148
9 N- Z7 f. |; p+ Z149
150
# E6 r: B* g" I" v5 d4 a8 e; Q5 }2 b151
0 i3 r) |& M, b! w. R$ j( z; c+ K152
153
, {( m& r$ Q& Z# i. |4 U154
155
156
157
158
5 e; m& Q0 h2 s7 F  A/ X159
160
161
162
! G6 l) F9 a  h( M- l2 }) V163
. [7 S5 X; E3 f: r% R7 _6 s+ ]164
165
166
4 E# P5 j4 D- P167
0 p* P: `2 U8 H% a" Q168
# f. u2 K1 e" J169
170
9 ?$ Y0 X/ x9 b3 Q, ]) T/ H171
172
3 x6 ~* v2 I- w8 Q/ B173
每天进步一点点！
不进则退！

* j" P7 i# L! \1 d
版权声明：
原创博主：牛哄哄的柯南
博主原文链接：https://keafmd.blog.csdn.net/
- |- O& g9 \1 l" A' p  A9 @————————————————
版权声明：本文为CSDN博主「牛哄哄的柯南」的原创文章，遵循CC 4.0 BY-SA版权协议，转载请附上原文出处链接及本声明。
9 G8 u5 I! _) f8 e+ N$ I. A原文链接：https://blog.csdn.net/weixin_43883917/article/details/118193663
* E+ s0 [1 Q1 @" z  P' f
: o4 }% k; _, |# F9 T
2 X" A# g6 {* D8 X0 I+ D

1051373629

每天进步一点点！