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

杨利霞

经典十大排序算法（含升序降序，基数排序含负数排序）【Java版完整代码】【建议收藏系列】
经典十大排序算法【Java版完整代码】
# U9 M: F7 S' y+ p0 h3 M5 x8 W/ S写在前面的话
9 M: f, U7 D1 b十大排序算法对比
冒泡排序
快速排序
  ?& n5 A% V" t# h+ A5 J8 k4 P. B直接选择排序
, q6 ], e9 |% u$ W4 u堆排序
7 F+ |& A0 {" H6 h) C归并排序
6 F4 K4 \) M( `3 F+ x# a插入排序
希尔排序
计数排序
5 J* n9 ]; X0 J' S: N4 L+ T桶排序
3 [7 e7 S: G4 A, g5 \6 S! y基数排序
5 ]6 U+ C; H" i; l$ U8 ]完整测试类
, h1 s1 u0 A+ B& P) |. j9 s7 {1 U写在前面的话
       虽然已经有很多人总结过这十大排序算法，优秀的文章也不少，但是Java完整版的好像不多，还存在某些文章代码存在错误的情况，同时也为了自己练手，决定把所有的写一遍巩固下，同时也真诚的希望阅读到这篇文章的小伙伴们可以自己去从头敲一遍，不要粘贴复制！希望我的文章对你有所帮助，每天进步一点点！！！


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


$ M: x; ^. A6 C( B1 T  M十大排序算法对比


  L* s! K8 x& R- p: i' U+ P

: z5 n; b1 T5 x关于最后一列的稳定性，我稍微解释下，例如对序列：1 2 4 2 6 排序，序列中存在两个2，如果我们把这两个2标记上（让他俩不同），排序之后，前面的2还在前面，那么就称这种排序是稳定的，反之不稳定。
9 P& W% L3 j0 y  w5 z- T
. {4 r" v) m! m; R8 E2 G5 y
- P9 p" U; P- I" D冒泡排序
简单解释：
* B3 s* l4 H) M8 |       原理就如算法名字一样，就像水中的气泡一样，每次我都把最大的或最小的放到最后面，这样总共需要n-1趟即可完成排序，这就是第一层循环，第二次循环就是遍历未被固定的那些数（理解成数组左边的数，因为每层循环都会把最大或最小的数升到最右边固定起来，下次就不遍历这些数了），两层循环遍历结束后，所有的数就排好序了。
       两层循环所以冒泡排序算法的时间复杂度是O(n 2 n^{2}n
1 W$ E; r# I, n4 V* a1 d2
3 |3 I) T+ d- V* q7 I- Y( t )，是一个非常高的时间复杂度，我在下面的代码进行了优化，加了一个标志位，如果上一次循环未发生交换，就说明已经是有序的了，就不继续下去了，反之继续进行下一轮。
3 N9 @% c0 J" _+ d% z) U; \


3 e8 ^! L2 x) _1 v& q' L$ R
2 h: p$ t' i" w: F5 F3 `

本文的图片来源网络，仅用于大家学习，侵权联系删除！（下同）
' W: u4 g1 I! \' G

- Y, A/ u, }+ a) Y/ [; T完整代码：


package com.keafmd.Sequence;


/ ~4 |9 k4 w- `5 }, e/**
2 g$ ~2 X& W+ m+ T3 v * Keafmd
*
* @ClassName: BubbleSort
* @Description: 冒泡排序
* @author: 牛哄哄的柯南
! V5 T+ k, r/ Q; `* u. f- ?5 {+ F * @date: 2021-06-24 10:31
*/
public class BubbleSort {


    //冒泡排序
    public static void bubbleSort(int[] arr, boolean ascending) { //exchange标志表示为升序排序还是降序排序

" a# x% t' X; g* q  W
% Q1 d, M1 Z7 L) A8 _/ L        boolean flag = true; //加一个标志位，记录上一次是否发生了交换，如果是，我们则进行下一轮，如果没有，说明已经冒泡好了

/ T3 d2 ?' w/ o; B$ t' p* n
        for (int i = 1; i < arr.length && flag; i++) { //控制次数，第几趟排序，只需要n-1趟，有交换时进行，只有flag=false就说明上一次一个元素都没有进行交换
# x; {3 X" [1 X0 p# `

2 \4 M( H& Q) C1 `7 c6 X) P2 X" Y' G            /*System.out.print("第"+i+"次遍历：");
            for (int i1 : arr) {
                System.out.print(i1+" ");
- Q# p# y7 |4 `$ Q            }
/ B( j6 o9 b. x4 O9 L3 b# U9 F            System.out.println();*/
# i4 d$ P4 {% H& m' X
: B0 ?+ y. T4 d* j# _" K
            flag = false; //假定未交换
+ X+ Z& P$ G' F& t
$ f2 f. d0 u0 H
/ e  I) ]" D* f/ C) K            for (int j = 0; j < arr.length - i; j++) {


( l0 K' [+ p( q& u; _                if (ascending ? arr[j] > arr[j + 1] : arr[j] < arr[j + 1]) { //控制升序还是降序
( m) |- A5 l, T" g                    int temp = arr[j];
7 c' @7 W4 n9 F4 g- d                    arr[j] = arr[j + 1];
+ K" J! t6 G2 z" U6 _3 F                    arr[j + 1] = temp;
2 _" M" ?4 i  f6 Q2 e3 P                    flag = true;
- s1 m; \, k" Z% R; P4 g' R                }

* y2 t  M* o4 f  \  f
  k5 }% ?% [! e# p% W8 [& ?            }
        }
    }
. {, j  B0 z; ^7 a% e# Q: l" K
) B% p! k- @5 }5 |$ d
    //冒泡排序 -- 默认不传参升序
5 Z6 o: ^2 g. e9 S. j+ S8 m( z    public static void bubbleSort(int[] arr) {
        bubbleSort(arr, true);
    }
( _& g8 L4 A6 v# M- w; ^}
! `( o. ], K- d/ m$ v1
- u/ c/ Y% B3 C! M# |2
3
: N$ @/ f) `2 W  T4
5
3 J( ]* R1 F- s; u3 g# ~6
7
; R% ?9 C. `- |! h/ o  I8
9
* ]0 h2 b8 k% D. k) P10
: X# W& G* t7 l- R  I' F& O11
12
' q& m- X$ {0 Q3 ]9 P, {% h" V13
8 C& h4 d1 E* F8 {14
/ @0 m7 Z% |6 O, H! j15
16
, i# v: G5 u* H. j1 }- D* F" t3 L17
& M- Q8 V3 C$ Z* q18
4 T& R/ f! Q- P* Z. m$ q19
20
; j/ c  F1 f6 x& z* \6 j' {& G21
22
/ h( R( D  x1 d+ }: O/ Z# \23
24
25
8 p/ c. ~  n% a+ p2 ^( \! c" Y26
27
/ l  o4 Q; E3 ?9 l9 r28
, n* s7 L2 U. I2 V29
  V1 y4 e* U/ D30
, C) A7 a  n$ @7 V" L# C31
32
- ^2 L( i2 f" D+ A# c7 {! l33
; R, k, a5 ]& b* C5 a34
35
1 O5 y4 O1 L0 i6 S! j2 j9 |36
+ E  S8 C7 g; A: T37
38
3 a  R0 F. ^* ?' N: h2 F39
! a4 I, T; {. w, p: g* v0 H40
41
42
3 c, [, J0 D5 [1 {5 ]43
* M& N- q* u7 e: e44
45
7 H) [/ g' U; }  ~8 D& C; {& r9 L测试代码：
% O: V* m& E% g. n+ T: x9 ^) J3 R

升序排序（从小到大）


package com.keafmd.Sequence;
1 D* n' }0 a7 ]& B0 L6 T" h0 q2 ~
6 P9 U) @5 |: j: ]# g' z: W
) j+ h2 b) ^$ j  I( e2 aimport java.util.*;
+ r3 E- M  T4 y) u! |# U$ Himport java.util.stream.IntStream;
import java.util.stream.Stream;

0 r5 G8 z% j+ |
& j" K5 Q, I0 L% ^. d' ^/**
* Keafmd
*
& b9 `9 I6 U, x! o" m2 D8 u) d * @ClassName: Sort
* @Description: 十大排序算法
5 g4 X( M8 J7 m: x4 R * @author: 牛哄哄的柯南
5 y, i  ]0 V2 c7 d  J * @date: 2021-06-16 21:27
*/
3 x; ^' `# [, D" T1 opublic class Sort {
# r" Q+ i+ f3 N; f+ H. S; f# T7 X    public static void main(String[] args) {
. h  z. ^7 u; O; \& g3 z7 k
8 K! c2 ?" O" q9 E# \  m  h
! k) H" d3 }8 P- C+ ?        int[] nums = {12, 4, 25, 47, 58, 34, 25, 9, 99, 26, 1, -13, 162, 10093, -66, -1};
        int[] temparr;


        //测试冒泡排序
        System.out.println("测试冒泡排序:");
$ ^% S$ o5 Z# A6 {  T( `        temparr = nums.clone();
5 U% i/ k3 p2 T2 Q4 D1 I        BubbleSort.bubbleSort(temparr);
        //逆序排序
        //BubbleSort.bubbleSort(temparr,false);
! a  P- {) q5 L: k. \        for (int i = 0; i < temparr.length; i++) {
9 K) }  `# N3 W# L            System.out.print(temparr + " ");
        }
: V5 m# X' v2 |  n* u        System.out.println();

1 B4 j6 I7 W' C  s9 H5 _) }
* Z9 K6 e0 X5 n    }
$ M) l# q# B7 m3 Y, ~, g( J  \}
1
2
3
( O# Q8 r7 O- G: s5 c4
) [- q3 Z2 |8 J0 I: j) b5
6
7
8
9
10
11
12
, d8 n* Z& L; R" W4 k  Z# }" E# ], c& r13
7 a6 y9 a3 w7 ]7 ?) t* n14
15
16
17
18
# r, L- F' j) `: ^' c19
20
21
22
23
24
( E$ f2 ]6 ]- S. k9 t25
8 u# ?$ ]: F; O# w1 n1 E26
( {: b4 f( o4 a3 a' w27
28
29
30
31
/ A0 Q- p( I% S( z4 @! R32
" y4 k" i$ S3 h4 J+ B33
运行结果：
. q6 X/ A8 n- [2 ?3 V& Q7 `4 l

测试冒泡排序:
-66 -13 -1 1 4 9 12 25 25 26 34 47 58 99 162 10093
2 Z2 N, R2 O( F8 t1
+ b8 `7 y3 \1 n  y1 I( @8 b+ D& y; Y2
# U" ~* {4 I9 @$ y# t% E  o降序排序（从大到小）


8 c  l0 }2 S: q7 A' x/ A2 L//测试冒泡排序
System.out.println("测试冒泡排序:");
: S* P5 i$ L. h; Ftemparr = nums.clone();
BubbleSort.bubbleSort(temparr,false);
for (int i = 0; i < temparr.length; i++) {
    System.out.print(temparr + " ");
}
System.out.println();
7 J) m2 P3 W# n5 J  Q1
5 }( F2 q: ?; B3 [+ s2 s& ~2
3
6 n; ]- _2 l1 [8 |4
9 q7 _1 n9 c% V+ |5
0 |" q& T6 T4 B" X+ x, e" W6
7
9 N8 J7 }. N$ V8 J- d$ l. n8
运行结果：
7 b4 N7 K6 L9 h! o8 h

测试冒泡排序:
10093 162 99 58 47 34 26 25 25 12 9 4 1 -1 -13 -66
1 M* ~8 q. b+ u! o5 Y! d) x1
2
下面几个算法的测试也就是换了下类名和方法名（换成相应的排序算法），如果想降序就在数组后面传个false即可。我就不一一复制了，我在最下面给出含所有算法的测试类，需要的自取即可。
# e* E/ R$ S, C4 l2 g

% ]" [5 Y7 q, B) D) J快速排序
简单解释：
快速排序就是每次找一个基点（第一个元素），然后两个哨兵，一个从最前面往后走，一个从最后面往前面走，如果后面那个哨兵找到了一个比基点大的数停下来，前面那个哨兵找到比基点大的数停下来，然后交换两个哨兵找到的数，如果找不到最后两个哨兵就会碰到一起就结束，最后交换基点和哨兵相遇的地方的元素，然后就将一个序列分为比基点小的一部分和比基点大的一部分，然后递归左半部分和右半部分，最后的结果就是有序的了。
2 x/ j6 e8 ]$ t7 V! H- T# v

2 H; `1 m  M" L% s



完整代码：
. o3 I6 ^! c- P' r& I  Z4 M
- C+ N" q" q+ [$ Y6 e- h' C
+ w0 R2 @2 Z$ f, @% Ppackage com.keafmd.Sequence;
8 h- G# g  s7 @1 k" u% n
* L7 J6 q4 t( j- d% x
/**
* Keafmd
*
; l( Y: o  Y' | * @ClassName: QuickSort
* @Description: 快速排序
* @author: 牛哄哄的柯南
  M2 V" Q8 G1 u# M6 b/ y; ^ * @date: 2021-06-24 10:32
*/
2 A9 B' ~) h3 F" I; U  ypublic class QuickSort {
3 R* Q9 @  n- U9 r

$ W* N5 g; K- y- z) z    //快速排序
    public static void quickSort(int[] arr) {
        quickSort(arr, true);
    }
4 L" H2 o- y; `% @

: O2 Z" _* ~* P6 J; C9 r' X8 a! @; g+ K    public static void quickSort(int[] arr, boolean ascending) {
( y5 L7 Y3 _& Q- f8 `. F: ^( r        if (ascending) {
            quickSort(arr, 0, arr.length - 1, true);
        } else {
. O& ^2 B7 M; h, J6 ~; O$ g* y. }            quickSort(arr, 0, arr.length - 1, false);
        }
    }


    public static void quickSort(int[] arr, int begin, int end, boolean ascending) {
) Y  |+ P8 j5 l* p- V0 ]        if (ascending)
9 o6 _5 J$ E6 \            quickSort(arr, begin, end);
) S/ ~/ j8 n( R4 t8 s9 [        else
            quickSortDescending(arr, begin, end);
    }
8 d/ [( g  @, }7 Z$ d

: R) K% c7 u: H* U    //快排序升序 -- 默认
- P3 t0 J+ K' |( s  a( \1 O0 g    public static void quickSort(int[] arr, int begin, int end) {
; ^5 S$ P0 H3 }0 ?        if (begin > end) { //结束条件
5 x# y, J% b( n/ F' r            return;
4 A( H" H  x5 q! _$ w9 S2 h+ M" W4 b3 H        }
        int base = arr[begin];
        int i = begin, j = end;
1 O* m/ O+ Y4 Q7 P+ Q        while (i < j) { // 两个哨兵（i左边，j右边）没有相遇
            while (arr[j] >= base && i < j) { //哨兵j没找到比base小的
$ h2 t5 Q0 |2 z5 s$ e5 U4 x                j--;
; U6 m0 ~; r7 P: f& V3 |            }
            while (arr <= base && i < j) { //哨兵i没找到比base大的
, O1 S. {( _1 u/ u% j. y$ \3 B                i++;
            }
1 j" b; B# e  @8 k( d' z            if (i < j) { //如果满足条件则交换
6 H% j- t1 t7 O% q                int temp = arr;
) u* F4 {9 G2 q% L                arr = arr[j];
" R2 _3 u! h, `! }9 @                arr[j] = temp;
* E7 K8 q# t& }1 J1 [; k            }

. G, e" l) l* ?# C4 \
( d1 ]6 l3 a6 |6 ~  p7 c/ f: J        }
        //最后将基准为与i和j相等位置的数字交换
8 O' a9 O# c! s+ C        arr[begin] = arr;
2 w% i6 b- S* D        arr = base;
        quickSort(arr, begin, i - 1); //递归调用左半数组
& i% A8 A1 b! Z* q; t        quickSort(arr, i + 1, end); //递归调用右半数组
- f- t# p6 b; C+ W

# b+ F& g% L5 N8 O- W! i# p4 k    }
1 N; z9 j! h2 F9 p1 x& Z
* T! O$ M! [2 H6 F/ P5 [: j
    //快排序降序
4 A) V7 n& ^: j- r+ J3 _: T' ~    public static void quickSortDescending(int[] arr, int begin, int end) {
        if (begin > end) { //结束条件
            return;
        }
        int base = arr[begin];
        int i = begin, j = end;
        while (i < j) { // 两个哨兵（i左边，j右边）没有相遇
            while (arr[j] <= base && i < j) { //哨兵j没找到比base大的
3 O' E' P5 ^! v6 `  |                j--;
4 _- U* {! i8 M6 S# l  F/ r            }
            while (arr >= base && i < j) { //哨兵i没找到比base小的
                i++;
            }
            if (i < j) { //如果满足条件则交换
                int temp = arr;
7 d# A2 |/ j0 u0 c. Q: _5 k                arr = arr[j];
                arr[j] = temp;
            }
  O+ k9 c4 B- O3 [" Z9 Z2 \
; r3 q' q( B) o. _; ]+ @+ H2 Z
        }
        //最后将基准为与i和j相等位置的数字交换
        arr[begin] = arr;
, |* _. l$ x& e) ^, l        arr = base;
        quickSortDescending(arr, begin, i - 1); //递归调用左半数组
; F+ c0 {$ H: K/ o3 \8 g) R        quickSortDescending(arr, i + 1, end); //递归调用右半数组

* f: M6 K+ K( @7 Y) X
. z9 q# V2 [( G$ T1 t; G  x    }

. C+ T1 M1 G# L4 C1 d  z# k
}
& A" i5 u) b) H; Y1
2
1 M* q4 l+ g6 U: S3
5 e$ W  ^( a4 X) `5 r4
5
( j4 F. _/ W* r5 d4 Q6
7
% M0 j3 B% {+ q" J/ G& @8
, ~/ z% r* K* j9
* ~# v! R/ n1 n10
11
12
/ [: x# ^1 e0 N13
. k5 t) @: f' }- E) \$ {" I  c14
15
5 {' t/ Z. d: d. B16
17
18
19
; S& {8 I: ]+ e: i0 `4 N# b- j$ p20
! n* S( Y+ B2 b4 [21
22
23
; f) u" ?; e4 X24
. l3 f3 H$ T+ Z- @* c25
26
' Y5 \+ C* g2 s% X. A27
28
29
30
31
32
" z7 w+ j/ r* {& y33
. g' ]; B4 p0 w7 X( j- F; Q34
35
: B5 y1 v* o/ @* I' R36
37
9 T: Y: o9 ^2 o38
  v/ r1 u" q) ^0 G3 R' |& C5 e  S7 V39
40
41
42
43
44
45
46
3 i3 t) F2 r+ K3 S( o5 [0 K47
48
49
7 D1 t# k4 X; K- K8 i/ W$ g50
51
$ \, p7 X# \- Z52
" o2 n7 b: Q; }53
* I( b. C% H3 E6 {1 {$ f+ v54
55
56
57
2 k( _0 l( ^8 r5 I5 I$ v+ G3 R- F58
3 }$ B3 `. {3 Y9 [, K5 U0 Y1 p59
. E. T, b( H: j% A6 V60
61
5 l; o9 l+ }7 K; D62
63
1 I  ]$ l1 J1 ~7 E, [1 Q% f64
65
! m! N; n! s/ j: h66
67
68
69
5 Q. l: t1 b' W70
) c. e' I  l7 N0 b/ P& X# r/ q71
  i! N4 j7 }6 P) o7 u3 C+ P! t- K3 F72
% n( L9 g/ x: W) O  p& X73
74
75
76
3 S& s  M' P0 E0 k77
78
6 a- _9 ?3 {; x" M79
80
$ w# n. u* ]! }3 U81
82
2 F: s8 A" B" D0 L83
84
85
' G* E8 I* Q4 H6 @% n, ~0 Y86
, h2 x& T0 U: q87
88
89
' \/ \( G4 [% \5 T90
6 L7 O% d: P6 W91
直接选择排序
简单解释：
# U+ G8 }: ^9 y( `数组分为已排序部分（前面）和待排序序列（后面）
+ k( r/ W4 b! y% W- a2 f第一次肯定所有的数都是待排序的
从待排序的序列中找到最大或最小的那个元素，放到前面的已排序部分，然后一直找，不断缩小待排序的范围，直到所有的数都是已排序的了


5 p7 T; F, ~0 c# H" k



' ^1 Q2 M& n% I- P* y7 N  U完整代码：


package com.keafmd.Sequence;


/**
* Keafmd
*
* @ClassName: SelectSort
9 _' j# Z3 B/ @9 Z * @Description: 选择排序
* F4 s6 U* E$ }9 c, P2 d * @author: 牛哄哄的柯南
* @date: 2021-06-24 10:33
) [% z* X6 N% Z" n */
1 g8 i- k3 z# Lpublic class SelectSort {
; t& d) m5 E& P# N' O+ g
* J, Y2 Y$ k/ J1 k, r9 g/ ]
    //直接选择排序
0 N' _6 w% @" P    public static void selectSort(int[] arr, boolean ascending) {
        for (int i = 0; i < arr.length; i++) {
            int m = i; //最小值或最小值的下标
, R( y, p$ i+ x            for (int j = i + 1; j < arr.length; j++) {
8 s% J8 Z, X- r! z) W4 M' b- z' T                if (ascending ? arr[j] < arr[m] : arr[j] > arr[m]) {
                    m = j; //找到待排序的数中最小或最大的那个数，记录下标
, ~2 e" K: D7 i+ D& l                }

- n9 d2 h" Q; T1 F
            }
            //交换位置
0 f$ v7 B! e0 `' C! f" k+ z8 O            int temp = arr;
, z5 W/ k# k- e6 I: r! U            arr = arr[m];
            arr[m] = temp;


        }
    }
! K+ u$ T+ ?0 H  w7 L$ d

    public static void selectSort(int[] arr) {
7 D# Y1 Q5 G. v% X9 K$ f: [$ D        selectSort(arr, true);
    }
}
1
# m9 X! J: d. l8 _* K; F8 J2
3
4
5 T: I) J/ m9 u7 t5
; T, M( w  v: @6
5 J: \$ ~: o2 k) T7
5 l; ?# i- k/ Z8
5 p- H$ E6 y% I. M! m9
/ H& l0 o0 o- g; [# \5 w9 F10
11
12
0 z2 F+ L3 S- ]13
1 o3 }* ~% y  M/ h/ ~- l* g  G3 |* i14
, Z1 k' C+ M3 O- {& B15
16
- ?. k' W/ T- k+ g8 ?17
18
1 z1 y! K0 M/ ?$ X, M' M- c( G19
: w0 U& L: ^6 E" H' X( s20
21
22
23
24
25
' q0 Y% ^, U% Z. R1 q! N% R9 t/ E( T26
5 p. t8 ?" `! p* L27
  n$ p% e, ~& w7 _28
% u, S; U. Q3 a1 t  s, ]29
30
31
32
: M! p2 r+ j7 `" I3 M( R33
34
堆排序
0 x1 G: \! }5 L1 q6 |2 l  R* e先理解下大顶堆和小顶堆，看图
大顶堆，双亲结点的值比每一个孩子结点的值都要大。根结点值最大
8 e; P& W- _! D  m5 z小顶堆，双亲结点的值比每一个孩子结点的值都要小。根结点值最小
* p3 ~9 n2 C! Z+ q
9 Q: C4 K" @. T$ |* _


简单解释：
构建好大顶堆或小顶堆结构，这样最上面的就是最大值或最小值，那么我们取出堆顶元素，然后重新构建结构，一直取，一直重新构建，那么最后达到排序的效果了。
1 B+ E, X3 S- |8 m+ A4 j0 L
" g( J* K1 A, S

7 I8 M5 w- Y. Q  V
! X5 s1 G" f  I8 B9 }
2 S/ _1 ^9 `. |
完整代码：
  T8 ?8 M# k0 A. Q8 Y7 P  G) S
2 n6 \% |5 z" U! f/ b7 H# h
package com.keafmd.Sequence;


/**
+ ~- y# q4 p" U" a8 m( I3 ` * Keafmd
) u9 U" X" h" n" r2 J- C6 K. Q2 U4 u *
* @ClassName: HeapSort
% ~0 \, v4 U# F6 p2 D  y$ r * @Description: 堆排序
+ S* n) q8 b0 J, n* M * @author: 牛哄哄的柯南
. z% A! d. P4 x4 y * @date: 2021-06-24 10:34
# @, p3 p9 K' V* x+ Q+ j, y7 F */
- c5 F8 f5 ^1 ~. `4 t, Q* E# Mpublic class HeapSort {

# i( e1 }. ]6 m2 d
5 ^. b5 g7 X$ d; [    //堆排序
    public static void heapSort(int[] arr) {
* ]  D; ]8 a# @$ q6 I0 C0 x        //对传入的数组进行建立堆，这里默认建立大顶堆，进行升序排列
        heapSort(arr, true);
    }
$ f& _- r/ @4 P. c
& v9 M$ B: g/ I9 ?7 |1 U5 V
    public static void heapSort(int[] arr, boolean maxheap) {

  b) N% }: V, M# U& U2 E$ x& d3 G1 {% s  |
        //1.构建大顶堆
% h. c& w/ z) y$ I# ]* Y; z9 H        for (int i = arr.length / 2 - 1; i >= 0; i--) {
5 z* B: X( G) w- g8 f6 b2 M            //从第一个非叶子结点从下至上，从右至左调整结构
            sift(arr, i, arr.length , maxheap);
        }
3 E" `9 Y5 j0 G' z7 V

        //2.调整堆结构+交换堆顶元素与末尾元素
- k1 G2 q5 v0 ^2 H+ Z% h6 Y  {        for (int j = arr.length - 1; j > 0; j--) {
" L' F; P+ u1 z+ B* d+ q8 h
1 q$ [* s; `2 N5 T& w. Z- S
. C6 v. g, c7 K5 e  v# _4 Z- \            //现在的数组第一个就是根结点，最小值所在，进行交换，把它放到最右边
$ w6 w9 r' a6 d) ~$ N! I) H/ k. X7 P. T            int temp = arr[j];
            arr[j] = arr[0];
            arr[0] = temp;


7 R* c+ {3 v' c6 e8 [            //重新建立堆
            sift(arr, 0, j , maxheap); //重新对堆进行调整
        }
    }
) t& ]& @/ l" R) `) \

    //建立堆的方法
    /**
     * 私有方法，只允许被堆排序调用
4 U2 O' f# X7 z# A) k6 k     *
     * @param arr     要排序数组
     * @param parent  当前的双亲节点
- t0 ~% D' @0 c2 c' w* c0 `; L( i4 I3 `     * @param len     数组长度
$ {  o  L1 M" P- ]$ `/ v$ N     * @param maxheap 是否建立大顶堆
     */
9 l2 t3 [4 g0 q# [$ r3 I4 j    private static void sift(int[] arr, int parent, int len, boolean maxheap) {


        int value = arr[parent]; //先取出当前元素i
1 x- t- ^" w+ g9 `
. ?( Z. ^# n0 `5 }; }) T  [
' O9 m( D3 a+ g/ G        for (int child = 2 * parent + 1; child < len; child = child * 2 + 1) { //从parent结点的左子结点开始，也就是2*parent+1处开始

  U  U. M1 f  {2 S; i3 E9 C
            if (child+1 < len && (maxheap ? arr[child] < arr[child + 1] : arr[child] > arr[child + 1])) { //如果左子结点小于右子结点，child指向右子结点
                child++; //右孩子如果比左孩子大，我们就将现在的孩子换到右孩子
            }
; E, S/ G2 x) @! ~8 |

1 k. z. P% E# _9 `. A, x# i            //判断是否符合大顶堆的特性， 如果右孩子大于双亲，自然左孩子也大于双亲，符合
5 Q  I. @( ^) k6 x1 M6 Q+ M  H6 E3 `            //如果子节点大于父节点，将子节点值赋给父节点（不用进行交换)
            if (maxheap ? value < arr[child] : value > arr[child]) {
                arr[parent]=arr[child];
" h. T3 S6 m( G; X" B                parent = child;
$ d0 b+ O# ]7 [8 S# g            }
9 c0 J. m+ F* @8 ~6 d- r            else {//如果不是，说明已经符合我们的要求了。
                break;
            }
        }
* ~) I9 J0 T- t  a4 f, u3 w        arr[parent] =value; //将value值放到最终的位置


3 s  R9 P8 Z2 X' a3 a' J

    }

( ~# ?+ ^+ P1 X: M  F$ C
}
6 c0 i$ c+ C. k( {1
2
/ h' |4 h  Y1 G0 @) z. \3
4
5
6
7
8
5 O+ ~+ X0 C. J" `; M2 ~9
, s; [% [' t$ j4 y. C10
- J+ B% O0 i+ O+ e11
7 \+ n' j5 i1 w, B" R. z2 f5 o12
- j! A2 y( j$ h% ]$ g: {13
. e. L' t$ G0 C) }+ R* \, c4 g- ~; J14
15
16
8 R# n! I& f( O- l7 X17
+ B; u( {1 n! R6 {$ q18
19
! G: y7 C' w3 m# j1 c" J20
+ `$ V; Y9 a- |" P21
22
23
6 X, F+ @& r5 R* t4 j1 q24
, Z. F7 {- [4 Y4 h" A: g25
, g4 e- ?5 p5 ^9 h# U. n26
# n$ n3 |3 ~/ M* C7 G9 `* P( D7 W27
; U4 a( i1 x" p28
29
+ n  J0 G; H$ F  Z30
31
. Y7 S* @2 s2 Z0 y  q32
33
34
# h0 Z: L  }* D5 {/ S7 f) n& w35
3 j. \/ E" n( Q( I% \* {- E% @36
0 s- @2 x& s  ~9 h7 p37
38
% @9 h3 T, g, |39
40
41
42
8 w# T+ ]7 l! u; n% U* f+ H43
44
45
46
47
48
3 ?! P. j0 J- w2 ]& I4 Z49
! |1 Q& `" a( s9 U9 W& x50
, C* _& T9 y) t' i4 i51
52
53
5 R6 |7 }* X5 g54
, Z7 [; D9 Z  {  s0 W55
' _6 g% j. X( J/ G5 b& A56
  B2 V# D$ r* l+ |. |4 c+ F  o57
; @9 g3 @3 o4 B9 X( o2 B58
59
" z+ d1 E) c* Y60
* |$ b- R+ M" H3 v1 M. R3 a61
62
1 L8 f- q  t( G) L& q* Z$ X63
64
65
5 @0 J( Z; _( L  V66
67
68
- Y+ A% v& l$ E- I69
70
4 j* _( U1 y- Y3 X4 t5 _) x71
# R) q& ]0 d0 R) I* n7 V; Y72
73
  X% }6 a  v% E$ u1 E& ~74
归并排序
% A! e7 Z: h! m$ {5 J简单解释：
# q* F3 d/ A  H, ]0 `) N# ^# c4 s该算法是采用分治法，把数组不断分割，直至成为单个元素，然后比较再合并（合并的过程就是两部分分别从头开始比较，取出最小或最大元素的放到新的区域内，继续取两部分中最大或最小的元素，直到这两部分合并完，最后所有的都合并完，最后形成完整的有序序列）


( Y# T: N; @  }/ G1 b" Q4 K
+ o7 u: F$ y$ K
# @7 H: H; T: C# W
1 V( w9 w" h2 F
6 V4 O3 ~/ h! j完整代码：

* N! B# x! P) y) r& G
package com.keafmd.Sequence;

# u( R& @) u* \% Q7 e" v
5 z( i% x* ?3 T% X2 C9 _/**
2 M  ~7 c/ ?1 P4 `7 p9 j. n * Keafmd
*
1 g% k" h) [& C! ?% Q * @ClassName: MergeSort
* @Description: 归并排序
; l  [' n  [& G, \8 Z * @author: 牛哄哄的柯南
' x3 N! w2 d2 i- J" J: w * @date: 2021-06-24 10:35
*/
1 g4 u  f- B: n3 A& ]" z0 Xpublic class MergeSort {

! G; d8 [1 J: A
) z3 S. G1 A- E8 }+ n    //归并排序
    public static void mergeSort(int []arr ,boolean ascending){
        int[] temp = new int[arr.length]; //在排序前，先建好一个长度等于原数组长度的临时数组，避免递归中频繁开辟空间
        mergeSort(arr,0,arr.length-1,temp,ascending);
    }
* b/ a* n2 i& K* \) }# a. L1 n3 K3 b    public static void mergeSort(int []arr){
        mergeSort(arr,true);
. n- _1 A9 \" f$ D& G; X* h/ T$ A    }


# }. ~, n4 r2 _. P/ h    /**
4 V6 B/ ?$ h4 ~+ l$ v: m     *
0 X$ S# _3 ?3 r7 E9 f3 f     * @param arr 传入的数组
     * @param left 当前子数组的起始下标
     * @param right 当前子数组的结束下标
& {4 |3 s9 o: o" j4 s     * @param temp 拷贝暂存数组
     */
) b; h8 Y1 j- l8 Z8 R) D    public static void mergeSort(int []arr,int left,int right,int[] temp,boolean ascending){
        if(left<right){ //这里是递归结束的条件，我们是对半分，那当left==right的时候肯定大家都是只有一个元素了。

# [' K0 f5 x$ @( @6 S$ [, N5 v+ H
            //对半分，比如总长度是10，left=0，right=9，mid=4确实是中间分了，0~4，5~9
  j4 @% h0 R9 o" \            //当长度9，left=0，right=8，mid=4，0~4，5~8
            int mid = left + (right-left)/2; // 防止越界的写法
) c# c: H2 A% M( F            //int mid = (left+right)/2;
+ K1 E* y$ W, y! E1 U- I9 s- t
8 j  ~4 j2 r( x& p" K
            mergeSort(arr,left,mid,temp,ascending); //左边归并排序，使得左子序列有序
% P: N# o8 I5 Y3 @9 i% |            mergeSort(arr,mid+1,right,temp,ascending); //右边归并排序，使得右子序列有序

# _& s* D7 Y- ^; ~5 }
            merge(arr,left,mid,right,temp,ascending); //将两个有序子数组合并操作
+ Y6 ?) E3 e0 `' \, t1 U  m        }
    }
# L$ J( E" e: w% h: j

    private static void merge(int[] arr,int left,int mid,int right,int[] temp,boolean ascending){
4 D, U( ^5 c( m3 H        int i = left; //左序列起始下标
' [$ h$ M: d$ n/ C6 v! S5 U+ u: E0 N1 i        int j = mid+1; //右序列起始下标
        int t = 0; //临时数组指针
! `! B9 B1 z5 M- F. L/ ^        while(i<=mid&&j<=right){
* j" J3 ^9 s6 |& j- H/ T; W            if(ascending?arr<arr[j]:arr>arr[j]){ //比较两个序列第一个元素谁小，谁小先拷贝谁到temp，然后对应子序列下标加1
                temp[t++] = arr[i++];
            }else {
# H/ ~: U0 h' i( A* D  d! G5 j                temp[t++] = arr[j++];
+ G3 t" p, u' u# s3 U            }
        }


        while(i<=mid){ //将左边剩余元素填充进temp中——左序列有一些数总是比右边的大的数
/ H" J/ l" _2 b9 s            temp[t++] = arr[i++];
        }


9 j7 M+ S" k3 F! F( @% I        while(j<=right){ //将右序列剩余元素填充进temp中——右序列有一些数总是比左边的大的数
            temp[t++] = arr[j++];
9 p3 V# G& R8 b2 f0 X# u        }


; v7 d# u* L+ i0 ]        t = 0;


        //将temp中的元素全部拷贝到原数组中
$ o# U; M) m9 H) y) _6 Z4 s5 R        while(left<=right){
            arr[left++] = temp[t++];
  g! {; o- {" E9 U        }

9 ]2 o8 O5 p. w: c* d; m: b( b9 l  c
    }

" I8 k% n2 b' E' `8 W0 m
5 @7 x$ Q- n0 j" T. W. L% {3 W- P}
1
2
8 D# E, W* ]3 _% z, O  s3
4
. R" q4 s5 v; p. V+ }5
6
5 \% e3 r* B, \7
! B* F9 Y3 f7 ?% G9 H" A! S! w8
9
10
11
12
1 ]# N/ h" l$ E' Y13
14
15
9 h. F# J( h2 s. d* H4 r7 J" n$ a# h16
17
18
, b% Y; [+ c; u9 O19
20
21
" D& U) h0 a/ R# M# U2 V22
23
9 {- ^5 Z  }# ]2 M% D' C24
# d% s. z/ Q$ D" e9 L25
26
27
1 G% K/ f" ~) @28
! U. ?# T! N8 W5 W" z9 [29
$ a4 C& Z7 s/ s( R! l5 n0 l30
7 _" v$ W3 G5 E31
32
33
% R2 t) }) {4 }  Q" d# D! \  y34
35
36
37
% j+ J  {2 X% q, i" @  y38
39
40
. x1 y/ z3 O/ X) G1 X# y41
42
43
, \8 @% Z; f/ q, R0 v44
8 x, q9 u' j" h45
46
8 A# U' m- T% g8 E47
48
49
" q) E: m- Q$ Z$ N50
51
52
53
54
0 `* y- I% v1 w7 s, M: a55
3 U6 Y& q1 j% Z1 K9 M9 h56
. B, {- x2 x3 M! y$ |, `) {* F57
% u4 g6 x+ J4 Q% O+ S% w. I58
' m  f- t/ \1 G! ]3 @* B1 I- R59
& p) ^6 v; A; ]' \+ Q2 W60
# Q8 c& n8 R2 K% V# O7 W$ v  c61
; F: s+ N$ o) a8 |* _7 ~62
63
64
% ^7 a- t7 [9 o( T7 G65
6 p4 D8 d0 A# H66
) P& Q. t% F' |6 l9 A% Y5 }/ x67
68
69
" @% [  O% P2 {  i* I* S8 c70
71
  s) S4 c9 d: Y  }% W$ P- g72
73
插入排序
. P, x& x9 z4 [简单解释：
3 I7 M* a0 F  H/ M最简单的理解就是打地主时我们拿到牌后的整理过程，从第二个牌（假设我们拿起来这个牌开始比较）开始，（说下升序）从后往前比较如果比前面的那个牌小，就把牌往后移动，直到找到一个合适的位置（这个位置的前面的那个牌不比这个要放下的牌大）就把这个牌放到这个位置，慢慢的前面的部分变得有序，直至全部有序即可。

- C# V& t" e; E5 ~

& Z8 \/ u& R, N

+ K3 t+ c/ ?( _7 C: o0 W; X
. M; M! ?" [  M1 }; ]7 Y/ r完整代码：

, T# @2 R+ _  a( c3 x# C/ v& x
1 C) U: R. s  C% E3 k; a* vpackage com.keafmd.Sequence;


/**
2 d% Q% x: V# j5 W9 q * Keafmd
  l+ A0 T% d3 \ *
* @ClassName: StraghtInsertSort
* @Description: 插入排序
* @author: 牛哄哄的柯南
# H. }/ @( c' R, z: ]& ~, } * @date: 2021-06-24 10:36
*/
public class StraghtInsertSort {
. [$ K( N& {+ T1 Y9 s+ R1 {1 K    //插入排序
    public static void straghtInsertSort(int[] arr) {
        straghtInsertSort(arr, true);//默认进行升序
/ l" y. z3 Q9 k" \3 C: k; @    }
* v' d- }9 ]; n" f

    public static void straghtInsertSort(int[] arr, boolean ascending) {
: J. Q; O( [, T# {9 K- X

, T5 b% W( A; h& X        for (int i = 1; i < arr.length; i++) {
            int temp = arr;
            int j=0; //这就是那个合适的位置
            for (j = i - 1; j >= 0 && (ascending ? temp < arr[j] : temp > arr[j]); j--) {
                arr[j + 1] = arr[j];
            }
            //把牌放下，为啥是j+1，
0 f7 H8 ^: h6 X4 o0 i3 h1 e            //是因为上面的循环遍历到不符合情况的时候 j是合适的位置的前面的那个数的位置
            //有点拗口，但是就是这个意思，看图方便理解下
            arr[j + 1] = temp;

7 V3 j  y$ D1 q% L
& }+ }/ Y4 P3 _
0 z1 X& ^" |& b' V7 T' F
        }
  N( p- ]0 `' G& X. F% K1 ^) s

    }
4 c$ _" p* W; ^4 Y" d$ g}
" j: L' A) x: f1
2
3
4
( H2 n0 F% {0 p3 M) d8 y5
6
& t: o: L3 l  w. t! P3 A6 v( r* R7
8
% T7 o0 B7 @6 n  l9
; r, G- O  j+ c: V' j3 y10
11
7 ]1 f* h; H/ F12
13
14
, K8 l. f" A. Y7 ?* M15
5 W& Y3 \3 P: g; O# X- V9 F7 U) t8 w16
3 p$ k0 ]3 }+ d, w1 x. ]/ m/ \6 V17
/ _$ S: p. Z8 {0 P8 B  p) w) Z18
19
7 O1 R1 l) k1 x# s; |20
21
22
23
24
( b! E4 `/ [0 F. a5 _. S25
# c0 y6 M% P' a. e7 j# R1 ]26
27
28
7 X1 D5 y/ F  m& i- V29
30
. c- _, B4 }; C& S+ `31
32
33
34
希尔排序
简单解释：
( K# k7 O' w" P3 D9 B希尔排序是插入排序的改进版，我们理解一个叫做下标差的的东西，也就是下面那个图中的增量d，初始下标差为arr.length/2，然后继续/2，对在同一下标差（相当于把这几个数单独拿出来了）的若干个数进行插入排序即可。

5 U5 S  K; ?3 q5 D
. @7 u6 U' p# m1 `) m: @7 @: q$ [
2 ^8 q/ p7 D" Z! E
" z* @* a- y9 @0 @+ g  \9 a
" L) n; i2 L/ u7 [" X9 F
完整代码：

1 u/ P+ W- m4 z; `
package com.keafmd.Sequence;

- K  ?% i8 {# S+ k/ V0 K- S! g
/**
2 [1 G8 T8 Y9 d * Keafmd
*
* @ClassName: ShellSort
& q3 E5 D" a! ~4 S7 x0 r! N9 D% V * @Description: 希尔排序
+ W7 ^- z) n/ D/ p' q * @author: 牛哄哄的柯南
* @date: 2021-06-24 10:39
9 H1 V6 [0 U9 A, r$ @ */
public class ShellSort {


    public static void shellSort(int[] arr) {
4 [) v+ {8 D, ~4 h        shellSort(arr,true);
    }
' F0 b' R2 p  N9 h' ?
8 M3 n1 P/ ~' e( V" _2 `2 A2 N& g" @  x
6 ~. t5 _3 C" U+ }9 ?    public static void shellSort(int[] arr,boolean ascending) {
( f7 ]3 B! I( g( r

8 v/ S# O, |( U4 {) V        for(int d = arr.length/2;d>0;d/=2){
0 p# O! d( k& v1 H7 i

# N) L& _- E) F$ V            for(int i=d;i< arr.length;i++){
                int temp = arr;
                int j=0;
5 m2 D% z, U* w: K3 K1 `1 @8 Q                for(j=i-d;j>=0&&(ascending?temp<arr[j]:temp>arr[j]);j-=d){
# x, g  K9 E+ M  M                    arr[j+d]=arr[j];
' p+ z. |1 E  b: r; a6 m' e2 X                }
4 Q% S5 G4 x' q! J                arr[j+d] = temp;
            }
8 D# A6 U2 S& ?: L3 {7 f        }


    }
$ ?  l# B+ I/ A}
" s, k4 r! Q3 D+ F7 c1
! m+ \' i1 W0 g0 A4 G, _2
% F: i8 Q4 @; O& E# d  ]+ L/ b5 n3
& ?& p! k6 @3 c4
; u/ [! P- m6 N6 f& `( j( [5
6
7
8
9
10
1 {2 B0 r# ~5 V1 _0 u: h$ X5 i11
0 z5 c; g+ J# g3 f: O7 F- J) t12
13
4 x6 z) X  n7 F6 _% e+ K; R% T14
15
16
17
3 {- V4 d1 f+ |, c5 C; f18
19
20
21
: }4 w3 ]! i) @. g* \22
0 V1 P' Y9 W" y3 E7 f# Y; y+ O23
& C& X  c5 b# h7 Q3 v$ t24
25
26
. z! X8 J# s- W8 r27
28
29
30
31
5 p- X3 Q3 Y7 x5 E& Y32
计数排序
简单解释：
) ]# e+ _7 f: W3 I/ u- {这个排序算法看名字也很好理解，就是就是额外找个数组来计数，然后在这个数组从小到大或从大到小把数取出来即可。
6 O, V: n* L1 Y5 K8 X
; `: l  A" b7 P& T" n2 {; ^7 u

% F+ c" M, J6 B2 _3 m9 a: Q
4 Y) d% H2 r# H9 r' d# i4 D

$ |  \! M2 C5 B! T: P完整代码：


5 P' _( j: L; y+ m2 _package com.keafmd.Sequence;

! }& c& U' ~5 ?  @, l6 U- B
2 k# C" ?. U: ^* H4 E  V/**
* Keafmd
*
* @ClassName: CountSort
* @Description: 计数排序
* @author: 牛哄哄的柯南
* @date: 2021-06-24 11:31
* v% P# D1 d! v7 F3 v' Y0 f2 b */
public class CountSort {

- }( L" D" Z, c8 H
    public static void countSort(int[]arr){
        countSort(arr,true);
    }


    public static void countSort(int[]arr,boolean ascending){
) m8 O0 S$ T1 j5 w& \        int d,min=arr[0],max=arr[0];

( H- m7 Q; f2 G9 G, y( O
        //找出最大、最小值
0 n4 f/ w# {' z8 |: c' S+ x- H        for(int i=0;i< arr.length;i++){
* L# ]2 \, x( b( K: t9 a            if(arr<min){
                min =arr;
            }
! u' d% l3 p+ x" F2 Y" ^7 d            if(arr>max){
! R4 e; W- y7 i0 c' z                max = arr;
            }
# H( @, @0 l- ?% `# k0 p        }
& U) T( E/ H8 `' ]1 v
0 I1 W' L4 R; t' E
        //建立一个用于计数的数组
& ^' G- g" P  F6 ^6 L        d = min;
        int[] count_map = new int[max-min+1];
  G' a5 d+ _0 Z' Z% a7 s# I        for(int i=0;i< arr.length;i++){
            count_map[arr-d]++;
        }
3 ~4 y; Q: c/ f4 P% Y7 I
/ V7 e. l9 W8 y6 o
        int k =0;
! n" N9 ?! j1 c        if(ascending){
            for(int i=0;i< arr.length;){
9 f8 \' h9 J- b+ M8 ]7 O                if(count_map[k]>0){
, N7 d' \0 C# M, U  V                    arr = k+d;
                    i++;
3 X. ^  c% H: E$ I* V1 ~                    count_map[k]--;
                }else
2 f) C  Q9 R8 I% N; q2 _6 d                    k++;
8 K1 g+ n) r3 @2 D5 g            }
' t9 A. q, _2 \5 `, V1 h, V        }else {
/ P4 c, \5 }$ G& a/ ?5 W            for(int i=arr.length-1;i>=0;){
) H* f0 b' E/ m9 ^6 F. j, [                if(count_map[k]>0){
, H: {8 R* [0 l  M2 X& W                    arr = k+d;
$ |- {6 T$ o& w0 q/ M; V                    i--;
2 Q. q" x4 l8 ^+ \                    count_map[k]--;
8 @/ A! a# k8 }- w& m& z                }else
: \0 n) }8 R# J' b6 D6 j; w% [                    k++;
% q9 W, `6 k; _! q* y8 j            }
; s* e( u; U+ U0 S4 g        }

6 q. U% K, V4 T2 Y0 k
. V7 P: K4 p3 k" \  l    }
}
1
& l+ W6 j+ m/ l% [2
3
4
; B8 Y  r# z; R5
6
" k" o$ O' s. C9 S, K+ ^' f7
1 c+ C4 L+ I9 m- P! p5 L1 g9 X8
- T" B' W5 X0 q( B9
$ D, n: |8 r) R# t/ U* d10
: ?& O" S/ v+ {0 t; `5 P11
12
13
' i* w6 B; _, g' _* e6 K. b# [14
! V& ~' v% K7 a( \# S- Z15
16
2 o( `; F& g5 ]4 p% |17
18
# v$ k; f' `  _9 |19
20
21
22
+ [/ s. Q: E1 s/ W) O: H2 H23
" j4 b! G- I0 X24
2 C: N1 `" V! J9 b25
26
& l+ ~) J1 i  e; B- h27
) f5 K  g) {& h* h. f. R28
29
30
6 f6 H0 T) d; C4 b8 {1 X* u/ _31
32
6 c9 J* c* J# I33
, l6 L" P7 o; M" _/ W34
' r0 Y6 g, P! n3 G7 J; n7 M. D4 q35
36
2 M# V3 ^4 `+ j" v0 N6 D! u37
38
39
40
8 {$ X- v0 o" D7 I41
42
9 ]$ x9 ^* C: m4 B8 n- ~  @43
44
% C7 s' u) E4 \" Z7 F5 Z: |45
46
  D( O0 S) M" l- e7 q# l47
. Z2 M/ \! g( i$ P+ ^# m48
2 m  w' ^% T8 X4 ~( v, W6 m; c49
50
% n" v: ^& g/ m6 I3 Y7 \  n# W51
6 x8 L- C$ O( T& W5 `4 Y  L7 D' H52
53
54
55
$ L/ b& F+ h. l. [$ @+ f56
57
( c' w2 v5 W5 W9 r58
2 H+ D% G3 Z; h6 H( o59
4 P; \$ n" F/ @3 _! ?; i7 m桶排序
简单解释：
就是把一个数组分成几个桶（其实是几个区间，从小到大或从大到小的几个区间）装，然后让每个桶（区间）有序，然后取出来放一起就可以了，相当于把几个有序的段拿出来放一起，自然还是有序的，当然需要是按照区间的顺序拿了。


- l' P6 C7 b: l4 \
1 v! p/ e+ o' w# B% z- |; t2 n% B0 [$ O


完整代码：


" D- F/ O! ?* V1 e' D- N9 apackage com.keafmd.Sequence;

* M& c4 S' Y- U4 f8 l& `
& E6 {9 F( F$ I  s8 w& Uimport java.util.ArrayList;
import java.util.Collections;

' n$ l  |+ i- S- E+ C! q
/**
% o+ M, L7 j3 u" ~2 ~- ^; o4 ? * Keafmd
*
* @ClassName: BucketSort
* @Description: 桶排序
* @author: 牛哄哄的柯南
, N: Z6 t$ V. l$ p8 r- M * @date: 2021-06-24 13:32
- p& W& d! m0 c( z */
public class BucketSort {
4 G9 v6 I* |0 n/ ~
2 @  r% b3 J4 j/ v: T! t* X
    public static void bucketSort(int[] arr){
        bucketSort(arr,true);
    }
; h/ Y; g0 Z8 e% b: K

    public static void bucketSort(int[] arr,boolean ascending){
        if(arr==null||arr.length==0){
" A- p+ C/ d4 E* d+ B- H$ _4 K, ^3 N# s            return;
7 {2 s  P+ V9 Y8 g        }
        //计算最大值与最小值
        int max = Integer.MIN_VALUE;
0 V& z. w. F4 |  }4 ~  w2 e* f0 H+ d        int min = Integer.MAX_VALUE;
        for(int i=0;i<arr.length;i++){
1 J5 `( ?$ r9 W6 U6 _  }            max = Math.max(arr,max);
            min = Math.min(arr,min);
4 J6 L; ~( e) l; o/ B9 F. d        }
/ o5 K0 |$ s, V+ e) Y5 |+ k4 {

        //计算桶的数量
# ?* g" @9 j, l4 G        int bucketNUm = (max-min)/ arr.length+1;
. ~1 U8 u+ P  H% g) k        ArrayList<ArrayList<Integer>> bucketArr = new ArrayList<>(bucketNUm);
8 k  A, I) I/ M; Z, [* Y        for(int i=0;i<bucketNUm;i++){
            bucketArr.add(new ArrayList<>());
9 {9 a) z. d$ q& U# c        }


- B) O1 O, B5 n: o' \1 x        //将每个元素放入桶中
; J; g5 A4 n( C7 _2 z* u        for(int i=0;i<arr.length;i++){
4 Z7 Y4 [/ j4 |( x6 H            int num = (arr-min)/ (arr.length);
9 k7 Y* w7 _3 U6 C" V# I6 D! G            bucketArr.get(num).add(arr);
        }
+ @4 z9 H( i/ V0 g4 _$ d3 p
; D) N9 l  o. h3 K- E- _
# a' f$ y7 F5 J3 I) _# a& _        //对每个桶进行排序
# ?8 c; Z5 I. p: b  Z        for (int i = 0; i < bucketArr.size(); i++) {
            //用系统的排序，速度肯定没话说
9 h2 X1 I# F/ Q7 R+ F: {2 ^            Collections.sort(bucketArr.get(i));
% A+ N3 S1 Y7 E8 A2 M; V  v* @        }

4 v7 C/ D3 Q* E2 [8 R
        //将桶中元素赋值到原序列
7 b- ?( F, [+ u! [% g5 I- s* ?! V        int index;
        if(ascending){
            index=0;
8 c- q* u% X  t7 n; Z        }else{
0 [7 N3 b/ v: w# I+ X; P. R2 o            index=arr.length-1;
) V# i4 f% t7 a* w% T2 s, y        }
8 [. r. ?6 P' f3 @0 b1 [) Z# s

        for(int i=0;i<bucketArr.size();i++){
# @6 I: U* \" a: I: R            for(int j= 0;j<bucketArr.get(i).size();j++){
                arr[index] = bucketArr.get(i).get(j);
# y, {" X" |7 D5 x                if(ascending){
1 d8 _! @- P# s+ [                    index++;
& V: I0 T* m4 z& j; h                }else{
                    index--;
                }
% W7 G4 X% P0 z% J/ q' p            }
1 E- g. G( c% Z) G# T, q

        }

6 G  }4 @; c: z) ]! @3 o
    }
' |3 v6 J# j4 c+ Z6 M0 d$ C6 G- X}
1
% l, q) A9 u' V! c! ^2
3
4
5
6
6 N: U0 {  Y0 _5 d, \1 a7
8
9
10
11
8 k& X, A. R5 W# r3 p- ?12
" r/ {* z& E$ B! s, }  k! D7 Q13
( e* n" K) F5 P, ?% R, b' W6 c14
15
  o" S4 S- R6 l1 j16
17
18
# \1 |1 @! _+ n2 F19
20
21
22
23
, b% y0 T1 O* ~. p' y& |! d24
) L3 L6 n0 _0 W+ S& c3 u25
26
27
) ?- W6 Q- X7 l/ r9 \28
9 p* P2 `9 R  x3 O  Y0 w3 }29
$ u( d3 X; Q  F0 s) C4 n, L% {30
31
32
33
0 s* I; \4 h" \! q/ \& h34
35
7 d: C5 ?# m$ {6 }) A36
37
38
39
$ {3 z# G$ p. ^7 {; E0 @40
41
! S1 f9 s! o2 p9 i42
43
, r3 |  }7 |& Q) ^$ L- b44
45
3 P: {$ n% J% N4 N5 R" C( t46
5 _8 V/ s! J+ f# [47
48
. u; k0 _* A% X$ f# U/ v49
' J- P0 u/ s3 P0 a4 T3 t50
+ u: G/ Y- U9 E2 G3 x. i51
6 J+ D+ a5 X( \- H6 j1 G0 K52
! A0 }0 j% t; Z# w53
54
* r/ W5 B4 q) V' ^0 t  x55
3 {. p; @: O& q- \) A! ^9 D) z: _- ]56
57
, I1 x% Y: \! I2 }4 t2 ]58
59
60
61
* g" |& Y5 L& G7 t) `, f0 n' k/ \62
63
5 [  |- e- U  t7 |: l& j64
) q8 b. B6 q! ~* ]65
66
; X/ X& _1 b% ^6 x7 f67
68
69
70
, ]9 E* z8 L; j. k9 ?% _( @9 w71
72
" A: [9 Q% X7 j1 y( r  P* X基数排序
简单解释：
首先说一下，我发现好多人写的基数排序只能排序正整数，其实只要处理下就可以排序含有负数的了，就是我们排序前先把所有的数整体变大（就是减上最小的负数，也就是加了），都变成正数，然后排序好之后，在减下来（加上最小的负数，也就减了）就好了。
基数排序就是按数位排序可分为LSD（从最低位[也就是个位]开始排序）和MSD（从最高位开始排序），下面写的事LSD基数排序。
9 b8 K/ k1 ^0 G+ I& T3 f基数排序就是把数按位考虑，让后我们一位数只能是[0，9]，就是我们在考虑某位（个位、百位· · ·）的时候就只看这个位的数，放到在[0，9]相应的位置，然后顺序取出，最后再按其它位这样操作（上面说了要不从低位开始到高位，要不就是从高位到低位）

# Y( M6 ~4 R2 D' w( f/ P9 p




完整代码：
, A8 U5 f- H7 @! ]: h
8 r& b& O7 O1 v4 B$ u$ W' V! q
package com.keafmd.Sequence;
1 x  l! {8 }6 [0 i$ O
, {* ]: k7 d- y! Y) G0 q
/**
* Keafmd
*
* @ClassName: RadixSort
* V5 j  U0 E' ~5 F) f) Q * @Description: 基数排序
' T9 c  E8 w$ J" |5 ] * @author: 牛哄哄的柯南
2 ~9 Y' C9 T" u1 C2 X * @date: 2021-06-24 14:32
*/
public class RadixSort {
    public static void radixSort(int[] arr){
        radixSort(arr,true);
    }
$ }1 ?, I3 ?" Y' I% A    public static void radixSort(int[]arr,boolean ascending){
- x* w4 G* C! I8 ^- R4 O        int max = Integer.MIN_VALUE;
        int min = Integer.MAX_VALUE;
        //求出最大值、最小值
& b' L, I7 g: c& \  w        for (int i = 0; i < arr.length; i++) {
+ t  M# E+ Z6 T; E            max = Math.max(max, arr);
- ]6 P4 F. K0 V) J7 o( `0 i8 X            min = Math.min(min, arr);
        }
        if (min<0) {        //如果最小值小于0，那么把每个数都减去最小值，这样可以保证最小的数是0
            for (int i = 0; i < arr.length; i++) {
: D( l% d3 T. J; e                arr -= min;
            }
            max -= min; //max也要处理！
; H9 L9 r* i8 \8 f& `( X* Z$ L0 V. e        }
        //很巧妙求出最大的数有多少位
        int maxLength = (max+"").length();
        int[][] bucket = new int[10][arr.length]; //一个二维数组，一维代表0到9，二维存放符合数
# I8 P3 Q( P+ m/ U- N) Y        int[] bucketElementCount = new int[10]; // 用于记录0到9某位存在数字的个数
        for (int i = 0 ,n = 1 ; i < maxLength ; i++,n*=10) { //个位 十位 百位 这样遍历
0 G4 m4 K4 v# {$ S7 g+ ^% ?8 o4 r& N5 z            for (int j = 0; j < arr.length ; j++) {
4 j& k; P# `& u! V' y                int value = arr[j]/n % 10;
                bucket[value][bucketElementCount[value]] = arr[j];
                bucketElementCount[value]++;
' p7 q% d8 f$ L! U$ q# @  v            }
5 N/ f4 x8 m+ f" A% X: E6 j. g

/ E5 ~0 G# b  m0 `/ W            //升序
            if(ascending) {
, L2 D2 e4 g% M2 |7 G( ]                int index = 0;
                //从左到右，从下到上取出每个数
1 A; t) f3 ?9 `) e3 k; a                for (int j = 0; j < bucketElementCount.length; j++) {
                    if (bucketElementCount[j] != 0) {
                        for (int k = 0; k < bucketElementCount[j]; k++) {
( N2 D$ j  Q4 l! K& y* O, ?* A                            arr[index] = bucket[j][k];
6 m8 b0 e+ w% f% J                            index++;
                        }
% Z  c% u1 H. W+ [0 @                    }
                    bucketElementCount[j] = 0;
* A* P' M7 N# D' c7 A                }
            }else { // 降序
; N8 I- ^9 I! L9 A                int index=0;
: G+ l" Y% p' C4 u; n$ N" n                //从右到左，从下到上取出每个数
) U3 I! T4 G+ E1 g: |                for (int j = bucketElementCount.length-1; j >=0; j--) {
                    if (bucketElementCount[j] != 0) {
- x' G' o. N. |* A% D                        for (int k = 0; k <bucketElementCount[j]; k++) {
9 `' q7 h  r/ U                            arr[index] = bucket[j][k];
" e8 T" J! D0 D( P' `                            index++;
* u' ^  D+ C% o6 V" R                        }
                    }
) v+ _% q6 H0 L0 X: v& o                    bucketElementCount[j] = 0;
0 I5 B& Y* R- X( j( |* u! {- Z                }
7 R) S, B- q/ r) P            }

) i& N7 M7 j% i3 Z9 u


            /*for (int i1 = 0; i1 < arr.length; i1++) {
: E( ?. m5 m2 g' @3 s8 n0 s                System.out.print(arr[i1]+" ");
            }
            System.out.println();*/
: T# ]6 W4 A# Q+ x" D& T6 p/ p1 B


  q! p% C3 W3 M


6 m% E; x* H: i% G        }
5 E2 j: E* c, n$ R        if (min<0){
; I" W3 ~( l- x7 _' I            for (int i = 0; i < arr.length ; i++) {
! E2 ^+ }* n& c2 U" O7 y% Z                arr += min;
            }
        }


    }
- x& A' b$ [8 m* F}
9 ~0 k( x' }% C+ [9 w; i, Q& S1
2
! S+ I: M5 P2 a0 g3
4
9 m" {8 s( b# W% G5
! Q4 T# V/ k5 s5 F4 C/ k, f* v6
- n; N7 |7 ~" B% U3 e7
; q( V1 b1 I& {1 q8
& v# `$ S9 ?7 z# K: ^; S9
+ {3 M. l0 o3 h6 Y/ I( ?& m10
7 o9 _/ f# {0 d! \. v" _11
4 N4 ?  b( r* Z: J5 {12
13
0 L- H% ^9 @5 V$ [% w7 W5 A14
15
/ w3 n7 T) U% T16
" E# ?0 r! L# ~/ @" m3 @. X17
( j1 w/ i7 u: l18
19
) Y* F9 u; S  G4 _; c5 d20
9 }/ k$ s/ O: r1 N, [( l8 L. ]; `21
6 o) b6 r; Y, z2 b2 y( W. P6 G22
6 A7 a' k$ b% J& g' d23
24
8 r# u2 y2 L) ]/ A. `: |3 t25
+ U: l# Z1 o; y. {26
$ A; j6 ^/ N; K9 F0 V5 J+ r5 C27
28
29
30
31
1 y8 x* y# v% |& U0 X+ K( F* i32
. H4 a" v; X# n: c+ T/ F2 |33
34
, _3 l) b% i* L35
36
37
38
8 `# V0 G# B4 T; d, i1 H# M5 ?39
40
41
42
43
44
45
46
' c- \0 }! Q" u6 u" S: r' I9 e47
48
6 ]- T; P/ A9 t, y+ e2 D# g' v0 K49
! _4 B0 G$ g, z1 E! b( p50
51
1 X8 g# ^. n/ F52
53
54
55
; h# {1 e! a4 E3 B1 J56
57
: s/ \4 L, ]- B: d58
2 J. i7 J4 N7 Y3 @59
60
& _* }  D' Q! l$ [6 ]( s61
62
) w4 d) Z; o+ ]63
* o# Z0 @+ D, b, \. U  B2 f64
65
! B6 R* k( w' D/ L66
67
* L/ [/ m' L; ]6 {68
# j: R0 @4 x/ Z69
70
71
1 O' L: o* r) X' q8 W6 g72
73
74
75
76
77
78
& Y! ~% Z7 F' [3 w+ u79
( J" K- |8 ~) `80
: a4 R1 E! Z5 T81
82
83
1 @/ E% L: k. g/ y2 r完整测试类
1 K/ J$ M4 V9 f# p4 x7 K; `package com.keafmd.Sequence;
* B6 G! k! X; u) A: I
( s8 A3 U$ U9 P! K0 d4 f
import java.util.*;
import java.util.stream.IntStream;
import java.util.stream.Stream;
/ \0 u- C' C0 A9 N: [# _  h
5 Y+ [7 j5 j. E
, t- G6 q* G# M3 ^3 q/**
: w0 L1 z1 Q9 b+ Q; Q0 c3 g4 v5 A * Keafmd
* e: [: R% K2 n# S2 R% w( U *
* @ClassName: Sort
* @Description: 十大排序算法测试类
* @author: 牛哄哄的柯南
( @' R/ o% }$ Q* q. K) E, j * @date: 2021-06-16 21:27
/ y6 y7 m. m! T8 m */
1 a+ n, i! c7 T9 ^, Mpublic class Sort {
! U/ g+ i+ b9 q8 E$ I; z
3 u+ C# l5 X/ u6 S0 a( V

8 T! C/ A% q. u( b: s9 g
    public static void main(String[] args) {
, \! m- W: \0 V3 D

        int[] nums = {12, 4, 25, 47, 58, 34, 25, 9, 99, 26, 1, -13, 162, 10093, -66, -1};
5 \! ?& {& @. B//        int[] nums = {12, 43,56,42,26,11};
        int[] temparr;


5 C- N0 Y$ N$ B6 j6 ?1 u+ E$ u        //利用系统Collections.sort方法进行对比

; S6 @  e: s, [4 C: Z
- o9 p# j4 ^) I. A, n6 S* b        //将int数组转换为Integer数组
        //1、先将int数组转换为数值流
: V2 q% j: |3 s/ {/ x6 h        temparr = nums.clone();
        IntStream stream = Arrays.stream(temparr);
5 U0 X' [6 P; M9 ?' k. H5 \, k        //2、流中的元素全部装箱，转换为流 ---->int转为Integer
        Stream<Integer> integerStream = stream.boxed();
: D: _8 K. W; G; ^9 |3 E        //3、将流转换为数组
        Integer[] integers = integerStream.toArray(Integer[]::new);
! n) e" ]& S1 q' u: |0 V        //把数组转为List
6 r4 j/ S$ b5 d$ s) s: B( T( F        List<Integer> tempList = new ArrayList<>(Arrays.asList(integers));
        //使用Collections.sort()排序
* Z- j+ v) ~2 e3 \) ], `        System.out.println("使用系统的Collections.sort()的对比:");

2 h+ u9 v' ~+ R  O5 S" g
        //Collections.sort
        Collections.sort(tempList, new Comparator<Integer>() {
            @Override
: k+ W" U% A7 p6 ]- [& f, m4 ]            public int compare(Integer o1, Integer o2) {
                return o1-o2;
6 i$ s2 i* a9 {                //return o2-o1;
, e+ c# @2 B% v: q; ~1 }            }
# G' J4 w/ r+ d        });


        //tempList.sort 也可以排序
( b4 v$ Y" {; V/ w       /* tempList.sort(new Comparator<Integer>() {
+ C4 P  T& v/ a- G6 `3 d            @Override
            public int compare(Integer o1, Integer o2) {
                //return o1-o2;
" U5 j0 v: c6 T' Y& e% N                return o2-o1;
5 H: {9 C6 Q$ s- R8 m            }
        });*/

5 X. n# s9 ?8 g/ G0 {" Y: x
        //遍历输出结果
$ H' b: g  x* F( U        for (Integer integer : tempList) {
            System.out.print(integer+" ");
        }


        System.out.println();

* x! C5 Q" u2 C$ I7 ]) T* U! q
# W) Y: B. k9 S% g+ p        //测试冒泡排序
        System.out.println("测试冒泡排序:");
        temparr = nums.clone();
1 z) ~  h; R7 }5 ?1 s0 ?5 w

        BubbleSort.bubbleSort(temparr);


: b* S3 s) b1 R: ?% e, {& G' z- [1 o0 M        //降序
! v4 W) V( r; n1 P; S* M; p        //BubbleSort.bubbleSort(temparr,false);


        for (int i = 0; i < temparr.length; i++) {
' s/ g6 K2 C+ ?& ]# i  p  [' y            System.out.print(temparr + " ");
+ Q$ k. o: t3 _* A+ t2 R4 Y4 B- D. A        }
        System.out.println();
7 o: I4 e; V0 u' l. W/ Z3 @

% Z/ M4 d! Y, w8 N2 P3 e        //测试快速排序
        System.out.println("测试快速排序:");
        temparr = nums.clone();
+ P  n7 P: }# j5 ~        QuickSort.quickSort(temparr);
' s5 @- Q) N6 o$ s        //QuickSort.quickSort(temparr,false);
        for (int i = 0; i < temparr.length; i++) {
3 [& r7 d3 S5 K! G            System.out.print(temparr + " ");
  T6 ?2 Y' S* v0 L+ x5 p        }
        System.out.println();
5 r; h( X  J4 c" v" o$ h7 W: `( j9 d6 h

        //测试直接选择排序
        System.out.println("测试直接选择排序:");
        temparr = nums.clone();
" Z& z* i$ e6 s0 ]        SelectSort.selectSort(temparr);
        //SelectSort.selectSort(temparr,false);
( n9 @, Y0 y9 U. ]2 A7 O7 s        for (int i = 0; i < temparr.length; i++) {
            System.out.print(temparr + " ");
        }
        System.out.println();
% S! d. R5 Y1 q
) M0 t) e" }4 N0 p
2 o- h* T+ g5 ]0 k        //测试堆排序
7 j4 f& _0 i& i, H7 d8 U+ {        System.out.println("测试堆排序:");
2 O$ L8 ?$ o0 y+ V        temparr = nums.clone();
: n# ]6 F' ^  @& w# c7 P+ e! W        HeapSort.heapSort(temparr);
        //HeapSort.heapSort(temparr,false);
, c, k. f7 g+ h3 f% Q/ L        for (int i = 0; i < temparr.length; i++) {
! J( g! A- h) _. C5 ?+ r            System.out.print(temparr + " ");
        }
# ?$ B% j& h; p0 n        System.out.println();
3 r, R& D4 C$ H( N) r* ]

        //测试归并排序
        System.out.println("测试归并排序:");
        temparr = nums.clone();
        MergeSort.mergeSort(temparr);
        //MergeSort.mergeSort(temparr,false);
        for (int i = 0; i < temparr.length; i++) {
9 \1 E" ^; s" ~) q8 o3 f8 g            System.out.print(temparr + " ");
* b2 Y0 i! q, w* A4 i- [        }
        System.out.println();


' r0 s4 v( p/ a1 ]# m        //测试插入排序
        System.out.println("测试插入排序:");
1 q0 H5 y2 M  \! G+ |        temparr = nums.clone();
        StraghtInsertSort.straghtInsertSort(temparr);
0 K0 z) M5 X% e( w. I! ?  h. \/ f1 y+ ?        //StraghtInsertSort.straghtInsertSort(temparr,false);
        for (int i = 0; i < temparr.length; i++) {
5 j( Y/ F: }5 a/ o/ [            System.out.print(temparr + " ");
5 h" h0 N* D% _6 p) |( U        }
        System.out.println();


& C3 b# W6 `! \; A: R
4 k3 _+ f1 G: a! b2 l
! ~& x/ l* V- c( S+ A- y* X0 L        //测试希尔排序
        System.out.println("测试希尔排序:");
3 t  s8 O, H: E, k        temparr = nums.clone();
        ShellSort.shellSort(temparr);
        //ShellSort.shellSort(temparr,false);
3 s: S8 u; `5 `; S6 j  G, D        for (int i = 0; i < temparr.length; i++) {
5 k" }# o) f) z9 [% @$ @            System.out.print(temparr + " ");
        }
        System.out.println();
& v* y2 M- l0 o
: V7 F# N4 O4 b- L! h, ~7 S( q

7 ^, X; ~( T) f6 h, H. C* X
        //测试计数排序
. h2 K0 ]) i8 f2 K3 {1 v        System.out.println("测试计数排序:");
+ t  W, e0 V/ I" y  ]2 \( z9 {        temparr = nums.clone();
7 }" ~* s1 _; f( Q        CountSort.countSort(temparr);
        //CountSort.countSort(temparr,false);
3 r3 s/ n' x, o) y# P        for (int i = 0; i < temparr.length; i++) {
$ \. P- p& V6 g) _6 w; Q% e            System.out.print(temparr + " ");
        }
$ U; S! i$ l- M1 E0 P1 d        System.out.println();

, h: X. D, S5 Z, }% V9 g  m


        //测试桶排序
, o# T8 y5 {" l& Q        System.out.println("测试桶排序:");
- A* s& _2 Y% t% @9 y        temparr = nums.clone();
        BucketSort.bucketSort(temparr);
4 g- X+ p; K% h$ E& b        //BucketSort.bucketSort(temparr,false);
        for (int i = 0; i < temparr.length; i++) {
2 n9 \0 |. B" E- w            System.out.print(temparr + " ");
: C: [- J/ T/ j+ l$ b7 D* ]        }
# F/ T+ k7 X; N1 S9 Z3 A        System.out.println();


+ A2 w' N; F# |: [        //测试基数排序
) L' W  ]4 h( s        System.out.println("测试基数排序:");
        temparr = nums.clone();
) l* b/ `7 ~7 R0 |$ y/ H' K3 E        RadixSort.radixSort(temparr);
        //RadixSort.radixSort(temparr,false);
        for (int i = 0; i < temparr.length; i++) {
            System.out.print(temparr + " ");
        }
        System.out.println();

- F- x, G, A+ W/ p. a+ V
    }

1 m) k6 l. O, q) A
}
1
2
+ K$ s' h7 k3 `8 P. Y) u- ?( q3
) r) K4 }+ f  K- S, Y4
5
0 s# @" k. \; n$ r0 G6
7
8
4 E6 N3 b. m( |7 y' ]# E9
8 a0 t3 O: y9 @8 N10
11
0 H# x( A/ Q* _12
13
14
% W$ I8 K" `" S- S  C' O4 L. X# [- ^7 }15
16
0 |0 E1 n9 L: d* N2 C17
! k1 }7 k) M7 f# m' f18
19
! U) U& `  f8 W20
1 `- L2 M- b% h6 y4 @/ U' b0 r21
# A/ g/ P5 A6 i- w4 \1 N6 _22
1 G# I. r# Y" s) h) J. L3 v1 T) ^8 d7 s1 D23
24
25
/ y1 S* ]: |3 f- N0 B2 Q26
5 C: C% W2 B. B) ]1 G8 \27
& H$ O3 f3 [9 ]6 `28
2 L/ L* l: W" H# F7 l6 j29
30
31
32
33
34
6 g7 J$ y! j3 h+ ~  k& E& h/ F35
' k: x; o6 e/ V1 \7 J- x36
8 s7 M, N" y$ y1 B37
38
39
40
41
+ k7 D/ q) B: w$ P! k5 X1 `42
43
4 G0 U! Z& X* N' }44
45
" m2 e2 j+ |& I) M' _4 i9 F46
/ `8 U9 u- a) C' K. \47
48
49
50
51
52
6 X8 t) T& ^5 i; x7 A+ s53
54
, v3 w2 U( z5 ~8 a; M& s' V& [55
56
4 F8 W( _: y' m$ C: i( P6 z57
58
59
9 z# }5 y( ]7 E0 g; T60
7 w; A3 T: o5 j* c- C61
1 ^6 w# L& J( x% d2 s# y3 C62
63
6 @5 l$ I$ h3 X8 w7 |8 q64
65
5 f/ ^) H  ?- R8 x" @# G0 ?66
67
6 v* G2 N* l4 q- Z% w+ z* T' g68
# v8 W6 i$ r% S. q1 e  ~69
2 ~* c) d/ u; X. R  q70
71
4 B6 W  c$ T4 J* U- p. Q& n- U72
73
74
75
76
77
78
4 I. n# i; H% ?% B  Y79
5 k% B6 z3 R, N# e/ t- |80
$ m( Q$ `0 t5 ~6 ^9 l81
9 |8 J# p3 Q  J% _) w* K& m82
83
4 [  U' ~2 ]" A0 C& G4 |/ b; X84
2 t* N% F) }( C6 @85
86
$ Q6 {7 ~9 ^( K87
88
89
90
, W  s# F9 ]# y. P91
+ L% X5 k; Y3 O* J" N( M/ ]92
93
$ e) @5 L8 k& s1 t' ~5 o2 F1 H! _( `94
: B: b% j# u* E# ^9 F/ s95
96
3 o) g, m7 L( u7 J, H97
) o% Z3 V5 i2 k) Q98
99
100
101
102
+ O, Q6 t  ~# N) b1 G- d5 p+ N2 @103
104
4 a9 l, w4 G! Q! |* i$ h, P105
106
8 K3 v% j) }4 d+ w6 `& E+ y( P0 l. {107
108
( m/ t% c: I' e3 j) u6 N+ `109
: o$ q2 A( A8 o) H110
2 X! f! ~* O: V5 {( O111
2 w7 k& f3 c, k112
& m' ]  c4 s6 S: W) X113
114
115
116
117
118
) f: ?9 }) {9 W5 ~/ f; f4 I119
120
, D3 m: d7 |0 ?121
122
6 ?5 F2 ]* c2 B3 N. J* V/ P123
124
125
6 Z: o& A$ B- z6 l0 }- g126
127
128
1 u/ c% H0 \$ i6 S7 z4 S129
130
% C* D. J! D" C131
3 Z8 H! L7 D! P1 \* L132
3 G) G, n" E/ S) q7 D+ ]! U- K* Z( {133
3 ~. C6 N1 q; p, z" Q134
3 }1 D1 n. [- D; l135
136
6 T- _* r$ [, y* [' g2 J2 m137
( N- ~4 X6 H: t* }1 S8 v( m& O138
* W  o: ?& D+ n2 Z139
; c* ~. Z( H- R6 t/ B$ h- s140
9 y% \" z+ S* f- m0 H, h141
$ t& X( P6 C7 R! W1 u4 r  ~142
# [7 h% O, Z) u/ `5 E! g143
144
$ P( h  w. g% Q& r1 V; ^' S) `145
146
147
* J" F$ M* j3 m& ~( P6 y148
149
150
, Z! J! t) G( C' e+ b" y! a2 y; q151
152
4 ~( H) c  R2 M3 W( I& Y; `5 P153
154
155
156
157
158
" q( q; g. X; x6 `159
/ ^$ j  L8 y8 d$ M160
5 `" d" R, U; X" q: b161
  G* n8 i/ f- B' M162
5 o6 l2 f/ R7 Z4 v7 T163
; ^; E0 H9 c  Y+ a) F164
165
/ Z" t* X7 S* J166
6 z& L! x! U% X! Q167
3 g# N3 q" h4 S4 o168
169
. ~. I) [& Q! s& P' j4 q170
171
# l! [! e$ w9 E& ~; @172
" l1 D* K9 K7 t% P1 m4 ^! o  u5 N  F173
  @* y9 A2 \" \7 T* \$ L: F% Q每天进步一点点！
. J8 b5 m; ^# I  h2 ^不进则退！

1 q7 \% o0 I' @6 P, D) N
版权声明：
原创博主：牛哄哄的柯南
9 i; c/ F: z4 O# H博主原文链接：https://keafmd.blog.csdn.net/
————————————————
5 ~. G( G' R6 v9 x) p版权声明：本文为CSDN博主「牛哄哄的柯南」的原创文章，遵循CC 4.0 BY-SA版权协议，转载请附上原文出处链接及本声明。
+ a$ ^0 N! V  Q, B1 X原文链接：https://blog.csdn.net/weixin_43883917/article/details/118193663
9 A5 f& }2 C, z: q. y: |8 p
, A7 `$ f2 n) _3 G

1051373629

每天进步一点点！
, i# f- `& y! G! J, [2 k