查看: 3201|回复: 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]) {& d/ C1 E& y) w4 u" M- r, y; a
      //             temp = arr;
8 W( w* b7 d' ~" h       //             arr = arr[i + 1];
- }6 q" D6 O! X0 d  H9 y       //             arr[i + 1] = temp;
2 u7 D( B! M: ^& T8 D! ?; F4 ^       //          }; P! |/ r+ S( z3 S' v/ w, {
      //       }, J' f: V) K# `# u0 V
      //2、第二糖就是把倒数第二大的排到倒数第二位4 Y7 Z/ h2 I& G; E
      //  for (int i = 0; i < arr.length - 1 - 1; i++) {6 B) Q0 j" q3 G. h9 f7 H
      //          //如果前面的数比后面的数大，则交换
; \3 e9 c, `3 G: E9 M       //          if (arr > arr[i+1]) {
+ d; L' s& m2 O( r* E' _       //             temp = arr;  }9 w8 a* q' u  x+ p
      //             arr = arr[i + 1];
- U1 y) T( n9 P       //             arr[i + 1] = temp;2 n7 {+ T/ e3 x/ c: P9 s' k( E% H
      //          }
- @0 V% f' G3 e* P       //       }
) f) u# D+ c& Z" x6 k2 P4 H       //3、第三糖排序，以此内推
+ E3 P4 _5 Q* C# T  I! L       //for (int i = 0; i < arr.length - 1 - 1 - 1; i++) {
# b8 U! l6 @7 w) V1 q       //          //如果前面的数比后面的数大，则交换
" N* S) y" Z) K/ I       //          if (arr > arr[i+1]) {
6 A& P! E$ y/ a' }( z       //             temp = arr;4 T2 w& n" ^6 H' @( ]* p
      //             arr = arr[i + 1];
. S& l' G3 Y+ o& v/ t1 o       //             arr[i + 1] = temp;5 ?5 z! @& W8 x$ ?* j  p
      //          }
; ^) W7 p. X: w8 s       //       }1 u! ~- e7 C) G
      //4、第四次排序，以此内推4 o5 K5 ^8 i4 j% [( E. K
      //for (int i = 0; i < arr.length - 1 - 1 - 1 - 1 i++) {
  y; K; _! `: y' k) q0 `8 l  E% H       //          //如果前面的数比后面的数大，则交换
3 b& Y/ {- h7 D& u4 g$ V3 `       //          if (arr > arr[i+1]) {
0 X8 d$ X8 X/ D& b8 G       //             temp = arr;
' F* U. A9 H0 G7 ]; i: s       //             arr = arr[i + 1];& E  H- r* I4 y/ r. B9 Z) q
      //             arr[i + 1] = temp;
/ X! T5 a8 U. D! O       //          }5 f5 s5 ]6 e/ R! N
      //       }
4 v7 C" ]/ z5 `2 \# i- e# X       int temp = 0;//零时变量，用来将最大的数值排在最后5 f6 _, d. ^( m% X$ A
      for (int i = 0; i < arr.length - 1; i++) {( u4 H0 J- o; t# |: E9 T% T
         //如果前面的数比后面的数大，则交换
: J+ ~: s; F( j          if (arr > arr[i+1]) {2 R3 Y. o, [( U& K3 z) j
            temp = arr;
: \8 ~! c( I4 K5 a$ _% ^$ `             arr = arr[i + 1];  V8 U2 C9 D* z; P. ^( \9 E
            arr[i + 1] = temp;3 Q" h, ~& t, L7 N* r
         }* x: p! F# c) d2 \" m: Q: T2 U) S
      }4 L  r4 ]$ K% ]2 L3 f

! s+ A( C# i: [+ k) ~. e
: a, F+ W/ M( n' Z0 e# ?       for (int i = 0; i < arr.length - 1 - 1; i++) {& O: M3 X, R) \* C) ^
         //如果前面的数比后面的数大，则交换
' o  d1 Z8 g( l- j0 i6 [          if (arr > arr[i+1]) {
: E) ~& f4 h6 [" u; x             temp = arr;
# s' Q; O* V2 j$ I9 S/ _4 z' _             arr = arr[i + 1];
5 ^* {* \5 B8 s* [) a" d! }4 E             arr[i + 1] = temp;
& C. t5 e8 `) C* W+ K( V0 I; ?          }
6 _7 K3 \4 d5 s8 _# B" C4 ]       }  x: J) y' b% m0 R5 D) x+ @5 F

2 q8 p4 X9 E8 U! }
! n1 v) l0 u4 m1 p       for (int i = 0; i < arr.length - 1 - 1 - 1; i++) {* d5 F4 e. T9 m* T
         //如果前面的数比后面的数大，则交换
- A: C  o; M. K: _  V          if (arr > arr[i+1]) {4 W: `4 Z7 e1 w9 R9 Q+ ?$ e3 q, P
            temp = arr;
4 B8 G" t, W; X             arr = arr[i + 1];( v& F- N9 ~  N9 b4 G" p4 U
            arr[i + 1] = temp;& K% J0 g# t' W: W7 s0 ?4 \
         }
+ s$ i6 V: Y; B' ^       }! ^2 P" N# c+ g5 O! Z
* E8 F0 |9 C. p# B6 T

* j  a8 s% J; z( H1 _. ]) f5 `! Y       for (int i = 0; i < arr.length - 1 - 1 -1 - 1; i++) {
2 U$ U+ h5 z4 p  w  Y$ i          //如果前面的数比后面的数大，则交换# h5 S1 ~9 a' s) {$ _
         if (arr > arr[i+1]) {
- L" M8 y  X/ D9 M3 u  h$ ]             temp = arr;! ~. Z$ F) q& t% e& ~
            arr = arr[i + 1];
9 K$ m* U5 [7 j# b" A+ z) i& J             arr[i + 1] = temp;
$ d) A) P6 Z! M) g  A          }
  a1 n/ Y3 }0 m0 W0 v5 x' n5 J8 ?$ u       }$ h! s2 r+ [  a& ^  T! v! A
4 S- D8 s- ^0 m0 _7 |( p

( M. h& ^3 @+ q       System.out.println("hello " + Arrays.toString(arr));
2 i& ]$ L1 u- N1 S8 G" {( g2 Q  |       //------------------------------------------------------------------------------------
8 w7 V% X4 ~7 ~* t+ E. U$ U       //根据上面的观察可以知道了撒，可以再用一套循环解决
0 f8 N2 N2 L5 Z& F) T' u9 V& |  M* Y8 a8 @# N7 k5 X

2 C8 z, i; C. s5 V5 r- W6 _* o8 X7 Q1 r( y/ Z" K5 T0 S7 t  t6 S& I, ~
6 `0 J+ M% o2 Q& q" R
      //好好理解一下、由此可知，他的时间复杂度为O(n*n)9 F- q" c6 q( F" r* |1 n9 h' L
      for (int j = 0; j < arr.length - 1; j++) {
: W' J: w; X& u4 k% h+ o          for (int i = 0; i < arr.length - 1 - j; i++) {
+ c9 A% f4 A' C7 B7 K) D             //如果前面的数比后面的数大，则交换9 B: D" C1 f% c1 d7 x( I
            if (arr > arr[i+1]) {
1 H! M. B+ n) f                   temp = arr;2 t4 E: P* u" ?4 K- P" h
                  arr = arr[i + 1];4 b6 x3 `, k% T8 c4 m" J
                  arr[i + 1] = temp;
! D6 f0 F, T0 `/ v' R             }
6 l; d1 [' v/ s" T+ \1 Y  f          }
, o" L$ S4 t& ]/ v: m. C  {       }/ f7 y+ u: p6 U
}% M" }5 Q- v& f# s8 S0 r) x
}
. P3 G7 u( T- ~" t  L三、冒泡排序的优化
1、思路' _/ d3 P0 l7 k5 _  e
如果我们发现在某一糖过程中，没有进行一次交换，提前终止
6 C( J: ?6 O" `7 u6 d2、代码实现
package cn.mldn;
( A* N+ Y/ @% S3 ~/ R: I6 |1 I& P5 u' L& z1 e8 r: c6 A6 v
# R) |' Q$ ]( ~7 Q4 G9 O
import java.util.Arrays;
% o  e0 N+ P4 d# _! d+ V" b
5 A# c2 e: v1 m) s: w) ^, I
% X" ^$ M# T# Y$ u" j" T1 Npublic class BubbleSort {
: U( K! k* I9 P& J! N public static void main(String[] args) {
! }8 y7 m( O8 \       int[] arr = {3,9,-1,10,-2};; d% u' k+ ?5 r# A, f$ r" G7 p
      //大致过程
# f, _! p; D3 x/ m       //1、第一步就是第一轮排序得到最大值于最后0 |3 d+ [' j- H3 k$ ~9 g; W
      //  for (int i = 0; i < arr.length - ; i++) {7 Z1 T2 o/ _4 Z! Y8 r" e
      //          //如果前面的数比后面的数大，则交换( X4 T3 ?1 w& R$ N* V; q  \
      //          if (arr > arr[i+1]) {, W6 t3 r! E+ b6 m" O. u1 {
      //             temp = arr;7 i  B4 V/ Z0 S0 d4 G3 [6 O
      //             arr = arr[i + 1];
; z5 \; Y6 a4 f( c9 {       //             arr[i + 1] = temp;( M$ a5 u$ A3 H& o+ X: V3 i  ~2 l" W1 s
      //          }5 I% e1 |5 t' P7 ^5 _
      //       }: D% n+ ]  d5 H9 t& |
      //2、第二糖就是把倒数第二大的排到倒数第二位; P5 w6 y0 c0 a- d4 _9 t
      //  for (int i = 0; i < arr.length - 1 - 1; i++) {- G2 G' _- }+ S7 X$ Q
      //          //如果前面的数比后面的数大，则交换
6 o; L& J& S" b: S8 g7 |       //          if (arr > arr[i+1]) {
" b$ F+ q% T' Z1 B* _       //             temp = arr;
  m, ?1 y. I# n# \4 F; t' ~       //             arr = arr[i + 1];
  X5 \4 [, x2 n, s1 H2 O       //             arr[i + 1] = temp;
; w- v& p6 S* }2 F% `( S  f       //          }
  ?+ D4 T$ b7 |) ^" y7 _       //       }
! @0 |8 K% m% s% o       //3、第三糖排序，以此内推
' T; Q$ z; C; W4 ~1 d4 W       //for (int i = 0; i < arr.length - 1 - 1 - 1; i++) {! L- n5 B3 V; A
      //          //如果前面的数比后面的数大，则交换
) q' p- K6 ~: U! L       //          if (arr > arr[i+1]) {
% }0 Z3 x" v+ Y; R3 [       //             temp = arr;
' I( L3 t) G: W1 C& ?       //             arr = arr[i + 1];8 P. W" @5 K9 E
      //             arr[i + 1] = temp;2 A, j: d) H- P2 t* g6 Z
      //          }
* y$ I" x* M# q0 n1 i9 {  b: ?       //       }$ n8 d/ E* @: V6 h% W3 g. t( N
      //4、第四次排序，以此内推
' n; u; ^+ f! J6 k- N0 D       //for (int i = 0; i < arr.length - 1 - 1 - 1 - 1 i++) {
  G: _( M' [# Z, k! B, A       //          //如果前面的数比后面的数大，则交换
4 P2 |- [% v2 x0 d* ]  @% N: ?- _3 A       //          if (arr > arr[i+1]) {$ s9 ^- i7 g2 v/ t
      //             temp = arr;
$ J# R$ f% h- f' r; y       //             arr = arr[i + 1];- M5 S8 N( T0 l9 }) b- F
      //             arr[i + 1] = temp;* e0 U# E, H" P) [" h; n
      //          }
% P0 l3 Z  O" N* h& A6 @. @+ ~1 V       //       }
. w' A" k" k! D# C& F4 d) Q3 ^% s7 k       /*int temp = 0;//零时变量，用来将最大的数值排在最后
* r/ `" T- d, W, |. R& b1 j+ b       for (int i = 0; i < arr.length - 1; i++) {# ]! G. h, Z; s3 ?1 j$ n4 {! x* f8 b& A
         //如果前面的数比后面的数大，则交换
% M6 O/ D& a0 ]          if (arr > arr[i+1]) {
: M7 [) Z4 g' J% p, z             temp = arr;
0 {/ o+ Y- Z% O8 a# d             arr = arr[i + 1];0 S( Q; I" n8 O( t6 Q* p& ]
            arr[i + 1] = temp;5 D( }7 `& f) d" W
         }
1 K! G- T0 ]5 z4 b7 y5 `       }" ^5 a0 o0 k# L5 a/ F& k0 j4 R8 \
7 [, x; \0 f3 J2 j; T2 `

* h% p6 w8 x- l0 g       for (int i = 0; i < arr.length - 1 - 1; i++) {+ o1 A0 x* q# C5 \6 d
         //如果前面的数比后面的数大，则交换
& L+ p( ^$ G: X. p9 l! }. a          if (arr > arr[i+1]) {
7 S6 ?9 X3 R6 y7 ~0 j3 j             temp = arr;
7 ?% U6 ^" _3 X! W& P             arr = arr[i + 1];- l  A9 t! B2 [5 k4 T
            arr[i + 1] = temp;
; B+ i. v9 L( Y  |: R2 {          }
0 A" q$ R9 Y4 r) V1 ]4 R5 w- q       }
5 U, s' q' j: I$ _+ A
4 J, Z) B" ~' d
  W  B, {6 f' N$ d       for (int i = 0; i < arr.length - 1 - 1 - 1; i++) {0 Z% u: ^+ Y* l* A  f  ^* E
         //如果前面的数比后面的数大，则交换
4 @" q5 A- M' T          if (arr > arr[i+1]) {
7 P# V' H2 Z3 d/ ?/ }             temp = arr;
8 E+ e: V0 H+ d3 q( D$ g& p( ]             arr = arr[i + 1];
* @% k+ _# Z5 a# r             arr[i + 1] = temp;) E. n' t1 ]% c7 T- ^9 b
         }! G$ i" Z2 q+ m6 Q
      }- J0 Y8 Y  P% G% a

3 z# j; ~9 c9 o; v. _+ P# f  z$ s. O' @7 {
      for (int i = 0; i < arr.length - 1 - 1 -1 - 1; i++) {" ^7 q2 Z: w8 @* {) Y
         //如果前面的数比后面的数大，则交换% Q$ L( l' o. P) i' C
         if (arr > arr[i+1]) {
5 s: z: ?  H# a) a4 R             temp = arr;! K8 ^0 C3 \6 g1 e8 L
            arr = arr[i + 1];  x( k8 j  S6 E2 J3 P5 K
            arr[i + 1] = temp;
4 {# {8 Z7 Z' A3 @$ m          }4 w# Z% {/ S2 X/ v/ P
      }*/
5 j& r2 P7 i% x: F9 x8 }  n" u4 E0 J) r" N$ g7 w
# J* w: ?) E0 @( w! ?. \. I
      System.out.println("hello " + Arrays.toString(arr));
0 }! ]$ A' i1 ^: P7 k1 H1 C! T0 w, \       //------------------------------------------------------------------------------------
* N1 T* i* H" i. H. x$ l% q       //根据上面的观察可以知道了撒，可以再用一套循环解决* ~- y$ S8 V& O! u
3 e+ f$ H5 V4 \

3 D) g. L1 u/ F. L4 i% o! W
" \7 u+ m5 M6 ?- [+ P+ b* f
  ^1 _8 A  p) Q3 m  W3 j6 [/ I0 n  X. M# Z' y6 i( u: r' @  u# F

% Q0 C; ]% S( w' _7 J0 g5 m       //好好理解一下、由此可知，他的时间复杂度为O(n*n)
8 Q: ]& y$ x2 t) b# V9 N/ B7 ]       int temp = 0;! d0 W" B7 t3 l
6 [9 d  X+ N* m8 V& X

) z' x# K) ]1 v; t1 Y       boolean flag = false;, t  H3 y% {& `( S
      for (int j = 0; j < arr.length - 1; j++) {
8 y0 i$ i8 H  [; f0 H          for (int i = 0; i < arr.length - 1 - j; i++) {9 E+ j& l. x+ W
            //如果前面的数比后面的数大，则交换
  D& q" B/ N! j             if (arr > arr[i+1]) {0 _5 F1 D) p  J
                  flag = true;//在这里把flag值为true2 m7 Z* G* c- _) f% q( e* U
                  temp = arr;( M" b+ }- ]. f+ R; ~# x
                  arr = arr[i + 1];# a0 m2 m3 B$ @* g
                  arr[i + 1] = temp;7 B9 n" n( C" [# c# s5 X! U6 t
            }1 ]% i6 k3 K5 p! _
         }
/ @, L5 p# p) ?4 B, t1 F' E- B          //在内部循环的时候进行查询
- _" B, }% r$ s% R          if (!flag) {//说明在第一趟排序过程中一次交换都没有发生。4 G) s  N* E: v3 \: R9 `& n
            break;
2 O* V) b. M% Y          } else {, Z. v' \: X! O: d
            flag = false;//没有这个就是执行一遍就没了，要让他进行下次继续
- E8 O2 w7 ?) a2 \' W4 v          }
  r: \" G& X9 M: O& c  Q# Y! @       }. Z( h; P$ |- ^) {
( \* o8 F- U" y9 C& ]

+ y* f8 }' v2 H6 w- L3 `       System.out.println("world " + Arrays.toString(arr));8 D0 C; d/ m' N( v% v7 s
}
0 i1 v7 x& e8 ?0 x1 H}+ t! g0 I, r/ n
四、将上面的代码封装为一个方法
* o. p1 i! X$ |# Y( }$ @public class BubbleSort {
0 r9 ?, T) Y  q8 b  P0 s public static void main(String[] args) {% r- J9 G. `" C
      int[] arr = {3,9,-1,10,-2};
; I+ d3 T: P, ?! q( `& F$ l$ k; Z4 o' H: u' z/ Q: [5 A7 o. e4 W
% [+ V# \8 p) @7 F. ^
      bubbleSort(arr);
# L6 q( r) C6 X, u: G" P1 d+ B       System.out.println("world " + Arrays.toString(arr));, h  K& M. s1 g4 f
}
* e6 Q+ R9 N: J9 s  P5 Y( Q1 d! \) x! g# @. N0 k

0 B) t0 H7 R- H2 C# r# P& m public static void bubbleSort(int[] arr) {: N. j  P( `8 I. d  x  G
      //好好理解一下、由此可知，他的时间复杂度为O(n*n)$ q- j* ~: [" E, j
      int temp = 0;
3 A5 w& [! o- T& Q2 ~2 ?7 Y+ ]% y' s, S: u. C1 s

3 d& g$ B2 I1 J1 s5 [       boolean flag = false;
# `5 y' k# ?& w8 ?, a. T3 K       for (int j = 0; j < arr.length - 1; j++) {0 Z  Y, a4 q9 M9 ]; F
         for (int i = 0; i < arr.length - 1 - j; i++) {
3 d+ D; ]9 |! j3 U0 ~             //如果前面的数比后面的数大，则交换3 A7 s, Z4 Z8 D; b# g# o
            if (arr > arr[i+1]) {' E9 d( M  c( I$ G
                  flag = true;//在这里把flag值为true
; S  y9 B* b5 i+ d! y0 a! d& r                   temp = arr;, E! I: M; x8 M4 O
                  arr = arr[i + 1];+ H: \. y1 E  \+ T4 a/ Y2 b
                  arr[i + 1] = temp;
& k" U- r/ t3 w, F3 z' V" G             }5 m. Q  l# o$ [$ n6 W5 q  Q0 J: b0 E
         }
$ B, E7 N2 v; r& C+ d          //在内部循环的时候进行查询, b9 k5 Q$ p7 K- K. n/ z- |
         if (!flag) {//说明在第一趟排序过程中一次交换都没有发生。4 ~& K. f- R/ S0 |4 R
            break;
- q& W( l/ ^: u          } else {
: j% h( d2 A: f8 }7 w9 F6 i8 j5 {             flag = false;//没有这个就是执行一遍就没了，要让他进行下次继续! \# h9 X4 G& S2 m9 @5 z  w8 u
         }
% v. h+ X! x& S( I; d1 [       }
4 J. H% G& @. }# N }4 O* c8 N& ?1 }6 V
}; C. I5 z6 k4 v9 P7 J3 Y. l
五、测试一下冒泡排序的时间复杂度
1、代码是实现
import java.text.SimpleDateFormat;) ?, ~1 z4 u) d
import java.util.Arrays;
$ l6 \+ S# D& g: fimport java.util.Date;6 k9 e1 m  ?( o, {/ f  i

/ n, ]1 R1 J& \8 t2 H% ^
6 r) P) g/ p8 Zpublic class BubbleSort {( t4 |: B- z$ l" m
public static void main(String[] args) {
; l! ?' K' |5 c( n       //1、创建80000个数据来测试一下我们的性能
1 U* ?& Q  o3 K8 D       int[] arr = new int[80000];0 V2 m! y1 P/ k8 b7 b" a5 D" F
      for (int i = 0; i < 80000; i++) {/ W- ~* E* \- R6 ^
         arr = (int)(Math.random()*80000);//生成0到80000的数
) s! l( V' M( e7 I       }: @- x5 K% s3 u
      //2、输出时间5 G1 K; _# U( o' d3 I
      Date date1 = new Date();7 x7 A; ^! ?7 h
      SimpleDateFormat simpleDateFormat = new SimpleDateFormat("yyyy-mm-dd HH:mm:ss");//格式化
) e0 R$ g4 ~. {) `. m       String date1Str = simpleDateFormat.format(date1);
3 p# \3 O! y. r7 c) r8 \4 w3 `       System.out.println("排序前的时间" + date1Str);' p, B5 r/ [' v1 v) v
      bubbleSort(arr);' J; f( a! s4 L+ a9 O$ U6 v
      Date date2 = new Date();
. W  w# u: G. a! u/ \" Z       String date2Str = simpleDateFormat.format(date2);
* O* |4 ]/ n+ }; W6 f       System.out.println("排序后的时间" + date2Str);
* }7 g6 G! _0 V5 f8 Q- L6 B# j$ k" m2 G" u/ H) M. }/ M

9 C/ ^" `; V2 s
4 ]/ y: A% e9 i+ q- Q2 Y: o; e
8 z6 J' I. |- h; T6 Q9 C* _9 S, ? }
/ }0 i) f7 z( [, d, b$ K" S% c- }. P' W" {$ e% W# h$ O
$ |) Y/ W- ]# h; X7 _1 G5 {
public static void bubbleSort(int[] arr) {
3 k, n0 ^8 M, A6 @4 W- q) P       //好好理解一下、由此可知，他的时间复杂度为O(n*n)- n: M6 j$ V' g1 m
      int temp = 0;' K9 \4 a: l  G  i7 g% h

" z* g2 v- I8 O$ E1 ~( v
' s' z2 G( ]( {3 z5 Y       boolean flag = false;
1 F1 G& E" l/ O) z' K       for (int j = 0; j < arr.length - 1; j++) {, Y9 t' I! V8 H4 J3 m' m# @$ A' [
         for (int i = 0; i < arr.length - 1 - j; i++) {8 m3 b' I7 U, {' o" n( f
            //如果前面的数比后面的数大，则交换2 h# w% ~- ^8 p$ e& w
            if (arr > arr[i+1]) {
+ D2 e/ a1 [6 }3 [                   flag = true;//在这里把flag值为true
& L8 O0 k& [2 X) m( |" F8 V/ w                   temp = arr;
4 B# Z& b. v- V( Z$ Q' t) U                   arr = arr[i + 1];
4 Z1 Q& d5 i% f  p* Y" ]+ w4 t                   arr[i + 1] = temp;
7 [- D# ?: J( ?9 ^/ X& D# C( I             }8 j7 n! c. \) ~3 M, i6 F& X
         }* u8 F! O4 W! e3 l
         //在内部循环的时候进行查询
2 c; Y: U& T3 ^* J          if (!flag) {//说明在第一趟排序过程中一次交换都没有发生。* d' D1 X! b- C. \1 l& ^
            break;' e: A; |, k* d% K9 L0 L. C8 B& t8 }
         } else {$ d6 H2 x/ X& [5 E
            flag = false;//没有这个就是执行一遍就没了，要让他进行下次继续
" _4 D1 W& w2 w  v& n* g          }3 Q/ T# x) o/ k5 ?, k
      }
2 U0 c4 K6 j- ?- D9 ? }% K6 C% D1 _5 k9 b0 P' V  W, L
}
9 z/ o1 s' ~! h- `( u! w; V% h7 c6 Z) ]$ N, V- O
  d' B% |+ c  q" Y( f; s' w
3 H- U( ~: M" d$ c0 w
2、效果
, N. `: e" @4 y+ |5 j0 W6 ~6 s
! ^6 p7 M$ b5 b
+ I+ I; I" {# h! S
5 |) `0 Q+ X. ]8 p
$ f0 |) \. {" I) Q, c& J
1 g2 p! w) c- n0 I' v1 c' o