查看: 3477|回复: 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]) {# L  K! _/ X" D1 r! z  {0 p
      //             temp = arr;+ b& }) }5 j) x% c+ r9 T* c7 ?
      //             arr = arr[i + 1];0 |" ^3 R/ ?( U  }
      //             arr[i + 1] = temp;" J* y& b( \% y. ?8 V- n
      //          }
9 |+ l" _- p) f& P       //       }; U) [$ ]0 i9 }/ r7 x
      //2、第二糖就是把倒数第二大的排到倒数第二位
$ R2 j5 e9 Z4 P/ ~* `5 z       //  for (int i = 0; i < arr.length - 1 - 1; i++) {
8 z: R; P4 X& O4 K* N+ z       //          //如果前面的数比后面的数大，则交换7 @+ \: y) ~! \+ N1 P
      //          if (arr > arr[i+1]) {) h: y' G7 Y8 I9 `+ T% f
      //             temp = arr;
! g8 H0 L9 y* E% U       //             arr = arr[i + 1];
( j& |# u( }- i- b# }; d0 b       //             arr[i + 1] = temp;
  s+ {6 M( ]) L+ T2 P       //          }
      //       }' D( a( H1 {" m7 ?  A  Q
      //3、第三糖排序，以此内推( b0 W4 h, i" i8 M- U6 a- _% |; f
      //for (int i = 0; i < arr.length - 1 - 1 - 1; i++) {: B4 j0 G( n8 E' k; v
      //          //如果前面的数比后面的数大，则交换
/ E+ C: h$ S/ d; w' _' A       //          if (arr > arr[i+1]) {) f) z3 D4 y+ J9 C; o1 r
      //             temp = arr;, Y6 _: ^$ t! X, r4 @8 R
      //             arr = arr[i + 1];
+ M5 K9 T" O9 D; C; k3 |       //             arr[i + 1] = temp;
; t( U9 |- b  m2 s" K       //          }
. A+ a6 b8 x& `; r. `5 _* b0 K       //       }- O8 H6 l( d9 l6 Z+ H- L( Q8 e
      //4、第四次排序，以此内推
- n+ g8 Q3 `. v* c       //for (int i = 0; i < arr.length - 1 - 1 - 1 - 1 i++) {! Z% W1 Y9 a' x# U
      //          //如果前面的数比后面的数大，则交换! p" x6 B- o, Z7 z" A: h/ w# W
      //          if (arr > arr[i+1]) {
! B1 y, x8 J' X" w1 K" N       //             temp = arr;
( m# e8 ~2 M9 x4 R5 z" g. Y       //             arr = arr[i + 1];! B/ u' n" J% V4 E( K+ v
      //             arr[i + 1] = temp;
! k+ y$ |  _8 y! ~, y       //          }
6 l3 K; Q* B. J' ~/ h       //       }
1 w. s; s( z3 R* Q       int temp = 0;//零时变量，用来将最大的数值排在最后# _% W4 @) K5 S. S2 S
      for (int i = 0; i < arr.length - 1; i++) {
  d, r  {5 s. K          //如果前面的数比后面的数大，则交换
- i& b/ ^; E! I/ A/ ^% ?! J- D          if (arr > arr[i+1]) {9 X& ^$ p' J6 D9 z0 w( M
            temp = arr;
# E* l. G% O0 m! ^- @* E' y% I             arr = arr[i + 1];
1 A8 B: A& ?5 a* n# L             arr[i + 1] = temp;
5 y# y- n" h! Q- ?5 F          }3 G8 Y7 W4 D% o+ \
      }( Z) ]( N: w/ t- f

  l7 D7 ^# {1 v* i: A7 n& {, s- w* d) K# c9 j- p& t# Y
      for (int i = 0; i < arr.length - 1 - 1; i++) {6 o/ T, r" W" H! U& Z% j- r
         //如果前面的数比后面的数大，则交换
  I: X3 Q+ \: Q# U, J% r4 j          if (arr > arr[i+1]) {
$ X6 r( ^6 Q& T5 H             temp = arr;
1 t; `% j* l) ~             arr = arr[i + 1];3 |# L. y/ }' U, Q" K
            arr[i + 1] = temp;+ l: F0 x- [' h: @- c3 s3 Y
         }
! {" U; W% ?6 R7 E* J1 d       }
, l) k  j& H' p) }1 h) d2 ]0 ~$ N2 k* n* R" P

" _. W* A6 j; R( [       for (int i = 0; i < arr.length - 1 - 1 - 1; i++) {
; C- U3 P5 A! W6 d  z) E          //如果前面的数比后面的数大，则交换' _; A' _) F0 m- J  q4 S" Z. u
         if (arr > arr[i+1]) {5 k1 q( |9 D; [: k/ U$ l
            temp = arr;& Q1 A; C. `8 z) G' p% e
            arr = arr[i + 1];! Q5 E! z- I' B5 T* X9 n, G5 E3 E: `
            arr[i + 1] = temp;8 K* b" I! c3 Y+ q8 o  o
         }
: Y. G8 j5 V: ^; X       }
% u. B+ B/ d1 L. x, \" _, ]9 b0 G3 H9 L

! ?' {% y3 f7 L4 N. b       for (int i = 0; i < arr.length - 1 - 1 -1 - 1; i++) {9 h, e: f9 P2 ]4 x: ?, I
         //如果前面的数比后面的数大，则交换% D. _( w) C8 O7 ]6 Q9 k+ D
         if (arr > arr[i+1]) {% j2 K8 Q0 R/ T) L$ e
            temp = arr;0 u! m. N1 l/ Q; M
            arr = arr[i + 1];* h& K5 L& @0 w/ B
            arr[i + 1] = temp;
9 E$ Q1 ~. Z5 P! @. o          }
$ F4 }) w% S) c: N6 p1 l       }% T4 G9 U5 L3 N3 h7 Z5 w/ g8 O

) S" P% c/ D( ]
- B; t! Q5 E, i0 I       System.out.println("hello " + Arrays.toString(arr));
/ ]8 y) S& z. X) e. \       //------------------------------------------------------------------------------------
) H. k6 J" ?! x# V       //根据上面的观察可以知道了撒，可以再用一套循环解决- @0 m: q  m/ ]: {0 D3 v

2 _  u) K5 T# g& @' F4 L( O1 @* T, k) o' E- Y! Z$ X" N

, S& x! m' _2 O: p9 m0 Z/ ?2 S- G9 v0 V; ^) L
      //好好理解一下、由此可知，他的时间复杂度为O(n*n)
1 S% V5 F; j4 M; G1 I       for (int j = 0; j < arr.length - 1; j++) {* C4 Q: T$ W" h' X( D2 _
         for (int i = 0; i < arr.length - 1 - j; i++) {' B# _9 d- F$ `" h$ V4 ?  @. @! @0 M
            //如果前面的数比后面的数大，则交换6 j  D* V" e+ B
            if (arr > arr[i+1]) {
7 i# {+ @" k) y* `' t! B7 D! j! |5 V/ G                   temp = arr;5 r1 V8 \$ x6 n* \, x! Z
                  arr = arr[i + 1];
& R3 P! k. s% L2 D5 B                   arr[i + 1] = temp;
# Y8 H5 Q" e. `$ z             }
2 b1 _. N' P2 g" L. ?% b$ W2 J          }: Z$ {% ]( e/ x+ K
      }
. i  D0 {" J( W$ Q9 C; T* V9 W }
1 e0 ]0 n0 R& A. @}# H" _1 P1 \, H1 k. q
三、冒泡排序的优化
1、思路! F) P0 v$ L) n/ J6 J  {% K
如果我们发现在某一糖过程中，没有进行一次交换，提前终止" P- _+ u$ G9 J+ r0 t) d
2、代码实现
package cn.mldn;  v7 q# k. n9 b" U8 u1 c
5 ^0 j4 m( `+ C9 v, G
- h8 }& [3 G( t! S6 z/ l
import java.util.Arrays;; ]! @, e8 [6 [' F* O$ q

" I7 |' K/ S* p9 n
+ T3 E8 c5 W" Q- m% M: [public class BubbleSort {  M. N( v' O7 c2 y
public static void main(String[] args) {2 p2 L  o. U5 {, r8 @
      int[] arr = {3,9,-1,10,-2};
3 o, Z2 m$ @5 `. b/ {- y- H0 a       //大致过程7 L1 m2 Q$ @) P
      //1、第一步就是第一轮排序得到最大值于最后! l, Y. _$ m7 ~, n2 ?+ s
      //  for (int i = 0; i < arr.length - ; i++) {
/ T3 Q4 i# Y1 ^- `% C$ O1 R       //          //如果前面的数比后面的数大，则交换: r3 P; T$ a# N# p+ {9 _/ I
      //          if (arr > arr[i+1]) {% Q, D% W% q3 e4 ]9 ?9 ]; t
      //             temp = arr;6 ~4 t, M. Y% d
      //             arr = arr[i + 1];* }4 ~" A- I/ H+ v7 b* D
      //             arr[i + 1] = temp;  t- |- [9 y5 D6 h
      //          }
! U/ G* B* X9 z; j2 |) D1 f       //       }+ {( ^! K+ y4 v, U7 F2 t
      //2、第二糖就是把倒数第二大的排到倒数第二位
- I: v! S/ p& a( F0 E       //  for (int i = 0; i < arr.length - 1 - 1; i++) {
- ]* X8 S2 |+ @: s* M       //          //如果前面的数比后面的数大，则交换6 ?8 }( z- y" N( k
      //          if (arr > arr[i+1]) {
4 ?7 Q8 l7 h5 _9 z       //             temp = arr;
" X# D1 C& T4 \. I" h       //             arr = arr[i + 1];; _7 r7 L" t% m  B. C
      //             arr[i + 1] = temp;
, I& Y) T6 B: u4 V8 B       //          }# t' J9 `' k" R- j
      //       }
8 d# ~8 M% G% L2 Q       //3、第三糖排序，以此内推
; k; }0 b3 O  c: y2 [3 w; _: S+ }       //for (int i = 0; i < arr.length - 1 - 1 - 1; i++) {
6 g6 v) N, _( b4 l6 `       //          //如果前面的数比后面的数大，则交换
0 V+ p& N* o" W# ?; K       //          if (arr > arr[i+1]) {
% }7 J) t% T) K- U& w$ L! S       //             temp = arr;) }  ~$ P% {; |2 c& y6 f
      //             arr = arr[i + 1];2 N8 X7 Z: a& }6 \7 X1 r
      //             arr[i + 1] = temp;
7 I; [% \" D+ Z" P: F, J) j       //          }
' F8 G+ ~1 r. w2 M/ X       //       }- R( j6 x2 I; @( _6 t
      //4、第四次排序，以此内推
) Z* {( m6 P7 d! ~8 V- B       //for (int i = 0; i < arr.length - 1 - 1 - 1 - 1 i++) {* ?1 P4 X$ Y. F* ?5 [
      //          //如果前面的数比后面的数大，则交换* N9 ~0 \3 g/ T* P% b
      //          if (arr > arr[i+1]) {) s5 O; s6 X( M- w+ c- z. w* X
      //             temp = arr;! B  e/ @+ U# ]
      //             arr = arr[i + 1];
  z# ?1 C( t* C* f       //             arr[i + 1] = temp;3 T" D/ G1 g0 f! |; [/ V
      //          }$ m; Y; Q3 t* e8 |7 |. Q
      //       }$ @7 F) {$ f5 W/ a3 {& y7 T; X# j, T
      /*int temp = 0;//零时变量，用来将最大的数值排在最后1 W1 D) D$ U7 |9 i( p
      for (int i = 0; i < arr.length - 1; i++) {+ r; @6 e1 ^4 r- \
         //如果前面的数比后面的数大，则交换: ~1 c" U% K  n4 l7 M  j% h( y
         if (arr > arr[i+1]) {
1 v* z' |) s$ i             temp = arr;, P$ J. X$ w! V/ x; O) `  O3 j
            arr = arr[i + 1];! \# b0 B. ~* h0 H, x0 q
            arr[i + 1] = temp;2 i, L: Z- ]' V& Q: Q( L% p
         }1 Q( f( G* _2 H* c$ M
      }
# y6 G0 w; o% n$ K* W! x1 {& M
. T- ~* D: B1 y+ R. X6 r
3 B* y* ]0 ?2 K+ W4 o2 C& ]$ @) Z       for (int i = 0; i < arr.length - 1 - 1; i++) {
' B9 R% ]$ O' r8 ^4 _% G          //如果前面的数比后面的数大，则交换
( w- s2 v9 E$ P; {3 q: ]          if (arr > arr[i+1]) {
0 A+ E8 ~: I; j5 {$ s) G, c: R             temp = arr;* }! y7 |* [  g- ?$ s8 k
            arr = arr[i + 1];
, l9 B, @( s7 C' v  B( x3 n+ M9 u+ m             arr[i + 1] = temp;
! o3 z3 u* Y' G! c# T% y          }( b) F  q2 Y* N
      }5 l# U4 F( `+ r! b

% ?" G; p+ D; U. X# `6 i; J. B/ G. h% h7 Z3 G, @
      for (int i = 0; i < arr.length - 1 - 1 - 1; i++) {
; d( g% Z' M" y          //如果前面的数比后面的数大，则交换
1 r% ^* s/ z- E$ `' ~1 g          if (arr > arr[i+1]) {
& s2 |; x7 ]2 M* s- ]7 {             temp = arr;' d2 C5 A0 U$ H5 T
            arr = arr[i + 1];: t  N1 k/ L' s/ B! A
            arr[i + 1] = temp;% Z- E" T8 g7 T
         }( ]" o; a- q5 c
      }
9 j( M% w$ ?8 W* R$ \2 s0 X: ?0 @. F/ c

2 m0 ], r2 @! ~/ `) J  {       for (int i = 0; i < arr.length - 1 - 1 -1 - 1; i++) {
9 x( r+ l& D4 f0 W, g4 o+ B          //如果前面的数比后面的数大，则交换
3 {# Y4 Z  `9 n+ f# {  D: x1 ?0 a          if (arr > arr[i+1]) {( U" Q/ t7 i; J& K. G
            temp = arr;- d' L. q8 g1 e. k4 p4 W# l5 s
            arr = arr[i + 1];9 R0 `3 {9 n) {( g# g6 I
            arr[i + 1] = temp;" G5 ]& N. U' O9 i  u. P( Z
         }. Z. \% s7 M: s. k3 Y
      }*/! x- Y8 m8 l0 m
7 d( b4 n- m6 c9 A& d: _
1 |0 J9 F! P, K: g! m
      System.out.println("hello " + Arrays.toString(arr));
9 {/ D4 M! j/ G4 e       //------------------------------------------------------------------------------------
# v# P# V# x" H: Y! i% r       //根据上面的观察可以知道了撒，可以再用一套循环解决  m1 Y2 F0 A5 |" Z

4 ^/ M3 R# f6 y+ o# T' a- s1 g! Z; W# a, Q: m

* X& _% V3 Z# H* J
3 j! Z/ D9 |3 X5 H# t. y0 S  P3 f* \  _2 ]0 d* J) f
5 F, j; g9 B! v! D% K& M7 H
      //好好理解一下、由此可知，他的时间复杂度为O(n*n)7 D# E" a. x" L8 ?7 j* {
      int temp = 0;/ p, }. J0 a& V- o& S" p% \$ l
$ {; F+ c1 n9 v" T; y, L# v
; v/ P" d8 f/ N7 m* b+ t
      boolean flag = false;1 t& L$ w4 N$ [% G! m! `
      for (int j = 0; j < arr.length - 1; j++) {
' |; L0 v  O/ @; @& v( Z          for (int i = 0; i < arr.length - 1 - j; i++) {
; N6 r1 h1 o+ V  I5 ]* c6 Q             //如果前面的数比后面的数大，则交换: @( e9 ?# u: C1 k) j. v
            if (arr > arr[i+1]) {
4 i& v- }% @1 t                   flag = true;//在这里把flag值为true( w" [/ @* B# Z! T
                  temp = arr;0 z; y' x# f* e9 W
                  arr = arr[i + 1];& }4 t( b; }  ~( p9 F" [7 h
                  arr[i + 1] = temp;' h' }/ h* T: E) D
            }
% `- P9 ]  C% H8 o! @7 P3 o; y          }
$ P7 \+ w2 l! p, O' u9 z% N1 \# A          //在内部循环的时候进行查询
5 |* G- Y( L) P% |  k. ?. h1 L          if (!flag) {//说明在第一趟排序过程中一次交换都没有发生。) r. i1 W' j6 L- L/ y" t
            break;+ j1 j1 u% n- }$ B" A, ^
         } else {
' }, S9 A( _! `0 E% e% D5 D             flag = false;//没有这个就是执行一遍就没了，要让他进行下次继续# Z( Z1 |2 t9 a0 J1 ]) |
         }, l2 q7 v7 C$ J' c5 W4 t  J- s
      }
% T! q& Z" r7 k
8 A; j) |5 T% D% S9 {1 ^
% G8 t1 ~. _4 K$ {3 k7 J       System.out.println("world " + Arrays.toString(arr));8 J- X& ?# Y! t/ d/ j
}4 ]1 M3 a1 q( i! ?* J, v9 G
}
, G! k3 A3 E% k  K' ~* |四、将上面的代码封装为一个方法
' v9 M/ D+ o2 |6 r" J  V6 A8 Npublic class BubbleSort {3 a4 X- p; c3 ?9 P& B* V
public static void main(String[] args) {
( `( Q& h9 n1 p6 B- B( q       int[] arr = {3,9,-1,10,-2};
3 Y, q5 S, e) F/ }: k' m+ J! ?7 j# X$ {' ]0 ^( K/ X* ?

; `- ^4 U2 S5 m  K- f0 D) m2 b# L       bubbleSort(arr);- L6 \: r6 {3 V; W5 L  \; \
      System.out.println("world " + Arrays.toString(arr));  \- e$ r, ^+ Z' _
}
! w& d; P- C9 k7 d
1 A8 |! Q' G" u' Y$ ^" T/ u9 i( f# _; a4 _4 w/ W+ Y
public static void bubbleSort(int[] arr) {' L$ }# K) W& r
      //好好理解一下、由此可知，他的时间复杂度为O(n*n)1 ^- t* b; R/ K- c
      int temp = 0;
1 L& [, O6 c& M) E. B* U# a
6 T$ H' _; t: @& x# `, ]
  O9 Z! L- x: p6 o" k- G       boolean flag = false;/ ]. X6 k3 V1 A/ I: j$ ]
      for (int j = 0; j < arr.length - 1; j++) {3 z7 y2 z/ R1 W6 K  |+ v
         for (int i = 0; i < arr.length - 1 - j; i++) {) A' _3 n) D; A
            //如果前面的数比后面的数大，则交换
2 Q! C1 t2 X' x+ e4 D             if (arr > arr[i+1]) {
$ x* x4 a7 Y, E8 p                   flag = true;//在这里把flag值为true
0 R2 _/ S$ A4 e5 J                   temp = arr;& q3 O7 B8 V$ t9 H9 V
                  arr = arr[i + 1];5 g5 g7 h' y6 Q5 C/ O
                  arr[i + 1] = temp;
4 \5 [" `3 [6 F$ J             }
9 z5 |- }$ W. e! A5 s% K+ ^' T          }1 s$ Y% d7 V% J/ x; M9 i9 V) }+ p
         //在内部循环的时候进行查询
8 I8 k2 e: [% q2 x: N          if (!flag) {//说明在第一趟排序过程中一次交换都没有发生。
& m+ q/ v9 H2 X! w& v; H             break;- d, t& [% U* u! |; k& N, a, e0 }
         } else {
% h- G$ b+ F6 H6 ?4 {2 G             flag = false;//没有这个就是执行一遍就没了，要让他进行下次继续
6 T* I; ~1 U, \5 c2 K8 M          }
6 S" {. E' O. K: {$ T' H       }
5 t) p) h1 m5 d; P }
1 j6 x/ M% q5 o5 b  l4 w}5 u: {3 G/ |7 b+ ^+ b) p! c
五、测试一下冒泡排序的时间复杂度
1、代码是实现
import java.text.SimpleDateFormat;
- F0 N$ o, _8 k: X' y3 Cimport java.util.Arrays;# s: f7 s8 u2 b
import java.util.Date;
+ Y: p, w5 y& X% S/ `" M
; T3 g3 y3 z4 H' C0 N* T/ j
- G0 f+ p. r$ w0 Zpublic class BubbleSort {
) n% k7 u8 u% f) R+ S. ~  | public static void main(String[] args) {
8 {7 O4 a) z- E$ k- [* M       //1、创建80000个数据来测试一下我们的性能
8 R+ ?2 G, u0 w" a* l7 j( y       int[] arr = new int[80000];
1 ^8 ?  Q2 n: U6 H  x: d       for (int i = 0; i < 80000; i++) {
0 r9 W! j/ {1 g5 F% Z: S          arr = (int)(Math.random()*80000);//生成0到80000的数) Y2 J. k& n9 ~; i! S
      }* s2 W3 @9 U4 s* C. |- S. ?5 d* ]8 T
      //2、输出时间
/ O/ ]# j0 A) T1 D, y1 y& L) p9 F* X       Date date1 = new Date();$ D! {8 j0 _. S1 Z
      SimpleDateFormat simpleDateFormat = new SimpleDateFormat("yyyy-mm-dd HH:mm:ss");//格式化
  @9 l# d; H% [; E) O- t       String date1Str = simpleDateFormat.format(date1);
  v  q$ R0 b/ K9 c3 i5 g' L# g       System.out.println("排序前的时间" + date1Str);
5 ^8 L3 J2 q1 P, y* q       bubbleSort(arr);% J" I" w" L/ n, t
      Date date2 = new Date();
- y' U# v9 v. _3 _% N- E9 O       String date2Str = simpleDateFormat.format(date2);3 z0 r% n) g5 Z( G$ J
      System.out.println("排序后的时间" + date2Str);3 S( ]' D  S" q" V$ h
& L) [) q7 d* O

* V7 I: _" i* [- v' K
, }& o2 O# c- p" q) l" }2 X
) \8 h; g9 B" p9 H; }0 M! m }
) o* S: t9 ?* c9 Y: |: z& k! P' r4 j
8 F9 T7 x- j3 x0 b8 h% G: o" D7 d' y* `& y8 H
public static void bubbleSort(int[] arr) {$ D& v8 B8 J! k/ u* ~+ J/ e
      //好好理解一下、由此可知，他的时间复杂度为O(n*n)5 E$ B3 I5 I) Q" M8 d* s
      int temp = 0;, u  ^4 O9 ?; J, k# j% y7 K4 o
$ H! G2 |. o! O* P
4 Y1 o1 z1 L! n9 }
      boolean flag = false;- ]; ]* {2 Q; O+ k; L
      for (int j = 0; j < arr.length - 1; j++) {
( L$ ~  H* i7 ~7 c1 V          for (int i = 0; i < arr.length - 1 - j; i++) {
: I7 ^: ]! c- E2 ?  b             //如果前面的数比后面的数大，则交换, I, u: o' X1 M) |6 s+ ]5 r  @
            if (arr > arr[i+1]) {+ L3 M; c7 Q3 e& @/ i- Z
                  flag = true;//在这里把flag值为true
0 s7 w8 h: o9 C) s                   temp = arr;/ F7 C/ M# w7 u
                  arr = arr[i + 1];1 h! v' s' x6 f% {6 l/ v) @& c$ h  l
                  arr[i + 1] = temp;
. I, ~: U( k' E: ]. K: P7 [! ~             }
) A& J8 e$ B3 V) l  q2 c& q          }# A5 l% A, I; C4 m$ k, e
         //在内部循环的时候进行查询
( f! Z0 N% \! \. w. F          if (!flag) {//说明在第一趟排序过程中一次交换都没有发生。
            break;
* h- ?$ B, {# \/ l1 h1 [4 E          } else {
1 [. k# b* R& p' _4 Z. f; l( P             flag = false;//没有这个就是执行一遍就没了，要让他进行下次继续1 y9 S: I) e+ S! t7 U4 T
         }
$ i& b5 a! Y0 J  M0 w- Y6 k# B0 \       }
( ~: ^! c: V" ?. E4 ?$ Y }2 V/ Q7 r) a& m9 c8 H
}
/ d3 q0 K0 O5 y+ F! f, l; ~+ u, c$ ~
, x' {1 g' j, `, t! F1 ?( i+ c' g: g1 K3 y+ i6 ~

1 d2 X  W2 j- _( d5 n: Q2 N2、效果3 m. Y0 }1 q$ w  f* ~) G- @3 q- [4 _1 q

, f5 b% m5 \0 p0 K
# F/ Q! I+ X& k# e  d6 }% h: j& E' Q! w
% r* F9 X. d+ [- G$ _. y8 ]

: a3 _7 y! I( z. X' a8 I3 ^