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

杨利霞

4 j' ], M7 N1 l1 v经典十大排序算法（含升序降序，基数排序含负数排序）【Java版完整代码】【建议收藏系列】
经典十大排序算法【Java版完整代码】
写在前面的话
8 s$ h- i1 q8 ^) A十大排序算法对比
" U! A6 g5 U1 a! A冒泡排序
快速排序
, f3 g- ~7 D/ o* o直接选择排序
堆排序
归并排序
$ ^  c: |; O: \插入排序
希尔排序
5 n- n, y3 `+ S( p+ L6 Q% d; [计数排序
桶排序
) k: }! m0 Z, Y3 Q1 d基数排序
) J* Q2 O7 b, p  W' T# [# \完整测试类
写在前面的话
       虽然已经有很多人总结过这十大排序算法，优秀的文章也不少，但是Java完整版的好像不多，还存在某些文章代码存在错误的情况，同时也为了自己练手，决定把所有的写一遍巩固下，同时也真诚的希望阅读到这篇文章的小伙伴们可以自己去从头敲一遍，不要粘贴复制！希望我的文章对你有所帮助，每天进步一点点！！！
* y+ h3 {+ M  x1 C

       我用通俗的理解写下对算法的解释，对某个算法的运行过程不是很理解的话或者想看比较官方的解释的话，单独搜索某个算法，看几篇不同的解释，就可以有自己的理解了，这里我主要展示代码以及进行通俗的解释！整起来，再强调一次，一定要自己敲一遍，这样才能理解的更深刻！
  }4 U7 [- h9 B2 d1 |2 t
4 |1 V  F" C+ V
3 O' L$ C- V8 [7 m2 V+ n3 y8 R# T十大排序算法对比
/ R; `, t2 B2 ]/ g9 J) @( [' p* R0 y


$ N4 n0 V9 l, \" X2 l
关于最后一列的稳定性，我稍微解释下，例如对序列：1 2 4 2 6 排序，序列中存在两个2，如果我们把这两个2标记上（让他俩不同），排序之后，前面的2还在前面，那么就称这种排序是稳定的，反之不稳定。


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


6 y! U" p8 U0 H& }+ L% I& r: K; L


: z/ b8 F6 G/ p/ A# Y, x* \
6 H" }- o4 {" P2 _% d+ h本文的图片来源网络，仅用于大家学习，侵权联系删除！（下同）
6 k1 ~! \0 i1 k( B( Z
& b  Q0 \9 ~" R! ]2 x/ N7 W
完整代码：
+ L1 a$ }( P: m9 u0 \

- h. J( [" o; e/ [package com.keafmd.Sequence;
4 @, O' v& d9 Q0 ^

/**
: h( ~# G9 P  ~  |4 c * Keafmd
# \9 F: R- N4 d: j& I4 q1 M+ d' Z *
9 i$ I) P  N3 D. ^; ~, A/ b/ n * @ClassName: BubbleSort
8 |3 v+ i& f* {" i' n! A: B * @Description: 冒泡排序
* @author: 牛哄哄的柯南
* @date: 2021-06-24 10:31
*/
public class BubbleSort {
$ ^* D" S+ F* P, ^1 x, ]# o% E

    //冒泡排序
! J, C: _$ r) e" _6 l2 o    public static void bubbleSort(int[] arr, boolean ascending) { //exchange标志表示为升序排序还是降序排序

( R- a4 h% x/ L3 r# \" B6 G+ N
        boolean flag = true; //加一个标志位，记录上一次是否发生了交换，如果是，我们则进行下一轮，如果没有，说明已经冒泡好了


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


            /*System.out.print("第"+i+"次遍历：");
' ?8 s, n+ N+ }% F            for (int i1 : arr) {
                System.out.print(i1+" ");
            }
- b" s) m0 z/ d: w" q9 H6 p: B            System.out.println();*/
7 g3 s8 Y5 j' f$ [4 I

            flag = false; //假定未交换
5 v  V! c6 K- q1 H9 E
: y; |2 U- ^7 T& O% \4 n% @
            for (int j = 0; j < arr.length - i; j++) {

/ b8 c* q3 h. a4 K" a* E/ ]
                if (ascending ? arr[j] > arr[j + 1] : arr[j] < arr[j + 1]) { //控制升序还是降序
+ Q( r! N7 q! f                    int temp = arr[j];
                    arr[j] = arr[j + 1];
                    arr[j + 1] = temp;
                    flag = true;
                }

7 B2 [; c* ?& r8 {
% ]3 v' x3 U8 J' o, S            }
        }
    }

' m7 d. y" M" u* p
! f* n0 P  d0 z3 O  X( E/ \. Z% s    //冒泡排序 -- 默认不传参升序
8 E- l/ F) i; v0 T" Q    public static void bubbleSort(int[] arr) {
        bubbleSort(arr, true);
    }
}
1
2
3
) `$ d, a! A1 w5 j4 p) A$ |1 K0 N0 P: P, _4
5
3 R7 g0 P- C' L2 a  H6
7
8
9 @1 P: _8 \' k9
10
4 b* i* m3 ~7 ]1 @# [11
12
13
14
! Z6 K7 n8 S4 c3 Y# O, [/ v( G15
+ y  x" ]/ ^/ C5 b2 D16
7 `$ H  f1 y2 {17
18
3 e2 U' t2 I; r, D+ l8 R19
20
, V% w$ L, G3 r8 \2 K0 G21
0 o. C8 Z$ Z6 d+ j% W+ w. s+ @22
: W0 [3 T; L1 \6 r1 d1 o$ E23
- q4 s& x& X- M8 b( `: c/ _24
25
% C1 t8 A' ~& v( w  Y26
5 r+ I1 J9 E5 p27
28
29
! e, q. K9 ?" D: o8 |& W30
- n; R$ m) f( Z6 c/ \31
* N6 L0 F8 K1 c& T32
33
34
35
36
37
38
4 J' S/ Z  O3 v( w39
$ u* ]2 }# d' k2 W- }40
41
$ V; E6 @9 H! e. H7 J$ b42
43
44
- Z* J7 O. f/ Z' _45
$ R7 [& v. Z: _) |+ i8 ~- ~: s5 ], n测试代码：
* t1 N) F: |4 V# E& e1 q3 o, o' B

升序排序（从小到大）

( P- B: E/ e" \
package com.keafmd.Sequence;
# k2 J" Z: X3 e
( A8 A- F. k9 O5 C5 q  n) {
/ {( }9 r' P( Limport java.util.*;
import java.util.stream.IntStream;
import java.util.stream.Stream;

+ Q. ~; ?: B* [9 n# a3 l5 Y
/**
% I3 [9 c7 H% N! M4 }- y * Keafmd
2 q; o9 M' S+ p7 x *
* @ClassName: Sort
* @Description: 十大排序算法
, T/ {  E0 D0 J * @author: 牛哄哄的柯南
* @date: 2021-06-16 21:27
3 }- @/ {7 [/ G% B1 Z- R8 K* `( s */
' [$ I+ _9 T& ^7 M/ z( t* b7 wpublic class Sort {
    public static void main(String[] args) {
+ x9 m7 d2 m4 D! x; z  [* B
( b2 P+ }0 e8 O7 P3 F
( h% x4 W! ^7 h: R  F) J$ n        int[] nums = {12, 4, 25, 47, 58, 34, 25, 9, 99, 26, 1, -13, 162, 10093, -66, -1};
        int[] temparr;


        //测试冒泡排序
        System.out.println("测试冒泡排序:");
; @# u3 A5 U: k: J! N        temparr = nums.clone();
        BubbleSort.bubbleSort(temparr);
0 P) H% o- e  z5 f        //逆序排序
        //BubbleSort.bubbleSort(temparr,false);
- w$ p5 D5 L: Y2 ^2 g        for (int i = 0; i < temparr.length; i++) {
            System.out.print(temparr + " ");
        }
8 r3 i6 R; W- r& i* A        System.out.println();


    }
/ G+ N- x" M6 R, D; U- P* @9 z}
1
! Z( ^: O4 H' I5 [. I( j2
  G: O3 |- v' |! r* n) p! n3
4
5
6
7
8
7 s, J) b$ J) b1 t* l6 f! x9
10
11
12
13
2 L& B% Y* V* F! J# L* R" B14
15
16
! j! u' H0 [! ^2 h0 Q' y17
18
$ y% w" r4 x) n19
% H1 _- |6 L: W# w- W1 A5 j' {20
21
22
1 i: [4 W( C1 F, z$ [) w23
24
25
, @0 G' U0 X0 n$ \3 W& x- J' p% V26
27
28
* v0 E; N  Z; d2 h' c9 V29
30
# D. m# O& s6 w* L, p+ p2 g31
32
33
运行结果：
1 k- Y; ]* Y4 V5 B
  |* r$ R! Z! C+ U. [' d- u* j) _
测试冒泡排序:
+ |  u, O( n. p9 _-66 -13 -1 1 4 9 12 25 25 26 34 47 58 99 162 10093
2 T; }, M5 Q% W0 y0 K* B; s1
% p$ T/ K2 D$ x/ s2
降序排序（从大到小）
& N- A  R2 a9 {0 |4 p- H3 k: x
. o& Z9 M3 s. w9 m9 V/ u
//测试冒泡排序
System.out.println("测试冒泡排序:");
' y3 v. N  l! K: P: s$ @& N) ntemparr = nums.clone();
4 T) K5 s8 t/ g# _& V2 l6 U* TBubbleSort.bubbleSort(temparr,false);
8 F. K6 E- {3 O$ Y6 F! `0 `$ pfor (int i = 0; i < temparr.length; i++) {
+ Z$ Q0 m& H5 |0 I7 p: O: h* u    System.out.print(temparr + " ");
}
# C; m! T: t0 r/ X6 jSystem.out.println();
9 u9 V) X' m) a4 E1
2
3
4
5
. Q/ s/ b& y) W6
% t& {/ j( ~6 ]. ~7
- R' u9 U5 I+ A7 x* ~8 r8
' ]6 ~. H( X- @' q. ?6 |! j3 |运行结果：
8 O6 _7 l4 R, w3 o/ U, Y

+ B" E% v6 H1 G; `# R3 g测试冒泡排序:
. N7 f$ u  i: S2 L10093 162 99 58 47 34 26 25 25 12 9 4 1 -1 -13 -66
4 L% e) x: {! J6 r) p. y# q$ ]1
2
下面几个算法的测试也就是换了下类名和方法名（换成相应的排序算法），如果想降序就在数组后面传个false即可。我就不一一复制了，我在最下面给出含所有算法的测试类，需要的自取即可。
$ K0 x& N" X) T) x1 b
, o+ M; {/ S& c# @& }
; G  C( ]8 H  J: b( E: r! j快速排序
; u: X- j* E2 i* ~) y简单解释：
快速排序就是每次找一个基点（第一个元素），然后两个哨兵，一个从最前面往后走，一个从最后面往前面走，如果后面那个哨兵找到了一个比基点大的数停下来，前面那个哨兵找到比基点大的数停下来，然后交换两个哨兵找到的数，如果找不到最后两个哨兵就会碰到一起就结束，最后交换基点和哨兵相遇的地方的元素，然后就将一个序列分为比基点小的一部分和比基点大的一部分，然后递归左半部分和右半部分，最后的结果就是有序的了。



4 D. W% f; Y2 l& n# }
3 h/ V% I  d5 r$ m! ?0 b8 K
3 |  f* Q/ s# R" e& P
完整代码：
5 R( F& [. x0 m! E  y' Q

9 P8 t/ R/ {0 \/ n! K1 x# wpackage com.keafmd.Sequence;
: c0 Q6 {2 O( @' I/ {% }

/**
# C9 |6 t( K4 j* g5 w0 p * Keafmd
*
* @ClassName: QuickSort
  T; p: X/ k8 W * @Description: 快速排序
, W7 D9 o: f, g% T) I * @author: 牛哄哄的柯南
* @date: 2021-06-24 10:32
*/
public class QuickSort {

- h3 c% B# o$ U! W9 i1 v$ b
    //快速排序
    public static void quickSort(int[] arr) {
        quickSort(arr, true);
    }
" w5 B9 |5 M. B* f/ f0 {

& I: C8 {5 D, Z; ~" u' E+ U, o) U    public static void quickSort(int[] arr, boolean ascending) {
+ ~# h/ u* p& N" \( I  S7 R% ]        if (ascending) {
7 c4 z  h  y7 e0 A2 d3 j            quickSort(arr, 0, arr.length - 1, true);
        } else {
) C! H: _" {% b2 c/ N! F1 n            quickSort(arr, 0, arr.length - 1, false);
0 |" t1 \8 b, o, c: N; y# b1 T8 T        }
' p( v# _6 Z4 n, U    }
0 d' ]9 U5 R) P9 u" H( O

    public static void quickSort(int[] arr, int begin, int end, boolean ascending) {
+ x- {2 F' I1 h        if (ascending)
            quickSort(arr, begin, end);
" }' S& R# u4 v3 a! A2 b        else
            quickSortDescending(arr, begin, end);
; J9 f- Z* o) t# a+ `    }
& \8 E) I. O/ ^7 O2 Q

. x$ T  o3 p; u# [    //快排序升序 -- 默认
    public static void quickSort(int[] arr, int begin, int end) {
, [9 Q& |& F7 Q        if (begin > end) { //结束条件
            return;
. k, C! ?& m  G) S7 L3 ]        }
        int base = arr[begin];
        int i = begin, j = end;
        while (i < j) { // 两个哨兵（i左边，j右边）没有相遇
* t: Y6 @1 F- t& B2 Y# E) M            while (arr[j] >= base && i < j) { //哨兵j没找到比base小的
                j--;
            }
+ P8 w5 q0 P/ ^) H% m+ ~' r- s            while (arr <= base && i < j) { //哨兵i没找到比base大的
                i++;
            }
) N6 [9 v+ B& j2 H/ ~            if (i < j) { //如果满足条件则交换
5 ?" F3 s! f1 \! N6 }; x                int temp = arr;
9 q% u+ k; ?  |8 R                arr = arr[j];
$ ^5 w" R0 _) @: O# J$ A3 s                arr[j] = temp;
            }
3 v1 m  ?! T! c6 ?

        }
1 H  Q2 c$ l& b3 x        //最后将基准为与i和j相等位置的数字交换
2 G5 n6 ?% w: u  s+ C4 D* c+ z1 B5 u        arr[begin] = arr;
        arr = base;
, x6 _5 X' E& z; ?        quickSort(arr, begin, i - 1); //递归调用左半数组
4 Y( v$ E) M) b1 d- o        quickSort(arr, i + 1, end); //递归调用右半数组
% C* ]1 b$ O4 Z" v2 x

    }
4 I; ^: A4 u( g$ y

9 o( }! V) c% H, ]    //快排序降序
    public static void quickSortDescending(int[] arr, int begin, int end) {
' F% E( a* w" V0 W( M        if (begin > end) { //结束条件
, [7 L3 D& _6 @1 |' v: p7 {6 t            return;
        }
) `2 e3 B0 R4 Q& z" t& H        int base = arr[begin];
, `3 R5 b8 G* I! m. M/ J" M# S        int i = begin, j = end;
        while (i < j) { // 两个哨兵（i左边，j右边）没有相遇
            while (arr[j] <= base && i < j) { //哨兵j没找到比base大的
                j--;
+ J3 A) r) J5 y+ Q            }
            while (arr >= base && i < j) { //哨兵i没找到比base小的
                i++;
            }
& o. Y8 o6 L( S5 F            if (i < j) { //如果满足条件则交换
                int temp = arr;
0 k$ ?! g6 i+ b; x                arr = arr[j];
* V; z- U3 l$ J* }4 N% [* y                arr[j] = temp;
            }

7 O+ J# k+ F6 N" y1 \9 c0 N8 @! R( P  \
& ~; z$ K, E! v+ }7 t        }
( i, ^9 ], M+ t9 [        //最后将基准为与i和j相等位置的数字交换
( O+ ?& M# }. Z& a4 Z# h( N6 `        arr[begin] = arr;
$ A' w! v* a7 [; b        arr = base;
        quickSortDescending(arr, begin, i - 1); //递归调用左半数组
. t/ W5 D/ Y: g; z" K! w  D2 ]" R        quickSortDescending(arr, i + 1, end); //递归调用右半数组
7 h7 D+ w* e* g

    }

, x2 @: ~# X+ c, n# L  t
' Q% G; J9 O) @1 W" F}
1
, Z/ z. |* s+ @# H2
; t( z) _" n% q( s7 S3
4
4 k. j) b* a, J1 d5
6
7
8
9
10
11
# c+ i" r) t2 r+ d, X) J12
13
. D8 ^% V( o0 x, {7 k3 P, x! H14
& s7 y! ^7 K9 _. R- N/ [8 R. [15
7 w8 Y% l. p& i' v  _  t16
6 J8 b  M9 `2 o, x9 E5 j! w) o9 h17
& L' D) f9 a* }& T4 s* i7 ^8 x18
* p# s* J) c$ J) v# g$ k; r19
# Z! n9 Z3 z! q20
7 a* `9 Y0 c) X5 l" v/ `, O! P21
22
23
24
25
26
8 W' s$ D- j7 A, g4 E/ w3 u3 W27
$ K2 ]- A7 a1 Z6 J28
  }2 ]- O8 l7 |( N8 X& f# J* O; z29
6 \8 M/ X- G& S. u- T1 g30
* t" f, t$ d" a+ a- A31
32
4 }$ `, m1 v3 Y: S% ?5 b8 J: \, p33
34
4 x" z1 i! q' k) ~0 b" ?35
9 ^. Y# u3 s5 s3 n) U" ]36
! T2 \& M0 t6 |& x0 C; C37
38
& i( ?: }1 ^- b) J. X7 J39
' q8 J: J7 M0 i* z4 o4 @40
) }; y9 `- `# x41
" M1 _5 M# x% I42
9 o& n+ s) u* X* @0 Y' f43
44
45
46
' A+ e8 Y. L, H) v) e47
( u& s: m$ c1 B3 Z9 N! j48
1 a4 t/ ^+ ^  K- Y) w6 v! f9 Y% `( e& L49
50
" |+ X: P+ X: }3 w2 S" j: T51
52
, I; U% w; n+ K7 h8 K2 C* E& G6 z4 |53
54
# C8 d( L7 u: o; f; g) W55
56
- w- V" Z% x' J( n4 f: M0 v57
58
. N% Y9 d3 \6 J59
% L5 u- [9 Z2 i1 ^- A+ k60
61
62
6 U: d! _+ @: a( c63
64
65
* m* z+ X& T+ f* D. [% _66
' U4 T, H) {- @$ \  T67
68
69
70
71
72
73
2 Q+ i( `  |3 Y9 a' H74
: Y% k# K9 B/ A9 h- z75
: O0 Y! V( w6 v2 ?+ `  B76
77
+ X! U$ Y/ e# F78
79
: ]/ P6 p7 c% \; Z( m: |80
5 R- ?( N9 s6 `+ f81
82
% Y. p5 r5 d- O- L: F  b83
84
85
86
; R4 x9 ~5 E9 @  o87
: `/ s; V4 X. R0 T- v' N$ I4 o88
89
90
5 e  B- \0 S9 t6 y# M% l91
直接选择排序
. T2 G/ W% h% x& z5 F, z7 ~简单解释：
2 @7 ]) G! A$ ^' `/ r& s" W数组分为已排序部分（前面）和待排序序列（后面）
: b" u' m( e8 a$ d; b9 P8 z% d$ f$ ]0 o第一次肯定所有的数都是待排序的
从待排序的序列中找到最大或最小的那个元素，放到前面的已排序部分，然后一直找，不断缩小待排序的范围，直到所有的数都是已排序的了
9 D" A1 I% p2 v4 K  Z
/ V4 e6 V( x7 w) ^, o
) @/ n" s4 h, R



完整代码：
; n) d9 r! w- e  F/ f" l3 Q
+ C2 I5 I7 q6 }. M. c
  ^! T$ c0 H  h$ @" O7 Qpackage com.keafmd.Sequence;
- y, h* w' h4 O( b8 ]8 x

* {$ Q4 w( ~7 p- {3 E$ _$ v" a/**
* Keafmd
*
6 Z# p' c  [  O7 m3 E$ P * @ClassName: SelectSort
% U* ~4 s/ \; A * @Description: 选择排序
0 x* T2 j/ j8 @) }7 E; Q5 C+ [+ F * @author: 牛哄哄的柯南
6 _+ h7 d5 m) L" w  l3 C# N * @date: 2021-06-24 10:33
  n/ N  ~2 F9 H3 K" r& Z9 o */
public class SelectSort {
4 q" B4 C" H7 X; u8 s; Y- P+ @
' ^2 ~: D# c" E( K9 [" K
    //直接选择排序
    public static void selectSort(int[] arr, boolean ascending) {
7 D3 r# M3 B" I, f        for (int i = 0; i < arr.length; i++) {
            int m = i; //最小值或最小值的下标
            for (int j = i + 1; j < arr.length; j++) {
                if (ascending ? arr[j] < arr[m] : arr[j] > arr[m]) {
                    m = j; //找到待排序的数中最小或最大的那个数，记录下标
1 H2 B8 c1 f& m9 c. I+ c                }
3 w+ E. H2 W3 _3 _' n& e! D( P

            }
9 S8 P5 t' u  h+ v3 c6 f2 W            //交换位置
/ M: r- p! i& H  e2 c- J& p            int temp = arr;
            arr = arr[m];
& s# l. x- K4 F) h            arr[m] = temp;


' z0 P8 p) y" S! H& ~3 ]        }
    }
1 I+ ~. j' Z( }. t7 p
( ]* j# I  Y+ b5 E9 W; n6 j1 d
3 W, W  @4 q8 Q    public static void selectSort(int[] arr) {
5 o; y3 D$ e5 {9 v        selectSort(arr, true);
1 {. q2 F4 Y- e; `! e    }
}
* a* s# e3 ?$ y; x. m1
. E& k$ }. K- i3 E' _) P2
6 q# s, s& Y3 c# z7 w6 S3
4
) G0 e- R" e1 Q  q+ J. r. z5
6 g9 ~) H- E) g3 U* @" H: {! v6
7
- }/ a1 \2 A( i' h) a1 V  T8
7 N! f5 P1 e# t9
& H4 h. I3 R' y3 z- r5 T10
7 g6 _: a; A" T8 j( G9 l11
12
13
14
15
! z2 d  m3 u) s7 ^6 t- E16
17
0 z; F& s' r0 u0 w; m' G18
1 f- h, }+ J+ c( |2 G" r19
20
21
% @6 a' y9 [! y2 M3 G" Z& ~22
23
/ ~) d# Y. K6 J" c24
25
26
27
" A( Q" [. b* n& {28
29
30
; j, g6 j& x( W31
3 U. _; {7 j$ J) l: Q( R32
33
* E$ }& d: E: D5 s4 Y) I) P34
堆排序
7 d  H8 N! Z. Y  P0 U! q先理解下大顶堆和小顶堆，看图
大顶堆，双亲结点的值比每一个孩子结点的值都要大。根结点值最大
* l; L$ b2 {4 @- D* \/ G小顶堆，双亲结点的值比每一个孩子结点的值都要小。根结点值最小
5 o3 l6 `. U& X, i6 M( A" @# G
& o# Z/ B! n$ g! i) `* Z. s
2 d6 r% w' n: Y# q

简单解释：
; f0 a+ Q. U" Y) K6 j构建好大顶堆或小顶堆结构，这样最上面的就是最大值或最小值，那么我们取出堆顶元素，然后重新构建结构，一直取，一直重新构建，那么最后达到排序的效果了。



7 Z- ?! k- I+ M/ x( I4 p2 y9 |
$ p: B2 Z' ~# o: u! q; U

完整代码：
; a& h2 b- ^5 Z! l4 P+ T) I, t) ^0 i

4 [) Z6 r3 r1 Upackage com.keafmd.Sequence;

' `0 D' R# \8 W& ]+ R
/**
* Keafmd
* s" [7 O; L8 x3 r *
* @ClassName: HeapSort
" u1 A3 S& j) ]. `3 q% i * @Description: 堆排序
* @author: 牛哄哄的柯南
* @date: 2021-06-24 10:34
, }) y2 s1 x, h/ d" W( z- Z1 E */
. G3 e" ~( v6 W9 M" Zpublic class HeapSort {

3 D1 y& T  x- n1 C% i4 r8 ~
3 Z- d6 m. d* _+ K+ w  `% }9 R    //堆排序
5 ^& r; ?- T: t- f! E" |: n" J    public static void heapSort(int[] arr) {
        //对传入的数组进行建立堆，这里默认建立大顶堆，进行升序排列
0 v+ X! X; V* l2 a' A0 b4 B        heapSort(arr, true);
    }

- ~& i8 H% [. Z/ g4 Y, y
    public static void heapSort(int[] arr, boolean maxheap) {
0 [0 y# K  E0 q" U

        //1.构建大顶堆
+ o0 F/ o6 X; p        for (int i = arr.length / 2 - 1; i >= 0; i--) {
1 M7 F1 c, V8 J. r- e            //从第一个非叶子结点从下至上，从右至左调整结构
            sift(arr, i, arr.length , maxheap);
8 S( _4 g5 F* `2 Q' ?( y: h        }

6 n* v9 l% u; N3 l$ z% f" M9 y& U
3 B8 a. f8 \3 P8 n1 ?. ^0 k$ H        //2.调整堆结构+交换堆顶元素与末尾元素
" y1 i; g) H, m  p1 B5 x, [( z        for (int j = arr.length - 1; j > 0; j--) {

/ [6 C2 T" F$ {3 ]  p5 E& V& z
8 l+ z! ~3 X/ m/ y- X3 E9 C            //现在的数组第一个就是根结点，最小值所在，进行交换，把它放到最右边
            int temp = arr[j];
+ O8 |: T; R% R: Y) \            arr[j] = arr[0];
6 `: T) ]" M8 K' E            arr[0] = temp;
" ^9 M6 j( a6 T* M& B; ^
2 }6 \4 Y) H; a& S
            //重新建立堆
" R: H+ Y  u8 K1 c) K            sift(arr, 0, j , maxheap); //重新对堆进行调整
        }
  g  a, b- \. F# Z& o    }


1 j  z, K* l* j; v3 l' ~    //建立堆的方法
8 I, |/ I7 `3 h2 ?: H7 Y3 Q/ f    /**
, f& j" _% I& q. O! Z     * 私有方法，只允许被堆排序调用
     *
     * @param arr     要排序数组
     * @param parent  当前的双亲节点
     * @param len     数组长度
     * @param maxheap 是否建立大顶堆
0 t: G" m: L" e# q3 g' ~; N7 Z     */
    private static void sift(int[] arr, int parent, int len, boolean maxheap) {
  ]; E7 Z) k! A0 s5 [
' W9 f7 e/ ~) D# P) B0 d# N
$ _' E: N2 z# \) G. Q/ i9 Q, i+ p        int value = arr[parent]; //先取出当前元素i
+ ^& b( i9 L% [5 Q: V, C6 W+ ]

        for (int child = 2 * parent + 1; child < len; child = child * 2 + 1) { //从parent结点的左子结点开始，也就是2*parent+1处开始
. A3 ?4 l+ u4 u; x1 @. u$ S: A
' n6 M: Y: x& Q# l) o5 s2 m( S
. x) v1 E* y9 L# t# W            if (child+1 < len && (maxheap ? arr[child] < arr[child + 1] : arr[child] > arr[child + 1])) { //如果左子结点小于右子结点，child指向右子结点
( b4 N* U( A% v6 H5 D2 c& \                child++; //右孩子如果比左孩子大，我们就将现在的孩子换到右孩子
            }
  N# B4 |& w' |8 c( a

! o$ d. n/ W$ O            //判断是否符合大顶堆的特性， 如果右孩子大于双亲，自然左孩子也大于双亲，符合
            //如果子节点大于父节点，将子节点值赋给父节点（不用进行交换)
. V" n. a0 @' o; z, E+ N; m7 Q            if (maxheap ? value < arr[child] : value > arr[child]) {
2 ]+ ]( `$ E4 B! V4 s# h                arr[parent]=arr[child];
                parent = child;
            }
2 N; q7 e  E/ D- k            else {//如果不是，说明已经符合我们的要求了。
1 z3 v0 M# ?5 f3 s                break;
/ W# e2 K- l/ m            }
# q. U5 ]- i6 Z: P8 v( Z        }
  h% ~0 k7 C  W5 e. J        arr[parent] =value; //将value值放到最终的位置
3 v; P$ e5 t7 Q  M2 s- N



/ @) R! S0 ~# A2 o' o# L9 C    }
4 C& R4 z( X# o& j9 V* k
  |% N. H8 Z  A+ e9 j2 z0 [- _' d
}
, a- n9 l1 D, }+ Z4 y& v' z3 w1
2
3
4
2 T0 ~5 _; x  G& J( i$ u- f; |% K8 G5
3 B5 c7 M; t. g6
7
8 {/ E) v+ [9 @* |8
8 q0 f# ^# d5 W( P& K5 F9
" A3 M1 ^# d& _6 r! ^; y10
# e1 C, S- z# P: x11
12
" O4 O& ]! u* ~) i$ x13
5 R, r$ S( E- N9 M( @0 F  n$ H+ ^14
' v' {" K1 m/ v- R% R15
16
17
18
19
20
4 H& j: I! Y5 K) ~( v; @2 P21
22
/ L, J' b8 m4 n& [! L* m23
24
25
26
27
28
29
4 u+ P4 k- z! ~) s30
( f5 e. q; y9 l) m7 r31
32
/ e; q- N) E7 J/ A0 K. |3 J33
  S3 }1 m" x& V" K* L. A1 M4 M34
0 p- V' P# j, c# I+ @; \35
. r' d% f0 H! [+ h# I, S; b/ z- e36
37
7 g: V1 |- b# k" `) f5 ?0 R" L38
39
5 \$ z# r* ^4 W9 J. H40
41
42
43
44
# n0 @+ G) ~! d45
/ W" ^% H7 @( Z. U" O# l  C3 Z46
47
0 h- d4 z# k7 c$ W9 d) b, G48
49
50
51
" E% _( l! O( ]8 |52
1 ?6 R9 \' l1 o7 f53
54
55
. i% _4 i& X5 `3 s, U1 I3 e56
57
58
4 Z6 O3 J4 n  ?1 B) o59
60
' u1 x; K& m" B) l; e3 ^61
62
% g$ i4 `! d& M6 G. h# {63
64
65
66
1 N$ c3 e/ Z& r5 s% X67
68
( X4 K) d" m& g, g69
$ ?1 |7 @0 B, f( X70
71
72
73
74
  e, u# l6 D# ~3 C归并排序
简单解释：
4 z2 M5 u' m6 k4 P) ]5 d# h该算法是采用分治法，把数组不断分割，直至成为单个元素，然后比较再合并（合并的过程就是两部分分别从头开始比较，取出最小或最大元素的放到新的区域内，继续取两部分中最大或最小的元素，直到这两部分合并完，最后所有的都合并完，最后形成完整的有序序列）


: o, C  M  h# [( G( G, k8 [
* e" a# x+ Q9 e0 {
4 X& c: x! ?' w( T

完整代码：
% K) \* \% u6 E; n

8 v3 f1 b8 ]+ s9 N. y8 x) apackage com.keafmd.Sequence;
3 L& b5 A0 l/ _9 O

7 J' O2 a; I* @. P/**
( |1 O; W& }! F8 @" w! I( c * Keafmd
. e4 h8 G5 P+ G- h& T *
0 q% l* M8 T9 p7 b' Q' X * @ClassName: MergeSort
* [6 O1 h8 z, \& w1 d * @Description: 归并排序
3 W( t4 @3 |9 n; K; l$ y0 } * @author: 牛哄哄的柯南
" w$ @* U2 j* G. O8 w. j * @date: 2021-06-24 10:35
*/
public class MergeSort {
& g4 ^6 g; a% [2 W
: v$ @4 o% {$ v' c# K" W8 J
0 x7 b8 m+ }4 ^. m! R  I    //归并排序
6 M3 _6 e: `: F9 v. v    public static void mergeSort(int []arr ,boolean ascending){
        int[] temp = new int[arr.length]; //在排序前，先建好一个长度等于原数组长度的临时数组，避免递归中频繁开辟空间
9 f8 Y: a1 G8 N0 P/ A. T2 a- @        mergeSort(arr,0,arr.length-1,temp,ascending);
    }
' x% i6 I/ @3 T: w5 k    public static void mergeSort(int []arr){
9 X/ Y0 V3 ?+ a$ Y# a1 I4 \% M        mergeSort(arr,true);
9 v3 `4 P- O5 F) x: S; h+ I    }


    /**
/ k* V9 @7 W4 `: A6 F: z& t     *
. w  P0 O; U" a0 f1 a" }     * @param arr 传入的数组
/ h/ S/ d$ f( \* K# z     * @param left 当前子数组的起始下标
* R% H, Z3 a6 o8 R2 l' o     * @param right 当前子数组的结束下标
# M+ y* S) j7 t     * @param temp 拷贝暂存数组
     */
    public static void mergeSort(int []arr,int left,int right,int[] temp,boolean ascending){
        if(left<right){ //这里是递归结束的条件，我们是对半分，那当left==right的时候肯定大家都是只有一个元素了。


  u6 S/ y4 B$ _0 L            //对半分，比如总长度是10，left=0，right=9，mid=4确实是中间分了，0~4，5~9
            //当长度9，left=0，right=8，mid=4，0~4，5~8
            int mid = left + (right-left)/2; // 防止越界的写法
            //int mid = (left+right)/2;


            mergeSort(arr,left,mid,temp,ascending); //左边归并排序，使得左子序列有序
2 d- t% |: Z0 x  D( ?, P" U            mergeSort(arr,mid+1,right,temp,ascending); //右边归并排序，使得右子序列有序

, y  r: T5 V- `5 m, a' {/ m. J
( B0 ]* s8 E! S            merge(arr,left,mid,right,temp,ascending); //将两个有序子数组合并操作
        }
. @: ~% Q' k* \' q; J6 Z    }

. t1 R# B: }/ r, S
7 A4 b$ V" A+ i/ Q0 R5 k    private static void merge(int[] arr,int left,int mid,int right,int[] temp,boolean ascending){
- r+ Z' i# F6 y2 O        int i = left; //左序列起始下标
        int j = mid+1; //右序列起始下标
: {- S$ J1 H/ {/ t; u0 `6 `        int t = 0; //临时数组指针
        while(i<=mid&&j<=right){
            if(ascending?arr<arr[j]:arr>arr[j]){ //比较两个序列第一个元素谁小，谁小先拷贝谁到temp，然后对应子序列下标加1
                temp[t++] = arr[i++];
            }else {
4 [0 [4 Q7 o2 J7 J( O1 H& U                temp[t++] = arr[j++];
1 e  G3 @* v6 `/ ?            }
$ I; N# B' @* H5 _+ g        }
. {; _  x* I' [" C

# ~( a3 K5 X- r; I- Y/ G7 n        while(i<=mid){ //将左边剩余元素填充进temp中——左序列有一些数总是比右边的大的数
            temp[t++] = arr[i++];
0 V2 w. v8 @9 r2 Q! M, _        }

7 T4 P" S$ Z7 u7 j6 q% q1 @
9 f( b4 _) m3 F8 q1 \( V        while(j<=right){ //将右序列剩余元素填充进temp中——右序列有一些数总是比左边的大的数
1 [+ V6 _- H* U! }8 _0 G            temp[t++] = arr[j++];
        }
. g& L; `  i5 B) K( D* ?, S

        t = 0;
, ^" Z8 O9 q/ {* u  E9 O

        //将temp中的元素全部拷贝到原数组中
) q, D  C( H5 I0 B  o+ A+ A4 ?3 O# j        while(left<=right){
            arr[left++] = temp[t++];
        }
# u* W1 v, d! ], x
6 D+ E& c8 S) e0 m6 `; \& c! f! p
6 D, M1 t; z& Y; Y9 e    }


}
1
2
3
6 n; p9 G9 u% B! d4
: H. s% q, Q* C0 O# c" U5
6
' X$ ?7 q6 q; S& a8 g7
8
2 e4 \, L$ d" o( s9
10
11
12
- Q5 M1 t6 q5 l2 p13
14
15
16
17
18
, b+ k" z6 Z6 I( {, ]) C19
20
21
22
; X1 g- j$ |& L  M23
24
4 c" X, e$ h6 P8 [8 @, v! e# c# T4 B25
, y5 q% c7 _3 V2 J" \7 q1 b. x26
0 d$ T/ X2 G- d8 C27
# s1 i/ _& H: H; c0 ?28
) s, a$ K" A( l( n% ]/ r  }: R29
. u- }( H* Q' f/ d30
31
32
! o4 V: K5 W- H$ h33
; Y2 |2 i3 {' t0 Z34
* E. q7 j5 u$ R35
36
6 l7 v6 J( J' X37
38
% L5 a  w* a3 p39
40
41
42
43
/ D, D) s. W1 Q. s+ I+ ?44
0 y  w6 p: M  b45
46
47
  m/ D- y9 f: e# k% P$ F48
2 r3 o" F+ r5 y4 F, c0 L49
7 ]' W' @( v. O( [50
51
7 _. `7 l. ~  |; B4 u9 i+ h52
; j, S" o* N+ t4 W( s1 J8 e& S9 z/ M53
54
55
1 n" h- |$ a* s1 @# p; q$ x56
* j. Q+ E" {; y! F3 b3 Q0 \' T57
, p( S# c. H+ K5 `; @58
5 Z0 N8 u0 d6 D2 R) d59
60
61
62
2 w9 P, n2 q4 N63
6 [; x) T' T% P2 J$ n6 B) P64
65
66
67
68
69
70
- a8 ?1 n1 M! m71
& Y) S" x5 p: Q7 @2 u72
5 g' c5 b7 ]- ?" W73
8 r+ k1 U1 N( ]4 K2 i  P2 k2 q插入排序
; p& ]( ~$ z: l简单解释：
6 w+ r4 i" X9 x0 K1 l最简单的理解就是打地主时我们拿到牌后的整理过程，从第二个牌（假设我们拿起来这个牌开始比较）开始，（说下升序）从后往前比较如果比前面的那个牌小，就把牌往后移动，直到找到一个合适的位置（这个位置的前面的那个牌不比这个要放下的牌大）就把这个牌放到这个位置，慢慢的前面的部分变得有序，直至全部有序即可。
$ \- G' r+ P. E. I# \5 V


* _+ R- h- D; i! S) }) E$ H


% ~& h+ ]  G. ?; G; g; E! Y完整代码：

' t2 \9 o- B8 g6 d6 ^& U
package com.keafmd.Sequence;

& M/ F( w7 u4 x/ E
/**
* Keafmd
- q  n: Q6 V& s: t *
* @ClassName: StraghtInsertSort
* @Description: 插入排序
$ j/ J0 s; G: l9 Z * @author: 牛哄哄的柯南
5 ?2 Z) w/ G* V) Z * @date: 2021-06-24 10:36
* A  m. x9 V7 S9 ^5 ?6 ]- ` */
$ I6 p  w5 [8 u' T: @9 r$ Epublic class StraghtInsertSort {
    //插入排序
+ C& h9 i# r  G2 [2 k    public static void straghtInsertSort(int[] arr) {
        straghtInsertSort(arr, true);//默认进行升序
- \; |; U* z$ i2 ]0 l: s% N/ |    }
  G! z1 w: q  @1 u& J+ Q  P" I+ Q1 a
, {( c; A' w) ^) ^/ ^
    public static void straghtInsertSort(int[] arr, boolean ascending) {
2 ?( ?. }' Y; F5 O1 x" M6 s

5 K* _; U  Q$ W2 c$ \" v        for (int i = 1; i < arr.length; i++) {
            int temp = arr;
8 s- t/ X1 O0 x+ w# m            int j=0; //这就是那个合适的位置
5 n5 I( R" |/ t$ k- A. r% F            for (j = i - 1; j >= 0 && (ascending ? temp < arr[j] : temp > arr[j]); j--) {
                arr[j + 1] = arr[j];
9 ]/ r1 X7 X! W# D7 y) R            }
            //把牌放下，为啥是j+1，
            //是因为上面的循环遍历到不符合情况的时候 j是合适的位置的前面的那个数的位置
            //有点拗口，但是就是这个意思，看图方便理解下
  h* j' ]$ u. z% m% [3 k" X            arr[j + 1] = temp;
: C  }2 _# ~8 W, H

9 d8 q8 x- }5 i) ^8 z& {
* ]  h6 Y+ j4 }% R- k
        }

1 u3 I5 W  M3 Q- C, Q9 @
    }
}
1
7 H+ h4 Q2 W7 T7 k2 K2
3
4
% R$ \. Q- G0 W8 d" |5
4 l/ L: g6 Z, O% C+ t& q6
7
8
9
) `8 |( k( E% X8 v; L4 N2 R10
- n* N* |4 M0 i1 G# R11
12
# W/ I- a2 V& a( P5 P$ x' S; f, Q/ J13
  z4 H& ]0 T/ W  \8 W14
15
16
/ y4 n' O' p3 o0 ^( _17
18
# `, q0 j7 q6 k) U3 h19
20
. ~( h  h: I7 `3 v0 O" ^21
22
6 n, U$ G5 o& L2 H5 P( B23
" H& k4 V* U) x9 w/ p24
25
26
27
* J- R3 Y  }; r! V# n+ f- ?3 S; n28
29
3 i+ f+ @2 n* u% E" S# n! X30
31
2 U8 f: G) J* Z9 M32
33
34
希尔排序
+ ]2 |' ~' g8 G/ ?简单解释：
希尔排序是插入排序的改进版，我们理解一个叫做下标差的的东西，也就是下面那个图中的增量d，初始下标差为arr.length/2，然后继续/2，对在同一下标差（相当于把这几个数单独拿出来了）的若干个数进行插入排序即可。

; w- A& ^; j/ l& ^6 b
0 D/ e* C5 v: Z7 a; B6 u; K3 I7 `



完整代码：


package com.keafmd.Sequence;

) c# U6 J. @1 r* [5 ?
/**
% c; P# y# L3 A" x- }9 Y * Keafmd
*
* @ClassName: ShellSort
* @Description: 希尔排序
* @author: 牛哄哄的柯南
% R7 @0 [$ P# |: d  ? * @date: 2021-06-24 10:39
* b9 @' S, y$ }6 h6 v */
public class ShellSort {


    public static void shellSort(int[] arr) {
. }6 A4 U: @! h3 |" a8 q  c- v        shellSort(arr,true);
9 W( z. E# ^' \" \1 w    }
, r+ E( e' c4 c* Z2 K, F

+ O3 `5 r! y3 |    public static void shellSort(int[] arr,boolean ascending) {
" @; \4 a) G" g

        for(int d = arr.length/2;d>0;d/=2){
7 O/ G+ r# p& \7 V5 Q) P
4 y  _3 m) v" a
' T6 O8 ?+ W9 [7 D# q, T( W* }+ n            for(int i=d;i< arr.length;i++){
                int temp = arr;
3 E/ b2 ~1 y$ _5 P7 |                int j=0;
- I5 i) Z! O3 D8 ^  C% p                for(j=i-d;j>=0&&(ascending?temp<arr[j]:temp>arr[j]);j-=d){
                    arr[j+d]=arr[j];
, K4 O9 W8 z, P; z: f8 T                }
                arr[j+d] = temp;
" L2 I7 N" `# z  p+ V            }
8 a, \1 t2 B6 u, |% ?        }

: j4 G/ o! M0 w; }& i4 `
; K3 D7 O; n. x5 l, d; p    }
: V  C9 j0 V: ?- z) c7 K1 c}
1
2
3
4
6 n; t! G8 l$ M* H4 T2 a# F5
6
$ s) n) d$ L# r3 {# o" L4 [7
4 A$ P& P: M( y: `" L8
9
10
11
/ K% |  N' U: n( \  _3 s12
13
( H' B  I9 s% {7 {14
1 j/ B: _" l, R  K' p15
16
17
18
19
& q6 E' ]4 U5 ?( i2 {20
21
22
23
24
25
2 o' H+ ~. a+ W26
27
28
29
% Q  H7 U$ `3 @  Q3 l4 {0 ]  r30
31
32
计数排序
简单解释：
这个排序算法看名字也很好理解，就是就是额外找个数组来计数，然后在这个数组从小到大或从大到小把数取出来即可。


: I- `3 `* j2 `



/ h6 v# o2 _# _' Z/ D完整代码：

7 G; a: X3 Y2 Z
package com.keafmd.Sequence;

+ k" `3 x9 ^2 j* s
/**
1 H7 j$ \+ V; n. I * Keafmd
# ]1 q, K6 w- z; V *
* @ClassName: CountSort
* @Description: 计数排序
0 o: S. w# ]; G  z2 J * @author: 牛哄哄的柯南
* @date: 2021-06-24 11:31
*/
public class CountSort {
9 h6 L+ D* G  G# r, W

    public static void countSort(int[]arr){
        countSort(arr,true);
    }
, x) c4 W& z  e

7 _) c* ^5 n+ N8 V5 V3 }& J    public static void countSort(int[]arr,boolean ascending){
: U5 ~) W5 P9 N; t8 d7 q        int d,min=arr[0],max=arr[0];

' q8 f, `2 N/ \! D& n$ {" ~
& D" `& H7 g) c        //找出最大、最小值
        for(int i=0;i< arr.length;i++){
            if(arr<min){
; K# a; u, A) a; v3 Y2 L                min =arr;
            }
            if(arr>max){
                max = arr;
% i9 L: ], T4 Z0 d  I/ D            }
% u7 Z6 h2 i2 [) E+ g" K: p' f        }

/ F* K, [' h9 q. ]" F5 E' s
& ]  S9 Q# r) V0 I        //建立一个用于计数的数组
        d = min;
        int[] count_map = new int[max-min+1];
        for(int i=0;i< arr.length;i++){
            count_map[arr-d]++;
. K" ~* y6 d+ u8 ?# x% C, [, N        }
% b" ^7 j% P' ?
# Y. q* p; m: h# O1 L' W
( x1 k0 z  K# \% [7 g' I        int k =0;
        if(ascending){
            for(int i=0;i< arr.length;){
' T! u* a4 F' J- r: U                if(count_map[k]>0){
" q- I1 I" c) R) p; D- G                    arr = k+d;
3 x( I8 F# o3 g, p; C+ ~                    i++;
                    count_map[k]--;
                }else
8 I9 X; D, ]4 G0 ]0 v. P9 L& E1 i                    k++;
) G. K4 ~6 T8 b6 A- b* W, j; {) U            }
        }else {
            for(int i=arr.length-1;i>=0;){
                if(count_map[k]>0){
2 M) i) X; g+ o; h( l- B                    arr = k+d;
                    i--;
6 a+ ^, e& A* B& ^8 O                    count_map[k]--;
                }else
                    k++;
            }
3 n2 t3 q0 M" h7 |" c. T        }


    }
  t4 p/ k) o+ L+ c0 K}
/ E. `" O* I! A4 T1
2
& [% F2 P- v% U3
% r6 H( D! g. \" d1 Z" i) u4
5
4 j; {7 \; A  K0 D! H, ~6
7
! Y7 F1 L, f; |5 R0 Q8
9
: s/ x6 \8 ]$ H. |) ]# Z% z10
% F( r7 I; M) x5 \! B( d) e0 B5 G11
12
13
14
15
( T5 d6 }# ~, t& Z1 k% x# \16
" f7 y% E( ~: R# j17
/ Q4 M& X$ P" j% w0 L& o& w# e/ \18
19
20
/ b& q- R6 d( ?, Y21
7 q1 u% U% `& y. Z- H6 z22
4 c- v' I7 P6 Q5 X% Y7 X23
24
25
26
27
  x- Z5 P7 \& Z8 p" w' }28
! R& e  L2 X5 M5 @9 T1 ?9 U  f29
0 U( k* C* O& a30
31
3 b8 |5 z% V* v) l) P32
33
34
35
36
37
" t2 j" ~9 m) ?38
39
40
; E5 ~  ^. k' |+ w& `& D& E* ~( h41
42
% P# E  C! E: x; n* [43
4 R0 N- a5 W2 |. {- i0 X44
/ s# c7 e& d6 `  E45
+ O. c2 |1 ^& F8 U( k46
47
48
$ d  `8 N  W0 x# V" _49
50
+ q% s* L6 r& }- E: x! @51
6 b& c/ R1 U! n: C5 _# u; \52
2 [6 c3 X2 W8 c5 U53
54
55
56
, F9 Q0 e+ m9 i57
3 d0 V" c& |  l5 z4 y( z: m, D58
59
桶排序
简单解释：
  \4 ?* {% S& R6 u就是把一个数组分成几个桶（其实是几个区间，从小到大或从大到小的几个区间）装，然后让每个桶（区间）有序，然后取出来放一起就可以了，相当于把几个有序的段拿出来放一起，自然还是有序的，当然需要是按照区间的顺序拿了。

& Y* w' [2 ~5 h7 P: A4 P




完整代码：


. E& J( E8 R$ f! J2 I: Zpackage com.keafmd.Sequence;

& S7 V- O7 y0 q& E7 c" T
import java.util.ArrayList;
import java.util.Collections;
) n4 w  q6 c: E2 t" [6 l2 `
( u* r$ c/ y1 G2 @6 p% }
/**
* Keafmd
*
1 z# S) \4 {! c+ _ * @ClassName: BucketSort
  f2 ~" j* B& J * @Description: 桶排序
0 ?# E) E% R  u$ t: L# i& r8 B: _7 D2 z4 H * @author: 牛哄哄的柯南
* @date: 2021-06-24 13:32
*/
7 C4 U& P; s' S/ ^public class BucketSort {
) q4 H- H: M, |3 h2 X, t& v4 O
( U( \2 i2 Q, ?5 Z. {2 Y, _
    public static void bucketSort(int[] arr){
        bucketSort(arr,true);
    }
6 C+ T# o: S6 p

    public static void bucketSort(int[] arr,boolean ascending){
2 t2 b" D  @0 Z& o        if(arr==null||arr.length==0){
            return;
) [) K" [0 y3 @; i4 v4 `6 x        }
        //计算最大值与最小值
        int max = Integer.MIN_VALUE;
        int min = Integer.MAX_VALUE;
) m: Y" v( u$ _  ?; B5 _  a        for(int i=0;i<arr.length;i++){
            max = Math.max(arr,max);
            min = Math.min(arr,min);
; G( U! q8 I6 d) g2 A        }
' y/ a6 j3 S0 h" [+ W- x( D6 J
' X6 v" F  H5 [' ^$ q
, P' X* |% ~2 p/ ^$ A7 c1 Q" r        //计算桶的数量
        int bucketNUm = (max-min)/ arr.length+1;
, h6 s2 W5 C- R: S  j5 n        ArrayList<ArrayList<Integer>> bucketArr = new ArrayList<>(bucketNUm);
        for(int i=0;i<bucketNUm;i++){
            bucketArr.add(new ArrayList<>());
& w9 P4 b/ V- w' Q! \        }


        //将每个元素放入桶中
8 N. g+ G- K: s2 k8 j; {, ^        for(int i=0;i<arr.length;i++){
9 \/ t& n; O2 _2 q+ X! c6 i            int num = (arr-min)/ (arr.length);
            bucketArr.get(num).add(arr);
        }
/ j6 O. E2 ~1 k1 Y) w1 d4 T6 `

0 K  [- g3 n  u- R$ f5 i+ S4 U# ]        //对每个桶进行排序
; Y- N" G& ~. L5 l        for (int i = 0; i < bucketArr.size(); i++) {
' R: q; B2 K: i, D  x/ @. X            //用系统的排序，速度肯定没话说
            Collections.sort(bucketArr.get(i));
5 Q7 y, J* N; e& d9 l. G# s7 @        }

: N; Y0 F  b; Q( @( u7 `+ b" ]* t
! p, x4 w2 N; y; v" v! F        //将桶中元素赋值到原序列
        int index;
        if(ascending){
            index=0;
        }else{
            index=arr.length-1;
        }

/ r' t. p  Q/ Q% E# [: K
        for(int i=0;i<bucketArr.size();i++){
            for(int j= 0;j<bucketArr.get(i).size();j++){
8 u# ~# m2 L. A$ K, n                arr[index] = bucketArr.get(i).get(j);
                if(ascending){
                    index++;
                }else{
6 \7 V5 G4 @* h. Q( U# `) i                    index--;
                }
& W  M- v4 J6 }; C: w            }
$ q9 K6 C! p! k

# _; c' y  |6 Y! z2 \        }

4 ^6 H4 Z, L5 U7 x
    }
}
% h7 l: L6 v0 [9 Z5 W1
2
3
- t  t! Q4 S' n# R. f* ]4
5
' a3 M* u( Q' m, D5 I6
/ d9 w" P5 `: N0 ~! w, l+ k7
" F. W: O  c" ^* B& z! ?# c; B& Y# H* ?8
9
10
+ E- r8 G# g9 Z: K+ e+ d' @11
12
+ q  d& U/ z- M8 c13
8 C# L5 F2 l/ x" n: i, |14
15
! B5 S: [: X. a. C  y2 P16
: u2 I6 m7 U$ ~+ L17
18
' a+ ?" j. a7 N0 {& O+ f0 Q19
, F. }- S, g+ S; l2 U4 }20
21
22
23
/ D/ d* {+ Q" t" H24
25
26
$ p& u1 ~; l' V  b3 j27
9 U. h3 s' m3 G28
29
5 w/ L; I1 l/ Z3 {( m/ C" M. o9 T) x30
( R7 I2 R( O8 v. o/ V2 |31
32
5 h7 m  E7 t0 o. E33
$ o- {9 ?. w8 h; m( R1 s. Q34
+ f- e* ~% c& R2 @35
& r3 h# u8 D/ ?/ o2 g36
37
, A' _# {9 g# p! E; w38
39
& v4 L1 _! G) u: S8 |0 _40
2 q8 i( R" E- q3 s" y" }4 I& e41
42
43
44
/ _" ?4 P; ]* B45
46
47
" \! X; D' V6 F9 N5 A# m48
: V8 a: {8 O  k. m49
" C" ~) `3 g0 @50
51
52
* ~( d9 E9 F. \; `/ Z53
54
' D3 D% l5 o/ ~8 ^! J! Z55
3 s; ^0 ?& }9 y' C+ c2 Y  D; w* Y/ h  `56
8 U, r- m  b0 F3 O57
58
8 _' o- C6 h0 I7 M3 R4 h6 h59
60
+ b9 g& B; ?8 Z* Z61
62
63
, o* [$ J  N8 U' D% ^64
5 b- E) |2 p( X& S5 X65
  S* J+ {- D1 ], Q66
67
68
69
& s) [2 w8 v/ S% x. M70
% }* {& J' c4 {. O2 f71
4 ^, {7 R4 V! ~& r6 }% Y# f( p72
基数排序
# r# \$ b8 V0 m' H: k+ L简单解释：
! f/ y( j& C, i9 }( P首先说一下，我发现好多人写的基数排序只能排序正整数，其实只要处理下就可以排序含有负数的了，就是我们排序前先把所有的数整体变大（就是减上最小的负数，也就是加了），都变成正数，然后排序好之后，在减下来（加上最小的负数，也就减了）就好了。
基数排序就是按数位排序可分为LSD（从最低位[也就是个位]开始排序）和MSD（从最高位开始排序），下面写的事LSD基数排序。
! J3 a' ^% p% u; F$ D" @1 O) }. V  l& G基数排序就是把数按位考虑，让后我们一位数只能是[0，9]，就是我们在考虑某位（个位、百位· · ·）的时候就只看这个位的数，放到在[0，9]相应的位置，然后顺序取出，最后再按其它位这样操作（上面说了要不从低位开始到高位，要不就是从高位到低位）

9 b0 k; X7 D& _- D. `" q7 x
0 @3 K! a) v' P

4 n2 L- V9 ~6 y+ s

9 h+ e5 r: u2 }9 O3 J完整代码：


2 T' _' v7 G0 o. @5 l* cpackage com.keafmd.Sequence;

9 X; I+ L; {6 ]
0 L6 x2 a/ R2 e# E, |% `/**
& }6 o" k, X  L: C% M+ N$ J, c. [ * Keafmd
*
* @ClassName: RadixSort
* @Description: 基数排序
* @author: 牛哄哄的柯南
/ O8 H5 U7 w) d * @date: 2021-06-24 14:32
*/
public class RadixSort {
) ~! Z: e2 ?" T    public static void radixSort(int[] arr){
; r; E5 k; [0 I        radixSort(arr,true);
. N& v  n1 V. A2 q    }
2 d# e8 `7 D6 {" w7 k    public static void radixSort(int[]arr,boolean ascending){
        int max = Integer.MIN_VALUE;
) [8 [6 B. _& ^$ ^, C        int min = Integer.MAX_VALUE;
( b! {, I$ d+ y% ?5 T        //求出最大值、最小值
( i% [3 d; |; I        for (int i = 0; i < arr.length; i++) {
            max = Math.max(max, arr);
            min = Math.min(min, arr);
        }
        if (min<0) {        //如果最小值小于0，那么把每个数都减去最小值，这样可以保证最小的数是0
1 G# b( ~6 H- |7 D( T% k8 Z: k            for (int i = 0; i < arr.length; i++) {
                arr -= min;
            }
            max -= min; //max也要处理！
        }
        //很巧妙求出最大的数有多少位
        int maxLength = (max+"").length();
        int[][] bucket = new int[10][arr.length]; //一个二维数组，一维代表0到9，二维存放符合数
* c" k8 v, j0 j# I* P/ a2 K, p2 s& T$ M4 M        int[] bucketElementCount = new int[10]; // 用于记录0到9某位存在数字的个数
        for (int i = 0 ,n = 1 ; i < maxLength ; i++,n*=10) { //个位 十位 百位 这样遍历
            for (int j = 0; j < arr.length ; j++) {
                int value = arr[j]/n % 10;
" y6 E" Z  @4 h  ]  Y9 l6 X$ X                bucket[value][bucketElementCount[value]] = arr[j];
' N2 R& E5 b" {; b0 u; u3 `                bucketElementCount[value]++;
            }
0 ]; q' \7 N) X0 D: V7 d' p

            //升序
* t) Z& F1 H3 Y) q* p) M' G4 l            if(ascending) {
1 ]3 {2 s4 D& f% B/ a- r" q                int index = 0;
& g' y9 r6 {9 @$ g5 Q7 A                //从左到右，从下到上取出每个数
) x! P6 w; T0 G                for (int j = 0; j < bucketElementCount.length; j++) {
                    if (bucketElementCount[j] != 0) {
. `0 O1 y/ D& f' N" Y                        for (int k = 0; k < bucketElementCount[j]; k++) {
# f/ C. P' h, [8 S  i7 }* |3 F                            arr[index] = bucket[j][k];
                            index++;
                        }
5 V/ m5 O% I9 ?$ x                    }
                    bucketElementCount[j] = 0;
5 D! h. {; P3 x                }
            }else { // 降序
" v: H, `( ?" z% D                int index=0;
) I3 v, Z; M- ?; M                //从右到左，从下到上取出每个数
                for (int j = bucketElementCount.length-1; j >=0; j--) {
- K/ j& _; b! p/ K3 P9 j. {' y7 [                    if (bucketElementCount[j] != 0) {
                        for (int k = 0; k <bucketElementCount[j]; k++) {
+ L8 K8 e" K% r& t                            arr[index] = bucket[j][k];
                            index++;
. _4 ], s0 H4 j1 G5 |                        }
                    }
                    bucketElementCount[j] = 0;
9 H+ ?! R% }- z1 i                }
            }

; \: T+ Y1 ~+ C4 X# I8 }' }
  c! c$ Z; Y4 J* d$ S# P

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






" Q4 b* b. L" ]/ D" _( g        }
        if (min<0){
; ~9 o4 Q( ]. `) R            for (int i = 0; i < arr.length ; i++) {
% ]4 w0 P$ C  i                arr += min;
  N+ {4 \* m: J            }
        }
( u% I: v! ]; T. ~3 V

    }
+ x+ Q# m# `1 z& h3 u+ Y& F}
1
! W, R7 |7 u7 g' F0 [2
3
$ K% g6 G7 }6 F( ~4
" |: K5 g$ @/ @  W5
0 K3 ^/ k2 r2 [/ Z$ v# i6
7
8
9
0 u1 {: a' u4 W( @' H10
. m4 i- |6 f! o& U5 ]11
12
13
0 q/ k$ S9 N  h& \( k14
15
. G/ {& Z( C7 ~9 L16
17
' Q! y2 n% M- x4 q* w7 s* @* e18
19
+ C" B* h; A' @& j8 A2 C* t. u20
) Y. t5 b: w  T5 T/ w21
22
) I9 v) l* p1 m2 E3 t! V* ~  U23
$ t3 A3 h3 R: R0 E24
: {4 C7 `- O, h- @- F25
26
% k. f+ H- m( x) F  {) b/ [# E27
  t, Y% X; y: b28
# s0 [- c' a3 [) B' ?" F29
30
' W7 n7 [/ d' J) l9 C  U5 F7 l) b31
32
$ \3 q+ U) w! C# R# h% H+ c33
34
" y7 z, Z6 \" Q6 n35
36
7 Z& X% R! u+ k( V8 q37
38
/ ]& @# s; K: ~1 w* V1 P- n+ o, b39
+ T! U4 Y4 {/ V7 W3 V  x0 {# a40
3 t# o) T5 b% w5 u* B0 @41
42
43
8 _4 M& `) h: y6 j8 b44
% U% z& Z- g: s4 ?' W( R# R, I45
, f5 k; ?3 {! y0 }  w# a( M, t46
47
0 y3 F2 G0 |4 o# |& R$ q$ i4 z$ O48
49
50
51
52
2 U/ A. \, Y5 v/ |53
1 ~# A; x7 b. a+ K% ?) v54
55
56
57
* @% h( G2 O0 `% x! E$ l' J58
' V8 h! j% V  V. }& n59
4 V- |+ j0 a9 q# C3 C60
; u9 s8 e/ [7 t5 k5 h61
62
63
64
1 v. R/ C; A9 u! ~! D4 Q9 u65
2 |/ F0 P: X2 z* n* b, \66
; f- c  C+ J7 R: E$ u% j& Z67
68
! i6 n3 g- E& w6 X: H/ S0 q69
8 J  y: D% h& R; s+ _+ A, f70
9 o& Q5 S# t6 |% j4 D71
72
73
74
2 e7 z" b' r- ?6 q8 ?: T75
76
# Q1 ^  U9 d# ~  D- c77
9 w, d/ L# |6 i' [( h4 W9 @4 T78
, h* K9 g* j$ G79
80
" `( j# C$ ]8 |) |4 B81
9 S: ~; g6 ?; _& D: G. q2 X9 u8 R82
% _, n$ W0 o) r, ]83
  w* [+ @$ J" P) d- l6 k完整测试类
package com.keafmd.Sequence;
4 h2 d0 k  o6 A4 d
8 G7 K9 P$ [& s* O! |; T7 R
import java.util.*;
$ h8 I2 r  s5 I, Gimport java.util.stream.IntStream;
import java.util.stream.Stream;
0 O/ ~6 d: j2 v9 a" X9 D

/**
* Keafmd
*
* @ClassName: Sort
* @Description: 十大排序算法测试类
* @author: 牛哄哄的柯南
$ a2 d# V0 U- u * @date: 2021-06-16 21:27
/ e9 [0 Q+ f5 {  |- B% d+ h */
; [1 ]* b/ Y7 j% G) I# J+ S( vpublic class Sort {
  i! @6 h- Q- W1 ~; E7 {
  ~3 t3 a- s: w" [

$ ^* A! e+ ?% Y) s/ E3 s) B/ m, P# m% r
    public static void main(String[] args) {

$ c$ }5 P% @" F% i
        int[] nums = {12, 4, 25, 47, 58, 34, 25, 9, 99, 26, 1, -13, 162, 10093, -66, -1};
: n; N& U; e9 C) ~, ~- n//        int[] nums = {12, 43,56,42,26,11};
        int[] temparr;


( w7 ~4 A, \. J6 G7 N        //利用系统Collections.sort方法进行对比
, j5 X8 u, C0 {( g5 A6 w" E$ f
4 b8 M, F6 y/ @9 l6 O% ~
        //将int数组转换为Integer数组
        //1、先将int数组转换为数值流
        temparr = nums.clone();
0 I2 K) q4 }, M2 n1 F        IntStream stream = Arrays.stream(temparr);
, X5 S; |6 Q1 [+ Z+ ?& W/ Z, v% s        //2、流中的元素全部装箱，转换为流 ---->int转为Integer
        Stream<Integer> integerStream = stream.boxed();
; ]7 Z  z1 }* l' W  p' x6 h" I        //3、将流转换为数组
        Integer[] integers = integerStream.toArray(Integer[]::new);
        //把数组转为List
        List<Integer> tempList = new ArrayList<>(Arrays.asList(integers));
        //使用Collections.sort()排序
! P# G9 `. v. N1 i        System.out.println("使用系统的Collections.sort()的对比:");
: q; w) ]3 L2 k1 E% f! N

        //Collections.sort
; Y* }2 F  `$ m        Collections.sort(tempList, new Comparator<Integer>() {
            @Override
            public int compare(Integer o1, Integer o2) {
, ^- r- v/ a& @+ f# u9 P                return o1-o2;
                //return o2-o1;
            }
# a3 U, o% z" |- L! D$ t        });
- r7 U! J* O" @9 o
; g3 A9 I- W0 x) r
        //tempList.sort 也可以排序
  u" S9 m/ Z( `       /* tempList.sort(new Comparator<Integer>() {
( s* @+ |+ n9 @            @Override
            public int compare(Integer o1, Integer o2) {
; h2 S0 H% S& f8 P+ m                //return o1-o2;
                return o2-o1;
            }
, H  I+ r8 a6 k; z7 n1 D        });*/


4 p( `$ F  y1 Q4 S! B( l/ J        //遍历输出结果
        for (Integer integer : tempList) {
% d0 R6 ^& S. S' r+ q# u! [4 q* e            System.out.print(integer+" ");
& C; k) s0 L5 z        }
# f  A7 f  z7 O' u$ ~6 v

        System.out.println();
7 [* C! f1 m8 o( P0 [# O' s1 l

7 i$ G1 `9 _8 e; I; K8 F2 X2 a        //测试冒泡排序
        System.out.println("测试冒泡排序:");
+ X7 s' o" X& F' j        temparr = nums.clone();
# E1 ^1 |8 M" D4 L8 e% e9 c

        BubbleSort.bubbleSort(temparr);
! U+ A& W2 f9 _  M, x: N

        //降序
; N& [; S- W4 g: K        //BubbleSort.bubbleSort(temparr,false);
* y& `. y# Y1 @0 P

9 J+ Y- z' G9 e% h3 n7 ?" _6 }        for (int i = 0; i < temparr.length; i++) {
            System.out.print(temparr + " ");
4 W9 Y/ @& W# h# t2 B" ^        }
- }; R+ z# r4 Y5 r- q. G% h        System.out.println();

  t2 Z" ]2 {( }: l' i9 ?9 u
8 w/ G5 x8 C7 F' l8 J        //测试快速排序
        System.out.println("测试快速排序:");
        temparr = nums.clone();
  c3 r. M; a1 H6 \9 ?" O        QuickSort.quickSort(temparr);
* X9 N7 n# E- n        //QuickSort.quickSort(temparr,false);
        for (int i = 0; i < temparr.length; i++) {
            System.out.print(temparr + " ");
- M  U4 y& s, F+ j        }
        System.out.println();
  z9 _$ I1 s) p1 R( G" O! _

        //测试直接选择排序
        System.out.println("测试直接选择排序:");
        temparr = nums.clone();
: U( w0 `6 H. b        SelectSort.selectSort(temparr);
, l$ [" X* d0 _$ ^, W/ _        //SelectSort.selectSort(temparr,false);
        for (int i = 0; i < temparr.length; i++) {
6 S; R6 [7 U8 D- ~- X. K3 y+ Z            System.out.print(temparr + " ");
9 H" y& p$ V, o        }
        System.out.println();
0 b* t' I) l( u$ M" D: J- ~

. Y8 L7 V& W8 b$ I3 ^        //测试堆排序
! g6 G& t; ?; x( r- }        System.out.println("测试堆排序:");
        temparr = nums.clone();
        HeapSort.heapSort(temparr);
$ Q' E' s: P: y5 h7 ^        //HeapSort.heapSort(temparr,false);
+ O8 G9 h8 h! L        for (int i = 0; i < temparr.length; i++) {
            System.out.print(temparr + " ");
        }
        System.out.println();
0 A  X4 w. y. q! D4 u6 B% n

        //测试归并排序
8 \, {& y% ?$ a/ r6 @  j        System.out.println("测试归并排序:");
        temparr = nums.clone();
        MergeSort.mergeSort(temparr);
( s9 U5 a% ?$ a3 h! N& p        //MergeSort.mergeSort(temparr,false);
) M% D3 u% x" A9 S/ L        for (int i = 0; i < temparr.length; i++) {
$ t0 _* s8 h4 I) D# k1 |4 {            System.out.print(temparr + " ");
        }
! T8 p  j  V/ _1 M$ M  i7 `& t        System.out.println();

3 a4 C8 t; H8 P: i$ O. |( |
        //测试插入排序
        System.out.println("测试插入排序:");
, I7 @7 j$ Y9 W        temparr = nums.clone();
        StraghtInsertSort.straghtInsertSort(temparr);
        //StraghtInsertSort.straghtInsertSort(temparr,false);
, \9 F6 L$ Q/ B9 [8 @8 A3 G8 }        for (int i = 0; i < temparr.length; i++) {
            System.out.print(temparr + " ");
/ A/ b1 E; h% P3 D/ U% X/ Y& w1 {        }
        System.out.println();
! C/ M" B( G' e" V" ?: k2 C
8 L; B' e: q( U8 u# S  `6 R
/ H! t4 c8 a. B  _

        //测试希尔排序
        System.out.println("测试希尔排序:");
        temparr = nums.clone();
        ShellSort.shellSort(temparr);
        //ShellSort.shellSort(temparr,false);
        for (int i = 0; i < temparr.length; i++) {
4 ]6 B5 l/ `  h8 H: z1 D            System.out.print(temparr + " ");
        }
        System.out.println();

9 ~: y2 R8 s" s) ~


        //测试计数排序
- I/ s$ Q! g+ Y6 a        System.out.println("测试计数排序:");
: T% K* O5 O' @, h        temparr = nums.clone();
        CountSort.countSort(temparr);
        //CountSort.countSort(temparr,false);
        for (int i = 0; i < temparr.length; i++) {
            System.out.print(temparr + " ");
1 h# n# w7 [/ S/ I        }
; a8 g& q4 W5 y0 F# ^        System.out.println();


5 y6 Y7 W: I2 ~/ J2 i! u: V
; C* A2 i: [+ Q& W" j; e, o5 d
        //测试桶排序
: @; G# j* B% |$ c- _, w        System.out.println("测试桶排序:");
        temparr = nums.clone();
        BucketSort.bucketSort(temparr);
        //BucketSort.bucketSort(temparr,false);
. n4 ~$ S! D% s- Z        for (int i = 0; i < temparr.length; i++) {
; ]$ k% B% Y* V) `6 l            System.out.print(temparr + " ");
        }
        System.out.println();
! V) Z1 ~5 E# W! c7 \$ O

        //测试基数排序
8 k! b5 u, }0 b        System.out.println("测试基数排序:");
        temparr = nums.clone();
4 q$ Z* E9 f/ ~6 E( y# T, W0 J3 E+ P        RadixSort.radixSort(temparr);
        //RadixSort.radixSort(temparr,false);
# ]6 S3 [# K- R8 S' N1 d/ ^* r$ ?        for (int i = 0; i < temparr.length; i++) {
            System.out.print(temparr + " ");
- ~6 h! Z/ B' Q' k        }
+ v% R% r, B1 G3 R# v# a" j, U        System.out.println();
1 V& Y2 K. w3 p" y) s9 S

: ~* v1 l0 t2 h6 k8 n    }

, W9 G8 p) h' ~6 |. c6 N
}
1 F( s1 y# a8 _' D1
2
3
; b- h" T6 Y. Z  ]6 ]0 [2 e" P! [8 j4
5
6
7
8
9
10
11
! B$ R* z" O2 c+ i* T12
3 G: h5 ?$ B/ e$ P7 `$ i* O13
14
. c$ P/ H, j; x2 L15
16
17
; }$ L7 |& Z5 }+ ~% e18
- g: d. X0 A& j6 w9 }9 I19
20
8 Y# i# f1 J9 R2 X1 q  f3 }, _+ o21
22
23
, a: e4 N! C# |! p24
' t0 Q8 A- L1 z$ [! I) _25
3 ~) D( c2 h8 _+ y  ^26
. N  c2 i0 R1 `* a27
28
29
30
31
. A4 f* q4 b5 f- O8 M& h# E32
6 C% F) D' S7 {" v33
34
, N& ]1 [1 K. b3 i35
1 C$ c( \+ I! E36
) A; Z' K; u% i% g37
4 a) r% e0 S, n1 H& X  Q2 ~38
0 P% D+ U2 L  W( v0 [5 W# @39
40
* G5 L% z- j) l0 Z41
42
" x  I& }1 o) K( s0 l" o, [$ a" z43
44
45
9 T9 m; n7 G& C46
47
5 |0 C4 Z  m! w$ o) \6 M48
+ x& B3 [# C. R! i49
$ `- [* A0 g5 s- a3 m50
% s/ h/ I3 i; F( k* {" l' d51
* [3 o) D* w( o+ r52
; h7 |7 t7 a4 I8 p/ X53
1 J9 O8 k8 a* H. T3 D) ~% W; ~54
& B* h7 |) u6 M2 a! u55
! Q6 _: e3 K( [1 S: z+ b) D56
- `% V2 I$ v8 Q' r+ ^8 P0 f. ~57
! ]" `% x2 c- ^9 @58
, h( ?& x! V# R" K" k  D3 {/ H59
4 A8 x; V1 Y  g  G60
61
62
63
64
65
2 J% x3 f0 K+ v* F; Y$ N( A- c* e66
- e. ]& l- I0 k) _5 [$ P, L67
68
69
& U' O( ?. p5 w  Z70
4 p2 q3 z' f3 l' ~2 L71
72
9 C1 }8 `4 }, b7 M% y( Y5 f, R73
74
! g. O# y+ Y6 q0 {& j0 ]" B3 U75
2 ^) O( M! a9 S& l76
77
78
, ?; H  E% U2 ~5 Z) v79
# A  Y+ v4 [; u: `0 d80
+ i5 w- A- r4 Z81
' y% X8 k+ E  S# }82
1 e; A1 i5 \$ R83
84
8 p2 W6 u0 k  f+ i4 _( u$ l$ ?# o85
" {( t8 s4 M* g4 J86
6 M8 o2 ~: V2 C% `/ j/ G87
$ j* `, s4 C* X' ]6 L( \88
1 W2 K- P; J3 K: L2 d1 W6 l89
- s( M# }1 s! q2 b/ _90
2 k6 F  \" r$ }1 ?91
* o- G# s1 @4 B5 b, X92
& w; U) f! W: [% p. ^93
94
95
96
3 Y& W: d3 S; }" _97
2 H- I3 N0 k# I3 _8 O: L98
9 H" y0 R, D2 x+ _4 |99
$ s) e8 B0 E1 j100
101
+ N# |( J7 e5 k. d& `7 }& ^* H& x' k102
0 B5 }' A! g) P: J3 v; B: I103
; o! ^9 Y9 G9 R' r$ w104
( y* N* q! Q; b0 ?7 F0 ?- y105
106
107
108
109
110
111
. i1 V4 e0 x6 b# j% q0 d8 Y) ~112
113
114
" I8 R) A$ C6 p5 `. v115
! @& a6 P7 F$ t1 O' \# y116
117
/ f+ ?" K$ f" Y( E118
# i# s6 N4 c2 c" t119
: A* T! w+ w0 @" h1 |120
121
( C- N7 s( v' V122
123
  X; Q, K3 t+ o$ v" D! i$ c124
125
126
127
128
129
* c) y7 ]3 c0 U  b: @0 l130
% w# x, y  z( Y; _5 G131
132
. S7 @" _! i+ ~$ @8 M6 O2 U, x9 G5 e4 `133
134
135
  @$ M9 |' R' l136
6 a6 N, d6 }, W9 i8 _3 R137
138
139
140
8 j; G* }! o0 o/ v+ B. C141
: y, g/ R7 ~0 {9 d# A. g" ^142
143
144
145
146
5 W4 c/ n% ?" N) k8 `, [147
* M. A  g5 P+ ~! G1 G0 b148
9 G, M  @1 x- `: `& w8 @' y149
150
* b' X' U; f% c/ q9 g151
152
: n! W" |3 \9 [2 j, M( h, n) Z$ a153
( U5 ~6 k) j8 m7 h  G# f154
155
. x1 [& P' F/ g* z- o/ h' u156
2 w  K! m! |- J! B, }% u& z' g4 z157
158
* L* D1 [& d" U* ?. {; f, {/ B; S159
9 {; D. n& k1 c5 a+ |160
161
( k" F' S4 l4 k5 R4 x162
& E2 }. l" Z9 v2 A8 S163
164
5 O) H6 ^2 O. U165
166
167
/ e, o4 k3 W+ M" l- S! r! w( W5 l- J168
+ k- x  n  w6 m. I7 ?169
170
" {  i8 i$ ^+ Q, P- J, x. @; g" E171
172
/ c  Z9 H4 G4 q173
7 D4 {5 @- D4 y+ V! Q! q5 P2 h每天进步一点点！
不进则退！

! S+ [% l1 W+ S% _0 d1 n
版权声明：
原创博主：牛哄哄的柯南
0 o1 I! x# h  X) I6 H1 C博主原文链接：https://keafmd.blog.csdn.net/
————————————————
版权声明：本文为CSDN博主「牛哄哄的柯南」的原创文章，遵循CC 4.0 BY-SA版权协议，转载请附上原文出处链接及本声明。
. V# D, H' c6 ~$ `" `5 o原文链接：https://blog.csdn.net/weixin_43883917/article/details/118193663
: c$ W6 C& M, s$ |# H& d

1051373629

每天进步一点点！