查看: 3509|回复: 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]) {4 {6 x; H" u  u
      //             temp = arr;5 a( F! S& W" l. y* B# S
      //             arr = arr[i + 1];
      //             arr[i + 1] = temp;- ]& h/ E' s1 Y  T3 e% B( i
      //          }+ \7 p# S$ ^9 U- L+ k
      //       }
1 B) e2 X2 D8 k  {. Y5 y+ D       //2、第二糖就是把倒数第二大的排到倒数第二位+ {" b7 ?8 l$ @9 Y$ V  H
      //  for (int i = 0; i < arr.length - 1 - 1; i++) {
' M, b' k* i! O9 U) |# |       //          //如果前面的数比后面的数大，则交换& O( b2 d& g# H3 Y8 o
      //          if (arr > arr[i+1]) {
* w3 M: a7 F3 I1 p7 O' O- M& B% y: {       //             temp = arr;9 K. K  G; \. z* U# n/ c
      //             arr = arr[i + 1];9 f) w; m, ?+ ?* ?% Z9 e
      //             arr[i + 1] = temp;2 ]4 ?* ^; X# z7 n4 m" \: T
      //          }
' ~2 n4 R! l6 m& n/ C. @. n       //       }4 r8 m2 F& h+ p% O& n
      //3、第三糖排序，以此内推
1 u0 R8 X/ ?& K5 x) E! t. i, e       //for (int i = 0; i < arr.length - 1 - 1 - 1; i++) {! E$ b8 V6 t4 d) Z8 a. T, K
      //          //如果前面的数比后面的数大，则交换# i( K6 x6 G0 V# L, L
      //          if (arr > arr[i+1]) {
8 `# @  m" }# a; S% T       //             temp = arr;. I0 V- x2 k6 k2 Z. u1 K
      //             arr = arr[i + 1];, S+ {! x/ A4 G* }* X9 g
      //             arr[i + 1] = temp;
# d+ a7 T; _1 ~6 P$ G  G       //          }
* `, J) B- n" O' a* _       //       }
: P$ {0 s% J& t* N$ q       //4、第四次排序，以此内推
% q7 X' e% m' `; c; D9 X- s0 _. Z5 w       //for (int i = 0; i < arr.length - 1 - 1 - 1 - 1 i++) {! ^' M" A" O6 m; {2 T
      //          //如果前面的数比后面的数大，则交换% G- A* T5 v2 B4 B
      //          if (arr > arr[i+1]) {/ k: V, s, I2 t, h
      //             temp = arr;
! Z) {' e. B" F, w       //             arr = arr[i + 1];
0 `2 n6 {: c' D" Q       //             arr[i + 1] = temp;% O: {" i4 h5 h9 s% O/ m
      //          }
" g# B: h7 Q: s1 n  r       //       }# |  `: s: c  g- @* l9 M9 y$ m
      int temp = 0;//零时变量，用来将最大的数值排在最后
9 f/ g5 D* K5 n2 p$ E( r       for (int i = 0; i < arr.length - 1; i++) {+ m0 u# o/ H( t9 O9 F
         //如果前面的数比后面的数大，则交换
/ z& V$ R& T" v8 k6 \, ^          if (arr > arr[i+1]) {+ n# L. Z6 t* H/ m
            temp = arr;
, e1 t4 o' \6 X/ e             arr = arr[i + 1];2 ~# R. O4 y: K+ y3 q! E
            arr[i + 1] = temp;
2 \3 U8 l. w) J8 j/ J          }  i' a6 O+ {+ w) K1 D1 y
      }
! u1 f( f5 e% Y5 `' V9 {" o) \7 X
5 L9 V" N- k) k6 n5 _
. X. ~" T# l  t; f1 Q       for (int i = 0; i < arr.length - 1 - 1; i++) {% \- J. g* V) h4 g
         //如果前面的数比后面的数大，则交换, F' t+ M: V  v  [0 q
         if (arr > arr[i+1]) {
( e$ Y) _. I2 d3 F             temp = arr;
1 b+ z' d( f* g( l; i             arr = arr[i + 1];3 O8 i) s0 q& y0 ]. o" @
            arr[i + 1] = temp;
) K+ ?& f' C# \: T; d- i# F          }2 n1 y+ K5 x& C" y$ u
      }
# j# I, u, Z8 d, {7 _" {" X! d! h- @9 P# V
8 d- Z0 ]  T2 W. b2 {4 t6 ^9 }
      for (int i = 0; i < arr.length - 1 - 1 - 1; i++) {7 L. S) l/ Z" t! I2 {
         //如果前面的数比后面的数大，则交换/ O+ g+ ^: G4 ~- A. C8 w/ U+ J+ d; K
         if (arr > arr[i+1]) {1 e2 x% y4 Q3 Y* `
            temp = arr;' b( ~) o- }/ n, i3 |, ?0 J) b# Q% _- m
            arr = arr[i + 1];' g& \) T; \" z5 s: i
            arr[i + 1] = temp;. n' C, M6 ~6 J( h7 e
         }
4 h% o) p) w& h/ y       }: x1 h" F. I, F7 I+ M
4 n9 Q/ |& v# Z. O3 L+ e3 n

: S& v( @. {3 A6 ^: E  z4 n8 ?8 T8 M       for (int i = 0; i < arr.length - 1 - 1 -1 - 1; i++) {
7 m' @7 ?0 f! T' H. L          //如果前面的数比后面的数大，则交换
( D. g* C' j0 `# U          if (arr > arr[i+1]) {
) Q" G, s8 `3 v, B6 W! p/ O             temp = arr;
* k0 w9 m. @, O6 w- i: p9 E. Q8 V# X             arr = arr[i + 1];1 S  l) V  D/ }* `
            arr[i + 1] = temp;, }! Y, m: M: l4 r2 I  V
         }  r: G# V, |+ Y' H3 y' M( _/ f8 ?) ]
      }) G# Y. K& f' T& z3 E

8 \5 D( v" ]9 ^
$ D, S( [4 x/ `2 P5 F" q       System.out.println("hello " + Arrays.toString(arr));% y; F; a, e6 I6 W$ n( ^. X% y4 [$ Q
      //------------------------------------------------------------------------------------) B( N) m6 Y& h% e' A# ?: ?
      //根据上面的观察可以知道了撒，可以再用一套循环解决
. ~% |$ {; j  n! \. l
; e; j9 l! m. ~; i2 X. r9 a2 q! F
8 ~+ \: K7 L! g) s% y9 F6 S( u& d; K) P) n  h: l
+ }! A% R' \# U; x1 q0 [$ G
      //好好理解一下、由此可知，他的时间复杂度为O(n*n)7 a- D0 `) z. m* Y4 q0 G
      for (int j = 0; j < arr.length - 1; j++) {; h4 S" ?9 h! G/ g9 E# h" x
         for (int i = 0; i < arr.length - 1 - j; i++) {3 Q( o$ P2 K% ]6 s! P  N: F
            //如果前面的数比后面的数大，则交换% A, J( d( f* J6 J
            if (arr > arr[i+1]) {
3 B( m4 R2 t2 ^+ q# z. [- R                   temp = arr;; |% D* O2 j5 _. ^1 Q
                  arr = arr[i + 1];
& N+ B* _. }% v/ v3 O( D; M+ p1 q                   arr[i + 1] = temp;
' I- j9 Y  z9 e; x  m             }4 B2 ^0 r3 v; u
         }
9 T# s) h+ F) Z       }% H, ]; g. M, X3 w; S
}/ h- A) }( S  q: {9 T/ Y# \/ p
}
) a# @2 D' l; O- f  _7 n3 k0 b三、冒泡排序的优化
1、思路
9 x/ q. P( O6 f如果我们发现在某一糖过程中，没有进行一次交换，提前终止
7 A+ X7 e/ x* [  Q' H  l2、代码实现
package cn.mldn;
, O. p# x" w4 h& ^$ L% p1 g3 j4 o9 y0 y' a4 y( ?- S9 w, B
  v8 g" h8 c8 J, j# v8 w  g7 m
import java.util.Arrays;
- U3 g; ^0 O* D' f1 |4 j! k  d% x% E

2 H9 G4 R& H! z4 G0 x5 S  Xpublic class BubbleSort {/ t7 F! g4 Y4 \4 U3 ?4 h
public static void main(String[] args) {
+ |7 Z! x6 I2 ^( S2 z" V" B& h2 l       int[] arr = {3,9,-1,10,-2};5 n$ ?7 {& q8 x- a4 `0 M0 U# _/ V
      //大致过程) V. j. R- B0 U6 x
      //1、第一步就是第一轮排序得到最大值于最后
5 R* M/ y: @- D* e       //  for (int i = 0; i < arr.length - ; i++) {9 d0 O5 z; @( m: |
      //          //如果前面的数比后面的数大，则交换
/ ?" P- ~% `' n3 P       //          if (arr > arr[i+1]) {
. u1 w4 H& B, X1 `& K' b& G" [       //             temp = arr;
: T; `' X, w7 U( I. A% E. N       //             arr = arr[i + 1];
; m0 v: W  I+ |: s  @       //             arr[i + 1] = temp;1 f$ E1 {1 p# u/ R9 [0 t
      //          }3 H1 ^' Y$ Q4 s7 m
      //       }
2 H1 V0 O# L$ A! w" \       //2、第二糖就是把倒数第二大的排到倒数第二位
7 @% Z" I/ {  G  c9 G2 z1 n8 J! q       //  for (int i = 0; i < arr.length - 1 - 1; i++) {6 c/ m& b9 r  m- p
      //          //如果前面的数比后面的数大，则交换8 {" [  @% ~' s' g: G  |4 K9 Q7 p. f
      //          if (arr > arr[i+1]) {
9 o8 @% M* w( ~+ _       //             temp = arr;
4 I8 s1 Z9 X! ^: R5 g+ l" G9 V% ^       //             arr = arr[i + 1];
3 V9 u7 a& w$ r+ c       //             arr[i + 1] = temp;* F# V9 {) K+ A
      //          }
; Q, k9 m, T  \) @) x  q2 }       //       }; q& J* q4 G8 \+ S0 N
      //3、第三糖排序，以此内推& w  Q( N5 Z( x: n
      //for (int i = 0; i < arr.length - 1 - 1 - 1; i++) {6 a0 W. X. m; E4 F( W
      //          //如果前面的数比后面的数大，则交换6 b/ Q- q/ V) B: m
      //          if (arr > arr[i+1]) {
" e: L% F: p' D2 j+ O       //             temp = arr;# h- P: _8 }( w' B& m
      //             arr = arr[i + 1];; p+ o6 o5 s9 g) `' T: c) H
      //             arr[i + 1] = temp;' C2 W% ^1 K/ R( h
      //          }
" _' \3 M0 W" N9 V- Z       //       }
1 K5 T) [' o7 V$ E; W       //4、第四次排序，以此内推
+ k+ u; t1 [. ?! h! E8 y; s       //for (int i = 0; i < arr.length - 1 - 1 - 1 - 1 i++) {
7 V7 i  X9 h; G) c* X1 S       //          //如果前面的数比后面的数大，则交换  l" L8 B" T/ i! J4 A" k8 K
      //          if (arr > arr[i+1]) {. _5 V$ R5 h7 i, C6 V, f, N: n) i
      //             temp = arr;* f4 O1 s) \# @( p0 [+ o
      //             arr = arr[i + 1];% j- T& [4 G3 ]! ^: G
      //             arr[i + 1] = temp;3 y4 x+ j, U7 c! H9 T7 V
      //          }0 J, O9 E8 Z; B6 _+ g2 q4 m6 h
      //       }
4 H) M8 j& v8 |0 p; M1 X       /*int temp = 0;//零时变量，用来将最大的数值排在最后1 U% a& k9 \8 ~  R- }
      for (int i = 0; i < arr.length - 1; i++) {
5 {2 e8 T) X, E8 J; a# `. Y: j7 O          //如果前面的数比后面的数大，则交换
: W% R8 W! s% v8 T          if (arr > arr[i+1]) {
+ q/ e1 t% o  h             temp = arr;
* v, w5 M7 W1 C1 c9 F3 i3 ]4 p             arr = arr[i + 1];
' N; ^3 Z7 A+ o: L3 U+ A% A; T$ B9 a" d             arr[i + 1] = temp;
% e; h" x+ ?1 Q# j* D1 ?" b: y          }
  }: U( }" J: S! W, s) Z       }
& V7 F4 v. H( g3 w8 E. {5 e6 O  F9 z" H8 t+ _

7 v5 ^/ \$ R3 ~( ?- W; x! G       for (int i = 0; i < arr.length - 1 - 1; i++) {7 E6 n) x: m  x/ m
         //如果前面的数比后面的数大，则交换: Q7 p4 K, q; Q, K  @
         if (arr > arr[i+1]) {
; z; }& S6 }" `% a9 E( q7 @' G             temp = arr;! f6 a; K* c( h3 X. G  X
            arr = arr[i + 1];7 }. h) m% @$ r/ x% Y8 v# w. y
            arr[i + 1] = temp;1 C5 E. w7 ]8 U+ F. G" D& ]! D5 E
         }
/ w/ m1 T! A, D       }
% D5 C- e1 k4 F# |7 m6 Z2 i) Y
+ X! R. r- {2 z1 K; L, {3 ^/ L( j8 X
      for (int i = 0; i < arr.length - 1 - 1 - 1; i++) {
9 M( a" L1 c/ }& i          //如果前面的数比后面的数大，则交换: d+ z& G, [5 t% X8 `, Y  h6 s
         if (arr > arr[i+1]) {
! }* _5 V1 C+ g& B- S2 T             temp = arr;7 M# d  }  j5 z; L
            arr = arr[i + 1];- Z9 }' ^) T& A$ h- z! a" k' d
            arr[i + 1] = temp;3 s* N/ d6 w0 t& |
         }; x! Y5 `9 L" t0 T: D9 N
      }0 R, H* Y, R2 Y! r( _$ d+ V" s$ z& K( |

! ]0 u/ ]( e: m: {. v( V) ^7 v2 {
      for (int i = 0; i < arr.length - 1 - 1 -1 - 1; i++) {/ Y7 E% [& f4 [2 C; R, }1 ?
         //如果前面的数比后面的数大，则交换# o& \1 ]) e8 J+ h
         if (arr > arr[i+1]) {
' M, D3 A5 ]5 q6 P             temp = arr;
# {, T. _6 `! ~9 Y; y; i             arr = arr[i + 1];2 ^1 X$ e+ R! m8 d
            arr[i + 1] = temp;8 y% Y% M" K+ W
         }1 N/ M/ H/ ^  n  m+ e# V
      }*/4 _2 Q! A6 C" P; {0 ^

- u6 w9 N% m' k+ M7 @( X$ b  v! X! }
      System.out.println("hello " + Arrays.toString(arr));
! c3 q6 I) u1 X0 ?) q       //------------------------------------------------------------------------------------# z* t( w, ^4 p. P0 V9 M
      //根据上面的观察可以知道了撒，可以再用一套循环解决1 _" O, X3 G) @/ |' V* h6 o4 v

% Y; _' w0 n* `. F2 l# t
* B3 x/ U& S- x5 ^( k9 f* P+ i  Y3 m/ U* R
* j8 I- ?4 U+ ~

' ?  v* J1 b3 i$ V% U1 m3 j6 [* I- v
      //好好理解一下、由此可知，他的时间复杂度为O(n*n)$ ^9 X. I0 l1 i: p% D0 ^/ S. H
      int temp = 0;* e" S& Q: J0 J0 o2 Q# y

% W" z# @1 R4 Z/ @9 z, _3 ^, i. x3 e4 b/ c& F# _8 h9 Y8 H1 a
      boolean flag = false;
/ b. M, Y8 d0 E3 O. v4 ~3 E       for (int j = 0; j < arr.length - 1; j++) {+ Y. c, D2 U+ {
         for (int i = 0; i < arr.length - 1 - j; i++) {$ {* u# U+ M9 i" j# T! k+ I
            //如果前面的数比后面的数大，则交换
. i4 ~) Y4 @3 `% \1 L5 B             if (arr > arr[i+1]) {
4 A, m$ H) ]+ P4 z2 Q+ r                   flag = true;//在这里把flag值为true9 V5 I. {4 ~$ L
                  temp = arr;
+ d; i  a/ s  G- [; M                   arr = arr[i + 1];
4 R* }$ V/ p" j* B6 Z                   arr[i + 1] = temp;
! _8 J3 e% \: s" |             }
( v& f. c3 d  P. s' e          }
% `# r2 @+ C7 E7 N' {/ c; d; d          //在内部循环的时候进行查询) d" p3 N* A+ {
         if (!flag) {//说明在第一趟排序过程中一次交换都没有发生。
: ~- ~8 _5 Z; L& R8 y             break;6 G" w7 Q+ V" f/ L( m
         } else {
, k" b$ ^" u# e( z5 q8 A. F             flag = false;//没有这个就是执行一遍就没了，要让他进行下次继续
/ `2 f8 D% |; k$ D4 P& h! `* Z          }- F' e4 {, m( F$ k9 Q/ t. m
      }
: D# T; \5 q$ ?4 K- r
6 \, m. D5 L8 @5 }$ C# R/ [9 u1 d6 g9 v5 ], J  m) i2 b
      System.out.println("world " + Arrays.toString(arr));
) _& l/ Y2 M' V" k }
- R0 h9 `0 |% j- U6 `8 j}1 I" @9 Q9 s$ i
四、将上面的代码封装为一个方法, C! ^2 r# M$ W0 R3 ^. S
public class BubbleSort {
; D( l' ?$ _( E public static void main(String[] args) {* u6 v7 U1 |7 q0 a, Q1 ]$ c
      int[] arr = {3,9,-1,10,-2};% X" h6 i, Q1 ~9 p3 C( b* B9 q
* w+ ^9 z5 |4 l1 l
1 t" g' S) f; }7 X4 w& k" r
      bubbleSort(arr);
2 D: [& K9 m, I1 \9 H       System.out.println("world " + Arrays.toString(arr));
: C; c2 v( P! C6 [" V5 Q; J5 p* T }3 D% a' _9 s3 u
$ i5 Z5 C. m6 n1 y$ i% o

6 [7 T) e( Q* |: t% L public static void bubbleSort(int[] arr) {
3 G) m7 ^% L( [* E       //好好理解一下、由此可知，他的时间复杂度为O(n*n)
/ n# ~) c. Q; R7 \: h       int temp = 0;
2 e# c- D& g0 r* @8 _/ ~" X2 I% {0 |1 s

. w6 ~- s: U) i7 ~$ ]1 w       boolean flag = false;: c+ J+ \! G' E; V
      for (int j = 0; j < arr.length - 1; j++) {
) `* ~  y8 r# i% t1 p# Y- O' T: T          for (int i = 0; i < arr.length - 1 - j; i++) {5 c$ M6 F! M, ~9 l+ x3 ?' X
            //如果前面的数比后面的数大，则交换
9 @9 M8 d$ f: X( U6 n$ M6 Q% j# E             if (arr > arr[i+1]) {
4 a8 f% @! ~6 O5 x1 K0 B                   flag = true;//在这里把flag值为true6 w4 x& M4 \; r
                  temp = arr;
8 I7 N. |. i, I4 U                   arr = arr[i + 1];$ C# v2 c( V1 s0 d  q
                  arr[i + 1] = temp;
9 K8 `$ n  h# H* B' x             }* b8 i, z  E3 D( T4 `
         }
, g4 H9 c3 T  m+ [+ S; a          //在内部循环的时候进行查询
- [7 h( u3 g0 Q" k          if (!flag) {//说明在第一趟排序过程中一次交换都没有发生。
! x% p3 a5 w5 q5 v3 d/ e( j             break;" w. Q9 F) n! p/ D& ^" p. `" d6 [
         } else {
/ i+ U" d# C/ ^             flag = false;//没有这个就是执行一遍就没了，要让他进行下次继续
" @  j" T# C( A1 r* D* s          }7 }9 e* H, @4 E) o
      }
' N# B( y" H, H6 b; R }
* y- o2 l: o6 O# O- ^1 X}
8 Y3 y* B# u# S2 B& g7 H' E五、测试一下冒泡排序的时间复杂度
1、代码是实现
import java.text.SimpleDateFormat;
. W3 k/ b; Y/ C7 U2 simport java.util.Arrays;
, I$ O% k* ?8 Zimport java.util.Date;
5 V8 E8 I  t$ f" Y/ e' K' s  m3 t4 H' ?0 r3 J

7 {1 q$ g% i3 Q/ r4 jpublic class BubbleSort {
$ r# y7 U# D: b: ~5 i6 X. z public static void main(String[] args) {
2 R* i% }, k) o+ T3 l$ e       //1、创建80000个数据来测试一下我们的性能
; z/ M. g) r0 ]6 w       int[] arr = new int[80000];
! @4 ?0 J3 Z/ L" s       for (int i = 0; i < 80000; i++) {
& C# R+ ]' n- H- }. k          arr = (int)(Math.random()*80000);//生成0到80000的数9 p6 K8 U6 Y- ?3 M. P9 g
      }
+ d8 e7 K+ C% Y9 M; _' R# g; N       //2、输出时间
( J4 t+ |3 c+ i. K       Date date1 = new Date();
8 N0 U. g- {! w4 Q0 E       SimpleDateFormat simpleDateFormat = new SimpleDateFormat("yyyy-mm-dd HH:mm:ss");//格式化: V$ _1 R9 B( I1 B7 n
      String date1Str = simpleDateFormat.format(date1);
4 O7 k/ L6 S8 C: d$ r; Q       System.out.println("排序前的时间" + date1Str);
6 z: B7 R4 u, B3 c( t  k  R5 j       bubbleSort(arr);& b7 b4 `  W0 t2 L' l; w
      Date date2 = new Date();" e, F7 v( M1 v7 _
      String date2Str = simpleDateFormat.format(date2);3 u/ j: b9 _( D9 U/ X+ X
      System.out.println("排序后的时间" + date2Str);: G5 e. F1 Q$ N

& `" k' s4 C& O; S# ~/ c
! p% e9 ^% B, Q6 F6 k4 b* J
+ b9 |1 }! H) C7 P3 `3 E/ m" [$ |4 d; O0 ^3 i: a% `
}
$ c, R& ~1 z$ {/ Y4 W
- p! w6 i5 g* A0 v0 L" z* ]4 U, y. J3 O$ C3 e2 `
public static void bubbleSort(int[] arr) {; y$ r1 O8 [! L1 _$ h4 G
      //好好理解一下、由此可知，他的时间复杂度为O(n*n)9 _0 R5 Z! W+ y4 K; x+ O
      int temp = 0;
* I( i  o" R3 j' P+ {; ~5 e) W' X+ e; u9 _

4 {3 i% }- D' w6 Q% M: u       boolean flag = false;- H* r6 B3 ~7 R0 Z9 O; K2 e  a
      for (int j = 0; j < arr.length - 1; j++) {
$ ~' [/ x4 W5 l& ~# A. d1 r3 j          for (int i = 0; i < arr.length - 1 - j; i++) {
3 g' P: a' ?5 O             //如果前面的数比后面的数大，则交换
& Y6 n/ |: h: y. ?0 C             if (arr > arr[i+1]) {
! ?# @3 C: ^9 K' S( O                   flag = true;//在这里把flag值为true7 u) G" H" Q- [* \
                  temp = arr;( b/ l9 d0 V2 j" W+ ^- |1 i1 q( E& \
                  arr = arr[i + 1];8 i0 m6 C/ p2 m. |  Q- r8 C; W
                  arr[i + 1] = temp;$ H; X- L3 \6 L
            }
; ]% e" P9 L' B5 t& s/ P          }9 O# L1 ~- s" C1 A" W
         //在内部循环的时候进行查询
3 S! m, i  v, N! h$ y          if (!flag) {//说明在第一趟排序过程中一次交换都没有发生。" d* h; v0 X! V' S$ D# q% H
            break;
8 ~+ ?; d$ ?! J9 s          } else {! s$ Z5 e8 e* i1 D
            flag = false;//没有这个就是执行一遍就没了，要让他进行下次继续3 r1 V) h3 z# i; r& e9 x! T
         }
; z, ^8 l0 ]7 [) v1 T; T       }* o+ a4 U' T; i* T. p( u
}4 Z# s  C1 ?) Q" Z/ m5 ]
}2 e5 |4 ?6 l8 Q
$ z; h% F2 r- ^1 J
- ?" W9 @7 E7 c7 p6 J3 q+ A6 g

6 M+ h' G8 r9 l; a$ d; i2、效果$ G( C; N6 s. m+ V( P7 `

! L9 a& f3 B8 B! Y
% \& d6 ]: Y4 z+ R7 X9 {; g$ P( x' s2 U

3 ]1 t) L4 u  a7 O
5 z4 e% T  G9 j