查看: 3478|回复: 1

排序算法之冒泡排序

字体大小: 正常放大

1178 主题	15 听众	1万积分

TA的每日心情

	开心 2023-7-31 10:17

签到天数: 198 天

[LV.7]常住居民III

自我介绍: 数学中国浅夏

电梯直达

1^#

发表于 2021-10-29 20:30 |只看该作者 |倒序浏览

|招呼Ta 关注Ta

                                                          排序算法之冒泡排序
了解冒泡排序是什么！
知道冒泡排序的思路
知道实例代码并且练习
有收获记得帮忙点个赞，有问题请指出。
一、冒泡排序基本介绍
1、冒泡排序（Bubble Sorting）的基本思想是：通过对待排序序列从前往后（从下标较小的元素开始）依次比较相邻元素的值，若发现逆序则交换，使值较大的元素逐渐从前往后移动，就像水底的气泡一样向上冒出。

2、冒泡排序的优化思路
因为排序的过程中，各个元素不断接近自己的位置，如果一趟比较下来没有进行交换，就说名顺序有序，因此要在排序过程中设置一个标志flag判断元素是否进行交换，从而减少不必要的比较。

3、冒泡排序的图解思路

其实就是两个指针，移动来进行判断，然后如此循环进行比较，具体思路大致如下：

第一轮循环得到最大值
第二轮循环得到第二大值
第三轮循环得到第三大值
第四轮循环得到第四大值
总的要进行数组大小减1的词循环

二、冒泡排序代码实现package cn.mldn;

import java.util.Arrays;

public class BubbleSort {
public static void main(String[] args) {
      int[] arr = {3,9,-1,10,-2};
      //大致过程
      //1、第一步就是第一轮排序得到最大值于最后
      //  for (int i = 0; i < arr.length - ; i++) {
      //          //如果前面的数比后面的数大，则交换
      //          if (arr > arr[i+1]) {
, F& V8 {: O. w2 B9 L       //             temp = arr;  f- Z4 J8 D, V! C- d$ e
      //             arr = arr[i + 1];
8 ^1 c5 A. K3 _' s       //             arr[i + 1] = temp;
1 j; q( q% m: D) C       //          }# ^% S: c& K! X; \# a
      //       }" l+ K! }# |! \/ C
      //2、第二糖就是把倒数第二大的排到倒数第二位
6 q& V& V# y8 Y) |7 M6 S       //  for (int i = 0; i < arr.length - 1 - 1; i++) {& A& @+ k/ p5 }- q0 F
      //          //如果前面的数比后面的数大，则交换  l! R* N' p+ d' w. a( O
      //          if (arr > arr[i+1]) {# f4 M5 U# a. e  n, w  Y6 H( B% F
      //             temp = arr;
3 M& A. c0 V' z6 p       //             arr = arr[i + 1];
+ Z; S1 G8 o3 i. v0 h       //             arr[i + 1] = temp;
$ B- g. I4 J, |" y' G0 d$ K' ?; g       //          }
6 ?5 P2 J) p3 ~! K# J       //       }. S" {- g  G1 d/ o( L8 }, D: H4 U3 t
      //3、第三糖排序，以此内推
* }, J# M" B; K/ ]8 l+ P) b       //for (int i = 0; i < arr.length - 1 - 1 - 1; i++) {, Y- S5 c0 P! i- e5 M" z1 S/ \( c& m
      //          //如果前面的数比后面的数大，则交换
" S. t3 G( s3 ^       //          if (arr > arr[i+1]) {1 `& Q9 `& D7 l" P7 L& \- W
      //             temp = arr;6 f* q3 y9 h5 T0 J! a. ]
      //             arr = arr[i + 1];  b$ d6 _# |4 M
      //             arr[i + 1] = temp;# }# K' r0 `$ i0 X8 T. }  t7 S
      //          }9 U0 x+ C6 n0 ?  N' M: @4 s
      //       }
) M  X9 k+ k! }6 @       //4、第四次排序，以此内推
6 j8 v3 a" \. D) Z5 v; L       //for (int i = 0; i < arr.length - 1 - 1 - 1 - 1 i++) {" n% ^" ^+ f/ ?+ P. J: O) f* L/ z
      //          //如果前面的数比后面的数大，则交换
7 l9 r8 j' w7 q6 ]# c3 Q. t. r       //          if (arr > arr[i+1]) {3 S. o: }" {. N  r; M/ ~% s" X
      //             temp = arr;
% r' V- A. e" f% m       //             arr = arr[i + 1];
" d4 L! h) X. C4 @# J+ U: T       //             arr[i + 1] = temp;/ j* D$ [3 B5 t# |; l
      //          }
- P, t6 Y" f+ U$ k) ]- Q       //       }
; T# @5 f: Y* X1 M( k& c       int temp = 0;//零时变量，用来将最大的数值排在最后5 Y3 O2 t6 _+ v, D* T/ ~$ L) y: b. q
      for (int i = 0; i < arr.length - 1; i++) {
4 J: r* H. @: a4 e7 {, ]          //如果前面的数比后面的数大，则交换
6 e3 u9 ^% Q4 C: j! z$ E          if (arr > arr[i+1]) {" l# s& n, g- b7 J* P7 V
            temp = arr;
+ ~* Y, V! t% D1 Y3 ^( e             arr = arr[i + 1];
; Y: [2 }- O$ @. D, E% u             arr[i + 1] = temp;' [3 H% @0 P  c" n" K( P
         }
3 i& s1 ?  m! `( H       }* B) y) `# _% p& b. O3 V

; ^+ A4 g  o6 A- |" w) R: u, p6 K
      for (int i = 0; i < arr.length - 1 - 1; i++) {- b6 P3 n' T5 a- y
         //如果前面的数比后面的数大，则交换! X( o6 n, b9 ^/ D) _  v$ {9 Z
         if (arr > arr[i+1]) {
: H' c! L& A" J5 K6 M( {/ L             temp = arr;
3 R% @# H. G9 \+ w( `9 f             arr = arr[i + 1];
5 o2 X$ f7 }5 L* Y# N$ x             arr[i + 1] = temp;
; l+ \0 \9 D0 V. q          }4 O+ a( C' Q# H2 y* D2 q' h9 T
      }
6 q4 X  F+ H9 T, e4 h1 o3 c( t/ c8 @, ?8 s% S7 l1 f

; `/ z4 ?! {: M9 r$ s       for (int i = 0; i < arr.length - 1 - 1 - 1; i++) {  M! |* Q% q" i% F( W3 o: e2 r
         //如果前面的数比后面的数大，则交换0 ?3 g  r. i9 y! e* H7 \$ b6 h2 N
         if (arr > arr[i+1]) {1 {3 l2 s; u. g. U
            temp = arr;) B; c" g8 _* j* f0 s
            arr = arr[i + 1];
# h1 D0 ]5 Z8 @, @             arr[i + 1] = temp;
! n4 }8 F9 {& a- b+ ^          }
+ C# d0 e6 o  T       }' z6 r1 E4 p/ h

" l; N1 P( L& z' s" e) k/ `, ]
3 V$ N5 g7 z9 J* D0 L! t       for (int i = 0; i < arr.length - 1 - 1 -1 - 1; i++) {
4 P0 z) Y2 w3 n1 T          //如果前面的数比后面的数大，则交换
/ C& K% M  ^* s4 T          if (arr > arr[i+1]) {0 w3 x; o+ W( h6 g
            temp = arr;+ z9 h2 Y, e$ x7 C7 q$ s
            arr = arr[i + 1];) V6 k0 ]! s7 {: Q' P- d% [& L0 k% u
            arr[i + 1] = temp;
% q8 q9 T) v9 G# C) t) m9 L          }& Q2 n! ?" i! j, D& C
      }3 P1 @* n/ E$ _7 B$ ]& c. A3 l

$ u* r& f$ i1 t$ e, S
2 J% m7 X+ r+ ^* D' F       System.out.println("hello " + Arrays.toString(arr));) i* `3 r6 h) n+ w# f4 D# _4 g
      //------------------------------------------------------------------------------------
. u3 u- Q! _9 F1 l, g" B       //根据上面的观察可以知道了撒，可以再用一套循环解决
3 e. K; O; T+ D5 ]2 M4 G; \5 \9 `" ?1 O' ^( ?

* f" e2 `* F9 K0 T, @' G+ y, y7 m, p+ u( d3 c5 D" {" V

9 t4 `' N4 K8 p, L# P5 o       //好好理解一下、由此可知，他的时间复杂度为O(n*n)
& U3 h7 I, N3 x# ]1 m' B       for (int j = 0; j < arr.length - 1; j++) {3 V/ {4 U9 x2 U, q: A
         for (int i = 0; i < arr.length - 1 - j; i++) {
; {8 f2 y  j- t1 k  n" v             //如果前面的数比后面的数大，则交换
& r% B7 {4 h1 U! J6 b2 T2 y             if (arr > arr[i+1]) {
; E4 B1 ?6 C9 @& ~- L                   temp = arr;
5 k4 h0 P+ }3 s" Y                   arr = arr[i + 1];6 {3 W2 A0 u; n2 n2 d$ p
                  arr[i + 1] = temp;
2 z' w- f: ?( I- M0 D             }7 a$ y- `4 z. @! c9 N
         }2 d9 [+ b+ ?/ n  A
      }
. A% F2 b5 X3 K$ v3 A5 X: G }
) x3 R" x0 c2 b9 }. ]& }}7 n* {. o9 n  d# A2 \/ }+ T- q2 P3 V
三、冒泡排序的优化
1、思路
7 ]9 Q0 b9 N' e1 r5 J# d1 h. l( d( ?如果我们发现在某一糖过程中，没有进行一次交换，提前终止% n. I- |) z& t
2、代码实现
package cn.mldn;% x3 a: V- L3 _8 Y$ R  a; U
; C, _) j& P1 t6 x- Z  A! n: B

, R$ U& |. L" S/ l/ p! ~3 ~8 C/ Cimport java.util.Arrays;& o$ e' Y2 n/ M7 ^: K9 M7 W* d
) M) Q# L  L9 P% m
# J* P7 ~% l% [! Q
public class BubbleSort {
' I" u+ O  W3 }% ]8 w( {* m public static void main(String[] args) {
- N3 A/ ^$ w; n. d/ i0 O3 [( k       int[] arr = {3,9,-1,10,-2};
- B/ g3 u2 I4 y% ]5 \       //大致过程
1 r" F5 K' U" L% j& I- F       //1、第一步就是第一轮排序得到最大值于最后$ O  i- [6 `( V! o8 E" m
      //  for (int i = 0; i < arr.length - ; i++) {
% I% L1 \9 n$ r       //          //如果前面的数比后面的数大，则交换
6 n% i/ H! ?& _4 g8 D) c/ ]; U       //          if (arr > arr[i+1]) {# q3 I4 n- e0 v; N/ o
      //             temp = arr;7 a* ]$ F; C. H; `( i' R( O$ y
      //             arr = arr[i + 1];0 {- ~  h+ @& t! H8 e
      //             arr[i + 1] = temp;
" W, F. l; N3 Z4 {       //          }( k- `& S- J1 E) N4 u8 h5 Y
      //       }
* p* b$ K3 d6 O; d- F1 M       //2、第二糖就是把倒数第二大的排到倒数第二位
' y/ x) i! C( \1 r+ Z" p% s       //  for (int i = 0; i < arr.length - 1 - 1; i++) {1 u% _1 R8 o' t$ i# a
      //          //如果前面的数比后面的数大，则交换
7 m2 x% G8 b" G, B, n8 m6 k       //          if (arr > arr[i+1]) {3 |9 n) g% G7 H) p! [
      //             temp = arr;& M" e5 k, ~5 X2 G* M; O
      //             arr = arr[i + 1];
; k- i# j3 I& D, b8 @2 j, }       //             arr[i + 1] = temp;1 ^) r7 }# Q' b6 H. K- z) X: X6 Z3 \
      //          }
/ G5 \8 ?) S$ r: t; F3 ]       //       }
& K0 [7 Y4 q; o6 h& a1 U       //3、第三糖排序，以此内推
3 M+ N9 d4 C# {; `! h; O2 M       //for (int i = 0; i < arr.length - 1 - 1 - 1; i++) {
2 j# y7 k* Z) P* S       //          //如果前面的数比后面的数大，则交换! ^. i6 z0 v# M0 N9 x5 _# e- k
      //          if (arr > arr[i+1]) {
+ T* |& r* a' Q- N* `       //             temp = arr;0 z, X1 {  T+ B* L0 ]$ d
      //             arr = arr[i + 1];6 P% r5 k3 Z! b& y. S) b; g8 C7 l
      //             arr[i + 1] = temp;# }9 a3 }" E# P! L9 {
      //          }  s- r7 v) s6 D7 @+ f; y  T
      //       }' V. h+ S) ]- G% [- r
      //4、第四次排序，以此内推+ u8 F, {! J! J! n$ D
      //for (int i = 0; i < arr.length - 1 - 1 - 1 - 1 i++) {
- x0 P7 W# J( P, W       //          //如果前面的数比后面的数大，则交换
4 x6 D& q( I0 ^: Q- t* J- Z$ P5 e       //          if (arr > arr[i+1]) {- ^  _* H* w& c, W1 ]# q: e
      //             temp = arr;
7 e! p# x7 V4 K4 G2 W9 h       //             arr = arr[i + 1];- U) n$ E1 E$ h2 \3 u, j, j
      //             arr[i + 1] = temp;
" A' s, N) u" v( W       //          }
* _  y- T. X# A       //       }
' J/ w( S2 b% Q" D& Q       /*int temp = 0;//零时变量，用来将最大的数值排在最后0 K, F  }* Z+ a6 k  e+ E
      for (int i = 0; i < arr.length - 1; i++) {
. C  r/ z$ Y0 m  c' `6 V4 k( o4 {          //如果前面的数比后面的数大，则交换
/ w$ d) P0 i3 s9 {          if (arr > arr[i+1]) {' T/ h- |9 U4 d6 s( u/ l
            temp = arr;7 G) O, N) ^2 l
            arr = arr[i + 1];
8 b9 V) W. [% i& {             arr[i + 1] = temp;
" U; {% [! |" U* ~0 o+ @# i          }5 a) n6 q4 E% m* c& C! J
      }
$ Y' l2 f( S& [' J1 s! Y& F
+ V  v+ G; A" b# K  J3 J& E1 U
2 ~* a2 P/ b0 J' H1 C       for (int i = 0; i < arr.length - 1 - 1; i++) {
; l- t3 ]' X  _+ B4 q          //如果前面的数比后面的数大，则交换
+ F3 J& P+ |/ z) |/ z$ L6 Y          if (arr > arr[i+1]) {4 C' y/ y% a1 F- M/ Q* a6 T: h. J
            temp = arr;" s9 N: h" E+ m; ~# v8 @( r  b& c- [
            arr = arr[i + 1];; m0 F6 |+ \* f% O* i3 T, z3 a
            arr[i + 1] = temp;  ~# w+ k2 Q' \
         }7 n( }7 L2 K' A8 Z
      }
, f/ B+ E5 M2 j1 ~
; M$ x( ]2 G6 k. r" c! s! }6 ~# R" `& c
      for (int i = 0; i < arr.length - 1 - 1 - 1; i++) {2 f  f1 I9 s6 {' w+ Y4 c8 R0 |
         //如果前面的数比后面的数大，则交换+ m9 P8 N9 ]) W* y* p. V1 R/ Q1 V; T# ]
         if (arr > arr[i+1]) {
+ i6 I0 _. T3 A2 z. _             temp = arr;1 B: z! B0 d, U' ?! a
            arr = arr[i + 1];
# {& p) j% C" O4 U7 e3 I- y3 o             arr[i + 1] = temp;
' V; L& W* I$ z' @7 a# U: p* C          }  c$ c' m: ~: r
      }. P* {" G, K. l! Q) ]
4 H. D* d& {. e+ J( u
7 p) Y# d9 G) U5 z* H" U
      for (int i = 0; i < arr.length - 1 - 1 -1 - 1; i++) {
5 h2 T1 F: l( Q0 s; I          //如果前面的数比后面的数大，则交换' V- V3 h& w+ G! A! d0 S
         if (arr > arr[i+1]) {
. t; R; _/ M' e" T, U( b0 l7 u$ h9 Q             temp = arr;
/ @1 l: E% b2 U+ f             arr = arr[i + 1];
& P% ?* }% f3 P' D; o; y; A+ N             arr[i + 1] = temp;6 O% m/ Z2 e, _1 Q' H  [* [& Z) x
         }1 B+ d& k& u9 ?# M
      }*/+ R3 t1 C/ s7 Z9 N2 \  A: S6 z" T
/ V2 k. m( s/ c1 q, Y8 j1 p

0 l+ ~" q3 H, K! `4 W# m       System.out.println("hello " + Arrays.toString(arr));" M, C( |. ~7 l9 w* T" U1 ?$ H+ m
      //------------------------------------------------------------------------------------
- s4 H" V% w" S* _3 L       //根据上面的观察可以知道了撒，可以再用一套循环解决( G" Q, m) n7 f% I
' z) `7 ?- O* k6 j8 w# G
2 \" P; V, B5 I6 C+ z
2 G7 s/ W5 ?  U3 O& X0 Y7 y8 T# O- k

9 w/ A) K- x2 |, |; {8 ^& x! M# k, E8 R9 h" v

1 Z) W! o3 n& n9 |# J       //好好理解一下、由此可知，他的时间复杂度为O(n*n)& X# \* Y9 n' h1 Y1 S
      int temp = 0;9 a7 }8 d. d( ]7 G' U# }5 e' b% j
9 ?7 R& o. o6 G' V* K

! u" [9 z8 t2 _0 F3 E       boolean flag = false;# t) j9 `" W7 v; A8 ~
      for (int j = 0; j < arr.length - 1; j++) {
( |$ l. M0 f. L. g7 h: s          for (int i = 0; i < arr.length - 1 - j; i++) {- Y* o* j4 @* l" V1 u) ~# n- ?
            //如果前面的数比后面的数大，则交换5 d/ h/ T; j4 @
            if (arr > arr[i+1]) {( G  l1 W. {+ \1 i/ ^2 x: b' Q; \
                  flag = true;//在这里把flag值为true* z9 M$ O* X! m+ t/ a
                  temp = arr;
- d. e5 x/ I! y  [                   arr = arr[i + 1];
  `8 G4 b; `; |7 x                   arr[i + 1] = temp;
2 p+ {- S2 S* R2 R9 z7 w9 \, R             }
* c, k0 l; [# m* N. B- r) q* Q& U          }
8 g& I+ [- v" [+ j4 \% k0 u0 _  T          //在内部循环的时候进行查询
+ y* {5 @: L8 s          if (!flag) {//说明在第一趟排序过程中一次交换都没有发生。. L- q3 ]1 A' a
            break;% B' v! t" C: _9 u, \
         } else {1 P9 R' w' u1 f  m1 I3 }- w6 _. `
            flag = false;//没有这个就是执行一遍就没了，要让他进行下次继续
8 H8 E1 u5 z/ K# G          }
! c8 z4 c3 z9 Z' }       }4 \5 o8 Z& P5 D  ~; H0 `

1 t) C* k7 X& B3 }* Z* P6 k1 Q, O7 A" h+ E: x; D# u
      System.out.println("world " + Arrays.toString(arr));# q1 X3 c) P& S# |" |
}
  {9 l" `. `/ }, X' I9 u  U9 q}# Y; E8 V5 d) H
四、将上面的代码封装为一个方法
- p$ |& u' [* I  L. opublic class BubbleSort {
3 Y; O& ]7 m4 O. S public static void main(String[] args) {
# t( y- q. o* F% x; M6 k/ [       int[] arr = {3,9,-1,10,-2};4 F$ L' H0 r; L6 ?7 j+ r( J
2 ^! @2 L9 }3 `. J; {5 P

7 r- r. B$ o# S% l9 {% K! z       bubbleSort(arr);- D4 S" u# P$ L9 O; B" v- V
      System.out.println("world " + Arrays.toString(arr));9 P1 G( |0 f  o) q) b0 G
}3 M  W( W5 p) u$ W* t# m. ?
" T0 n6 t6 M+ Z  |( a* T7 {" h* S% q
! N, k" B0 D' F, B: s
public static void bubbleSort(int[] arr) {; c. H; t+ `& Q, y
      //好好理解一下、由此可知，他的时间复杂度为O(n*n)! r* C) J' U( g7 A' j: y! E% a
      int temp = 0;9 G: R( p8 O  F6 q  q, u/ M
. p7 n9 Y3 @2 p; b; w$ B: u2 E* b+ J1 L
) T9 u2 Z3 U& v% N& o
      boolean flag = false;
/ w5 c0 [, v& [5 y/ u9 W7 N       for (int j = 0; j < arr.length - 1; j++) {
         for (int i = 0; i < arr.length - 1 - j; i++) {
: n+ C" E5 j$ H. x2 i. z             //如果前面的数比后面的数大，则交换
* ?/ `/ ^. Z- S& J' w7 z, O             if (arr > arr[i+1]) {
; z( C0 L% w- d# o                   flag = true;//在这里把flag值为true2 m" m8 s% C, ^8 i# t$ |! c1 o
                  temp = arr;% y1 n: S: r( B9 D% r3 b. H
                  arr = arr[i + 1];! t# {- P+ o% q$ A
                  arr[i + 1] = temp;7 C" T4 `/ M& i! e
            }
& F7 O' ]8 b2 H/ V          }* m# j) w' F2 B5 Z+ H
         //在内部循环的时候进行查询
! z  D2 f, S7 o5 q( N9 f          if (!flag) {//说明在第一趟排序过程中一次交换都没有发生。# n& P$ ]+ J8 p6 C7 Z* s& n
            break;5 ?' ]$ u# \0 w% N, b" D) e* C* N1 ?2 F
         } else {
' S' Z* P, Y" R+ L! f/ t0 Y             flag = false;//没有这个就是执行一遍就没了，要让他进行下次继续: A; X/ K, E% `$ K
         }
) k' ]2 Q. S5 O# x# L  g       }3 Q  Z: O+ P; M, M7 K8 M4 m+ A
}7 p0 a! d2 H9 o" H8 S! s
}5 j" U1 ?  E* P& U; J6 @
五、测试一下冒泡排序的时间复杂度
1、代码是实现
import java.text.SimpleDateFormat;+ y7 X. N% K! ~0 I9 ~
import java.util.Arrays;
' R* @6 {1 M3 \, ^4 ~- i; n/ \import java.util.Date;
7 u) c8 e  ?0 ]# \4 n
3 `, q4 u6 |4 f$ M* j3 Y7 |! |, e9 c8 k2 _
public class BubbleSort {
4 k: G  E( l3 A$ t7 j8 S" L public static void main(String[] args) {
/ c1 o5 A/ q! g8 n( S       //1、创建80000个数据来测试一下我们的性能& k1 B  Y! V3 p& ^% {5 ^( G
      int[] arr = new int[80000];
- V; y" W* ?2 X6 H. U       for (int i = 0; i < 80000; i++) {
9 n, J. A/ @! O8 G; [- _          arr = (int)(Math.random()*80000);//生成0到80000的数
$ O5 \2 ?5 ^% c5 ]0 z- v1 ?       }0 O. J5 P9 U  P9 ?4 ?
      //2、输出时间1 n: J: Q0 k9 l, q5 ]) Y
      Date date1 = new Date();
( r1 C9 r% B; V0 T       SimpleDateFormat simpleDateFormat = new SimpleDateFormat("yyyy-mm-dd HH:mm:ss");//格式化! V$ z- r) G* Y, x/ ~5 ]5 k
      String date1Str = simpleDateFormat.format(date1);1 i& x, ^: T5 b+ D: M
      System.out.println("排序前的时间" + date1Str);
& `" K" v% K% g2 ~  Q6 r+ E       bubbleSort(arr);
, G7 v' ~( y6 g% ^3 j       Date date2 = new Date();
: n8 U/ u5 V: i; r$ Q5 [' Z" ~       String date2Str = simpleDateFormat.format(date2);6 c* m, ~( z6 q
      System.out.println("排序后的时间" + date2Str);4 H1 B, }' N0 k) s

/ `; w. O/ j* _5 f7 h
/ X% e5 j0 R/ [" }
; ]! d$ H: S  W6 m2 [5 A% H1 ?
* i6 _/ n4 Y6 n/ e( ] }1 p( h; N2 r# h

4 l5 l, u6 m$ i# B) V5 w6 ?9 M4 c7 s& ?1 Y' A/ s# c; O2 ~7 ]
public static void bubbleSort(int[] arr) {
* R( U6 V: I. ]1 d; S+ o       //好好理解一下、由此可知，他的时间复杂度为O(n*n)% B0 s5 Z; s; |; q/ B
      int temp = 0;( q# @; ]) g7 i, u* D) {, D3 }5 A' `

3 h2 ?" }1 |4 H5 b5 L5 Q: S' b+ b3 ]1 A
      boolean flag = false;
" ?' j! Q, m* V7 Q4 T2 n8 B! m6 t       for (int j = 0; j < arr.length - 1; j++) {7 H7 b4 H% `6 o9 z/ S: |/ _
         for (int i = 0; i < arr.length - 1 - j; i++) {: R  S1 `: I* c6 q5 L# ~9 N1 s
            //如果前面的数比后面的数大，则交换
1 r3 V6 D* x8 M  e             if (arr > arr[i+1]) {6 j% ?* U6 p; r7 Y& r
                  flag = true;//在这里把flag值为true3 s/ T5 L! i/ b( V' H, P/ W: {
                  temp = arr;0 y# a0 m$ C( O$ y4 j/ o
                  arr = arr[i + 1];! w! u. e- t1 v! A" W# t9 ~  x
                  arr[i + 1] = temp;
3 v0 Z+ H' l1 G# e1 ~* V             }
  ]1 o9 U3 G* u4 P7 G3 t2 {6 c. l0 n          }
& a6 B7 f9 P' ~$ w: D: i          //在内部循环的时候进行查询( i7 g/ v" M/ N4 c
         if (!flag) {//说明在第一趟排序过程中一次交换都没有发生。/ Q# N) c. p6 C' e2 j( C: i, m
            break;. h; I0 m$ d; J0 Z  I
         } else {# n! E$ I& i# n
            flag = false;//没有这个就是执行一遍就没了，要让他进行下次继续4 A# L8 ]' ^  J" W: f8 \$ R% P
         }
  I  l+ t% I- p7 E/ P- [  |       }
/ v# Q1 L5 j* K! M4 q5 j8 v* A* @4 W }
. F* ^& i2 w# M}8 T) _5 T" i2 F" k4 y
& ~* `6 W# U3 ]: t. Y

1 o2 r0 E7 p: d! T6 K
0 w' ?3 b- L0 O2、效果
, \3 z, E! r& a
8 \5 F8 n2 X) Q8 c. e6 T8 r5 [0 s
; s# b; F% G+ ^8 D6 `. ?9 H7 O1 o4 [( O- R7 H5 b7 {$ j
3 P5 O+ [( _: Y& B. u  U

/ \: a  m4 `0 [1 U# ?# ~: h% `' P