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

杨利霞

经典十大排序算法（含升序降序，基数排序含负数排序）【Java版完整代码】【建议收藏系列】
- u% D$ O! S# E# P+ s经典十大排序算法【Java版完整代码】
写在前面的话
十大排序算法对比
) ?5 S  p1 |- C& c/ d+ h& ~冒泡排序
快速排序
2 w! l' S5 W: x直接选择排序
: T4 f6 j6 F7 Y9 X" J堆排序
" ~; Y% @4 r2 B# R8 E归并排序
7 _/ Y% A% g, e! \  l插入排序
, V4 u4 n6 _# B1 [0 N& Y- \希尔排序
计数排序
/ b$ g0 R0 q9 r; i; l5 I桶排序
基数排序
5 h* b  ?! E$ \完整测试类
2 k4 E! P* O  E" t# ^0 L写在前面的话
       虽然已经有很多人总结过这十大排序算法，优秀的文章也不少，但是Java完整版的好像不多，还存在某些文章代码存在错误的情况，同时也为了自己练手，决定把所有的写一遍巩固下，同时也真诚的希望阅读到这篇文章的小伙伴们可以自己去从头敲一遍，不要粘贴复制！希望我的文章对你有所帮助，每天进步一点点！！！
2 K. j+ V) K* M5 M
& n: D- g( {' z- g* e, t; |
       我用通俗的理解写下对算法的解释，对某个算法的运行过程不是很理解的话或者想看比较官方的解释的话，单独搜索某个算法，看几篇不同的解释，就可以有自己的理解了，这里我主要展示代码以及进行通俗的解释！整起来，再强调一次，一定要自己敲一遍，这样才能理解的更深刻！
4 L% N4 `: N9 I

十大排序算法对比




# r0 E* t$ h; K$ w! n+ L  T. D0 P关于最后一列的稳定性，我稍微解释下，例如对序列：1 2 4 2 6 排序，序列中存在两个2，如果我们把这两个2标记上（让他俩不同），排序之后，前面的2还在前面，那么就称这种排序是稳定的，反之不稳定。


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



4 }* J; y/ u4 N+ k+ E9 I

# Q5 X1 R2 ]8 R% d
本文的图片来源网络，仅用于大家学习，侵权联系删除！（下同）
( j7 E6 Z0 C; f. I

完整代码：

% Q; f3 v& A. U
" F4 V' }& ~5 b8 w$ spackage com.keafmd.Sequence;
& J9 r/ L0 n5 n% _9 b" P: |# Z* t
+ b( x5 H, k5 f
/**
* Keafmd
8 c# _3 }/ G: t *
* @ClassName: BubbleSort
$ i$ u) s9 A5 D6 S4 x * @Description: 冒泡排序
* @author: 牛哄哄的柯南
  N, E# E5 p, z1 z+ c7 W5 I  m * @date: 2021-06-24 10:31
*/
public class BubbleSort {

3 Z2 L* h$ Y9 F* m; _
    //冒泡排序
" W! U( C+ k1 E  m    public static void bubbleSort(int[] arr, boolean ascending) { //exchange标志表示为升序排序还是降序排序


# |( j# d+ N$ `) U' t        boolean flag = true; //加一个标志位，记录上一次是否发生了交换，如果是，我们则进行下一轮，如果没有，说明已经冒泡好了
3 w1 p. U8 H/ T) |# @, M7 n' g

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

            /*System.out.print("第"+i+"次遍历：");
4 d0 Y( T( }: w& [            for (int i1 : arr) {
                System.out.print(i1+" ");
! Y4 v: T, x& m7 U            }
            System.out.println();*/

5 l7 l' E; r# U2 q, ^
            flag = false; //假定未交换
+ i  y" `5 P: ?

            for (int j = 0; j < arr.length - i; j++) {
; r+ Z+ _3 y. O$ g9 l4 {" N( ~( L

                if (ascending ? arr[j] > arr[j + 1] : arr[j] < arr[j + 1]) { //控制升序还是降序
9 i- s7 n( L. {8 C+ a5 u9 F8 Z/ A                    int temp = arr[j];
                    arr[j] = arr[j + 1];
, H5 L% @8 n0 s7 C9 b1 ]1 j1 t                    arr[j + 1] = temp;
                    flag = true;
                }
& o6 @+ _/ j+ D
4 a4 D+ k+ a1 c4 |" @, A4 s, w" u
4 j- J2 o6 H- q/ ^/ w- E4 z            }
        }
    }

' s; H2 |) d8 \4 O! b& H
# y0 l3 F5 F: ]    //冒泡排序 -- 默认不传参升序
# n8 d0 ]# |2 [* j* W    public static void bubbleSort(int[] arr) {
5 Q- S6 O2 q8 C$ Q        bubbleSort(arr, true);
7 Q4 R! N6 o6 t; F7 M% ?3 C    }
& o# y# A$ s1 E" Z0 p}
1
2
: Z- m( Z% w) A, O. w: z3
# A6 n% L' K1 B" y  M! K4
5 b: a6 L& L& d. F! Y# M5
6
7
8 y- n/ s% j, `* |4 r0 V* o8
9
10
11
7 [, {" M# s& x, p6 d* c12
13
3 [. n/ Y0 j% d. F" x14
& }) R4 Y( p2 ~! T" W( Y0 H" a! U+ c15
16
17
1 c" i% K6 J7 o# a18
19
, x8 R+ o. o8 U; z7 a/ F20
3 i( o) ]+ {* l: c$ D: B: |21
% [! O7 P& u7 r4 W, ?0 y22
, d- ]# w. k% x( Q23
8 O- C; Q; Q9 @* j5 u24
/ q! }9 R) }( l! j+ X25
26
" H' ~4 w' i- k$ B) Q27
) w0 K$ E( B* m28
8 i- u% G0 q) H3 a1 v5 \+ d' ^29
5 n4 e+ l; K3 l: N! N0 a& F30
# Z% n3 s) |$ f7 s. K, C# v$ _31
3 V9 w8 M' H/ q) M" k' c- E32
33
9 L2 a" s7 X/ A) J6 {34
35
, P/ s' L2 k9 l. E1 {" @36
/ K& Y5 q; _  S0 g' G3 o0 J37
* [$ {( x& l+ H38
39
40
& \/ f$ P. `0 c. s1 |1 i9 L3 f& i8 b41
42
43
44
45
: C! k4 m" b: M, x1 M  |测试代码：

+ W4 N( U+ \" H. K+ [3 b
升序排序（从小到大）
  \! q" R  L" I; y0 g: _6 m

! J, D1 m7 [3 _0 \7 Rpackage com.keafmd.Sequence;
; R3 Q% F/ Z- ~' N; \

import java.util.*;
) M& g0 N. \# C) |* qimport java.util.stream.IntStream;
import java.util.stream.Stream;


/**
; S  Y1 c" Z% E( Q( E7 ` * Keafmd
4 e1 B2 `, |' Y  K* D( Y *
* @ClassName: Sort
* @Description: 十大排序算法
0 s# U/ `5 A2 q! Y8 w * @author: 牛哄哄的柯南
* P/ c% w4 g) x' Q) x * @date: 2021-06-16 21:27
*/
public class Sort {
    public static void main(String[] args) {
3 J0 W; A8 B; ?" n- d5 {) a( {

        int[] nums = {12, 4, 25, 47, 58, 34, 25, 9, 99, 26, 1, -13, 162, 10093, -66, -1};
. z/ v5 K, J1 c. A  P        int[] temparr;


        //测试冒泡排序
4 M1 {. F6 b4 i        System.out.println("测试冒泡排序:");
        temparr = nums.clone();
$ b' @% _: x+ z        BubbleSort.bubbleSort(temparr);
        //逆序排序
% L1 d" o  Y' a$ }3 a: m" g4 o        //BubbleSort.bubbleSort(temparr,false);
6 w: |& {) E+ r% ^        for (int i = 0; i < temparr.length; i++) {
            System.out.print(temparr + " ");
0 V" ?, D- m8 f" J        }
        System.out.println();
  V, s& J" G# r' d  s7 }, c

    }
) w9 G( Y) x$ ~( w* |0 v5 o}
  E* ?! g* o8 [: b1
* W+ c; E: S1 M2
3
( q. P  R. x( W& h4
5
8 n4 N: p4 d6 z3 V6
7
) C' Y4 a+ E. s2 l9 h5 X: `8
9
10
+ I' d+ z& \, a' \; |3 t" f* P11
12
! R: P% m" g/ G) g13
14
15
. H* Q! h2 T/ N0 G  |16
/ h" P' {. J# M17
18
19
' Z1 F% F9 O0 o' M20
& ]; n8 ^: y* g9 U* x! i21
" L3 e$ D3 P' Q2 Q0 R4 O22
9 Z# H$ d; _7 a7 `, A3 d23
% |% t# V: B8 b- ~6 z24
# _+ r, C4 C4 E7 r6 O% G% P25
26
27
' v2 x2 g7 h, o$ i* Y28
29
30
31
32
33
运行结果：
' u# t8 T9 Y" n$ i' _" W, M0 g4 v

测试冒泡排序:
, |. I3 ]4 m. F5 o! }/ b-66 -13 -1 1 4 9 12 25 25 26 34 47 58 99 162 10093
+ E* p$ `1 L; B- ^1
2
降序排序（从大到小）
# [0 Z! G/ n, r/ y3 S
8 G8 G/ j  N- D( F
) T& g6 X% `9 M  n: P0 c2 y//测试冒泡排序
System.out.println("测试冒泡排序:");
temparr = nums.clone();
BubbleSort.bubbleSort(temparr,false);
9 @& P6 ]$ c6 y0 Z- Lfor (int i = 0; i < temparr.length; i++) {
$ Q& f0 s; a4 ~+ Q- N    System.out.print(temparr + " ");
}
) J0 Y4 [: |- c( l4 I+ y# |& e- T: RSystem.out.println();
0 T* W1 D" j% u$ J5 x1
2
1 v# B! p9 k5 E' o( |# z3
" A3 ?1 c( b; V' }, f4
+ t. Y8 X8 Z2 A1 D5
: v! ^* u% U! w/ w. T6
7
  A$ U0 P  Y2 z5 q8
- p- J2 W; a; k1 ~% l- F! B1 J+ W' ?运行结果：

5 ]2 L1 i8 Q; @
$ B6 b& y; t: ^( X7 v9 V% w测试冒泡排序:
10093 162 99 58 47 34 26 25 25 12 9 4 1 -1 -13 -66
1
2
& k! ?# k4 u0 D$ A1 k! x& J& G下面几个算法的测试也就是换了下类名和方法名（换成相应的排序算法），如果想降序就在数组后面传个false即可。我就不一一复制了，我在最下面给出含所有算法的测试类，需要的自取即可。

! M! v$ f; F+ x2 n0 j
快速排序
简单解释：
  R, V9 S- q* o3 V快速排序就是每次找一个基点（第一个元素），然后两个哨兵，一个从最前面往后走，一个从最后面往前面走，如果后面那个哨兵找到了一个比基点大的数停下来，前面那个哨兵找到比基点大的数停下来，然后交换两个哨兵找到的数，如果找不到最后两个哨兵就会碰到一起就结束，最后交换基点和哨兵相遇的地方的元素，然后就将一个序列分为比基点小的一部分和比基点大的一部分，然后递归左半部分和右半部分，最后的结果就是有序的了。
* E1 x# {& T0 {% G$ T8 ~
% A& l' T% f  J2 q$ H1 C
+ J$ x& l# z6 U2 F
( p5 M+ y0 m9 U9 b

5 q8 ~3 N3 |4 W. W" h' m
完整代码：
' s' o( _4 o1 Z0 ]1 W/ l0 R" A
. A" X. H, L5 d. \) e
8 U$ e" d4 E9 ~# ^- Fpackage com.keafmd.Sequence;
! p, f( a8 G( L2 B/ d* b

/**
* Keafmd
3 c6 P0 p: ^4 M8 U  M7 K, S& z *
6 I4 S# ^+ u3 c; N8 t# r/ W * @ClassName: QuickSort
* _4 J2 j2 X- ~- V# ]# M * @Description: 快速排序
+ y) l* q9 ?& I; K. [ * @author: 牛哄哄的柯南
( y/ w9 E4 ^& ?( I * @date: 2021-06-24 10:32
" L& P- p7 r, J */
public class QuickSort {

7 @0 R1 D; B' `& Q
1 G/ k5 l- U) _9 K3 U+ n    //快速排序
% ~6 `7 b5 E( Y6 B7 |- F( W    public static void quickSort(int[] arr) {
        quickSort(arr, true);
4 s9 F, y9 o7 Z/ j# Y0 D6 V8 x    }
0 i9 q1 ~) v6 ]+ {/ V' e

; b, b2 Y* m) h* A9 x- H/ d' P    public static void quickSort(int[] arr, boolean ascending) {
        if (ascending) {
            quickSort(arr, 0, arr.length - 1, true);
* v. u, r  ~' M' x5 y3 U' _        } else {
  s' \, f. L$ K/ E+ w" Z            quickSort(arr, 0, arr.length - 1, false);
/ u9 u1 J8 m' @  j/ Y- I$ z  C* O: V        }
    }


( k* o. `& h3 ^* J    public static void quickSort(int[] arr, int begin, int end, boolean ascending) {
        if (ascending)
            quickSort(arr, begin, end);
6 N3 p$ p: O. @! B        else
            quickSortDescending(arr, begin, end);
+ n8 B  S8 ?# A; s3 \& L, J    }
/ U1 k4 @' o# T2 t. M
5 d- f8 @# S6 y* q" y6 d; H' I
- n; K8 K! a  S* o. I; X; L    //快排序升序 -- 默认
    public static void quickSort(int[] arr, int begin, int end) {
: r& n5 o! u8 K0 g/ F7 \2 f        if (begin > end) { //结束条件
            return;
        }
% P* a2 w# a! p- t        int base = arr[begin];
        int i = begin, j = end;
3 T: y7 q0 Z# E) m        while (i < j) { // 两个哨兵（i左边，j右边）没有相遇
) v% m- N% P- W& `8 w            while (arr[j] >= base && i < j) { //哨兵j没找到比base小的
                j--;
$ a: v  X$ x. K& q# H            }
            while (arr <= base && i < j) { //哨兵i没找到比base大的
                i++;
            }
) Z! L6 q5 ^& z' d' y2 i* m            if (i < j) { //如果满足条件则交换
0 B" {; O( e% N% z                int temp = arr;
# S1 _5 J" `2 U, a; Z3 i! O5 E                arr = arr[j];
& v$ I) [' h: G$ C- U* s0 n                arr[j] = temp;
* O9 \& I: z* H( ^' J' U            }
# N/ P, O  L$ s+ J+ ~* K

% A; i5 h: k2 {! o* S        }
        //最后将基准为与i和j相等位置的数字交换
. x) S& r1 ?5 ]5 t4 k" B' X5 d        arr[begin] = arr;
/ {' F% g, M  X* B, l9 J: Y        arr = base;
' }. l% q: D/ _9 K$ j" u" u- P. P6 N: d+ ?        quickSort(arr, begin, i - 1); //递归调用左半数组
0 A; H+ b  p7 `" p' u. F        quickSort(arr, i + 1, end); //递归调用右半数组
, E9 A' J$ {3 o- L9 M3 z" f8 W( W3 m

    }


    //快排序降序
    public static void quickSortDescending(int[] arr, int begin, int end) {
        if (begin > end) { //结束条件
            return;
        }
        int base = arr[begin];
( |: F1 c/ I# B; o& m        int i = begin, j = end;
        while (i < j) { // 两个哨兵（i左边，j右边）没有相遇
$ }; [& W/ B% _6 [% c7 g7 N            while (arr[j] <= base && i < j) { //哨兵j没找到比base大的
                j--;
            }
! W* n# O8 S. A: }* I            while (arr >= base && i < j) { //哨兵i没找到比base小的
                i++;
            }
' d4 K9 _' }& q/ ~' Z; S9 a            if (i < j) { //如果满足条件则交换
) n& \& `. @- d& T: i, C                int temp = arr;
6 {% x4 _- s+ J7 J0 y, e* u2 Q5 ~                arr = arr[j];
                arr[j] = temp;
            }
1 i4 F  a5 o/ s" I( U6 r; Z
/ d1 ]% k( m. [* \
        }
) ]7 Q' q& O% ~3 i/ H# I) Z        //最后将基准为与i和j相等位置的数字交换
# A/ x4 o! e. U5 m/ O4 N9 Y3 r        arr[begin] = arr;
        arr = base;
9 k, h0 a* t: W        quickSortDescending(arr, begin, i - 1); //递归调用左半数组
        quickSortDescending(arr, i + 1, end); //递归调用右半数组
: I: R9 x( {4 V9 W

' z$ s9 _/ l3 c. A8 |/ d4 r    }


' b% ^, T# X! \+ B0 K/ v4 F}
1
2
3
" k8 U; T# Y# }4
5
6
7
1 d  i7 }4 O0 k2 R/ Y8
! v7 D; O  J% r2 G9
5 [8 C" u1 m- F+ W. B7 H" J10
11
12
13
' U  s" M$ ^7 W8 N0 C! d) [3 G14
6 C2 A' i  E) M7 O15
16
/ H% h% _$ T: ~$ H0 I2 v8 i17
18
19
20
7 e& `# {% p  b/ ]* Q21
22
6 S7 v4 g  f5 o+ Y+ P& j8 P( [) c5 `23
4 }; e. O% D. _$ {1 j' u24
25
4 y% v' D: I! F  j  j( g4 s26
27
28
29
4 [6 B; g% M9 g" W( A; L30
0 }( A7 _& B* L& m. v( }/ n0 `31
  u: y0 g. y8 ]: x% q32
# ^' n+ k8 Q5 r  p33
0 z/ L: G$ l% B# E& j; p34
35
! r% t  [  W% x36
/ {; w# z! f1 x( \, g6 a37
38
: l# D: e' ^4 G! b39
$ s1 B  E/ i6 ?6 I. {40
! H( D* @/ T! N$ f. e7 U; }& N. U41
42
( _& O- f4 I' z, @43
44
45
! ~, x+ `- Z- C% G4 M' I1 @- T46
47
48
49
# |- B7 Y# d2 r) b$ R" H& L/ }50
. g4 b5 h( Z% |1 Y* w5 L& C51
52
53
54
% t( N, `7 E* s+ [4 Q8 L$ ]55
56
" [* w8 O1 T, x) H3 A/ y- ^57
5 j; B  v+ G4 `; R; o58
3 ^" @* E) {3 i  q  O4 a) G# ^3 ~) v: a59
+ n4 L6 o+ G+ u7 S9 ?8 b60
61
62
6 q% y) W6 m5 I2 p; a, q5 ?( }63
) n7 D, Q# d! f6 S( G4 r0 A) }64
65
3 R5 O& p; }% O% o) T2 y# |3 ~66
% D- R" T. s; X3 _$ A0 r$ `* ?67
68
3 \$ l7 U+ P% u. l" b3 r8 \& v69
% s2 G$ S( K5 ~# w) W4 [; S4 o70
71
72
. A; j6 t) T- k9 ^4 E* g; j73
4 I8 B( y) ~! F9 x1 }. ~  n2 x) ?74
75
76
77
0 G- u( F. G7 c$ _. C4 M78
79
80
81
82
# H: R8 K7 ?$ Y; T) D83
+ ?1 Y& G2 W8 Q7 j84
85
/ p+ a# p' N" t; O7 ?86
1 E' j' y1 a$ D2 k- U9 |) [0 Q87
: t# |# K4 A3 g8 `* O) {( k/ {88
89
0 A; {$ q" E) z4 Z; t90
% I/ W. p, p; C# r91
  K2 g8 c' L' |直接选择排序
简单解释：
数组分为已排序部分（前面）和待排序序列（后面）
第一次肯定所有的数都是待排序的
! B& n* [5 \. ~: ^" `5 \从待排序的序列中找到最大或最小的那个元素，放到前面的已排序部分，然后一直找，不断缩小待排序的范围，直到所有的数都是已排序的了






( S0 N; B8 j+ P! m: Z  s' a完整代码：
: T) [8 x, T6 e. Z+ {% u; o1 ?

7 X2 Y! v0 M4 D, gpackage com.keafmd.Sequence;


6 V& G. T' N# [$ ~3 Z* k) K; u# `& q/**
* Keafmd
0 N6 y/ s: ]0 W* V3 h% ?6 C *
* @ClassName: SelectSort
. c9 ~! ^( K& S: H( }. { * @Description: 选择排序
* @author: 牛哄哄的柯南
* @date: 2021-06-24 10:33
+ ~4 l% U- a3 d */
public class SelectSort {
' I' {0 S+ R" ?! o2 ?( n' \2 i$ V
$ k1 B0 r5 u. G- }, M* k) S
/ E  i2 m$ w* q  @1 A! D# _    //直接选择排序
    public static void selectSort(int[] arr, boolean ascending) {
        for (int i = 0; i < arr.length; i++) {
            int m = i; //最小值或最小值的下标
            for (int j = i + 1; j < arr.length; j++) {
; Y  p% {) z7 p% I9 s( a9 ^                if (ascending ? arr[j] < arr[m] : arr[j] > arr[m]) {
9 d9 C# t  a: c3 n* M, g0 D                    m = j; //找到待排序的数中最小或最大的那个数，记录下标
                }
; u1 _7 X& [9 T$ m
# o. _# ~; P# l3 p1 V
            }
( |6 v) s" \% J2 P4 W7 z            //交换位置
3 }9 s7 O4 l8 y1 ~            int temp = arr;
. L% X/ ]* Q1 S3 i4 K            arr = arr[m];
            arr[m] = temp;
" P* t4 U0 I1 G0 H( z; e! H

4 T; }/ c( B0 R0 k- a) U+ G' m        }
    }
6 M3 m$ D% L) P
( f9 I0 K! m" N# |+ l  S
- C* ?' o- H0 `. g4 o' Q    public static void selectSort(int[] arr) {
8 A* ?/ x1 t4 C9 L2 _  m3 \        selectSort(arr, true);
    }
! Q0 f/ Y" v* m: d- U1 l}
1
$ @4 n5 Y) h" H2
3
4
5
6
7
% L  u0 m9 |% W# l; y. z8
1 G& i3 \. o3 h2 O9
1 a: b& e1 }* W+ j10
: ?/ ]4 J9 [/ y9 {. ~+ m6 K11
7 j; y! ]: C' P( O5 t2 Y12
13
14
0 R9 x$ N5 {3 l4 g5 o  m* h15
16
17
18
19
; h/ d; s/ L+ ]20
21
2 b, f4 P# a/ ^22
7 G9 Q. Y  @* S" L4 T- ?6 [/ h23
24
25
8 b8 ^- e+ q+ `/ L- V; H. J26
3 M, B4 ?& i0 B# q4 c5 H7 x27
- p  z$ }  {. E" i: y6 W4 u8 z28
% O: ]  o) e: [2 `* q! i% i: q( h29
% O8 t& F/ @4 p- d" r' V3 x+ ]30
31
32
6 F6 n. ^$ D+ W% V' I5 E; c) P/ O4 G33
/ `! o3 P, L2 N34
堆排序
1 I* M/ B# a, Q先理解下大顶堆和小顶堆，看图
大顶堆，双亲结点的值比每一个孩子结点的值都要大。根结点值最大
小顶堆，双亲结点的值比每一个孩子结点的值都要小。根结点值最小


* s$ ?% X$ s/ y) H
0 A; h  t, R) ~/ ?! b
$ j. O/ `5 Y; r, j! |$ N9 E. b简单解释：
构建好大顶堆或小顶堆结构，这样最上面的就是最大值或最小值，那么我们取出堆顶元素，然后重新构建结构，一直取，一直重新构建，那么最后达到排序的效果了。
& u8 \- T: m" _+ R; q
' L, @( G( T: J5 @) z



( y! l7 K6 a% C, ?, i3 z6 I
! K7 D8 M4 d' `0 w完整代码：
) y8 I- l3 L9 @! |

package com.keafmd.Sequence;
# V8 k$ ?' G& A9 C% N" p+ o4 {, h5 ~6 y

/**
* C- c( U2 ?+ v% g; t- v; a( M * Keafmd
*
/ o) l* K; q, V" ] * @ClassName: HeapSort
5 i! M$ v$ q$ ?1 P * @Description: 堆排序
1 W9 C& \9 b/ m3 O * @author: 牛哄哄的柯南
* @date: 2021-06-24 10:34
! h9 J4 S  b7 b* I' ] */
public class HeapSort {
5 }1 L  X1 K1 Q- G) I8 ?; i3 A

( Y2 e# w# D9 M+ ^  P    //堆排序
    public static void heapSort(int[] arr) {
        //对传入的数组进行建立堆，这里默认建立大顶堆，进行升序排列
" [- Z4 l9 p5 W7 z; w        heapSort(arr, true);
    }
, H% G" ?7 m! F) n4 W$ y$ V

    public static void heapSort(int[] arr, boolean maxheap) {


9 v0 ^" Y+ F: O/ c+ ~        //1.构建大顶堆
3 C2 |1 P5 {4 \" @        for (int i = arr.length / 2 - 1; i >= 0; i--) {
            //从第一个非叶子结点从下至上，从右至左调整结构
4 A$ R8 ]8 y, K0 H) k4 a1 Y            sift(arr, i, arr.length , maxheap);
7 a0 g+ }- T" o) @2 \) I& @        }
+ s6 j( y& Z: p) A

- q: I9 O2 c  m7 Y& c: ?) p        //2.调整堆结构+交换堆顶元素与末尾元素
! H1 F# S& z& H        for (int j = arr.length - 1; j > 0; j--) {

, e( H, \! ?" @9 f
3 W: I) s+ F' u4 j            //现在的数组第一个就是根结点，最小值所在，进行交换，把它放到最右边
6 z$ ^. j0 J. G            int temp = arr[j];
            arr[j] = arr[0];
5 w4 L* ~/ I9 M& `5 u7 `2 P            arr[0] = temp;


            //重新建立堆
1 j# l, a8 Z! W+ S            sift(arr, 0, j , maxheap); //重新对堆进行调整
        }
9 b( U1 m- C8 X" k    }
- K/ Q$ w! a7 v

4 B# |/ ~; J* Q# |    //建立堆的方法
    /**
     * 私有方法，只允许被堆排序调用
: v3 i: O- Z3 P1 x1 o/ A     *
. q; ~; m5 u6 o& ?6 x- ^     * @param arr     要排序数组
& b$ x4 j7 s- B8 A, E6 _% K- I     * @param parent  当前的双亲节点
     * @param len     数组长度
     * @param maxheap 是否建立大顶堆
% i3 |; R* G1 X0 G/ Q+ ]     */
    private static void sift(int[] arr, int parent, int len, boolean maxheap) {
6 H% i. c, w. S& |

        int value = arr[parent]; //先取出当前元素i
9 d+ w+ \' k, I, g% a9 |6 F

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

% u( L7 |  N* M& ]5 p
5 t2 u3 M7 r' L4 e* C1 \            if (child+1 < len && (maxheap ? arr[child] < arr[child + 1] : arr[child] > arr[child + 1])) { //如果左子结点小于右子结点，child指向右子结点
                child++; //右孩子如果比左孩子大，我们就将现在的孩子换到右孩子
            }
: W6 [& u, a! ]: D3 }! A% o( Z, q
# {. n4 T" S$ Q0 J! p6 {
            //判断是否符合大顶堆的特性， 如果右孩子大于双亲，自然左孩子也大于双亲，符合
            //如果子节点大于父节点，将子节点值赋给父节点（不用进行交换)
            if (maxheap ? value < arr[child] : value > arr[child]) {
$ e/ w* Q+ k0 I7 W                arr[parent]=arr[child];
- l5 ?, t" ]" a                parent = child;
5 F9 u3 w( D# ~4 ^: q& ^            }
            else {//如果不是，说明已经符合我们的要求了。
                break;
            }
2 l/ e6 S# m, Q! n% `        }
        arr[parent] =value; //将value值放到最终的位置
6 ]2 r4 B' s2 d5 N& _+ l

, d( [* ?% t  T; y( ]5 z

    }
, A- Y/ Z" C& r* A" Q& J, ^
2 W9 }0 u2 Y2 Y3 R
}
1
# _! n% H' a! v0 ~2
3
& x9 g6 Z6 A: i  @) O" l  ^) c$ ^4
7 T. r7 P( p; I* a5 V; J3 T. N5
6
7
8
9
10
: q: p. ]' [* ]$ Y11
' [' O! L* Y  ^9 S1 S12
5 C' P2 P9 E3 |13
14
15
! {. y3 j9 l* @2 A0 H- }7 d, `16
* q+ ~* C( _) y" E17
18
19
% B1 A1 l- x. g5 L* A$ t20
21
22
23
' ^( o, J" B0 D6 U/ j4 h, X24
- @$ O) |% W$ ~3 Y25
26
27
28
29
30
9 F6 G$ U6 S6 T% w; B31
32
! G/ ]6 R# Z. z! E3 Q! d: m& D9 J) ^( p+ a33
' ~, ~( v) q1 l: |34
9 y7 f9 e' [# N6 h& c* @$ ~35
36
' W( ~, U" C# [" k) }, V37
- i. C$ Q9 A4 K+ n38
- I: G3 O, m0 [9 i) T39
9 g: N* S0 v/ t" s40
41
42
43
44
45
8 O: D6 B" H4 G, C1 C$ Q+ I% Y46
% C9 r0 F4 T0 ?/ W( ?# }! G. I* i0 E1 @" o47
# b( x! C5 N0 C0 a9 W3 X1 g- c48
/ n8 @4 _) m; L/ V/ j$ }( _4 L49
) v3 x' W- H+ J$ E, x% A7 H50
51
52
+ Z3 `) C  d) T2 w% V53
% i/ w+ u/ F6 r+ Q" x, H54
55
56
( A9 j/ }. {7 S8 j" ~3 S57
58
+ Y0 L* u1 n3 c% t- S59
: h! [/ l; k  i60
  @, |; l! r( N* V, S( E9 q61
& Q' u2 @: B, ~- X9 D( ?* k8 @5 y62
63
* {5 I6 l+ `$ B6 S$ ]64
; \2 y: k6 P7 F9 C, F& H4 E5 I65
1 k$ `; W4 x) T! C66
3 D2 g7 j/ v) D1 W+ f67
+ ]5 n$ M- \# e68
69
70
$ V8 |7 }& m& g. e3 o71
7 u5 L* b+ c. A6 G3 v# N2 o0 s72
% n# G7 k& K6 t0 f7 [* O6 p73
74
; l" M% x1 w; b) v归并排序
; B  a* n5 g* a6 X5 K6 l简单解释：
该算法是采用分治法，把数组不断分割，直至成为单个元素，然后比较再合并（合并的过程就是两部分分别从头开始比较，取出最小或最大元素的放到新的区域内，继续取两部分中最大或最小的元素，直到这两部分合并完，最后所有的都合并完，最后形成完整的有序序列）

! k; S. J1 V/ E* S3 l- a0 z

( }; B0 x. M# b* H! B

& k6 a5 b6 y" k$ `2 J) `
0 Q5 [( R9 F- C1 w5 z( E完整代码：
  P; h4 K3 ]  f: ?2 i- H
. i) T4 _; L& q8 l
package com.keafmd.Sequence;


! s0 Q. Q: r  _" l6 X5 }/**
* Keafmd
+ I$ ^' p' w' Q+ Z. j$ v3 [0 L *
* @ClassName: MergeSort
* @Description: 归并排序
8 {; Y/ P) X6 [# L3 Y' ]3 l * @author: 牛哄哄的柯南
2 p! Z" U, O' q * @date: 2021-06-24 10:35
*/
, x  A: H: ~- l: w% m8 Rpublic class MergeSort {


    //归并排序
    public static void mergeSort(int []arr ,boolean ascending){
        int[] temp = new int[arr.length]; //在排序前，先建好一个长度等于原数组长度的临时数组，避免递归中频繁开辟空间
        mergeSort(arr,0,arr.length-1,temp,ascending);
    }
    public static void mergeSort(int []arr){
        mergeSort(arr,true);
    }

4 ]2 t, A" F5 v5 L
    /**
) V! S  c" I' c7 j$ c) K5 Y% x# d# x     *
9 {1 c2 I6 m! w& t! ?     * @param arr 传入的数组
     * @param left 当前子数组的起始下标
+ @) q) o/ [1 J8 r9 N! C, \0 q: o     * @param right 当前子数组的结束下标
& ^) S& D% S- X; R0 y     * @param temp 拷贝暂存数组
     */
$ P; Q5 N: i4 K4 v# T) u8 g8 e    public static void mergeSort(int []arr,int left,int right,int[] temp,boolean ascending){
        if(left<right){ //这里是递归结束的条件，我们是对半分，那当left==right的时候肯定大家都是只有一个元素了。

! Z* y! Y, O5 R+ p1 ?; K
            //对半分，比如总长度是10，left=0，right=9，mid=4确实是中间分了，0~4，5~9
# w& A$ S/ B3 h6 y5 G" U: ^            //当长度9，left=0，right=8，mid=4，0~4，5~8
) Z$ d$ M9 V) J: P1 L9 \% J            int mid = left + (right-left)/2; // 防止越界的写法
. J/ _$ ~- g* E& S" f            //int mid = (left+right)/2;


            mergeSort(arr,left,mid,temp,ascending); //左边归并排序，使得左子序列有序
            mergeSort(arr,mid+1,right,temp,ascending); //右边归并排序，使得右子序列有序
6 N; z4 I9 a' k

            merge(arr,left,mid,right,temp,ascending); //将两个有序子数组合并操作
        }
! U0 `) o6 t; l! u2 q: E    }
. R8 l; t( V# r# u8 Y+ X( o0 O8 U
, f; Y+ O: M& b# }! x+ F
7 N: E$ b! e) i/ p( e' w8 N    private static void merge(int[] arr,int left,int mid,int right,int[] temp,boolean ascending){
        int i = left; //左序列起始下标
        int j = mid+1; //右序列起始下标
# |5 K" }. K+ d! _        int t = 0; //临时数组指针
: _6 }( i3 U2 _8 Z) G' Z        while(i<=mid&&j<=right){
            if(ascending?arr<arr[j]:arr>arr[j]){ //比较两个序列第一个元素谁小，谁小先拷贝谁到temp，然后对应子序列下标加1
                temp[t++] = arr[i++];
! ^) c  J5 {, U9 e; N2 Q            }else {
                temp[t++] = arr[j++];
" D# T+ U" v' d( u/ n            }
        }

6 S' E% m% V6 a% P% Q* M& V
& R  v* p& `  b0 `. o3 I/ e        while(i<=mid){ //将左边剩余元素填充进temp中——左序列有一些数总是比右边的大的数
            temp[t++] = arr[i++];
, @- [+ b  e( I7 T        }
; L* i- p- H  X+ l+ D
+ J$ R/ y# M/ Z; T5 v9 G; _
& N) m  }: ?5 ~# t        while(j<=right){ //将右序列剩余元素填充进temp中——右序列有一些数总是比左边的大的数
            temp[t++] = arr[j++];
        }

$ H+ f" m! q# b/ n1 f
' ]9 L; ?6 n- d" g5 L) U' C4 W        t = 0;

" S# J+ y1 Z) g9 G
+ M  N; s4 [+ u; m/ M! B: j        //将temp中的元素全部拷贝到原数组中
; y5 r7 \: v! T1 b1 R1 N& Q        while(left<=right){
& \( }5 a  E8 {9 e            arr[left++] = temp[t++];
        }
, I& ^4 g$ v1 O$ i( C( I7 _& G$ q
/ a# P/ g6 j5 }1 r9 e0 M
8 z$ U: w2 T$ {    }

: I$ _9 L2 }- A) H1 {
  o+ w& h6 I/ p/ B0 R}
3 T; ]0 E: j  d9 ?1
2
3
4
5
3 T( L( S% E' z/ v6
" e" q0 ?; D9 P7
0 D9 H) T* D( |: T$ G' C; c9 c8
' v0 y) y8 j" K' {) ~; p9
10
' B- s# K7 [2 y$ F: ?0 g' M3 ?8 j4 d11
# Z4 z6 W  R+ ~4 w, S! ?/ Q12
8 R0 s1 B* ]1 B6 s4 _5 t! |- q  @13
- n9 y4 C/ y$ e2 W7 L14
2 d/ g3 S! }$ x15
16
17
18
$ @7 N7 u* |0 E- ?" }6 `9 J19
20
21
( _9 o# M1 A8 N0 ?4 l1 Y! C$ ^2 Q22
23
, M- Q: s; Y/ s* U9 K24
3 _4 V9 K6 b8 R+ y: Z3 `25
26
1 J( l8 v3 @  c; ]* g27
28
29
30
31
32
33
34
35
& D# S. o& f4 @3 ?36
37
38
% G2 ~/ d1 F7 p' n39
40
; k7 X6 a4 }# q; A) a41
2 u5 f5 l: t: B# v( E$ f- q# g' M42
43
/ D# Y1 N3 z* R1 y% i- P7 r2 ~44
& O* b: w  v- I45
46
; V$ H: U/ S9 N* n: b3 l/ \9 I! ~47
48
49
50
51
! u7 n% W  d) o! I52
; i' S4 @8 S  }0 i. \9 I53
54
( E: M; d, E. {& c5 W# S. K55
5 {8 j" X1 M! K  a( E% Z56
57
58
2 E6 H! b. y2 [# ^6 t# y/ k' b59
60
; {# d8 E8 j8 U7 `$ f) B61
62
63
4 t( @% f( h& ^9 V& E6 z$ ^64
65
  c& o; S0 F! Q- {4 {4 v66
% B! u6 C$ j: a( a! u$ t( ]67
68
7 w( V. c& C3 N/ m69
* j+ y- x/ \1 z* U) G70
# J' F7 c: m+ M* Z, ]71
6 I$ K& U# d  Y+ G! }72
5 T: T2 ~/ `6 H- Y0 c73
& X# Z! |3 W' H5 e+ |; m' }插入排序
简单解释：
9 E, `! |4 t; m  N最简单的理解就是打地主时我们拿到牌后的整理过程，从第二个牌（假设我们拿起来这个牌开始比较）开始，（说下升序）从后往前比较如果比前面的那个牌小，就把牌往后移动，直到找到一个合适的位置（这个位置的前面的那个牌不比这个要放下的牌大）就把这个牌放到这个位置，慢慢的前面的部分变得有序，直至全部有序即可。
7 [+ A9 r; {% f

3 ?% k" r/ h3 W2 e


# O& O0 a, d, B9 x0 u: x
( \7 S' `5 C6 G9 \. q9 M& F. k完整代码：


' W& ?! F7 p2 v2 J+ ]8 E6 g1 wpackage com.keafmd.Sequence;

, e8 w" X' ]5 G; h. a/ O1 \
; A7 O2 G8 P2 i; @/ ]/**
* Keafmd
; @; o4 W$ I9 |; Q *
" q5 X' L- B/ S2 G8 |4 @, I. @ * @ClassName: StraghtInsertSort
* @Description: 插入排序
* @author: 牛哄哄的柯南
* @date: 2021-06-24 10:36
*/
public class StraghtInsertSort {
    //插入排序
8 r8 m. x; h5 K) N3 t+ U" j    public static void straghtInsertSort(int[] arr) {
+ J  w9 l4 j* r        straghtInsertSort(arr, true);//默认进行升序
3 k2 `, m% ]( k0 w5 n! }3 r    }


* c/ k3 _6 b2 y! t    public static void straghtInsertSort(int[] arr, boolean ascending) {


        for (int i = 1; i < arr.length; i++) {
2 {/ S: h4 i5 [; {+ J. ^! t            int temp = arr;
7 Y9 @2 n+ Q5 _* T. G: \2 f            int j=0; //这就是那个合适的位置
            for (j = i - 1; j >= 0 && (ascending ? temp < arr[j] : temp > arr[j]); j--) {
                arr[j + 1] = arr[j];
% l  E/ V# S) _- o2 n% f: }* u            }
            //把牌放下，为啥是j+1，
' z) D4 Z# i" \            //是因为上面的循环遍历到不符合情况的时候 j是合适的位置的前面的那个数的位置
2 R, g3 z+ ]% K% J            //有点拗口，但是就是这个意思，看图方便理解下
            arr[j + 1] = temp;

3 ?1 c  ?+ f( Z+ _2 A: p" C

0 W" \& k( W7 Y( z1 u
5 E/ L% F% x- R1 P        }


    }
}
1
2
( e8 e* `2 W% _5 @3
7 |6 b! l' @* \9 X( a4
5
6
7
8
  A$ Q. `' R" V; E  B0 M; Z* M9
" ]. U3 U0 g, m: {10
11
12
13
14
15
16
17
18
0 v& d2 H, A2 @+ P+ Z& G- z* u19
# {+ U3 r1 Z% B0 l- \% s0 T3 J20
  O" v, [$ Y, F0 e21
4 V0 j5 D* {% \+ c: o22
. F" Q4 _8 Q3 C# H23
24
5 I# x( G* }8 }7 m& @25
26
& Z$ a# w. C" g, \! @3 |- E9 G" i27
28
& f% B( u$ _) k29
- Q/ E! @0 a. D' I1 f1 S2 j30
# B6 h" `% o: G31
32
0 R! E* A4 }! j$ E& _33
34
希尔排序
1 ^4 o- m+ V" {* i6 o% X6 _2 \简单解释：
希尔排序是插入排序的改进版，我们理解一个叫做下标差的的东西，也就是下面那个图中的增量d，初始下标差为arr.length/2，然后继续/2，对在同一下标差（相当于把这几个数单独拿出来了）的若干个数进行插入排序即可。
% Y9 e# J( Y. F( R, V; N' A


2 D& s4 d4 |; E) q( d
4 X; x* M) ?8 @; _, }/ \
8 o; {' j6 M* S* {- Q
完整代码：
% ~; P/ o' {( |! o: K- |5 j

package com.keafmd.Sequence;
3 S0 |6 q: i# O3 q5 x5 e
2 M9 V! D$ X8 `- `8 B' m  T( t" A
5 m, g% M( _+ U6 f. V8 \6 ]: i/**
* Keafmd
*
* @ClassName: ShellSort
2 h, p, v2 g/ Q1 J' u/ X# L! ~ * @Description: 希尔排序
" a! @  ]; H9 Y& _! @  Q; ~ * @author: 牛哄哄的柯南
* @date: 2021-06-24 10:39
*/
3 U! j1 S6 v% h% Npublic class ShellSort {

  G3 V9 a( v8 \- _
" ?% c/ ~- T7 S    public static void shellSort(int[] arr) {
        shellSort(arr,true);
    }

3 A/ Q  R0 ~+ n+ Q" X' x
    public static void shellSort(int[] arr,boolean ascending) {
. G$ @- j0 \$ b! N/ A1 d) b* |
1 ^/ Y3 j( b) g) ?, D2 c
        for(int d = arr.length/2;d>0;d/=2){
5 T- n  H) h1 Z3 e5 |

: i% M2 _) r7 l* e' ^+ M            for(int i=d;i< arr.length;i++){
) t; m3 A3 e9 O1 N, h! N                int temp = arr;
                int j=0;
                for(j=i-d;j>=0&&(ascending?temp<arr[j]:temp>arr[j]);j-=d){
% n; ^. Y7 ?& a                    arr[j+d]=arr[j];
/ Q5 N3 j- L( V0 Z" ?                }
                arr[j+d] = temp;
4 \5 z" M/ q6 U; Y# j6 b# ~            }
        }
5 c" R0 A! K2 S

7 H# Z( p9 D  P$ P' `, y$ h    }
, R2 Z( ^5 W2 ?! f& I. y}
; m' Z  o5 Z1 P0 E6 k2 v7 u1
2
3
4
8 K* e! o+ p/ L  n! k5
) l7 c0 R5 F- `7 e! z6
7
8
9
& A. _8 A& \' s  ]' @10
11
12
13
1 t8 D) C9 m) H) F+ F0 O- |. ?14
15
1 `  c# {) F, t+ y( b1 F: g7 v16
4 a: q/ l! ]; o3 P17
18
3 \3 B& Z$ G3 u* e( R. P19
: S* B7 s* |+ }. g. F: s20
21
0 a( g: {0 Y! f  n22
23
& ~+ ?* L3 g6 z5 v  m1 n% {24
9 W: p# U0 l# x( {25
1 ~1 J/ Q' j2 r5 _2 }26
4 \3 y- O- y9 O. l! i0 o- S) `27
28
29
: j0 r* m, g& G% W6 |, G- U! O# _30
31
/ J# }( A8 N' C& x. R% U32
计数排序
% p/ d+ V( M# \3 X. D简单解释：
这个排序算法看名字也很好理解，就是就是额外找个数组来计数，然后在这个数组从小到大或从大到小把数取出来即可。
/ Z3 `& m0 O" R0 s
8 n1 V7 e2 t- y0 M) C+ y

) F; F  ^, g& k


- ]2 J0 x! t2 W. T& R9 P& o2 E% N完整代码：


: c3 [9 ?" i( a( y( [$ }package com.keafmd.Sequence;


4 S- l3 O* x5 R8 |' L# H/**
& A0 k- E' H! A( ~1 Z * Keafmd
*
* @ClassName: CountSort
! Z2 C8 K- F8 Q" O( w. V3 Z0 O * @Description: 计数排序
* @author: 牛哄哄的柯南
: Q+ r4 X6 A5 a  `$ t# e1 @; L * @date: 2021-06-24 11:31
*/
public class CountSort {

8 l* @& ^2 q& T+ U
7 N) j: w0 i; {; w& r" L    public static void countSort(int[]arr){
        countSort(arr,true);
5 E# J8 Y( |9 M* _1 l# L8 E  R4 y    }
' n+ }. ^& N% n6 T8 b8 _

* w) C9 P* q* w8 S7 B, }" ~: g1 p2 y    public static void countSort(int[]arr,boolean ascending){
$ F8 C- t! F- p* Q        int d,min=arr[0],max=arr[0];

# |: |3 j, g. a; V) d, g1 R
        //找出最大、最小值
        for(int i=0;i< arr.length;i++){
( P  f; e. @% X) f) u( i: j# ]% {            if(arr<min){
                min =arr;
            }
            if(arr>max){
                max = arr;
& `" `# v+ v# C  u3 j            }
/ J5 J5 ^; ^5 r4 O        }


" ^" }# A  e7 \- @! i" k        //建立一个用于计数的数组
! \) Q$ r3 _" }, }        d = min;
/ C7 {0 b; x; x* A        int[] count_map = new int[max-min+1];
        for(int i=0;i< arr.length;i++){
. [; b7 \; R" ~4 E' q  |' W            count_map[arr-d]++;
* C9 G$ ~: |  O8 x, e- {1 w/ |        }
6 O! V/ }0 g# v8 J
- a) A& ]6 X0 }3 D; Z
        int k =0;
$ d2 u( _# N5 _; }2 {4 i4 _        if(ascending){
6 m+ E# G  u  g- [0 e( y            for(int i=0;i< arr.length;){
                if(count_map[k]>0){
                    arr = k+d;
. ~3 |2 C4 ~* e9 P! ]                    i++;
                    count_map[k]--;
                }else
                    k++;
            }
) F* M  e  b9 F: X' P        }else {
0 d! g9 o# t5 W4 z# x) A            for(int i=arr.length-1;i>=0;){
- u6 q3 _/ R5 c                if(count_map[k]>0){
                    arr = k+d;
                    i--;
                    count_map[k]--;
- Z+ z2 Y2 |% v& t5 \                }else
                    k++;
            }
" _  `# e3 T8 W  C$ H+ l' ^        }


    }
}
1
2
3
& R0 t: `: |" [0 J4
: i; p: H+ G( L5
6
7
8
/ z4 _# u7 D) @4 r9
10
11
12
13
14
15
16
17
18
' [$ u) C' r" E5 k  b& j" H19
20
21
* n+ Q  A( S: w" w- G% I22
23
24
25
2 r/ }& i% c; `7 A3 O, s26
, `& a! I/ s4 T. m0 [27
28
29
30
. `, a: @3 Q" ?9 t# s% v% y$ Z; h31
% u% v7 M0 x+ S+ V3 n7 U32
33
34
! D% a1 E7 y$ |' B4 s35
% O% S/ |7 j  z1 E( p- W7 y; z36
37
9 F% A) Q9 p; u* p8 M3 u38
39
* M1 x1 a2 d5 s" ]- q40
1 N2 g1 A$ M) C) |3 N2 \7 n41
42
43
: z6 Q0 Q: [1 c2 b8 I1 J. `44
45
46
47
2 L. K; n" n  y( V/ C, O, Z48
# J( _- o( r" t# I49
* `& k$ P8 \/ }( T- ], M& C$ @50
( U9 z8 R5 D$ x7 i$ A! c51
4 J% g# r" Y% C1 ]) }52
53
54
9 t$ \4 q/ E) s/ |9 g. X55
56
57
' ?2 j. v3 S4 U% l4 ]& U58
59
# Z  G/ R' y$ z+ k桶排序
( {* l* d4 D9 I  Z简单解释：
7 _! L3 o! R# M, N( Q, ]. \就是把一个数组分成几个桶（其实是几个区间，从小到大或从大到小的几个区间）装，然后让每个桶（区间）有序，然后取出来放一起就可以了，相当于把几个有序的段拿出来放一起，自然还是有序的，当然需要是按照区间的顺序拿了。


; _, X- q% n$ }; D


* |  S' T/ p, s' F
9 K% C# r* @9 T- s: |完整代码：


/ F, v! u4 H6 upackage com.keafmd.Sequence;
; T% _, b) y' b- o- U( C2 a6 B

import java.util.ArrayList;
7 s9 h5 r# @0 w7 ?2 N0 z6 D* p8 t2 Iimport java.util.Collections;

3 m4 |! d( t. H8 i$ B+ s
/**
/ N8 K$ o& X# V+ y( y3 V * Keafmd
*
* @ClassName: BucketSort
4 i3 |9 Z) v- e: q9 V0 I5 O) Q * @Description: 桶排序
4 h  `7 `' C% j0 b& G" @4 H * @author: 牛哄哄的柯南
* @date: 2021-06-24 13:32
*/
public class BucketSort {
) o% |0 ^: C6 z
1 W8 B3 K4 Q# ?( f* [' a( J
    public static void bucketSort(int[] arr){
1 L" S2 r+ }9 s2 K9 R/ F. w        bucketSort(arr,true);
8 N' E* J% V, o' m( n. N& x. K4 L    }
! k( p2 A- U3 R6 A

    public static void bucketSort(int[] arr,boolean ascending){
/ A2 P- U  Y0 I) z1 [9 @* A5 W        if(arr==null||arr.length==0){
            return;
        }
        //计算最大值与最小值
0 Q0 \- O4 a" V2 k7 v$ P        int max = Integer.MIN_VALUE;
        int min = Integer.MAX_VALUE;
        for(int i=0;i<arr.length;i++){
            max = Math.max(arr,max);
6 n0 N3 `! h1 E: f7 ~/ p            min = Math.min(arr,min);
        }

5 h6 p+ |$ P- `( w& d4 m4 R+ O: ~
* }! m3 b. m( _2 I- H; t        //计算桶的数量
        int bucketNUm = (max-min)/ arr.length+1;
2 V5 K* E, Y/ B, V1 G% x5 l        ArrayList<ArrayList<Integer>> bucketArr = new ArrayList<>(bucketNUm);
$ M1 |. _' {& o3 G6 v+ Z+ ]        for(int i=0;i<bucketNUm;i++){
            bucketArr.add(new ArrayList<>());
, ^" v) O1 h2 H) X* h1 q        }
2 g7 @- q. O" `  e* m! W
7 e: @% h' ^( ?" e8 s3 H: V; C6 o# |' ~
" e  e) W. Y: z        //将每个元素放入桶中
5 v& ?4 S  h' U6 c% f9 t' p        for(int i=0;i<arr.length;i++){
            int num = (arr-min)/ (arr.length);
: d2 y$ x/ G' b5 P            bucketArr.get(num).add(arr);
- W3 ]3 |& B: M9 V! J        }
8 o: Q: e3 i) R; T$ u
$ F4 L5 V( X$ _" \$ `3 w! V
        //对每个桶进行排序
, p/ g) f' d+ y: F+ u; Q2 S% @        for (int i = 0; i < bucketArr.size(); i++) {
            //用系统的排序，速度肯定没话说
            Collections.sort(bucketArr.get(i));
        }
, e6 M- K3 c/ U9 k$ [

% f; s% D' Q9 \' J, ^9 Y2 m9 q1 [! C        //将桶中元素赋值到原序列
        int index;
        if(ascending){
            index=0;
# F, o/ W0 t5 I" |. k        }else{
- c0 z7 R8 G7 s2 T            index=arr.length-1;
        }


# J3 l+ {2 X: ?+ \" |$ P        for(int i=0;i<bucketArr.size();i++){
5 n$ H4 }. @1 D            for(int j= 0;j<bucketArr.get(i).size();j++){
                arr[index] = bucketArr.get(i).get(j);
4 s7 I( R" ?" ^1 O                if(ascending){
                    index++;
3 V8 R6 N1 g- Q! w1 D, n                }else{
                    index--;
* X; A: I/ ]* N                }
- C6 m8 z# _7 V* H" g            }


        }
8 ]. @! ^0 M/ s# z6 I$ _$ N9 b- l

    }
* [! B/ c& B2 Y( r4 x5 q# D}
1
2
$ F. w' @9 v  n+ H7 @  ~5 r  v; K3
. z; I+ z( ?6 Y) q: c4
; ~5 j/ S8 l# {& ^5
3 B7 y9 Y% ?) g) t$ H* R6
7
  r; A0 [5 m5 O8
+ v. o$ L% R/ i/ V# P5 H9
10
11
$ o: `/ B: E" W* H1 _. A+ z# M3 t12
13
14
15
16
8 j, \( N* t* z7 u; c17
18
. K5 m) K, m! X+ d/ L" y) o/ p* J19
20
/ p9 P& c  |- d5 s21
22
23
24
/ t! c$ c$ L$ P/ h; M: @, |$ T25
26
27
28
29
30
  X$ v5 l6 F! g' k2 R31
7 O6 e- ^0 t7 x32
; U: l  n1 T$ n1 k  {0 g33
* ?0 a3 m' x# Z; w0 ]* T34
+ f2 ]5 r+ g6 {' h8 E4 h4 y35
  C) l8 T- A2 ]% n36
37
38
" ^4 i  Q# `3 Q0 L7 m39
" z/ c& G: K4 n1 p+ G4 K. A40
41
$ k, O4 u9 n3 S3 w1 N; r/ e: u42
4 f- v' c( s- O) {% I2 E43
8 y8 e$ S6 E* l3 L8 k44
( ^, e& p, L* t' j* \2 H" l45
# e, B6 D& _  }. C+ I: s46
47
48
49
50
51
+ N& d& ~4 o4 v$ _; C2 f% X52
* [2 j3 r3 c6 H53
54
  W; [8 G& v3 A+ J6 j1 {$ L) f# R  z55
( f, L( h& d9 {9 e8 p  Q5 k56
57
58
# O  ^; m$ S2 k59
60
/ C4 d* ]  N$ G: v# \' s0 a61
62
63
64
65
66
67
68
3 [' I+ \# L8 i) T% b. H* _& w) f69
; s4 v7 h! w8 H* e+ K' ~% e70
* l: _6 o3 u/ c$ J71
72
3 E. j9 ^, _9 V. Y9 b基数排序
简单解释：
首先说一下，我发现好多人写的基数排序只能排序正整数，其实只要处理下就可以排序含有负数的了，就是我们排序前先把所有的数整体变大（就是减上最小的负数，也就是加了），都变成正数，然后排序好之后，在减下来（加上最小的负数，也就减了）就好了。
基数排序就是按数位排序可分为LSD（从最低位[也就是个位]开始排序）和MSD（从最高位开始排序），下面写的事LSD基数排序。
) }' i9 S& v3 _基数排序就是把数按位考虑，让后我们一位数只能是[0，9]，就是我们在考虑某位（个位、百位· · ·）的时候就只看这个位的数，放到在[0，9]相应的位置，然后顺序取出，最后再按其它位这样操作（上面说了要不从低位开始到高位，要不就是从高位到低位）



  X; {5 R7 s2 w  o, T0 Y1 T


完整代码：
2 u' I# [" A2 c: s3 ]* T2 D* I
/ y6 {$ Z% \& h: r, I
2 K) d7 y. t  [( Z, K$ Y* Ypackage com.keafmd.Sequence;
  s2 n  m6 l: u  _' c/ T

/**
- |5 s" W& ~8 G' g$ c2 q7 S * Keafmd
*
3 K8 x, j& ^6 i" W0 ?; k- o * @ClassName: RadixSort
* @Description: 基数排序
6 J9 ^7 w0 C" S" l( \. {9 H * @author: 牛哄哄的柯南
* @date: 2021-06-24 14:32
*/
( }& [2 @: o) }8 h6 D6 Kpublic class RadixSort {
# Z* `# }* ]0 n! G4 r% B' A    public static void radixSort(int[] arr){
+ s2 O  V8 _0 B2 L9 U) _        radixSort(arr,true);
; q, W7 E  F$ V8 C5 @1 }4 d    }
. y6 I+ `7 C1 i$ M1 N    public static void radixSort(int[]arr,boolean ascending){
        int max = Integer.MIN_VALUE;
        int min = Integer.MAX_VALUE;
1 Y7 N8 ^, e' S. g2 l        //求出最大值、最小值
        for (int i = 0; i < arr.length; i++) {
            max = Math.max(max, arr);
: N5 m8 D' p( e2 t4 Y& @" \            min = Math.min(min, arr);
        }
2 C; M' {) i, ?3 g% Z. o# g, C0 U' ^        if (min<0) {        //如果最小值小于0，那么把每个数都减去最小值，这样可以保证最小的数是0
            for (int i = 0; i < arr.length; i++) {
1 [; {. Z; k* S+ `2 W+ M                arr -= min;
            }
0 L% J- n' U+ L& S' S' D0 x0 Z; n1 }            max -= min; //max也要处理！
4 v' r' K2 S0 C9 P+ I3 ^        }
        //很巧妙求出最大的数有多少位
0 d" k7 y; M" c, r' y        int maxLength = (max+"").length();
2 A, L: h8 Q% s: s: w2 O5 s        int[][] bucket = new int[10][arr.length]; //一个二维数组，一维代表0到9，二维存放符合数
- D* w0 c* F' u- @* J% ~        int[] bucketElementCount = new int[10]; // 用于记录0到9某位存在数字的个数
$ R+ z+ c' {+ U* u& f+ L        for (int i = 0 ,n = 1 ; i < maxLength ; i++,n*=10) { //个位 十位 百位 这样遍历
- L1 n  S7 E+ y/ l/ P            for (int j = 0; j < arr.length ; j++) {
                int value = arr[j]/n % 10;
                bucket[value][bucketElementCount[value]] = arr[j];
# J6 e  F. A; R5 f  p5 Z- l: H                bucketElementCount[value]++;
            }
' |: M9 p$ G2 e

            //升序
            if(ascending) {
                int index = 0;
                //从左到右，从下到上取出每个数
  E+ s; r- w1 q+ I1 E# M1 T% q5 r                for (int j = 0; j < bucketElementCount.length; j++) {
+ s0 W, S- J- O3 b: A7 o                    if (bucketElementCount[j] != 0) {
9 I5 x$ P% S8 F/ S                        for (int k = 0; k < bucketElementCount[j]; k++) {
                            arr[index] = bucket[j][k];
                            index++;
3 k- H/ \9 ?' Y1 f                        }
) j# r  n: M+ i( @: W                    }
                    bucketElementCount[j] = 0;
                }
; u( h/ I2 w; ~9 `            }else { // 降序
$ Z  G& b9 r, u2 A( c* R7 @                int index=0;
3 O+ A& x3 @; t6 _' L% [# h                //从右到左，从下到上取出每个数
                for (int j = bucketElementCount.length-1; j >=0; j--) {
4 _* h  A( \; p7 w2 T, `                    if (bucketElementCount[j] != 0) {
                        for (int k = 0; k <bucketElementCount[j]; k++) {
+ s4 w  N" C1 D& }  g                            arr[index] = bucket[j][k];
) |. t* `5 A1 G                            index++;
                        }
                    }
                    bucketElementCount[j] = 0;
                }
9 b2 u; @5 p1 }+ \            }

- L$ \3 S( b  D. i

. c: x  u& z8 H3 y, {3 Y
            /*for (int i1 = 0; i1 < arr.length; i1++) {
                System.out.print(arr[i1]+" ");
            }
; h6 m+ D6 [0 F5 n0 b            System.out.println();*/
2 |7 e  k2 I; _1 b9 j( \# l





        }
6 M; x' Z+ y! Z) H' n1 G        if (min<0){
            for (int i = 0; i < arr.length ; i++) {
" o4 i( Y' Y  N0 V5 l7 r0 N! Y                arr += min;
            }
        }
. ?7 q7 Q6 k% p/ F5 l
! O4 u& W1 O( [9 l
    }
& B" Z$ g6 l1 Y3 @+ l3 r8 Z$ x}
/ D7 F* N" L* z' P1
3 t1 [" Y9 Q- i8 c1 E& I2
3
* x7 @$ w; i  y; X7 u4
5
- h# C- b$ H/ I. L6
. Y9 C6 d5 H, Q4 R5 N/ _7
8
9
10
) O5 q0 z8 U) T- I11
12
13
14
15
16
17
18
19
/ g! S; ~1 l; w( a9 r/ s% `$ F20
$ c5 @, ~" ]2 Z2 I+ \( m7 t21
: F4 S+ _. B) B6 @+ L22
23
24
" z/ u- A% y9 Q0 l" V% X9 y  Z25
0 O0 E7 a6 s" j26
( s' a8 f- Y' ?; I27
28
29
30
- F$ ~2 y% ^; p" Q2 A31
32
+ Q8 ?/ N2 b  {& s7 M, C) @33
) I& K' s' O$ g* i34
35
36
  L4 T1 @2 Q: }; ?  E3 U37
9 I% d9 E0 h! E6 Q! `38
39
40
41
( h' b' t5 C$ {42
43
% |, L% b: ]7 K+ b4 U+ q2 v44
: S5 a% R" M9 C* q. `6 K, q45
46
+ g" E4 l$ ^% n2 c5 [47
% g* A$ D( [/ W; g3 a48
5 p$ b0 o+ f+ z$ l' G49
50
& j; \. I3 H! |. u6 @7 |51
52
& A) k! X7 U* ^" V' f# R/ t* {53
% T. [3 v6 ]5 N  G; |) y54
# n1 M" |. j/ [55
) i( ^/ [5 O, w: c% t- y( f56
57
58
! M' B! x; ]. h9 ^59
60
1 Y# D! o# w4 V/ {; `61
62
6 S- {# D1 Q5 i0 `63
( V# H0 G  x8 e! g+ ^3 j64
65
& p* e# e1 ^5 A" t66
67
68
69
70
) e: h  T9 j! f9 U+ ^) F+ U: N* P71
4 k. A& X! z/ u. P3 J72
73
74
4 [  V8 e" v7 f" ~75
3 `' i: ^5 N$ Y3 F: X( z: F- C76
77
78
79
) ^  [! H4 X# i0 b0 o" B80
/ e* {2 m$ r5 C81
82
$ C# @+ u* Z3 f! V  J0 B1 o83
' ?) t: B/ B# M3 h; m6 Y完整测试类
package com.keafmd.Sequence;
' C8 ^! O, D# r# s4 m+ s) r2 Q

& [( {$ v: W9 }: l1 S+ Z4 o5 e* _import java.util.*;
9 x1 t: s* o/ himport java.util.stream.IntStream;
import java.util.stream.Stream;
5 F6 m; [- x6 ]- z8 p/ B9 t
+ J' Z% j" }' s- S
8 @- ^; X( W& g/**
! o( `1 c) P. u% n. E' H1 M* o * Keafmd
*
$ o" x3 O# a# T3 k; G+ } * @ClassName: Sort
' i8 L4 E0 Y# T * @Description: 十大排序算法测试类
! T1 O3 n4 n, E" y+ ?) R* m  t * @author: 牛哄哄的柯南
* @date: 2021-06-16 21:27
*/
) ]% T- Q/ f! i; J4 c6 ?& Apublic class Sort {




- |6 K2 z  z! |+ b    public static void main(String[] args) {

4 l8 Q0 h9 T/ W! A% N4 E
0 x) s) G+ g4 d: n& e2 P) `( z        int[] nums = {12, 4, 25, 47, 58, 34, 25, 9, 99, 26, 1, -13, 162, 10093, -66, -1};
$ g  v& O; T( ~  j8 W9 B% e' u0 d8 {//        int[] nums = {12, 43,56,42,26,11};
        int[] temparr;


+ D6 ]! i! }2 M" J& h0 k$ b; I        //利用系统Collections.sort方法进行对比
" V0 E& Y+ i8 K4 z0 G; L: c
- z8 n6 P! }$ l2 J1 k2 H0 I  P* m
        //将int数组转换为Integer数组
        //1、先将int数组转换为数值流
        temparr = nums.clone();
& d2 f" ?" {, M- ^% K4 A7 n        IntStream stream = Arrays.stream(temparr);
        //2、流中的元素全部装箱，转换为流 ---->int转为Integer
7 U8 s: {4 m) }7 {, A9 u* m: z        Stream<Integer> integerStream = stream.boxed();
        //3、将流转换为数组
; A: G( f" e) Q        Integer[] integers = integerStream.toArray(Integer[]::new);
+ D5 C2 V0 t) ]$ U" N' W% K        //把数组转为List
" j: x& ]$ Z0 J3 {" j1 |        List<Integer> tempList = new ArrayList<>(Arrays.asList(integers));
        //使用Collections.sort()排序
        System.out.println("使用系统的Collections.sort()的对比:");
2 a; j9 [* R2 F) \- O5 p
) }) [0 }% t% Z6 J. a
  O4 O8 m) ]5 @: i; O- @        //Collections.sort
7 x  M8 T% N5 E. H* g+ c        Collections.sort(tempList, new Comparator<Integer>() {
            @Override
            public int compare(Integer o1, Integer o2) {
                return o1-o2;
                //return o2-o1;
            }
        });


        //tempList.sort 也可以排序
; Z  ?4 {  F' M       /* tempList.sort(new Comparator<Integer>() {
4 P4 n; g) y# r$ s; Z9 V) k            @Override
+ e* B$ G# ~, c; c& _8 E$ ?            public int compare(Integer o1, Integer o2) {
                //return o1-o2;
                return o2-o1;
            }
        });*/

/ P$ I6 p7 \8 v6 }* U( j
$ A5 h- N0 D) I( x6 [! I! c" }        //遍历输出结果
        for (Integer integer : tempList) {
            System.out.print(integer+" ");
        }
/ r" [7 h- W5 m: l

        System.out.println();
) ]) b- g' z/ U! E2 E( V5 K6 ?7 X
: D& W9 E/ T; n0 L% q+ K
        //测试冒泡排序
        System.out.println("测试冒泡排序:");
        temparr = nums.clone();
* D! [% ~! j6 H

& L5 M- O  L+ s$ y        BubbleSort.bubbleSort(temparr);
) |; G5 t0 M  A

4 P# g3 D% l" q        //降序
* U1 [1 z/ Q4 {; [) |# d        //BubbleSort.bubbleSort(temparr,false);

( z' S8 H1 A& y0 t) X
        for (int i = 0; i < temparr.length; i++) {
            System.out.print(temparr + " ");
        }
        System.out.println();

' N# S! i- T7 {8 ~
        //测试快速排序
  T: e: j4 W1 M  ^* @        System.out.println("测试快速排序:");
        temparr = nums.clone();
: g; V7 }, ^0 I" D* @  T        QuickSort.quickSort(temparr);
        //QuickSort.quickSort(temparr,false);
$ O2 V6 V/ d3 l, \$ E        for (int i = 0; i < temparr.length; i++) {
# c2 c) k, S7 O/ N" h4 H            System.out.print(temparr + " ");
+ Q4 m. l6 v& f* T! m/ M* \        }
1 a. Y' y" f7 p' r# ^. d' y  F        System.out.println();

5 [* ~0 h; z$ e4 `" v9 g8 g  f. ?4 t
+ |" G( A' C+ B) l: x& F! u        //测试直接选择排序
        System.out.println("测试直接选择排序:");
3 f# k" ^6 ]& R5 l5 U* M        temparr = nums.clone();
9 }6 q1 V9 s8 h4 G+ S% _3 t        SelectSort.selectSort(temparr);
        //SelectSort.selectSort(temparr,false);
        for (int i = 0; i < temparr.length; i++) {
( q  v+ p' e, {! Z- Y" v            System.out.print(temparr + " ");
0 _9 t: |+ T5 E& K        }
( G: U# G+ r% E. J' |        System.out.println();


$ n& [8 D/ [& A0 C        //测试堆排序
) X* ^. O9 z. ^+ x  b5 A1 M1 r1 I  H8 R, @        System.out.println("测试堆排序:");
        temparr = nums.clone();
        HeapSort.heapSort(temparr);
        //HeapSort.heapSort(temparr,false);
        for (int i = 0; i < temparr.length; i++) {
* P3 h* t9 @4 D6 v1 F& W            System.out.print(temparr + " ");
( Y% V( c* `& V: I0 O6 E! }; V# N' E        }
5 _. u' e5 W8 m" D9 G        System.out.println();
4 E& ?1 m9 M' p( W  k/ n3 a$ K- d

1 `, Z) P5 D& l        //测试归并排序
        System.out.println("测试归并排序:");
. a) K  V1 x) K. l& |$ S        temparr = nums.clone();
        MergeSort.mergeSort(temparr);
        //MergeSort.mergeSort(temparr,false);
        for (int i = 0; i < temparr.length; i++) {
$ S& x+ R  ^; c            System.out.print(temparr + " ");
        }
7 S: D- H9 K" X8 I. p        System.out.println();

. U+ p" f. w4 }7 `: T* T& p  h
        //测试插入排序
1 T- m" X  D4 S- `, I        System.out.println("测试插入排序:");
        temparr = nums.clone();
        StraghtInsertSort.straghtInsertSort(temparr);
4 B8 a+ e  I4 p" ~* o+ d+ H        //StraghtInsertSort.straghtInsertSort(temparr,false);
" E! Z8 |: ~0 C9 L" ]+ h6 H& s        for (int i = 0; i < temparr.length; i++) {
            System.out.print(temparr + " ");
5 c& p. q( R  |, R; I        }
        System.out.println();



1 S2 h. z6 k1 Q. {) B& ~
1 {1 ^& }! D$ ~( Q) Y        //测试希尔排序
        System.out.println("测试希尔排序:");
" o3 g. u9 z: `# _5 _9 @        temparr = nums.clone();
        ShellSort.shellSort(temparr);
) F8 }: L# n; X0 u& O( p: r5 B) S/ U5 O: Y7 X        //ShellSort.shellSort(temparr,false);
9 t8 u+ E( Q& Q. t3 x, o' ~. j        for (int i = 0; i < temparr.length; i++) {
$ F. X) k- m/ ?+ q  B; q            System.out.print(temparr + " ");
0 v6 d( o# ~) i# A& T        }
        System.out.println();
  ^/ @, h4 X3 r* s& v( e

- P4 H! T4 e- D0 ^
5 v5 R& }( A# j6 ~: i  v5 @) p
' a  ]; [: x/ G, ~3 g1 c5 o- f        //测试计数排序
        System.out.println("测试计数排序:");
1 N6 r9 E; \! s$ e5 Z        temparr = nums.clone();
) l8 {# }* \4 v0 s- e, _        CountSort.countSort(temparr);
; x, Y6 N1 [2 R8 \! v        //CountSort.countSort(temparr,false);
* C( X/ X' b0 ^4 i. k8 v$ ~3 Y        for (int i = 0; i < temparr.length; i++) {
7 u3 W5 f0 b6 \% N3 `) r            System.out.print(temparr + " ");
3 d. c& M4 g8 o3 }2 S        }
9 A9 O8 v9 @! k  t8 i2 L        System.out.println();




        //测试桶排序
        System.out.println("测试桶排序:");
  k. j+ a0 u3 C        temparr = nums.clone();
        BucketSort.bucketSort(temparr);
" b. f! e, \) Z. ~  {$ F. u        //BucketSort.bucketSort(temparr,false);
8 Q4 n) h$ `7 n* F        for (int i = 0; i < temparr.length; i++) {
. v( Y3 x$ B' T- q            System.out.print(temparr + " ");
. |5 m/ q5 T# t/ n2 B        }
0 a( g2 h; u& r3 _- P# b( b  z) \' ?        System.out.println();

* c; f3 e! @; s+ n2 v2 A( K
        //测试基数排序
" _1 ~) {/ _- C+ a% w        System.out.println("测试基数排序:");
& F' c# y7 Q0 H, v$ l8 D3 S, P        temparr = nums.clone();
  y% ]4 G+ _4 ]2 T& x# x4 W        RadixSort.radixSort(temparr);
        //RadixSort.radixSort(temparr,false);
        for (int i = 0; i < temparr.length; i++) {
% c# j, {& P) w  @3 B            System.out.print(temparr + " ");
9 S# e2 D- m. {6 r6 e4 R        }
        System.out.println();


/ [& [) ?/ e) y0 d  R    }
/ J4 t- M9 i2 a1 ~& m2 {% r" B' ~1 Q

3 O& {( V7 n- L}
! v6 d" l& {7 Y  y7 S3 ^/ \1
. I7 j) t! J0 j9 \6 j+ d7 o& j2
3
/ Z% O  C4 v4 H( v( G3 i4
* {( \. d) m3 V& V6 l5
6
( U: @6 t9 C! ^7
- l" R4 h) Z+ d/ |8
9
10
11
# W- T  Z# }8 [" a12
. v1 A  D7 d+ u1 M7 R; i13
1 @5 i5 y" C% {14
1 P, Z9 j0 _' C+ R4 f5 w15
16
17
18
# U: A& \! |8 x4 U8 N# }19
20
: }3 ]% h7 ?5 L8 n+ L  @: X  G21
22
23
2 f* p& Q' w3 {2 T24
& t% l2 F8 T: Y; e4 i# h) W3 v: a5 `25
$ ?8 m; T2 d% Q$ O) K: _26
27
28
* O* {" E  i7 N# Y+ \29
& |3 o% }  l9 k! x/ H4 x30
0 B4 }( m+ p$ `' ]31
6 z- x% _4 \) d5 m; ^32
# K% f* y- x! N* L& X33
  y" D1 g3 `& p34
8 K1 w+ @3 `  `$ s35
36
37
$ A  z; u0 a3 A38
39
40
7 `  _  I$ |3 [4 n$ g2 Y" X& S41
42
43
44
9 a7 S& j5 R0 E$ ^& e" @45
/ y' a# H$ D/ u46
47
48
49
50
51
52
53
54
55
$ X8 [$ N8 v" f0 E56
57
58
, s! ~5 y: ]8 U- z0 `59
60
61
) h7 S' v0 z2 d2 a& i62
- z* K6 {2 j4 {63
( {1 W- _7 s7 U3 D/ _- u64
' L' R. x. }* T65
66
67
68
' p! d* Y  M7 ^69
70
71
72
73
74
75
76
77
78
2 v: P+ @2 Y1 C79
80
2 n0 M8 k1 T2 G: _81
82
83
  c8 ~% p( b, Q9 C2 o. Y84
85
86
87
88
" _" t# u$ n( |4 |( E: A89
90
91
; x  H7 E* A$ c' s4 n7 q92
93
! ^% G& ?' `2 N! E; M1 K94
/ o2 U8 r0 G, [3 s95
( G( Y1 l/ W* j$ C96
97
2 l" o. @/ ]) Y# Z7 Q98
" @( L& X3 M" s0 O% p, ~99
100
101
102
103
104
! P' t2 T8 Y" _( m  C; d105
106
107
108
& y4 [, H8 C2 i9 b+ c+ `# ]109
4 L8 V( |+ t  @' H110
111
112
113
114
115
116
117
  r5 u2 P! q$ E; ^  ]5 P118
+ |: a9 c1 }: O; ~119
120
# K+ U9 b. z3 Z4 o+ ~, u1 ]' i- c+ y121
122
123
( o- p- N4 a- c% v- {1 [: t9 W124
125
: y' _1 Y& r) S126
127
128
129
130
131
9 l1 ?2 k  Z. n0 b* D132
133
' y& |8 n6 g3 w) |6 S* Y+ @% ?134
, e/ Y6 l' V  ~& x3 E8 [135
, K6 I0 |4 K1 C8 j136
! h  {/ [# q0 }8 X9 q3 U( Q) [137
  w, m# B  c+ B" l1 h# T138
$ ^0 |' @- W, @# _" b. t$ |/ f139
140
, s1 r7 U9 l1 _4 T+ a; z141
- p1 w& j+ [5 O/ r5 a5 t9 j- N142
143
144
& L9 X; H; W& ~) `1 l5 C145
/ f, ~. ]6 r3 w146
147
148
149
150
151
1 }: |1 J% j" n( }2 y8 f152
153
154
/ T9 [" q- m% Q: F+ d; s155
156
157
% Z  K+ N9 q6 u+ t* o158
: B: E1 @4 v' X  u$ e+ t2 g; `159
160
: p% V4 r) B# f" q; h161
162
163
164
; l- u& D: A8 T. c7 s0 K165
6 u, I+ u! I  }. |! @+ ]* I166
$ p# V4 m1 X/ {. I, e% r167
; X  ?# s, E- y% [! {; e4 r168
; O. O# g! ^, l( p) q5 Y( h169
170
" V# A0 [6 s8 ~) q4 Q171
172
5 g7 N& y6 [) S5 t. k5 L0 D173
- s6 K- D$ _$ y+ a; B6 ~# c/ S每天进步一点点！
: C7 j' T# x  U3 K5 c2 [" W. j2 ]不进则退！
6 t% z  }! h% _. ?' m

版权声明：
原创博主：牛哄哄的柯南
博主原文链接：https://keafmd.blog.csdn.net/
————————————————
- N2 T) N% ~3 r6 f7 o版权声明：本文为CSDN博主「牛哄哄的柯南」的原创文章，遵循CC 4.0 BY-SA版权协议，转载请附上原文出处链接及本声明。
+ {2 l8 q+ {8 |, q# {4 J原文链接：https://blog.csdn.net/weixin_43883917/article/details/118193663

! K: I; t3 W% \# b5 N; b3 K, q; A9 K0 ^) I
5 n" V6 Q. O; O. V( Z5 y& e

1051373629

每天进步一点点！