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

杨利霞

经典十大排序算法（含升序降序，基数排序含负数排序）【Java版完整代码】【建议收藏系列】
经典十大排序算法【Java版完整代码】
写在前面的话
十大排序算法对比
! x" t6 G, u6 I1 R+ ^) W4 V0 X冒泡排序
6 O8 C0 J5 R" f7 x快速排序
2 g5 {4 m9 s$ H直接选择排序
6 \) C; S$ |1 S, u& T堆排序
6 K/ P: ?# K- c3 r) y' x- F1 y, @归并排序
. F5 M! }3 `& a" d插入排序
  Y  q# v) k/ ], G# ]$ C5 [希尔排序
6 T; _# M! i1 b" f计数排序
4 k. Q  v1 ]! r) Z8 T桶排序
. c/ n8 q. D' S% Q. E基数排序
完整测试类
5 p) k: G* ~+ n) [4 d" U0 o写在前面的话
! X' b$ l( b/ _9 ?       虽然已经有很多人总结过这十大排序算法，优秀的文章也不少，但是Java完整版的好像不多，还存在某些文章代码存在错误的情况，同时也为了自己练手，决定把所有的写一遍巩固下，同时也真诚的希望阅读到这篇文章的小伙伴们可以自己去从头敲一遍，不要粘贴复制！希望我的文章对你有所帮助，每天进步一点点！！！


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

2 K7 ~% Q5 V# a& w. n' @: L: _" _) N
7 h8 F' ]! y9 [; j( f3 P十大排序算法对比



0 R+ o  A( S% K2 r
# E9 A* w9 d  E# M1 H关于最后一列的稳定性，我稍微解释下，例如对序列：1 2 4 2 6 排序，序列中存在两个2，如果我们把这两个2标记上（让他俩不同），排序之后，前面的2还在前面，那么就称这种排序是稳定的，反之不稳定。
) W+ x* s& Z0 i$ p4 Q/ r- M
) J  b: v3 o7 l! q; L( G" b
$ B4 z/ u/ r/ E6 A) d1 ^6 G冒泡排序
, {0 U/ [  J; I( |简单解释：
' c" G6 \  P6 r/ v       原理就如算法名字一样，就像水中的气泡一样，每次我都把最大的或最小的放到最后面，这样总共需要n-1趟即可完成排序，这就是第一层循环，第二次循环就是遍历未被固定的那些数（理解成数组左边的数，因为每层循环都会把最大或最小的数升到最右边固定起来，下次就不遍历这些数了），两层循环遍历结束后，所有的数就排好序了。
: R! m, A0 S7 A- p2 M       两层循环所以冒泡排序算法的时间复杂度是O(n 2 n^{2}n
2
4 e; o( K6 _' [' y2 r )，是一个非常高的时间复杂度，我在下面的代码进行了优化，加了一个标志位，如果上一次循环未发生交换，就说明已经是有序的了，就不继续下去了，反之继续进行下一轮。
6 Y8 D5 K, @1 m) Z1 }/ R& v  s6 X  C
) k8 h9 p% a& ?4 Z1 A% t; R: ?

3 ~7 B  v5 I$ E" V


本文的图片来源网络，仅用于大家学习，侵权联系删除！（下同）
$ f" X7 k* [# v, @& [$ k

5 w; f6 Z+ D& ]. \: Q完整代码：
: ?0 @# c; |. t5 U3 V& }7 Y* _
! H" s4 X# d) G$ S6 P1 L5 w7 N
package com.keafmd.Sequence;
  p8 r: S1 v0 k& U
. F# }/ W8 I( g. J
2 @! ]/ c0 |- b2 c( I, ~/**
; m: o# H- X1 m% f * Keafmd
5 M4 L: A7 C4 Z' `7 c# D; I0 Z. @. y *
* @ClassName: BubbleSort
* @Description: 冒泡排序
2 s" L7 [) }( H, s% h) G5 [$ j * @author: 牛哄哄的柯南
4 A& P# d9 i9 {2 e. S4 x * @date: 2021-06-24 10:31
1 P) ^( B1 T  n* } */
- X: b- H5 j4 D5 V" e# C+ Upublic class BubbleSort {


    //冒泡排序
    public static void bubbleSort(int[] arr, boolean ascending) { //exchange标志表示为升序排序还是降序排序
, [5 Y8 E" }$ }1 h/ h3 B

; o6 p, E( E) b) U% F/ f        boolean flag = true; //加一个标志位，记录上一次是否发生了交换，如果是，我们则进行下一轮，如果没有，说明已经冒泡好了
& E/ A$ f8 E" t0 G4 ]" Q  M! }0 q
; y6 c8 `7 `' @: I* _& y; Q
& o. s  L% H3 S2 ?        for (int i = 1; i < arr.length && flag; i++) { //控制次数，第几趟排序，只需要n-1趟，有交换时进行，只有flag=false就说明上一次一个元素都没有进行交换


            /*System.out.print("第"+i+"次遍历：");
            for (int i1 : arr) {
/ A( B; e7 `* I( F9 L4 @                System.out.print(i1+" ");
            }
" c( j! F7 Q4 x. L5 e, J            System.out.println();*/
6 I2 t4 {7 D6 i8 }2 \5 S# G
* |8 D& k2 M, S) {) d
# W, @7 f. }/ t0 j1 Q! t. {; H            flag = false; //假定未交换


            for (int j = 0; j < arr.length - i; j++) {

9 P- T9 a7 ?8 b; ?
7 ?! d* E8 r; s# G8 W* `) r                if (ascending ? arr[j] > arr[j + 1] : arr[j] < arr[j + 1]) { //控制升序还是降序
                    int temp = arr[j];
                    arr[j] = arr[j + 1];
                    arr[j + 1] = temp;
0 N$ m3 O7 w+ c2 V* A( K; f                    flag = true;
                }


            }
4 ~5 O8 r4 |. k0 f        }
( ?' f2 n+ i  r+ `    }
; z" ]& D- A% ?/ S4 F. E6 c
, P# M, C- T- Y
  |+ L; j" Q* z# K8 r    //冒泡排序 -- 默认不传参升序
3 i9 G* i5 Y4 S4 E, a) m7 ~/ Z    public static void bubbleSort(int[] arr) {
        bubbleSort(arr, true);
    }
! d' U. o" G. h9 `}
1
2
2 E3 e! J% |" n1 s$ v3
4
5
: ]  v) d& e9 [$ u& |3 Z/ R$ J. o6
" J: m+ U6 S* c7
8
$ h* b# ^! K8 h1 N/ o) q: J9
: k7 G, v  C8 G/ d7 R- i3 l6 l10
: j$ g( s0 f) K9 `/ _, n, u11
+ s* I: Y* y9 P6 X. G12
* Y0 ~0 Q+ Q0 n' x9 E; O7 M13
, u" ]% y' r; ]; i& Z' U14
15
16
6 _  b5 k, P8 J7 u, g+ d6 B/ M1 R17
1 a1 O$ A% o4 I. i, U18
9 s% ~! g; h. R* q/ o19
- v; `3 t% P7 z; n20
21
22
5 R+ n! D  e+ a2 t: D5 r23
& g! A: K$ P6 a0 \7 `" @. K24
25
26
27
28
29
" }; @- A( e7 ^* A" F3 {30
4 M$ q: Q! U% y2 O9 G6 m+ ]31
; G- a5 D5 Q# W/ c32
33
34
* R: F& D( t  }35
36
$ \6 f7 I9 N& \( P; V% k0 C8 f37
38
39
: X$ g2 ]3 V8 g1 J/ `6 C) }40
( K, h/ N& G, p7 h: Q41
* Z( i# w: O7 Q5 g42
; [# a& V: f, U! f  Y43
; L" P1 n) E' z  v' J6 ^44
45
测试代码：
9 Y% A$ L# k& A

% t+ s! M* u4 u, ~3 f升序排序（从小到大）
% [% Z. _9 _1 ?# S' \- c: T
/ N! f# `: i+ d- d2 H
package com.keafmd.Sequence;


import java.util.*;
import java.util.stream.IntStream;
import java.util.stream.Stream;
6 _. ?$ P0 N# h8 V/ ?

/ [" z+ a: C( q$ z( g2 [  E$ Y/**
* Keafmd
, K0 \- H" K, A; f4 {+ E *
3 G1 U- ]  {% w * @ClassName: Sort
* @Description: 十大排序算法
, Y3 J& ?# G8 w1 t * @author: 牛哄哄的柯南
& x7 l* D: l0 ] * @date: 2021-06-16 21:27
9 s. e% a! ~- I5 S! R */
public class Sort {
    public static void main(String[] args) {

- w- M2 e/ V$ Z. Q4 O) G7 h
        int[] nums = {12, 4, 25, 47, 58, 34, 25, 9, 99, 26, 1, -13, 162, 10093, -66, -1};
        int[] temparr;
7 a9 X- b3 K4 B2 D
$ p  c" N7 o- U2 e$ l
        //测试冒泡排序
        System.out.println("测试冒泡排序:");
        temparr = nums.clone();
* A* u0 ]" }6 `' V$ }' [5 S- i" @8 ^- {- l        BubbleSort.bubbleSort(temparr);
5 w' H  |4 Y: ~( ~4 ]+ B8 V        //逆序排序
) \! N9 N/ G  l" j) {        //BubbleSort.bubbleSort(temparr,false);
        for (int i = 0; i < temparr.length; i++) {
            System.out.print(temparr + " ");
7 Z2 y& Q7 t* W" r- X! H        }
        System.out.println();


    }
}
& F* W3 R2 y" W  X% V- ?8 r4 ~1
2
. [0 z9 L8 z$ u+ M, o3
4
  z6 J  R1 W7 Q. e* L! R+ Q5
6
7
8
9
10
+ ~5 P% C1 `, K/ |4 ]11
12
13
14
15
) w2 D8 X; t$ R' V& J$ W16
17
18
19
20
21
* V, v$ z+ G. J/ A& f22
23
24
" v9 F0 ]. H. d* ?3 I25
26
0 [+ _$ g& P  t- t  K6 E! Z5 @# a9 n27
# p( d6 d4 n; a; ^28
, O; W2 T, V( l) X1 z29
30
1 ^+ j3 u' |4 g31
32
33
运行结果：


测试冒泡排序:
1 N1 s  p) e. H4 T-66 -13 -1 1 4 9 12 25 25 26 34 47 58 99 162 10093
1
/ @  c5 M" {! H2 \  L+ d" `2
降序排序（从大到小）


$ U: R' \5 t# q//测试冒泡排序
System.out.println("测试冒泡排序:");
temparr = nums.clone();
/ S; _! l6 `/ E# D- nBubbleSort.bubbleSort(temparr,false);
, ?# a/ d& T4 T9 bfor (int i = 0; i < temparr.length; i++) {
' v3 r- `2 G* ?. u1 B/ Y% e; W# t    System.out.print(temparr + " ");
# F8 {  E# L4 M9 v}
System.out.println();
1
2
' d- t5 @9 Y* b  g9 f3
! y, ^, N7 J. g. S4
5
7 ?3 P+ K7 ?4 M1 C2 t9 W6
; y- g7 m2 C9 z5 P7
3 W4 i2 t8 c4 I! J8
$ m; K" ]7 d9 O运行结果：
6 Y. b! x1 G( `8 ]8 W; w

) r) d: w' W3 K- n2 ?测试冒泡排序:
: q, J; k3 r! J; c6 U! h10093 162 99 58 47 34 26 25 25 12 9 4 1 -1 -13 -66
1
4 {* y; l6 b! g/ h2 i5 p! y2
下面几个算法的测试也就是换了下类名和方法名（换成相应的排序算法），如果想降序就在数组后面传个false即可。我就不一一复制了，我在最下面给出含所有算法的测试类，需要的自取即可。

2 G. g3 U5 W  a" e' ^. ]7 L
6 j) o8 z& x& k快速排序
8 L% d1 g' \; h& r/ H- P简单解释：
" A$ \( Q- r  x快速排序就是每次找一个基点（第一个元素），然后两个哨兵，一个从最前面往后走，一个从最后面往前面走，如果后面那个哨兵找到了一个比基点大的数停下来，前面那个哨兵找到比基点大的数停下来，然后交换两个哨兵找到的数，如果找不到最后两个哨兵就会碰到一起就结束，最后交换基点和哨兵相遇的地方的元素，然后就将一个序列分为比基点小的一部分和比基点大的一部分，然后递归左半部分和右半部分，最后的结果就是有序的了。
: F* N! T/ d0 p) p* w


4 N0 [+ N$ c, F2 q9 a3 M9 h


完整代码：


package com.keafmd.Sequence;


/**
: B! g; y9 F$ }$ E9 O3 N * Keafmd
*
* @ClassName: QuickSort
3 \9 X$ F+ n4 @; _" U5 } * @Description: 快速排序
* @author: 牛哄哄的柯南
  S- t; y+ L0 _8 M4 t: {% Z5 m * @date: 2021-06-24 10:32
*/
% |. V1 z. U8 E4 _public class QuickSort {


: K& J& g! j: L0 Y' y; h2 n    //快速排序
1 F! S& k  P& U7 G: T    public static void quickSort(int[] arr) {
+ v3 i; S* T4 u, J% ~+ I        quickSort(arr, true);
    }
' ]8 i' c; x6 F. J* H
: F+ v! c: G- z  Z
' j( [8 L) @  C    public static void quickSort(int[] arr, boolean ascending) {
        if (ascending) {
1 W: H' m0 {3 P5 z            quickSort(arr, 0, arr.length - 1, true);
, f; C) r4 ]3 ^) \9 c        } else {
4 V, ~4 n1 g1 X8 Q* f# }" A            quickSort(arr, 0, arr.length - 1, false);
        }
    }

$ m+ {! R- T- u! A  b# R
( V$ L) N  {* S' O! q9 n6 ?) A% n    public static void quickSort(int[] arr, int begin, int end, boolean ascending) {
        if (ascending)
            quickSort(arr, begin, end);
6 ^1 ]0 K/ e% l3 f        else
# `4 L3 a4 g& `; r# Q            quickSortDescending(arr, begin, end);
    }
/ H5 V8 }' G2 f2 H

- V4 S8 Z8 s  D  b    //快排序升序 -- 默认
    public static void quickSort(int[] arr, int begin, int end) {
        if (begin > end) { //结束条件
0 V; f! H2 [3 F7 l+ Y8 ]8 ?            return;
        }
" L: R1 D7 Z2 c, b9 }        int base = arr[begin];
9 S- m: [, q0 X( W( H        int i = begin, j = end;
9 s- I$ A! p! i( a        while (i < j) { // 两个哨兵（i左边，j右边）没有相遇
            while (arr[j] >= base && i < j) { //哨兵j没找到比base小的
                j--;
, v9 x, c% {* `, R' M3 Y            }
            while (arr <= base && i < j) { //哨兵i没找到比base大的
1 I( n  u! p" b8 U                i++;
            }
  q2 D9 P1 v, m' g( k; b            if (i < j) { //如果满足条件则交换
                int temp = arr;
                arr = arr[j];
                arr[j] = temp;
            }
. b/ S4 k$ Q' |" D
- n: O/ u( ^# A
        }
        //最后将基准为与i和j相等位置的数字交换
8 A; H& |% c! j3 u        arr[begin] = arr;
        arr = base;
5 j8 x, {4 Z1 _" f$ Y        quickSort(arr, begin, i - 1); //递归调用左半数组
( u* g9 s8 x: S( j) E1 R4 w        quickSort(arr, i + 1, end); //递归调用右半数组


$ b4 n3 V( I2 K, W; }    }


9 u, s6 M% G* J* _& {2 I3 m! p    //快排序降序
" @1 }7 y5 P4 Y, ]6 ?    public static void quickSortDescending(int[] arr, int begin, int end) {
" j4 h/ z- d: K- s3 X7 q        if (begin > end) { //结束条件
5 F% g2 z. w- T# r0 ]* C1 {! W) [            return;
        }
        int base = arr[begin];
& e$ r- C* q- D! ~1 h8 ?8 ?        int i = begin, j = end;
        while (i < j) { // 两个哨兵（i左边，j右边）没有相遇
9 p0 y" I7 g6 }: V7 Z4 s) k8 Q            while (arr[j] <= base && i < j) { //哨兵j没找到比base大的
- z) R7 h  Q& T; J" }3 e4 @+ e) ?5 N                j--;
            }
            while (arr >= base && i < j) { //哨兵i没找到比base小的
! g) |' ]* c7 C7 q( b                i++;
, o& {9 U: M( X8 w            }
3 A6 B3 w- t6 @$ M            if (i < j) { //如果满足条件则交换
! Y3 a0 G1 |. S- L8 J( ?; P! m                int temp = arr;
* ]6 ^! N5 B4 i% Q- r                arr = arr[j];
                arr[j] = temp;
, p: N) J* `0 M9 k            }


! \$ k) l# p- _& o( s        }
        //最后将基准为与i和j相等位置的数字交换
        arr[begin] = arr;
' J* r5 |: q) u- L& T        arr = base;
        quickSortDescending(arr, begin, i - 1); //递归调用左半数组
! ?( W- B& M+ i  f! `: Q, m, V        quickSortDescending(arr, i + 1, end); //递归调用右半数组

9 |3 G& O2 p5 c6 I, g  k
    }


. x( S1 k$ J. @: E; v* @- L1 @; J}
1
8 k) M$ V- ~9 p: N4 E2
( [* r& G5 ]) V% `6 m0 K2 `* o. I3
5 C6 S, f( S% ~8 h4
8 \* f: n2 v' K- x2 A4 J* Z5
6
6 L. R2 t. ?: x% V3 q* N, Y0 p7
8
+ ^) `4 v5 I3 D9
8 N7 J* Y9 T/ \; s0 s5 V10
7 w2 T) \3 V; n11
12
13
6 e: T5 l% V" c# X" m' [4 y3 S14
: `0 L( _9 T1 Q5 i& m; t  j6 C15
16
17
18
19
20
2 F9 [  o; i8 l& o+ ~21
22
, y; z; T) ^1 P3 P# K23
24
4 i) y, `: G) @' r25
% g9 w! W  d5 n) }26
27
6 o7 U% ^* Q/ B9 `28
, G; e5 o$ W: d" m, F2 `4 {29
30
" Y% d! x7 y, p31
2 K: T9 b& O+ C1 [5 ]32
6 l$ N) ~$ ?' i# y# i, E! b- s8 [% G33
34
35
36
( H) D" r5 o, s+ m, o/ p2 s37
, L* I" k. w6 Z0 l6 L! i38
39
/ _4 J! O, Z! W$ f2 p8 x# `5 j40
4 R1 X( G8 f) n' G# T$ h41
2 g! X) y# R2 M42
43
44
45
46
47
3 P( O3 q1 c" B' ^$ E48
49
: o# I6 c% X) k; E8 Q/ ^2 k50
51
4 D! v  F$ J# V) B( K' @52
53
54
, c( p3 P* o1 _2 B55
, A# s: ], `) A; _! T! I56
57
/ P+ d+ ~4 T* [58
* l6 j6 u) J) B* Y59
60
5 {1 Z; l; m8 `! n8 Y7 f61
, U7 j; _& s; X4 T  b) f. V4 p4 a: ^62
63
64
65
66
2 D, B/ u0 X; p- H: b67
68
/ C8 x; @4 U4 k8 }69
70
; z0 T; I0 _2 P% A71
6 X( E3 n$ I( e! o72
73
74
9 J4 r3 {9 C! d2 M" J75
76
: p. h* c  ^4 [7 @77
78
6 U, y4 y5 @0 }: b/ f1 F5 B79
80
+ q: @" A. W6 _" s3 ^7 ^" |: b81
82
83
" S( V, R6 w0 r, C, R  y1 x, H& g84
85
86
7 t7 q; U8 t- {87
; y5 c% ~$ p/ e9 ]. r2 e, b4 C. ~88
, U9 _% h' r0 I4 v) A/ L& R89
90
91
直接选择排序
简单解释：
数组分为已排序部分（前面）和待排序序列（后面）
第一次肯定所有的数都是待排序的
从待排序的序列中找到最大或最小的那个元素，放到前面的已排序部分，然后一直找，不断缩小待排序的范围，直到所有的数都是已排序的了

: W0 N) n/ n' J7 X3 C7 K


; b" C. [2 _& _) e
1 A& O9 y+ _0 q' L
) H7 ?5 e1 n( [6 p完整代码：


& r. `9 r  @  H/ ^8 v0 \package com.keafmd.Sequence;

) X3 t0 O+ N$ T% [% J& Q% e
2 X" w1 j) Z# ^5 ]7 h9 [/**
* Keafmd
$ S: h7 l$ u# x7 a4 ?' x! [( J *
* @ClassName: SelectSort
! C; B8 W$ p7 t * @Description: 选择排序
* @author: 牛哄哄的柯南
* @date: 2021-06-24 10:33
9 r! {. B; F0 F& M: b/ H( e */
public class SelectSort {


    //直接选择排序
- C/ W" ^+ }( X$ [    public static void selectSort(int[] arr, boolean ascending) {
7 D( m# @% N0 `        for (int i = 0; i < arr.length; i++) {
6 ]- t7 p+ l1 _* N4 @! s: p            int m = i; //最小值或最小值的下标
            for (int j = i + 1; j < arr.length; j++) {
; n& \* D% @8 z6 Y4 ^                if (ascending ? arr[j] < arr[m] : arr[j] > arr[m]) {
                    m = j; //找到待排序的数中最小或最大的那个数，记录下标
                }


6 c* F; i1 t9 v7 W# K% Q            }
            //交换位置
            int temp = arr;
  \( x* S  o% V2 @( C( H            arr = arr[m];
            arr[m] = temp;
3 Y. V0 [* |) ^) a

        }
$ b- }' u, S8 F* L4 y    }

, _6 ~) I: R  j4 F% f% r! F( S" B
( H5 `/ }( q' W. B% N& I    public static void selectSort(int[] arr) {
; e% x$ k0 G' h        selectSort(arr, true);
    }
}
, M7 t& P$ ~- o* u* G7 p1
2
3
+ ?4 D6 p; [8 d, W9 v% I( R0 P; |; b4 a4
8 j& O( o9 E$ Y, Q5
6
7 y$ S4 n% K6 e1 X8 {7
8
$ }( G0 |. |- B9
. c* |( W: P2 }8 A& ^0 j10
11
12
13
1 V- @) r; _( z/ U; W2 N2 y14
( ~. d! y; y9 y) r/ C! c3 L15
2 p4 r; @0 y; G16
17
# F0 N5 X) I* Z5 W8 m) ~18
19
20
21
22
23
2 j1 s7 k6 X, A. E4 X) n% e6 B24
. L/ M. F1 C8 x& C: A: b25
7 p# S4 p! @' w26
27
+ t- ~8 @; B# O; Z! f28
) p" t. k' z7 s8 y0 n# F; m. C3 u3 [29
/ G6 v1 k1 s( j+ t* ]30
31
32
33
34
8 e, {9 i1 v; G) [6 d; {7 Z6 h堆排序
9 Y9 g$ A" ~% B% J. c3 O, k& V先理解下大顶堆和小顶堆，看图
大顶堆，双亲结点的值比每一个孩子结点的值都要大。根结点值最大
小顶堆，双亲结点的值比每一个孩子结点的值都要小。根结点值最小


$ _* E" @) l/ c/ D; I

简单解释：
构建好大顶堆或小顶堆结构，这样最上面的就是最大值或最小值，那么我们取出堆顶元素，然后重新构建结构，一直取，一直重新构建，那么最后达到排序的效果了。
  T5 b* x* U6 B5 o4 P

* h3 i  t9 n9 C$ `* I) U  {) K# S

* t# J% _) N( d% k; ^; t. P. _6 g
( x, ?# g  H- E+ r) N
完整代码：

! ~0 {+ n1 m0 X( Y/ H; `
4 B' R+ o# v/ opackage com.keafmd.Sequence;
2 B* j3 ^+ j! @: k+ R
1 D( V1 \) g. ]/ `; r0 b
% D& A/ ^3 S! {/**
* Keafmd
: X. S/ E* e- v4 t/ ^ *
+ Z+ {3 B, j. V) ~" U * @ClassName: HeapSort
* @Description: 堆排序
3 \) `% d1 r' I7 k3 X * @author: 牛哄哄的柯南
! s4 L* `; f6 r/ a/ X * @date: 2021-06-24 10:34
*/
3 J' ?8 B! J/ }) j- A. b1 }) Apublic class HeapSort {

* S  e; |4 g* b% A% \: ?# v
    //堆排序
    public static void heapSort(int[] arr) {
# w) L8 @( ]+ \8 V, \8 S        //对传入的数组进行建立堆，这里默认建立大顶堆，进行升序排列
        heapSort(arr, true);
    }

; g+ {- u. G8 ~/ o% m7 C; _
: F/ f+ Y  y! J, C3 {& E+ {" I1 r    public static void heapSort(int[] arr, boolean maxheap) {
& m. ~" J. {8 U/ W
) i' b. ]6 v. E2 w5 ~
3 S& Y. ^7 k  ~2 m" _        //1.构建大顶堆
" C1 N8 Z7 q, N/ l  ]/ I        for (int i = arr.length / 2 - 1; i >= 0; i--) {
            //从第一个非叶子结点从下至上，从右至左调整结构
1 F  Q' M# U3 @3 Q( R            sift(arr, i, arr.length , maxheap);
, ]1 y/ u9 \( f; S        }
9 G- i$ X0 M  D" N$ [" R' T" e

, i5 m5 j4 e$ B+ C8 y0 K        //2.调整堆结构+交换堆顶元素与末尾元素
        for (int j = arr.length - 1; j > 0; j--) {
( D1 u+ y* e* [; o
1 d  Z% l7 y. Z1 E( Q4 A) \2 ]
            //现在的数组第一个就是根结点，最小值所在，进行交换，把它放到最右边
            int temp = arr[j];
6 f. q  k( G7 b& E8 `            arr[j] = arr[0];
            arr[0] = temp;


& v: R2 q9 M( F- X+ Z( h$ ^, [0 ?# w            //重新建立堆
            sift(arr, 0, j , maxheap); //重新对堆进行调整
$ V4 ~% q' H3 c/ @5 s8 p" H6 W        }
( u! |6 K' p' ^5 k' f. m7 P! s    }

9 O: D0 T4 q& `3 |+ F4 q7 w
    //建立堆的方法
- b& k3 l( S, u    /**
: z3 S, K. H  l  V7 O: G     * 私有方法，只允许被堆排序调用
  Y8 [$ k" z: H9 t6 s     *
% A* j$ L0 a% f: n3 s- k! _9 t     * @param arr     要排序数组
     * @param parent  当前的双亲节点
. c) i% [& \- o     * @param len     数组长度
     * @param maxheap 是否建立大顶堆
     */
' v! s- b9 \- w. F! ^: ^    private static void sift(int[] arr, int parent, int len, boolean maxheap) {


, c) }2 n- U0 b. \9 O        int value = arr[parent]; //先取出当前元素i
; y4 A. O) x9 p" i

7 u& W" H+ o0 l" F        for (int child = 2 * parent + 1; child < len; child = child * 2 + 1) { //从parent结点的左子结点开始，也就是2*parent+1处开始


' x8 M$ n6 R8 w1 a            if (child+1 < len && (maxheap ? arr[child] < arr[child + 1] : arr[child] > arr[child + 1])) { //如果左子结点小于右子结点，child指向右子结点
* {3 w% s# c  t4 Y- M# Z                child++; //右孩子如果比左孩子大，我们就将现在的孩子换到右孩子
            }
, a0 P  W% K4 A4 o) W0 p: ^% Y/ H! q9 j
8 m, k/ A5 t! d* }, p
            //判断是否符合大顶堆的特性， 如果右孩子大于双亲，自然左孩子也大于双亲，符合
, f* X* n2 N3 s! P! c            //如果子节点大于父节点，将子节点值赋给父节点（不用进行交换)
            if (maxheap ? value < arr[child] : value > arr[child]) {
                arr[parent]=arr[child];
                parent = child;
            }
            else {//如果不是，说明已经符合我们的要求了。
                break;
, N8 g. E, p/ W            }
        }
) n) p! c( |1 y6 O9 o        arr[parent] =value; //将value值放到最终的位置

1 Y; u1 R9 H% Q; [( N
. j; C* F  T1 }& v3 j& N3 ?

+ n4 z% C# V  u2 N% A: ~. z4 E, u    }
1 r$ F- J# c( m: S6 ]4 j& l+ r
* y: y/ z+ ~- O! S
}
# j. S  L5 l9 r) f1
- Z5 p4 t9 [. ?" F: o7 u% E) n  r7 ]: F2
9 H% n% e' W7 y/ j( |; h3
; H! y; E% \4 Y; Z4
+ V% q, D6 O8 s5
6
' S: U: }! |6 k+ ?; o) M$ t+ ?7
2 _; U7 p% h4 r! ~8
9
10
11
. P6 y$ j1 g0 T! S3 F12
9 z7 b2 F( V% M7 l8 ~13
4 R" Q! p0 \" V) W14
* e/ ]* P* L' C4 M15
( c9 N; D" _+ h8 j  s5 \16
17
, y; f1 c; ]" T& e18
# Y7 v" }# s: D8 d0 X19
20
, B, l& t, K) g21
! O8 M7 v: C% M( P22
23
8 d" K2 V1 d( Z7 O* g24
25
4 M9 z2 L  m& |9 W" L9 y6 c26
27
; `$ Z3 k. T, T% z. k28
3 ^/ P* J. `$ Q- Z* [( q6 D29
: j! Z9 c7 n: t5 y- V30
31
, t- u& [6 ~7 b5 P, Y32
0 m1 J/ f5 J/ j" s$ x& [- Q33
0 S. V8 v. D- \4 u34
, ?/ E& }( O4 p/ N35
( l( I& Y" S' g/ ^7 g2 \36
5 g" `% k" b8 }5 x" K37
38
/ }! j' k- p2 L5 H: ^39
  J( X& Q! S" r3 F6 v8 B7 k/ E6 V3 s40
3 T6 ~7 \4 F5 s/ L  E! A5 j8 T* a; z41
42
8 J9 I9 g5 y, i43
44
45
46
" u* L- P; ^. z6 b47
48
49
- Q# ~8 U. v* U) `7 y% n  k50
51
8 N' I; K- Y0 d4 W' Y' Z52
: u* Q- r  F/ I1 R' c/ Z* Y53
2 j  g# T( {; D54
9 h/ _- {, O# R# p; g4 W' W8 N. y/ p55
1 g6 h6 t# e( P4 V8 @56
3 x' s% J' u, x3 H4 d5 J* T% ]57
58
59
: `  a) p- a( g5 F6 T60
61
/ q4 M* \' H  i7 `7 `62
63
; v# }7 h: ~" _& n; c$ F64
65
66
67
- r# u# G3 Q: r. m68
- m% d' M6 C0 C1 y% _2 k) n69
70
71
2 G6 E# {( S( x- S: L( r2 E9 o72
73
0 _: m6 Z  G6 w+ M1 a6 w9 k74
- {7 I  F( j! o0 G# x归并排序
简单解释：
该算法是采用分治法，把数组不断分割，直至成为单个元素，然后比较再合并（合并的过程就是两部分分别从头开始比较，取出最小或最大元素的放到新的区域内，继续取两部分中最大或最小的元素，直到这两部分合并完，最后所有的都合并完，最后形成完整的有序序列）
7 {. ~3 |- P& p1 s: w# B) b

  R% l6 q( b- P7 T6 t  D  P3 F
6 f3 k! j9 n5 z6 @0 l' N
. u  ^# u/ p5 i) ~" J- R

完整代码：
5 A- A% B! B: A7 Q. _7 c0 D

% x4 e0 G7 l! C7 e9 kpackage com.keafmd.Sequence;
! T/ U* q0 B4 f% u1 s: Z: m8 S

, [# @% T: i- T5 d& D: }4 X7 k/**
* Keafmd
1 l8 e. a) \# X; | *
* @ClassName: MergeSort
1 ], a  {" r( u; S/ F * @Description: 归并排序
* @author: 牛哄哄的柯南
8 Y) O2 E) w" {! b: m * @date: 2021-06-24 10:35
*/
+ H# J) i" A! ]$ H8 xpublic class MergeSort {

  u& x9 r5 D7 q& ]
    //归并排序
& i2 q4 u2 r& p( ~" u2 v' Q" `    public static void mergeSort(int []arr ,boolean ascending){
7 J* |  h1 F7 j6 w( i2 ~* k7 k        int[] temp = new int[arr.length]; //在排序前，先建好一个长度等于原数组长度的临时数组，避免递归中频繁开辟空间
        mergeSort(arr,0,arr.length-1,temp,ascending);
; l9 v8 L0 J, @' h    }
! K* G& k5 T. o' W    public static void mergeSort(int []arr){
% a( r. O" i6 c: B9 n5 N, O        mergeSort(arr,true);
% |! x0 f8 `% l( I5 o# Y    }
0 Y+ _  R. ]7 c7 u2 @* s

    /**
0 r+ H! n$ _4 j6 g6 L1 Q     *
% Y, r' E9 T( }3 t     * @param arr 传入的数组
0 W+ G, f0 X$ ^2 V8 l0 J+ E     * @param left 当前子数组的起始下标
9 [- Y# x% ~6 k% h     * @param right 当前子数组的结束下标
1 a4 C5 }) o! @  U) ?     * @param temp 拷贝暂存数组
     */
" ^' m9 g# E- Z4 Z2 R; T    public static void mergeSort(int []arr,int left,int right,int[] temp,boolean ascending){
# M3 [0 A" ]. {5 t        if(left<right){ //这里是递归结束的条件，我们是对半分，那当left==right的时候肯定大家都是只有一个元素了。
6 ?" ~, r) Z/ n# s6 x8 J
$ `; z1 \+ ^& d' \
$ Z( r9 a% v5 K$ D* q( {            //对半分，比如总长度是10，left=0，right=9，mid=4确实是中间分了，0~4，5~9
( T& E% i+ t3 Y            //当长度9，left=0，right=8，mid=4，0~4，5~8
) b4 ~1 r0 |2 ^. U2 f( i- Q            int mid = left + (right-left)/2; // 防止越界的写法
            //int mid = (left+right)/2;


( R; E2 i  O8 r+ h9 ?            mergeSort(arr,left,mid,temp,ascending); //左边归并排序，使得左子序列有序
            mergeSort(arr,mid+1,right,temp,ascending); //右边归并排序，使得右子序列有序

6 V5 S8 z6 O6 {: R: E
            merge(arr,left,mid,right,temp,ascending); //将两个有序子数组合并操作
9 ^1 M! m) y7 g; @        }
    }


1 |9 A, d( G% G( E. A# y! G' T    private static void merge(int[] arr,int left,int mid,int right,int[] temp,boolean ascending){
        int i = left; //左序列起始下标
        int j = mid+1; //右序列起始下标
) o0 c# t* \5 G; c* d        int t = 0; //临时数组指针
        while(i<=mid&&j<=right){
# I" W% M' Y/ T3 T/ q- ~. Q5 I9 \            if(ascending?arr<arr[j]:arr>arr[j]){ //比较两个序列第一个元素谁小，谁小先拷贝谁到temp，然后对应子序列下标加1
8 d; W; d) M* t1 U+ R                temp[t++] = arr[i++];
/ Y1 C8 V8 c0 d, l1 U            }else {
) M) b; T& B, r  u5 C9 b1 Z$ s                temp[t++] = arr[j++];
            }
        }

: J# \* B3 p$ G/ S
& H, X! u, l- R2 a        while(i<=mid){ //将左边剩余元素填充进temp中——左序列有一些数总是比右边的大的数
8 O3 f1 N2 o$ F% M1 y# g/ y! H            temp[t++] = arr[i++];
- P; S& |" ~5 s3 J" N0 R. f3 }        }


7 a3 X. S0 s4 o3 L" s, O/ I        while(j<=right){ //将右序列剩余元素填充进temp中——右序列有一些数总是比左边的大的数
            temp[t++] = arr[j++];
7 u5 e" K) @% X7 B$ R        }
; R  r% B6 V0 m! p" K+ P
: W- t' X0 L" s8 Q  N. r
        t = 0;

: ^! U' A. v& K. g# I7 O
        //将temp中的元素全部拷贝到原数组中
9 [2 \: J2 m$ g7 [/ m1 u. j' @        while(left<=right){
2 R) t1 Q0 V; t' ~( w            arr[left++] = temp[t++];
5 Z5 {3 Z0 C% h        }


' \* z% F! I3 Q    }


}
1
2
$ h: K2 y/ {3 ]% P2 l3
4
0 T$ F( J$ ]2 M/ l* O5
- X! j5 R/ k# c4 C) X* L3 q: K6
7
- c+ P( K# ^6 W' B8
' s$ n) t6 c5 K1 j. j* {9
' B4 k( k3 B  `10
11
+ M) ^: W' t3 u/ t, Z12
5 t  a8 p8 J  p$ A7 d' @* ~7 L5 f& I13
14
15
+ N$ H5 l: U% g9 H6 d) A16
0 a8 O( z) X' z8 p, D6 K7 u# ^17
! f9 w. `3 [, \; U$ ~  c  b% r18
. D! q. v5 q1 k, S9 Z19
20
21
/ V' m& }4 ^6 i) b# D/ ?( u$ Q- @6 W22
23
% j3 Q  I; p: p$ \; M- D24
25
26
27
28
8 y' _& r( I: x' S29
30
31
32
33
6 Q1 m, ]9 S2 \3 a5 L2 X% e7 Z% n34
35
36
) K& Q- u% p. f; L37
/ @. p9 _+ Z. u5 U3 {38
39
40
' E: d- N, K7 o- o" a41
42
0 \- i! s+ @: ^; y) u8 A. K7 O5 f43
) `$ y0 E* m+ v' A& ^1 K2 o: T44
45
46
3 d# R. t# y3 F4 k% |, B, H% ?47
48
49
# v$ r1 {' T" j, m" I$ w, ]  f9 G/ C50
' a# |6 m! [4 C* C# C/ H0 W51
52
1 t) U2 V5 [& \4 a* c9 W53
54
, s; a. n* d1 W. _! S6 {' D55
56
57
58
- b4 o0 ~$ R  _  R; u7 E59
9 G0 m6 C2 N) U3 W! Q( D" x2 N60
61
62
( K8 h7 M: o7 l& S63
# j$ p+ L+ p5 S% _) M6 F; N64
1 m; {  d" ?4 X65
66
2 l- d# \7 d+ i67
% B" ^/ {/ b; _( Q( {3 ~68
69
70
71
72
5 m7 m9 ^- ^+ Y) \73
, N; d" R6 b/ ^/ y3 l插入排序
3 t- y' v$ B# ?8 p6 X$ K' g( a1 l简单解释：
最简单的理解就是打地主时我们拿到牌后的整理过程，从第二个牌（假设我们拿起来这个牌开始比较）开始，（说下升序）从后往前比较如果比前面的那个牌小，就把牌往后移动，直到找到一个合适的位置（这个位置的前面的那个牌不比这个要放下的牌大）就把这个牌放到这个位置，慢慢的前面的部分变得有序，直至全部有序即可。



+ P7 q1 K( K/ \0 t
7 `1 h3 _$ q9 |7 L3 f
" b% D' |, t4 T
完整代码：
& a) W+ ^( C+ j$ f) g& Z! H- z

& r" A1 C& e- b' R" d5 e. b+ Q2 ~& kpackage com.keafmd.Sequence;


/**
* Keafmd
*
: m8 W8 V: [3 r* S* ?) Y9 n0 t; r, z * @ClassName: StraghtInsertSort
7 k3 I7 R; c/ l, ^! ^  o1 u1 E6 Y * @Description: 插入排序
/ D1 F7 h, T9 R2 ]2 M, y7 T3 C9 ] * @author: 牛哄哄的柯南
* @date: 2021-06-24 10:36
7 d4 Q+ b* L  F* y */
3 |% c0 m( A( q+ X( ]% N& Y* F9 {public class StraghtInsertSort {
- x9 i9 i) t8 Y, K1 F: \/ J$ I    //插入排序
% J3 C$ _) G' U1 e    public static void straghtInsertSort(int[] arr) {
        straghtInsertSort(arr, true);//默认进行升序
    }

) {+ V* K- N1 g: U1 L" d1 L
    public static void straghtInsertSort(int[] arr, boolean ascending) {
( t( ~; q; Z* B0 |% x/ v

        for (int i = 1; i < arr.length; i++) {
+ s: G3 M. g% u$ t  m            int temp = arr;
$ M5 G: ~) R: N7 v. q            int j=0; //这就是那个合适的位置
            for (j = i - 1; j >= 0 && (ascending ? temp < arr[j] : temp > arr[j]); j--) {
                arr[j + 1] = arr[j];
            }
% R$ B3 e2 s! `% F8 z, w  u1 O  M            //把牌放下，为啥是j+1，
: _+ u/ [5 i/ x5 m9 Z            //是因为上面的循环遍历到不符合情况的时候 j是合适的位置的前面的那个数的位置
            //有点拗口，但是就是这个意思，看图方便理解下
. }/ i$ [( X& J8 o& D; `5 I5 v$ [            arr[j + 1] = temp;

- }( p+ J. e- \8 G7 u* m: s* n


        }
* J4 o3 O# A3 m
" v6 i4 k7 u3 p
    }
, g: Q9 l7 o0 S& Q* }}
1
2
3
- R8 g6 [% Y% V0 @4
+ a/ F& o* c9 a/ h1 v5
  e0 m% w  }, s6 \. Y" ^6 e8 z2 B6
7
% S7 O+ v7 g; k4 Y* S- I+ s8
9
10
11
0 i  S: _3 j1 M! {+ N12
3 _+ G; r5 R8 _: y& L2 ]9 z. H13
14
15
: z: ]! `% z9 i& s9 g7 X- Q16
% Q2 ]) L0 s! j" v4 R9 q17
, \; K% `# _! L9 @! C( N5 L1 t1 X18
19
3 b% o0 }' H( Y8 T8 P$ p20
21
7 c0 W3 ^  }; h0 `4 r, y22
23
! l3 X+ q! C7 I- h" ]. b24
25
/ D3 l6 R$ \8 J1 I26
27
28
29
0 o+ q7 C2 I, [  Q30
31
: H! l" @$ d( ^+ F3 Z$ l( W3 j& K32
33
! p0 R" M5 m2 c/ s, l34
4 `; q7 _9 y# G5 p% i/ z" [希尔排序
简单解释：
$ K' {2 W6 T2 I" j/ K希尔排序是插入排序的改进版，我们理解一个叫做下标差的的东西，也就是下面那个图中的增量d，初始下标差为arr.length/2，然后继续/2，对在同一下标差（相当于把这几个数单独拿出来了）的若干个数进行插入排序即可。

5 c- i, X/ g: E


  s$ E1 L! S: C8 O% G3 _/ J

完整代码：


package com.keafmd.Sequence;
- b: y; _. c+ x3 J# s
' C* P* P* r& b) T7 s5 B* M, S
/**
* Keafmd
*
* @ClassName: ShellSort
$ h  h0 B/ `2 f * @Description: 希尔排序
* @author: 牛哄哄的柯南
* @date: 2021-06-24 10:39
3 C, D5 }! S) `: z2 N */
. t' _( X: _) x# U2 epublic class ShellSort {

9 p( _, l/ M# m" o2 Q9 X+ v0 v" B2 |
4 ?: V8 `! T; t4 t2 f' ]7 a    public static void shellSort(int[] arr) {
1 O; p* ], |3 s* N, T        shellSort(arr,true);
+ d5 q1 G/ v. ~; _    }


    public static void shellSort(int[] arr,boolean ascending) {
% |. ]/ _6 j# A8 d  i" {
/ i' _2 B$ q6 Z. s8 M! J  ?
4 K0 X2 F/ @% Z% e        for(int d = arr.length/2;d>0;d/=2){


            for(int i=d;i< arr.length;i++){
" i* M4 \, |& ]0 k                int temp = arr;
- X- I  a- ^! q- a, i/ b. i) i& L                int j=0;
                for(j=i-d;j>=0&&(ascending?temp<arr[j]:temp>arr[j]);j-=d){
& l2 ]3 S7 F& \3 c1 T& Y                    arr[j+d]=arr[j];
6 m; e2 ]8 G0 T2 m- }* [                }
                arr[j+d] = temp;
            }
6 A+ O" J; C$ [; H8 w3 D) d9 h, x        }


. f4 }+ ?9 v! G* J7 c# I1 P    }
}
1
2
3
: q, K0 e+ B0 V) @! I: O4
5
4 G! T7 r' h+ Y6 _6
5 `8 ?% u& H! N/ }7
7 y  `3 ?0 C9 m- V" R' K" G8
  f7 x4 {; v5 Q9
; M' @$ B7 L9 S) Y9 I4 z5 ~10
" h# [8 @% A$ F11
12
13
14
15
16
3 y( Y7 }" T; E6 m0 ?: y4 V17
; j( \$ L7 D, ?18
! Z2 Z1 w, L8 B) z0 [/ H( W19
$ f3 u8 T4 j+ g5 }2 Q* |20
21
1 \5 E3 i& j, W. X7 ^: n5 N22
' p2 E3 ~' D6 _1 h+ \1 W) ~5 ^0 s0 S23
# o- v) k1 A" A24
25
; s) Z! K- `! ?6 q! }26
27
5 }3 c" `% n4 s. m8 E, B28
. b: r- f+ l6 a( K. ?) K+ U5 @29
30
' x& g* @3 H- f7 H* Z31
32
计数排序
; o, @! b  s/ U/ R" f  M简单解释：
" P1 `  q/ b0 p; \" j6 z& {- C' P这个排序算法看名字也很好理解，就是就是额外找个数组来计数，然后在这个数组从小到大或从大到小把数取出来即可。

4 B9 T- K% R+ |

; {6 w4 j& h8 V% N2 q0 n- f


完整代码：

2 d% Z! c7 I& S$ @' E: N
( f& M9 D' z7 \package com.keafmd.Sequence;
- _% k/ W. ?9 V# o" R1 ^/ G

7 Q; K* ?8 W$ D; J, T5 b/**
' ?$ i. r3 f' M2 p2 ]6 b# j * Keafmd
*
* @ClassName: CountSort
* @Description: 计数排序
+ x! r1 p, S* u* P5 t# }: ^ * @author: 牛哄哄的柯南
* @date: 2021-06-24 11:31
*/
; \( L7 g6 E  ]/ V. Ypublic class CountSort {


$ E* u8 J6 S/ l6 ]! Q5 i4 l    public static void countSort(int[]arr){
        countSort(arr,true);
+ m0 I; l+ H( W/ Z- n2 s+ `    }
4 C$ d7 T& }9 r

5 k$ b. H8 p3 }. D" a8 r: s    public static void countSort(int[]arr,boolean ascending){
        int d,min=arr[0],max=arr[0];


        //找出最大、最小值
! |, L0 H4 g: c$ H        for(int i=0;i< arr.length;i++){
            if(arr<min){
1 E2 M0 h! H$ c) |* ^& }! J                min =arr;
) d6 F/ s) e3 X5 G0 r( f            }
% X, x1 s1 g9 u* V( Q' V; n  ~            if(arr>max){
                max = arr;
            }
        }
+ A4 P4 t( g7 I$ Z* ]& k
+ I; N! k" J. [  i
        //建立一个用于计数的数组
        d = min;
        int[] count_map = new int[max-min+1];
        for(int i=0;i< arr.length;i++){
            count_map[arr-d]++;
        }


        int k =0;
2 Q; q; x9 P, e( \5 ]        if(ascending){
6 y; D) F% H5 V( n) g            for(int i=0;i< arr.length;){
( N; L1 M7 j/ }, ]/ o% j                if(count_map[k]>0){
                    arr = k+d;
4 `' [$ U; F5 H! q. E6 t" `                    i++;
                    count_map[k]--;
                }else
                    k++;
            }
        }else {
/ `. y6 V/ ?1 c7 E# B; q) `6 c            for(int i=arr.length-1;i>=0;){
, W/ P9 ~9 e; R; K2 i                if(count_map[k]>0){
                    arr = k+d;
' M& y+ a. p/ A* Z% N                    i--;
% j6 F: j* B  |, u2 J2 H, u4 R" p+ `                    count_map[k]--;
                }else
                    k++;
            }
        }


    }
" a: ^3 l1 e5 I! }& I7 a}
$ b  f( z$ J2 `- \8 o1 C1
2
3
. S% s/ C8 B; r- S' @3 A! @8 H4
5
6
: C0 P  E# ]1 R, Y7
& \  D) {/ _( r& J8
; P4 b& `' l* _0 y' S8 G9
9 R" g' B* G- G# l6 R& M6 ?& e$ |10
11
12
13
( r+ b5 O* f5 Y" \$ }' Q# S6 K" C4 k14
7 ?) f: D. Y/ X0 ?4 d, ]15
& l6 }8 H3 a) U, g6 w16
17
; ^2 M) q/ L4 ~( \( h# q! ?18
19
20
+ ?& k. Q" k! P; z. ]- C/ M21
, ?4 P9 @# @6 C9 d5 C. |22
23
24
$ y- d: M, i5 ?0 G3 V5 X25
26
27
28
29
4 p7 o, \1 R8 W9 h! n( c9 D) v30
" t9 [) G4 j4 {" g31
32
6 k2 z0 R. d) d- p! H33
$ z$ I  x" q  _: K1 Y34
35
36
) y! q6 {, G' Z- G/ c37
1 `' V9 s3 P" W& }5 J38
5 Z7 ?& k. R8 A39
  d2 N8 d" r+ ^; |' t1 M, A3 j40
41
- h3 f1 v' n9 x& K42
) `; S6 `( Q/ |1 E5 U( k6 i43
+ K# N' h3 N. Y& t44
  C1 G3 Q' T, n& X6 W$ E45
( j" {  ]7 j. w& @9 G. O46
9 t7 ^' v* r6 |  f* r! n47
- _% e; N9 k3 |( J5 s. G48
3 ~2 ?* V$ Z& L3 N+ y2 W49
50
51
; s9 u5 }2 J7 b8 A: x3 z52
# r( x3 s; u! K+ g53
54
55
56
* s' o' S6 p0 J4 k2 L. o9 o57
58
59
2 y* g" `9 g3 x$ N4 c桶排序
简单解释：
就是把一个数组分成几个桶（其实是几个区间，从小到大或从大到小的几个区间）装，然后让每个桶（区间）有序，然后取出来放一起就可以了，相当于把几个有序的段拿出来放一起，自然还是有序的，当然需要是按照区间的顺序拿了。
% ?$ Y: R# b& X5 l. Q" Y
- O4 |6 d3 ]. I



* j3 Y, h' @; f0 |$ r
完整代码：


package com.keafmd.Sequence;

5 z4 \* Z% Z; X& l. d$ }
# x7 r) o6 @8 c5 Cimport java.util.ArrayList;
import java.util.Collections;
* j3 M4 B0 Y% ]
* Q  J0 Y8 y' u; M/ X/ H
/**
* Keafmd
) T5 `  W8 Z0 o' C' W *
4 W: s$ v* l+ R* i; p6 w; R/ i * @ClassName: BucketSort
2 e$ F1 R7 b- t * @Description: 桶排序
* @author: 牛哄哄的柯南
, ]7 l- N; g0 c) E7 \ * @date: 2021-06-24 13:32
*/
- b5 i  L. _" g- k8 y3 ppublic class BucketSort {
/ K' X& @# b( K7 D5 s. K1 @
0 H( l% p( i2 e) e" k& I' S
+ O/ D$ b5 q" d    public static void bucketSort(int[] arr){
7 o- L+ X; K8 O' u+ }        bucketSort(arr,true);
    }
% H7 U7 k& ~% t

    public static void bucketSort(int[] arr,boolean ascending){
% A0 Q8 P: l- X        if(arr==null||arr.length==0){
            return;
        }
        //计算最大值与最小值
, o/ f8 v1 p6 ^+ p: _' E* x4 n        int max = Integer.MIN_VALUE;
        int min = Integer.MAX_VALUE;
  H& n, Z7 ]# ^        for(int i=0;i<arr.length;i++){
  m1 ?, j0 h! j            max = Math.max(arr,max);
            min = Math.min(arr,min);
4 t9 D! G' ?" s' l+ p        }
! O2 {& E6 ~1 ?: j2 I# Y1 N
" q8 w4 k8 L! w2 o8 D1 P& u* N" D0 w
# Z3 V( f' ~) [        //计算桶的数量
        int bucketNUm = (max-min)/ arr.length+1;
        ArrayList<ArrayList<Integer>> bucketArr = new ArrayList<>(bucketNUm);
. y' @7 E& ]* @2 [. K, {0 D  W        for(int i=0;i<bucketNUm;i++){
            bucketArr.add(new ArrayList<>());
        }

- }3 w4 N9 E. y" Q. O& Y- G: a
1 M; E" V2 ~& i4 }: K0 q        //将每个元素放入桶中
        for(int i=0;i<arr.length;i++){
            int num = (arr-min)/ (arr.length);
            bucketArr.get(num).add(arr);
0 w7 V8 }* t5 U/ ]) O8 {        }


        //对每个桶进行排序
        for (int i = 0; i < bucketArr.size(); i++) {
            //用系统的排序，速度肯定没话说
            Collections.sort(bucketArr.get(i));
        }
# h; `: W1 `: d% L$ V8 W
: g1 g- F. g  d& E4 B6 }0 M
        //将桶中元素赋值到原序列
        int index;
        if(ascending){
1 ?: \, h' A  {9 @* {! ^7 S            index=0;
        }else{
( b/ q8 Z. B. S0 Z, x; N: W            index=arr.length-1;
% u1 i8 V" h9 K6 }* t# x        }

  q- d( a, b. m% p2 O6 h! Y$ z
        for(int i=0;i<bucketArr.size();i++){
( ?/ R7 J  a9 w. y+ m! w3 n            for(int j= 0;j<bucketArr.get(i).size();j++){
2 }5 h& t, ]8 R- F% W  t3 u                arr[index] = bucketArr.get(i).get(j);
                if(ascending){
7 S8 @1 |* N( C! i                    index++;
                }else{
/ f2 r( I. N9 I2 O' t6 W5 y2 ]0 K# k                    index--;
5 b' T* D2 f' ~8 x# P                }
            }
- N% L+ h9 C+ \/ R" i# k: {5 l

        }
: [: ^- o8 u  G4 u0 x; J& f0 Z

    }
+ L4 y' f, K+ @) L}
: J# Y1 f. E* W$ h! ?7 O; Q) h1
: z0 H& ], ]7 K+ p+ ?2
* N6 v8 s  }) e# h8 h3
4
, Z% h, c9 b; z0 \4 S7 D; s5
6
8 D/ n% a" t+ N1 Y/ k+ L7
8
0 r0 [5 m, O& }  R6 ^9
10
& x2 V! i; \8 h& e( @; _11
12
13
* j1 q1 D! P' O14
15
2 b& m/ j! I% `: b) ]# s16
+ h" W' M- J6 r# U7 y: ^; n6 _17
7 d) r7 e/ u0 e! d( h' h18
19
4 o1 ^7 p& ?2 w9 N+ `20
0 f1 ~0 v# }, `7 A5 d7 l+ r21
22
& @8 u, A! x0 r23
$ U) {9 Y2 f  M) i24
4 C& b/ f/ ?5 V# s3 Q25
26
27
% Z# W* O, z4 f9 d28
29
30
+ m1 T$ W' t; q+ \( b% c" I3 p' s31
% G: y0 `# {8 N" O32
33
34
5 J" U& K( M' e' n5 G: N* u35
. s, b' `! \4 r0 d1 o36
37
38
39
40
% L1 s- A: _9 R* k- [0 K41
& N! W  P- E$ H# }42
# ~) p% n7 t; a+ N% L$ k43
44
45
1 x  C& Z4 A! q& z. r46
47
! y- w1 L' M  P48
49
50
, b) i3 G% ~- j% t  Y51
52
53
54
: E8 A( e4 j% x: ?6 v6 \. D5 q9 Z/ R55
56
) j% |+ X4 e7 S# @2 g* k" j- W; x57
58
59
60
, Q# M1 u  |! o' X61
6 R5 r- x: r/ X9 U8 u" j9 z+ g" ~62
/ m( f9 B# j1 G3 |0 B63
3 D8 r; J6 M0 u$ X1 Z  y: r- q! G64
65
4 V: i5 @7 ]. N4 h. G9 {4 j$ y9 `66
& i0 Q, ?! F0 a: _3 O% I67
68
69
- |) W" {3 c# V! g  W( W7 C70
( c3 b' g7 D9 A( w, v+ [& W( ]71
72
8 H  a6 {& M7 d: U; ~. X, q- M4 Z基数排序
! P7 H/ b1 a1 l: d0 r( I) M: g+ }简单解释：
5 x5 u0 L9 X: N" P. \4 Q8 G+ A首先说一下，我发现好多人写的基数排序只能排序正整数，其实只要处理下就可以排序含有负数的了，就是我们排序前先把所有的数整体变大（就是减上最小的负数，也就是加了），都变成正数，然后排序好之后，在减下来（加上最小的负数，也就减了）就好了。
基数排序就是按数位排序可分为LSD（从最低位[也就是个位]开始排序）和MSD（从最高位开始排序），下面写的事LSD基数排序。
基数排序就是把数按位考虑，让后我们一位数只能是[0，9]，就是我们在考虑某位（个位、百位· · ·）的时候就只看这个位的数，放到在[0，9]相应的位置，然后顺序取出，最后再按其它位这样操作（上面说了要不从低位开始到高位，要不就是从高位到低位）
4 M3 ?5 X/ T; m3 Y- |: h$ y# `




. y# F+ H3 G& p! H$ j4 f
完整代码：
7 k6 x, _: Z. Q. h  ]$ `1 Q

package com.keafmd.Sequence;
6 D0 J& b- o4 m4 Y: |/ Y. q
# C" z" o% d" L4 P; C
# O! J( g! M1 B& @- c/**
5 N$ `+ j; G( b, l* C% s! I1 H * Keafmd
*
# O% V) N( S3 A * @ClassName: RadixSort
* @Description: 基数排序
* @author: 牛哄哄的柯南
) @: T  n3 V0 c0 k( ?% } * @date: 2021-06-24 14:32
! {1 k: p5 M# Y8 H. ] */
' R# l5 b& }" B+ Mpublic class RadixSort {
    public static void radixSort(int[] arr){
        radixSort(arr,true);
    }
    public static void radixSort(int[]arr,boolean ascending){
  A4 V0 G0 w) @: Z6 Z0 i1 u# f4 a9 w# W        int max = Integer.MIN_VALUE;
        int min = Integer.MAX_VALUE;
! G0 k  c1 B% i+ ~/ f, y8 |        //求出最大值、最小值
  F5 L" l) r8 ^        for (int i = 0; i < arr.length; i++) {
            max = Math.max(max, arr);
& R; i2 E6 }& g% y# S            min = Math.min(min, arr);
) H- P! D4 R$ j" {& U        }
2 P% \  D9 C5 a; r# R  j        if (min<0) {        //如果最小值小于0，那么把每个数都减去最小值，这样可以保证最小的数是0
1 s: t: m% ~$ v1 |6 W# T            for (int i = 0; i < arr.length; i++) {
                arr -= min;
; Q% p7 h2 c% a+ J' W            }
% ?. p9 _3 K; T            max -= min; //max也要处理！
, C* ^5 x) ^6 w( d( \% w5 R+ J0 `        }
        //很巧妙求出最大的数有多少位
+ @! T  x- h' G8 o# F) u- A6 b        int maxLength = (max+"").length();
" l" Z# Y' H2 [" ]        int[][] bucket = new int[10][arr.length]; //一个二维数组，一维代表0到9，二维存放符合数
        int[] bucketElementCount = new int[10]; // 用于记录0到9某位存在数字的个数
6 Q! b' C' m6 H" _, e( d0 M/ g4 n        for (int i = 0 ,n = 1 ; i < maxLength ; i++,n*=10) { //个位 十位 百位 这样遍历
            for (int j = 0; j < arr.length ; j++) {
6 b1 Z" |" ^# \: g/ F                int value = arr[j]/n % 10;
                bucket[value][bucketElementCount[value]] = arr[j];
                bucketElementCount[value]++;
* O8 ?2 B8 G, O$ d            }


            //升序
            if(ascending) {
2 Q9 z9 f1 `: [; x% u) b                int index = 0;
                //从左到右，从下到上取出每个数
                for (int j = 0; j < bucketElementCount.length; j++) {
                    if (bucketElementCount[j] != 0) {
                        for (int k = 0; k < bucketElementCount[j]; k++) {
                            arr[index] = bucket[j][k];
& s  \+ Y# e& h                            index++;
4 z4 Q# {: `4 n7 q* G$ F+ j+ t                        }
- W% d( `. A& [. j' e/ R2 n5 U                    }
                    bucketElementCount[j] = 0;
                }
            }else { // 降序
                int index=0;
                //从右到左，从下到上取出每个数
, K  F' \6 K$ E& h( u                for (int j = bucketElementCount.length-1; j >=0; j--) {
- n' y2 c' F. E( x- D                    if (bucketElementCount[j] != 0) {
3 |! a) V( I9 i; [; v                        for (int k = 0; k <bucketElementCount[j]; k++) {
                            arr[index] = bucket[j][k];
6 s- V( ?5 [  h: s1 k2 G! w                            index++;
                        }
                    }
, w6 i7 g9 D3 E7 J+ m                    bucketElementCount[j] = 0;
/ s7 `" N+ t& l                }
- b5 a5 q8 ]  r$ @4 _# N9 k: k            }



  Z% W7 ~- o! D( l+ O# T6 T
            /*for (int i1 = 0; i1 < arr.length; i1++) {
& s! b. Z1 P, S8 ~                System.out.print(arr[i1]+" ");
: Z" S4 j4 F6 ^3 q9 q            }
, c1 G' z/ R& |6 R3 z% P1 `            System.out.println();*/
6 l  h; v! p4 K* m5 \0 ?

. J3 c+ Y4 G6 e/ j! @* ^, T- U

* J" Q0 f( L0 K, E

        }
        if (min<0){
            for (int i = 0; i < arr.length ; i++) {
$ ?/ s- H+ S1 a) P* H                arr += min;
! A# }/ i% H. Z" d  [            }
        }

/ ?5 ~% X. O; w& E( ]: O
    }
4 M) h  I5 d# f7 s' [}
$ y: {6 q  O6 S- t1
8 w8 e0 h3 r5 H0 l" B7 s# Y2
8 K- d. A- M7 E& g: d3 O" G3
4
: n3 j$ X6 \( F  P5 d5
% M0 w, Z/ k  _9 t) K( P8 }) s6
' A0 g8 J" \7 u/ W) H" h9 g7 t7
8
9
10
2 U" L( {2 b6 N8 ?. }- u7 Z11
12
7 ^7 p" S8 J+ z6 Z4 A" f$ u/ Z" g13
14
15
9 s5 ~1 k6 ~7 M5 n) p16
17
18
19
: X% ?# r1 g. t. Y0 [20
21
# a% y' K5 A: R: i9 {22
23
24
25
  H3 Z! W8 L1 b3 Q! C26
27
8 b" F! L0 n' O' _28
3 D# B( {+ T8 D/ y4 R! d0 M5 Q29
, j7 v4 M' K8 u( d- B: }30
1 Z, h; s: |6 i/ J+ j8 N3 b' f31
32
  C# X8 y3 V2 v33
34
35
36
( F' O& v. M, f) C1 q8 y37
38
39
40
5 z& \3 G8 p  J5 X) |* g  V41
42
43
( g, S' F4 ~9 f" V# M  o) R44
45
46
47
8 w) A; I  m6 N& l7 R9 z! w7 Y* a3 ^48
49
50
51
3 h9 v4 ~8 G$ J, g$ m52
- r! |0 ~; Q2 X2 P3 B+ X  c53
54
! K$ D7 Q3 X  j55
% ~0 P/ u: |1 C- {/ P) Y56
" @& X* F4 S4 m8 o$ p57
58
59
) E/ c3 z% T5 X$ ?60
61
62
& X! e' @7 E: T* t/ ^0 m63
64
# |% W1 x' p5 o& ?, ]5 Y65
0 P" Z- D6 [, c! N8 M/ y66
67
7 s' F$ w5 r4 u0 t68
69
70
# _0 {6 s! t- X& H) ~71
; v- d; r# H- c/ |8 Q7 i72
73
6 r3 D# W+ f+ c9 [+ q/ d3 N  c74
: A+ o) I. J# S' F75
76
77
# E3 A6 g' _1 a! C* R78
. g5 T8 F8 W: a79
5 @: Y8 G# j" C6 u, O, ?7 k: [: [80
4 f& U% j$ g4 b3 A; {! ^3 f81
% k5 p5 q" D4 h/ \7 _82
* v! P" r) U* M5 B* u3 k/ {/ X83
完整测试类
package com.keafmd.Sequence;

' _7 J* @# K9 A6 d5 Y& j1 J
import java.util.*;
import java.util.stream.IntStream;
* O8 w8 L1 |# {; [2 I1 P) _& M% Ximport java.util.stream.Stream;


2 Y* e8 C, b3 I  {4 g7 x/**
- |% {! h9 i( q; c: N * Keafmd
5 ~$ h/ T$ {( u; z3 ^ *
* @ClassName: Sort
* @Description: 十大排序算法测试类
* @author: 牛哄哄的柯南
* @date: 2021-06-16 21:27
*/
public class Sort {



7 L  d; k- a/ z. i$ w, J
2 Y+ }7 [3 I  Y1 t6 ~- X" y8 k    public static void main(String[] args) {
) o; i: N8 c. i/ G8 ]/ T8 C/ T
" R+ Y+ s$ p6 }2 y$ W8 t: R! e
/ t- ?" X6 Q; ^# C! R        int[] nums = {12, 4, 25, 47, 58, 34, 25, 9, 99, 26, 1, -13, 162, 10093, -66, -1};
, F+ F9 Z" ?- m2 ]+ g% H+ L' J8 P. L0 k//        int[] nums = {12, 43,56,42,26,11};
        int[] temparr;


) b. M$ z! u( _        //利用系统Collections.sort方法进行对比

- z! y/ s# y$ f4 D% g3 A
        //将int数组转换为Integer数组
        //1、先将int数组转换为数值流
        temparr = nums.clone();
        IntStream stream = Arrays.stream(temparr);
; x. i4 Q  D# T9 M6 y& T* y        //2、流中的元素全部装箱，转换为流 ---->int转为Integer
        Stream<Integer> integerStream = stream.boxed();
6 f# v8 U) c0 N2 k; Y3 P$ y0 G        //3、将流转换为数组
        Integer[] integers = integerStream.toArray(Integer[]::new);
        //把数组转为List
        List<Integer> tempList = new ArrayList<>(Arrays.asList(integers));
3 ?% N; h) l4 r& T" X        //使用Collections.sort()排序
4 Y) V, H( {! }4 H$ j- f, U, J        System.out.println("使用系统的Collections.sort()的对比:");


        //Collections.sort
        Collections.sort(tempList, new Comparator<Integer>() {
            @Override
            public int compare(Integer o1, Integer o2) {
                return o1-o2;
                //return o2-o1;
$ U8 P: b1 H2 r* o1 x( ]/ N) y            }
        });
1 U# }: S+ o9 P; r
% B/ p" w% A/ q
8 u( P, A- Q; H/ Z' M, t        //tempList.sort 也可以排序
       /* tempList.sort(new Comparator<Integer>() {
% @0 S! n, a3 K1 _3 \! k8 e            @Override
% S; x5 Z* R/ Y- W            public int compare(Integer o1, Integer o2) {
- U0 @' c: K, c  T4 z- F4 v7 c0 m                //return o1-o2;
                return o2-o1;
$ q5 p: |( Y; x6 n6 T9 Y) l. I            }
        });*/

9 p1 J* u! w; L3 i7 Y; k) B! m9 W
        //遍历输出结果
        for (Integer integer : tempList) {
- |5 I$ O9 L3 v3 p+ ?( r            System.out.print(integer+" ");
        }

7 i- O6 k/ e9 i5 r. S+ I
        System.out.println();
0 J7 a$ Y! c5 ~
2 V# K. h8 ]) _% |- j( P
        //测试冒泡排序
        System.out.println("测试冒泡排序:");
        temparr = nums.clone();
. X( N) @% a7 _2 T( |- R
! m9 g9 y* ^) q2 [  U" `# a- J
4 n8 a. h* g* Q3 ~        BubbleSort.bubbleSort(temparr);


% E4 P6 S4 }- E! g        //降序
1 C& d: Y/ f  i% \# W6 A; \        //BubbleSort.bubbleSort(temparr,false);

' G# M! T$ i4 Z8 w
        for (int i = 0; i < temparr.length; i++) {
            System.out.print(temparr + " ");
        }
        System.out.println();
6 d8 s$ B2 c+ ~6 \2 }

        //测试快速排序
4 ?2 S& {4 h# ]" D/ r6 }$ |$ m0 b" D; s        System.out.println("测试快速排序:");
5 A  G/ ~9 A7 X4 s- O* i        temparr = nums.clone();
! `0 G6 R; ?2 ?  U1 p5 H( R# f        QuickSort.quickSort(temparr);
        //QuickSort.quickSort(temparr,false);
* J" \8 s( \9 H        for (int i = 0; i < temparr.length; i++) {
            System.out.print(temparr + " ");
( p/ t" \: Z& F7 W& k- J        }
        System.out.println();


) E/ e( _! ?6 c9 p        //测试直接选择排序
) D$ ]3 W% {" F3 L5 {9 j, @9 I        System.out.println("测试直接选择排序:");
        temparr = nums.clone();
        SelectSort.selectSort(temparr);
- }4 v) d; a! Q5 J  X' f4 }' Y        //SelectSort.selectSort(temparr,false);
% F( ~9 @) v  f9 M        for (int i = 0; i < temparr.length; i++) {
) Q- ]7 d, J2 h2 j            System.out.print(temparr + " ");
/ [; O: |: O% y        }
, G( j; ]+ a, i* o) W8 V8 @        System.out.println();
8 `' O# M& g% e# w4 O
8 x# I# j. Y* U" q
* G5 u+ r  J( @. Z) W3 y        //测试堆排序
        System.out.println("测试堆排序:");
! n  `8 d9 h% M) A# P' }8 Z        temparr = nums.clone();
        HeapSort.heapSort(temparr);
5 y7 z' D  }' F& g  s        //HeapSort.heapSort(temparr,false);
% P- k3 c, _. H# R        for (int i = 0; i < temparr.length; i++) {
            System.out.print(temparr + " ");
        }
: z  G1 X7 |+ h$ _. W        System.out.println();


        //测试归并排序
0 X3 f6 U* C6 R+ h+ S        System.out.println("测试归并排序:");
        temparr = nums.clone();
3 ?1 n% d$ o7 `$ _3 }& r        MergeSort.mergeSort(temparr);
) S# t6 l" H. k% O% m        //MergeSort.mergeSort(temparr,false);
; g; z2 {) |+ |/ |+ G4 b4 X        for (int i = 0; i < temparr.length; i++) {
            System.out.print(temparr + " ");
        }
& @- T+ q- R8 E; o2 T3 R' I) S        System.out.println();


; {# X* D5 r8 N( \- F4 C. {/ d# a        //测试插入排序
6 w# L+ L  ^) G. A8 u( K5 s        System.out.println("测试插入排序:");
        temparr = nums.clone();
2 v9 k/ i3 d' d3 I& ]' b( W( ~; ?& Q        StraghtInsertSort.straghtInsertSort(temparr);
        //StraghtInsertSort.straghtInsertSort(temparr,false);
* O- r, ]' ~' [) N% V        for (int i = 0; i < temparr.length; i++) {
! b7 S5 E& ^" H, r5 b! n& `            System.out.print(temparr + " ");
        }
: w3 M' r1 F: w        System.out.println();


6 V! w0 g, O; M' q1 n

0 e7 T* M$ R" D2 ]3 C; Y& U        //测试希尔排序
        System.out.println("测试希尔排序:");
        temparr = nums.clone();
        ShellSort.shellSort(temparr);
        //ShellSort.shellSort(temparr,false);
        for (int i = 0; i < temparr.length; i++) {
            System.out.print(temparr + " ");
, g4 q3 [/ B. v        }
        System.out.println();

6 \: K$ f4 G7 B: C2 w0 O
8 u( P+ h7 e) D& u9 Y' W5 ?

        //测试计数排序
        System.out.println("测试计数排序:");
* G1 _# D( U# R0 `( |9 q1 M, p% e        temparr = nums.clone();
        CountSort.countSort(temparr);
        //CountSort.countSort(temparr,false);
        for (int i = 0; i < temparr.length; i++) {
            System.out.print(temparr + " ");
        }
        System.out.println();
. Y& `9 U6 K% t
' n( u4 Y/ Z" p# ?: t! h* S
8 L5 r$ |5 b/ p2 }; [. J
4 X: }" r: H, ?' ~
. Z2 X2 I# I: R- d        //测试桶排序
        System.out.println("测试桶排序:");
# x' v- E9 E3 e' z3 D' X2 W: o        temparr = nums.clone();
9 }3 C3 t/ ~  ?* q# v        BucketSort.bucketSort(temparr);
        //BucketSort.bucketSort(temparr,false);
* n' P1 M! a; _7 A  D        for (int i = 0; i < temparr.length; i++) {
            System.out.print(temparr + " ");
. A8 q  B/ w# Y( ?! ?  J        }
        System.out.println();
. u+ O" A: _1 m

        //测试基数排序
. {* G% ]( J- }6 r+ r" J        System.out.println("测试基数排序:");
        temparr = nums.clone();
        RadixSort.radixSort(temparr);
2 Y% y2 ?% k: K3 `; v        //RadixSort.radixSort(temparr,false);
7 N7 O* x; r/ D# d# T& _        for (int i = 0; i < temparr.length; i++) {
8 V# c' ]' H8 o0 l            System.out.print(temparr + " ");
+ _+ f! P1 E' E% E        }
        System.out.println();
$ V. \* t/ t6 |  S2 h7 o( N
  }) {" c1 f( Z) L5 r3 H, O2 _
    }

, r9 P( y# B, m5 i5 }$ f! `  n
( w# S, B8 ?0 C8 o) j4 M}
( X- s2 m5 ^( v$ c9 m1
' q7 o2 W9 I4 q7 ~4 c2
* y1 N! X* b8 ~# E. \1 h1 X3
4
2 S9 J+ u, A: r! i+ s/ g8 G" S5
. U0 j. T% T6 y) |+ ]4 L6
" E% ]" \* j- T. S+ b( q* ?9 Y3 Z( U- u7
3 r5 x, K% V8 ^6 e- A  P: T  X8
9
10
% O2 j3 H% S4 K/ P- }5 D6 G11
( H. T$ C2 [( `7 _2 h* ^12
13
14
15
$ }4 q) A2 \/ v# f8 C. \3 n0 m( s16
! K( a+ q) ], O% P17
' z7 r" }7 t4 X' w5 K1 t. n$ Z18
& W( a7 m3 g# ~# S) p8 Q19
20
21
4 q0 c  `* l' ^7 B22
23
# w, |' |- G6 b9 d) C9 C& T" [24
" I# k" K# T! x25
$ j$ {$ V# {: ?2 u: J26
! B7 L, L9 L4 f9 M* L6 V27
28
29
30
31
32
33
8 l0 Y- \- K: H) m. F34
- a/ u% O( i+ u; g- G35
36
1 {" E* ^& m% e; A( n0 y) ?7 N37
  U' t- z) @* a: m0 Q! S3 a38
1 h* l7 K2 w3 U$ k: E$ D39
40
: W+ H! ?% y6 K* r( X41
4 S' J# e  P6 T6 K! p$ V42
43
44
45
) |+ l- L& L  Z/ C8 V+ R( O46
47
48
& O# C) E% n+ {* U6 t  x# w49
50
51
52
53
# B' K- g1 N) R& o( {5 o54
55
56
57
58
& M3 R( z4 p9 s! D" P59
60
61
$ Q% a+ V* {# x62
8 D- g/ @( t1 y6 O, D4 m, S63
: d# p2 T* I2 ], _64
  H% _" y9 L; s& g0 a. u65
66
0 z' [5 k2 F4 p) s2 A67
0 Y/ n# b2 M" `: y- w. ^$ l68
! j5 z5 w* E% j# g69
70
( O6 Y: J6 W! T( K3 z71
72
3 b( C# P* ]* a3 T- G73
74
75
# J' ?0 g4 s) O76
3 e4 C; \% ]/ Z% v1 y/ D. ]77
78
) }/ F. j9 H0 K2 s79
80
& o) s# L8 i. `7 r. V0 i3 I81
8 R0 `- u/ G- x- G6 X9 i82
  {9 k6 u7 D4 d8 W4 ~) l3 G83
84
85
86
87
88
' Z& M! d1 B" D$ e* S" }4 W89
90
2 G& e" d/ S* ]91
- N2 g  M- k, X# O* n0 }8 O) I! ?1 G92
( X, S4 k* z: X93
94
95
96
3 a% a( y% H- q: s. y, K97
98
99
$ `5 I+ \9 Q/ e8 P) p/ q100
101
102
103
104
( J4 W. A1 V8 ]( V' z# [105
* h' X: X4 Z# M9 C& J5 ]106
6 {8 p$ x' u6 g! ~, [  F8 W, a107
108
. q3 o1 S0 V, ~' {! ]109
110
111
8 S' h2 R3 D* X6 I5 W' }112
113
' s; e: k0 q: b$ K. ?: g! o' u114
7 j, B9 z! R7 z: E; x; Y6 u115
" H4 K7 _- }* s  S, B2 B116
117
% t, y9 t- Z# x1 q2 K# Q* y* G. w: h6 K118
119
; O8 v4 ^& h% r120
121
122
123
0 A7 D8 Y; t8 T4 l4 B. I7 m& J% \9 [124
" q3 y) E9 B1 I, B: N# L* [125
126
: r* \8 X& `2 }6 O( U! z6 p! Y$ ]' U127
9 d# U* ~8 \, e1 t128
129
130
131
132
( `4 s7 O: o% _9 h/ e133
/ _0 ?6 V6 }) f9 l( X* t9 J134
+ Y- I# j! p" k: \135
136
% N! y# R: q/ k137
138
  [! m- Z( u: J5 K139
: w3 P$ }% Y, Y: j3 s( A140
8 n+ ?  p  d" w# @2 o2 ~141
4 a! N3 z/ l& O/ O( x- c: _0 I142
143
/ m5 N# E# c4 J. O9 u' _& z144
5 H( \5 s6 Y* `, P$ m' P5 w/ i145
2 a/ `; v' u% S1 m) W' j- I; v9 ]146
147
: ]# n& y1 W$ J7 F* ?; Y148
, i$ O% A; U  M- l4 N149
150
151
! t; s& w- n: H7 `7 [! I5 g# G152
4 F- r' Q, f: C) v. E" n: [. G" H153
154
+ p) k2 Y+ j4 e" D+ G155
156
3 S. k* D* I0 M  W# U$ `157
158
+ s; w4 R. T2 P$ u. m; P159
0 i5 O$ y! A. l5 @' e- J# ?160
161
162
3 [" F; Z  w1 p/ H- P/ J6 M163
164
165
! A* z3 ]- E7 ]+ v166
3 T% ^/ o' g- y, P: ^167
168
169
170
& d/ D# C9 _4 m( Z* J6 ?  D! M171
172
173
每天进步一点点！
不进则退！


版权声明：
原创博主：牛哄哄的柯南
  q8 B5 q2 F1 ~/ Q博主原文链接：https://keafmd.blog.csdn.net/
* S6 P+ K9 _6 _# {  E————————————————
2 {5 l4 H; p9 g: \( h版权声明：本文为CSDN博主「牛哄哄的柯南」的原创文章，遵循CC 4.0 BY-SA版权协议，转载请附上原文出处链接及本声明。
1 ?/ o6 l$ C/ V) C! Q8 J, ]原文链接：https://blog.csdn.net/weixin_43883917/article/details/118193663
; r3 z" Y& o1 n  _
3 |8 P# ?; k+ x* K/ R, p3 c
/ F1 u4 ]9 s' \* D

1051373629

每天进步一点点！
, n- B: S- Q! w) V4 T6 p6 H