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

杨利霞

6 K* a+ J4 B0 ^经典十大排序算法（含升序降序，基数排序含负数排序）【Java版完整代码】【建议收藏系列】
经典十大排序算法【Java版完整代码】
7 L5 G7 V- M- m) w7 v: l写在前面的话
十大排序算法对比
冒泡排序
快速排序
直接选择排序
堆排序
归并排序
插入排序
$ G( S7 P8 `( B/ j+ @2 \$ k% e; ?5 G- D希尔排序
计数排序
' z/ ]6 T: I0 R) l, ^桶排序
1 P- n0 M. |" F9 u2 C) ?* h5 u基数排序
! {. C  Q% m* P; Q* K, c; n完整测试类
$ b( ]# r9 v' v# K# N& t( ]写在前面的话
       虽然已经有很多人总结过这十大排序算法，优秀的文章也不少，但是Java完整版的好像不多，还存在某些文章代码存在错误的情况，同时也为了自己练手，决定把所有的写一遍巩固下，同时也真诚的希望阅读到这篇文章的小伙伴们可以自己去从头敲一遍，不要粘贴复制！希望我的文章对你有所帮助，每天进步一点点！！！
  z. T& X3 d) @# N7 j/ V0 F
: }+ j! |: l4 s
( R. c( e) d! [! u       我用通俗的理解写下对算法的解释，对某个算法的运行过程不是很理解的话或者想看比较官方的解释的话，单独搜索某个算法，看几篇不同的解释，就可以有自己的理解了，这里我主要展示代码以及进行通俗的解释！整起来，再强调一次，一定要自己敲一遍，这样才能理解的更深刻！
, G  N2 u; }; m3 I
9 S4 _+ i. H0 ^+ @7 a5 [4 a
十大排序算法对比
/ a3 a- Q  D  p0 |( e1 X; M

% i) t3 s2 L3 x% A
$ L" J  o- \$ R( U1 @/ K* e
关于最后一列的稳定性，我稍微解释下，例如对序列：1 2 4 2 6 排序，序列中存在两个2，如果我们把这两个2标记上（让他俩不同），排序之后，前面的2还在前面，那么就称这种排序是稳定的，反之不稳定。
. f0 h6 j. x8 g- [4 L: ~

冒泡排序
1 {8 [6 W, h; `简单解释：
% S: Y6 u) A* }- {       原理就如算法名字一样，就像水中的气泡一样，每次我都把最大的或最小的放到最后面，这样总共需要n-1趟即可完成排序，这就是第一层循环，第二次循环就是遍历未被固定的那些数（理解成数组左边的数，因为每层循环都会把最大或最小的数升到最右边固定起来，下次就不遍历这些数了），两层循环遍历结束后，所有的数就排好序了。
1 z5 ^0 n7 `" c/ d+ R       两层循环所以冒泡排序算法的时间复杂度是O(n 2 n^{2}n
! Z) b+ W+ w5 x2
)，是一个非常高的时间复杂度，我在下面的代码进行了优化，加了一个标志位，如果上一次循环未发生交换，就说明已经是有序的了，就不继续下去了，反之继续进行下一轮。

+ L8 u9 Z' ^( A" h! Z. ]( Z+ c4 y) O
! V+ ?* H. c- g3 {
$ I: Q0 K0 A; p- `


. K: ~3 q2 z2 F5 b$ Y本文的图片来源网络，仅用于大家学习，侵权联系删除！（下同）
, s+ p# U2 k5 b& {4 _

  T; I$ m/ j. o5 B' m完整代码：


package com.keafmd.Sequence;
! C8 u8 y- u0 b6 J

. ^- S% u4 I+ w: c& G% t/**
* Keafmd
# E5 U. I, e& [; U. ] *
, Y$ l% G  b- ~, [# A7 {: O4 v6 y * @ClassName: BubbleSort
* @Description: 冒泡排序
* @author: 牛哄哄的柯南
* @date: 2021-06-24 10:31
*/
0 }1 R1 w. M2 i/ I4 `public class BubbleSort {
) u; `: J- q$ t( c2 I; `# q
" i2 f" h2 H8 C. A8 [) x
    //冒泡排序
    public static void bubbleSort(int[] arr, boolean ascending) { //exchange标志表示为升序排序还是降序排序
! ?$ l2 {* c# G. s

) X0 U$ x% j4 m9 [& m        boolean flag = true; //加一个标志位，记录上一次是否发生了交换，如果是，我们则进行下一轮，如果没有，说明已经冒泡好了


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

* s% \! E7 f# g2 k
: s) I2 K" Q: d0 d4 L+ f            /*System.out.print("第"+i+"次遍历：");
            for (int i1 : arr) {
8 H8 M$ O* O" Y; T7 ~  i0 w4 W                System.out.print(i1+" ");
) ?! [$ _' \8 r2 [) m1 l) v            }
- A! G' w: z) W            System.out.println();*/


            flag = false; //假定未交换
, K5 y, j" ~* L7 Q. M0 l( F" i

) L" \# v/ C9 l7 H/ d$ V+ I1 `            for (int j = 0; j < arr.length - i; j++) {
- z$ j: `" z$ x6 J0 m! P

                if (ascending ? arr[j] > arr[j + 1] : arr[j] < arr[j + 1]) { //控制升序还是降序
% H3 i/ b6 k7 y3 |4 s& t                    int temp = arr[j];
- m( ?: G. c& I1 o+ O' D. r8 U2 K                    arr[j] = arr[j + 1];
/ Q9 H9 w& Q- Z7 G" M* W: a$ L                    arr[j + 1] = temp;
  J6 C: g7 i' K) Z% i                    flag = true;
/ U) S2 K' S% F2 j) q0 m% Z                }
/ |( ^6 b: l- X4 z
3 E/ ^! g* w; b: i# a2 m" {8 a
            }
# S3 b( m  r0 p/ u        }
    }


0 l; S( w4 r2 I! u, ^" T! s& X    //冒泡排序 -- 默认不传参升序
    public static void bubbleSort(int[] arr) {
        bubbleSort(arr, true);
' h6 H, [' N7 o6 p7 [6 ?- i  ~    }
9 O2 F; K$ p1 u+ u7 M1 x}
: P8 `6 K8 W; f8 z, u( f' D6 h1
# d) J, Y! L! F1 L% r& D2
3
9 }) q2 T. O* X; j6 Q% V4
5
8 U. K' g, q; |6
% C& u* H: i1 d" t7
' u& [& Y/ e( ^8
9
6 a# z! y6 c  x1 r10
  H' B* E; \6 [5 V9 \/ f. b11
12
13
1 M( \' \9 c! g# L/ c& O14
' ^' [- J/ V3 A1 c( {+ ]15
4 K8 i/ `7 _. R16
7 w2 G: ~- z0 W17
18
19
5 X. |" G1 j1 ^- N% E% [20
21
22
3 u2 a6 w1 m3 s+ M6 k% a/ F23
24
25
0 W& {$ V3 b; y3 j7 S8 A4 ?* |26
27
1 Q, R/ `& P! G( |3 Q! `. Z- u) w: S28
29
30
: }" j2 |3 O( l2 }31
7 B. T2 N7 T5 f' I32
* r0 e  V  K+ B* @4 @; c33
34
35
& v/ T1 u% u8 S, H: {( N( T$ s36
37
38
39
7 t9 m$ z. n  a40
41
42
9 L& @5 m4 X6 ^6 A4 Q43
44
/ o& u! i: n2 Y! ~* U6 a45
6 N7 W; P+ a2 O  V- V测试代码：
" F$ Z8 {, g6 y. @
$ c  D) L/ F- i" A8 O' K
升序排序（从小到大）
5 G# B( r4 M4 ?6 Q) a$ w
! |  \# ?- q0 k5 g
package com.keafmd.Sequence;
3 `. Q9 u  f+ C1 E9 ^

$ Q0 ~% r. N8 jimport java.util.*;
3 X/ H/ R! b, iimport java.util.stream.IntStream;
import java.util.stream.Stream;


8 Z: S9 X/ i( D6 S# h5 T$ v* {/**
* Keafmd
2 v4 L! r+ H# Y *
) H& F% y3 z6 E6 C0 T" S * @ClassName: Sort
* @Description: 十大排序算法
* @author: 牛哄哄的柯南
* @date: 2021-06-16 21:27
*/
public class Sort {
) |0 @7 E" ?# N( K6 j2 f2 \! t) k    public static void main(String[] args) {


7 j" K  J+ ?( f5 e2 c        int[] nums = {12, 4, 25, 47, 58, 34, 25, 9, 99, 26, 1, -13, 162, 10093, -66, -1};
        int[] temparr;
, I' X+ D4 K9 B0 D) x4 ^

" s& l+ i) |3 Y0 r5 R) W        //测试冒泡排序
) L- ~1 G" m3 y        System.out.println("测试冒泡排序:");
        temparr = nums.clone();
/ u5 p3 F  v3 d( t        BubbleSort.bubbleSort(temparr);
8 c+ `; X% i8 j( n% d& C/ y, f! y) k/ A        //逆序排序
        //BubbleSort.bubbleSort(temparr,false);
) R4 v3 L4 m$ M9 S2 `6 D        for (int i = 0; i < temparr.length; i++) {
6 H0 @4 S5 t1 [8 {& I; t7 G            System.out.print(temparr + " ");
        }
& J( v+ [. v! |/ }- g        System.out.println();
2 U9 b- r0 j0 p6 m' z4 @. {" \
. o9 ^, [8 N' A; g# i
- H4 Z0 _4 r9 o    }
}
# L4 O0 W  G: Q$ |4 Y/ Y1
2
3
) q; P2 Q# h, a8 F. F4
5
$ e. g/ K; C5 V& O$ M7 {! _( N/ ]6
) K; R1 g$ ~! j7 ~  E9 w, u7
8
9
10
5 |% X4 C) ]8 R: {; D% k11
12
) q; A+ I$ A' f- {) u1 b( K2 j13
" L6 K, q- L/ r  J  r1 g! d14
15
16
17
0 y8 F5 u- q' @6 Z  K18
( |0 ?6 w; n; E4 e+ P19
5 [# p4 E- B% _0 E20
21
# @! X* y. e5 C1 M5 J22
23
24
: @  W4 \; G5 y' O25
4 _; e6 e. |4 ^  X3 @9 {26
- i, Z9 E: P9 C27
, @2 a" q2 W# j: n3 v28
- o- E5 W+ N/ ^  T2 I- Y29
( J, S" ~' f4 L; W1 [, [30
* E6 k5 X" J8 d  ^+ N% U9 c31
32
33
9 I# \. {9 |7 B- ~! Q! J6 j  ?. r) H运行结果：
+ K) v5 Y* y" ^6 w6 U

测试冒泡排序:
. V6 l& U& q: O( l* H-66 -13 -1 1 4 9 12 25 25 26 34 47 58 99 162 10093
# R1 s( ?) u# N7 o  {6 F1
2
降序排序（从大到小）
. P$ ^$ _3 K; g+ l  |! j
1 J; I0 c3 n7 ~4 Z  Q7 k8 I) C
//测试冒泡排序
System.out.println("测试冒泡排序:");
; v; M$ S  k3 W( r$ I' Ptemparr = nums.clone();
BubbleSort.bubbleSort(temparr,false);
6 b6 u3 N. G  qfor (int i = 0; i < temparr.length; i++) {
9 I  X* V' `( S/ P! w6 F  d5 r    System.out.print(temparr + " ");
}
System.out.println();
1
2
0 J" s* _1 r! T* N  [* o3
3 i& Z' h* E6 ]: P4
5
* v  x. y6 r9 A6
1 d. K( D( E0 G; l: J8 i6 s0 U; H7
# ]! ~+ |% a4 @8
% O4 |" i: W6 _+ i- v+ Q运行结果：
7 K8 J3 A! [" B; Q9 O4 C" v  b

测试冒泡排序:
10093 162 99 58 47 34 26 25 25 12 9 4 1 -1 -13 -66
( H8 K( M3 c. h) r( `1
' d% Q( @; s  j9 d$ B2
下面几个算法的测试也就是换了下类名和方法名（换成相应的排序算法），如果想降序就在数组后面传个false即可。我就不一一复制了，我在最下面给出含所有算法的测试类，需要的自取即可。
$ N& d( n4 R! D1 T

6 G, k* U( h1 K! ^4 H9 P快速排序
简单解释：
7 o- i0 x# @  \+ P1 H9 ]( ~5 `快速排序就是每次找一个基点（第一个元素），然后两个哨兵，一个从最前面往后走，一个从最后面往前面走，如果后面那个哨兵找到了一个比基点大的数停下来，前面那个哨兵找到比基点大的数停下来，然后交换两个哨兵找到的数，如果找不到最后两个哨兵就会碰到一起就结束，最后交换基点和哨兵相遇的地方的元素，然后就将一个序列分为比基点小的一部分和比基点大的一部分，然后递归左半部分和右半部分，最后的结果就是有序的了。



: T, j( R& t9 W- f  P
" q5 f, u8 C* h0 x9 A, Y$ D$ h2 c

' B' R3 W' l" p0 U( p, R完整代码：
4 S1 t9 r: d" x/ ?2 W
3 C; m; v" ^. ~# C6 h7 [* L0 d
package com.keafmd.Sequence;
/ K. A" C" E$ a+ G

/**
* Keafmd
*
* @ClassName: QuickSort
( i' \* @3 w& `5 |. v+ M * @Description: 快速排序
* @author: 牛哄哄的柯南
* @date: 2021-06-24 10:32
3 h0 z! Y$ [/ `# V */
public class QuickSort {

! W% _, a/ Z8 E. G' ]
    //快速排序
9 M$ e5 i4 ?' O; B* u6 T    public static void quickSort(int[] arr) {
& Z0 b1 k6 |5 ?3 F# }7 m        quickSort(arr, true);
: ]8 k& Z" ?- n/ m5 k" h4 ~, Z7 d( f* h    }

! l2 a/ G/ ~7 p) w
5 j1 G/ m  t- I$ _    public static void quickSort(int[] arr, boolean ascending) {
        if (ascending) {
/ ?4 M+ X, a9 U: E            quickSort(arr, 0, arr.length - 1, true);
        } else {
; p! ]  B9 A3 m( b            quickSort(arr, 0, arr.length - 1, false);
4 a! ?; V; e; S8 D, z- g        }
    }
  L# q! q2 E8 X% f* C, r
9 r4 z1 B: l5 j+ w( ~1 l& |1 [
9 ]3 Y: m$ S5 M3 u7 G    public static void quickSort(int[] arr, int begin, int end, boolean ascending) {
        if (ascending)
            quickSort(arr, begin, end);
        else
            quickSortDescending(arr, begin, end);
    }


    //快排序升序 -- 默认
    public static void quickSort(int[] arr, int begin, int end) {
        if (begin > end) { //结束条件
: I% M" D' J3 h            return;
        }
        int base = arr[begin];
        int i = begin, j = end;
        while (i < j) { // 两个哨兵（i左边，j右边）没有相遇
- U* r3 r/ Y" W" \' t% J            while (arr[j] >= base && i < j) { //哨兵j没找到比base小的
                j--;
; p! A6 c. v1 C1 L7 t8 Y9 \! L            }
; c3 x$ Z! ]) Q4 T2 A5 ?) a            while (arr <= base && i < j) { //哨兵i没找到比base大的
                i++;
- r( u; }# p0 l8 Z6 `7 V5 q" F            }
' R0 L2 b; d$ \0 ]: ^* ~' T            if (i < j) { //如果满足条件则交换
                int temp = arr;
                arr = arr[j];
* ^: v6 Z4 U* B0 \1 A                arr[j] = temp;
            }
# ?/ L; ?( A8 X( R$ v" p

        }
( l+ c: ^4 f, W; Y  }        //最后将基准为与i和j相等位置的数字交换
        arr[begin] = arr;
        arr = base;
! V& X4 ]5 n7 \8 h+ w4 O  {( E        quickSort(arr, begin, i - 1); //递归调用左半数组
: Z, {: W2 t& m9 N        quickSort(arr, i + 1, end); //递归调用右半数组
' D& P) V6 D9 e# F

+ H( D9 _8 h0 ]0 C  L    }
' T3 X2 w( h4 Z7 X" V) H  F/ V

    //快排序降序
    public static void quickSortDescending(int[] arr, int begin, int end) {
0 A2 o9 Z/ \# R) t/ R5 c, W+ V        if (begin > end) { //结束条件
& B- w% V+ E6 ^: h' B            return;
        }
7 e3 t3 Q2 G6 e' W        int base = arr[begin];
        int i = begin, j = end;
        while (i < j) { // 两个哨兵（i左边，j右边）没有相遇
            while (arr[j] <= base && i < j) { //哨兵j没找到比base大的
                j--;
            }
% j; ?. z# N, \            while (arr >= base && i < j) { //哨兵i没找到比base小的
                i++;
% M) q  s+ @- o. w: s; V  \  p            }
            if (i < j) { //如果满足条件则交换
- R+ e- W! J3 _2 ^5 W( k- z$ ?6 s                int temp = arr;
                arr = arr[j];
4 t- p9 p! c: d$ M6 e3 f+ _+ P" s" D7 D                arr[j] = temp;
            }
( Z) k- P7 j- A: ~5 C- ^' o" |

+ d8 Q% z- U. _; y5 P( h1 I        }
        //最后将基准为与i和j相等位置的数字交换
8 s/ ^- J$ x, j% I$ q        arr[begin] = arr;
+ j+ u! u& c* U  a! J        arr = base;
        quickSortDescending(arr, begin, i - 1); //递归调用左半数组
; P" ?. F& s. f; f        quickSortDescending(arr, i + 1, end); //递归调用右半数组


    }
$ s% O  \) ]; l
/ I: p  }! L) e% C; O6 J/ t
}
1
2
: n  u- A8 Y1 z( B) {' q3 N3
& n/ m% {& x# E1 J# N) a2 h4
5
6
' Z- ?- ~$ M0 h# T& J- U7
8
2 O1 j! x8 t$ `9
9 s6 K: [; Z% Q; F- }9 o10
11
! ^9 i) \4 Y5 t% r7 V- c12
13
# b3 n9 J4 s: j* E0 E) z5 x14
15
16
17
18
# ^& R( i3 H/ e* |# c19
20
21
22
23
. A$ W, Z$ F0 g4 g9 V/ k24
25
26
27
: X/ Q1 V$ X' l  T/ H, C7 D$ K28
9 @1 w+ p5 J& T$ Z29
- _, |; T- n  Y# t30
  V: ?2 J0 l( F3 j3 \31
32
33
1 d2 p+ f+ Y1 D$ w& {! p6 Q/ E2 O34
35
36
37
38
- y5 X5 R8 z/ i* @39
! J6 x: F- K& O7 L) v/ S+ b40
41
42
2 K) k* n/ K/ z. y* [7 R# ]43
44
45
46
6 e; G) H& s. V1 q5 d1 L47
1 H! ~# Z: p  t48
49
50
51
52
% u0 m$ u1 y( Q9 s53
54
55
56
) S/ q) Q, O( u0 u$ G3 f5 ~57
58
59
60
1 u  j7 o6 J2 H5 x* N% o61
62
* `8 E" ]4 j4 X- O3 R63
# X! }. h' Z4 ]' U8 h7 W1 e64
65
/ `2 N# l$ _( t- x# X, ^66
; ], a7 G8 i7 u( ]* L7 j# Q" u* E67
68
  e, U4 M6 h$ `# k! u8 s4 N$ u0 ^69
70
) f1 B- S; {* F, l71
2 M: N; o, X* I- T$ A- |0 z5 y/ ?- g72
73
74
2 K# w  G; w6 K5 p2 e+ Q4 t! N1 Q6 a75
76
: J/ v4 |: }+ y77
# u- ^& k2 _: U5 V, }78
' s; _# p8 H7 K, }7 [, u79
80
0 Y$ i" i$ B6 i9 [- P81
# E) R2 S6 w7 S. _+ c82
83
84
85
/ }# |2 ]& ^6 k/ g# M; f- @" D7 d86
87
88
89
90
! w+ S2 @0 J4 X% |7 j  w9 f91
* |. A* w2 C; |4 j直接选择排序
9 P% x0 k. c( {- r* M2 x6 w0 g简单解释：
数组分为已排序部分（前面）和待排序序列（后面）
第一次肯定所有的数都是待排序的
# z) V- Q: N" s/ m7 k2 t% U$ u9 N从待排序的序列中找到最大或最小的那个元素，放到前面的已排序部分，然后一直找，不断缩小待排序的范围，直到所有的数都是已排序的了
" O- |' y/ L& k0 o1 F
/ b* `2 R* F1 L/ Y9 s  P) P

  |, S- w% D4 R% U) _6 _

3 H1 Y+ F1 m: |8 ^$ Z
& x8 h4 B- Y! B' y完整代码：

) }7 L6 U  u, D# g
. o# E  C2 s$ [- ^package com.keafmd.Sequence;


; k0 Y) Q/ n( h/**
' D9 ?5 S* c8 I * Keafmd
1 [: Q! |) Y. f/ x *
* @ClassName: SelectSort
4 a  Z  I8 [+ X; h) }+ Q * @Description: 选择排序
* @author: 牛哄哄的柯南
* @date: 2021-06-24 10:33
  O2 D/ H  @7 P# a8 u8 H */
public class SelectSort {

/ h: L) \8 ]8 q
    //直接选择排序
    public static void selectSort(int[] arr, boolean ascending) {
        for (int i = 0; i < arr.length; i++) {
            int m = i; //最小值或最小值的下标
% Q- w! R+ g, ~! r            for (int j = i + 1; j < arr.length; j++) {
& a! n* k  ]0 d9 w% m                if (ascending ? arr[j] < arr[m] : arr[j] > arr[m]) {
: W% T- N- @; R/ W' V5 _                    m = j; //找到待排序的数中最小或最大的那个数，记录下标
                }
, \- h! D5 M5 k: Y# X* n7 f, c6 y
3 Y5 |! _) [2 x, e
            }
            //交换位置
            int temp = arr;
# e! [6 i+ h, @            arr = arr[m];
            arr[m] = temp;
0 j( B2 R% g6 d; ~* N1 b/ S
! I/ C% \5 j! \4 x. \; H7 C
2 M+ `4 b3 t; J- f  D% m        }
    }
" A0 i1 }5 @' h
: O' A: O# i6 w7 k1 L
    public static void selectSort(int[] arr) {
        selectSort(arr, true);
    }
1 B* M- R! z3 u' z" A. \4 d$ @}
8 U4 K& V: Q2 @/ R1
2
( |" j! C$ ]0 {0 q# u3
' o1 ]# ]1 p: {4
5 G0 P1 W3 U1 r( R' t" Q5
! y# S. S2 ~8 n. a, x" ]" |6
7
# y( r( e# P. k  E- h" W8
5 \9 s2 Y9 H% v/ W- Z, z9
10
6 u% K7 J6 `& a( U& }3 D11
12
0 @8 J, I+ C; p13
14
15
16
17
$ m4 L! v7 n+ I5 O2 P18
8 h$ E5 U" a8 c( ^7 X( Q  g19
$ |. ?$ g9 ?7 K0 g20
21
22
23
( ^$ I* k; @# b24
7 M& C3 P2 u* p* P* M9 O25
26
27
3 v; @: _5 h2 G, n28
1 o! Q7 M$ `! G* U29
30
' k  n* c6 ~3 N  D  g5 v, R! ]( c+ B4 }7 ^31
32
33
34
堆排序
- C$ M9 Y8 }$ s5 M0 E' A, J* O先理解下大顶堆和小顶堆，看图
/ Q: W/ ~6 o- R6 B/ M& E8 \6 {大顶堆，双亲结点的值比每一个孩子结点的值都要大。根结点值最大
小顶堆，双亲结点的值比每一个孩子结点的值都要小。根结点值最小


2 c* |) t0 ~3 K! a8 }- }5 z# M
! C# O6 E: ]# Q* m- r
$ t6 T$ s4 j" j) Y3 z! r简单解释：
构建好大顶堆或小顶堆结构，这样最上面的就是最大值或最小值，那么我们取出堆顶元素，然后重新构建结构，一直取，一直重新构建，那么最后达到排序的效果了。
4 b9 K/ N# @# _+ M9 F0 f8 S0 u

$ s- ~" j' X, i( i

& q/ J3 J1 r0 E$ \0 [

' W) ?" Z1 r. [  T) e7 n完整代码：
; D; f7 v1 X4 c$ G

package com.keafmd.Sequence;
- Q2 N* H( s: H" {6 e
3 _# o6 h7 |6 i+ T, z. q/ C
) x! D/ X' F6 \: m; o/ p/**
  v% X3 p( @' x2 u% C: B * Keafmd
*
* @ClassName: HeapSort
1 \! @  j8 U' p; t * @Description: 堆排序
7 a' R. z9 k: w) V * @author: 牛哄哄的柯南
* @date: 2021-06-24 10:34
* A+ H9 ^; j& i% P2 [1 S8 [ */
public class HeapSort {
3 s; f, o5 o; k

    //堆排序
    public static void heapSort(int[] arr) {
        //对传入的数组进行建立堆，这里默认建立大顶堆，进行升序排列
        heapSort(arr, true);
+ ?3 a& X9 \0 X5 x, E" T6 \& x6 |    }


7 r) e+ W8 B; [- N% p% e6 N    public static void heapSort(int[] arr, boolean maxheap) {


        //1.构建大顶堆
- b' t6 O2 k0 p2 L1 [        for (int i = arr.length / 2 - 1; i >= 0; i--) {
3 x% u8 z0 j6 |' B9 V9 a            //从第一个非叶子结点从下至上，从右至左调整结构
            sift(arr, i, arr.length , maxheap);
, f% q' i$ K! o( M: v& y4 F        }


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


+ b1 B/ b) y/ s! x            //现在的数组第一个就是根结点，最小值所在，进行交换，把它放到最右边
* c2 y6 z. D' b3 t            int temp = arr[j];
            arr[j] = arr[0];
            arr[0] = temp;


            //重新建立堆
            sift(arr, 0, j , maxheap); //重新对堆进行调整
+ n. F" ]5 F& g: r9 n        }
( l5 ?  D9 v& |! p5 W1 M* A    }

3 o( L4 S2 b$ G7 h; M( m4 S
: {" t2 T0 m' X0 \    //建立堆的方法
, e5 l5 H) j! [1 U    /**
3 g' j/ L' D, G$ d4 L" ?     * 私有方法，只允许被堆排序调用
: G$ O5 y( m9 o) f9 J     *
1 @3 ?% V0 C( d6 T7 z* H& s     * @param arr     要排序数组
# M6 l* {* M: k/ v( \# k. ^     * @param parent  当前的双亲节点
     * @param len     数组长度
     * @param maxheap 是否建立大顶堆
     */
    private static void sift(int[] arr, int parent, int len, boolean maxheap) {
5 e2 j# O, _0 F# }$ h
; x; ?. n  n8 C2 N+ O. ]/ |3 q
1 g2 F/ f% R2 f* C        int value = arr[parent]; //先取出当前元素i
5 R) n' B  C  D- n  b: X" p& i
5 Y6 T1 N, V4 d% S6 i& J1 h  s, \
/ S( \# m; {- y) J        for (int child = 2 * parent + 1; child < len; child = child * 2 + 1) { //从parent结点的左子结点开始，也就是2*parent+1处开始
8 @- ~  e5 w/ w# G/ Y; T4 B
. O+ b' x1 |& C- ~
1 c! q9 o( Z' P            if (child+1 < len && (maxheap ? arr[child] < arr[child + 1] : arr[child] > arr[child + 1])) { //如果左子结点小于右子结点，child指向右子结点
: G: l. v6 h( L                child++; //右孩子如果比左孩子大，我们就将现在的孩子换到右孩子
1 a) W" _: k$ z' k# E, W7 @. R/ y            }

. j$ r" Y: n, {# ]2 Z
            //判断是否符合大顶堆的特性， 如果右孩子大于双亲，自然左孩子也大于双亲，符合
; Y; b# h/ \. s! X: I# w            //如果子节点大于父节点，将子节点值赋给父节点（不用进行交换)
6 F6 J6 b1 q  r4 v7 |- \* l            if (maxheap ? value < arr[child] : value > arr[child]) {
5 N; B. b& U/ k; L                arr[parent]=arr[child];
                parent = child;
9 I3 r3 i3 j0 V+ e' [            }
            else {//如果不是，说明已经符合我们的要求了。
/ ~( @, h6 B% n                break;
. ]; I1 R" A' `0 P            }
3 q/ v7 R5 ^3 {6 M        }
        arr[parent] =value; //将value值放到最终的位置


- ^1 f  b6 z) I

    }

% Y# C9 z8 s2 I9 S' Y
& f2 t9 F4 g% w2 @" y; \# G}
1
( @: q- _+ u, C& `2
8 _3 b. q: S2 ]7 K3
% G9 l" l; l: B- r4
5
6
+ J2 A5 A3 L0 q" S8 O7
; x. F8 }9 w2 I! k) y4 e8
( n: r# w# x' n: x9 F# L9
) f2 |2 e( m7 t10
- i' s5 r% P8 w. ?. H5 j11
12
13
14
5 E/ P( B& g. F  N$ p. {& j) T1 ?15
16
  p: |0 x$ G5 I) S17
0 }9 e- _1 `' S8 o18
19
20
21
4 W, o% V% s& J3 e22
/ W2 u2 y7 }. K23
24
25
26
- x) i( Z; J4 Y9 J2 `27
) g8 b+ _  g/ Z3 C! V  w28
/ [% z; Y( W5 _  A: Y( y29
30
31
32
33
34
7 O$ g) y1 Q# J8 R3 N* e35
# t- ^, Q- m4 [5 d36
37
3 M  g4 r& M- T( D7 T38
39
40
/ ?; K* B. l7 a1 M" M* E41
42
6 K; B, `2 \1 @  x' H43
44
6 }: z7 L: r; G' D2 ~45
46
47
9 H6 J1 b5 I4 H2 }48
: c- |- v" K, l2 Q, U4 v2 ~49
50
51
52
1 A% ^5 J! z# W8 |1 w- d" ^4 u53
54
55
56
57
/ m+ O; M: |3 r( h58
59
60
61
4 ~  F' R! I) H62
5 ?' l: p1 R* c63
1 e6 r* {5 Q3 c5 q64
65
66
67
- T6 T3 i; f$ ~& u) o68
! m' M- a5 S+ e5 n1 d, k. X$ i69
9 R, s: J6 @3 G7 |! M70
71
- P( Y, z2 }. J72
- E) }1 h3 E- p: J73
7 _3 v3 |$ w% z3 \; H2 s' K74
5 a4 b  J! [% C5 U6 y2 I归并排序
简单解释：
该算法是采用分治法，把数组不断分割，直至成为单个元素，然后比较再合并（合并的过程就是两部分分别从头开始比较，取出最小或最大元素的放到新的区域内，继续取两部分中最大或最小的元素，直到这两部分合并完，最后所有的都合并完，最后形成完整的有序序列）

0 U3 Z/ T# V/ {& C2 F  U/ G6 G




完整代码：
& q7 I8 c' m0 P7 q% C: C
+ U+ B) y& Y7 Z) H6 `! c
, N5 f; j9 t, b; T9 z. C) ^: Gpackage com.keafmd.Sequence;
$ m; R7 I+ ]: b

/**
* Keafmd
, x5 ~$ n$ s  r# `8 v *
* @ClassName: MergeSort
* @Description: 归并排序
* @author: 牛哄哄的柯南
0 |9 M* X2 G# ?9 X  k' _ * @date: 2021-06-24 10:35
*/
/ J! l/ M/ B) n# k0 ypublic class MergeSort {
: N  E6 p! _4 J0 W) Y2 v0 q

5 x, K7 Y( v- w( P8 r# f7 k    //归并排序
    public static void mergeSort(int []arr ,boolean ascending){
        int[] temp = new int[arr.length]; //在排序前，先建好一个长度等于原数组长度的临时数组，避免递归中频繁开辟空间
' ]) h# _: d# Y2 s$ N! P        mergeSort(arr,0,arr.length-1,temp,ascending);
  `9 O' ^* \. B: V6 |    }
    public static void mergeSort(int []arr){
: S( F, W$ f7 N) G        mergeSort(arr,true);
; o5 {8 |& z% T: W+ c    }
; o0 {) u3 z; a' s

    /**
; b3 }- G! E2 `3 w1 K9 n     *
     * @param arr 传入的数组
     * @param left 当前子数组的起始下标
, ^1 L" Z6 n& Z' H     * @param right 当前子数组的结束下标
     * @param temp 拷贝暂存数组
     */
6 E3 c; s; t" w6 x    public static void mergeSort(int []arr,int left,int right,int[] temp,boolean ascending){
        if(left<right){ //这里是递归结束的条件，我们是对半分，那当left==right的时候肯定大家都是只有一个元素了。
. T& o8 c3 W5 X! b3 w% p1 Y

" n# F$ h+ F0 [- w            //对半分，比如总长度是10，left=0，right=9，mid=4确实是中间分了，0~4，5~9
            //当长度9，left=0，right=8，mid=4，0~4，5~8
$ r7 D- B7 N6 C4 {# H7 W3 p$ g            int mid = left + (right-left)/2; // 防止越界的写法
5 c5 @) O( S- X# {8 r' Z            //int mid = (left+right)/2;
% ~' N3 v5 v- V7 ^5 b

9 r6 t9 T6 O" m# Z& I4 R8 I            mergeSort(arr,left,mid,temp,ascending); //左边归并排序，使得左子序列有序
            mergeSort(arr,mid+1,right,temp,ascending); //右边归并排序，使得右子序列有序


            merge(arr,left,mid,right,temp,ascending); //将两个有序子数组合并操作
        }
    }
1 U& u" C" L" s
8 `3 A" I( S+ E
/ X" C5 B+ q) h- i; A    private static void merge(int[] arr,int left,int mid,int right,int[] temp,boolean ascending){
        int i = left; //左序列起始下标
        int j = mid+1; //右序列起始下标
+ A/ `3 N2 i# L7 c/ {5 y1 z8 ]        int t = 0; //临时数组指针
        while(i<=mid&&j<=right){
            if(ascending?arr<arr[j]:arr>arr[j]){ //比较两个序列第一个元素谁小，谁小先拷贝谁到temp，然后对应子序列下标加1
* o7 o/ y  e% u                temp[t++] = arr[i++];
0 I6 u5 f2 {7 T2 p            }else {
- ~7 S) V6 R6 Q2 z/ S                temp[t++] = arr[j++];
            }
        }
/ D3 z0 N3 v! @+ U) Z+ M; V

! z- |, p* b, O( _# k        while(i<=mid){ //将左边剩余元素填充进temp中——左序列有一些数总是比右边的大的数
7 R5 |; z: @. ~4 d, C+ m            temp[t++] = arr[i++];
" x+ F( x9 `2 E7 X( {0 _        }
  N& G* m, X$ ~/ I2 {% ^3 I

        while(j<=right){ //将右序列剩余元素填充进temp中——右序列有一些数总是比左边的大的数
2 Q* ]  H" K* c/ d            temp[t++] = arr[j++];
2 e3 a7 T5 n* O2 }        }
, a; |  @* q, q6 C

        t = 0;
' p( Y4 x0 L' l* M

4 r0 k$ B+ ?# Z8 E" n6 u2 h        //将temp中的元素全部拷贝到原数组中
9 D5 t* }$ l! U1 K" ^! }        while(left<=right){
8 ^( g. Q. ]& o# Z6 g            arr[left++] = temp[t++];
        }


( ]) L8 Z3 t1 d2 z( h* H% H    }


# D/ L" i& q! r, t}
  w& V0 A) @" y9 A0 D: t1
; `( _" E/ o# M- e9 W5 j2
3 t5 h0 L) g5 T/ o' O3
- M9 ^1 h3 ?( N* j4
, W2 W5 B9 r8 p% m& v" |3 Z  z5
6
7
$ p) r7 w; {2 |! b8
9
; g+ ~7 V5 g3 p5 b+ j; z: @2 n' `10
7 Y/ u' E+ k; Z4 U$ P# P$ D4 `8 V11
0 i0 R# R% H+ i2 v) G! `8 Q; _12
+ |, L" J1 L8 w9 V) |! ~( }6 R13
14
15
. t6 i$ E$ m, ^; D& v2 K16
: X& n5 Y# M% p5 E* _17
( s. v' t5 b) F6 ]3 V% I: x/ }18
# D# d- W" _( ~1 F- I  z1 Q19
20
( N+ }3 I! P& |8 p& G/ B( p21
22
7 g8 ~6 [' _/ F* c23
24
# x7 Z" c1 C! H6 H3 m# p25
26
27
' g1 W% B# @: D0 b28
3 P9 k0 Q: U/ H8 i! Z2 l/ m29
30
31
32
33
34
0 i+ n) F9 r& v* M8 _& t35
36
( y/ w) P) x. a  d$ |; O37
38
39
! x) C1 l* F( o, `7 f/ o1 q40
# y% P. {; j& s( }5 u# M' [6 h: z41
: K, w9 o7 ?* Y% q42
43
2 n; N" P9 J! Y# H8 Y5 S1 X9 b44
45
46
$ p7 \( r$ p9 e9 O47
% g- u( X9 r. d48
9 K  G- w3 w3 c. _49
50
51
52
53
54
5 _' B; N8 t- l' ?55
- _4 C! R% M: X' w56
57
58
3 a! X$ {6 A; b7 g0 z7 @59
60
2 a0 z! e- r- J) `8 ]61
" B6 M+ e' n: t+ c& F0 h62
63
64
# b- o1 N9 W* V+ i7 K65
1 b, w9 b6 u1 [' @66
7 J; p$ }8 H0 ]0 b% y67
4 }6 M" Z8 g$ V' [/ I. }68
  [  a, N/ r; q) J1 ]9 _2 Y69
( o& H0 Y( s/ F+ K- k70
: |) D: C" N# o1 d" M2 T; Y5 N+ k71
72
/ F( n* \1 O6 D  B4 Z- z73
) g2 n! Y# v- G2 `" ^插入排序
简单解释：
& K) F- m& f& h) H9 a1 E6 T最简单的理解就是打地主时我们拿到牌后的整理过程，从第二个牌（假设我们拿起来这个牌开始比较）开始，（说下升序）从后往前比较如果比前面的那个牌小，就把牌往后移动，直到找到一个合适的位置（这个位置的前面的那个牌不比这个要放下的牌大）就把这个牌放到这个位置，慢慢的前面的部分变得有序，直至全部有序即可。

9 C3 ^" ~4 B7 B. Y8 U6 i: @
6 Q, N: H2 ?, p
9 \& S9 E0 T. @& E1 v2 T) k! o

. k1 ~  J! M# E
完整代码：
! m2 z: ~& C* e* }2 b* q9 m4 ]& n

package com.keafmd.Sequence;
8 g+ u% b' `. }  r
! y) P4 p, X: a/ i6 J5 p7 x' |. v
/**
* Keafmd
*
* \% y; ?5 p# t! ^' v * @ClassName: StraghtInsertSort
* @Description: 插入排序
* @author: 牛哄哄的柯南
6 J: Z% _/ I1 p2 ] * @date: 2021-06-24 10:36
6 q% p- G' E  `3 R8 g4 Y& D' ? */
1 w* s2 }6 r' ^5 R) u; }3 ~2 ^public class StraghtInsertSort {
    //插入排序
, v9 @' A" Q9 {  f! x& U    public static void straghtInsertSort(int[] arr) {
- Q! C8 e. h# r1 b' L        straghtInsertSort(arr, true);//默认进行升序
) {, l0 W# m7 `0 m    }


. E( T  {5 ^) O% H" i  K  ~    public static void straghtInsertSort(int[] arr, boolean ascending) {
0 G$ Y1 d$ A6 _! q. d5 R

        for (int i = 1; i < arr.length; i++) {
: T/ @- T! V$ v, ]7 A& V  e            int temp = arr;
' l+ C: n& ^7 D            int j=0; //这就是那个合适的位置
0 c- y: @( b  l1 A1 Q( C            for (j = i - 1; j >= 0 && (ascending ? temp < arr[j] : temp > arr[j]); j--) {
$ Z9 P; B- u* K4 f                arr[j + 1] = arr[j];
% r( g3 V. ]* K) Z            }
! p! Y5 {* v$ a- \            //把牌放下，为啥是j+1，
            //是因为上面的循环遍历到不符合情况的时候 j是合适的位置的前面的那个数的位置
3 e+ @4 }* f$ d4 P4 X( p            //有点拗口，但是就是这个意思，看图方便理解下
            arr[j + 1] = temp;
8 d0 R3 `# E5 |0 b" T" i4 a" s5 M' P
* \  K& {3 X+ l/ Q  F, W) j2 c4 I
  X1 @6 g8 w; F" x5 I

        }

. i' l+ |" z0 N% E5 ~* O3 @
    }
}
' M* Y5 k1 E: ]: D* t1
2
3
- s5 G* y  [- N; e5 m3 @. ^) M3 f! O4
5
6
7
8
9
0 a, q, T5 O0 N! L" J10
( c) |0 x  n' k" s( Y11
& W) k) _+ ?6 c12
6 E& T" L0 r: `* E" x& r13
3 X$ m& S$ z% O, X14
3 k+ I2 q  v5 T* S4 }0 |15
' t1 C+ L, x: E0 x* F& E# ?) \" z6 Y! z16
17
18
; p1 p% o+ Z9 x+ x" B19
% a% b$ z  f7 _8 d4 L- C5 k20
2 |! g8 Y6 A. d: ?21
22
23
24
% t' d" I0 w; L25
26
4 [& V) b. d1 M8 R' m0 b8 q; }6 W27
6 \  Q  C. [+ K9 b! @28
29
30
31
5 q* n/ c# l: m: b8 W/ n2 F32
: N! a2 f. f7 A7 {8 y33
8 q, S" |& I, U, ^& \. Q34
4 f/ N* `2 J6 `希尔排序
# E. P* Y0 w4 z8 K+ K  G简单解释：
* Z, D- C, ?5 p" C$ l. q希尔排序是插入排序的改进版，我们理解一个叫做下标差的的东西，也就是下面那个图中的增量d，初始下标差为arr.length/2，然后继续/2，对在同一下标差（相当于把这几个数单独拿出来了）的若干个数进行插入排序即可。



; d* v+ v2 k3 Q1 Z7 R! E' ~& w
5 B+ O) j& ?& |. s" l
. j5 b  M* W/ W
* m) N% d' w& a0 _1 p完整代码：
. L; k9 L: \$ Z  F6 F$ E, c& v" [
! @4 t! P* B4 E/ u. Z, u
package com.keafmd.Sequence;


/**
* Keafmd
! D2 Z# J! U! J5 W *
* @ClassName: ShellSort
4 U% s3 p" t- e. I3 Z* M * @Description: 希尔排序
* @author: 牛哄哄的柯南
* @date: 2021-06-24 10:39
0 R4 C! c! F( v' @8 E, P */
public class ShellSort {


0 R- T* I: _6 g. k    public static void shellSort(int[] arr) {
- F& O1 Z0 {# J1 ]        shellSort(arr,true);
3 Q7 J! ?1 A( u    }
. y' s: `4 M9 e) J7 s; M* N

    public static void shellSort(int[] arr,boolean ascending) {
: u; H8 Y4 V+ K2 L9 X: R

* b! P( J+ `& j        for(int d = arr.length/2;d>0;d/=2){

2 V/ M) _0 L- Z1 q: o
            for(int i=d;i< arr.length;i++){
! b! a! b7 a* c& V                int temp = arr;
                int j=0;
8 f2 H& J4 P" h# j( Z/ @! G                for(j=i-d;j>=0&&(ascending?temp<arr[j]:temp>arr[j]);j-=d){
                    arr[j+d]=arr[j];
                }
                arr[j+d] = temp;
/ X; @7 `( G% [% P. q* e            }
" Z  C# E" u: r1 s        }
1 A( E) Q9 [( h: _( Y
  ?( |; t+ H- }7 l( E$ z! |# L3 l
/ R9 O( _% H( ]9 |) ]/ p+ C" K    }
: K3 }2 x1 i" `3 n}
4 x' q4 \0 x9 ]/ @3 R, W1
2
3
4
9 p- S4 b/ N- M5
7 ?3 ^: N" @( t  w6 B# F. F4 f6
, K3 F  j! A/ m- q7 d1 S! ?7
6 w0 l; k0 @) G7 ^8 a8
9
  m6 r) l) i  a0 D% A10
11
) z8 q3 V* x6 j) g) z* z! a7 s4 b( |12
13
: b; c2 L' j4 I# {9 B8 v4 A14
15
% S9 R8 k, }, l3 h7 q6 ^16
17
6 l* O, u2 e, Y' V7 A18
; |/ B3 I; K/ f3 D/ K19
# Z9 y" q( r3 _+ M20
21
22
) ?/ A4 W" W( [) m2 x* T23
2 F4 _; e: x! `: |3 e24
25
26
* K; b6 ]7 K6 ~% r' S  P" H. e27
28
29
30
31
# L4 ]/ T, j& i5 }32
; g- I: t4 L% }1 N! p计数排序
简单解释：
这个排序算法看名字也很好理解，就是就是额外找个数组来计数，然后在这个数组从小到大或从大到小把数取出来即可。
+ }- {% X& b  b6 u7 G

. P- m  \4 \" Y
. C: J: p! P  b$ \1 a- l

* |" z- \4 ~1 |3 {
5 P  m$ s, p# J$ N! ?完整代码：

0 R: K$ W% v7 \  Z) G( A
package com.keafmd.Sequence;
% u/ F; w' M) C4 E+ b( `

/**
* Keafmd
*
2 x: @( o5 m! E/ S5 j- s' q, Q * @ClassName: CountSort
* @Description: 计数排序
% b+ O; S% J4 S+ \ * @author: 牛哄哄的柯南
( C0 f3 ]4 G3 \+ y# S, D * @date: 2021-06-24 11:31
*/
public class CountSort {
5 f( C& W+ k  s. |0 P1 q  _

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


    public static void countSort(int[]arr,boolean ascending){
3 k! w+ r% a, A! I2 W* n5 M6 ?3 r9 r        int d,min=arr[0],max=arr[0];
/ s4 J: P& @. h# U( J

4 Q. A- F5 g' Y+ G        //找出最大、最小值
4 ~0 g7 a) U8 N, {' }        for(int i=0;i< arr.length;i++){
            if(arr<min){
                min =arr;
, }1 E0 c8 I# o6 @  q. U            }
8 v5 d8 a$ Q2 D% m7 z8 e1 M: v2 n            if(arr>max){
0 @7 E- N4 L* O( s7 E% E                max = arr;
9 _- V; g) L( z' D) X0 b5 Y4 M            }
        }


7 ~5 U8 G+ s/ k3 }, t- ?        //建立一个用于计数的数组
        d = min;
        int[] count_map = new int[max-min+1];
3 C" B; N$ x  g9 T        for(int i=0;i< arr.length;i++){
5 B) O  G+ r; R            count_map[arr-d]++;
        }

  k: A9 Y% G( ~  |8 v8 q9 g+ v
        int k =0;
. x" J" t4 S* a4 a        if(ascending){
$ a2 y+ v! L) y            for(int i=0;i< arr.length;){
+ w! t. @5 j' R$ d                if(count_map[k]>0){
                    arr = k+d;
                    i++;
                    count_map[k]--;
                }else
                    k++;
            }
        }else {
            for(int i=arr.length-1;i>=0;){
, r2 g* [4 h1 G! M5 x( ]                if(count_map[k]>0){
1 E' x& W5 l9 d$ r" `                    arr = k+d;
                    i--;
* e& c* c3 J# z* r4 U                    count_map[k]--;
& G: e8 D  W6 k9 k4 ~                }else
                    k++;
. u  }- x( y3 S* ]1 A            }
+ N9 p# H$ k. q: \8 U/ c        }


' C$ |7 [1 T5 z( D- Z9 v    }
}
8 N8 p" k4 R/ ~* b# o1
( ^) `: q( G. Y2
3
( b! I& l% n: d" E3 e4
% \; ^4 g4 b5 s0 m5
, S! Y$ ~: x$ c* ]2 [7 C6
0 a+ S% t3 v2 t3 j7
8
" |' C' H! q4 t, O; x. v' s9
10
11
* z1 W1 }; ?# u% P6 m" p12
13
! ]: u: W' q$ s$ d7 {8 B8 S! g( \14
8 W7 i3 c8 x3 A% _15
0 v9 Z0 ]0 X: U( M6 y, f16
3 K8 q6 E* H. f' A* J1 A; ?17
18
19
20
5 O6 E- G. @& A/ n! w21
22
! g3 S2 L; B  p2 S1 M" b" d23
24
. l4 J" c+ t1 _25
26
27
28
5 i6 A, M. j8 X* J+ d29
30
31
' n. B7 M6 H) x32
6 ^9 v; d/ q( ]$ Z33
34
" W0 p0 g  x  X% t, Q  N* a0 E35
36
37
! K2 e. r# l6 \" M/ L38
; _1 I- B6 _9 M3 C39
40
41
42
+ K: F# {( Y2 D) [( x43
44
45
46
0 w! [5 o, Z. V# G& t& R% ~47
48
49
50
51
, t9 ~& e  Z$ _+ J; v52
& \/ C3 T0 x' E2 q% M# [53
4 a* p& A; u+ ~. k0 I! r. Q54
2 k% w4 ^4 G4 \55
56
7 d- R6 B8 v4 u" P5 J2 \/ x2 H57
58
59
& X) b" |; i% `3 R桶排序
简单解释：
就是把一个数组分成几个桶（其实是几个区间，从小到大或从大到小的几个区间）装，然后让每个桶（区间）有序，然后取出来放一起就可以了，相当于把几个有序的段拿出来放一起，自然还是有序的，当然需要是按照区间的顺序拿了。
  u- z! |  u" D. K* H

/ h8 A8 ?- r0 g1 H! s) z! t* c$ _

6 e& a3 G8 ]. g4 M! x8 d+ L& }

完整代码：
/ s: t* E" a9 U$ L8 ]: ?

package com.keafmd.Sequence;


import java.util.ArrayList;
2 H3 d* r! D" b0 _$ C9 bimport java.util.Collections;


/**
" K0 i$ M7 R1 [7 g( h * Keafmd
4 G# w! X' [! D* { *
* @ClassName: BucketSort
* @Description: 桶排序
+ g, {3 f' e8 @" }- L2 H * @author: 牛哄哄的柯南
* @date: 2021-06-24 13:32
1 A# ?5 G% ~% r( Z: e$ U3 J. X */
, A- A! \/ H( Y. g' Z" Lpublic class BucketSort {

/ \8 H0 F# T% k. P( J1 U  W
    public static void bucketSort(int[] arr){
4 {" Q+ e' M1 \  P        bucketSort(arr,true);
1 o4 p  A2 J3 H0 A3 T, \* b    }
6 Y; N4 Z5 E6 M/ N
0 X% D& I# Y. w( _1 x8 {
    public static void bucketSort(int[] arr,boolean ascending){
        if(arr==null||arr.length==0){
            return;
        }
' s: }7 N# `! S9 O9 K: ~) r/ @- x        //计算最大值与最小值
0 a  x/ {: x( v4 \3 U9 m" l$ L        int max = Integer.MIN_VALUE;
; }' C" q- d% F$ u! \/ Y- E: U        int min = Integer.MAX_VALUE;
: h8 a! E0 K6 `4 j, m        for(int i=0;i<arr.length;i++){
3 a) t7 `1 }4 }* {% D            max = Math.max(arr,max);
            min = Math.min(arr,min);
1 U/ t8 F* v+ a& @- f! Y        }

3 t2 m( R. H# m- j4 f8 B
        //计算桶的数量
        int bucketNUm = (max-min)/ arr.length+1;
" l* Z! m$ p& ]+ A4 G' {        ArrayList<ArrayList<Integer>> bucketArr = new ArrayList<>(bucketNUm);
        for(int i=0;i<bucketNUm;i++){
            bucketArr.add(new ArrayList<>());
        }


        //将每个元素放入桶中
        for(int i=0;i<arr.length;i++){
            int num = (arr-min)/ (arr.length);
            bucketArr.get(num).add(arr);
        }
( {! y( ]2 E1 k( y9 _  ~
& U  _4 @% b7 y8 k* e+ R7 b
: V+ e) {& \* M        //对每个桶进行排序
3 W* E& m  G+ _, H0 O3 d        for (int i = 0; i < bucketArr.size(); i++) {
8 J# q! q' F+ l' r2 |            //用系统的排序，速度肯定没话说
6 X# P* J" A. u: m) d& t" [& F* A            Collections.sort(bucketArr.get(i));
        }
! ~; `+ @% [' G+ O  k
8 A6 x3 s9 }# c& g) X6 P5 t, u
        //将桶中元素赋值到原序列
" k9 {- {/ G+ j" v: y+ |0 F- B* z        int index;
        if(ascending){
            index=0;
( X: J2 j- C$ {2 w        }else{
) y5 {# @8 a) @1 Q& R# d            index=arr.length-1;
        }

1 X, D2 l* y6 L. r
8 N: H+ q7 ?) F; M        for(int i=0;i<bucketArr.size();i++){
            for(int j= 0;j<bucketArr.get(i).size();j++){
                arr[index] = bucketArr.get(i).get(j);
1 h9 T6 S7 F0 R3 D% H8 I( ~' m0 x                if(ascending){
                    index++;
                }else{
4 v  h9 w, t% B                    index--;
                }
            }
8 u- M% H9 B% Y8 H
/ O) S3 w$ G' T: t& O4 n9 h
        }
8 d) _# P! C) o+ J7 h4 O% y
2 Z# o0 X4 N# L8 Y
    }
% B! C3 |; q: e# C2 C}
1
2
3
4
) [6 m3 I: t! E9 ~, `1 U5
6
7 N2 n) \3 M" Q% P2 E* }% o: E% O. u7
! J, N) K3 T% n/ U8
9
10
11
' Z1 b; E/ s% {# v' F" E3 I12
13
# @0 O3 D7 |4 H; {4 A! S4 a0 a+ c14
15
16
# u. a1 m& g. L6 H! L, O# O; r17
18
19
20
" f  H# H1 k' t! a: l8 o# C21
# h3 x, [1 Z7 @6 R$ y22
23
, D$ ?- ?+ P# h" d' t7 z24
7 s" X  ~! E" h% m& }25
. u: c9 `: C9 O) X$ _/ F8 h26
. G% J# y! }' f! Y4 o3 f# ^' r$ B27
28
29
30
31
6 ~* T& C- E% H% q32
; I9 V& m/ T& H( o/ w, a) f: b. J33
34
. r' n' W' E6 O35
36
, o' ~5 H4 [9 H' t: {. L7 x* n37
38
9 [  G1 I8 S! l: ~) L39
40
5 e3 }, G$ K9 A41
42
43
$ Q# T* `$ h  u/ I9 h4 o44
: ~  J3 _  f" i& f1 M# }45
46
47
; P- U/ W" M' z, O48
49
50
51
52
53
! a3 x2 U/ Y0 Y0 \  B54
55
56
# k9 t3 s# H! Q# S: E57
* T, m/ m( ~6 R6 J9 q' S  T58
59
60
61
62
3 E# |, H* J! Z8 |) s! F9 D63
64
+ N, f0 t% j0 C% c65
$ k9 m* R) a: Z6 W$ b; u3 b: }66
5 O1 m7 \* ?/ n* f5 A; m67
# M& g& f$ |! j8 ?! @68
# N5 I; `1 a; H/ I& N/ a69
- M8 ^% t! _5 N' j9 W. Y, ?8 l70
8 z  g0 Z9 y! ?- D) g5 j$ }! A' y71
72
1 Q# m6 {9 P6 l5 |# g基数排序
7 C5 m: |1 u% j  ~- t( Z简单解释：
首先说一下，我发现好多人写的基数排序只能排序正整数，其实只要处理下就可以排序含有负数的了，就是我们排序前先把所有的数整体变大（就是减上最小的负数，也就是加了），都变成正数，然后排序好之后，在减下来（加上最小的负数，也就减了）就好了。
+ V" q' w* ~# H. _7 I- F$ s基数排序就是按数位排序可分为LSD（从最低位[也就是个位]开始排序）和MSD（从最高位开始排序），下面写的事LSD基数排序。
/ z/ D1 T" B0 l基数排序就是把数按位考虑，让后我们一位数只能是[0，9]，就是我们在考虑某位（个位、百位· · ·）的时候就只看这个位的数，放到在[0，9]相应的位置，然后顺序取出，最后再按其它位这样操作（上面说了要不从低位开始到高位，要不就是从高位到低位）
7 p6 f( s# E- @% c: R; c7 E
6 ?" B: I( M) T* b% Q


8 S5 t* J8 R9 r$ w

完整代码：
. B/ U4 X  U! K

package com.keafmd.Sequence;


/**
* Keafmd
*
7 j8 j0 N. |# K! u1 i* V * @ClassName: RadixSort
* @Description: 基数排序
& O: C2 p& E- {# L * @author: 牛哄哄的柯南
8 j/ s! `) a' I) v& |# E0 A * @date: 2021-06-24 14:32
' v/ @7 j4 h3 c3 t2 _' F0 c' G( u1 T */
public class RadixSort {
    public static void radixSort(int[] arr){
8 L, _, z5 o' _5 v6 R        radixSort(arr,true);
    }
, K4 O, ?5 m" A, J8 N8 h: j! _    public static void radixSort(int[]arr,boolean ascending){
        int max = Integer.MIN_VALUE;
        int min = Integer.MAX_VALUE;
" q; X* N0 p/ k) b3 S        //求出最大值、最小值
        for (int i = 0; i < arr.length; i++) {
: Q+ q& K5 `; C* x) o( k            max = Math.max(max, arr);
7 x/ z: \, r- E$ N5 X! j            min = Math.min(min, arr);
$ m2 R( o  W5 |1 z: K# e3 Y* q. ]        }
1 ^) @$ [* m& q% \2 \' p        if (min<0) {        //如果最小值小于0，那么把每个数都减去最小值，这样可以保证最小的数是0
# S, U1 J/ {3 R" [5 c% b! L            for (int i = 0; i < arr.length; i++) {
2 i5 ?/ {# d3 W/ r$ ]( M                arr -= min;
# p* I1 }) _+ L# t0 ^( i            }
( ~" _) C* S7 Q" _8 Y! h            max -= min; //max也要处理！
        }
  k7 A. S- V7 }) W        //很巧妙求出最大的数有多少位
        int maxLength = (max+"").length();
" i% c, ~, b8 x' o% Q+ i        int[][] bucket = new int[10][arr.length]; //一个二维数组，一维代表0到9，二维存放符合数
$ w  Z+ _1 X0 b6 Y0 X        int[] bucketElementCount = new int[10]; // 用于记录0到9某位存在数字的个数
        for (int i = 0 ,n = 1 ; i < maxLength ; i++,n*=10) { //个位 十位 百位 这样遍历
# i. P& S9 O( R- l3 ?  D            for (int j = 0; j < arr.length ; j++) {
                int value = arr[j]/n % 10;
                bucket[value][bucketElementCount[value]] = arr[j];
                bucketElementCount[value]++;
/ }. Q5 ?  p/ r+ g            }
; {! Z1 Y( V. a6 A
! s' D3 _' l& ?
            //升序
: U9 Z; m# x7 ]' L) C% S$ H" G7 K4 B            if(ascending) {
& L- W$ W9 b) ^: G; X4 x                int index = 0;
5 w8 J. w5 ?  {+ b6 G! w, b$ ^* D                //从左到右，从下到上取出每个数
1 @1 }2 @2 G5 z. @                for (int j = 0; j < bucketElementCount.length; j++) {
  b8 M- v& V. F3 P                    if (bucketElementCount[j] != 0) {
% \( D$ ^# C- R  \$ [                        for (int k = 0; k < bucketElementCount[j]; k++) {
                            arr[index] = bucket[j][k];
                            index++;
                        }
                    }
                    bucketElementCount[j] = 0;
                }
            }else { // 降序
                int index=0;
: N6 n3 d& C( o1 \# q& w# A                //从右到左，从下到上取出每个数
- b+ n4 ~& E& F4 I# y+ o% ~. H                for (int j = bucketElementCount.length-1; j >=0; j--) {
                    if (bucketElementCount[j] != 0) {
                        for (int k = 0; k <bucketElementCount[j]; k++) {
                            arr[index] = bucket[j][k];
8 D5 _7 b4 p( E  }8 g* ~: Z                            index++;
' y5 d) |# R( B8 @" E" q5 k6 y/ X                        }
                    }
' i! e  D% L$ V6 T( w                    bucketElementCount[j] = 0;
                }
) _6 w* P# L1 m1 t) S0 w" u7 G3 k            }

+ y2 ^* j; y* d: t( E

+ L' D; L3 J) c9 o/ k; D
            /*for (int i1 = 0; i1 < arr.length; i1++) {
6 Z2 {* |; ~/ S7 ~$ L! g                System.out.print(arr[i1]+" ");
/ r9 G. ~4 L( J2 w            }
# ]  ?; |, ?4 [( a* }6 ?            System.out.println();*/


. G: Y( ?+ n4 |' _1 q" K# V

7 ?" B0 I( u- r: L0 v( U) E
% d' Z* D1 T# d3 T" w
        }
/ Y" Q7 Y( r- m        if (min<0){
            for (int i = 0; i < arr.length ; i++) {
                arr += min;
6 }5 D* @, s( y0 J            }
4 V! ^* f5 a+ z* @! f* o        }
2 h% W' C7 q- M8 a7 C

. d/ Z7 V6 y; Z' E2 t2 c5 B( F    }
}
1
2 E+ o: B" z: I* c1 l3 t4 u2
  s3 B4 E2 c9 `) ?' X8 |  Q3
4 l3 n6 D5 e4 m6 p+ H' F( w4
5
' [# ~- M' z, r& r6
7
& j9 ]4 \; \* _, J% w& A8
  y, O0 e9 o+ K3 T1 S. o" |2 S5 W9
10
11
5 S: y, |1 }" D, S6 v12
  M4 Z7 b; w! L! r# @7 X/ G13
14
+ O# ]$ |) h0 V- t( e15
16
, {  d9 b  @. I6 W7 ~/ u; I5 z7 Q* F17
3 e% p% N. l0 ~, W3 T; y18
% T1 `. n5 z! s: `7 g4 ~19
20
" P& n( p9 m- R9 V# W, B; k: G9 f) I21
1 Y( N; d' i; W7 ~' G6 ?2 F22
23
. M. a& R  J2 e! v9 l: P) j8 H3 k  e24
% ~8 e% \7 B7 \  h- ]9 b% i1 G25
26
, J0 I! s3 Q! T8 s1 m27
28
7 Q% }1 P" v7 s, Z; q* p% C29
30
  z# _8 {3 B+ W  A# \31
32
33
7 ^% W! b: R% s6 o4 J4 y- C34
8 P8 I; d. u" ?$ G) G8 }35
0 s3 D. U; ]5 B  [8 t36
37
38
39
! [/ W5 J6 [7 y& `0 o40
41
42
1 f5 b! O$ }2 S  T$ x/ k43
44
& |* k# ]6 Y8 J. Z# ?45
' e2 m7 B  u8 W# [( p46
# R! M$ d- h7 \' }47
! z( d2 Y; u0 S0 H! V4 U48
+ w& l2 T% {5 m/ c8 C! g49
50
51
52
; s# q4 @& y: B7 k- e1 n9 b53
54
& L! c# a7 t/ A, e55
/ y! A. W# H0 @- l( [56
57
58
! s" U6 j/ v' Q2 Q$ p: B. u5 ^59
0 H4 z! V; L0 f60
61
62
63
64
65
% Y8 K/ o" d  `# d# E7 E6 N) U66
67
68
69
70
71
) J( I/ q4 s+ x6 }72
1 T- K* x8 P* I! g. s# ^3 N73
74
9 Y% t7 y' H) P7 v  e: [* I3 h75
76
77
1 i0 B" Z2 L9 k7 e) f! I5 C78
2 v- w# S4 A: P4 m79
% o! g8 g" h# G; |' x8 h80
81
# H3 Y9 y# \  [  m, m7 p- o82
83
完整测试类
5 A* V- a5 v" r" i  Hpackage com.keafmd.Sequence;
& f3 o# p; @! Z& G8 ]6 R
) Q$ o. x+ h4 C- O& h, J$ {6 x1 E. [' n/ k
import java.util.*;
import java.util.stream.IntStream;
import java.util.stream.Stream;
2 M5 W3 x- H; ~/ {7 ]

/**
* Keafmd
3 B; i4 l1 p, U3 u4 u. s% T( ^ *
2 s$ I$ Z) T: M2 C/ t1 \) H3 D * @ClassName: Sort
* @Description: 十大排序算法测试类
* @author: 牛哄哄的柯南
* @date: 2021-06-16 21:27
*/
public class Sort {
$ \1 M- \! f  I# {  o" X
1 D- {; F/ r  ]6 p2 u

1 \1 r) y# h' G" _
* t: u5 E* O9 z$ v    public static void main(String[] args) {
5 O( p% D& d2 I+ p+ q# `+ B! Z6 S/ C

        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};
% M; L4 _. V. @" x$ o" J! {; V$ u        int[] temparr;
# p2 H7 b# ~: j

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

6 G6 [) s/ H3 @- N$ D
- e; [2 v# d5 i: Q! m6 v1 D2 J        //将int数组转换为Integer数组
7 w, m9 u7 k: |* Z; \3 ^. ~+ X        //1、先将int数组转换为数值流
# `. k1 ]8 `& L7 @* H$ E; G        temparr = nums.clone();
        IntStream stream = Arrays.stream(temparr);
        //2、流中的元素全部装箱，转换为流 ---->int转为Integer
        Stream<Integer> integerStream = stream.boxed();
1 i5 ^: i+ L. q4 G( ]        //3、将流转换为数组
4 C' H* W' M. T2 `9 T/ ^        Integer[] integers = integerStream.toArray(Integer[]::new);
( N, j8 V$ @8 n& N9 l. m+ y        //把数组转为List
        List<Integer> tempList = new ArrayList<>(Arrays.asList(integers));
        //使用Collections.sort()排序
        System.out.println("使用系统的Collections.sort()的对比:");


        //Collections.sort
        Collections.sort(tempList, new Comparator<Integer>() {
$ Y) R: G6 y; V% h. N! h. E- B0 F            @Override
            public int compare(Integer o1, Integer o2) {
1 V- w- j. @* X7 ]2 d5 V                return o1-o2;
                //return o2-o1;
" q) k3 @* s# K            }
9 c! [* X& ]* Z: K* d  T6 O2 J        });

* A. m  v3 h  \! o3 D  p, Q; C. A
& }( \; g% X. D, ~" C, u; g, K        //tempList.sort 也可以排序
       /* tempList.sort(new Comparator<Integer>() {
            @Override
& B6 |' x6 D5 Q& E' `6 h- N5 @; g: W7 o            public int compare(Integer o1, Integer o2) {
! y5 ]2 G* A! i7 q) d& H                //return o1-o2;
                return o2-o1;
            }
        });*/

3 n1 U7 @9 m; ~' K4 L+ t
& W. C# U5 Q- Y$ a) I        //遍历输出结果
        for (Integer integer : tempList) {
            System.out.print(integer+" ");
        }

- p' X# E4 K0 ]: C" f5 e
        System.out.println();
5 n% ^0 }1 R7 H6 \

        //测试冒泡排序
6 R& w( f" `' n( s# u& S: L" R        System.out.println("测试冒泡排序:");
  A* {- @6 d/ S. g7 t& R        temparr = nums.clone();
3 K. U* Q5 k2 i) [7 e

8 f3 ]' M! V% f0 {: [        BubbleSort.bubbleSort(temparr);

% x0 D0 p( f5 ?* L6 D4 S
        //降序
: x8 u7 T" t. _* x. C2 ~  T) R        //BubbleSort.bubbleSort(temparr,false);
; M- C4 g  c& e3 b% c& T- {
8 Y. d; y7 ]) t) p
0 L, A* E, r. l$ v( X  {9 \/ c        for (int i = 0; i < temparr.length; i++) {
            System.out.print(temparr + " ");
. K, k9 k! N$ r8 ~+ e        }
        System.out.println();
/ q# q5 O3 \6 U  C- Y

( l+ \. W+ j9 I# `- E0 U5 q" K        //测试快速排序
        System.out.println("测试快速排序:");
        temparr = nums.clone();
, ]# o/ o% `' C. f9 O        QuickSort.quickSort(temparr);
        //QuickSort.quickSort(temparr,false);
        for (int i = 0; i < temparr.length; i++) {
- m2 i" I7 G' k( A3 z            System.out.print(temparr + " ");
        }
        System.out.println();


, f3 v7 R2 L% m: C; l6 O+ t3 M. i- G- u        //测试直接选择排序
- F. F4 w7 I! x% C& A& f1 [        System.out.println("测试直接选择排序:");
        temparr = nums.clone();
) k4 h2 W! X% i, ?7 _, b0 Y        SelectSort.selectSort(temparr);
3 h% {! W' {% v9 Z6 S        //SelectSort.selectSort(temparr,false);
. M% O: N! s! N! [3 h/ Y        for (int i = 0; i < temparr.length; i++) {
4 ~9 |$ u* U9 G3 N' F# T& ~            System.out.print(temparr + " ");
        }
- u+ v# N( a$ V. ]        System.out.println();


- P2 ^# M" m/ U        //测试堆排序
        System.out.println("测试堆排序:");
        temparr = nums.clone();
& D& o' K( C( q8 l        HeapSort.heapSort(temparr);
        //HeapSort.heapSort(temparr,false);
        for (int i = 0; i < temparr.length; i++) {
            System.out.print(temparr + " ");
        }
        System.out.println();
7 `9 R/ S/ ?( p' ]. Q

        //测试归并排序
" L- ~$ D  e& m" d9 C        System.out.println("测试归并排序:");
% e5 j4 ?: [4 [9 y* i: i        temparr = nums.clone();
$ F& R* ?5 H' Q8 ^2 W6 j  H! Z        MergeSort.mergeSort(temparr);
        //MergeSort.mergeSort(temparr,false);
        for (int i = 0; i < temparr.length; i++) {
            System.out.print(temparr + " ");
        }
6 r2 }  y3 z  B" L+ W2 r* ~        System.out.println();

( h* {7 x# W/ Z% o
( x9 m* F& f/ d) R- K        //测试插入排序
+ `2 a7 k( d# g        System.out.println("测试插入排序:");
        temparr = nums.clone();
! G" @, \: K5 \6 ?4 ^: b8 x        StraghtInsertSort.straghtInsertSort(temparr);
0 ~0 C( o* J3 O+ {( R9 M        //StraghtInsertSort.straghtInsertSort(temparr,false);
        for (int i = 0; i < temparr.length; i++) {
            System.out.print(temparr + " ");
        }
: w) ?, \! E+ m; w2 z- D/ U- o        System.out.println();
. }/ l2 @: P3 Q; n8 v5 [


# j; f- Z7 t% r( K* d: ?
        //测试希尔排序
8 H* Y8 Z( R. G: \        System.out.println("测试希尔排序:");
        temparr = nums.clone();
        ShellSort.shellSort(temparr);
        //ShellSort.shellSort(temparr,false);
        for (int i = 0; i < temparr.length; i++) {
- R* Q. n3 h% I& i1 B6 I            System.out.print(temparr + " ");
( t+ h  i7 A5 o5 V; G6 C* N        }
        System.out.println();

% R" E: T2 d5 A9 [& P0 U


( b# h" x3 F9 _0 c2 \/ Y        //测试计数排序
. E( j$ r) h1 y5 T        System.out.println("测试计数排序:");
2 J; _0 @2 i4 _& X; y        temparr = nums.clone();
9 V; _. L9 S( J% R, K9 t  m+ c        CountSort.countSort(temparr);
# t  y& d( `; q+ P, I- o        //CountSort.countSort(temparr,false);
& |0 l7 r- @" q  M        for (int i = 0; i < temparr.length; i++) {
            System.out.print(temparr + " ");
- b- f3 N3 k" q* }7 A$ p        }
8 Q3 G' r( ~5 D# W1 @1 W        System.out.println();
9 O1 @6 }* z; z/ Y* `! H



$ C. c5 l+ Q  X        //测试桶排序
        System.out.println("测试桶排序:");
2 t; a3 c: j6 e$ {        temparr = nums.clone();
        BucketSort.bucketSort(temparr);
1 U% `0 ]* Z( W. I        //BucketSort.bucketSort(temparr,false);
        for (int i = 0; i < temparr.length; i++) {
& @, l+ F- ~  A# `, i' C/ [' t            System.out.print(temparr + " ");
. l- d2 C% w- d2 |        }
        System.out.println();


% x. }- U8 M; W: i' S2 K        //测试基数排序
        System.out.println("测试基数排序:");
        temparr = nums.clone();
! T: B2 Q% l' }) M1 k$ @        RadixSort.radixSort(temparr);
        //RadixSort.radixSort(temparr,false);
        for (int i = 0; i < temparr.length; i++) {
            System.out.print(temparr + " ");
2 o* G* z) G7 H, x        }
6 u9 Z7 k! U. c, G* q        System.out.println();
2 N9 ~& c  q4 g' N% `& b- S! h( C

    }
9 p, ?, o- j6 \. n6 R
, R4 \7 u& Y" {' O/ i' e
! M$ v; h* G1 Z9 N, A3 ]" z8 d}
2 |. }5 Q/ k% m, J% [* Z1
2
3
& F4 I& j3 C2 q- \4
5
# m/ J4 _6 u" q: Y* W# D! u6
, b9 a, G. ?. D/ I9 `! U+ N, R7
8
9
$ g8 O6 V7 A4 d9 z" k( F10
11
12
13
14
15
16
) Y6 q4 q3 w: I% U  C3 q17
18
5 j0 D+ V' f* s8 g" c& B6 G19
20
21
& Y* z7 s" L4 r& O# f22
23
24
25
26
) c& [3 y1 K% J# F/ J8 p5 J4 Q27
/ V3 @9 T2 W1 s; q( W28
29
30
$ t- o  v: P/ s' x31
9 B' {2 ?: h$ M) Z32
33
34
35
0 A" n$ K, e% a- n9 ]1 N36
37
38
39
0 Y* |8 D& a( E& `. b( E40
41
42
43
44
45
* O6 i1 Z) m% {+ ]46
47
- k$ e" K* o; ]2 d: Y4 F+ Z3 b1 M5 s48
49
6 V  T, u+ t! C2 B# ^7 t50
9 p7 s1 K9 Y, U6 t5 a6 I/ G: e51
52
& Y' L5 f& a, `9 N53
7 s2 ^: [! T% d' n' |& B  {9 j54
55
56
: ?  n" m3 i; Z* Y2 S) S3 B57
3 H! d+ |2 b* B9 _6 W( j58
59
' ^6 K' ?" E: v60
8 }* u0 {( {- i" A61
2 o7 B) u$ D. K0 R9 P62
63
9 Q# U: B% D$ S, A64
: ~' X: h9 u5 w! T' c. B+ w# K65
1 t. {7 ~2 w7 a5 w6 E% ~66
67
68
' Q% p$ d- G. F- n3 F/ [1 n69
, j  {4 w4 ^' `7 J70
71
72
6 N7 @% g9 V- x+ F: j73
74
75
76
" o& v) q$ t9 K77
* F: M, G" R5 I' u' ~: Q, z78
79
+ N; m5 |" i0 Y% u( O' z0 Z# ?4 }80
81
82
9 n) \" z2 H) w5 S* }83
84
# s/ e: p' k1 C. z1 Y! D  Y85
. C) P; U) q" Z1 A7 {! q7 X% I86
87
% W, z% P$ v3 y0 D0 p2 {, u- |88
" c) b' f. E& F2 l8 q0 Q! ^89
8 o/ i. w1 m; S7 X90
: F" J& a8 E" h' B8 q91
$ W( B( ?9 Z  J# [92
93
94
4 K$ C$ Y0 C* Z95
96
, l8 i1 K4 f9 B# y( F97
98
99
100
101
102
. P8 T# k) @- ~9 X# V9 B: I103
* ^3 S0 X/ g6 E1 K  `& c4 c104
105
106
* _. J+ m- q3 O9 n: c0 D107
108
109
110
111
112
' I/ ~7 b6 \7 B5 s113
6 C# Z7 ~4 C! A2 i114
115
116
1 I& i; F* x4 W& W! e9 |; H117
118
. x7 ]4 N; b0 U' e( J+ [119
120
  s9 e5 h+ i0 F' ^1 L121
$ p* A  }2 l! L& T122
9 l& y0 j; q7 U123
, a; Y4 z$ c( |* U# m7 y! R5 i124
4 ^, w4 R2 z; g; b& K- O125
126
127
1 d( C4 h0 L% ^# f128
129
# p: [0 N1 z  i# `130
131
2 T! P. u, q, U% n132
% [- w# ?* T' J+ Y133
( P) q- F4 M4 F# s* C134
% ]0 L2 T" L( E135
# p' v) ~/ o6 p% H+ R- X3 F4 D136
# [/ Q% \: l1 e) d3 r/ u$ U7 S137
9 X6 G! I: W9 X: l- T% g) |& k138
) _% @5 A0 {2 ~( P139
9 R9 M7 ]5 ~! ]# W" c$ s3 F140
141
142
143
144
145
146
  c& l3 }9 c3 j* c: Y# V147
5 b- [$ a5 R* }' L; D% H148
8 T* I" o3 n. B$ S8 @3 N149
7 C2 p, f, H4 j: F150
: o0 v  h& z  g; r* A151
152
153
154
155
' q/ u" x3 |2 G" }9 @156
+ n- {1 x/ a1 e157
5 l8 z; Q8 _* N" I158
159
160
161
162
, v8 S; g$ Y4 s- }163
- ]. [: G# U6 D+ e$ |" H164
; ~% H5 F  b# F5 {6 i! D165
166
6 A# E% N8 K4 ?167
4 O9 _& l  x8 c8 t168
9 }8 X: U) B5 z% Y0 i' f7 p, K# _169
170
171
/ u; y* x$ v: L& d: m4 l- K172
) s; E* N# A! B3 R& X; j. R173
每天进步一点点！
& H' U) l. w% z3 Z9 }- g1 j不进则退！

& h7 x( J6 U& \& H' D. c
* }' k8 k) a2 a& x5 I& {3 l版权声明：
原创博主：牛哄哄的柯南
; w( ?2 E2 N# s" \& S1 j! |博主原文链接：https://keafmd.blog.csdn.net/
————————————————
版权声明：本文为CSDN博主「牛哄哄的柯南」的原创文章，遵循CC 4.0 BY-SA版权协议，转载请附上原文出处链接及本声明。
原文链接：https://blog.csdn.net/weixin_43883917/article/details/118193663
, s" e9 R7 V  s
0 W% z! [- m% J5 x" }- k
, Z1 P) u, B4 f6 s" n

1051373629

每天进步一点点！