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

杨利霞

经典十大排序算法（含升序降序，基数排序含负数排序）【Java版完整代码】【建议收藏系列】
经典十大排序算法【Java版完整代码】
! h1 l+ d+ i7 n5 i) k  W2 e6 m( b写在前面的话
十大排序算法对比
冒泡排序
快速排序
. n( `, D3 z9 N* C5 l, p直接选择排序
堆排序
! G2 s( K2 B: t' g! g归并排序
7 B6 C8 |  ^  R+ n/ L6 u插入排序
希尔排序
6 n* ]3 e7 O; L& A计数排序
  Q: I3 Y7 c4 R( s" _桶排序
% D' q- {6 ?8 w. N基数排序
! h1 y( @/ _; P& r' `' b% m5 w完整测试类
( T. M8 p1 w" A4 |# \% a+ Q写在前面的话
9 F! G, O) N" k, A  }, U/ D8 G! p7 X       虽然已经有很多人总结过这十大排序算法，优秀的文章也不少，但是Java完整版的好像不多，还存在某些文章代码存在错误的情况，同时也为了自己练手，决定把所有的写一遍巩固下，同时也真诚的希望阅读到这篇文章的小伙伴们可以自己去从头敲一遍，不要粘贴复制！希望我的文章对你有所帮助，每天进步一点点！！！
1 h$ t2 C+ A( y4 J" L1 z

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

. {! A$ }3 _& L, N& v( l: P
( e1 k- s3 s& U/ l& f十大排序算法对比
5 t+ A0 E" y9 P- F2 o$ ~* t
' J/ e: N3 c3 M* w6 ~# \

) ]8 x* ], G+ i0 J5 z& N* c
3 Q0 C' s3 d: t6 s" h; n  O# P2 X关于最后一列的稳定性，我稍微解释下，例如对序列：1 2 4 2 6 排序，序列中存在两个2，如果我们把这两个2标记上（让他俩不同），排序之后，前面的2还在前面，那么就称这种排序是稳定的，反之不稳定。

( i  T' O) D: z9 U4 t
' {! f7 I4 h  O冒泡排序
简单解释：
       原理就如算法名字一样，就像水中的气泡一样，每次我都把最大的或最小的放到最后面，这样总共需要n-1趟即可完成排序，这就是第一层循环，第二次循环就是遍历未被固定的那些数（理解成数组左边的数，因为每层循环都会把最大或最小的数升到最右边固定起来，下次就不遍历这些数了），两层循环遍历结束后，所有的数就排好序了。
       两层循环所以冒泡排序算法的时间复杂度是O(n 2 n^{2}n
2
)，是一个非常高的时间复杂度，我在下面的代码进行了优化，加了一个标志位，如果上一次循环未发生交换，就说明已经是有序的了，就不继续下去了，反之继续进行下一轮。
: o6 h2 f* l; Q, N* H# E
, e/ K) S6 K8 U! |3 ~



* a1 Y* j% L/ {( x1 z  x6 _2 s. a
本文的图片来源网络，仅用于大家学习，侵权联系删除！（下同）
. a9 S8 R! @, o

+ ^; `6 V/ l2 r$ E7 o( L( g完整代码：
. ?0 W6 n) p! g2 c2 m: n
9 X' H" m* D) \3 K9 A/ _- O4 k
package com.keafmd.Sequence;
$ \, |1 |7 f. v& M
* f. N, Q. D2 k. O( M
; ^7 g8 e' i- f7 F9 Q/**
. v: M5 t9 F% P/ N* s% P * Keafmd
*
  U  b3 E& J+ e# H8 j * @ClassName: BubbleSort
* @Description: 冒泡排序
* @author: 牛哄哄的柯南
0 L4 p& G  C# f3 x* n * @date: 2021-06-24 10:31
*/
' w- Y. N  e8 R: W5 q3 K6 |public class BubbleSort {
, B2 p3 ^0 L  @  c
( A& G% ]: c9 L6 x1 Q! V1 D/ t; a. E
; m, c& K- H; L    //冒泡排序
  N6 \1 O6 W& k9 W& C8 ?    public static void bubbleSort(int[] arr, boolean ascending) { //exchange标志表示为升序排序还是降序排序


        boolean flag = true; //加一个标志位，记录上一次是否发生了交换，如果是，我们则进行下一轮，如果没有，说明已经冒泡好了

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


& n) L6 M6 E4 K' k5 `! s1 g            /*System.out.print("第"+i+"次遍历：");
            for (int i1 : arr) {
                System.out.print(i1+" ");
; E3 j$ A  i) b1 f( `5 E            }
            System.out.println();*/

0 W( x) j6 p& [, B: |. J  Z0 d
1 O7 g3 C; X( q5 s7 o3 N* @            flag = false; //假定未交换
) J. x- Z" j5 c: q- u6 M8 T
5 c) H* \7 h0 h3 a
            for (int j = 0; j < arr.length - i; j++) {
& ]# S, T/ x6 W6 C6 L/ U) Y

                if (ascending ? arr[j] > arr[j + 1] : arr[j] < arr[j + 1]) { //控制升序还是降序
8 [2 v3 v3 R6 w4 [                    int temp = arr[j];
                    arr[j] = arr[j + 1];
                    arr[j + 1] = temp;
# {' `# `, C( ]9 r. v7 e" H. ?                    flag = true;
$ r( b7 J4 B8 N* g, s                }

/ h. w$ N4 l4 q6 _9 q
            }
4 Y8 I% j& I0 W7 F6 l1 ]0 j: i9 e        }
' U, c. q- N# \, ~7 W& ]% `4 D    }
, F3 C2 ]. i. G! r& O

: y/ I! b0 H  O5 u# z- K    //冒泡排序 -- 默认不传参升序
    public static void bubbleSort(int[] arr) {
        bubbleSort(arr, true);
    }
}
: n) Q' G; J; ?1 E( \1
4 O( n: O$ j- K) s* m2
3
, A% n* Y- o5 k  H( O4
5
6
7
8
9
; ^$ r+ W5 y) u% n10
  y! ^; Q* ]+ q1 a  U11
" z* S1 ?9 I" i3 S" b" f12
13
* e# Z' @9 v8 s* a: d/ H$ L) d14
( ^) `2 S! @' a* {# }15
2 c$ p: R" i7 C6 A4 P1 h7 p16
17
& R9 h4 s% H/ V! W9 M. t18
19
9 N* d) _# j( L' b4 _  r5 w2 e20
21
22
; G2 t0 K% X( u- q: J23
24
0 [, b  S, B; S2 H1 L: N25
26
. U8 D! m9 T( p; X27
4 P( R" I+ L& T3 B7 Q; ]0 [, @28
& a( _7 N0 R* g& _( P+ \- D: e& }4 F& V29
, M1 I, @" r( J& f. B30
4 A  t& O9 e6 [3 U- z1 k( ?7 |31
32
33
, E2 J' E6 U' C$ A3 V34
& ^; d- ^3 @  E  i; h' T$ D  K  X35
36
+ v2 j, B9 d2 f8 w37
38
39
40
4 R! _! H- D' t. T7 [( ^41
- g, ?9 r: H1 X# ^3 z9 t' j42
43
44
45
  s# m( h+ x2 {) n6 A( a$ g( c测试代码：
  f$ `6 _# |, R; W: ^0 i
2 P- c1 O* j9 p" A: ]+ g
/ w) k# j& e, C  a: q; X: Y7 O0 a8 e升序排序（从小到大）
, Y9 e, v& F9 S2 i, w* A- E

" N) K# w( t8 r8 Vpackage com.keafmd.Sequence;
0 w( |' [" R8 d; S% n

import java.util.*;
import java.util.stream.IntStream;
import java.util.stream.Stream;
& B0 C. b/ Z  Z- N
7 v$ V  c* X1 X( }  Y
/**
2 y% U0 G" V# w2 Q0 c * Keafmd
*
5 v4 w- x+ O* @9 R * @ClassName: Sort
& c7 S1 [) }. X  `% ` * @Description: 十大排序算法
9 P/ k" Z) g$ j! \/ I! e8 _: k, O) r! X * @author: 牛哄哄的柯南
( T0 ?( \. m( l0 m * @date: 2021-06-16 21:27
3 s% p1 S5 Y6 [& q4 w( O4 } */
! v3 b, K% }' @public class Sort {
* M9 m, A/ K* F9 M3 Q    public static void main(String[] args) {
8 O' u! ^' H; c9 w; N
1 T) o6 A+ ^' G) G. b% W
1 ?( i( K3 B. w4 A% k        int[] nums = {12, 4, 25, 47, 58, 34, 25, 9, 99, 26, 1, -13, 162, 10093, -66, -1};
        int[] temparr;

, k7 Z. P- w4 y7 p
        //测试冒泡排序
        System.out.println("测试冒泡排序:");
2 h" q. z/ w  O4 e0 ]4 ?5 Z        temparr = nums.clone();
        BubbleSort.bubbleSort(temparr);
        //逆序排序
        //BubbleSort.bubbleSort(temparr,false);
$ K" L  j( {  G$ T  A        for (int i = 0; i < temparr.length; i++) {
            System.out.print(temparr + " ");
6 y$ _' Z! m0 @6 U        }
- d9 K: k. F( P* N2 h! k  l: U        System.out.println();
8 H2 C6 d. ?( ^7 q) ]: c9 \6 A

    }
}
: r! S; N( k7 {1
2
3
4
$ i: W' W  X" \0 k& n5
6
6 o0 a+ ^: ]( l' n# w7
8
3 S$ ]9 e  l; i' V1 s" O: z8 \+ V9 X9
  P9 Q. g" v4 w% {& o0 m3 ]10
11
. A" F0 @) }4 U12
9 o6 M1 `$ a* \4 Z6 b13
14
15
16
& i4 W/ p4 |. C: O. r( H17
18
. I7 @9 l" l4 `- \, f19
  J1 J! t& c+ `20
- j! Y; g6 {  x; J9 P( _/ c21
22
0 R2 M: o1 o5 }, z23
8 Y9 e: y! h# ^# ^4 _* n3 e24
9 r& h6 _8 u* I. {" ?1 V25
; ~8 x1 ~' k/ H1 x; u26
27
28
& w9 B9 y1 J) Y! q; ]- K2 ^( Z29
  S: v) t; N# x) g30
! m* ]6 x3 k7 |! q  @) @31
7 K0 p7 _' N8 h0 c& R& o& M/ D- @32
0 _+ w% J+ j# o& B3 `33
' ~( ~; x) O7 X7 {2 Q' l运行结果：
$ H2 U/ m! D: d: A' K5 z

测试冒泡排序:
( q% p+ q% B, A) p+ X: k. _-66 -13 -1 1 4 9 12 25 25 26 34 47 58 99 162 10093
# g) M$ O" C& y/ Z1
2
: j+ P7 ^) a+ j+ d; g降序排序（从大到小）
1 v- j4 e. _0 h
: _% c9 r, K3 R* [' P8 T
# ~5 Q7 A3 n2 @1 h; q//测试冒泡排序
System.out.println("测试冒泡排序:");
temparr = nums.clone();
BubbleSort.bubbleSort(temparr,false);
for (int i = 0; i < temparr.length; i++) {
$ j# L: r: W' A, h    System.out.print(temparr + " ");
}
System.out.println();
1
2
$ z* h0 t+ f$ E  u$ u3
6 P7 ^# R& L7 [1 \4
6 u% \' c5 D4 H# e! P0 @5
6
7
9 d+ @( p3 h; g2 z  f' c% Z6 R8
! `: h& }. f2 o9 g运行结果：
7 b- Y6 ]8 D* ~1 d% q8 N
( T( W: ?1 ~# H8 M, i
测试冒泡排序:
10093 162 99 58 47 34 26 25 25 12 9 4 1 -1 -13 -66
1
0 l, [/ k  v0 Y' A  P7 C: J* J# g2
下面几个算法的测试也就是换了下类名和方法名（换成相应的排序算法），如果想降序就在数组后面传个false即可。我就不一一复制了，我在最下面给出含所有算法的测试类，需要的自取即可。

4 D# \. W. e5 ]9 R; W: [. r% a; E
* P! L" E! ~- j- D2 y快速排序
简单解释：
+ H, a6 A; X/ y- i3 T快速排序就是每次找一个基点（第一个元素），然后两个哨兵，一个从最前面往后走，一个从最后面往前面走，如果后面那个哨兵找到了一个比基点大的数停下来，前面那个哨兵找到比基点大的数停下来，然后交换两个哨兵找到的数，如果找不到最后两个哨兵就会碰到一起就结束，最后交换基点和哨兵相遇的地方的元素，然后就将一个序列分为比基点小的一部分和比基点大的一部分，然后递归左半部分和右半部分，最后的结果就是有序的了。

1 f: C$ p0 |0 l9 r


9 B1 S/ M- {' ?( u9 G% T: {% C8 \

& ?% f6 O5 K" ]5 {- o完整代码：
+ R/ W9 c5 |( n  a
7 a& \: ^5 ^% d
. K( D, Z* {+ D; t# `$ n4 h. Rpackage com.keafmd.Sequence;
- c! |) o# G9 a* p- d& n/ V6 P

' g& B3 B* B6 e6 ~/**
1 D0 w( B7 I! e  [, K' k * Keafmd
*
- H8 b  g- h( ]2 P) N * @ClassName: QuickSort
* @Description: 快速排序
" s$ L5 [. g* E( C/ j * @author: 牛哄哄的柯南
/ i" X* r% j% ^4 J$ q5 ? * @date: 2021-06-24 10:32
*/
. a& ~+ L/ u$ Q* ]. B$ dpublic class QuickSort {
; S9 K3 O6 N+ ^& C* A4 w
2 n7 N5 R2 w/ C( L
    //快速排序
    public static void quickSort(int[] arr) {
9 a; t/ ^& J3 T) V        quickSort(arr, true);
; f' n1 Z* w" s, g  e; I& o/ I, D1 ^    }
/ j% o% Q- F2 W" ?" o

    public static void quickSort(int[] arr, boolean ascending) {
        if (ascending) {
            quickSort(arr, 0, arr.length - 1, true);
        } else {
. J+ E' B4 }/ V1 T* s. H            quickSort(arr, 0, arr.length - 1, false);
        }
    }
5 \; ]3 `3 x) f0 P

    public static void quickSort(int[] arr, int begin, int end, boolean ascending) {
        if (ascending)
            quickSort(arr, begin, end);
        else
            quickSortDescending(arr, begin, end);
4 \1 A% j" G+ {# [/ P    }
1 |" ]/ f" j" F1 V% n
& Q9 e5 X1 t3 q- j& C+ T
    //快排序升序 -- 默认
, P) J' P! d) d; O* ~    public static void quickSort(int[] arr, int begin, int end) {
3 Q/ X2 V: H2 Y3 ^8 r/ N8 T0 a9 l        if (begin > end) { //结束条件
            return;
        }
        int base = arr[begin];
        int i = begin, j = end;
, s5 e0 K& o/ E, b1 w; X        while (i < j) { // 两个哨兵（i左边，j右边）没有相遇
  b& n+ p$ q% t: h0 }7 z% H) l" f+ j            while (arr[j] >= base && i < j) { //哨兵j没找到比base小的
( s$ r7 s3 {# D! \$ ]" i6 R                j--;
            }
            while (arr <= base && i < j) { //哨兵i没找到比base大的
                i++;
            }
; I6 }' d) ^* l            if (i < j) { //如果满足条件则交换
                int temp = arr;
" G  ]" L+ Z$ {/ P8 \9 V: d                arr = arr[j];
0 c4 O7 j7 V9 f2 A                arr[j] = temp;
, H2 e& P0 ]5 {- O1 g2 j4 k9 @            }

9 Y& G: R( y0 T; @  w" q; H1 D
5 s5 E+ `' t! n' v+ Y* @        }
        //最后将基准为与i和j相等位置的数字交换
        arr[begin] = arr;
* l1 v6 D  Z% G' j2 l& f        arr = base;
        quickSort(arr, begin, i - 1); //递归调用左半数组
2 ~* q8 J' q; K0 N" T        quickSort(arr, i + 1, end); //递归调用右半数组
. J$ ^5 Z+ A9 O7 g: s: l6 L% D/ \
2 k9 Q' W; y" m& T2 p9 m4 X# [, ~
: A7 _) x) O# g. H0 A. {) G    }


/ u+ Q7 C) Z! ^+ K, |    //快排序降序
+ [2 q. m0 M7 ^4 z4 Y" G# {: [    public static void quickSortDescending(int[] arr, int begin, int end) {
        if (begin > end) { //结束条件
            return;
  ]# h' i" i6 A- A3 ?        }
        int base = arr[begin];
        int i = begin, j = end;
        while (i < j) { // 两个哨兵（i左边，j右边）没有相遇
* w+ s# a" M' h) y) U            while (arr[j] <= base && i < j) { //哨兵j没找到比base大的
3 p- J. j! T, D" t& r: c                j--;
1 s8 @$ a) @4 [+ X# |5 }# {: j8 j            }
8 {  s$ n# `+ H' C4 D' F            while (arr >= base && i < j) { //哨兵i没找到比base小的
                i++;
            }
            if (i < j) { //如果满足条件则交换
                int temp = arr;
$ Y- I1 O, o, }% s                arr = arr[j];
                arr[j] = temp;
$ ?7 I) Q7 R2 G            }

6 X& L% |' w) R+ q; {; g
        }
        //最后将基准为与i和j相等位置的数字交换
        arr[begin] = arr;
        arr = base;
        quickSortDescending(arr, begin, i - 1); //递归调用左半数组
        quickSortDescending(arr, i + 1, end); //递归调用右半数组

' U/ ]$ V% ?9 V8 M. ]3 d% R
$ x7 \4 y( s+ A1 ?1 E/ y$ u    }
7 Y; f& K7 l+ T3 P

; u" L. T/ X) q* `}
2 E% N* l4 [# a- p9 F# n, j1
* ~; U( M4 f% O: ?2
  [; w  S& ]7 `6 d; A& e' w+ u! f3
4
$ i/ \* g5 \% {! S5
$ J! `8 E. L: S6
7
( E! j+ c. E) f& f. E8
9
6 E, g) u1 j6 ~2 k10
11
, Y) q) @5 \( x- c12
13
* a2 b6 W3 q0 i14
- _: e3 J! l/ p15
16
2 z: B+ w" z% J: }7 {5 X! t17
9 E$ |6 p8 A1 }( k7 J18
+ V  L+ O7 `) [* p8 `19
20
21
$ F6 T+ D- _6 U( P2 K1 m2 O1 _22
' p+ t" J9 g  X7 U4 F$ C* {23
" d; }0 X2 Q3 L0 E9 d24
25
/ G  A1 c- m% h& V4 g4 F26
6 H3 }, T5 y6 h$ Y5 N7 s27
4 t: [9 J& Y& L/ @9 ^& _7 y28
! y% o5 N" |# G' C( R29
30
31
32
33
34
, ]" k8 U3 ?( V35
36
37
: |: u( r( }$ ]% [, b38
; c1 M9 K9 I! X2 ~39
' h/ I. A$ r" b0 r* N! A. S40
: U  t2 k" W0 \8 x! Z; p! ^6 V41
42
43
44
, R7 j; X0 n# k2 T45
+ U. l7 T% c) G0 B3 f, d! }46
47
48
49
; v2 q5 M* t% }# x* R50
8 U2 O% d. N8 J  U" w51
52
, F) u5 K6 ]) Z3 u7 a53
) i+ b- |4 H. X7 d. m$ q54
55
- s/ s1 i5 a1 ^  W56
( l6 H7 j4 f( {" e7 P57
4 J4 g/ Q/ P# f4 p; R58
0 J9 r2 ]) b: M0 l0 u7 D1 E+ j59
5 G9 q; |5 B% a1 E) M0 t60
61
. _5 y) H/ _7 ]! q$ _- z& O62
$ K5 P4 W# }6 k. R9 z0 O63
+ {( r3 B+ @. d' s1 g1 c" i64
65
1 \. L' u; R3 p1 S# V8 l. H3 x* G66
' R* E1 b# ^8 E( O  v67
68
69
( m* x! g- ?5 Q2 ^$ H7 F70
71
- k; c8 v; c4 ~3 Z5 x. S& r72
% }! k6 d9 U* B0 e1 B3 a73
" d/ _" k/ a8 \4 }: W- h74
  M& _! J2 q, o8 p+ n7 p# `* g75
8 `& t/ ~$ [5 a1 c  w& e76
77
% `( `5 E- R" H# ?78
: ]. X) i1 K  |79
80
81
) T/ J9 S& l# Z4 m* g" a82
$ }' s5 D2 V8 n$ Z83
" h" v4 q1 i, @84
! x  c4 s9 u) S7 U0 _, w: E85
86
87
88
, H( }- B( `$ g, M89
! z& d0 L+ `0 ^* w* m+ C90
, U5 o! `2 q4 _91
直接选择排序
简单解释：
* A) z' L! {% C7 l数组分为已排序部分（前面）和待排序序列（后面）
8 _. I( _# |0 O: Y  H第一次肯定所有的数都是待排序的
, C7 K" K0 W" j) u8 [从待排序的序列中找到最大或最小的那个元素，放到前面的已排序部分，然后一直找，不断缩小待排序的范围，直到所有的数都是已排序的了
  n' B4 q, }6 O/ F+ A9 z
: |, m; v5 O$ e4 {
' F; j; r( S! `



完整代码：


* a7 i$ E! I( Gpackage com.keafmd.Sequence;

3 z0 f* Y0 p% R5 s; R
' A$ k; }6 T1 W2 z/**
" I9 W5 ]0 u* |3 z) ?/ t( Q3 ` * Keafmd
*
* @ClassName: SelectSort
* @Description: 选择排序
* @author: 牛哄哄的柯南
8 E. x6 ]5 [& C * @date: 2021-06-24 10:33
. q5 H: s# R! `& M( w */
public class SelectSort {

$ V% C: k/ l6 }- R6 x" S
0 B( @' a2 g, }1 r0 K1 N  c1 |    //直接选择排序
: C1 ^3 G' K0 S    public static void selectSort(int[] arr, boolean ascending) {
0 b  G6 b9 O7 B# J! Y8 V5 v# W& N        for (int i = 0; i < arr.length; i++) {
/ S, W- G+ g( e& J% a9 X            int m = i; //最小值或最小值的下标
5 q4 R! G7 P+ t* R$ i8 I5 ~7 @6 b# O# Q            for (int j = i + 1; j < arr.length; j++) {
                if (ascending ? arr[j] < arr[m] : arr[j] > arr[m]) {
                    m = j; //找到待排序的数中最小或最大的那个数，记录下标
$ J# _( a3 q8 U# ?6 Q                }
2 p4 Z* r/ ^3 S4 ~

; ]' z" S; P5 c" V3 G            }
- V0 \& Y! V4 K) [0 v$ K- y            //交换位置
" P. `' p, c; r* G. c  u/ R            int temp = arr;
            arr = arr[m];
            arr[m] = temp;


) M) I+ Z/ J* z        }
    }
) Y  ]& U! p) ^
! `+ x$ y, v$ }
+ u$ H) U; \' \+ d& i" Z! U5 i    public static void selectSort(int[] arr) {
: m& d* C( _% x! B& v        selectSort(arr, true);
    }
( f; ^  j# z8 L- T5 }9 p: Z% s}
# K6 m& W4 J6 |( P9 c2 J% T1
2
5 o. c& r  q: f7 @) J, ~3
4
8 D1 C2 H+ |3 W9 Q" \5
; U6 e& N7 z* `" w6
7
8
" X8 N- ?9 h; G( b4 x. |; \$ D8 L; l/ M9
1 t5 M: Y$ Q$ x3 }  H10
8 v( o8 e; c' V2 X11
12
! p3 H) ]! [3 H: U1 P13
; Q" N' x2 l- Y4 u- G5 D14
15
16
7 z4 _1 o* {8 Y/ T/ W  L' }6 z17
18
19
20
1 m$ l$ g" u" ]& p4 I% W1 {& E21
22
+ d* Y* o1 X* ]' q7 y' z6 d23
24
25
26
+ g1 F$ w, _* e+ e27
28
/ |; b0 }* q& F% p6 B2 O9 E29
$ `: n5 W! H, y7 R2 g30
! K2 j# S3 {7 `8 E& L31
32
3 z" b6 F$ F! [+ Y33
  \' r& Q) {7 ]+ L! M3 @. Q$ W1 [! X34
堆排序
先理解下大顶堆和小顶堆，看图
大顶堆，双亲结点的值比每一个孩子结点的值都要大。根结点值最大
小顶堆，双亲结点的值比每一个孩子结点的值都要小。根结点值最小
. M0 I# K3 e' a7 r' U8 f

. f* e; D& {% o( C! a2 A

1 f. u0 f# O! t' l) K% h2 @; ^: @简单解释：
" Q& H0 W1 ]# C构建好大顶堆或小顶堆结构，这样最上面的就是最大值或最小值，那么我们取出堆顶元素，然后重新构建结构，一直取，一直重新构建，那么最后达到排序的效果了。

1 n/ q0 c, ~  ^0 ~+ c! a* \- w


4 |, A3 M2 A! V, d6 Y4 Y
5 L3 A/ Z6 ^/ h4 a! c% X9 F3 R
完整代码：


package com.keafmd.Sequence;

* [' ]8 r1 R( O1 T: q; S
/**
* x3 d0 v3 O) ? * Keafmd
*
' b6 I( R9 H5 U( C9 X1 C * @ClassName: HeapSort
* @Description: 堆排序
! h  E9 N0 Y# _/ d6 w" F * @author: 牛哄哄的柯南
8 r- h" i6 ^: @3 G" r9 c4 c * @date: 2021-06-24 10:34
$ H' x, H" B4 V0 p9 D */
public class HeapSort {
* X4 I$ ~3 l1 Y- {  U3 \: E! \
% b# V9 g3 \! J; ]5 o& f3 t/ |$ Y
    //堆排序
    public static void heapSort(int[] arr) {
2 K* X) _! B4 j5 [( |4 F' W; M        //对传入的数组进行建立堆，这里默认建立大顶堆，进行升序排列
5 L$ T. @' _5 t' |        heapSort(arr, true);
    }
1 f  s7 Y  T+ Q# c) F6 U

    public static void heapSort(int[] arr, boolean maxheap) {
; T7 h- O" @. W5 ^5 R: r

* q3 _6 p9 C9 `1 p" K/ Q0 w  Q        //1.构建大顶堆
        for (int i = arr.length / 2 - 1; i >= 0; i--) {
) j# H( R6 o0 |" D5 R            //从第一个非叶子结点从下至上，从右至左调整结构
- Q7 E0 V, L  [$ q( ]            sift(arr, i, arr.length , maxheap);
        }
8 o( k  \0 v; E# y3 L9 F4 J

        //2.调整堆结构+交换堆顶元素与末尾元素
        for (int j = arr.length - 1; j > 0; j--) {
; z0 V$ y" |6 [- t) d6 P
. p, z7 A9 D3 G9 |8 D; ~$ e9 m% L8 X
            //现在的数组第一个就是根结点，最小值所在，进行交换，把它放到最右边
            int temp = arr[j];
) F) @' W: y' X7 N; W3 Y3 i            arr[j] = arr[0];
            arr[0] = temp;
8 {1 \1 e0 @' \; S0 b4 U! N
1 J( X% _4 q& {
            //重新建立堆
5 n- S$ }+ H' L& h            sift(arr, 0, j , maxheap); //重新对堆进行调整
        }
5 ~, P$ O* C/ ~3 o# i    }
- W2 C/ p' M  @8 q7 @

    //建立堆的方法
    /**
     * 私有方法，只允许被堆排序调用
     *
     * @param arr     要排序数组
     * @param parent  当前的双亲节点
     * @param len     数组长度
. B( m! l/ B+ ]" v     * @param maxheap 是否建立大顶堆
. c6 j2 ~) w+ O( l) G     */
8 \' k0 i) k  _, U    private static void sift(int[] arr, int parent, int len, boolean maxheap) {
- i! P0 }$ E$ `) x. b6 d  I' J

6 V3 p: M" g% P5 H" L9 ^        int value = arr[parent]; //先取出当前元素i

- x' o% x9 j2 A+ f% w
        for (int child = 2 * parent + 1; child < len; child = child * 2 + 1) { //从parent结点的左子结点开始，也就是2*parent+1处开始
7 I) r5 _) Z5 m6 u5 @( X6 s

. X" z/ J7 h0 [( [& A  N            if (child+1 < len && (maxheap ? arr[child] < arr[child + 1] : arr[child] > arr[child + 1])) { //如果左子结点小于右子结点，child指向右子结点
/ P% n( @6 }$ q1 F2 t9 @) i" m                child++; //右孩子如果比左孩子大，我们就将现在的孩子换到右孩子
            }


            //判断是否符合大顶堆的特性， 如果右孩子大于双亲，自然左孩子也大于双亲，符合
            //如果子节点大于父节点，将子节点值赋给父节点（不用进行交换)
0 Z. P. B  ?2 P9 L- H4 r" H            if (maxheap ? value < arr[child] : value > arr[child]) {
' B+ U' W/ w% U$ B                arr[parent]=arr[child];
0 c! x2 g# \- s7 U1 Q  t- j                parent = child;
            }
% x& e" N6 s6 I; ?' g0 G# K8 g            else {//如果不是，说明已经符合我们的要求了。
                break;
' R5 a2 n  s" t( `8 U3 k! `            }
4 g& z1 ^. u& M  q$ H- S0 }' J/ z; Q        }
) L, i  K5 u- ?8 N! ]3 Z) e! ]        arr[parent] =value; //将value值放到最终的位置
. s% O+ @6 Z  n9 ]  o8 D/ G! d
% `8 ~  c" Z+ Y: ~! U# d3 W7 A5 B
" X+ X, M% r! @" O  D0 `- ~4 {8 F

4 I7 l! u+ G0 ^! u. e( J  }    }
  E; w& C. g5 v. p( O; I& {9 g

}
1
9 x- e" C, K4 c; o5 C! [4 ]  O2 h2
3
2 s  R# _# s* s/ r3 q4
5
6
7
5 w7 ^0 Z( M' ^9 G' k% u- o8
4 i- {# _" [: {4 Q- ~' G9
10
3 O. h( n. [/ _. C11
12
13
14
15
! N8 T8 s1 f( l+ ?+ d9 _* A( `16
- h- ~& P. a3 N: w( G17
- i: T4 |0 ?! c% u; ~( u18
19
20
21
22
6 ^' s& D) P1 _! @: e7 g23
$ b, T# \6 `2 _; l7 X24
) {8 I) P$ s* u( R25
1 @- k( C& X; Y3 H26
27
: h, F. P9 J" r* u28
! J1 b2 f5 m8 z8 P9 N; k29
30
5 ]2 D. I; S4 f  B6 H8 f31
32
; p+ |, L/ |: N, q33
+ N6 h. b+ l) S* O6 s. S34
35
: X: C4 ~: j" s1 U0 G36
' R4 z+ N% X3 A3 g& W* v( @* L37
0 i. ~: K0 i) [! `8 A& ~38
39
40
41
42
9 x: ?( z. n; G43
44
( T9 S1 \2 _( j5 p3 ~6 m& S* U45
46
" o  z( W0 u2 l$ M47
48
49
50
; S) e' m5 F7 I  E9 y1 D1 F51
' \8 g# l, n' @+ ~% M/ `3 W, g52
53
- }9 p" }1 a4 R- ^( [" B% h$ }54
$ {0 \7 `$ P  k# H55
56
57
58
59
& I5 x; F- T' w& ^- X* T60
61
/ y, H! e! |  N  a8 ]" h62
63
64
) S! c0 A( w$ [2 ]1 S6 O  t65
66
67
68
69
0 f3 p3 F; S$ c. t! D/ d- j70
71
. F7 A6 u) `! j. d72
73
74
0 ?' Q2 K4 N& Q( h归并排序
5 f( i' N) |% _: p+ i/ K5 c$ _5 @简单解释：
该算法是采用分治法，把数组不断分割，直至成为单个元素，然后比较再合并（合并的过程就是两部分分别从头开始比较，取出最小或最大元素的放到新的区域内，继续取两部分中最大或最小的元素，直到这两部分合并完，最后所有的都合并完，最后形成完整的有序序列）
+ k: s% J2 ^- x. C% j, ^


4 }5 y1 Y0 Y; H( a4 ?! e$ E


4 I& P# }; {  ?! U: T完整代码：

) \; E6 v. v9 X) ?' E
package com.keafmd.Sequence;

3 k7 H$ F9 u* F/ w( c9 D( {
3 m. N/ P+ h* N# o; [; s0 X! i8 @/**
* Keafmd
*
* E9 h0 e' T" G! |$ B/ M * @ClassName: MergeSort
* @Description: 归并排序
4 `0 v' Q$ q3 \, t: e3 m* H) M7 v * @author: 牛哄哄的柯南
  t5 M  z+ D# E" B5 z * @date: 2021-06-24 10:35
% o" d8 n9 W$ L5 ?0 u */
" Y2 [* O) @. R/ C0 _8 Apublic class MergeSort {


    //归并排序
, o$ G% C' l. U7 w* p    public static void mergeSort(int []arr ,boolean ascending){
+ C4 ?1 d+ x! f9 e. I        int[] temp = new int[arr.length]; //在排序前，先建好一个长度等于原数组长度的临时数组，避免递归中频繁开辟空间
        mergeSort(arr,0,arr.length-1,temp,ascending);
    }
- g4 S% r2 r# t* I    public static void mergeSort(int []arr){
        mergeSort(arr,true);
0 X) j. x8 H/ F- c, e- R* `3 F    }


3 M/ r' L2 P# d: ^4 G( S" B$ m    /**
- ?5 C3 \7 ~% F& p. N! [     *
     * @param arr 传入的数组
     * @param left 当前子数组的起始下标
4 R  R# o0 _4 V) k8 I  [     * @param right 当前子数组的结束下标
     * @param temp 拷贝暂存数组
     */
9 t" H" m+ \) T0 C    public static void mergeSort(int []arr,int left,int right,int[] temp,boolean ascending){
# w1 J% ]% u6 y) }  x        if(left<right){ //这里是递归结束的条件，我们是对半分，那当left==right的时候肯定大家都是只有一个元素了。
% L( r4 v7 L$ h0 v( n
8 P* F% E  }" h* _5 [
" R! d2 P5 ]/ {1 M0 d            //对半分，比如总长度是10，left=0，right=9，mid=4确实是中间分了，0~4，5~9
            //当长度9，left=0，right=8，mid=4，0~4，5~8
            int mid = left + (right-left)/2; // 防止越界的写法
8 X- c; }7 \' J# ]/ n$ c+ o            //int mid = (left+right)/2;
* E/ E) {+ [4 V2 l

            mergeSort(arr,left,mid,temp,ascending); //左边归并排序，使得左子序列有序
; p: I! N' f) P" ?% H. q8 H            mergeSort(arr,mid+1,right,temp,ascending); //右边归并排序，使得右子序列有序
4 Y3 V( _7 X, r/ N* ^; q8 u
! e5 U- R4 o, S! F( G5 R
$ Y" T2 W: h2 P- N            merge(arr,left,mid,right,temp,ascending); //将两个有序子数组合并操作
        }
+ r( Q/ X  \* c' l* k/ ?# P    }
: ?  h5 A1 A  q6 T* M

    private static void merge(int[] arr,int left,int mid,int right,int[] temp,boolean ascending){
        int i = left; //左序列起始下标
        int j = mid+1; //右序列起始下标
9 j$ G/ U: p: H6 j7 h        int t = 0; //临时数组指针
        while(i<=mid&&j<=right){
            if(ascending?arr<arr[j]:arr>arr[j]){ //比较两个序列第一个元素谁小，谁小先拷贝谁到temp，然后对应子序列下标加1
                temp[t++] = arr[i++];
/ }' G) u: H3 R/ l; T: S/ q            }else {
4 l- c  }# f. s8 L+ P                temp[t++] = arr[j++];
0 k1 W6 \. I3 c8 G8 D+ \            }
5 j! ~. s1 S: f; M        }

& G" w5 o7 d- j7 M0 y" ^
* U: T4 R& ]7 Q$ f! L: a. k" P        while(i<=mid){ //将左边剩余元素填充进temp中——左序列有一些数总是比右边的大的数
) q6 i  c4 o2 _) d% J: H9 b6 S            temp[t++] = arr[i++];
        }
" y( m9 `9 K8 x  }8 ]$ r
# u5 T4 ?1 A- B" A
        while(j<=right){ //将右序列剩余元素填充进temp中——右序列有一些数总是比左边的大的数
* X% E: l7 f* ~% @0 u; p4 B3 h            temp[t++] = arr[j++];
" m2 |2 L* E, l- j" ^, n        }
+ @' |( L1 B( |: M/ ~

        t = 0;


% o& K0 _! C# [0 k# M        //将temp中的元素全部拷贝到原数组中
: W! o4 v  u* |8 o) U7 `+ j# D        while(left<=right){
4 }7 F4 C$ g' d, u            arr[left++] = temp[t++];
  f% y7 N+ X3 V" \/ B        }

' |7 \4 }3 I, n! [: H; r" y3 |
6 g- x" B$ B! y4 e9 q6 |    }

' ]) D0 x7 _4 D4 h
}
$ V+ g8 j9 D/ u" E6 v1
! w: l2 N  G( r+ h, O; Z7 E2
% T7 Q  K+ R- H5 K2 p. Y3
7 S) q* e! W# b+ `$ }7 s4
5 t5 |/ l! c( R. J4 v5
* t' [% T# [2 H4 S6
8 {5 E9 v  A+ q* T  @7
# T5 c1 d2 B' o* m/ F8
: ^6 r4 s* J3 w' ~* t9
! V; A" I2 v% a+ g: e. @* s10
11
. C2 o/ y# J% J  p" t6 J12
13
14
8 r# p7 H7 [1 G9 R) H15
7 I' O! e6 M: l16
: \$ |) Q# o% x8 ?17
18
$ f  X, m4 x0 S. e; r19
20
21
' r* {* B3 H0 E- O( @22
# M2 z9 F: C% V2 |23
8 t& {; Q" ]0 Q! L9 u- M7 v24
25
26
27
5 j! Y- \( f5 ]+ f+ P28
29
7 x6 {4 K$ W3 h, S! ~30
- y- x1 W  H; E- O; w. [0 b31
32
33
34
, I9 \' _* a4 c5 F6 u! }35
36
37
38
39
40
41
) c" r4 j% i: C- W42
! ~( G& t. |" X; \) M9 I/ C43
6 d  F% Y. Z4 r3 A! s% c44
45
46
47
) m+ Q) C( w( H2 K3 s48
49
8 J& \8 s8 l2 b6 @50
51
52
53
54
% G+ p9 j1 q* c55
, F7 m/ v+ w7 p0 \7 ~  d/ [/ [56
57
58
% d7 m+ a, V: ]/ A8 [59
* \1 b5 {) |& }8 {8 R0 w60
61
4 Q% H4 r9 e* ^7 R$ G62
( V7 j( B) ^  t! ?$ m0 x% a3 _63
" v' W2 K5 q9 j1 x64
65
$ e( T% y2 e0 j; l2 E66
; l8 n! L* e; J- Z. t. v2 y1 e+ _67
, L: h7 Q/ s0 S: |68
69
70
6 N) b7 i  M4 t5 M8 S, Q; ^71
& ]" o* q* R0 ?5 \( V8 ?72
73
! V" I6 T% K$ |插入排序
# i/ Y" d; z; s  ]$ ], y简单解释：
最简单的理解就是打地主时我们拿到牌后的整理过程，从第二个牌（假设我们拿起来这个牌开始比较）开始，（说下升序）从后往前比较如果比前面的那个牌小，就把牌往后移动，直到找到一个合适的位置（这个位置的前面的那个牌不比这个要放下的牌大）就把这个牌放到这个位置，慢慢的前面的部分变得有序，直至全部有序即可。


; C6 f4 ^3 ^9 j

: o  }+ ]6 y, e* j" C# ~
& s0 O6 ^3 O& `4 {
- y" z* U- I  R5 a# f7 v9 Q8 o完整代码：

/ l. r( n# D: V& o: f. e. w
+ K4 l) W( F( z6 A2 Lpackage com.keafmd.Sequence;

  f! Z0 ]  G3 H8 N) S( X- Q) j
/**
( P) x" Y5 t7 H * Keafmd
*
' O( l3 I+ p8 A0 T: `: {7 S * @ClassName: StraghtInsertSort
* @Description: 插入排序
5 ~1 [4 h% s8 A' o6 n * @author: 牛哄哄的柯南
3 {) J0 J* \; U8 b/ c) Y% Z/ | * @date: 2021-06-24 10:36
*/
public class StraghtInsertSort {
    //插入排序
    public static void straghtInsertSort(int[] arr) {
        straghtInsertSort(arr, true);//默认进行升序
    }
5 @- K" v/ ]* y6 w# f* P
- y& A# y% C, J# \
/ m/ K# |6 x7 `! ~    public static void straghtInsertSort(int[] arr, boolean ascending) {


, {  Q) W9 Y! o7 X2 q/ b7 ^1 V        for (int i = 1; i < arr.length; i++) {
6 B2 y0 r& U/ e/ [7 i' |            int temp = arr;
5 }5 N( e/ v- V9 G% d2 T            int j=0; //这就是那个合适的位置
3 c$ D3 K* p9 }5 E1 }3 S5 [            for (j = i - 1; j >= 0 && (ascending ? temp < arr[j] : temp > arr[j]); j--) {
" Q9 ~4 F7 \( f! ?5 q# k                arr[j + 1] = arr[j];
            }
            //把牌放下，为啥是j+1，
            //是因为上面的循环遍历到不符合情况的时候 j是合适的位置的前面的那个数的位置
            //有点拗口，但是就是这个意思，看图方便理解下
            arr[j + 1] = temp;
, p8 I0 V4 ?9 i) @* i1 m



        }
. ]% T% {) Q" u1 H4 D  u2 M& Z
' a) ^5 {* A1 d$ ^
    }
9 }9 \) ?0 j( ]% A}
7 k* D9 v! u/ {. N2 A9 P/ P0 {1
2
3
4
5
, _3 I3 G( g8 `7 V/ n& [+ {8 u* n6 Y! H6
7
, r- u# A& C* b1 P1 s# H8
9
10
11
12
9 Q' ^, B7 }( J( L/ y  H13
14
; Y( j6 ?/ e1 [9 _15
16
17
$ D1 G; x1 I; [- Z18
+ ~. \! \1 }' U$ A1 F& j19
5 N: P$ X+ m6 s& O$ j# E20
21
- D! s$ S. G) ^7 `- M' I3 u22
+ N) B1 o- a; m& n1 l, m23
24
25
! f! b: c' B! q" e" y9 e26
27
+ L  {1 K2 a# Y  D  K3 X28
29
# s: x& j  `2 G! R30
31
32
33
34
希尔排序
简单解释：
希尔排序是插入排序的改进版，我们理解一个叫做下标差的的东西，也就是下面那个图中的增量d，初始下标差为arr.length/2，然后继续/2，对在同一下标差（相当于把这几个数单独拿出来了）的若干个数进行插入排序即可。




: o" r0 e, A: ]# l2 n: k0 u" {+ ?

完整代码：

) P  G& j7 `/ P& j: g
package com.keafmd.Sequence;


5 ?) {; o' {9 J& W( {& o) g# Y/**
" b. j( W2 v0 B' T1 j1 K * Keafmd
*
* @ClassName: ShellSort
* @Description: 希尔排序
* @author: 牛哄哄的柯南
* @date: 2021-06-24 10:39
*/
public class ShellSort {


; N5 x& `$ Z9 S8 I    public static void shellSort(int[] arr) {
        shellSort(arr,true);
    }
" e4 q1 o( P2 P' ]* E( h
' o; Y$ t' F! Z* _% N: ]5 c
    public static void shellSort(int[] arr,boolean ascending) {

, C% W; l* _8 ^& Z( ]
        for(int d = arr.length/2;d>0;d/=2){
. M. Z3 t! n$ ^1 |$ Y0 P

' `/ V/ Q9 @. t            for(int i=d;i< arr.length;i++){
, G) n2 q9 n# _3 P                int temp = arr;
8 k6 x: F5 X, s2 {                int j=0;
2 U5 n6 h4 b* B* \9 l                for(j=i-d;j>=0&&(ascending?temp<arr[j]:temp>arr[j]);j-=d){
; V) g6 o+ i) x                    arr[j+d]=arr[j];
0 q* L! c! [$ @' L* q2 C                }
                arr[j+d] = temp;
& `2 `8 f3 l/ A0 q5 N' c            }
4 K" H& ?: f- r+ q8 ], D( _        }
9 `7 v+ z: p" h/ e7 l. u, p5 _, I2 P2 Y
8 I! F/ ^- M/ W% U- s- m. C! X
    }
8 }. ]1 v- U5 V! a7 @) G# P2 u; {9 j}
1
2
3
4
5
6
+ `' N- Z/ A7 d$ |$ Z7
' a3 O8 C$ N' R3 k8
/ ?5 h* Z  f2 n. G0 _% O$ Y' A9
, y. O' e! H8 N1 Z! [10
3 [: I+ m6 X) r" x' X0 Z5 D( ~11
9 h4 x. |) l& d/ V9 m# j2 P" l12
5 D1 q! f) L2 M5 W+ T; S; S3 L# K13
14
15
; |4 i2 s2 [% l! R% r( ~  w16
6 v7 K2 T) ~" C# l17
18
19
20
21
22
) }' t: Z4 c2 F7 r' Q, h% K23
5 N1 f5 a: b; i24
) ^6 R- y# V: D) q. H0 X! b8 y25
26
. e- }6 T4 j9 h27
28
29
/ o9 |* I  l/ L30
31
32
计数排序
简单解释：
1 h/ y% ]9 B. F3 W( O这个排序算法看名字也很好理解，就是就是额外找个数组来计数，然后在这个数组从小到大或从大到小把数取出来即可。


% ^: h4 ~4 @) U3 l$ C
5 R/ ^+ }$ n1 t; P0 @% X+ m
# h8 J( ~6 D8 q- v- C' h& `
' \0 I2 X  V- a! `) C# Q
1 P/ D6 O# f4 ^  T完整代码：
2 h$ @" {1 G' a% D: g9 b
+ b3 }# z/ U% Q3 _# c
package com.keafmd.Sequence;


/**
! c  U# K+ e; }! h& q( x1 ~7 y9 p * Keafmd
*
1 d7 V2 s! Q+ _& b: Y: ? * @ClassName: CountSort
* @Description: 计数排序
/ L* [' L9 _$ }, }3 @9 [ * @author: 牛哄哄的柯南
$ n% d4 F: k$ ^ * @date: 2021-06-24 11:31
8 C, |, W; A8 l( t5 Y+ g- i# [ */
public class CountSort {
6 l4 J" _6 r" w, T: N5 m

' _- m- Z3 O( J1 k& K  H% j  A$ T3 P    public static void countSort(int[]arr){
# c: ~" W/ t( x. @% d! R8 V+ i# Z; h        countSort(arr,true);
    }


    public static void countSort(int[]arr,boolean ascending){
- r- C4 ~7 M7 a        int d,min=arr[0],max=arr[0];
6 C* Q3 P5 p9 i& E/ [* u

        //找出最大、最小值
        for(int i=0;i< arr.length;i++){
, X3 p6 r- U) |& F6 j0 c            if(arr<min){
7 v* P; B0 }' j  F& R                min =arr;
            }
            if(arr>max){
                max = arr;
! w  t+ Q6 W( C$ X$ p$ ~            }
        }
6 |4 n& q* V5 s  e, a

        //建立一个用于计数的数组
        d = min;
/ O( D, `' \. q1 N        int[] count_map = new int[max-min+1];
        for(int i=0;i< arr.length;i++){
            count_map[arr-d]++;
        }


        int k =0;
1 N8 o4 F0 w1 U% {' e! [/ W& e        if(ascending){
            for(int i=0;i< arr.length;){
                if(count_map[k]>0){
                    arr = k+d;
                    i++;
                    count_map[k]--;
( A( s/ }; i2 @4 |1 v* c                }else
( R! x# E' m/ P: c! T                    k++;
            }
2 k& U+ {, T; D. Q4 B        }else {
            for(int i=arr.length-1;i>=0;){
                if(count_map[k]>0){
                    arr = k+d;
( B: s, t  Z: Z4 N  X                    i--;
                    count_map[k]--;
0 x5 G$ K9 Z4 d" b' `7 [, V- P( U                }else
6 b, a/ Y5 F. x4 o; v9 f                    k++;
            }
        }


/ c4 x. `( D5 l3 c' o2 B' p    }
}
1
2
3
4
0 j& b# ?5 x" F& W5
6
7
8
9
7 x/ G6 Q6 @8 t7 J3 S3 D9 I10
11
" J- v! w3 S0 Y0 N" N. H( |  l12
13
14
15
% X6 U  G8 t8 m1 K16
2 X; d$ K9 f5 e1 D8 l17
* h; A4 @' |, }18
19
20
+ C) V& W+ p( p, ^21
22
) c7 t: W5 r8 l' `& j; G$ p23
0 y& q4 Y$ N( q: t* Q24
0 ]4 Z3 a# i8 V* J, g0 m25
% w, P5 E- o" h26
' S; \$ R! m7 R5 u6 ?$ J27
28
29
30
7 N1 p1 N, M0 m% U( z3 z* I+ c31
! v) |' n5 p9 _- E! C32
33
34
2 s6 r) E" L. t9 n35
36
' c) F# @/ T3 Z: A5 l5 p37
! h: Y( @$ j  U! B38
( f# @( r4 n- f2 M39
8 y. P5 K# X0 R0 I40
41
42
43
# \7 E( ~: ]' J/ ?+ g6 _  o44
. M4 K, x# `- P0 I4 N* H45
: s- W2 r  ]1 {" b46
47
48
49
$ _# D3 T, T  ^4 @; D50
+ a3 e9 p4 P% {6 K51
6 b1 ~" U6 i# Y+ ], B# c52
0 o7 s9 ?  }% z/ P% Y5 S& Z53
# t# K  \9 j: n6 W2 ]54
& A9 Q& E# x7 g* V55
0 k9 S% j' V7 n2 e4 `" i56
. e/ z  x; w6 h* J4 Z( s* o, Y6 I57
58
59
7 [* S5 |2 _7 {/ F桶排序
- k( Y6 S) f5 N( }简单解释：
就是把一个数组分成几个桶（其实是几个区间，从小到大或从大到小的几个区间）装，然后让每个桶（区间）有序，然后取出来放一起就可以了，相当于把几个有序的段拿出来放一起，自然还是有序的，当然需要是按照区间的顺序拿了。
$ ]/ a9 _2 v% h1 u+ j* p
/ W- V) K; f* q
. G$ W8 B- @3 S
* |$ ~  Z& D- Z$ r) G; y


( A  i8 I1 J+ y0 y完整代码：
0 G, i5 ]) _* ]; u6 p/ O
) ]& y2 w  A) f+ R% Y
! v$ }9 x9 e$ Y. Apackage com.keafmd.Sequence;

2 ^# R' b* W0 x  D+ A, C
# p2 ^+ M& |! y# r: Wimport java.util.ArrayList;
- U& z" Y5 G7 Z8 Pimport java.util.Collections;

9 L7 z. e2 A6 U4 Y3 A1 B, F4 D0 m
( c6 h4 E: A( ]( y, f5 i  m& D/**
% S$ B2 E" D7 i5 J: T  Q0 L7 r9 v( | * Keafmd
" y$ Y& A0 `$ b0 F" L *
* @ClassName: BucketSort
* @Description: 桶排序
' U) a" }7 i; a3 ? * @author: 牛哄哄的柯南
* @date: 2021-06-24 13:32
" O9 u5 h  v: f; A$ C! `( e2 J */
2 f7 T! R# K5 ^/ ]! x, spublic class BucketSort {

, k1 x) M. B/ t1 a
    public static void bucketSort(int[] arr){
" ?; O2 P0 a, ?8 ~# H! Z6 G        bucketSort(arr,true);
    }
1 R: F4 w0 s9 u% N8 x
$ |) s/ ~) h* {2 b. C, X4 Q
    public static void bucketSort(int[] arr,boolean ascending){
0 ]) U! O8 I+ E2 j1 _. N        if(arr==null||arr.length==0){
            return;
        }
        //计算最大值与最小值
5 k7 v# d7 z- f7 i- ?        int max = Integer.MIN_VALUE;
        int min = Integer.MAX_VALUE;
        for(int i=0;i<arr.length;i++){
4 y& O+ A* r4 T- }            max = Math.max(arr,max);
6 c5 b  G1 `. L            min = Math.min(arr,min);
8 A% J  V" A6 N        }
/ ^" L  o8 `' n( y! b

        //计算桶的数量
3 O, k! t" [  P% F7 P        int bucketNUm = (max-min)/ arr.length+1;
        ArrayList<ArrayList<Integer>> bucketArr = new ArrayList<>(bucketNUm);
- ?. f, n9 U0 B# X* A( u2 C        for(int i=0;i<bucketNUm;i++){
            bucketArr.add(new ArrayList<>());
3 k" u6 O2 t7 S$ L1 I1 A/ _        }
5 h* c- V! }- [6 E0 m8 A- _, F
* t% s5 g0 s8 z7 M4 H: w
        //将每个元素放入桶中
+ g; U8 G# D( F3 Z5 d! o  o        for(int i=0;i<arr.length;i++){
: y) q8 c/ _1 f4 Y5 S% f" B            int num = (arr-min)/ (arr.length);
            bucketArr.get(num).add(arr);
        }
$ a7 {4 i+ q9 u: g8 w; m" X, m( T' `

        //对每个桶进行排序
        for (int i = 0; i < bucketArr.size(); i++) {
            //用系统的排序，速度肯定没话说
            Collections.sort(bucketArr.get(i));
- _( l1 P9 t& T8 N2 h9 y        }

" O0 M# {3 d* ]/ j7 ?7 j% u
        //将桶中元素赋值到原序列
        int index;
; l; V- D; o" P8 B# X        if(ascending){
            index=0;
        }else{
6 h7 J. g  \6 l7 V* P6 i& Y            index=arr.length-1;
: O( w* [7 v0 T        }
' X; P# N4 v8 w

        for(int i=0;i<bucketArr.size();i++){
0 S' {( ^  f- g7 C0 h; m            for(int j= 0;j<bucketArr.get(i).size();j++){
                arr[index] = bucketArr.get(i).get(j);
                if(ascending){
                    index++;
                }else{
8 C1 e0 t7 |3 B: C                    index--;
) D/ [' G6 b; V0 ~$ g9 C+ }% K                }
            }


        }

6 [! I& R. |. Z: d) K3 g
6 J- c, q$ r1 J& `" r, l    }
% r+ |! s' f& q2 T' R}
1
2
! k# h! |5 O( t4 }: T3
4
5
6
7
8
9
10
11
12
) Y5 H& S9 O& }& p; K13
# g" F9 K3 [) d' U14
  N0 V1 S/ }) @( A3 w15
/ q$ l( C; s4 N- D$ x) A16
6 b( n/ X; N; r7 Y% z1 Z5 [' @17
! s4 d* o. M1 o: U' B8 x/ U18
- e2 _0 H. r+ m5 x" j* N0 `8 h" \19
20
21
4 M7 a& {& B) _0 H22
23
6 y  C+ U' d4 ]/ H$ b4 _24
. G2 }* J7 B+ I8 B3 V1 f2 B0 W* |25
26
27
28
29
30
& Y7 Z; x% r- d6 t31
32
. d6 u( B: u# I33
34
35
! u% l' B# e, ~( ^% A* V/ A$ @36
4 R3 `5 O' J+ t. u$ l: Z37
38
4 e$ @  H/ M( G# w" y% r' _  d39
40
  ^4 D0 C6 O+ R6 c41
42
43
44
" X5 T' T5 `' S& m6 O3 j9 x45
46
1 R2 t& Y% P! ?$ C. G! K$ I# w47
48
- `3 ~% y) q8 ~% \49
6 }" I6 P' m6 l! k/ ]50
1 R  t$ d9 V7 v" s51
/ [! _# }' [4 m% g0 P" s52
53
; Q6 r7 p$ j, s8 |% o54
55
8 b0 ~0 y" `- U3 w  a- l56
57
58
59
60
61
62
63
1 b/ P" @+ g0 Y9 F) ^* i% T2 q' q64
65
66
3 X: R  i! \# n* }4 e67
/ Y9 d; Z5 N' ?- M: S. F68
1 y( d) p/ J- U7 t69
1 n/ E& f0 o4 s% W70
71
9 Z% S  Y) ]9 u8 t! z1 [+ x72
基数排序
简单解释：
& _2 s, P0 Y3 [: e( f7 C首先说一下，我发现好多人写的基数排序只能排序正整数，其实只要处理下就可以排序含有负数的了，就是我们排序前先把所有的数整体变大（就是减上最小的负数，也就是加了），都变成正数，然后排序好之后，在减下来（加上最小的负数，也就减了）就好了。
# ^, C# h/ J: z基数排序就是按数位排序可分为LSD（从最低位[也就是个位]开始排序）和MSD（从最高位开始排序），下面写的事LSD基数排序。
% z% D+ W' e  c+ ?0 Q: N基数排序就是把数按位考虑，让后我们一位数只能是[0，9]，就是我们在考虑某位（个位、百位· · ·）的时候就只看这个位的数，放到在[0，9]相应的位置，然后顺序取出，最后再按其它位这样操作（上面说了要不从低位开始到高位，要不就是从高位到低位）
, m/ d2 z# v! r7 {$ d

0 o, [  K9 e3 u3 y5 \) @8 B
" G  W6 M' Q4 q# `; H3 @4 K
* L- O+ o/ f# N
' e- F; a$ Q3 x: K# [
9 a6 ^" s; F. r; n4 y8 Z6 N完整代码：
# y# F1 F0 l3 ]9 [6 b- V& C
* t4 M% p: y6 I' s. p% f
package com.keafmd.Sequence;

3 ~( k% Q0 U1 }* V  W) B! o
/**
* Keafmd
. @" f6 l9 ^. y3 q- _9 r *
1 h2 x) Z/ `2 R) h5 n * @ClassName: RadixSort
* @Description: 基数排序
* @author: 牛哄哄的柯南
* @date: 2021-06-24 14:32
( i' r" c3 f8 O* z5 m; P */
% _. |+ Q; }  ~5 c9 d3 i9 [public class RadixSort {
    public static void radixSort(int[] arr){
6 X3 i) Z# M: V/ O5 y5 e1 t        radixSort(arr,true);
2 w: H2 P2 a  w4 p0 |  P9 @2 O    }
    public static void radixSort(int[]arr,boolean ascending){
        int max = Integer.MIN_VALUE;
: h0 G0 j3 ^/ Q; }        int min = Integer.MAX_VALUE;
        //求出最大值、最小值
        for (int i = 0; i < arr.length; i++) {
" O2 |$ A! s' G- U; ]            max = Math.max(max, arr);
            min = Math.min(min, arr);
        }
$ B: U; Y/ i9 F. ^; x, `# x1 G' R        if (min<0) {        //如果最小值小于0，那么把每个数都减去最小值，这样可以保证最小的数是0
, }7 x& ]. _$ Y0 p            for (int i = 0; i < arr.length; i++) {
: {4 B, A0 O" T, b                arr -= min;
            }
            max -= min; //max也要处理！
        }
        //很巧妙求出最大的数有多少位
        int maxLength = (max+"").length();
0 u5 e: I3 L# U3 j( K( v# t7 a4 K        int[][] bucket = new int[10][arr.length]; //一个二维数组，一维代表0到9，二维存放符合数
8 k, t" i& \( v. k        int[] bucketElementCount = new int[10]; // 用于记录0到9某位存在数字的个数
. O3 t* Q: I9 `4 q, B( u        for (int i = 0 ,n = 1 ; i < maxLength ; i++,n*=10) { //个位 十位 百位 这样遍历
$ t( |" {; e& n4 {: ]' j2 J            for (int j = 0; j < arr.length ; j++) {
                int value = arr[j]/n % 10;
! I" C8 i5 V3 k1 D3 Y/ q0 V0 \* v                bucket[value][bucketElementCount[value]] = arr[j];
% d* p# \+ ]3 C) _% r8 `                bucketElementCount[value]++;
            }


            //升序
            if(ascending) {
- l7 {, s: n( w2 N  A: v                int index = 0;
" b  h; s8 ]* w8 N3 g7 j7 g                //从左到右，从下到上取出每个数
                for (int j = 0; j < bucketElementCount.length; j++) {
9 h% G9 b4 p! Y5 s4 Z- M  U                    if (bucketElementCount[j] != 0) {
( j% F' {  x: O. F( p                        for (int k = 0; k < bucketElementCount[j]; k++) {
                            arr[index] = bucket[j][k];
                            index++;
                        }
                    }
                    bucketElementCount[j] = 0;
( |" Z% i& ^, U2 m                }
" q8 R) h3 {8 ^! H            }else { // 降序
7 d3 d0 ], g  v& G1 |6 m                int index=0;
! @! C- s. v7 b7 B. V/ j9 T! A0 q                //从右到左，从下到上取出每个数
  g3 q; }* Y5 V4 W) V, z                for (int j = bucketElementCount.length-1; j >=0; j--) {
                    if (bucketElementCount[j] != 0) {
2 x4 |/ m# v% q                        for (int k = 0; k <bucketElementCount[j]; k++) {
                            arr[index] = bucket[j][k];
% o1 @* i* L! \9 E# a                            index++;
                        }
9 q! c4 `# t, l! O+ V                    }
                    bucketElementCount[j] = 0;
                }
            }




            /*for (int i1 = 0; i1 < arr.length; i1++) {
. x8 J' y5 \) y1 M$ [* ^7 x$ r                System.out.print(arr[i1]+" ");
! G) o" @  X# G7 X* x% U3 y3 G8 S" ?            }
3 v4 J% p4 U4 L# \            System.out.println();*/


" _0 D( L3 W8 C- J% I
0 z" g7 m% [! ^. V5 ]+ P3 D

# ~" `/ X; h5 j. \3 T
, E; E( ?' g( m: \4 Q$ W3 W  k" r- [        }
        if (min<0){
6 `) d9 |2 w0 {( Y  O3 H! v2 W            for (int i = 0; i < arr.length ; i++) {
                arr += min;
            }
% P( D3 C9 r& R+ q% @* q        }

$ P. P. B# j' t  w3 ]* [
    }
6 D+ H5 |2 ~% m' ]& Y; s$ ]7 J0 V}
: O* ~/ f& }" d: k1
4 g& D; i. y0 a2
3
6 a+ I3 ~0 X9 ]: [8 u  D1 v+ D1 R4
5
6
7
8
# d4 g* Q* z. @3 f7 m9
10
11
& b$ p/ _% i. L; O12
13
14
15
16
$ h! A1 k2 }& u7 j4 C+ }17
& I0 U8 J5 M9 a  l5 C4 g18
19
20
21
22
23
24
25
26
1 C( _2 m" R8 e7 }27
' E- A# r& T, A0 Y* Q3 j1 w28
29
+ `4 G0 u8 V8 n) L6 z- V30
# r7 ], R2 u# s6 H) t% _31
32
33
  X! R5 n7 e' |% o6 ~$ G2 p( q34
35
7 K! a  f" `' Y8 R. Z8 G' A36
( _. l( l/ O; d& z) W; P37
9 |# y* g2 u$ D, V* ]38
39
  j* j( U5 H+ q3 e/ s40
41
42
* H1 X( F; z* G$ @# I. X7 U+ x43
44
45
" ^4 U! |. r( E  H: Q46
47
. \) _$ }0 w0 O1 Z: Y1 i48
49
) Y$ l) ~1 z' X, A2 |- w9 P1 b50
+ ?5 k. D# r2 T' A0 v4 B1 x0 I& O51
/ [5 `" t; ^9 j* |6 j3 h) j52
+ W5 Z9 F  b7 y1 x8 z53
' j5 T1 T! A; n" f) f9 d54
$ T; o- I: ^5 B  w+ y55
56
57
+ A- p: x6 K( u0 C58
! _9 P* C! D' L6 i/ v, W7 u59
7 h2 M+ x: X0 T, e' c' {' D* f60
61
62
63
8 s, S, {; U" e: R8 c64
65
' B3 W5 `  p- {6 r+ c5 }66
# N# M" a2 Z9 W& N9 N5 M# X67
68
7 Z9 s4 N; ?2 j+ d69
" F6 x0 l& x# b, V70
% i1 M9 {1 E! ~4 M71
72
73
74
75
& E/ `  E  a7 d8 g3 ?' s  |76
6 ]  U$ q& ^: |# a2 _+ C. z' a- F77
: G6 }4 M9 q, {3 y$ }- U78
79
2 R7 C! \6 K3 R7 L# f80
/ E' I. W2 V% H# R  `6 I5 X81
& P7 I" ?; k& o% o# I/ T2 V2 A4 S82
83
完整测试类
, F% _9 }) \# b* kpackage com.keafmd.Sequence;
) B/ ?+ s/ V4 P4 c5 k  s, T
1 I3 o$ d8 b6 B1 n7 u! R
import java.util.*;
import java.util.stream.IntStream;
import java.util.stream.Stream;

" q$ s( H0 J0 M; t+ v
/**
* Keafmd
. h8 T/ Y2 h. u3 `3 x! C3 A9 f *
* @ClassName: Sort
) d" L* T- }6 A& n, D' p * @Description: 十大排序算法测试类
* @author: 牛哄哄的柯南
! @5 n1 H- K4 M" ^- `6 ^5 e5 \# H * @date: 2021-06-16 21:27
) V9 r$ s5 H* Q8 J7 k/ G */
8 Z7 L6 Z" X  e$ k  S: npublic class Sort {

, p4 W- @. [4 b8 i) `. P


+ n5 L" B, L5 v! D    public static void main(String[] args) {

% C/ i4 W$ X% r& D, }
        int[] nums = {12, 4, 25, 47, 58, 34, 25, 9, 99, 26, 1, -13, 162, 10093, -66, -1};
//        int[] nums = {12, 43,56,42,26,11};
: q( E+ s  d. K! z2 e        int[] temparr;


        //利用系统Collections.sort方法进行对比

4 p4 K* U% }0 [- {- R5 ~
4 J% t6 |; L9 z9 d# \9 Y. J- S        //将int数组转换为Integer数组
        //1、先将int数组转换为数值流
# ^9 D2 k8 P% U* d5 u        temparr = nums.clone();
2 p& g7 W0 u9 s  x+ ~- f, T        IntStream stream = Arrays.stream(temparr);
        //2、流中的元素全部装箱，转换为流 ---->int转为Integer
        Stream<Integer> integerStream = stream.boxed();
2 V: u, `* V' {7 D6 w        //3、将流转换为数组
        Integer[] integers = integerStream.toArray(Integer[]::new);
        //把数组转为List
4 r7 o, D+ K7 R! w5 t        List<Integer> tempList = new ArrayList<>(Arrays.asList(integers));
( z! W6 T1 `4 x( ]8 \  o6 m5 o) Z: n        //使用Collections.sort()排序
) n( k& c" }2 o4 G. j! @. S        System.out.println("使用系统的Collections.sort()的对比:");

, P: g% h" |  t$ L
        //Collections.sort
        Collections.sort(tempList, new Comparator<Integer>() {
            @Override
# U7 g" @% a! a' ~            public int compare(Integer o1, Integer o2) {
                return o1-o2;
                //return o2-o1;
+ G1 R6 `6 K" J7 q            }
        });


        //tempList.sort 也可以排序
       /* tempList.sort(new Comparator<Integer>() {
3 [" J6 S4 j) T; G* o3 [            @Override
            public int compare(Integer o1, Integer o2) {
3 e. _! y% Z5 K3 _# f                //return o1-o2;
/ V1 T  a0 F' q9 `  @; z6 [: K7 K                return o2-o1;
            }
- \; g, h- X' }/ l3 e* V7 C        });*/
4 K- ^, g/ R% U% y

        //遍历输出结果
4 D; b, B  [. Q* ?5 x5 o2 x+ S6 I+ z        for (Integer integer : tempList) {
            System.out.print(integer+" ");
        }
1 ^. W& T) n7 }3 i- }& f& m; v

6 G8 u' k; [. I. r7 {6 p        System.out.println();
' R1 X$ Y0 L+ w! V- ~! K7 k

, m6 E" A6 G" o        //测试冒泡排序
        System.out.println("测试冒泡排序:");
        temparr = nums.clone();

7 @+ }  j7 a# J8 T& T; `
        BubbleSort.bubbleSort(temparr);
7 T8 T5 h8 p( t2 b' F6 Z2 M

        //降序
: K1 G- [# P9 k, C8 ~        //BubbleSort.bubbleSort(temparr,false);

' x0 ?6 n$ `. p7 G& I( x2 ]4 b
        for (int i = 0; i < temparr.length; i++) {
            System.out.print(temparr + " ");
        }
        System.out.println();
" D- `: y# C- K* `  [# ^$ s
: C6 G0 W2 N6 B6 ~3 O
        //测试快速排序
        System.out.println("测试快速排序:");
        temparr = nums.clone();
. J5 v9 n0 y. ?9 G5 u( Q! H        QuickSort.quickSort(temparr);
        //QuickSort.quickSort(temparr,false);
        for (int i = 0; i < temparr.length; i++) {
            System.out.print(temparr + " ");
+ @' h3 T4 \, ]7 E        }
        System.out.println();

0 m* \. i8 M' c" o- G
        //测试直接选择排序
! K; Q3 c" X2 y: i& q) S. y        System.out.println("测试直接选择排序:");
        temparr = nums.clone();
' Q. E( Q) ^+ @+ u; v3 \* c% K        SelectSort.selectSort(temparr);
1 d( }) j" N! u6 ]: W        //SelectSort.selectSort(temparr,false);
        for (int i = 0; i < temparr.length; i++) {
+ u' t1 k* a: H6 M/ V0 [            System.out.print(temparr + " ");
8 g; K4 ~' f5 ~+ P, J        }
/ U* Z3 g4 v; a1 H  l9 i        System.out.println();

- ]# Y4 u6 {7 \5 X" P8 v  j
        //测试堆排序
        System.out.println("测试堆排序:");
: O( h- |& w: d$ v( g( N        temparr = nums.clone();
        HeapSort.heapSort(temparr);
        //HeapSort.heapSort(temparr,false);
        for (int i = 0; i < temparr.length; i++) {
" A3 Y( I4 [$ d, k1 U) [            System.out.print(temparr + " ");
$ h# u. J* O, a        }
        System.out.println();


        //测试归并排序
        System.out.println("测试归并排序:");
        temparr = nums.clone();
        MergeSort.mergeSort(temparr);
        //MergeSort.mergeSort(temparr,false);
        for (int i = 0; i < temparr.length; i++) {
            System.out.print(temparr + " ");
        }
6 r" k8 W# ^; E! i0 c        System.out.println();

2 h8 A8 C5 J& N, j- A4 d
        //测试插入排序
        System.out.println("测试插入排序:");
& z6 a9 q' ~3 M+ c9 l; E, U        temparr = nums.clone();
        StraghtInsertSort.straghtInsertSort(temparr);
        //StraghtInsertSort.straghtInsertSort(temparr,false);
& b* F. X% U7 v/ _0 b! i: U        for (int i = 0; i < temparr.length; i++) {
. c$ k& ~) V. M% U            System.out.print(temparr + " ");
        }
        System.out.println();

8 f7 Q4 ], j. J7 `, x9 Z

: T0 q% @2 Z! O4 \7 d
        //测试希尔排序
. R7 e2 ^3 [$ i" l: P1 Z. E! U        System.out.println("测试希尔排序:");
        temparr = nums.clone();
7 [* F; _; z9 a' p        ShellSort.shellSort(temparr);
5 v8 E/ ~. T8 p$ i8 K        //ShellSort.shellSort(temparr,false);
& n" Z# ]( Z: E5 Y" i% W        for (int i = 0; i < temparr.length; i++) {
0 H) s- F2 t2 R5 @; P            System.out.print(temparr + " ");
( b( C) K# Q  }1 O0 o5 m2 q6 G        }
        System.out.println();
7 A3 X6 N: U/ l: y" Y1 f! @, V



. Z; A$ W. e) q! p+ D/ x& |        //测试计数排序
        System.out.println("测试计数排序:");
        temparr = nums.clone();
        CountSort.countSort(temparr);
        //CountSort.countSort(temparr,false);
        for (int i = 0; i < temparr.length; i++) {
            System.out.print(temparr + " ");
" z" }0 {+ E; P        }
        System.out.println();
# q" ~4 L9 _  e9 H
& \; a5 _0 k% D6 `- }: b5 n! A

) Q* a4 _4 C; r' c$ D5 Z9 F' a0 u/ \
        //测试桶排序
        System.out.println("测试桶排序:");
! j# o/ |- p# g4 h; u0 \  B: A        temparr = nums.clone();
) v7 q, K7 g5 B4 f7 f# ^: b8 {        BucketSort.bucketSort(temparr);
0 a7 Y) B% [$ A) s( b4 c2 r* O        //BucketSort.bucketSort(temparr,false);
6 p  n- R1 j2 }5 N- o        for (int i = 0; i < temparr.length; i++) {
            System.out.print(temparr + " ");
9 n0 y/ e( c7 z( C0 l- }% {& P        }
        System.out.println();

! @) ?6 J3 a/ [
& x2 I( [* J" p3 b- i" e3 d        //测试基数排序
        System.out.println("测试基数排序:");
, m7 `4 K, O; K3 H8 R: x5 a) H        temparr = nums.clone();
9 ~7 @9 U! {# U( }) u        RadixSort.radixSort(temparr);
        //RadixSort.radixSort(temparr,false);
        for (int i = 0; i < temparr.length; i++) {
. L9 Y- k4 k' K            System.out.print(temparr + " ");
+ u6 O) b" c7 O4 N        }
5 ?3 m7 i" f7 {/ X" t  ?; U        System.out.println();

5 E% _/ w! K( p/ M  ]
    }
) B6 B! j- a% `. w5 C. ~

}
1
2
# n3 r$ A5 j" O" w8 V3
4
0 U: @0 F8 g  V" M. a3 y- V5
6
( m0 p6 ?# ^9 Z7
8
9
! t/ Y$ ^+ Z" U* B0 |10
% H+ W- L% H+ z; o, A' w11
12
9 J) k1 l, }5 o0 D8 y! O* G13
* J; L( Y% i) B+ a: K14
: j% u9 m* _3 [6 a& t' G* c, A15
16
17
18
. w3 d% b5 i) j0 i19
' E4 T3 t  p; j% o20
21
8 P" k. l$ k6 d+ V! B4 @4 ]0 ]9 ?22
: o3 X/ `3 l" q) d% g3 K3 r0 }23
0 d( Z% J* A' @/ Q+ R4 k' q$ S24
6 J: \- W6 W5 }25
26
' k0 a1 B6 C6 s9 l- v9 }3 x! Y# N27
% m1 D' P/ p$ \8 L- F4 V& O5 c28
5 P4 I  n# M3 e9 C# P: B7 r5 |3 d29
" N2 \- a. P% Y5 u1 M: \. m8 _8 V30
1 M5 `  |7 G+ l1 R6 Q. u8 d31
32
6 g7 U. k. F; m$ h+ ]+ ]33
34
35
; K& r9 x( H* @( A. v36
5 ~, n% W: G9 G( X+ I7 C( @37
38
  F4 R- h, p8 J  W2 r39
/ N+ s# ]3 s. E+ J1 ]+ O9 E40
41
42
43
44
& L2 C* x) h8 v; ?45
46
  R- q8 b$ h- _47
48
49
9 g% i  q% d' r" [) X. V50
51
2 t$ T& W" x) O; K' e8 F52
53
54
55
56
57
; R  _& o) j, m9 N' ~/ p58
6 J% m% ^% V4 N59
60
% w. h) r) u% n( N, t) }61
62
, O, R0 U# K, x/ c9 _63
# ?2 `) T8 @+ q) {64
& J& {# T. q1 h0 U2 t65
3 I9 S: l& M( ]" M1 f66
$ {" u/ V5 Z9 ]! ^3 d2 W67
68
6 |9 m$ Z& I3 k% Q* L. u. D69
70
- e" F1 z5 z+ L71
72
73
2 }6 D, F6 e/ V3 `( k' m74
75
$ Z. S$ l" W1 U9 r4 n76
- u& T% J5 F0 K/ O77
* o3 C7 p& ?6 N& Y, I7 X78
79
80
6 h) r% }$ n$ W  N8 x" ?. L$ y81
82
5 T/ W) d9 l" G1 c: w/ ]83
. k9 R0 h' @; x9 G; N& k- K0 t84
) f3 H! D0 B  y85
86
87
88
89
7 b% i6 n! g. t. g90
91
92
93
1 Z6 N" M: m# }" l/ s94
95
96
97
! k2 |: Z2 H8 f4 {8 H8 l) c! @, P9 ]98
99
: {) f+ R0 @) R100
3 g) b9 ~- ~" O4 x2 U101
102
103
7 q" [5 i+ H! D% W. o104
105
2 n' Y" w( ]5 Z, `& d106
107
108
109
. W2 G3 E9 [, M6 G5 O; o110
* T# i6 j7 j6 l! T111
) h: Y3 l" \) f112
113
4 a$ i2 U1 s; X( f$ X2 U114
; o0 g+ n; @: i8 y$ e5 i, ^115
1 j3 B; C" S) F2 e  d116
# q/ `2 T) T! \117
& u0 Z) P/ z7 U9 O118
8 ^. |! N+ `! X6 u7 d% f. L; h119
+ f, Y* |5 U5 `9 P: [120
121
- f- l6 ^3 W& r8 J2 z" S$ q" X7 j" H122
123
124
125
- X8 B6 n$ z% n' X/ w+ w1 r) x9 W# y( O126
( J2 v/ S; R, k4 y3 |9 H; o127
128
( p" z3 y2 \0 A/ z* h, F. n' Y' Q5 L129
130
" r" N7 e# R% c: a131
132
133
134
- j  g) v' Z( Z- v& ^135
136
8 n7 {. g& F; y137
- t  N8 E( ?$ B/ H0 W* N8 ?138
139
140
, \: w0 ^9 K! j141
. T# i9 x; [; i! \9 g5 [142
143
144
145
146
147
, c7 i* U& m3 l9 c0 ?# E148
  e9 I3 [5 G" f3 K3 a! A& M' d149
150
151
152
153
2 }6 {0 y8 M, N7 S# p154
155
3 a4 Y. I# N- y5 x+ e; l8 H156
157
+ z. V9 `" Z& n' s158
2 O: J( a/ |2 p0 ^$ R159
; M9 z' H# A4 v/ E. W160
161
162
( R5 n$ P$ F1 ]163
- X' |$ I& k6 \) t, c& e% ^0 l: S164
165
166
167
/ t4 B% X5 h! _: W: X& D* ^# }2 q' c4 _168
5 {! O& W! U, \" G+ B! e169
170
171
172
173
8 v# D+ h* p7 @每天进步一点点！
5 C( h" T6 w; N4 b7 w. h) C8 l3 L$ p不进则退！

, h( u8 S, S1 @1 f  d
! i7 i$ D3 z& k) X- L版权声明：
原创博主：牛哄哄的柯南
- c: Y4 W& P# {' ]& i$ q+ q+ f7 X, _- K博主原文链接：https://keafmd.blog.csdn.net/
————————————————
版权声明：本文为CSDN博主「牛哄哄的柯南」的原创文章，遵循CC 4.0 BY-SA版权协议，转载请附上原文出处链接及本声明。
; a. ]0 N7 n3 w! `( _$ H. t原文链接：https://blog.csdn.net/weixin_43883917/article/details/118193663

7 x8 r0 T1 q* o0 M" J$ K2 D4 `

1051373629

每天进步一点点！