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

杨利霞

经典十大排序算法（含升序降序，基数排序含负数排序）【Java版完整代码】【建议收藏系列】
经典十大排序算法【Java版完整代码】
写在前面的话
十大排序算法对比
5 R+ P' A$ e6 `5 i0 o5 D7 \冒泡排序
  H; F% Z* S3 M  C  @2 \! V快速排序
直接选择排序
堆排序
归并排序
插入排序
希尔排序
计数排序
桶排序
基数排序
完整测试类
写在前面的话
( P- H; z4 J8 F       虽然已经有很多人总结过这十大排序算法，优秀的文章也不少，但是Java完整版的好像不多，还存在某些文章代码存在错误的情况，同时也为了自己练手，决定把所有的写一遍巩固下，同时也真诚的希望阅读到这篇文章的小伙伴们可以自己去从头敲一遍，不要粘贴复制！希望我的文章对你有所帮助，每天进步一点点！！！


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

. n) s6 Q5 H2 j9 R; |5 s
- \8 y8 e4 }4 P十大排序算法对比
9 k: q; o% M* ~* T
3 ?$ Q$ a& L2 I) @6 f
, W$ W2 [: D$ R6 E
- ^5 A7 {! D4 l
2 ?) @% V/ @2 w$ s' K+ o关于最后一列的稳定性，我稍微解释下，例如对序列：1 2 4 2 6 排序，序列中存在两个2，如果我们把这两个2标记上（让他俩不同），排序之后，前面的2还在前面，那么就称这种排序是稳定的，反之不稳定。
6 E) b6 Y: ]2 w, N' k% r
" M$ ^  s, I2 P
$ {4 l; w/ ^4 u8 ~$ T, @! E5 \冒泡排序
简单解释：
       原理就如算法名字一样，就像水中的气泡一样，每次我都把最大的或最小的放到最后面，这样总共需要n-1趟即可完成排序，这就是第一层循环，第二次循环就是遍历未被固定的那些数（理解成数组左边的数，因为每层循环都会把最大或最小的数升到最右边固定起来，下次就不遍历这些数了），两层循环遍历结束后，所有的数就排好序了。
       两层循环所以冒泡排序算法的时间复杂度是O(n 2 n^{2}n
2
)，是一个非常高的时间复杂度，我在下面的代码进行了优化，加了一个标志位，如果上一次循环未发生交换，就说明已经是有序的了，就不继续下去了，反之继续进行下一轮。

: I) k# y3 f! r; t+ m# b% I% F
" I* @3 o( A  L" g
2 \6 j9 F' b0 `; ^- h

! V7 ~4 q$ @- B8 Y1 a4 \2 X  D
; \: D) ^- z/ A* x- S: r, {' f本文的图片来源网络，仅用于大家学习，侵权联系删除！（下同）
1 d+ p4 [! s$ `5 I

- p4 ]# `" p+ _- q+ _- K3 E完整代码：
/ z8 m; `3 K2 f, R. ^- `
) H* `8 Z( x4 E$ }+ S2 S" s
# T. b* p8 q* A$ opackage com.keafmd.Sequence;

$ i% i9 G( b9 N; U" E
/**
* Keafmd
7 S- A' @# c% A' E *
& z( Q5 I# p$ G+ A1 Q) Q2 J* J) S * @ClassName: BubbleSort
5 r' d# q  |2 ^+ ]( A3 {. |* a$ G * @Description: 冒泡排序
* @author: 牛哄哄的柯南
* @date: 2021-06-24 10:31
2 _3 @0 x7 O- P6 Y */
- D6 g( X9 P. X9 Z$ S) v% T0 Fpublic class BubbleSort {


    //冒泡排序
; z, v, Z% @) ?! G" u    public static void bubbleSort(int[] arr, boolean ascending) { //exchange标志表示为升序排序还是降序排序
' O# w5 ^6 X9 V+ ^% c" ]

        boolean flag = true; //加一个标志位，记录上一次是否发生了交换，如果是，我们则进行下一轮，如果没有，说明已经冒泡好了

7 Q! \4 {' ~: [5 v  N% T2 p: R; B
( ^3 ^  y+ P1 Z8 a8 }# J0 F0 u        for (int i = 1; i < arr.length && flag; i++) { //控制次数，第几趟排序，只需要n-1趟，有交换时进行，只有flag=false就说明上一次一个元素都没有进行交换
. h& W* C$ T  @' \! o
4 p# j1 _" @6 u7 w, y: z
2 b# `& P" |! E            /*System.out.print("第"+i+"次遍历：");
            for (int i1 : arr) {
                System.out.print(i1+" ");
5 Y  e% w) m) J# s+ e  u            }
            System.out.println();*/
8 \9 P# K4 G6 j/ S  U
: Q  m$ r# [* c$ N# h; b
            flag = false; //假定未交换

9 W/ A! m- }4 u
9 K& c, F8 y) a: `            for (int j = 0; j < arr.length - i; j++) {

& {6 @. b* k# V. V: n
                if (ascending ? arr[j] > arr[j + 1] : arr[j] < arr[j + 1]) { //控制升序还是降序
                    int temp = arr[j];
                    arr[j] = arr[j + 1];
& @. v; h4 Y1 a0 Q                    arr[j + 1] = temp;
                    flag = true;
                }

+ H  y; M/ ?7 o
            }
        }
9 C% X% K2 F$ r$ K" {' p1 ]$ u. M/ d    }
: J9 s# Q/ v6 N+ J% m% |
$ i' ]* k3 J$ c, M) W- c9 U
    //冒泡排序 -- 默认不传参升序
    public static void bubbleSort(int[] arr) {
        bubbleSort(arr, true);
    }
}
- r+ C! t+ T5 A2 J5 t( n4 e1
2
8 {4 Z. \& n" y  r1 F2 f- u8 C! u3 b3
/ V( C# \, R5 y0 Q4
5
6
- |1 ^# D* e5 `# g7
/ A1 M6 ~0 }8 L% w# ?* g9 ]# }8
6 C6 H: g2 x( b& d1 w6 I9
, A1 p; _: s! e: r( s9 H2 g  W& F10
11
12
/ `8 L) s& n. V13
14
: t( b- ]5 [: z: u( l" H: n3 W7 e' L: n15
16
) t5 T& ]6 Z# o# s0 G+ `17
18
19
& V! M+ Q: @3 H# e8 M6 Q: a20
21
22
% ~% C: o7 f* v2 q6 k, K$ ~23
4 V; B% x; }9 ?- V" y* C5 p. S- k24
25
7 f! e% s. i; k+ c( j" X. G/ m26
# a6 ?' E0 [; b2 `8 R27
% Z1 }( s; r$ v3 j28
2 B9 T6 w8 ]+ \/ U; I( _! V29
30
2 }* `$ o% X2 M" M' q0 G& m  N6 V! r" z, S31
32
33
9 R8 N% u. n- e0 S+ ]  z34
35
" r: D4 H1 a3 K, h/ J36
+ P2 O7 R$ @, g, l2 P" A# ~37
38
, g$ O& \& ^6 A39
. J: [3 Z  j- B/ X8 U40
41
- R; f0 U5 I2 ~  e7 S42
43
44
# F# S6 p+ @  X  Z8 Z- h45
# F  U$ o! H1 f7 ^( j测试代码：
  D9 u" x+ V% U0 Y- T1 O

# K3 W2 {# k6 n7 H# N升序排序（从小到大）
/ u2 M% j% E$ X7 H$ P- B
9 |0 G$ a: U) N% V8 B7 t
+ L/ {) i6 V, Y$ j; e" |$ Gpackage com.keafmd.Sequence;


$ ]1 |7 y* A; n% g* p" zimport java.util.*;
2 ^0 b/ o4 {: M3 L7 Jimport java.util.stream.IntStream;
import java.util.stream.Stream;
( B" A. e8 V4 j8 ~
( N+ [" x. ~/ D! a8 C7 L
4 f' l5 E0 S6 q; K/ @/**
' e2 B4 l7 h9 d$ D2 X) E * Keafmd
0 j, R7 k- C/ q *
+ K6 P2 |' H! h! c% E% [ * @ClassName: Sort
* @Description: 十大排序算法
* @author: 牛哄哄的柯南
; b0 v) F- m, e0 i0 I  c * @date: 2021-06-16 21:27
*/
public class Sort {
    public static void main(String[] args) {
  M2 D! p3 n( D5 _& Y7 [3 n
9 j( ?1 k! h% ]3 f
4 m: E: H# m. h' b        int[] nums = {12, 4, 25, 47, 58, 34, 25, 9, 99, 26, 1, -13, 162, 10093, -66, -1};
        int[] temparr;
0 q' X! E. a; Z9 Z! k0 _: b8 Y
2 h( A7 t) u3 W% w7 W1 O! ]
6 G* Z" E; F/ d0 n        //测试冒泡排序
        System.out.println("测试冒泡排序:");
# z( x% k& k6 }" l( W, {& L        temparr = nums.clone();
        BubbleSort.bubbleSort(temparr);
        //逆序排序
        //BubbleSort.bubbleSort(temparr,false);
0 x, D6 X( E5 i) x, A$ w        for (int i = 0; i < temparr.length; i++) {
7 z; v! y' a- |# b            System.out.print(temparr + " ");
+ e- V& ^- P" ]7 T7 y' x8 Y& f. k        }
        System.out.println();
" ^& c* O" J( K+ S9 I
; i3 {% t+ m# p' j& G. A4 F! Z
; K* J1 N( I  C# V6 e    }
8 I; O1 D0 d) T}
5 N: c: R+ ?3 e$ j! w4 U1
' j' e: b4 [4 c2
& m" w, l# p$ A# p0 f3
% C5 ], Y+ [8 }0 |4
5 M: I5 ]/ Z( N3 y9 j+ D- x5 N5
6
7
& C/ {9 g2 A9 ]1 A8 B% M4 P8
9
10
11
12
13
14
0 x; w; i2 @/ p  f+ [" m15
' {, U7 X) c' ?+ L16
17
. {% ~% h% ~8 l- a6 C18
" [. n. r* Z# @19
20
21
22
23
24
# d0 a, N. c! }' f25
26
27
  m% x5 N  L  q% V$ G$ d8 [8 |* Z28
29
- Q0 w$ g- w0 U3 v9 b+ I30
9 _  N" a- D$ v2 {% u31
32
33
4 o/ v0 i& G. T8 u% g$ M运行结果：
9 j5 Z0 \9 I, U
) W( X; G' w8 L: D& r. T0 d8 e# @
; O: ?/ {5 z0 S/ C! d) U测试冒泡排序:
-66 -13 -1 1 4 9 12 25 25 26 34 47 58 99 162 10093
/ e( ?0 |) j) m& C! F" P# w1
2
  D) |" }. V2 N6 s降序排序（从大到小）
9 ~4 W% H- r7 f7 h
2 B7 `. k5 O+ K. U1 E
  x! M  X( k* L7 R/ M//测试冒泡排序
System.out.println("测试冒泡排序:");
temparr = nums.clone();
BubbleSort.bubbleSort(temparr,false);
for (int i = 0; i < temparr.length; i++) {
    System.out.print(temparr + " ");
% z: L7 J+ Y6 k6 O, Y( D}
System.out.println();
1
2
3
1 H3 C, I, ]7 X9 C4
5
0 v2 i, S# N5 \' T& N* x+ M6
7
7 U1 w. K& V' C1 R8
运行结果：
; U9 V  \: S; _

' |" S3 W: B: I8 Z9 n2 ?( ^8 r测试冒泡排序:
10093 162 99 58 47 34 26 25 25 12 9 4 1 -1 -13 -66
4 n% _; H. O0 w7 k7 B1
2
下面几个算法的测试也就是换了下类名和方法名（换成相应的排序算法），如果想降序就在数组后面传个false即可。我就不一一复制了，我在最下面给出含所有算法的测试类，需要的自取即可。

  N3 f5 d8 I. R6 j- `9 D% A/ D
快速排序
简单解释：
快速排序就是每次找一个基点（第一个元素），然后两个哨兵，一个从最前面往后走，一个从最后面往前面走，如果后面那个哨兵找到了一个比基点大的数停下来，前面那个哨兵找到比基点大的数停下来，然后交换两个哨兵找到的数，如果找不到最后两个哨兵就会碰到一起就结束，最后交换基点和哨兵相遇的地方的元素，然后就将一个序列分为比基点小的一部分和比基点大的一部分，然后递归左半部分和右半部分，最后的结果就是有序的了。


' n- M) s$ q% E# e& I

6 u! Q0 e+ o2 |# @# O) H9 J  v7 r$ a
& a6 ?5 N, I. S9 d' f9 @* l
完整代码：

* c+ p4 ?9 z& g/ S( {* L
" H7 [: f1 s4 w% \package com.keafmd.Sequence;
, r. R- y% w) r

/**
5 C! B( v, E+ B6 g * Keafmd
*
  l0 O7 l# Z/ A! C * @ClassName: QuickSort
. ^" Y9 a/ {: e; g4 f. h * @Description: 快速排序
9 m& d( }. s; q) @5 p * @author: 牛哄哄的柯南
* @date: 2021-06-24 10:32
*/
1 ~! z  y  p) tpublic class QuickSort {
+ A9 Q/ t' x* v4 L

2 ?9 \$ h# e- V8 f4 c2 _. j2 M' v% K3 K    //快速排序
    public static void quickSort(int[] arr) {
        quickSort(arr, true);
    }
3 g$ l9 v) c# K' w+ W% X1 p2 P$ C* I
' l# L: O' C0 l/ H8 J8 U
0 f6 U2 l$ D. h- C* a2 v    public static void quickSort(int[] arr, boolean ascending) {
" I- E# J# h5 U& R0 {        if (ascending) {
            quickSort(arr, 0, arr.length - 1, true);
        } else {
% v+ R" A/ [5 d4 k            quickSort(arr, 0, arr.length - 1, false);
        }
: L. m. S/ `9 r. o0 E! U9 y    }
7 T& e- }" k1 a/ S# `+ |
; x6 E4 q$ `$ T! ]
    public static void quickSort(int[] arr, int begin, int end, boolean ascending) {
$ B; O4 [- L. d$ F" c5 k8 H( X        if (ascending)
+ |: z( |: f( ]8 E, l6 F& G* _            quickSort(arr, begin, end);
, t% x1 ~7 J  Q4 D: |        else
( `! G$ w; O* N            quickSortDescending(arr, begin, end);
    }


2 w  n: d+ \4 M$ \) f* G    //快排序升序 -- 默认
    public static void quickSort(int[] arr, int begin, int end) {
        if (begin > end) { //结束条件
            return;
        }
        int base = arr[begin];
: _  T. V  F) c        int i = begin, j = end;
        while (i < j) { // 两个哨兵（i左边，j右边）没有相遇
            while (arr[j] >= base && i < j) { //哨兵j没找到比base小的
: d/ ]2 n$ ?2 `7 S/ q/ Y" a                j--;
            }
1 `* G9 L- Q" P/ R! G1 ^            while (arr <= base && i < j) { //哨兵i没找到比base大的
                i++;
, Y6 F' ^7 u3 x8 Q            }
            if (i < j) { //如果满足条件则交换
                int temp = arr;
- s# z3 {, m) ^! F9 Y. k5 ]) a8 I                arr = arr[j];
                arr[j] = temp;
: r, D0 r1 H( T! K. T            }


5 o  @" P; y; r  N, W2 v/ |        }
1 r: ^3 V) v) X$ Y- u- }, K        //最后将基准为与i和j相等位置的数字交换
        arr[begin] = arr;
        arr = base;
        quickSort(arr, begin, i - 1); //递归调用左半数组
        quickSort(arr, i + 1, end); //递归调用右半数组
2 d& X& ~* P) A+ N0 \  _

    }
( E8 c9 K/ b0 ?4 _5 L& J6 {

9 f9 l6 w4 \5 C& a) m    //快排序降序
' \) u" |4 |( K    public static void quickSortDescending(int[] arr, int begin, int end) {
        if (begin > end) { //结束条件
$ z! M$ N5 B6 [" E2 C% A- H            return;
        }
        int base = arr[begin];
7 o# W' n( l; d  `) ?* V        int i = begin, j = end;
        while (i < j) { // 两个哨兵（i左边，j右边）没有相遇
            while (arr[j] <= base && i < j) { //哨兵j没找到比base大的
1 U* Y' C: q4 O+ ~. d1 q) ^$ E6 U                j--;
, ~2 @& h+ b: n- G3 v& G            }
            while (arr >= base && i < j) { //哨兵i没找到比base小的
: x2 ]; h4 P2 f- R2 z                i++;
8 L+ x" \4 b1 ^2 g1 J            }
2 w" S5 Q: k, S( v            if (i < j) { //如果满足条件则交换
                int temp = arr;
) a& v6 ^2 L1 z, ]. I8 X( j6 V                arr = arr[j];
                arr[j] = temp;
3 W% M- @- J$ O            }

1 H' e  j% R) f# T# j& o
1 X, q/ a$ x) C        }
; q2 V$ M  P1 F! Y+ l$ q! A        //最后将基准为与i和j相等位置的数字交换
        arr[begin] = arr;
        arr = base;
        quickSortDescending(arr, begin, i - 1); //递归调用左半数组
# E- I1 F& {7 B3 M5 _        quickSortDescending(arr, i + 1, end); //递归调用右半数组

1 g/ i  X5 I# W* `" J' {( z
# K6 E' V- N% Y8 \    }

2 E4 z) B7 u- a5 I& m6 x* @+ k
}
1
2
3
4
5
6
7
; B+ P/ A" p, ^9 e- O8
9
10
. G+ E& p, o5 H' i7 Y- Y; F11
1 H+ f: d3 h" m: a8 R12
13
14
15
16
& x1 m; X& X2 ]8 V8 f2 T17
18
19
3 t6 @2 r1 R+ I  P, |20
8 @+ a8 G/ ?, W+ d6 u6 b- D21
22
23
* f9 H6 Q; t7 a' a( t3 P' V24
25
: x, j; w& {: l7 X26
1 N1 J: g  Q& B6 O$ L% x4 `" N9 ~27
& a" e0 Q8 b( m! _  d! {28
29
- I* s: N& H  Y+ J  y! M" U0 h! [" ?30
31
32
, c% y( K; N; g6 Y5 v7 J7 @33
34
35
36
9 d$ b7 {3 v- @9 K( K! S37
5 N" b2 P' x* ^5 e$ L9 l38
4 O' P2 F/ `+ U8 M# _0 I9 _39
40
$ q# E" ?) w& s" n% F* @- V41
* {( z3 J$ e. A. @! O42
43
# ?- ]* Z2 R1 h" `2 b2 H44
45
) v: c& H# T- _. C. r& }46
47
' p& r/ k& W+ u! T48
2 {, D+ Q. B0 Q49
50
* z7 b4 U, j! w$ D. H51
52
; p* R* t0 n% {53
1 d$ A! {8 U/ F0 q54
- u6 Z6 |3 m3 X5 h! B! N55
56
57
" |  v4 @, L8 S" A58
0 |7 a6 ^8 y1 N5 J4 S59
60
8 X* e4 `$ `% O  d/ v& R61
6 n% ]) R" r# U$ W5 Y3 K1 j62
63
64
65
5 \. d* q+ P! O5 ]66
, B3 p+ g" k5 b7 _3 x  n# c  h2 w4 L67
  i2 u) F, r7 S' `0 V' @9 E68
69
70
71
72
73
- O; Y8 f3 e$ N. n, Y* h74
: e* u4 Z9 I& ]! k' I75
76
6 x" t+ c& b# a: h2 c77
78
79
7 {: A/ n- O- F+ a9 J, e80
6 u( G; E5 e! ^& A8 G81
82
. O! g3 u5 j; w! H& O83
84
% X. |% D+ m+ c85
( f# W6 H* s7 Z86
* s/ u4 }# q: j+ U7 m; p9 z7 f87
$ l0 F) ~0 H! p8 h: z" \88
4 @! z+ m- ?1 r/ ]8 m  d89
! D1 m8 \/ ]% ?% x: z90
91
直接选择排序
  I: o0 P( C6 V8 Z- u4 C2 `( s# X% p简单解释：
数组分为已排序部分（前面）和待排序序列（后面）
第一次肯定所有的数都是待排序的
. @% X; \+ B6 {: W从待排序的序列中找到最大或最小的那个元素，放到前面的已排序部分，然后一直找，不断缩小待排序的范围，直到所有的数都是已排序的了
( E, B8 O1 E; @: G2 }) S


; O1 R; R* O# R8 @# [* b( q' C) a
: N0 h7 T  s# c/ M1 K1 @

7 G) h( Z; p' d& M7 Y8 D# }' m1 F+ Z: A完整代码：
- O8 d3 ~5 L* J! W
; r" K: Y  _, v3 @5 F6 F3 p
8 D, o4 ?2 I2 E0 |5 Npackage com.keafmd.Sequence;


/**
* Keafmd
' `! ?" U0 p! ]( z( ? *
* @ClassName: SelectSort
5 T+ D& `$ j( k# U* U3 { * @Description: 选择排序
* @author: 牛哄哄的柯南
* @date: 2021-06-24 10:33
*/
public class SelectSort {
" y2 ~8 f* W& J& U' w2 g
2 s' C& A( |! A1 A9 p- r2 S# z7 }
3 M- X- W' K, N! D8 V    //直接选择排序
1 ^5 t4 z" Y1 ]2 N: z! K$ G# {    public static void selectSort(int[] arr, boolean ascending) {
! A0 x  o! j9 [2 n' ]: u4 t( |, m        for (int i = 0; i < arr.length; i++) {
            int m = i; //最小值或最小值的下标
* [. m1 p6 M0 O3 m. I( O$ D            for (int j = i + 1; j < arr.length; j++) {
                if (ascending ? arr[j] < arr[m] : arr[j] > arr[m]) {
. r8 y6 ?, b" X! k5 p                    m = j; //找到待排序的数中最小或最大的那个数，记录下标
                }

( R! B9 i* U0 k1 p6 c  `0 _6 V/ Z
6 w8 H5 i9 L* Z            }
            //交换位置
            int temp = arr;
. n4 v! K* J% `- I2 q% J            arr = arr[m];
  z- j- K* S" b5 W; |! i! v            arr[m] = temp;
9 ^; d) ^1 d% u3 [  T: x( H% L5 b1 K
2 o/ O( G5 p+ ]: G7 Z8 O% p  N
. p$ l- C  S; _        }
. f1 Z1 `. k& Q7 t2 {9 m! x    }

9 p; {8 F+ W( `: y! o. K% H
    public static void selectSort(int[] arr) {
3 c8 [2 `, Z9 }# i        selectSort(arr, true);
    }
" ]+ W1 R0 [3 F}
: V4 M3 h2 N. c) V7 {; f/ t& q1
2
3
4
, v. B# _- w" U4 g. E% i1 B1 ]5
7 G0 z1 i7 Q" f, o% Z/ S4 l, X6
+ a( K/ b9 z7 X7
8
0 L% E$ E7 T8 _1 U% m: z, v3 r$ X9
1 L/ m: a# {5 J5 x/ \10
11
8 D+ n/ `8 s' U  x- X6 x! N7 R# b12
13
' t7 \: Z7 F+ P0 J4 x! u8 M14
# ]. B9 G, Z9 z$ d15
16
17
18
19
20
21
3 a$ a" G  p5 q8 {22
  f+ ^6 t/ x- C' J0 G. }23
24
25
26
27
0 E# k5 c* Y/ X( `28
29
30
. \! a4 y) U6 o" z5 p& L5 M8 V31
32
( w) t! b2 V- \) |2 U; C# Q+ A33
& @2 J& f: P! N& @1 p$ J! f4 W34
8 V3 m) _! b* w0 z6 m) R+ v" \堆排序
先理解下大顶堆和小顶堆，看图
大顶堆，双亲结点的值比每一个孩子结点的值都要大。根结点值最大
小顶堆，双亲结点的值比每一个孩子结点的值都要小。根结点值最小
  B0 }( K* K2 m
5 d& ~& N5 r# L# W


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


# F$ o1 Q, `# R. I; h) O2 I


1 V) o5 R! s, j3 l. W+ d, [5 w
完整代码：
0 d$ G5 A! c5 E. j+ ~  D

package com.keafmd.Sequence;

6 L( N+ O# F: `! B; m
! M' k' a9 O6 c$ M/**
* Keafmd
*
* @ClassName: HeapSort
* B$ i6 _3 c% I2 p, V: q * @Description: 堆排序
* @author: 牛哄哄的柯南
! A0 ]/ |( w5 W5 I) f * @date: 2021-06-24 10:34
*/
public class HeapSort {
7 c  @0 S  J) c
9 ?, a7 P  p1 R/ s, A/ G2 r
    //堆排序
. @5 E9 A$ b+ }% g6 L    public static void heapSort(int[] arr) {
9 L0 T  K* a6 R0 C        //对传入的数组进行建立堆，这里默认建立大顶堆，进行升序排列
        heapSort(arr, true);
    }


5 `' H( ^( u; g6 |6 k    public static void heapSort(int[] arr, boolean maxheap) {
5 o& ^  B8 P# a1 b
) N( }5 `  w- I: l
        //1.构建大顶堆
. N& k* q! J% f/ m9 W  F        for (int i = arr.length / 2 - 1; i >= 0; i--) {
            //从第一个非叶子结点从下至上，从右至左调整结构
6 O+ V7 ~* G9 o! C( L! D            sift(arr, i, arr.length , maxheap);
        }


* u0 D* v% C( S; L! D8 q        //2.调整堆结构+交换堆顶元素与末尾元素
        for (int j = arr.length - 1; j > 0; j--) {

" |7 _2 s- A( P3 |! @
/ c4 T2 }3 m- W# E3 Z& n/ y$ V            //现在的数组第一个就是根结点，最小值所在，进行交换，把它放到最右边
6 V- S# ?8 x6 z" G            int temp = arr[j];
            arr[j] = arr[0];
9 c* r7 A( y+ l2 z5 ]- d+ N* ]& S            arr[0] = temp;


% Z4 s6 z; m$ _) ]8 K6 |9 g            //重新建立堆
            sift(arr, 0, j , maxheap); //重新对堆进行调整
5 x& b6 T9 s) I4 D+ ]        }
/ X: h2 ~& \1 n8 L    }
: C2 l1 h; ]0 m4 c
, J/ J! N  f3 M$ c% F' `
    //建立堆的方法
; Y+ {4 m# e6 L) W    /**
     * 私有方法，只允许被堆排序调用
     *
$ \' e/ ?- A2 C, A; C0 _! q     * @param arr     要排序数组
( C8 a4 N) o" O5 m* q0 M     * @param parent  当前的双亲节点
, l5 T/ s. g* e     * @param len     数组长度
% S- c8 o2 P0 }; a     * @param maxheap 是否建立大顶堆
0 E/ f7 }7 C9 M( y, A( p* N/ J; M  N     */
    private static void sift(int[] arr, int parent, int len, boolean maxheap) {
1 t) C2 S' c8 f6 `& \- x

        int value = arr[parent]; //先取出当前元素i
  Y: ^$ o& l: ]+ J8 V3 k2 J& p, r

        for (int child = 2 * parent + 1; child < len; child = child * 2 + 1) { //从parent结点的左子结点开始，也就是2*parent+1处开始


7 d) e6 V: `# D: G            if (child+1 < len && (maxheap ? arr[child] < arr[child + 1] : arr[child] > arr[child + 1])) { //如果左子结点小于右子结点，child指向右子结点
% u) j% h7 T- |  n                child++; //右孩子如果比左孩子大，我们就将现在的孩子换到右孩子
            }
! f8 K( J7 ]1 W, f$ r8 ]/ T3 C

) g) P4 D. G9 p6 ?            //判断是否符合大顶堆的特性， 如果右孩子大于双亲，自然左孩子也大于双亲，符合
            //如果子节点大于父节点，将子节点值赋给父节点（不用进行交换)
            if (maxheap ? value < arr[child] : value > arr[child]) {
                arr[parent]=arr[child];
7 w; R7 c8 K* K% s8 j. w                parent = child;
            }
' J( {& E/ _4 B- v: Y            else {//如果不是，说明已经符合我们的要求了。
                break;
            }
. k+ X% M; y8 h- T+ _        }
  O4 Y2 Z4 e  D. T5 m# P7 a3 N        arr[parent] =value; //将value值放到最终的位置

+ r8 d! X/ ~& x' D8 h5 W
% }) h! n- |$ n1 T0 q
6 a+ }/ F5 ~/ e9 Y1 M6 g
    }

- R; @3 d. r, s
}
: r  N" i' {6 [- @, u1
; L6 g0 u% _, k9 \# k2
3
4
6 y! J: Z2 }; v) B: F% o9 F# K: H5
6
. d! A, y3 W) a7
8
5 ^( s! @3 C. C- ], T9
10
11
9 r) K8 q9 P3 M: P$ x12
13
14
15
16
17
( z2 o! {' L) ]5 Z- A7 S+ A7 k18
19
20
8 t. J( {5 L$ F: F7 K1 j21
" `# v4 T( h& y$ w( D# ~22
23
& P- G) G1 }/ r: F: u24
  D9 J/ v* `9 R+ C$ A' K25
8 S  \" {; D5 i26
27
28
5 N5 X/ i" B+ B1 N% y4 E29
30
3 |9 f) J( F+ e! g; `4 c# T! t31
32
1 c3 D( B6 X- f7 n. N, m$ ^8 ]  K33
34
35
36
37
/ h, M* l4 w$ N% r  |1 J6 C38
6 D  l$ ~0 Z  K' y8 i39
40
41
  ~$ K* k, j- D% I+ T: e42
43
44
45
46
) y/ v/ B2 S0 g+ b47
. Z: o3 d0 @6 Z& `( m48
6 x) }6 O* y6 b49
0 w0 U* E. N0 C3 v50
8 M) h. {3 ?. D6 G. n- M51
52
) w% M4 H9 O/ @7 j1 U53
; u, B1 d9 E( r- l8 S% C/ ~54
55
56
57
1 F8 l/ u- Y) O1 d. \) P58
59
1 \: h! E4 M: O  @5 t4 W* b60
61
% A. y3 K9 [! Z9 a" L& `62
63
64
65
66
67
68
69
70
71
72
8 ?, B* ]3 y$ h8 @$ |5 q. ^, ?. W0 v73
0 T. d4 A6 u$ p, C( u  P74
3 _9 M4 @2 V+ K" {. J归并排序
/ o2 N$ l6 M# O& P简单解释：
该算法是采用分治法，把数组不断分割，直至成为单个元素，然后比较再合并（合并的过程就是两部分分别从头开始比较，取出最小或最大元素的放到新的区域内，继续取两部分中最大或最小的元素，直到这两部分合并完，最后所有的都合并完，最后形成完整的有序序列）




* {; q5 T+ O0 ?, g8 ]8 {% m( K
4 _# d8 y. Z( J2 S
- x4 Z8 }& i' d) q完整代码：

1 Q4 O' \2 `9 |8 r$ s" V
package com.keafmd.Sequence;
2 m) i: Q/ a, A

! N1 Z3 Y# |. C+ c7 V! y- ?/**
5 V+ @* n! z8 Z" y * Keafmd
& I- K# R: x; o+ _% U+ t3 ^8 Q9 s *
- G$ Y, S: ?9 B7 [. `% ?+ T * @ClassName: MergeSort
* @Description: 归并排序
* @author: 牛哄哄的柯南
* @date: 2021-06-24 10:35
*/
3 C9 d7 _4 Z( ~" E* N. Dpublic class MergeSort {
# M5 h1 Q- g* t9 n# n/ o6 f
: a) x$ Y: y* ~% m) Z- J2 V" p# H
8 x+ A$ ^8 b  I5 e    //归并排序
. z, @- ^: g! Y$ a6 }    public static void mergeSort(int []arr ,boolean ascending){
# @+ m  C. O! D* n/ h        int[] temp = new int[arr.length]; //在排序前，先建好一个长度等于原数组长度的临时数组，避免递归中频繁开辟空间
        mergeSort(arr,0,arr.length-1,temp,ascending);
    }
    public static void mergeSort(int []arr){
        mergeSort(arr,true);
    }
- l8 }  a8 v, w, Q

    /**
& M0 O  q$ ~6 I/ E7 G8 |     *
     * @param arr 传入的数组
  y7 J; j  U' l. K  w' b9 }     * @param left 当前子数组的起始下标
# q; ^7 ?- u1 k. ^) l" w& {3 l     * @param right 当前子数组的结束下标
  O/ ^/ Q+ M, {     * @param temp 拷贝暂存数组
! }% O3 F5 Q% P     */
0 |' k$ P6 U7 P6 M- T    public static void mergeSort(int []arr,int left,int right,int[] temp,boolean ascending){
3 @. @4 n, j2 f4 v1 A        if(left<right){ //这里是递归结束的条件，我们是对半分，那当left==right的时候肯定大家都是只有一个元素了。

" A8 x3 X  V+ c! h# M9 k1 e
            //对半分，比如总长度是10，left=0，right=9，mid=4确实是中间分了，0~4，5~9
            //当长度9，left=0，right=8，mid=4，0~4，5~8
: ~1 L7 R2 P6 I# j) V            int mid = left + (right-left)/2; // 防止越界的写法
. R) k% r$ `" E. v4 D            //int mid = (left+right)/2;
. `+ G3 C4 M) f$ j% P
+ \/ D$ m$ @5 b% s/ l' F
            mergeSort(arr,left,mid,temp,ascending); //左边归并排序，使得左子序列有序
            mergeSort(arr,mid+1,right,temp,ascending); //右边归并排序，使得右子序列有序

3 B1 e) [: V. S2 z. H
' V6 n8 P3 ~7 K/ [/ J3 z$ U            merge(arr,left,mid,right,temp,ascending); //将两个有序子数组合并操作
        }
    }
1 E6 o' _8 t8 p( G

    private static void merge(int[] arr,int left,int mid,int right,int[] temp,boolean ascending){
        int i = left; //左序列起始下标
        int j = mid+1; //右序列起始下标
        int t = 0; //临时数组指针
        while(i<=mid&&j<=right){
            if(ascending?arr<arr[j]:arr>arr[j]){ //比较两个序列第一个元素谁小，谁小先拷贝谁到temp，然后对应子序列下标加1
                temp[t++] = arr[i++];
            }else {
' G5 D6 f( K% Z" r* E) W                temp[t++] = arr[j++];
" T! z" w# p4 B/ p            }
5 U, Q9 O% B$ {5 L" u3 q        }

% [/ }$ @7 P+ P; M
+ c' |  {: a4 X( U; F) @        while(i<=mid){ //将左边剩余元素填充进temp中——左序列有一些数总是比右边的大的数
            temp[t++] = arr[i++];
' f$ f0 m# [  j' i4 D1 M        }

8 g# |  A6 r$ U: C, d
        while(j<=right){ //将右序列剩余元素填充进temp中——右序列有一些数总是比左边的大的数
6 s3 {$ Z/ X/ C$ C            temp[t++] = arr[j++];
        }


        t = 0;
2 o( ?% L& Y- l5 W. ]+ [2 j
; a5 u  m) S  q- r* E6 f
        //将temp中的元素全部拷贝到原数组中
        while(left<=right){
            arr[left++] = temp[t++];
; k  p+ u5 k' A; \1 w# H        }

+ z7 y, i3 P) x; g: [/ P/ J
& S; J2 P5 T% v% L9 U    }
" O( O9 G$ Z( Q  W$ d/ p& Y7 a

}
1
4 e! w: [4 ]: t1 H2
1 W" n) Z) g& v; ^( g8 E3
: R0 b& Z- a; I4
5
6
7
  o; b. V  r4 t( M; V2 c8
4 I  d, p0 V% G/ [9
7 f  A4 q9 B; s7 q! w# p+ P10
11
12
( e. J* p+ D1 d" A/ ?8 w0 l13
14
8 c8 u$ j" M! W, Y+ c5 q15
7 I0 m7 O9 u# _! j4 J; Q16
17
18
19
20
21
: u# f5 B: s2 J2 C22
23
24
25
+ F- x# V7 n0 r  Y# I4 U# Z  a26
27
+ l% M( b  j7 |; u0 Q# C28
9 [- X& [! d: ~$ H9 ^5 ?! A% t29
$ i+ f, q7 d( Y& K3 \30
31
  P- M+ P. W7 ^' x! u0 L2 _32
33
34
35
36
37
38
6 n8 x, p( @6 z) k39
2 b4 R5 Z1 ]: T# ~' f2 u% ~; f40
" V3 Y1 A! |* X41
# {# b+ d: O" }3 c  C, ~: I0 t" L42
- u: M; C4 M6 V43
44
45
+ b( r; ]! v' h3 A: H46
47
48
49
50
4 M$ k) H  \( c% ]7 o1 t+ @1 d$ M51
52
53
! ]8 w+ A6 p4 l4 }6 b  m54
55
56
57
58
59
2 q/ s9 i, |, }* S60
61
62
63
64
: @, F' w! I' a" n6 |4 E& @- F65
8 k  t0 [  `4 O66
67
4 O: P* e; e, v# y+ M68
( Q0 J# l4 o# X: D69
) ~( z9 i( v3 \& d70
6 t% z! ?( {0 i; N, T% |, `71
72
. h3 S/ P) g* q$ b5 I73
插入排序
+ o4 I/ `# |# |( |简单解释：
; p8 y2 t/ F0 `/ T- _3 a6 H4 `' h( }最简单的理解就是打地主时我们拿到牌后的整理过程，从第二个牌（假设我们拿起来这个牌开始比较）开始，（说下升序）从后往前比较如果比前面的那个牌小，就把牌往后移动，直到找到一个合适的位置（这个位置的前面的那个牌不比这个要放下的牌大）就把这个牌放到这个位置，慢慢的前面的部分变得有序，直至全部有序即可。



. K8 b: o! \5 d/ U. E

- R' ?( R& D/ l2 C+ T; {
完整代码：


package com.keafmd.Sequence;


/**
7 c" Y: j5 d6 v$ t# Z1 Q2 w * Keafmd
& Z" w: B( \& G) Z$ j *
) T0 G5 R* V5 @: n' M% Y1 E: J * @ClassName: StraghtInsertSort
* @Description: 插入排序
, l% D9 J' h; q8 u$ m * @author: 牛哄哄的柯南
* @date: 2021-06-24 10:36
*/
( T; n1 ?/ q) r6 Wpublic class StraghtInsertSort {
    //插入排序
' V9 d; G( c* Z: t/ I( V    public static void straghtInsertSort(int[] arr) {
        straghtInsertSort(arr, true);//默认进行升序
    }


6 u+ Z1 S% f& o$ S9 F    public static void straghtInsertSort(int[] arr, boolean ascending) {


+ [7 V6 \( o5 }! t" X2 q3 f- Z        for (int i = 1; i < arr.length; i++) {
& `$ s' V+ o' K0 u            int temp = arr;
            int j=0; //这就是那个合适的位置
            for (j = i - 1; j >= 0 && (ascending ? temp < arr[j] : temp > arr[j]); j--) {
                arr[j + 1] = arr[j];
3 |2 W( }3 `% ]! x% c            }
7 u: J$ D5 h1 Z" ?% ?' J* u            //把牌放下，为啥是j+1，
            //是因为上面的循环遍历到不符合情况的时候 j是合适的位置的前面的那个数的位置
$ a; G$ F2 X# {6 M6 V' Y* o            //有点拗口，但是就是这个意思，看图方便理解下
$ I1 B* ]8 J8 x( H" u; u, V            arr[j + 1] = temp;




* t8 Y$ r; P9 T( e; v        }
- S4 L8 [& ]5 S9 N
/ G/ X9 R, D( E; n' O
    }
}
1
2
3
$ H6 C4 g$ l- K1 b. ]* |9 p) M3 O4
9 h; i# U3 v9 y; L5
6
7
2 ?# q6 [. F' M7 J+ f0 N8
; a: V$ {, ~# A1 }" Z9
8 }' }5 ^! R: a/ a10
: W5 n! M& e, [9 O7 X11
) Q& L& r! J2 S/ m8 r) q: ^( l+ M! e12
13
14
15
16
17
, }5 W  K8 V# O) G18
19
20
0 u: E3 p9 u+ v# v8 S% ]21
9 ~* R  a8 {  b* O  |22
23
24
25
# v) [" m3 i/ L( U  F26
( m: s# V9 z/ R5 l27
28
" A- E0 `/ V  ]/ W* Z. [3 D1 @* s29
30
31
: Q5 p$ S& y/ a( B32
33
34
希尔排序
) e( m9 e1 h6 Y0 O1 |% ~简单解释：
# e* t$ h' u4 e希尔排序是插入排序的改进版，我们理解一个叫做下标差的的东西，也就是下面那个图中的增量d，初始下标差为arr.length/2，然后继续/2，对在同一下标差（相当于把这几个数单独拿出来了）的若干个数进行插入排序即可。
1 E2 p# m: M& H& T: M, L
" c& Y% L9 O& I& }4 g2 Z
& @( ~; E5 q4 s/ }+ ?
% S+ D" b# s' A2 q& W9 i+ y


( L% `7 V+ b4 @4 z; E完整代码：
+ S1 p4 |" Q- ?- ^2 ]  K$ X8 |; p

package com.keafmd.Sequence;
# i5 G- E4 W9 O/ E2 c
4 c4 j( E; }$ W& R
" ]+ ~: I6 s3 d  H$ D0 C/**
* Keafmd
- |6 e, P3 D! x0 ?2 E+ t( N *
* @ClassName: ShellSort
3 q" ^/ x. w1 n1 ?6 J+ T6 U# ~ * @Description: 希尔排序
* @author: 牛哄哄的柯南
* @date: 2021-06-24 10:39
  q! C) c  k9 l& d/ v; P+ O* ` */
& p) z( j$ b5 ]9 }! j6 F7 _' [public class ShellSort {
8 r8 q4 F2 C- m  h1 J1 s4 c
( |" x2 [/ Y! j* t4 ^9 e% X
% J/ Z9 D- d, Q& E    public static void shellSort(int[] arr) {
        shellSort(arr,true);
    }


6 F- n4 Y8 i3 `5 y/ z) b0 v    public static void shellSort(int[] arr,boolean ascending) {
% Z# E+ c$ d1 t/ e! f# z! W
# o& X3 [4 v9 I
        for(int d = arr.length/2;d>0;d/=2){
' \& V1 p" |  w7 Z5 ]5 r
* Y( p( u9 g6 I" ~: Q: p: x
+ i2 o  L1 g+ w" T& q. ?' W            for(int i=d;i< arr.length;i++){
) ~" n! e( s+ `" I4 m1 s                int temp = arr;
                int j=0;
! {1 {; I2 D) `1 [" k, g: @+ X1 u                for(j=i-d;j>=0&&(ascending?temp<arr[j]:temp>arr[j]);j-=d){
( w& m4 N9 i" [" `3 z                    arr[j+d]=arr[j];
                }
( w& U+ y  ^  m% D, q* Y3 y                arr[j+d] = temp;
            }
' f& @1 E5 Z6 o/ F5 R% A        }


    }
}
- Y( m! K# t7 A! m( o5 k3 I7 D1
0 f5 t9 h. g: P; `4 \+ Y/ d+ E' x2
! Z: d3 K0 p/ C+ G& Y; ~% S3
5 Q6 z; P: l% E, g# B1 M4
5
: x# ^$ v+ [" e9 j4 J: O! t6
7
" \$ G( {1 U% U8
9
10
% N; U, g; Q" P11
; y/ @' U5 f: ~- H. S6 D: S6 Y12
  p+ r4 {+ }! x2 K+ T13
) `: S7 x% S& @- d14
15
; _+ b5 y1 j, Y; @16
17
18
* `2 U+ z0 H: f. `$ h4 ^6 C4 b2 o9 B19
20
21
22
8 i* c- h4 Z9 `/ s: W# L23
5 _, s4 V5 i3 z1 E24
25
26
/ F& n+ q) ?0 p/ B* b27
7 Q# ^' u4 l& i28
/ R/ F7 T7 A( J7 ?, P3 N8 U* g5 m29
30
31
* u% ~) U: d; w32
% j( F) K; h& o8 h9 U5 l: D( }计数排序
5 |, ^/ k, B) n: A2 h& h0 K0 p简单解释：
这个排序算法看名字也很好理解，就是就是额外找个数组来计数，然后在这个数组从小到大或从大到小把数取出来即可。
+ X" b% T. N( o



$ B3 R5 E: q2 p, X+ t5 G
* U, Y* e4 H4 c) q% L
完整代码：
0 v) Q# p4 u1 F; K4 O; y

package com.keafmd.Sequence;
* d& T6 E# a, D. U
9 Z; j/ J; Q$ ?; l/ }) q8 [1 ?
" w8 \3 \8 A6 F% M$ f! k/**
* Keafmd
$ |. k& K( s' y5 n *
* @ClassName: CountSort
! `- r0 @! s' W0 h* P1 q6 }7 | * @Description: 计数排序
* @author: 牛哄哄的柯南
* @date: 2021-06-24 11:31
*/
6 K1 u' {$ }* ?public class CountSort {


    public static void countSort(int[]arr){
- M* t1 a7 d% `% ]3 u; F% a6 ?        countSort(arr,true);
    }
# v$ u/ p, M; L- g
' L2 @( U) {0 i/ @& f, I/ r1 g
: _7 Y& B: |3 }: G( X    public static void countSort(int[]arr,boolean ascending){
        int d,min=arr[0],max=arr[0];
+ a. C0 w  K9 O  A; V. j  P

        //找出最大、最小值
) S: j. ~4 n  A: K        for(int i=0;i< arr.length;i++){
            if(arr<min){
                min =arr;
            }
$ Q# w8 |* ?8 _6 Q! f, D            if(arr>max){
                max = arr;
            }
        }


# r% W* o! z2 ]. A+ K/ R+ [        //建立一个用于计数的数组
$ ]6 O$ H2 `- S' Z4 X) j        d = min;
" c" l: s0 f( c* Z5 T        int[] count_map = new int[max-min+1];
: `- L% n+ I# y  \8 W+ C        for(int i=0;i< arr.length;i++){
            count_map[arr-d]++;
& F* d) y, {( U- h/ {6 B! _        }
- g0 X6 @: D- g& ~2 T% _# C1 e

        int k =0;
% }9 f4 ~3 |: W( Z$ s4 i8 S        if(ascending){
            for(int i=0;i< arr.length;){
                if(count_map[k]>0){
0 k! |6 t' K3 l9 U' I$ r                    arr = k+d;
                    i++;
2 B( x( k) H. \' D. [6 b& m( W                    count_map[k]--;
                }else
                    k++;
$ a# F9 t" ^# N            }
        }else {
0 q  R. t0 c: @' S# ~            for(int i=arr.length-1;i>=0;){
2 x$ m' D3 W7 q/ N6 K/ W9 `                if(count_map[k]>0){
8 [2 g6 C* |8 ]6 l! M( T                    arr = k+d;
, m$ {& Z0 k' Y/ U9 g                    i--;
                    count_map[k]--;
                }else
7 Q  n0 A/ O6 N( L0 K                    k++;
            }
        }


    }
}
1
9 @7 h" m% D- d/ E/ O5 M% i& N. P2
) I: S8 L& _5 c5 O! B3
3 ], ]& R( [. r6 B4
9 Y. P% d7 C  {5 y3 @! }5
! j+ F3 Z( `0 i6
& }, s7 _: f8 g9 ?' u2 a7
/ {9 W  P& e7 E5 |8
7 e6 L. ~! T9 Q- I; F' i3 N9
10
' U0 E; m+ s# Y4 P+ C11
( U) x5 X$ m7 }  k3 \3 m6 g, X9 e12
" ?* @; f+ H, x2 J13
) J" M. ?0 {9 N+ E/ [+ Y% J& T9 T14
15
16
17
# r7 _5 S0 G7 ^6 G# U' S18
" u: l" }+ e7 {$ G; R+ s19
20
! p6 P9 m8 i# w' W21
22
23
3 T2 I5 {4 _( Y24
3 |4 ?1 p1 W0 e7 I% b$ t' @25
& F6 h, e# k1 M3 j6 E26
27
$ j& I2 c' B" \28
4 W6 d/ U! l  |+ `! }; H1 m; ^29
30
* |4 h9 l5 u" u9 ^8 \. z3 O! Y/ u9 Z31
/ Q& u+ e( y) c$ i: _) @* \! R1 ?32
8 \0 l7 E- Q. A  A6 o33
9 X7 T& k2 a: W) ~; q! I% I34
5 p4 i# {$ R: H. b* X- v" }0 Q3 a35
36
37
38
. }' J/ U3 h- L" v. J4 ^% k39
40
4 Z3 ^6 j  P( d0 {41
# s7 Z/ h& x0 Z42
43
) Q3 C" ~9 F( v$ V44
45
3 F( g! V0 B- a46
47
7 e$ i0 N' U% J* f6 D) |48
3 E  [/ M, V$ ]3 `; r49
50
) V: L( W' g/ E* U* L51
52
53
54
1 M) u1 J3 W9 K0 G55
56
# v( X+ C7 ?9 A) d8 P; H57
& n) x6 g! r0 A# x0 \$ M. j58
59
, W4 [8 i: m" V2 b桶排序
简单解释：
就是把一个数组分成几个桶（其实是几个区间，从小到大或从大到小的几个区间）装，然后让每个桶（区间）有序，然后取出来放一起就可以了，相当于把几个有序的段拿出来放一起，自然还是有序的，当然需要是按照区间的顺序拿了。


, @5 O$ I) V# s



完整代码：
6 V  [$ g; ~6 t; Q! L' B$ v
5 F6 {$ c) K7 Y3 m" b+ U# h4 R
package com.keafmd.Sequence;

' }5 p  Z& b, U7 i
import java.util.ArrayList;
* `! E1 D' ?$ v% L$ oimport java.util.Collections;
% d& X7 Y( m' M

) G3 p$ m9 d5 Q6 p3 A) f1 P0 \/**
. y( a! |7 T# V) j# I * Keafmd
*
8 n, |" v4 a3 s( z * @ClassName: BucketSort
4 X. a+ j( `: G% p. Y * @Description: 桶排序
  _' N' t. a' E6 ` * @author: 牛哄哄的柯南
, ~& }8 f+ F( I6 N+ H * @date: 2021-06-24 13:32
*/
" c4 c' y  j% d2 E# kpublic class BucketSort {
1 y% ^: F5 z: b$ C: s8 [$ T
$ h! L/ R% E2 M4 [
    public static void bucketSort(int[] arr){
% A) J3 b, z: Z  _. V+ b* S! \        bucketSort(arr,true);
    }

$ L( Z7 i8 z+ h! x# Q! X
4 |9 R# L$ A9 f5 Q6 o# C    public static void bucketSort(int[] arr,boolean ascending){
. ?" @1 d2 s* \* R  q4 Q, n        if(arr==null||arr.length==0){
' X: T4 Q1 D+ i$ n- N; w9 ?! g            return;
5 H4 S0 `( J# Y  e% M        }
9 \9 X6 s  L5 m3 S( v        //计算最大值与最小值
9 _) b- w: N( Z) L        int max = Integer.MIN_VALUE;
/ I* b+ \- V: ^0 [1 y        int min = Integer.MAX_VALUE;
        for(int i=0;i<arr.length;i++){
            max = Math.max(arr,max);
            min = Math.min(arr,min);
5 i* t& o- V4 u- K        }
/ b& J) _5 N3 |% X
3 n& f( j+ ]+ {$ Y( S* ~1 k7 @
: j7 d# H+ E2 N6 l- M. @# }        //计算桶的数量
% C% e( {& j2 M7 D. ~        int bucketNUm = (max-min)/ arr.length+1;
        ArrayList<ArrayList<Integer>> bucketArr = new ArrayList<>(bucketNUm);
) Z. Z; x" k$ r% k        for(int i=0;i<bucketNUm;i++){
            bucketArr.add(new ArrayList<>());
& j+ f" {- s$ M% v        }


% }- \6 m2 g# \* @        //将每个元素放入桶中
        for(int i=0;i<arr.length;i++){
            int num = (arr-min)/ (arr.length);
$ x) L! t+ s7 c4 t( C            bucketArr.get(num).add(arr);
0 i* l+ s5 b8 H' @        }

  ~9 i8 |) v7 ?% g9 N0 T% |% ]# b. ^
        //对每个桶进行排序
$ G% E) f9 r4 X' {$ X        for (int i = 0; i < bucketArr.size(); i++) {
* X! a$ [2 S; e; |6 O$ y, N            //用系统的排序，速度肯定没话说
$ L% T8 E" }" ?6 e            Collections.sort(bucketArr.get(i));
# P; p4 P' X" X+ O1 I) b+ d        }
; q0 t9 I7 `- |# D: t  I4 ]0 |, A

        //将桶中元素赋值到原序列
' @* `5 z' [! N, n! W        int index;
        if(ascending){
7 P+ `" g5 \$ o            index=0;
        }else{
" B7 t' ~2 v9 i. J3 e            index=arr.length-1;
        }


2 ]! `7 G# S9 u1 _0 T        for(int i=0;i<bucketArr.size();i++){
6 Q- _2 w! r) Z            for(int j= 0;j<bucketArr.get(i).size();j++){
$ i% a% w9 d6 T/ |5 W                arr[index] = bucketArr.get(i).get(j);
+ E( r1 I2 w& N; V0 ^% X# q                if(ascending){
1 U$ u- e/ z- U' U/ J' j9 ?                    index++;
                }else{
' O7 k# ^; Z2 j& A7 [5 x4 f2 M                    index--;
                }
            }


$ K! z: l: k9 ?7 E        }


7 u4 t+ D; ]- D* x7 f    }
}
1
6 k% ?0 x6 ~. V9 y+ M# V' E2
3
4
( V# n* D' x/ ?0 K7 |7 b5
6
7
6 w) k2 O, b) d1 g- N( s8
' A# P! ?4 F/ @. `2 i4 l* M8 Y  u3 I: v9
10
+ i5 o$ j' Q1 y5 V* [3 U11
12
13
: L* e; t- y6 U- H1 ^14
# u! L6 g1 {" d; p* S  V2 c/ T15
" ~3 B) N/ p0 P; y3 f16
' E% m- k, f" {! q. i. h  S17
18
' k( I! l; \) _: w19
20
21
2 W+ G% x7 H7 m. O1 j: u# k22
23
* u7 j, y6 G( O( b' T$ F24
25
26
27
28
' ?& s4 N4 p4 U/ t1 M% F: g6 S29
9 l+ x4 a% Y- W$ Q# U9 i) C. ^- a30
6 c8 q, ^) \6 `# s31
32
5 D0 O: a8 v% `, Z& U9 k, S33
3 O& y/ r5 `! [4 {* g# [' r34
  D6 N8 ~2 m2 |2 D# [" A35
36
' s/ d. }7 y9 Q/ `6 p37
38
2 j3 t& i& o. S39
40
3 ?( r/ M- s. @# t7 ~- V" p3 R41
42
  \& k( @$ G; b8 O* S9 Y3 G43
44
, v' [& Z8 k9 u; {1 `* P45
! z% G# o4 ?$ l: o3 F, P, q+ u46
# T% t! V* }7 j7 P47
& X! B3 @/ r" g8 g: f48
49
50
51
52
: x! I( J' H: f# R; L. a- S; d53
54
55
- ], F* T/ ?& Q' X' o, @56
57
' }, ^  S9 a' _7 |  |58
! O! m% `7 w8 j+ r* i59
* f% S& M" U# V1 u! d1 d9 k) X60
) |8 g4 i+ X9 K61
62
63
/ r" ]+ _0 H3 F: q64
65
66
67
; ~  z1 G9 _+ d2 Q9 }6 F5 @$ o9 F68
69
$ }( E9 X  K4 k! _70
71
72
8 o* [& V1 h5 X. m; [* T: Z基数排序
) y  I, {+ e% a: _2 j6 V# y简单解释：
% y  J" }# X4 v4 T& Q首先说一下，我发现好多人写的基数排序只能排序正整数，其实只要处理下就可以排序含有负数的了，就是我们排序前先把所有的数整体变大（就是减上最小的负数，也就是加了），都变成正数，然后排序好之后，在减下来（加上最小的负数，也就减了）就好了。
基数排序就是按数位排序可分为LSD（从最低位[也就是个位]开始排序）和MSD（从最高位开始排序），下面写的事LSD基数排序。
6 F: L% a" R8 t& r1 E1 d基数排序就是把数按位考虑，让后我们一位数只能是[0，9]，就是我们在考虑某位（个位、百位· · ·）的时候就只看这个位的数，放到在[0，9]相应的位置，然后顺序取出，最后再按其它位这样操作（上面说了要不从低位开始到高位，要不就是从高位到低位）




: `  M7 Y$ f! h% {

完整代码：

5 z3 v4 N6 P7 K; O  H0 P& T8 E
+ f: W( i. n' q: bpackage com.keafmd.Sequence;
; N' p9 u3 ], u, q+ P0 b
, ~6 {( x! g4 d( q3 R
/**
* H0 I4 C7 c) @' V * Keafmd
*
* @ClassName: RadixSort
2 g# H. C" r, F, \ * @Description: 基数排序
. [% S! I+ K/ a  r0 Q * @author: 牛哄哄的柯南
* @date: 2021-06-24 14:32
, h, \- Q1 ~, [; ?$ r+ g */
public class RadixSort {
) E" ]$ x) y& \: b# h    public static void radixSort(int[] arr){
        radixSort(arr,true);
    }
    public static void radixSort(int[]arr,boolean ascending){
        int max = Integer.MIN_VALUE;
: y& b5 p5 I7 \% l. U" f  [7 W! W        int min = Integer.MAX_VALUE;
# u5 ?& C1 L8 e0 |* T        //求出最大值、最小值
6 Z' f* v$ Z1 f. A* \        for (int i = 0; i < arr.length; i++) {
7 v/ x# n% r; O) d; v            max = Math.max(max, arr);
            min = Math.min(min, arr);
5 y' E) w' V/ P" M# R1 B        }
) N8 j+ ^0 L/ X1 F  g, O        if (min<0) {        //如果最小值小于0，那么把每个数都减去最小值，这样可以保证最小的数是0
6 P# L4 `. N/ ^0 ?6 \& B            for (int i = 0; i < arr.length; i++) {
                arr -= min;
; M: j: l$ Y" _- q* @            }
            max -= min; //max也要处理！
1 r. S6 V1 T; G) Y" q1 H- A        }
        //很巧妙求出最大的数有多少位
        int maxLength = (max+"").length();
        int[][] bucket = new int[10][arr.length]; //一个二维数组，一维代表0到9，二维存放符合数
, ~: W# e, ~$ ]* F        int[] bucketElementCount = new int[10]; // 用于记录0到9某位存在数字的个数
        for (int i = 0 ,n = 1 ; i < maxLength ; i++,n*=10) { //个位 十位 百位 这样遍历
* }- M3 C5 B2 F0 A7 K; ?            for (int j = 0; j < arr.length ; j++) {
                int value = arr[j]/n % 10;
                bucket[value][bucketElementCount[value]] = arr[j];
* d. P9 z6 p. A                bucketElementCount[value]++;
            }
* B2 {. Z) ^7 [6 L7 V

            //升序
            if(ascending) {
! d5 u) U6 l, p) c7 f! d9 j                int index = 0;
0 Q$ z: p$ k: m: L+ T# V) ]                //从左到右，从下到上取出每个数
& ?5 o! k! L) ]5 ~7 u$ l' d                for (int j = 0; j < bucketElementCount.length; j++) {
                    if (bucketElementCount[j] != 0) {
8 ?5 S* @/ H: `$ H3 ]& R                        for (int k = 0; k < bucketElementCount[j]; k++) {
                            arr[index] = bucket[j][k];
+ C' v, i7 x' V/ }4 u! G) `                            index++;
                        }
6 \6 w2 g2 N# r0 L1 s                    }
                    bucketElementCount[j] = 0;
8 b' h# `3 ~1 `3 Z6 G) e                }
# A  F% ~, A( f$ I/ w/ r            }else { // 降序
3 d. g* }$ C0 r  }0 Y, a                int index=0;
% ~  N" }# m# v! e& n, s                //从右到左，从下到上取出每个数
  g* L1 c! D$ i0 e4 G7 I                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];
                            index++;
) I& A% H2 a- i/ p                        }
                    }
8 m- I6 x! X3 j/ H. |1 @  A% s2 I                    bucketElementCount[j] = 0;
                }
8 O/ \( ?; @  l5 U3 K) m            }
; p& Q/ y3 Q  x7 P  K' y
! v" t; P/ ?. @5 ?7 }  N, ^( k+ V9 ]
; U8 |6 s$ ?3 m" `& x( m
" I; }/ v6 U$ |, W
9 ~% J( S0 r/ H( v% T            /*for (int i1 = 0; i1 < arr.length; i1++) {
! \; `" ~  t. l                System.out.print(arr[i1]+" ");
9 y8 V# ~! J$ K            }
% t8 M# W' s' w5 I            System.out.println();*/




' w/ b/ L* \: W+ z; f% V6 O

        }
! l. w' P6 T9 J. _1 c        if (min<0){
+ t+ i! o8 F# ]6 r            for (int i = 0; i < arr.length ; i++) {
( M" Q. r1 H9 A& b4 e2 q/ b$ X                arr += min;
3 J% o3 f3 h( r/ T8 ~            }
$ b( `6 j7 ~8 d3 c        }
, d' S9 H2 }9 H
1 a, W3 C& g  c
    }
}
1
2
3
4
5
& q) D- V+ r6 h* y6
7
( s" n; a* ]: f; B* E! r8
9
; w6 A; k. h6 b5 m; u8 [5 V: t10
11
12
13
14
: T4 X( U; g# W- o! d1 _$ t7 O15
6 P: D( Z# b2 d3 W7 n& X& _16
17
7 K$ V% T7 |$ q7 J) j) V18
8 C. p- [" b0 y19
+ L2 R- f8 l1 i. Q6 c/ \6 O( \20
21
% ]1 r" S1 ?4 V9 ]5 w- r22
23
24
25
26
. l/ m8 O) D  C$ U3 C27
7 N6 x- I; k1 y$ N+ o4 d5 b4 U28
29
30
7 k! A0 Z$ D  r3 T+ A+ i# R- f31
32
33
/ t4 d4 N* G5 U, e  j34
35
; ~6 Z  l2 E7 K9 J0 {- j: P7 J36
37
38
; Z) S0 ?! s0 Q39
( }2 w* V+ c8 Q40
41
; F# ^3 _& G7 P" N2 ?7 |! h42
43
8 t6 i4 V  r# q& p4 D44
" P9 u4 q- I6 Y( N7 D9 w0 p( `45
! v) q9 v- T$ A8 b& p46
47
; o$ h( o2 s* J& \3 d! [% C1 Y5 U. j' m48
49
50
/ X7 t3 g! l- S- x51
52
7 J  C; v6 O; N5 p5 b53
54
55
56
: c( f; j4 l: n57
* R! ^# ]& ^" q3 {58
0 ~9 N0 H" j. j59
) Z6 X# S8 l/ R$ L60
61
62
$ d# i! D+ A' o4 R63
1 L5 E5 n) G+ k. i$ w5 ~$ i5 D64
65
66
1 I! w1 n9 B% E- R( p$ n4 a67
5 o2 P" U! ]8 |68
. X, K( D! ~0 X4 D, N% a9 m% V  U7 p69
: n) O$ T" _: v' J) `70
71
72
73
74
+ z( V/ f" a  E0 d75
76
77
% t: j& F0 l6 U- T; l78
79
80
( C# k. b2 l$ ]8 E) l, z5 d5 m* L5 e81
82
83
* M; l* p% A9 j2 j完整测试类
package com.keafmd.Sequence;

1 o  M5 f* t! r
* S& ~& l4 v& p3 oimport java.util.*;
import java.util.stream.IntStream;
import java.util.stream.Stream;


/**
* Keafmd
*
. `, }. Z. L) v8 B- V5 y! O  U * @ClassName: Sort
, \) U  v- h/ c8 s. K% V * @Description: 十大排序算法测试类
* @author: 牛哄哄的柯南
  R; j/ R3 h6 U; [8 z * @date: 2021-06-16 21:27
/ U( c  K. ]4 M, w3 t */
3 }0 o" G4 @8 h: Opublic class Sort {


- S# \' q' g- e2 @

2 Q% Y0 M+ ~4 S: }    public static void main(String[] args) {


: q6 l; h! p6 u7 A6 e" _        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;

5 X" \( Z. A& T- T- n9 _3 q
        //利用系统Collections.sort方法进行对比


+ t% x* s: c* e        //将int数组转换为Integer数组
        //1、先将int数组转换为数值流
) m0 V' b4 R6 t5 j7 N0 b        temparr = nums.clone();
; j, F- e2 [9 t& @+ H        IntStream stream = Arrays.stream(temparr);
        //2、流中的元素全部装箱，转换为流 ---->int转为Integer
        Stream<Integer> integerStream = stream.boxed();
        //3、将流转换为数组
        Integer[] integers = integerStream.toArray(Integer[]::new);
        //把数组转为List
        List<Integer> tempList = new ArrayList<>(Arrays.asList(integers));
        //使用Collections.sort()排序
7 V; Z6 F& v7 u, o1 u9 o% r7 i% R        System.out.println("使用系统的Collections.sort()的对比:");


        //Collections.sort
( M5 `9 G& A' Q/ h# j        Collections.sort(tempList, new Comparator<Integer>() {
  X' r3 ^) A% q( P( Q0 K            @Override
  y( Q9 S. |$ D            public int compare(Integer o1, Integer o2) {
                return o1-o2;
* W5 ]& q( i  t4 o" j                //return o2-o1;
! O' G% _7 z8 w$ ?6 l# [            }
        });


        //tempList.sort 也可以排序
: u, i7 V! S9 v- b8 Z; e/ Q       /* tempList.sort(new Comparator<Integer>() {
            @Override
            public int compare(Integer o1, Integer o2) {
                //return o1-o2;
) P" I7 @) e% U/ {" m$ A) z                return o2-o1;
5 E9 K5 W- W5 H6 u( L- l            }
        });*/
* L: t; ^7 {4 @& t: R& ?
) E; Y, D1 O  \+ I$ Y+ }
+ J/ v" T* M9 l  \# H        //遍历输出结果
        for (Integer integer : tempList) {
            System.out.print(integer+" ");
        }
& Z7 U$ i2 ?$ \" }' w
/ L. {, L! e$ \" u8 Y3 b
5 W' L) m  @3 z& A8 m- n. T        System.out.println();

- J; d, A& q$ e8 g, w
8 G2 m1 v. R0 X" x        //测试冒泡排序
        System.out.println("测试冒泡排序:");
        temparr = nums.clone();
, [6 |" Q8 P4 _0 F2 ~
. q6 @0 W/ ^% W8 H
; L$ I+ _* b, u# q        BubbleSort.bubbleSort(temparr);


        //降序
0 }; V" m8 L' P: d6 |% L. q        //BubbleSort.bubbleSort(temparr,false);

4 n" _& x/ @5 }
        for (int i = 0; i < temparr.length; i++) {
) A4 y& N9 b" u1 m+ Q5 ]4 t            System.out.print(temparr + " ");
+ S) U1 l. _) `" I2 _        }
+ [# G' O3 r0 E6 T8 G* f. L        System.out.println();
9 Y' ?# O+ O; q5 _5 ^
& Z" s/ M. K! }7 G0 Q$ X; H& r
' K! N1 r! M4 h8 J5 u" |& w& i: s        //测试快速排序
        System.out.println("测试快速排序:");
9 [. S3 y1 q" @        temparr = nums.clone();
0 k( W! k1 V# {( Y! s0 Y        QuickSort.quickSort(temparr);
2 f0 e( u0 r4 W+ b8 h9 I8 z7 I/ g  k        //QuickSort.quickSort(temparr,false);
        for (int i = 0; i < temparr.length; i++) {
            System.out.print(temparr + " ");
        }
        System.out.println();

* u" [+ Q4 W' B: l9 K( A/ M) }
( H# O/ V8 I( T# j. J* E! r6 y2 c2 }        //测试直接选择排序
8 V6 T/ P( K6 ]# Y        System.out.println("测试直接选择排序:");
) p9 E( ^% _; D+ R: ]" k        temparr = nums.clone();
        SelectSort.selectSort(temparr);
        //SelectSort.selectSort(temparr,false);
6 P/ [! l3 S8 I/ a; T        for (int i = 0; i < temparr.length; i++) {
' A2 d# W  T7 r5 o: \            System.out.print(temparr + " ");
) s* c& R# v; ^& T  C/ V        }
+ ?0 z1 e2 z- f% _        System.out.println();

" n& @3 }7 L2 ^' r; ^5 \+ I( y
/ {- z. X9 [: v7 \2 c        //测试堆排序
: P& Z+ c0 n  {0 f( r4 `% X& w+ J        System.out.println("测试堆排序:");
* @: E5 t0 G/ ?$ ]6 ]  P        temparr = nums.clone();
        HeapSort.heapSort(temparr);
        //HeapSort.heapSort(temparr,false);
0 N- ^( A/ `; Q9 ^  z% a9 F% [        for (int i = 0; i < temparr.length; i++) {
            System.out.print(temparr + " ");
. Q3 }7 q8 U$ M0 t3 t& f. S4 ?        }
        System.out.println();


        //测试归并排序
        System.out.println("测试归并排序:");
- l6 Z" M+ Z8 E        temparr = nums.clone();
        MergeSort.mergeSort(temparr);
! `3 n: ~+ y+ M' }# _        //MergeSort.mergeSort(temparr,false);
        for (int i = 0; i < temparr.length; i++) {
            System.out.print(temparr + " ");
1 C5 |# v8 ~% R9 \5 `9 n+ M        }
/ h+ |+ ^- E' q+ Y' }1 P( T2 x        System.out.println();
6 r8 \( T  O7 Z* l

) P* T  W5 S' _! \2 ]$ W        //测试插入排序
8 Z. N  L2 e; e& m        System.out.println("测试插入排序:");
/ v0 V' t3 ^* U7 R: z3 d        temparr = nums.clone();
' j- m8 ~4 G% c: _        StraghtInsertSort.straghtInsertSort(temparr);
        //StraghtInsertSort.straghtInsertSort(temparr,false);
        for (int i = 0; i < temparr.length; i++) {
            System.out.print(temparr + " ");
        }
/ R/ d: ]( v/ a3 v* h        System.out.println();
, g- p; a' ?. @) X6 u2 Z


- q; {' F1 N$ f  s" f
, P. @8 O5 R$ N& g% f        //测试希尔排序
        System.out.println("测试希尔排序:");
        temparr = nums.clone();
' s" n! @( M) b/ F$ K        ShellSort.shellSort(temparr);
        //ShellSort.shellSort(temparr,false);
        for (int i = 0; i < temparr.length; i++) {
3 E2 R1 I% a- o$ t; ~4 }" `1 s% i            System.out.print(temparr + " ");
        }
: w! Y& i* O: S6 a$ S        System.out.println();



  J% g, V+ r# c: m- v5 h& `
# m/ ]3 n) K/ P  Q        //测试计数排序
! J, P4 v9 e' v% _5 |        System.out.println("测试计数排序:");
        temparr = nums.clone();
3 L# o: r% z  k        CountSort.countSort(temparr);
4 x) U( G2 n) T5 e6 _& S9 u- @        //CountSort.countSort(temparr,false);
" P7 I% y, w6 w7 {        for (int i = 0; i < temparr.length; i++) {
            System.out.print(temparr + " ");
        }
        System.out.println();
7 J/ }! k# ~: A  B



/ ?/ I0 S3 Z6 ~        //测试桶排序
2 K# A* n) B! Z        System.out.println("测试桶排序:");
% t7 t; n8 ?1 ~- i- M0 Q        temparr = nums.clone();
        BucketSort.bucketSort(temparr);
        //BucketSort.bucketSort(temparr,false);
        for (int i = 0; i < temparr.length; i++) {
            System.out.print(temparr + " ");
/ R. o+ z: K4 t& v/ _0 G+ |6 [- G        }
/ J+ `% R0 @- n$ ]& e        System.out.println();

/ L7 i8 P/ H+ T  j8 y
        //测试基数排序
) B; Q& ]7 U- r& k+ B4 _        System.out.println("测试基数排序:");
- W) m& g; E/ ~$ _/ u* V        temparr = nums.clone();
        RadixSort.radixSort(temparr);
4 Y% o6 _9 T6 O5 Q/ T        //RadixSort.radixSort(temparr,false);
        for (int i = 0; i < temparr.length; i++) {
            System.out.print(temparr + " ");
        }
( v" p5 F: l6 p/ Y6 V3 m% T! m        System.out.println();
/ ?) x" Q, i9 Y5 `- [
6 g+ ]! B% E8 w5 v+ ?% `3 I
    }


}
6 K! |+ _) s( \3 q1
: j- F& X7 B# A9 J; m- J2
; i' O: K) a1 S3
4
+ ^. L* a! [8 ]' u: |4 A- K: }% ~5
6 f: B) u" Y3 A' p6
4 B4 q2 s) w8 [7
# {/ q/ |$ y" t9 b8
9
10
. n: S3 J+ |9 P9 l11
/ P  F9 f; g. Q& V& [12
13
: A8 {+ X2 M# F9 l/ c14
15
$ ]9 w# j, \, |16
  I/ z: Q  D2 R# g1 }) H* [17
& T1 v3 B5 U2 t! D7 H) i. {18
+ |# t# d" r( h. c$ R7 t/ \19
/ \2 g7 `3 }& V7 \20
4 g) K+ W5 c. g- K1 l21
22
' I/ n/ s& ]' b; J- F) j23
/ k. _4 U! F  `% J24
25
26
27
28
6 u& f9 h/ a2 L* s0 ?29
30
* s: w% f! d  `0 U/ ?7 k8 }31
) {" v! _/ a/ S$ T! u. f* [# P( K32
1 |$ k+ V& E/ I  P9 V' c33
34
8 ~3 n5 z; f4 U3 j4 E1 S4 W35
36
37
  E# U, \7 }8 I+ u$ l6 Z38
39
40
/ N9 d$ e& |0 P41
" Z4 \' ^" W2 |7 i& d8 j  Y3 M42
: k5 w0 Z- c( s: Q  g43
' ~' A' ?% ]* n6 A9 k: ]44
45
; f; p( m' q6 l- [46
47
$ l: X6 Z; ~- P& \  C9 B7 Z$ U48
. z# P& U  g1 J1 C$ Z$ V5 v# E/ F% ]49
50
51
( ~) I- O2 i7 q, ^# X. Q3 S: n52
53
( s( t0 m) I( s( u* f6 J- u54
55
56
/ g* Y6 ~# z0 }* B57
) `# S7 q8 R8 ?$ [( n3 x58
" m- x/ |6 }" w# @* U% @2 O59
60
61
62
* [* }. T" A1 ?" P63
% z5 P  o" ?( t+ h7 [64
7 o1 R! t- \  G) I8 m8 I) n0 L65
4 Z6 W9 v# W' D& F# E4 ?66
3 \$ g1 \3 o* y% O  {& M67
4 c/ E% W- _! f/ }) F68
3 B- ?; O) _: m. _0 W3 l3 s4 U69
70
  m1 J$ G* [/ i7 l* J; z! l3 Q  f71
' }& z& e& e: A$ {; T) `/ c1 F72
2 c& Z' f3 n& H73
74
75
$ v) `2 J6 b6 n' @, F" F0 D76
! v1 E+ C/ s0 w77
. b: h. Q1 }' H/ G" z78
79
80
81
8 X! Q) ~4 D. t7 [4 E6 a0 M82
: }; q) n& l8 }" k! @83
/ y' P. I  e! Z/ i( D' ?84
85
) }8 x& P. R# n# R86
: w  T  [, j  c! [/ ^9 h; S87
- O! x' S6 S% l9 A0 r" N/ I88
89
- m3 k' H0 O& N5 Z: S: Z2 w90
- i1 f" |) W5 \! v4 j! D& o91
92
93
94
( _5 k& @/ o1 S4 H* i( V95
7 t$ ~( S5 V+ l96
97
98
0 l" D7 c, f9 C) `) N% q3 u99
100
101
) o6 {; y/ I9 n" s7 P0 e- _102
103
3 J$ c& s& g; Z( X1 Q6 w) S104
105
! _" A# D$ j- h106
# w7 y  V# Q+ d) {107
9 r+ @1 o$ a7 _9 f9 w2 T4 c9 A# `108
109
110
1 l0 [" U, _: m7 n/ y% f- z7 U111
112
! s, Z4 @# y. M8 b) V3 v113
114
! M0 b, w4 K! Y$ I$ ?115
116
117
118
119
5 ^, p$ o2 b& O3 W9 v! D4 T; H: p$ D120
1 y+ N* X8 M9 Q* k121
  k2 S( D: }  i& f8 r122
4 S" X; |$ G/ v2 n123
124
! f) m4 l. }, i) |1 a2 E125
& v& |! [2 F, G  \, C126
4 M) Q* d8 z7 E* v  X127
  |' Z) |& o# m5 N$ `128
129
130
131
5 Q6 {6 s9 e1 W( {132
133
; j$ J. O9 L2 ^9 Z134
135
136
0 S( J( j& A0 v% K1 Y, ?137
138
6 d% n& k9 B8 A; S3 f7 ~! T139
& G% W0 ~5 ~) B140
& v* |0 H& o8 I/ n5 z141
* {7 q# I" h! M3 T142
1 Z; F$ r! t; T1 u5 d# ?4 I2 }$ s: z143
5 Y0 `5 R' r; @1 D& n7 u144
145
. M* o$ ^( V! Y5 o" h146
147
; G$ r% J* S6 a7 W% l+ v7 c9 v+ d148
149
150
151
9 I. y# M5 M& l" @# |8 _5 Z152
153
154
155
' j2 b0 f3 n6 P+ T156
5 t- H$ ~! n: u  n157
. |" `3 ]- a+ ?" g$ B158
' U. c# h2 R% H6 T& `& Q159
160
161
162
163
# V1 U/ k" S" b7 a. ?: u164
: Z+ a5 B  Z4 m, w165
- B; a6 q% ^( ~- a% I) B166
167
' f9 E/ {0 F- z4 p+ P168
169
3 l0 b5 i; @: J170
171
172
173
. @/ z0 D* L" E/ ^1 J7 k每天进步一点点！
不进则退！


/ j6 C( C  e; |4 v& J* l版权声明：
& U" Z0 a) k% C0 j9 i( l$ D原创博主：牛哄哄的柯南
! C3 i) V6 A; U0 F+ _1 H0 \博主原文链接：https://keafmd.blog.csdn.net/
; F$ \% z% }6 |6 F————————————————
7 {& x( `  {3 J: [6 z! \; N! `7 o版权声明：本文为CSDN博主「牛哄哄的柯南」的原创文章，遵循CC 4.0 BY-SA版权协议，转载请附上原文出处链接及本声明。
原文链接：https://blog.csdn.net/weixin_43883917/article/details/118193663
: Z- k# V" c" h
1 n5 q, y; g" L$ U: S8 {$ o0 R
2 k3 p4 [3 ]0 @# z8 u% _4 u7 F0 k, R

1051373629

每天进步一点点！