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

杨利霞

# w6 J; `/ S8 J. l, A) \+ |经典十大排序算法（含升序降序，基数排序含负数排序）【Java版完整代码】【建议收藏系列】
5 F1 K; I8 n4 K, F8 ?经典十大排序算法【Java版完整代码】
- U% i! S1 P! c8 @写在前面的话
; ^' z' }( n& O9 \8 C  q2 I! [# b十大排序算法对比
冒泡排序
* j0 n+ s- d8 C; @! i4 G' |) B7 M快速排序
直接选择排序
, y# d9 s1 C8 |. r/ {, ^堆排序
归并排序
插入排序
$ ?7 Z- N+ K6 V5 X, e希尔排序
+ P$ i' K- b. v计数排序
2 ~9 l1 r, B/ b! o' s2 }桶排序
' Z8 U* O- Q2 c' l9 ^; B( ~- F0 i基数排序
完整测试类
写在前面的话
       虽然已经有很多人总结过这十大排序算法，优秀的文章也不少，但是Java完整版的好像不多，还存在某些文章代码存在错误的情况，同时也为了自己练手，决定把所有的写一遍巩固下，同时也真诚的希望阅读到这篇文章的小伙伴们可以自己去从头敲一遍，不要粘贴复制！希望我的文章对你有所帮助，每天进步一点点！！！
: I7 z- f  {: L& U

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

& m% Y. p  E3 q4 n" \
十大排序算法对比
" C( p( d- B8 r5 c8 f0 }( E
9 J4 z4 q& R: T. ~& o$ _2 K

2 f3 D. N) q0 [( V4 O' X# R5 d+ n
  `% _$ d4 }. p1 y! `6 a9 H关于最后一列的稳定性，我稍微解释下，例如对序列：1 2 4 2 6 排序，序列中存在两个2，如果我们把这两个2标记上（让他俩不同），排序之后，前面的2还在前面，那么就称这种排序是稳定的，反之不稳定。


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


7 F4 i4 p( X: s* \" I
1 H8 f3 ^- _5 H1 ?" T

8 w1 Y, ]) ^9 e7 v0 ~1 b本文的图片来源网络，仅用于大家学习，侵权联系删除！（下同）

- Y' @: o/ V9 _+ L
完整代码：


package com.keafmd.Sequence;
" t. w+ d4 |! x! e
, c& B- j* ~5 a6 E- a7 ]6 t( O
- w0 L, [3 L! J& ^- W% _6 T/**
3 ^$ |' V: J, m4 c, q9 |  V * Keafmd
. T) h) Q5 K+ o! ^# R. { *
* @ClassName: BubbleSort
' f( R! G2 S+ l: @/ `" x * @Description: 冒泡排序
* @author: 牛哄哄的柯南
* @date: 2021-06-24 10:31
*/
+ ]4 c% F, }+ F7 I: f, j. F. T0 ^public class BubbleSort {
' X$ U0 o* m* i7 l
" C, g! Z; y( u+ I; c
( }8 c9 p5 c3 `( Y    //冒泡排序
) ]8 |2 y# g- c& y7 U! e    public static void bubbleSort(int[] arr, boolean ascending) { //exchange标志表示为升序排序还是降序排序

) w" m' h8 s) x+ i. a" N/ a
        boolean flag = true; //加一个标志位，记录上一次是否发生了交换，如果是，我们则进行下一轮，如果没有，说明已经冒泡好了
  w1 m& v8 U3 f) O
! |! ^7 T( W/ W1 c
        for (int i = 1; i < arr.length && flag; i++) { //控制次数，第几趟排序，只需要n-1趟，有交换时进行，只有flag=false就说明上一次一个元素都没有进行交换

' {$ @5 S, v( ~
            /*System.out.print("第"+i+"次遍历：");
" Y5 {9 D8 w' Y' X! u            for (int i1 : arr) {
3 i! s6 Q1 C4 ~6 Q" t                System.out.print(i1+" ");
! e/ E5 G) }& G- H3 J7 x            }
            System.out.println();*/
4 B' N& d- ~6 D) J9 L
/ }4 U# y; p; Z4 {& N
$ V) u6 I! V2 k            flag = false; //假定未交换

  Z& G% R2 {0 U; W9 P! h0 {; W7 Z
            for (int j = 0; j < arr.length - i; j++) {

; i6 p9 t" G* k% }5 t' Q
! `. V# K0 M/ B' G9 s8 r/ Z                if (ascending ? arr[j] > arr[j + 1] : arr[j] < arr[j + 1]) { //控制升序还是降序
                    int temp = arr[j];
                    arr[j] = arr[j + 1];
) s3 u" s6 A& |! t                    arr[j + 1] = temp;
                    flag = true;
                }

) A1 I  b* C7 V/ N5 c4 O3 l) b  g
            }
! T3 n2 p* R. P8 W8 C) s        }
    }
) g# @! G2 P  Z1 [: N. }- i7 }- [

+ j8 a/ }0 G# o# J" ?    //冒泡排序 -- 默认不传参升序
    public static void bubbleSort(int[] arr) {
0 v. o: B1 D1 n4 S/ W" _        bubbleSort(arr, true);
: @& ]1 w" |% G5 m( ~  m    }
$ y" l3 @  s$ F9 }3 {- j}
$ K& V7 y1 [+ O5 x1
  `4 k4 }7 z- \, I/ l2
2 F: h  ^8 r6 s) W) B3
/ F* L+ J! f- P' o0 k  @) `6 k4
9 |4 m* S$ d' Q, U' a: t7 i5
- h5 q4 H, m8 Y0 p6
% y1 e2 ?# e: f# S( k7
  N) s& \# q; g" Q$ B. s8 E" O! P8 [8
9
( w$ j" c* k1 N+ @10
- V' `9 {% I) X" ?  b( c11
, |6 h0 O5 L; N: ^' E" P# R5 K12
0 R3 i9 ~% }1 E- Y" {13
14
15
16
17
  }9 |5 j) X: P: D18
# Y  A: }+ L4 p1 F19
' X1 C( D3 G9 @' t9 N( G7 |6 _1 Y20
8 a  i/ I1 N4 P) p21
; j3 r4 Q# J4 G. F" {* K8 K22
23
3 W* W& M% i# `7 g24
25
26
6 K2 U. ]# L4 R6 Y; N$ r  @. I27
6 U0 G; y7 a2 e4 j  _" J; D28
% O. }, H% L" y, j) f1 n29
30
31
32
33
6 W/ n9 m1 n* `6 [, X3 }. s34
7 w( f. d3 v! r6 a/ i! a6 V4 v7 a7 |35
: T4 i$ t1 I+ q! r! r5 {* E36
37
' X3 K- o; E' g7 ^0 Y38
39
40
. a7 W5 V! {+ |0 @+ I41
42
  ^) H; y1 K6 q8 E; \' m1 n# f43
44
45
6 P- r( t/ J( Y7 k  `; G7 R& Q测试代码：


9 |, r8 C) Y8 Z* g- M4 L: b升序排序（从小到大）
- Q9 D2 {$ |5 Q( `; l

package com.keafmd.Sequence;

( M# N% }6 z9 K- o: y/ t& g
9 G( g5 `9 m( {import java.util.*;
. X. a3 I9 \& w$ f, @$ yimport java.util.stream.IntStream;
import java.util.stream.Stream;
$ M$ B5 n1 ?& p' E; i
! x0 }2 R: P% P& C9 K+ V
! s. ]6 b4 \, x- g( V$ s+ W/**
3 t4 `6 R; Z5 h * Keafmd
2 E: W  |6 {  `! |  \ *
* @ClassName: Sort
* @Description: 十大排序算法
* @author: 牛哄哄的柯南
7 k* v" J2 E9 O0 V  S+ k7 N * @date: 2021-06-16 21:27
% A: a9 Z4 p2 I! A */
/ r# z# i$ ?7 Zpublic class Sort {
    public static void main(String[] args) {


        int[] nums = {12, 4, 25, 47, 58, 34, 25, 9, 99, 26, 1, -13, 162, 10093, -66, -1};
        int[] temparr;
, j- i( V4 m7 L9 C& z; R' i9 a% h3 V
8 \$ a8 k4 }. v7 o4 ^, ~5 }
4 n3 ~) h9 _0 Y, k        //测试冒泡排序
# A6 q6 U) X7 p1 l* a9 p  k        System.out.println("测试冒泡排序:");
        temparr = nums.clone();
        BubbleSort.bubbleSort(temparr);
        //逆序排序
        //BubbleSort.bubbleSort(temparr,false);
        for (int i = 0; i < temparr.length; i++) {
            System.out.print(temparr + " ");
        }
        System.out.println();

/ Z  B! a7 d8 v# W" y
    }
}
3 c0 x6 u3 s' i0 x$ G1
' ^: t  r# X! L9 a% x2 {7 w2
+ r* h7 K9 w3 M% N3 v3 {3
' T# \* R' j6 s; U1 T: k5 T4
0 A1 K( d9 P' i" {. {) w5
6 b, x! t9 _) R& e3 w( s& m6
5 x- g4 z( O1 Y0 s8 L: {2 x  z7
3 V! A8 K( Y/ U" ?! _* H& E8
9 s; S' x- u! S& Q# T6 q! z9
+ V, G* E; W2 [2 A9 w10
" c( e2 U) M% V. I11
' `! D! _& m% ]. O+ ~12
13
( o4 w2 G! n" J4 O+ ?% Y6 R1 D14
15
16
17
7 k6 S+ M( _4 ], o# J  n- b18
# e$ _( K! ?; ^: w8 [4 B( |19
- G" @: F9 F6 [20
21
% n% F/ U* G+ U! c( s22
& A. Y+ \; g9 Q23
24
25
26
27
28
9 Q1 o4 b$ S) V9 J29
30
- `2 J' J+ e( ?: }' d31
32
3 H* O) q" v* s  N: ^33
% G  l$ C/ P# |3 S  U# }# B运行结果：
6 o4 x% j- k9 V9 n$ N) t/ M( t) Z
$ _. i% I) j; j2 e9 B& M# y
4 _7 l, Z4 h$ A  I测试冒泡排序:
! i  v# N  u) u8 j/ o4 b-66 -13 -1 1 4 9 12 25 25 26 34 47 58 99 162 10093
1
2
9 W6 a+ N9 F4 ~; K" b. A! V降序排序（从大到小）

7 k4 ?+ z. m5 p" |9 Y
//测试冒泡排序
System.out.println("测试冒泡排序:");
temparr = nums.clone();
BubbleSort.bubbleSort(temparr,false);
4 n7 H3 o0 H7 B4 O$ \for (int i = 0; i < temparr.length; i++) {
    System.out.print(temparr + " ");
}
System.out.println();
1
* T' \8 ~7 {8 u: @; O% w! M7 L/ n2
3
5 U1 D; r6 T0 O3 k4
  R: t% T7 g& F1 y/ h& J( T9 g5
6
) k4 d1 J+ p' s/ M- B/ \  b7
8
9 J! n, P3 @% f运行结果：
; E. ?; C: w  S; M+ v
$ p) Y. z' M# z1 g1 p  X
6 g2 b( _* }$ B% K$ j7 q, W测试冒泡排序:
10093 162 99 58 47 34 26 25 25 12 9 4 1 -1 -13 -66
1
2
下面几个算法的测试也就是换了下类名和方法名（换成相应的排序算法），如果想降序就在数组后面传个false即可。我就不一一复制了，我在最下面给出含所有算法的测试类，需要的自取即可。


快速排序
简单解释：
快速排序就是每次找一个基点（第一个元素），然后两个哨兵，一个从最前面往后走，一个从最后面往前面走，如果后面那个哨兵找到了一个比基点大的数停下来，前面那个哨兵找到比基点大的数停下来，然后交换两个哨兵找到的数，如果找不到最后两个哨兵就会碰到一起就结束，最后交换基点和哨兵相遇的地方的元素，然后就将一个序列分为比基点小的一部分和比基点大的一部分，然后递归左半部分和右半部分，最后的结果就是有序的了。
6 t; R7 j% t, w8 o/ _% W

5 O! y, E; [6 X& K+ D7 j5 B
  ?, Z3 N- D6 R8 x5 ^& D3 [2 K
8 P( V% P8 Y2 g# M6 A3 k

完整代码：


5 o4 |% u1 A8 v; h0 Rpackage com.keafmd.Sequence;
) A+ n: G" O& c4 k# g

: I4 f3 Y' o1 X1 m  h/**
* Keafmd
*
/ M- d2 b& E- d3 x * @ClassName: QuickSort
* @Description: 快速排序
* @author: 牛哄哄的柯南
8 E6 E# u" g4 N: w: _1 y" l2 a5 d * @date: 2021-06-24 10:32
, z# T. w- C: v8 V: \ */
. F! @5 B' y5 N5 `& b5 tpublic class QuickSort {
3 B- D* ?8 w8 D3 a0 a  l9 R) i# k
1 Y; P( n& u, a4 n& \' l. O
( k9 C9 G& d$ E8 O9 ]8 e% S4 z* K    //快速排序
    public static void quickSort(int[] arr) {
        quickSort(arr, true);
    }


    public static void quickSort(int[] arr, boolean ascending) {
        if (ascending) {
$ j7 z4 v& g8 s/ u7 [9 t            quickSort(arr, 0, arr.length - 1, true);
        } else {
: F  @1 K) x5 k" ]8 g+ y            quickSort(arr, 0, arr.length - 1, false);
6 U! ~+ U( _/ Y2 p5 |1 G; |% u        }
' u+ k# L9 n( v+ u* n4 l    }


8 z6 _8 L! i( F    public static void quickSort(int[] arr, int begin, int end, boolean ascending) {
" e, v  A) U8 N" V* Y        if (ascending)
            quickSort(arr, begin, end);
        else
5 E& [% z4 C8 P, f3 N. @/ x8 _0 }            quickSortDescending(arr, begin, end);
6 P% Y8 e8 A' ?+ e: F. u9 L    }
; P( k( H6 N  r% e7 ^8 H" ]

    //快排序升序 -- 默认
    public static void quickSort(int[] arr, int begin, int end) {
# q: _; r! M8 p6 L6 M5 H        if (begin > end) { //结束条件
            return;
        }
        int base = arr[begin];
        int i = begin, j = end;
0 X: R5 E& S$ D6 ]9 J' l        while (i < j) { // 两个哨兵（i左边，j右边）没有相遇
            while (arr[j] >= base && i < j) { //哨兵j没找到比base小的
$ V7 \" ~2 [9 i0 ~' K% @0 h( S                j--;
* G9 M2 [- ?4 H            }
0 i3 W& }' z# H: U2 B- Y* X5 s+ T0 [2 A            while (arr <= base && i < j) { //哨兵i没找到比base大的
, Q; H6 C+ C# _                i++;
3 v; Y1 ]5 v+ @! W- A1 [            }
; e) Q  P: v7 a0 y9 b; y            if (i < j) { //如果满足条件则交换
5 N. E& ]6 ^6 b# j                int temp = arr;
                arr = arr[j];
                arr[j] = temp;
% b% p4 R1 W+ M8 Q            }
/ y# R$ O# y, E! Q$ s
3 v7 z) o: b: c6 y9 V
3 G  }# k! l/ @  A: T        }
        //最后将基准为与i和j相等位置的数字交换
        arr[begin] = arr;
        arr = base;
        quickSort(arr, begin, i - 1); //递归调用左半数组
        quickSort(arr, i + 1, end); //递归调用右半数组

% _9 ^9 u4 Q$ o( @7 V
    }


    //快排序降序
    public static void quickSortDescending(int[] arr, int begin, int end) {
) D4 i. f$ ?' |8 [" y        if (begin > end) { //结束条件
            return;
7 @  o. I  _2 @$ {% U2 x        }
4 I4 A6 G( [; @# N        int base = arr[begin];
        int i = begin, j = end;
. \/ `/ ^: J  x' l, O5 l7 M        while (i < j) { // 两个哨兵（i左边，j右边）没有相遇
            while (arr[j] <= base && i < j) { //哨兵j没找到比base大的
                j--;
            }
            while (arr >= base && i < j) { //哨兵i没找到比base小的
                i++;
            }
            if (i < j) { //如果满足条件则交换
1 U# t  D, M" s$ p, b                int temp = arr;
                arr = arr[j];
/ M1 L, l! N, S8 A& W7 o, z" I# v                arr[j] = temp;
            }
6 Z; E+ R8 x1 Y) u2 n' @4 o

" Q% ^2 [) ]0 S1 E# e0 a        }
# I, X3 u8 @  M: D. D, G" s. d        //最后将基准为与i和j相等位置的数字交换
        arr[begin] = arr;
  c# h0 I8 X- S7 F9 y- T- t2 v        arr = base;
        quickSortDescending(arr, begin, i - 1); //递归调用左半数组
/ P. y  \" |; ]3 J3 V9 c$ O* v3 \        quickSortDescending(arr, i + 1, end); //递归调用右半数组
) B2 N# h2 u+ X) r' p' D0 x0 `% ]
: g" z4 n8 ]& I( p2 h  g4 X+ f5 g1 M
    }

1 K' s: M1 r, [8 I5 d+ n
}
$ A+ r" s! l* M3 H# D1 |1
2
; {. B! k. j( O- b5 x3
4
  B, \" `+ N& d" R, U. V# o, r% K9 A5
6
7
8
1 K; y2 x$ V' T2 n0 \' F9 F9
10
6 {1 c% Y* f' s) {+ {3 R) P/ T7 N11
: X3 [* w5 F1 k1 A* @) p8 k1 l12
6 M% y8 [4 F$ o$ U% F13
14
' X6 h' x+ d- m+ ?15
7 q  S/ S) ?  }7 ^4 t3 B& j; S; Q1 \16
9 W/ E2 w" D1 X/ p17
18
( c: g! j6 ^' g8 O1 t& K7 y19
- K4 N& d' F, v; i3 @) S20
' O: I3 [& h2 e5 q$ S8 P" Q0 f21
22
0 E; N! F! F5 [8 i$ G23
8 `/ }7 J0 C! f. d7 i. c24
* `" B! B* O  A* Z) N25
1 V# C* n5 @9 ]7 S8 u- B) H, G26
5 P! G& e  Z, E5 K27
28
29
30
& O: m0 R5 \5 V; w31
32
- F, N" b1 x: L1 G2 P' B) |33
34
/ Y, z- \/ N+ c& n5 ^# {# a$ f4 X/ o35
36
37
% |, C. u+ {& g0 E& y- s38
0 V( p1 [& U; A4 e39
40
41
$ Y" ]0 L3 I# W4 w( w42
43
$ u9 V' }- B- g5 k44
45
, U5 r8 a7 @- ~: J! t; @. v46
  _0 ~0 r0 n' D* h7 V8 C8 l! M# M# p47
48
! P, \3 U* V# E1 G8 J- n49
% }% j  m1 n1 q; ?$ `, s: N50
: _7 e6 B$ L0 i& @7 f51
52
53
54
' ?1 h& d# z; X55
56
57
$ E6 g$ z- |1 V! W58
59
4 _$ z  l$ u0 w* m6 H* G60
61
6 L5 \) I3 h( p4 R- `62
0 N( U! s8 t* B63
64
65
9 d: U: s/ I0 P) R/ P% ~8 u5 T8 ?5 \66
67
68
9 c  |6 A  R9 a/ j' l( _+ \69
8 Q& C4 K, N. X: R8 V; P+ A& i70
71
72
) d9 X. X$ `& o8 b; i& a73
74
75
76
4 d+ V- i# ]3 Y) L; r77
78
79
! Q6 X0 V' _. b" v! A# V9 m80
: S4 t" b: t* ?  C81
7 C0 C# p* U! z! z, A5 }8 i82
! P0 d$ v' `% V3 ~83
: W1 m1 O8 e: B: ^  b3 Q84
85
86
87
( [. _$ W2 M3 ?+ {+ y: ^& p7 ~3 o88
89
90
. `4 L5 h, n" p& A91
. F5 d  X4 x$ V& j* Q4 `直接选择排序
% c# _' {' F+ f& {4 v* a简单解释：
数组分为已排序部分（前面）和待排序序列（后面）
8 }: j3 g$ B3 |第一次肯定所有的数都是待排序的
0 c0 a6 D* n4 r7 `8 C4 S5 }+ q& J从待排序的序列中找到最大或最小的那个元素，放到前面的已排序部分，然后一直找，不断缩小待排序的范围，直到所有的数都是已排序的了



5 b% J' t* G# k! M4 }


完整代码：

% e& b1 u+ R- C7 Z9 x3 R  r
% b, C4 d( l3 k! |" O- F& |4 l% Vpackage com.keafmd.Sequence;
6 O& [5 \# x& O4 x" Y/ ]- U% k- [
% K/ r7 B( f/ b8 H0 T# n6 c
/**
* Keafmd
1 l$ p# c- O5 m: D0 R  t *
; S; j6 V& z* E; g * @ClassName: SelectSort
* @Description: 选择排序
3 ~, z9 S6 P' Q: v+ g* F9 Y; ^ * @author: 牛哄哄的柯南
* @date: 2021-06-24 10:33
*/
public class SelectSort {
; ]' l' G% o# b% _+ s$ K' Z

    //直接选择排序
0 q9 t2 T9 _) v2 p- K6 X( b$ L: l    public static void selectSort(int[] arr, boolean ascending) {
2 E! E( s9 L8 C1 ?* Y        for (int i = 0; i < arr.length; i++) {
            int m = i; //最小值或最小值的下标
- v- \5 O) b5 H5 U/ g            for (int j = i + 1; j < arr.length; j++) {
( j1 t1 m) \- w4 k' X. ?, R, s                if (ascending ? arr[j] < arr[m] : arr[j] > arr[m]) {
                    m = j; //找到待排序的数中最小或最大的那个数，记录下标
                }
) [( \4 K; Y5 |$ `

            }
8 `' N" f1 T6 G; i* l* X            //交换位置
            int temp = arr;
. D- t: C; V% @7 h, t, |  A            arr = arr[m];
7 r" ^" e; P: F6 k% Q0 Z5 B  @            arr[m] = temp;
6 m& v* r+ F6 A, ^

5 w# r1 A5 [9 ?6 A' u        }
/ G( K, x  `- X" L    }

. `  ~4 M) x* D2 A3 z
# J8 J- E1 Q# D& ]4 e) S3 Y8 R    public static void selectSort(int[] arr) {
; Q2 J8 T" \* b. N7 p        selectSort(arr, true);
6 W3 Z. a7 M, C/ \7 q! S" \& ]    }
' s$ [; N9 n# d: F2 u}
3 X% n. i1 H* E$ C4 g/ o* S- `1
( J4 p4 d  u; @2 C; \2
' D" m8 e4 t! |0 P/ d# X3
4
, a' [# r3 w1 I; \& ]0 i/ M- Q5
6
7
8
( n2 s# K  o8 a8 F0 D! X9 d3 H9
" L7 B% ?. ?  U) G* _9 h8 \10
11
+ h* r5 S+ ^* C4 E, K! z12
13
/ _6 I% t# Z6 L( y. P2 w  w8 x) N! K14
15
' G% A* w% ?* u3 r8 g, H" u# o16
/ \- [' |& n+ |17
9 Q. Y- Q' v4 {& f+ _18
19
20
; b+ {+ v: {, q9 M21
22
4 Z1 X, z1 O! x; W7 I. g, i23
24
0 q) I( y  Y' |& V% N25
5 n, c6 e2 J9 d, P* d( P  ?26
9 w4 I3 Q8 P" a  b+ e27
' J; w: V8 |! k6 d, J" \: q! ^: x6 v28
- N& I; \4 u- M29
30
0 q* T; W1 n6 i: r" G31
0 ]7 |4 h0 S7 {  f: X3 X6 V32
33
0 X' c/ p' h, ]! j7 Q34
堆排序
先理解下大顶堆和小顶堆，看图
. K4 W2 v8 @4 J& F9 u4 _大顶堆，双亲结点的值比每一个孩子结点的值都要大。根结点值最大
6 A6 o+ S2 m3 d% Q小顶堆，双亲结点的值比每一个孩子结点的值都要小。根结点值最小
2 w" S: E- {6 {: d/ I( K

5 L. m7 X6 g  o% r# T

$ m# x; M( w0 H6 m简单解释：
构建好大顶堆或小顶堆结构，这样最上面的就是最大值或最小值，那么我们取出堆顶元素，然后重新构建结构，一直取，一直重新构建，那么最后达到排序的效果了。
% D: y" }1 l. f0 B
" _6 J. a# d  [7 g  L4 H) d9 ~
! J% H7 [( V8 d6 J- r3 `8 v# I$ {



完整代码：
" s6 ]8 }: w( b# P2 a: e

package com.keafmd.Sequence;


7 h3 U, W# N) |( q8 y4 m/**
* Keafmd
*
. T. `7 F0 \: {/ g% j * @ClassName: HeapSort
* @Description: 堆排序
% N5 W0 `1 e$ a8 T' E) v! _ * @author: 牛哄哄的柯南
, Z) F6 H4 J2 p' d& T' F  f2 Y * @date: 2021-06-24 10:34
! c( B/ }* h8 s9 u* a. v  D7 e */
public class HeapSort {
" ]$ F' Z; o" Y7 W  v
8 C' u( p/ b( K7 @% |6 b
    //堆排序
    public static void heapSort(int[] arr) {
        //对传入的数组进行建立堆，这里默认建立大顶堆，进行升序排列
        heapSort(arr, true);
    }
, c" j% C" Y# o, j5 p) H* \( X

    public static void heapSort(int[] arr, boolean maxheap) {
# {7 j7 W- }9 z0 O: M3 Z

( c9 Y5 I/ m* W4 I$ v8 _        //1.构建大顶堆
        for (int i = arr.length / 2 - 1; i >= 0; i--) {
7 O1 X% l4 D5 Q5 c0 o            //从第一个非叶子结点从下至上，从右至左调整结构
            sift(arr, i, arr.length , maxheap);
        }
& \8 i7 v6 U! w4 D& }
- ^, Q& \  A& i
& A* ]. O: F6 w0 D1 J# i) I  @8 p        //2.调整堆结构+交换堆顶元素与末尾元素
& T+ I* b5 [8 W( {; B        for (int j = arr.length - 1; j > 0; j--) {


" m; i, n& Z9 q1 f9 V3 J2 i            //现在的数组第一个就是根结点，最小值所在，进行交换，把它放到最右边
+ Q2 h* {  r6 d  P$ L            int temp = arr[j];
            arr[j] = arr[0];
6 [7 S0 ]& L$ A- c9 v- Z) o0 d            arr[0] = temp;


; n( ^; {5 E/ C! R+ H& N! I            //重新建立堆
8 I# K- \( ~6 L3 N; {* M            sift(arr, 0, j , maxheap); //重新对堆进行调整
        }
- t! w8 P6 x) |, R. W    }
2 [( R5 c7 E/ H8 e9 l9 B2 `
# d6 _' w& `1 O6 ]
: I  K+ T2 b* Y0 a+ y    //建立堆的方法
( @+ g' f! n8 B. o    /**
     * 私有方法，只允许被堆排序调用
     *
     * @param arr     要排序数组
     * @param parent  当前的双亲节点
     * @param len     数组长度
5 |- N; N' m8 C6 a4 f' _     * @param maxheap 是否建立大顶堆
     */
    private static void sift(int[] arr, int parent, int len, boolean maxheap) {


, M) w0 ]1 S5 o4 c9 Y) W  B* q        int value = arr[parent]; //先取出当前元素i
, x  `; `3 r" ?9 F1 u/ i; X2 J3 p
  x8 u# J0 K6 f7 T" ?6 {1 ^/ r2 l, Y
$ X) f  H2 ^- ?- V' W6 r) T2 @        for (int child = 2 * parent + 1; child < len; child = child * 2 + 1) { //从parent结点的左子结点开始，也就是2*parent+1处开始


0 }4 w$ H; o0 B# ]2 G            if (child+1 < len && (maxheap ? arr[child] < arr[child + 1] : arr[child] > arr[child + 1])) { //如果左子结点小于右子结点，child指向右子结点
, D; ~  A  i5 K! b0 u                child++; //右孩子如果比左孩子大，我们就将现在的孩子换到右孩子
            }


            //判断是否符合大顶堆的特性， 如果右孩子大于双亲，自然左孩子也大于双亲，符合
            //如果子节点大于父节点，将子节点值赋给父节点（不用进行交换)
3 E6 L$ \3 ~2 ~* m8 b& t) e6 }            if (maxheap ? value < arr[child] : value > arr[child]) {
                arr[parent]=arr[child];
1 |8 m" m+ ~! @" X( o0 w                parent = child;
            }
( m1 B, u1 c+ N: F7 c- x. N% [            else {//如果不是，说明已经符合我们的要求了。
                break;
            }
$ s+ m9 _+ C/ A8 [/ I        }
& }( O6 `4 J9 L' l% ^& K        arr[parent] =value; //将value值放到最终的位置


3 l# p& b! `$ v, A7 C8 O% V
2 \" |) W! d( ^9 I, j1 ?: Q
    }

" J/ ?0 M- p, D! {2 J
}
' N( |. _, W( C1
2
+ g0 D8 ^- g  }' D3
9 F) h# h' R4 U0 k( e5 q4
5
6
1 m* ]4 O5 A" v7
8
/ w5 s4 Y; Q% z9
10
11
  c6 k; ~5 b% u12
+ B+ m0 v4 b$ L& ?8 P* O$ N9 R9 k13
! i" {+ S' `$ \1 F) b14
15
/ a2 v6 O5 I; d# R* q. X# _8 r2 d16
17
& [: K% a, e8 @18
  \4 P4 E( P% }( [) f19
20
- P# `6 E: T9 |# ?21
22
) a: {; F' E  N0 \23
. s6 @8 F4 h) W# j& ]. x& f# E24
; i3 c" O& J+ A% V25
$ T$ \; @# [/ @/ @26
27
5 \3 d2 T! \4 G3 z8 m- g$ I! {28
29
30
# V+ B0 w) ?# J31
: o- T7 O* |( k. h5 Y32
5 h) }9 P( y( S$ t2 R33
34
  }+ k) p5 {& r; J* a1 Y35
36
% R; Q# t  t2 c: T9 V0 B3 H37
4 K, Z3 T; k; y8 u' g38
, M5 m7 O2 X1 \- _" Q8 V39
40
41
6 Z, S, z  M: }# ^% f% v2 Z42
/ n- L# w8 b) c* v; S  N9 ^& x: e+ ]43
8 c! j2 z! F# u8 H/ j6 D! [4 S$ _) I44
45
! D) W3 M# e& Y" V9 y5 j6 z% z46
47
48
' F# R7 J+ x% |/ x2 \9 ~! L49
50
51
% Q  `4 h) f4 J: g52
53
54
55
56
& c+ l( b7 Z. y, l' l1 f/ ]57
0 E$ V& L9 O4 {5 U58
59
60
61
$ X5 ?0 G' Y) u! h62
63
. r) c, B& [- e. V* x64
. r& H; o% G) s0 y# M65
/ Q: d6 y+ ?$ u  f) i66
- b& t7 S0 C3 X( v5 V& Y7 ?67
* _: U* {3 k1 n# r5 p( G+ I68
* f  W' _! `+ j' x4 e69
6 X# t$ Y% F- R0 O70
" E5 V1 M& a9 k! I71
& [# W0 M" N. r9 w5 ^72
( A, R3 l# ]9 M; E73
9 I5 |( F1 M+ U- R+ \) e6 f74
6 G: g9 a  P0 j# e- A归并排序
简单解释：
8 c, P. T( _( Z该算法是采用分治法，把数组不断分割，直至成为单个元素，然后比较再合并（合并的过程就是两部分分别从头开始比较，取出最小或最大元素的放到新的区域内，继续取两部分中最大或最小的元素，直到这两部分合并完，最后所有的都合并完，最后形成完整的有序序列）
/ _$ d' @4 u( l7 x5 q
2 q) L2 r) ?- [


1 ^* i3 Y1 p5 M
/ z2 i" F" b/ g$ E. ~5 z
完整代码：


package com.keafmd.Sequence;

( C9 W& f5 g' ?: ^9 X/ Q$ E& A
/**
* Keafmd
8 _) |. _( v! x1 ] *
* @ClassName: MergeSort
# y2 [4 A& z# H3 i1 Q * @Description: 归并排序
* @author: 牛哄哄的柯南
1 K+ e) j! }2 B1 F# U+ c, Q, k7 e, _ * @date: 2021-06-24 10:35
$ K! Z. M4 x; G3 I- w: ^ */
public class MergeSort {


    //归并排序
$ L+ W( S+ [* @) K2 e8 _    public static void mergeSort(int []arr ,boolean ascending){
& p6 K0 K& j# ~0 ]        int[] temp = new int[arr.length]; //在排序前，先建好一个长度等于原数组长度的临时数组，避免递归中频繁开辟空间
        mergeSort(arr,0,arr.length-1,temp,ascending);
5 W: X: d+ l9 t2 S    }
% e- |, A* S# {9 w: }8 Q' ]# F  t    public static void mergeSort(int []arr){
$ r! B6 a  F% G/ ^3 L/ n        mergeSort(arr,true);
2 A, a3 ~$ G6 s    }

9 d! K' w6 x) u; e. T' u
: H6 M" E+ }$ G+ |2 X6 \. t    /**
' p: i6 c0 ~6 L$ [4 d     *
     * @param arr 传入的数组
     * @param left 当前子数组的起始下标
+ k, B! @: Z  h/ @     * @param right 当前子数组的结束下标
$ _" v1 B! a) n2 E1 A2 n     * @param temp 拷贝暂存数组
     */
    public static void mergeSort(int []arr,int left,int right,int[] temp,boolean ascending){
        if(left<right){ //这里是递归结束的条件，我们是对半分，那当left==right的时候肯定大家都是只有一个元素了。
; m/ t8 K9 d: a. `
$ e" `; Z' }8 e; Y% k; T
5 \8 c  _. o" z            //对半分，比如总长度是10，left=0，right=9，mid=4确实是中间分了，0~4，5~9
6 ]$ f  K2 F% [; M, h! _7 ]2 g            //当长度9，left=0，right=8，mid=4，0~4，5~8
: |6 U5 R; Y& N% P            int mid = left + (right-left)/2; // 防止越界的写法
            //int mid = (left+right)/2;


            mergeSort(arr,left,mid,temp,ascending); //左边归并排序，使得左子序列有序
            mergeSort(arr,mid+1,right,temp,ascending); //右边归并排序，使得右子序列有序


) @, {8 F: @6 h' _" \5 U% j            merge(arr,left,mid,right,temp,ascending); //将两个有序子数组合并操作
5 {) {6 f! m4 Q" h        }
    }


, \& m2 N9 i$ |5 @    private static void merge(int[] arr,int left,int mid,int right,int[] temp,boolean ascending){
% i% _9 F" p' b$ |9 I        int i = left; //左序列起始下标
        int j = mid+1; //右序列起始下标
        int t = 0; //临时数组指针
2 t* s# Z1 b: Z5 D8 o  j        while(i<=mid&&j<=right){
# T- d: b. m! }$ ^' g5 M            if(ascending?arr<arr[j]:arr>arr[j]){ //比较两个序列第一个元素谁小，谁小先拷贝谁到temp，然后对应子序列下标加1
                temp[t++] = arr[i++];
            }else {
. d6 ?# ^% w, A( h/ a: S                temp[t++] = arr[j++];
# u7 h# c' S/ ~            }
& O9 d3 q: Z0 b# E6 z        }


; p# M$ D; i7 A2 Y        while(i<=mid){ //将左边剩余元素填充进temp中——左序列有一些数总是比右边的大的数
$ ]+ A9 r( {7 K; u0 d& P            temp[t++] = arr[i++];
5 `: U( ]& k( r9 [2 Z; `  ~        }
/ s/ z1 Z  _( q' n

9 `+ g& f1 X* d  H$ g( M        while(j<=right){ //将右序列剩余元素填充进temp中——右序列有一些数总是比左边的大的数
            temp[t++] = arr[j++];
# q/ {; ?" R1 P        }
* ~8 F( ^( ~1 M0 M+ f! H! F
* {: z, A1 e( @% Q6 e+ U
, O$ F8 N/ Y3 D4 W/ ~$ {! W        t = 0;
9 i" ?" {! h/ m% d* j7 [

        //将temp中的元素全部拷贝到原数组中
6 B& G. C; O$ i$ \, {2 x: j/ p        while(left<=right){
            arr[left++] = temp[t++];
        }
" R6 f0 j- c6 b" D0 f! Q

! I0 l1 d  C$ A. L    }
7 N5 O, A* q" y$ Q
4 ~/ j% ^& B& I
}
- p* h5 j, _3 m) c* F! A1
# B6 @$ ^0 E- b2 B2
3
4
$ u. M# @. x9 B: n2 u7 q5
. }/ P6 r3 Z$ I' j- @8 {, x; p; V9 a6
7
8 |2 t3 K, `  Y8
9
( b4 e7 T; G% t! X10
: e7 w& H7 R1 f% u11
4 [) G& |5 }- J5 V, c) D12
13
14
; p0 O' N- F: k- g5 X15
16
17
18
5 d' n' D1 T  {$ U9 ]19
4 M" B& B+ v" y- v20
+ Y( ~1 s9 u1 N' _  I! J21
22
0 F$ i( r- L% f+ t23
) H& L' i% d; Y# ]2 L+ q24
25
26
27
* _4 q6 X- n* j) o0 W# L28
29
30
31
2 u9 L; }5 N' A1 ~+ U; f' {32
& m' e- }2 O, Q: Y6 Y8 x2 W8 v33
& e  n! G3 u0 G: s- |& |34
. B, u2 v2 C0 X$ R9 p35
36
37
38
$ T$ L0 {1 }! ?39
40
41
42
( {+ w4 s  N' x43
& a" l$ J9 o% u2 U% l& c: o) A44
1 `7 `! ^  b  P6 I: d6 ^0 Z8 \. ?. U45
46
- D5 e2 H( ?$ s/ I0 p3 {2 g" W47
48
0 `' @0 G( K" a. Y- Q. O- @49
  C0 q1 z$ D# {& F3 \& P6 L6 d50
51
+ l4 b- K" S& g52
53
54
/ @! t/ n/ L! s. g, M" W55
" [" V# ]% ]* D3 H. [56
( k7 `2 l- n: q* i0 R; L- c. W57
58
59
60
3 c6 {3 y* z' [0 w! G+ k61
62
63
7 e& g6 N1 E: b1 _0 Y. g64
65
& S; M# w9 a/ f; Y" T" U7 W6 e9 N66
1 R7 u) i8 L# O, R67
" J! R& ]' k' c5 p7 s$ V6 D68
6 T) p: E" L# ]& y& ]4 D. R69
) P& s3 C5 J) p9 M- l' S6 ~/ a5 t70
71
8 y2 T, h- v& O. K* ^6 [3 ?3 Q% U72
! P3 o" h" V$ L4 z  o6 V% m% R73
插入排序
& ?$ R  n- T+ Z0 R$ T# Q# l简单解释：
最简单的理解就是打地主时我们拿到牌后的整理过程，从第二个牌（假设我们拿起来这个牌开始比较）开始，（说下升序）从后往前比较如果比前面的那个牌小，就把牌往后移动，直到找到一个合适的位置（这个位置的前面的那个牌不比这个要放下的牌大）就把这个牌放到这个位置，慢慢的前面的部分变得有序，直至全部有序即可。
3 k0 G. z/ _/ _2 U
4 w* r9 [' `$ d+ H( t. b: j

# s# q. _: N8 C

) q: j& G( U) Z6 G: A
完整代码：
, t- |8 M( q& X8 y! P. a3 M" D/ U

' K9 g# V5 l8 v( b' _& Z5 \; npackage com.keafmd.Sequence;

& h0 |; j2 p3 i& O' B8 i& E3 k
/**
* Keafmd
& T  u- R$ N# k- [3 }% p! |, P *
# {1 I( \) z8 X6 s/ q5 _; N * @ClassName: StraghtInsertSort
* @Description: 插入排序
* @author: 牛哄哄的柯南
. K- r$ o" L) Y * @date: 2021-06-24 10:36
- j1 k' V) f& z! X0 s */
public class StraghtInsertSort {
+ K( N6 @/ p/ f    //插入排序
% H# @* R$ `7 T$ X6 \    public static void straghtInsertSort(int[] arr) {
        straghtInsertSort(arr, true);//默认进行升序
    }
" t% F' _! I8 H/ E. m; t6 t' |! n

    public static void straghtInsertSort(int[] arr, boolean ascending) {

. E# h+ P0 U6 E* u5 q, f, ?
        for (int i = 1; i < arr.length; i++) {
            int temp = arr;
            int j=0; //这就是那个合适的位置
) q$ O9 s$ ^' C& }5 J            for (j = i - 1; j >= 0 && (ascending ? temp < arr[j] : temp > arr[j]); j--) {
                arr[j + 1] = arr[j];
! L0 ?; w, V7 M7 c            }
: G: m" g- @/ l; B8 m1 Q            //把牌放下，为啥是j+1，
: W1 ?" V$ A# c4 t; M! P            //是因为上面的循环遍历到不符合情况的时候 j是合适的位置的前面的那个数的位置
            //有点拗口，但是就是这个意思，看图方便理解下
            arr[j + 1] = temp;




1 N# B- V" R: ?; r7 }& Z# u' s        }


    }
}
% D- b0 n: v5 l8 {# F) @) L1
3 [1 b1 K* u) x" e/ P2
3
4
! n+ y( Q. n$ W# o: v6 z" Y5
1 H2 C! v: i+ G0 B1 Y- X. p; Y) V6
7
8
9
$ e% r2 c) ]( x& l! s10
11
12
13
/ G/ ^5 E" Y' l+ C7 g3 a8 Y( \14
15
16
17
18
19
20
21
4 E' m  G. F0 i- f7 L7 o2 `22
& b1 L; i- N: P, n& N# w23
  H8 o7 {6 G, @) s2 z1 n2 ?/ f- i24
25
& s* c: W6 a# p, y3 o* O6 X26
; E$ B* N" S% ~  G* S27
* D6 `" H1 S$ A: \28
( C3 h. p6 P+ Y3 b& t29
" F/ }) t& T9 v9 n/ E30
31
; k8 O2 j: Q/ k. s( e1 P6 v. Y2 i32
5 z1 A+ I% ?( O, i33
34
希尔排序
6 k* [/ M) q  T6 A$ ]# `9 U简单解释：
希尔排序是插入排序的改进版，我们理解一个叫做下标差的的东西，也就是下面那个图中的增量d，初始下标差为arr.length/2，然后继续/2，对在同一下标差（相当于把这几个数单独拿出来了）的若干个数进行插入排序即可。
: U4 h$ D$ _) L: Z





完整代码：
5 F6 G. i* _( i7 n; W! y
- ^# a+ \* D" t6 P3 T9 ^
% |6 J+ b7 e5 X' ^6 jpackage com.keafmd.Sequence;
  C! P, f) G! N8 ?/ N

2 U; ~4 C. g9 p* e/**
* W4 q5 Z  Z- y! x. J+ i0 ? * Keafmd
*
* @ClassName: ShellSort
, z* h2 a6 t' d/ ^ * @Description: 希尔排序
: P3 E3 P9 n# S/ m& P# }3 r * @author: 牛哄哄的柯南
* @date: 2021-06-24 10:39
*/
public class ShellSort {


    public static void shellSort(int[] arr) {
" [) ^- U7 Q& M( M+ s2 Q( n+ ]        shellSort(arr,true);
    }
: f1 ?' |* Q5 G. n# X" a

    public static void shellSort(int[] arr,boolean ascending) {


        for(int d = arr.length/2;d>0;d/=2){


0 D' `. E* e/ t4 m5 h' W3 m            for(int i=d;i< arr.length;i++){
* u' a  y0 X+ v/ y0 C; x, ^                int temp = arr;
2 C1 k2 i8 I0 C+ s& B5 V" S9 x                int j=0;
5 G0 ^  B3 J. z! T                for(j=i-d;j>=0&&(ascending?temp<arr[j]:temp>arr[j]);j-=d){
                    arr[j+d]=arr[j];
& S8 ]3 p7 K8 j, J" k0 ~' O. ]8 u! m                }
                arr[j+d] = temp;
            }
        }


    }
  y$ L  i" g) V' i1 Q: g( L5 o}
6 j# J  g; P$ X3 A: N! B0 y1
0 z/ {% R* I0 E$ U- n2
/ ^8 e. u/ ]3 M1 O) t6 Y) |3 U3
' E- d3 P0 i5 r3 E8 q( N4
5
6
( ^0 U5 [5 |' T. }- ~; @- T7
: s$ b3 y  w) n# x/ ]) m8
9
1 w% [4 r) g% J2 D( I& p7 r. ]10
5 u' s8 X% m+ ]  T11
12
13
14
: D  a/ S. \& A- Q, ?( B. k$ k15
16
6 j! l: i8 b9 B7 f17
' M$ p" S% ]( @18
* V* |! k% e; K& }9 d0 `19
6 a( o. E7 U: G& N. t20
! h' S: Z* N+ t7 Y& A( C- R21
# u: f; c( K) h+ u) P& x22
23
6 y5 u3 i: t$ M% F6 C1 D! A( c  e24
( ]) T% M" O: Z. O; u2 x8 F25
26
1 y1 k) r/ z" D! T% t; w( }27
28
29
30
( L+ u) U) U- M# V& ]31
32
计数排序
简单解释：
这个排序算法看名字也很好理解，就是就是额外找个数组来计数，然后在这个数组从小到大或从大到小把数取出来即可。

) Y: U. h% y& E9 F+ R


6 W! F1 p' z# l  M2 l2 J- V% }
6 U% @1 _3 }7 T7 d) }8 ?  b
, F& I; P8 b/ _( X. {( M完整代码：


1 v3 M+ C7 f3 d7 I5 K+ Npackage com.keafmd.Sequence;

$ W$ D: H) e$ g! i% \0 i0 v: g# {
4 E' l% [9 R/ |* x$ ^/**
* G7 T3 V1 u/ K% N0 s- G- M * Keafmd
*
& k( m7 g3 r7 O# W * @ClassName: CountSort
% N1 Q1 r' P! ] * @Description: 计数排序
* @author: 牛哄哄的柯南
$ n2 _1 J- z2 \8 n/ v. ` * @date: 2021-06-24 11:31
! f2 }* S! \+ s, s7 E */
public class CountSort {

6 P" t/ y4 Q( G1 o3 \; P6 W; o" x" P
( Y- S: B. o6 G' q$ [4 A0 B( Z    public static void countSort(int[]arr){
! ?+ V5 @7 r5 V: V1 t7 n! h        countSort(arr,true);
3 Q) a! G4 g5 U8 R    }
: c6 F! R% c" \8 Y4 h. O8 o
  {; b* P% W) i+ i
  I$ |0 s1 c0 {! X& o/ W0 d    public static void countSort(int[]arr,boolean ascending){
        int d,min=arr[0],max=arr[0];
! A4 Q- V7 v4 m) B: {  r/ c1 e

        //找出最大、最小值
/ ]. s. n/ u, A' J+ ^        for(int i=0;i< arr.length;i++){
0 Y( Y) l* T7 C; N0 d            if(arr<min){
( B. \4 F* G. X$ o* i0 ]1 [/ E$ G                min =arr;
            }
            if(arr>max){
+ G" }8 {0 o& Y  N: B( A4 e                max = arr;
1 \" }9 t1 s0 w. G/ q            }
6 J' L. x& {# Q& Q2 T  }4 w: y        }
% \( v4 `( `  w! H. m% u. w

        //建立一个用于计数的数组
5 i5 S( a1 t2 i" ]; m2 B        d = min;
; P" Y6 T8 E4 \5 Q        int[] count_map = new int[max-min+1];
* N- n1 N) b! d$ Y/ i5 ^6 [( T' X        for(int i=0;i< arr.length;i++){
/ c! T0 c* C; t            count_map[arr-d]++;
* o. q! q+ j7 K; m1 r8 m        }
$ ^2 G8 Y2 A+ d/ k5 ?

0 l, ~6 w" n/ C9 I- e. g        int k =0;
" x8 C1 X2 V& k4 O5 h0 y* ?        if(ascending){
! i8 c; S6 X+ O, y2 f            for(int i=0;i< arr.length;){
4 c" p2 l7 s! _' k+ n7 ^$ M                if(count_map[k]>0){
2 f7 S' i+ C" K( F$ F5 @                    arr = k+d;
                    i++;
                    count_map[k]--;
/ Q. N6 F5 O5 |% K+ T                }else
                    k++;
            }
        }else {
            for(int i=arr.length-1;i>=0;){
; w6 r! D! T3 g0 ]! e; p                if(count_map[k]>0){
2 K. P! z" U! P5 }1 s2 J                    arr = k+d;
                    i--;
                    count_map[k]--;
" N7 \" W" n* h. Q; }) x4 q                }else
                    k++;
3 a9 {. O3 P: S( d/ ^0 H7 p/ z            }
        }
( |0 R" v' _/ c9 Q) |5 h

    }
' p- r- U) Q. i( P3 O* f% [0 \}
) Y. P" x3 F6 v! N1
2
$ M6 e; M3 b& p+ J" k  a8 W3
% o1 D+ t: l& g' |% a4
8 o. y* [' }* ?' V1 H: Q5
6
7
8
" p* X( p8 f1 h: ~! f& O4 s9
10
6 o; W5 K6 b8 j. Z* v11
' h. N* f, B7 A/ Y12
13
8 }% D6 a( r" m# `4 E$ e6 w& r- J14
) o& n( v3 d7 C15
3 K% b0 y* {4 m% W0 J( t+ @9 w16
17
18
6 ^6 }! Z: c3 I19
, n* v. O: l. H9 K( j' U20
  a5 ]' X$ }3 J, u, R" g21
/ d+ C6 E- j7 a& C# s22
4 C' H+ T! G$ h23
24
+ P9 d0 `/ F0 E  B0 J& W: H. J25
26
6 O4 x; d% _8 D1 L2 V4 P5 J! u( [0 s27
; `3 G* L  F7 [4 [28
, g) C" F5 l& H( f3 \29
30
: [' n0 @3 f; t1 \) D31
32
33
, ]' f4 {* ^. z5 A6 R34
35
1 c2 s1 V5 }1 H  E36
7 p! v3 x: C4 ^$ y. u& A* Y* ~, D+ F1 D, r37
38
39
; q, w! o- x6 |' c' a40
41
42
1 r, V/ h0 t* A& T9 }& v) f43
44
- i4 S6 R- E7 h. f45
. a' y$ x# ^( S3 v" `, E46
" h8 \0 N& u$ r* c/ M1 V$ v& Z47
0 m7 p$ B/ s# c; ]; b; ^48
49
50
/ ^; f* W( E. g- H/ o51
52
53
& D/ r! }% P8 F7 J8 P! h54
3 ^0 X+ X' P4 l* w' n55
& m% u2 e9 x* E$ _' l$ k56
% {( I) B* e1 k4 {  \& [57
58
59
桶排序
# t' ~  D2 t2 `- p. U& B简单解释：
就是把一个数组分成几个桶（其实是几个区间，从小到大或从大到小的几个区间）装，然后让每个桶（区间）有序，然后取出来放一起就可以了，相当于把几个有序的段拿出来放一起，自然还是有序的，当然需要是按照区间的顺序拿了。



9 |, m2 t% j. S6 m; W


完整代码：


package com.keafmd.Sequence;
$ H- w/ J2 v% W2 P3 g) X
+ w9 V8 e# |; ^1 y, D
9 r/ w5 w- z, D- ^* x1 O" rimport java.util.ArrayList;
import java.util.Collections;
1 F. K0 @7 _, |
0 K! w% H- ~1 I% n; X* |( U
, S/ A5 V7 r9 W" T/**
* Keafmd
5 H: N5 B; g1 T+ X  M8 h. ` *
* \! t& F) z% L% V* r& | * @ClassName: BucketSort
  E+ a' W# E! b4 j* n * @Description: 桶排序
* @author: 牛哄哄的柯南
* @date: 2021-06-24 13:32
*/
public class BucketSort {


    public static void bucketSort(int[] arr){
        bucketSort(arr,true);
1 ^! p6 }, _" T  b1 Z    }

0 R7 a! N8 G- F
    public static void bucketSort(int[] arr,boolean ascending){
        if(arr==null||arr.length==0){
3 A- r7 j- {. i. Z0 @0 M  H! _$ j            return;
/ C( V; T8 h  j/ e6 F        }
        //计算最大值与最小值
        int max = Integer.MIN_VALUE;
        int min = Integer.MAX_VALUE;
        for(int i=0;i<arr.length;i++){
            max = Math.max(arr,max);
6 x2 }) g  H# d" d: @3 |" b( D# k            min = Math.min(arr,min);
* g8 `6 w) f4 H        }
, E! l; \, q5 n6 W! x: i

. }% ^2 T" H. n5 g# J% \        //计算桶的数量
( ~8 y% i' J2 e7 ~- |  i        int bucketNUm = (max-min)/ arr.length+1;
. M/ L4 k: @4 J, S0 v        ArrayList<ArrayList<Integer>> bucketArr = new ArrayList<>(bucketNUm);
* f* ~2 `3 z" h0 J/ R0 `        for(int i=0;i<bucketNUm;i++){
            bucketArr.add(new ArrayList<>());
        }

1 t6 Q; R  `) W/ i! Q
        //将每个元素放入桶中
        for(int i=0;i<arr.length;i++){
            int num = (arr-min)/ (arr.length);
            bucketArr.get(num).add(arr);
        }
& V& N6 c( Y7 n+ u& H5 `

        //对每个桶进行排序
+ q1 v* q' s, d9 ?+ L# m' I        for (int i = 0; i < bucketArr.size(); i++) {
5 E* l' d6 V! B/ z            //用系统的排序，速度肯定没话说
1 ?/ z0 `  u# e/ Z/ x# o" h( d            Collections.sort(bucketArr.get(i));
* o# d2 Z5 X5 `( Q7 ~        }


        //将桶中元素赋值到原序列
1 F3 U7 V! U4 c8 c! s) U        int index;
        if(ascending){
" M) {. D& ^. S& Q! P, c$ n            index=0;
        }else{
            index=arr.length-1;
4 C! x0 c$ q, l0 U0 n        }


- n: F6 m3 ]. t        for(int i=0;i<bucketArr.size();i++){
1 q$ z, l$ H& K2 [            for(int j= 0;j<bucketArr.get(i).size();j++){
9 @' y2 X2 q# u5 r5 M, U" b                arr[index] = bucketArr.get(i).get(j);
4 W! K8 b" h) C& N4 r4 ~                if(ascending){
                    index++;
                }else{
                    index--;
6 ?4 f" o4 h+ S- @! T4 r                }
% Q7 k8 s' N( ^( p* `/ S9 N) I1 x4 L            }
: q# k& e2 \3 j4 f7 v- d0 b: x9 R$ ~

        }
" {: J. {. O" I# n

- h: s8 [1 H7 U$ [    }
}
1
8 }# L; P4 w7 ~5 m2
7 j0 _- K% L" i( |. I% V3
4
5
6
7
5 u& F$ q/ I2 j, \0 \8
9
10
$ |# L' G3 g. G9 D3 i11
( U, R" B& l0 S  }12
; ~! F" W( T- ]' G! `0 `13
+ s% F) z- |. ~- f+ \14
15
% m0 E4 Z# E% a3 O9 I* f16
17
18
19
20
21
22
23
24
25
26
27
5 A+ d0 v4 W% X1 w- x28
# y) c- W* E( S# _) y. j' g! v. D29
30
31
32
  o+ U0 @+ M. x3 y* t33
34
) {5 K9 l9 J' r& g$ z35
36
, L4 Z+ g, ]# {* H# f37
% g) _2 r" W3 n7 L0 ?0 @3 y# g38
8 r% m$ ?  ^0 O+ }( v( f39
40
# V* s5 ?5 q. b0 @1 k' ]# i; A41
42
43
44
- h8 a7 Z4 |& y5 @45
46
1 w: g5 K3 A( R* v$ l2 M47
6 E2 ]2 a, u3 ?$ j' @2 e" c0 Y1 S48
# a3 H: Q7 b/ O  G( l! |- Q49
& }3 g9 `) y/ p9 F; J50
51
52
53
54
7 g' b' F- ^9 z- S55
56
57
3 g( Z' ~$ [3 h  n) S0 |9 K58
59
7 E4 b% o( L$ U- R4 j. m+ V/ u' M60
' x3 h5 v* Y  E61
2 [: D# _( N, `4 p: f' ~$ O6 e$ c62
63
( M! v7 ^& S1 }" X. O1 B64
65
66
2 ]7 y0 |* l! r6 o8 L67
  r# t. l! v1 c4 D3 Y4 g4 U68
69
; g' R5 I# q" t( _70
71
72
基数排序
简单解释：
, J0 o0 ?! r  e; ^首先说一下，我发现好多人写的基数排序只能排序正整数，其实只要处理下就可以排序含有负数的了，就是我们排序前先把所有的数整体变大（就是减上最小的负数，也就是加了），都变成正数，然后排序好之后，在减下来（加上最小的负数，也就减了）就好了。
基数排序就是按数位排序可分为LSD（从最低位[也就是个位]开始排序）和MSD（从最高位开始排序），下面写的事LSD基数排序。
( Z9 m( v$ h/ S6 T基数排序就是把数按位考虑，让后我们一位数只能是[0，9]，就是我们在考虑某位（个位、百位· · ·）的时候就只看这个位的数，放到在[0，9]相应的位置，然后顺序取出，最后再按其它位这样操作（上面说了要不从低位开始到高位，要不就是从高位到低位）

+ e) g8 H9 H2 b# J) v7 j% }. B
( V( X1 Q4 E% G9 H

1 @$ J9 F$ A+ q4 ^4 B  a# @
) i+ t2 q& }% e5 }2 c% n" J% E
完整代码：


package com.keafmd.Sequence;
5 o  V( {1 y- \' r
9 _  u# u: A! N) \5 t+ P# P
' l; k! J# F! H& Z/**
, j0 g' `6 I2 d% K: }3 @! u! T' M * Keafmd
# D0 d3 |, z' @: l. \* p) C *
. H7 a* ^7 r5 N0 T * @ClassName: RadixSort
& U9 J$ T1 X6 ] * @Description: 基数排序
* @author: 牛哄哄的柯南
7 }5 L3 j9 k. q. x * @date: 2021-06-24 14:32
*/
3 f) x( C2 E) S) u8 w3 ?4 n  Fpublic class RadixSort {
    public static void radixSort(int[] arr){
  j9 L, }- B* G2 b% s        radixSort(arr,true);
    }
7 K- U- i( N& d    public static void radixSort(int[]arr,boolean ascending){
: Q+ J/ C3 ^& S$ c% F        int max = Integer.MIN_VALUE;
2 \* ^0 w3 D3 d$ }$ o3 D  ~        int min = Integer.MAX_VALUE;
        //求出最大值、最小值
        for (int i = 0; i < arr.length; i++) {
1 f, O  E* b+ N0 a. N1 c            max = Math.max(max, arr);
            min = Math.min(min, arr);
3 t& u& c7 Q6 c/ D        }
6 K; v0 Y  z6 W5 T1 e        if (min<0) {        //如果最小值小于0，那么把每个数都减去最小值，这样可以保证最小的数是0
3 i  U6 {2 D0 A0 X. k6 ?            for (int i = 0; i < arr.length; i++) {
                arr -= min;
) H# g, i9 Z1 \, e. K            }
            max -= min; //max也要处理！
        }
1 p9 q+ w# t# u6 S; s& e- {        //很巧妙求出最大的数有多少位
8 U3 o9 L, {! ^; p; k7 K        int maxLength = (max+"").length();
" n- x+ r; t6 K; I' [        int[][] bucket = new int[10][arr.length]; //一个二维数组，一维代表0到9，二维存放符合数
        int[] bucketElementCount = new int[10]; // 用于记录0到9某位存在数字的个数
- b: ^' F: K3 f' U  N+ v$ Y1 N, }3 T        for (int i = 0 ,n = 1 ; i < maxLength ; i++,n*=10) { //个位 十位 百位 这样遍历
            for (int j = 0; j < arr.length ; j++) {
( o4 V( T+ G: ^' N) ^                int value = arr[j]/n % 10;
                bucket[value][bucketElementCount[value]] = arr[j];
; C6 k8 ~/ X; \  I4 ~' j8 s: {                bucketElementCount[value]++;
9 `% x1 z0 O. j- R            }

) v& z. h& |: A6 N  m0 D1 x6 p
" v- t  x% Z- x# u' T" }2 L            //升序
" A  c  I. x. \/ J. f( {            if(ascending) {
' C( [* m* X1 X* H* y* i* ~  X, J' g                int index = 0;
                //从左到右，从下到上取出每个数
5 i/ u/ a7 m9 g% r, ^0 y% j                for (int j = 0; j < bucketElementCount.length; j++) {
4 |* Q, o& ]+ I: X0 J3 H                    if (bucketElementCount[j] != 0) {
9 K+ U9 s8 \0 ~8 G. ^9 h                        for (int k = 0; k < bucketElementCount[j]; k++) {
                            arr[index] = bucket[j][k];
                            index++;
                        }
. [; y7 `7 E" z& B/ U; [; ~                    }
                    bucketElementCount[j] = 0;
                }
' ~: H5 K6 _8 L; M' C- ^6 r. L( E3 n            }else { // 降序
3 g; V: r( s4 c7 Q/ ^" K                int index=0;
                //从右到左，从下到上取出每个数
                for (int j = bucketElementCount.length-1; j >=0; j--) {
                    if (bucketElementCount[j] != 0) {
" i- b2 {6 p8 P5 x                        for (int k = 0; k <bucketElementCount[j]; k++) {
' o7 G7 o: w9 S" S, l  q                            arr[index] = bucket[j][k];
  _: K9 t3 o7 c1 ^- Z: v# o                            index++;
                        }
                    }
                    bucketElementCount[j] = 0;
                }
            }

" n! }( M2 B# i; A9 U  j
2 b" V" B% q. f$ c6 _
" u3 ?$ c6 B- z8 _
0 r2 r0 R9 i( |& C! A$ n            /*for (int i1 = 0; i1 < arr.length; i1++) {
7 Y& ^% J$ k' Z6 C- ^                System.out.print(arr[i1]+" ");
6 Y. |1 z0 g8 U+ S8 g, n1 K1 M4 e% C  ]            }
            System.out.println();*/
$ I+ ^% d) R, E4 V

# H6 }$ ?$ J- ]2 l1 `- h" m7 `


9 M" G" q2 {. I* L% c; P/ T2 ^9 n5 W
        }
        if (min<0){
            for (int i = 0; i < arr.length ; i++) {
9 L; e6 K: ~, y2 ^+ l8 \                arr += min;
9 h0 Q0 W+ v1 ]( ^$ }( Y* a            }
3 Y1 u0 E, |+ U) o1 z  C( s7 \3 I        }

0 y$ D' w1 C( J5 j( M3 n* ^
; D3 c# _, s/ i8 Y5 O    }
}
" H' B7 Q$ e8 g4 B( R1
/ z. Y: D9 [" g& i  B2
4 a  G! L& q4 [' Y6 p/ [! u7 o/ o3
  ]  T4 `% ^( v0 C4
5
6
! Q3 Z" T- I! D6 F7
8
+ d$ |6 [2 ~  k% `& P9
# m2 @+ q& J) e/ @2 \: D, A10
11
12
1 |' Q6 ?: C& A1 {13
14
15
3 D* {0 |/ j4 L" ^16
17
18
19
' s: V3 h; j5 U* d20
6 i6 p$ @/ N+ f6 }# Z$ @21
22
23
24
25
26
27
28
29
30
31
0 g2 x. A7 ^- q! @32
33
34
: Q, H& @  x* k- Q; d35
+ t0 P" I/ v0 Q2 _- C8 ]2 a$ V# w36
, F2 o" ?( q$ l+ c( ^* A37
4 [& o" T3 g: E- g# Q+ `% X, o38
39
40
4 m$ a2 A& D' a; |# j, G41
6 h% A' a! f" j42
43
& l8 a' I  I# b% O! W# c5 w* x44
3 L+ t+ i* M! u2 ^45
46
3 B" T4 i8 d* ?& e( \- j9 w7 F47
48
, _, x1 v( m2 N) F" o+ X49
50
5 H, v+ V$ y( D+ X; L: o; C8 C7 M" c51
, y. g" Y: F+ T% F5 t52
53
1 [# O# _. R* h- [1 x54
/ E- {. O0 o6 i. Z55
2 v8 R9 ?+ q0 }56
57
( o; x& e7 o; R( D$ B0 o- L58
59
& _; d; m/ N/ C  ?* }/ ~2 |60
61
3 E/ X* f8 B% U4 ~62
63
" Z: }+ T3 n9 _, o/ ]% ~/ y64
65
9 k5 ]# H( O( ]66
67
9 b, e* k( K  `2 {7 ~( A3 F' N2 ]# q68
  p; X+ ~0 _0 L, o69
70
4 n9 B7 q, G1 D5 c% J9 {! O2 v71
+ d* {9 s1 D0 J/ b72
73
74
75
76
77
78
$ d" Q  W& b! B3 B1 ?4 ~8 T# p79
80
81
# d) j" x( Z- ]% t7 f; Z! X82
+ M4 n- A' n4 v7 Q6 d83
  N3 g4 s5 ]  Y' t( {0 W  R' ~4 Q完整测试类
# {2 A+ A( \. N# H5 Qpackage com.keafmd.Sequence;
9 P% u, w. I  v$ A

import java.util.*;
2 i- u6 `3 `! O5 [+ c- j* \( bimport java.util.stream.IntStream;
import java.util.stream.Stream;
% G; r- K9 h# [' }- p
9 h( T' }' L" M7 s9 C6 v
/**
( v) [3 c6 [. L  s3 ?3 ^3 r * Keafmd
*
: Y" c& `8 j( z3 `* f$ }/ y * @ClassName: Sort
, o3 l6 f1 z6 U9 ^) t3 O; O * @Description: 十大排序算法测试类
* Z/ H  Y( }" p) D' U0 ] * @author: 牛哄哄的柯南
2 b: D: o' l6 k& f0 ^8 J * @date: 2021-06-16 21:27
4 W1 _" Z% [% r) j4 I6 c6 @6 v */
- A. T/ P! D# B# m  h( j) Lpublic class Sort {

7 ]* {. P5 b" K8 |

: V% h! A- C4 z" x8 E
$ c- \7 I+ p. p5 c: n! A2 C1 ?    public static void main(String[] args) {
! m& S8 {3 I6 p, |

        int[] nums = {12, 4, 25, 47, 58, 34, 25, 9, 99, 26, 1, -13, 162, 10093, -66, -1};
4 W+ K4 k& A* i2 S: |% i. J1 _9 a//        int[] nums = {12, 43,56,42,26,11};
& P0 i$ n$ }4 k' u        int[] temparr;
& r, @: B* ]' r4 q* {
6 K# U% p' O% u! q* n, L1 z! S
5 L1 t- q9 U# t: }! f9 q        //利用系统Collections.sort方法进行对比

* F" O5 Y9 T- v7 Y; k- o% }: _
+ i, z% @, P, p% T        //将int数组转换为Integer数组
+ P; x; H8 D" ], f/ `4 H4 Y  v% v2 T" n        //1、先将int数组转换为数值流
$ ~& D4 r  b- N' j        temparr = nums.clone();
        IntStream stream = Arrays.stream(temparr);
7 |+ b' R/ Q2 A9 w1 z# P        //2、流中的元素全部装箱，转换为流 ---->int转为Integer
        Stream<Integer> integerStream = stream.boxed();
        //3、将流转换为数组
        Integer[] integers = integerStream.toArray(Integer[]::new);
5 ?' l% B" B: x# t. A  _4 G        //把数组转为List
        List<Integer> tempList = new ArrayList<>(Arrays.asList(integers));
        //使用Collections.sort()排序
* p" ~+ J6 ~/ V( q( P- n# e% c        System.out.println("使用系统的Collections.sort()的对比:");


        //Collections.sort
* c3 L" \6 N$ ?+ G, J5 ?6 q        Collections.sort(tempList, new Comparator<Integer>() {
            @Override
8 D6 r* a; i+ U& y* L            public int compare(Integer o1, Integer o2) {
                return o1-o2;
                //return o2-o1;
6 N; P! n8 B: H            }
7 I7 k9 U$ J) c6 z% F        });

6 Z# \' G# E6 u% G* b/ O$ }$ v& W/ i
        //tempList.sort 也可以排序
       /* tempList.sort(new Comparator<Integer>() {
' e- q& }1 H7 Y  \            @Override
            public int compare(Integer o1, Integer o2) {
                //return o1-o2;
, X. `2 F5 V# Y                return o2-o1;
/ w& u* v6 H5 ]' Q            }
        });*/
% Q3 x" @$ Y' i5 _0 u% k' [

* f# a* ^" `( ^7 A        //遍历输出结果
/ F; q: D) M) P1 M/ V6 g* `8 O        for (Integer integer : tempList) {
' n) m: H1 R+ k3 z' i2 [            System.out.print(integer+" ");
: P& E: L$ `0 j7 Q' g/ R1 |        }
4 h/ q& O4 p2 s/ c2 S

        System.out.println();

8 [6 v  r' F  D% @
& D4 d8 \! t* k, {1 R        //测试冒泡排序
        System.out.println("测试冒泡排序:");
: m! O0 H# O' b9 |( r        temparr = nums.clone();
5 o' t- _& H' h! P% |7 O
8 l2 r6 W7 t1 ~) H. u* D6 a8 X' {$ e
) F+ u9 B3 K3 |( P        BubbleSort.bubbleSort(temparr);


        //降序
        //BubbleSort.bubbleSort(temparr,false);
$ V6 [3 \; Z9 {
! W* z3 g+ @" B2 W0 E; f
$ n4 D3 s5 @( @, j+ `6 }: K        for (int i = 0; i < temparr.length; i++) {
            System.out.print(temparr + " ");
6 J$ Z$ y" Y" ]) W0 L        }
        System.out.println();


- }' p& `# h+ a8 H8 V0 c        //测试快速排序
        System.out.println("测试快速排序:");
        temparr = nums.clone();
        QuickSort.quickSort(temparr);
1 a" ?) ?; o4 y+ p" W        //QuickSort.quickSort(temparr,false);
        for (int i = 0; i < temparr.length; i++) {
            System.out.print(temparr + " ");
        }
        System.out.println();


        //测试直接选择排序
8 Q3 X; s% y# {4 ^2 _        System.out.println("测试直接选择排序:");
        temparr = nums.clone();
) m9 w" }8 ~. Q  x/ c* d        SelectSort.selectSort(temparr);
' {( I, V. z8 D- E! s- q- |- T; D, a9 _        //SelectSort.selectSort(temparr,false);
% N  ~4 g2 ~3 a8 }% R        for (int i = 0; i < temparr.length; i++) {
            System.out.print(temparr + " ");
( ]  }1 w' T+ J        }
& P& W. l4 e3 q! i1 b! A5 F5 a        System.out.println();
1 x" H! w3 w6 A/ h

% V& |4 n; f! Z* x        //测试堆排序
        System.out.println("测试堆排序:");
        temparr = nums.clone();
        HeapSort.heapSort(temparr);
        //HeapSort.heapSort(temparr,false);
        for (int i = 0; i < temparr.length; i++) {
0 ]9 }1 k+ K6 j6 Z3 t0 F' J            System.out.print(temparr + " ");
) w$ {2 r' i( H* Y; x3 `1 u8 u  H, c7 q        }
' l/ U( T; F1 K7 J5 P# J, n        System.out.println();
. e) D* ]1 d8 Q; a; p4 ]
# c$ t+ o) T; u! |
        //测试归并排序
        System.out.println("测试归并排序:");
# h' s8 a0 ~9 n) \' u        temparr = nums.clone();
        MergeSort.mergeSort(temparr);
0 \8 W) ~& [% L( q        //MergeSort.mergeSort(temparr,false);
/ s5 f$ s* ^" t        for (int i = 0; i < temparr.length; i++) {
7 M3 k" a: N  Q  J; B+ A+ j# V7 j            System.out.print(temparr + " ");
0 G5 [. U& j& N7 u6 O3 ]2 U        }
        System.out.println();

# \+ o+ v2 P6 \6 U( k, ~0 E- l
  B7 n9 g- {; L        //测试插入排序
        System.out.println("测试插入排序:");
0 m' p: s* n0 X' c* h7 H7 q' _        temparr = nums.clone();
        StraghtInsertSort.straghtInsertSort(temparr);
        //StraghtInsertSort.straghtInsertSort(temparr,false);
  a0 E  z+ x2 _) X4 V        for (int i = 0; i < temparr.length; i++) {
7 V0 M$ |7 j$ p: W9 C" }5 E+ }            System.out.print(temparr + " ");
        }
        System.out.println();
  o; i! b5 j6 t, d9 u; H
" s1 m" V4 X, s, S  @


        //测试希尔排序
" B! y5 ^. o8 p3 b' A5 R        System.out.println("测试希尔排序:");
7 g& K0 O7 z8 I        temparr = nums.clone();
        ShellSort.shellSort(temparr);
        //ShellSort.shellSort(temparr,false);
) I  X1 \9 a% A4 f        for (int i = 0; i < temparr.length; i++) {
            System.out.print(temparr + " ");
; i; ^, l' A$ |/ B9 O        }
        System.out.println();
% ^; c( j( ?$ `, a% y! [* S5 V! @
% j% e7 `! F6 \' c7 a6 |  |8 M

1 J$ s7 a% O/ L! z8 T
        //测试计数排序
- r0 O4 B2 V; A8 d        System.out.println("测试计数排序:");
        temparr = nums.clone();
        CountSort.countSort(temparr);
& D. {* ^; B& K" O, K; N: }        //CountSort.countSort(temparr,false);
& G- B) M$ W6 {* Z6 W        for (int i = 0; i < temparr.length; i++) {
  N$ J  E- @( Z  _( W1 y; |9 J+ Y4 g            System.out.print(temparr + " ");
4 g/ k) x( z" b6 x5 s! d1 c        }
$ a( n2 \# G% k/ H) O# Z        System.out.println();




: s* F9 q* v9 D( G( J: h        //测试桶排序
% K1 w/ a9 c: N" `* V, a        System.out.println("测试桶排序:");
4 ~$ v: q. ?3 s. H# k8 j8 \        temparr = nums.clone();
% {3 ~9 z0 T! y. F& D9 ]. O        BucketSort.bucketSort(temparr);
( f' d3 ]$ ?" D+ w6 c        //BucketSort.bucketSort(temparr,false);
        for (int i = 0; i < temparr.length; i++) {
7 w; c/ x4 d# h9 L1 _/ r            System.out.print(temparr + " ");
        }
        System.out.println();


5 e, \& C7 e2 J! @" G        //测试基数排序
! L( h  Y9 k0 V3 J7 g; X        System.out.println("测试基数排序:");
        temparr = nums.clone();
        RadixSort.radixSort(temparr);
        //RadixSort.radixSort(temparr,false);
        for (int i = 0; i < temparr.length; i++) {
            System.out.print(temparr + " ");
5 |: j2 e$ h  [: ~2 ?# |' B, S        }
        System.out.println();
3 ~. q0 U8 k4 s# Q3 `3 s
1 m" h; d1 |0 ^: S. f$ {
( [. |& T7 [4 b% G! f7 T+ m    }


6 L# a7 a% I& w9 N}
( @! e- @8 _. J6 G3 J, F1 I, f1 V1
2
2 ^, \) l& p( R, b) M3
4
5
6
7
. Q$ ^  v+ w8 s- U% ]: V8
9
$ e5 ]. ^3 j5 X* K. Y9 I10
- q- U' O  P% S4 z* k7 Q1 H" F11
0 M: V! o0 [7 s, j  Q' U: p12
13
14
- ]1 L  N; |% R' N4 O7 d9 y8 `15
16
* R& Z' B$ f2 y+ I* y5 `# k17
( j- e$ y4 _) C1 C) U  Z0 _3 m! z  A18
19
20
21
8 W' ]# S* k+ L2 Q4 U# |22
6 N$ R. f0 G8 @' J* i( a23
24
; ~0 {& \: {3 N9 i  W$ J+ A25
26
! G0 t; g# q* p* f+ Q# i27
1 T4 g, J& S* I8 M( Z28
29
7 W! C0 |& \* N  n8 B30
. L- G" p* s) m2 n7 T31
& J* U6 ?. K3 [2 U) U( F. H32
33
# L& w3 r3 l3 b) J- v  y" X5 t34
35
36
( J$ b7 }7 e# U37
& D& d6 a, Z# O$ y# Q# O' b38
  R# ~3 g' W$ v9 @; d9 H39
40
41
4 x: k$ k/ V& {42
43
44
45
46
# C" H5 T& b  g% w47
48
49
% m/ |: |$ H$ i; Q; ?; u50
  v; ~0 u5 D+ o1 e7 o8 |51
9 F1 b& c: {% p4 @: s52
5 R5 H9 `& t0 b. |! {: L2 U& V9 ~53
$ w6 N* m- U5 o54
* {- G: I% i4 \55
2 @6 D/ G, s/ _  K# O56
57
- o' a* c7 r% k+ y: w58
& J' t2 A; I: G$ k+ I3 O& a59
; J& u/ ~) s  C% q" U% r60
% t+ o4 s* T9 |& j' E9 H+ T* H& i61
62
63
: s) p8 Y8 ~" o# g6 f! @& k64
65
66
+ @' w* d. e8 L- l7 W7 S; L# M7 ~67
68
1 ^, e# i+ u( g69
* W( [- D( G0 O- @& k' E70
9 p( g" c8 v- S9 E7 s1 X71
72
73
+ Q( v9 a( w" I# t4 V3 r& G74
75
, a9 P% r% n8 m' r1 O4 B3 e76
77
78
79
80
81
* I/ D+ ~6 z6 ?9 z3 j) Z% G5 E9 I82
83
84
9 j9 x  {. U, h85
% `# w3 V% Q" H/ {, I" }) B: Z: d1 n6 o$ N86
8 R  }) A. F% o" g. n3 G  i, l/ o87
. b9 ^! A1 {6 W7 X! q8 [7 A  [88
3 q$ Z) }# H  {+ a2 }6 H89
4 Y4 f  K6 F/ F) g" n90
91
92
93
) ?5 c) h% I. Z94
95
96
97
98
99
100
101
& Z" ?/ f$ ~2 ^5 `. i102
1 V1 X4 B9 V- @4 w  \103
) R2 S: j. |- _8 J104
/ w  [2 L& J! f105
) x( M! r: l8 H: x106
107
108
109
! j3 f' b- U+ _& _. C! `3 T2 N# T110
6 E3 m" x* ?* b111
5 g( K+ c$ T8 Y& T6 r, l% D112
; v4 C1 _5 B0 N' V- T$ R0 Z$ c9 N113
114
$ {8 m0 N  K( @) a$ I, j; Q115
116
$ P& h" f3 k1 F3 m1 m2 i8 J" b5 [117
* y6 j: J8 a  [8 G% F118
119
120
) O8 n! I- [; P2 H7 h3 Q% k121
' ?) K3 ]8 N0 I% v& |122
' P( M1 @. ?0 X, J4 L% C8 p123
124
125
126
127
128
5 {' [3 B, i3 ?3 E* B1 [- F. u129
: Q# j! h- A3 g& U* y8 m$ w130
131
132
( g5 a4 B3 K/ h6 \133
( w, ~/ B. z1 c0 X134
135
136
137
8 o& }9 w% {0 M' F! ^138
139
140
141
142
  q  ]* r2 V" G; V143
144
145
0 ?4 [1 `* n9 @' Y) ]/ K146
147
8 ^9 k# G' m* U148
149
/ M: Y3 F3 I: V! A/ W- h3 F150
151
' [6 P3 D. s1 H" b, h  `5 q# c# m152
153
; v; M: U& X- [0 }; M154
" S' J) \+ ^- d: ]155
* v$ h  [0 J6 q" w( U5 `156
157
; A% Z& F4 A* ?6 |* a: G9 ]4 f158
159
160
7 q3 O# D+ ^# S' b3 O161
162
: R9 ^: g3 q, D- u( t( g; O% _163
164
/ F  m5 A2 _7 J165
6 f& @: ~7 Q# L5 J. D) e' s4 d166
, ~/ f% D5 C4 J) `2 L# b0 L; x167
0 q* D7 K! _; ]. B% p  g9 s168
169
170
/ J4 r0 x$ q" o, c171
* Q' |" R  r$ S) A. Y5 z- G172
173
9 d0 r  _6 h. V/ `每天进步一点点！
不进则退！

4 U1 j6 W6 a% @8 @% s
版权声明：
7 e1 Y, _. D) u5 o* q原创博主：牛哄哄的柯南
博主原文链接：https://keafmd.blog.csdn.net/
2 ^% k. g6 t- [" Z————————————————
版权声明：本文为CSDN博主「牛哄哄的柯南」的原创文章，遵循CC 4.0 BY-SA版权协议，转载请附上原文出处链接及本声明。
$ B7 q! `/ ?- @/ W# V  g原文链接：https://blog.csdn.net/weixin_43883917/article/details/118193663
  b% B! k$ h, ^

" Z8 W3 V, N. s8 w& @' H# N

1051373629

每天进步一点点！