查看: 3119|回复: 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]) {" v7 y" u; Y- o; w, W" L
      //             temp = arr;: q- L. `) J1 c0 r) h, U& B
      //             arr = arr[i + 1];
/ `# C5 W- o! i: G' ]       //             arr[i + 1] = temp;
5 h: x$ @2 E. K  o       //          }
7 l, H+ O- W# {/ C9 V       //       }7 u8 w: u# o2 }. s: Z7 {
      //2、第二糖就是把倒数第二大的排到倒数第二位  H& C6 e* H, L4 Y7 B+ F
      //  for (int i = 0; i < arr.length - 1 - 1; i++) {1 ^3 t* g3 i  g& X" }! k% O0 F8 O
      //          //如果前面的数比后面的数大，则交换. e; g3 ^: y% r  @: v
      //          if (arr > arr[i+1]) {
. l7 K5 q+ J* Y5 V* ?       //             temp = arr;" D1 Q2 F% y* P. k5 z
      //             arr = arr[i + 1];) E- I1 X& |4 V1 r. Z! V
      //             arr[i + 1] = temp;
* B+ I( \* U* ?! P6 Z       //          }; r# G/ G; g: f: ^* S: f
      //       }
% F& u1 ?+ ^% o8 E& U; c% s1 Z8 e       //3、第三糖排序，以此内推
6 L2 }* j2 N4 K0 w       //for (int i = 0; i < arr.length - 1 - 1 - 1; i++) {! g* k" L3 M8 @, B# \" F8 p1 L
      //          //如果前面的数比后面的数大，则交换: Q2 N1 \; O$ Q4 ]
      //          if (arr > arr[i+1]) {0 E' E% f- I" i0 D( H7 [! f( Q$ U0 l
      //             temp = arr;
2 {2 [1 H' m* n       //             arr = arr[i + 1];
1 y% J0 I7 N; R) ?       //             arr[i + 1] = temp;. r4 {' H4 ]8 z& Y1 z
      //          }4 ~. [3 J7 v- J$ A; m
      //       }
1 X' d7 i, G5 d8 }$ ?  b4 @       //4、第四次排序，以此内推0 A2 |8 I. F" ~# g
      //for (int i = 0; i < arr.length - 1 - 1 - 1 - 1 i++) {3 K$ S/ a. Q; M* j, l4 i
      //          //如果前面的数比后面的数大，则交换
% J3 m2 c& Y# e: o0 h4 i3 H       //          if (arr > arr[i+1]) {
+ _, t( _" R2 I) T$ j       //             temp = arr;
8 z* V( h( U0 ?" o6 k       //             arr = arr[i + 1];  [) }  n( K( ?' Q( |6 v
      //             arr[i + 1] = temp;/ y% L! P/ k6 q! Q; H1 F
      //          }& l7 }* x2 a6 B) E0 d; C/ J
      //       }$ r2 C4 ?' H0 Z
      int temp = 0;//零时变量，用来将最大的数值排在最后# C* z9 @  _2 M0 [, _  ?
      for (int i = 0; i < arr.length - 1; i++) {
8 e8 l2 B3 ~5 S9 _# I. R          //如果前面的数比后面的数大，则交换. n% ~4 c; }, C- {7 Q
         if (arr > arr[i+1]) {
; S' f9 n' Y) p1 o: M: D             temp = arr;
- W) ~0 v/ Z8 S7 u             arr = arr[i + 1];1 Z! W; P& k( T& Y! Y
            arr[i + 1] = temp;
, q; e& u4 b" ~: }. {3 W          }
5 e* @& J+ v# Q& p( }       }; H) ]' H' }4 ?9 K8 u4 F
1 T; j) l; L, F1 {" |2 `

. H3 i" j) }$ l: z9 Q2 o       for (int i = 0; i < arr.length - 1 - 1; i++) {
8 Z8 t, G0 z; c/ c1 @$ Q$ ~          //如果前面的数比后面的数大，则交换& V  C1 k/ b$ e6 {% N7 v; t
         if (arr > arr[i+1]) {
# m* K& e+ ~7 m' @# i. A0 S) g: ?  ?             temp = arr;
+ O% _9 H1 C  r" W1 c& \7 r             arr = arr[i + 1];8 e. k2 J" t" u+ @
            arr[i + 1] = temp;
  s! w% R6 l) E$ j  D  u( f          }
, ]) e: t9 z2 ]8 c2 d/ I0 A       }& E$ o- [7 j% [7 B4 U7 n4 D

2 p0 h" n5 e& P3 g# ]! N0 f) q- K$ s/ ~* ~$ u6 A" h
      for (int i = 0; i < arr.length - 1 - 1 - 1; i++) {. b! u# w' z$ W! I- N" u
         //如果前面的数比后面的数大，则交换
" z7 @# @! M" x9 l/ v          if (arr > arr[i+1]) {+ a* R1 U0 l+ Q+ e- w2 O$ H
            temp = arr;
* n& Q9 z* m7 {2 Z$ v             arr = arr[i + 1];
* m( a, q# Y0 G! s             arr[i + 1] = temp;
) X4 x! V" w! R& o$ u5 i: }) Z          }
" @( |- W2 J. r* V/ E+ ]       }
5 f, E9 E% S6 U+ P( r# f$ V( V' {& a6 q
- X8 F- x9 A+ F# H1 S
      for (int i = 0; i < arr.length - 1 - 1 -1 - 1; i++) {
3 W  P& c2 b  Q/ V0 O4 c5 X          //如果前面的数比后面的数大，则交换: Q7 m# q, L& Z/ o% B% D/ @( P
         if (arr > arr[i+1]) {
7 p9 S# M% v; p2 @+ g  J# H             temp = arr;
0 `" ]0 s! S! g' k: o2 F             arr = arr[i + 1];7 F7 z" R' L1 b1 Z" }1 c# A3 \
            arr[i + 1] = temp;+ C  D& w  m8 C; t  U, j8 {1 C* q6 e
         }
$ q( O) @4 T3 ?% k0 C+ e5 |/ I4 ~       }
* F/ z; i" y. X, Z) s& g
, W" L: w$ d+ [# d, L6 Q; l( |
      System.out.println("hello " + Arrays.toString(arr));& [  A) `/ R, K( n) Y
      //------------------------------------------------------------------------------------
6 h# {+ n: t$ O% Q9 k) l       //根据上面的观察可以知道了撒，可以再用一套循环解决
2 n, b& w5 e# c1 N1 q# @0 {2 B) ^* {
$ n2 K5 D$ l" F( c) e/ T5 h

+ ?; Z7 k/ _) \
( k0 w8 l) C3 W5 L& q       //好好理解一下、由此可知，他的时间复杂度为O(n*n)
/ }; K7 W! H! C1 l' S( C+ ?1 u       for (int j = 0; j < arr.length - 1; j++) {
1 n- T5 c* T( S' K0 _) b; h0 {          for (int i = 0; i < arr.length - 1 - j; i++) {* C; m6 d3 B6 i% s
            //如果前面的数比后面的数大，则交换2 n" O3 v% D6 Q$ [! @+ V7 r+ O
            if (arr > arr[i+1]) {6 E0 i9 d8 A9 w' A
                  temp = arr;2 ~' u0 |" c2 w8 \' N; n
                  arr = arr[i + 1];
$ {& s9 r7 ]9 q3 i! u                   arr[i + 1] = temp;
+ ?+ R; J- T$ Y9 N% H( |3 ?& @             }! {) ~: i. [4 Y! Q
         }) k( ^5 j$ o' ~6 g
      }0 C9 }5 b$ O* R, {5 W6 ]* k, w
}
, H/ K  {  y* R$ Z$ l+ e}; \% ~/ P0 X! I
三、冒泡排序的优化
1、思路; b1 e1 i7 V9 u3 m6 e- M  C% k
如果我们发现在某一糖过程中，没有进行一次交换，提前终止
) ~; Y8 R2 j( y5 U; \2、代码实现
package cn.mldn;5 {! [; l. m, _8 R& H3 Y

" @7 ?0 d5 g4 p3 G; y/ _$ ]& ~  K2 d9 V, }
import java.util.Arrays;# q, z- M, w( p% ~6 n2 r3 k/ y
# _5 ^1 r6 G* p4 F  i! W, _' o& O

; i+ O2 [) `6 Spublic class BubbleSort {
# n# S  _0 `" N' }, Q, F* y& D public static void main(String[] args) {' W" {- x# S; j4 V4 f: K* Y
      int[] arr = {3,9,-1,10,-2};$ v6 y" `$ l# a- N' s
      //大致过程) z" R4 I: N9 N- Z' n$ A6 i  X$ \
      //1、第一步就是第一轮排序得到最大值于最后2 U" r; d% H4 E  b  ]* O5 x: V. V' t
      //  for (int i = 0; i < arr.length - ; i++) {' ]) b/ C9 ?" I
      //          //如果前面的数比后面的数大，则交换
( a/ c1 R+ j0 `! x. S/ b       //          if (arr > arr[i+1]) {4 N: f7 g! Y" [8 T2 U3 A- [
      //             temp = arr;
+ B) m% m5 P3 C       //             arr = arr[i + 1];
1 k, C$ k9 [! z, O  [       //             arr[i + 1] = temp;9 `5 f& f, N" T% X# F
      //          }
, R: i! Z# X* W. R' m: Y       //       }2 H2 M! Q1 J; d! `- J
      //2、第二糖就是把倒数第二大的排到倒数第二位" i! q. m1 i" @6 P* P" e
      //  for (int i = 0; i < arr.length - 1 - 1; i++) {1 h9 n8 t9 Z; z6 |, v
      //          //如果前面的数比后面的数大，则交换$ J- K) |4 y/ r) r4 O
      //          if (arr > arr[i+1]) {
/ x: F2 F2 A. @0 J7 y1 {& P' L       //             temp = arr;
      //             arr = arr[i + 1];
! ]4 J  F1 A8 t" X' n" [! {4 _       //             arr[i + 1] = temp;" X, @1 i6 h2 X: J8 x/ I
      //          }! I7 X0 d: b1 c7 t( K! t
      //       }& `# `1 D( F, q2 G( s
      //3、第三糖排序，以此内推
( y' @( Z. j; \) D7 r" {# {# O       //for (int i = 0; i < arr.length - 1 - 1 - 1; i++) {
/ @$ N/ d# Q6 z0 [       //          //如果前面的数比后面的数大，则交换2 r+ `; ^/ o: l  [9 o
      //          if (arr > arr[i+1]) {
' A% q5 o& o0 |3 t2 t( [       //             temp = arr;+ {9 \3 e. w$ Y' x, j+ r3 Y
      //             arr = arr[i + 1];% {1 J/ i. `' N* X7 x; [. h" P
      //             arr[i + 1] = temp;
% r. \% Y- y+ n* H# E  ~       //          }9 a" N+ ^+ R: O: `2 ~7 C
      //       }' T: P4 Y% C, e" A7 p
      //4、第四次排序，以此内推
1 J$ f# ?* s1 U/ ?* G       //for (int i = 0; i < arr.length - 1 - 1 - 1 - 1 i++) {
7 y: ^  F1 y( l, b/ {       //          //如果前面的数比后面的数大，则交换, Z# X. T8 z% M% x2 h
      //          if (arr > arr[i+1]) {
$ F! }, m" T% k( ]2 ^& l$ C       //             temp = arr;
5 c, x4 X6 k  D# w& z       //             arr = arr[i + 1];3 ^, y/ x- M7 z1 o& c& [, H" T
      //             arr[i + 1] = temp;
5 V3 x7 h1 b$ v2 w% [  H       //          }
* Q9 P$ |- E+ V0 f; U/ |; C       //       }3 s* g$ `1 r6 ^( j
      /*int temp = 0;//零时变量，用来将最大的数值排在最后
7 u, e& R! g, _8 p( B7 ?, J       for (int i = 0; i < arr.length - 1; i++) {
6 H4 K' W7 s) M! w& W          //如果前面的数比后面的数大，则交换5 {5 j/ U4 H. C) {9 v, X
         if (arr > arr[i+1]) {9 L, R4 X  y9 ?) M) V' m) s
            temp = arr;. u) B  f0 X' B/ ]8 x& p* L
            arr = arr[i + 1];
" u8 ]0 \% ~8 C             arr[i + 1] = temp;
) d4 Q5 q# U( F  i/ H* ], G          }
' r* O8 n; i; g8 K2 ~! N& n       }' s( ]1 n  T* {8 s6 v& N  k
, {* m1 {: M9 h  r5 c5 {4 D
/ M. o8 j) u) [, B" y* R1 U
      for (int i = 0; i < arr.length - 1 - 1; i++) {. W0 d2 S9 H4 |, z' V# P. q
         //如果前面的数比后面的数大，则交换
& g% r3 h' j; w! x9 \; W3 z          if (arr > arr[i+1]) {
( G. Q- X# V6 }4 l2 q9 D# \) N" A             temp = arr;1 v2 {+ `! N, |9 a1 Q
            arr = arr[i + 1];3 ^1 E& z* H+ N; O
            arr[i + 1] = temp;; P" |; r5 L  Q7 E
         }. z2 [  R" t) F' f& u
      }0 ^9 p! m$ _  @

/ {7 v0 F3 [( j( p
/ [  h) M$ Y& b6 N0 Z9 a       for (int i = 0; i < arr.length - 1 - 1 - 1; i++) {0 W+ c$ {! v7 ^# p" s1 W
         //如果前面的数比后面的数大，则交换! a: a% h) j* [+ A" `# w/ x1 P
         if (arr > arr[i+1]) {* p" ]& G0 \* G; E* v& U
            temp = arr;
" g& a* J: o% C: ^8 Y% D+ c% x             arr = arr[i + 1];  K" u) ^0 m- O2 X
            arr[i + 1] = temp;
/ v+ y3 ?/ N8 b& J. p2 w/ z          }
1 f8 M4 E7 {6 U1 c       }% ?; Y" b0 F2 z/ G
/ h: {; ~4 I/ z9 T% u

+ `, v, E0 d, {, p) ]       for (int i = 0; i < arr.length - 1 - 1 -1 - 1; i++) {( q/ O; d# l" R" N
         //如果前面的数比后面的数大，则交换: X, F5 [7 F( f7 z$ y  p
         if (arr > arr[i+1]) {
5 c3 W4 O. A7 m$ q: A             temp = arr;
% ?) L# G( G% ?6 ]- n             arr = arr[i + 1];- S1 n/ G# l, w% T4 t6 ~+ J
            arr[i + 1] = temp;* N1 O" z0 Q) P9 b+ E
         }
% k! i4 y1 {/ s5 X! J3 e/ T. B$ c       }*/$ ?. s/ D) K2 q6 q( z
3 R1 u2 R, U9 Z+ X
# F: \5 m: Q, U, B7 \
      System.out.println("hello " + Arrays.toString(arr));
- m1 s7 E7 @8 R0 y3 r# s2 c       //------------------------------------------------------------------------------------
; r% d/ b5 y# j" F' q3 J7 }8 i       //根据上面的观察可以知道了撒，可以再用一套循环解决7 m! N- ^' k- B  D' I
+ {' P/ k0 n' X) u& P% n5 R& S! y
" q1 L. c  A* V
# U0 U! f2 I, o3 t4 d' x
: u5 d% a1 J7 b" h* E+ P' T* ~

' n! t+ x" Q/ I5 L" K; x" q' O- T: Y- r$ {8 {
      //好好理解一下、由此可知，他的时间复杂度为O(n*n)
5 ?* b6 f2 H  a. v       int temp = 0;9 S7 e, n6 N; U- |) y

2 A0 v6 J' }3 e7 K! \% Z
: ?& @0 n% f: {/ `5 t2 k! x       boolean flag = false;
3 g1 `# x$ g& \1 k* U$ D       for (int j = 0; j < arr.length - 1; j++) {  P9 r& P* J& y6 m3 B
         for (int i = 0; i < arr.length - 1 - j; i++) {
: |) O$ @. E8 l8 J             //如果前面的数比后面的数大，则交换* D" J! s. f! [+ {. A
            if (arr > arr[i+1]) {4 j/ {0 Y% ~$ a! {8 u) x; _
                  flag = true;//在这里把flag值为true
0 @/ g" x9 B; Q' x                   temp = arr;
- w7 D( L4 G- T; x) d                   arr = arr[i + 1];, ?  ^: n$ |: |$ F, l
                  arr[i + 1] = temp;  u. D/ @/ F1 d0 w% m
            }, p6 j. [/ n+ P' f" t
         }
6 |) j7 }. S) G) {5 y* I          //在内部循环的时候进行查询' q. {, @* C& G5 D2 h
         if (!flag) {//说明在第一趟排序过程中一次交换都没有发生。
& P4 S9 o& z) w! @3 s             break;" [( o8 Z0 s9 ]
         } else {
. ?. B- r$ u4 b$ _/ z8 Y6 ]             flag = false;//没有这个就是执行一遍就没了，要让他进行下次继续
( Z% w5 [, z, h) R( C0 n4 b) }* n          }6 O6 `6 j6 g  w' {- {. ^) g' N
      }( z: Y4 j4 n! b8 M4 Z: @3 I
& }7 \; y+ D$ O( t( }* J3 ~6 H9 K

/ B' c2 x& y5 i2 L4 h1 m+ u; K8 I       System.out.println("world " + Arrays.toString(arr));9 f& c: w, W/ u: F, l$ y" G7 Z
}
2 r4 J- V$ C  v1 p+ i- F( \}' K" x' Z6 J; d9 l" R0 ~
四、将上面的代码封装为一个方法! k, s7 c( q) v) Q, c+ M% a
public class BubbleSort {
: b9 w% f3 P, u& k" a5 g- s9 Q" H" [ public static void main(String[] args) {& w+ L" q1 x- C  U) F/ E* N
      int[] arr = {3,9,-1,10,-2};
( `7 [4 `9 I7 @/ W4 E. `; a9 b
/ I( s8 G; _) v
7 K- _( [3 g4 Y4 Q       bubbleSort(arr);- `4 c- ^! y% u, H: i1 k$ j
      System.out.println("world " + Arrays.toString(arr));& |/ V: i9 d! [5 S
}
& i& h. G' o$ F& }8 ^7 _% Y. s
/ Z: d# h# \9 e6 R! L) P4 Y3 m% p* h
public static void bubbleSort(int[] arr) {
+ C* v6 w0 i- c( B# q/ W/ s       //好好理解一下、由此可知，他的时间复杂度为O(n*n): k7 S' p9 J/ J# W6 W* B
      int temp = 0;
* P# Y2 u% h$ l4 p  ~, y' e' i# i) f! t$ J+ y

6 u+ A* }  j$ ]+ f! w0 j       boolean flag = false;* s9 M+ n* l& ]8 V2 V- r9 }
      for (int j = 0; j < arr.length - 1; j++) {
- y* i/ Y, C# z' l9 q- i          for (int i = 0; i < arr.length - 1 - j; i++) {
: x' `6 ~$ r7 h             //如果前面的数比后面的数大，则交换
$ l: G5 p( P5 b' U( Y% c, C9 b             if (arr > arr[i+1]) {$ q6 [/ E3 [3 W1 W
                  flag = true;//在这里把flag值为true% Z- t9 h8 {" m& I
                  temp = arr;
- W# ]+ j  B' z: a                   arr = arr[i + 1];6 s+ A; j: n% Q, ~* F0 M/ x
                  arr[i + 1] = temp;
$ v8 N+ x7 }" U1 R             }& }  y/ a! j& @
         }+ U. H0 |, p/ V* R, H, h* o1 [2 C
         //在内部循环的时候进行查询
; l: W, E: e% o          if (!flag) {//说明在第一趟排序过程中一次交换都没有发生。
' N% S2 W' U" i8 Y) c& V' t             break;
# u$ @8 D( d$ X& Z5 e% O          } else {  Q4 R9 ]- e, _6 a+ X) B" k+ F
            flag = false;//没有这个就是执行一遍就没了，要让他进行下次继续
% d* l8 l! }, p- j8 F( E          }
( u+ ~  j0 Z' v/ r9 s       }4 z& ?) [: W$ C4 k- }  e
}# U2 W# B7 [2 e+ u; v
}; E9 w+ s9 N" Q. G3 M
五、测试一下冒泡排序的时间复杂度
1、代码是实现
import java.text.SimpleDateFormat;
' [" E4 i4 F! g9 H, f7 j* N( R. Yimport java.util.Arrays;3 i4 v6 y  H# P8 I# M' g
import java.util.Date;; q+ s* a+ V( t3 Z  S
6 J* c/ e2 B  i, V  P' ]& t( H
  s5 F: z' g4 _! ^
public class BubbleSort {+ `  M; g; `- m( H
public static void main(String[] args) {; ~6 R; k, w9 b
      //1、创建80000个数据来测试一下我们的性能) y2 n2 n- ]6 ~4 R
      int[] arr = new int[80000];
: A- N( {# U7 ^' y7 U. `       for (int i = 0; i < 80000; i++) {
( h( H8 N# i$ e# T1 |9 B  k          arr = (int)(Math.random()*80000);//生成0到80000的数3 {: d2 S+ u5 B$ J" n. a, |
      }
9 M8 E: q# B" {4 S) H       //2、输出时间
* @& ^( K- ~5 h/ v5 s       Date date1 = new Date();$ `+ t4 F  M( @% I5 L4 _/ {- d" \# J
      SimpleDateFormat simpleDateFormat = new SimpleDateFormat("yyyy-mm-dd HH:mm:ss");//格式化7 e" U' R2 q( ~. O* z4 x
      String date1Str = simpleDateFormat.format(date1);
; r7 s0 d$ {$ K. N       System.out.println("排序前的时间" + date1Str);1 N  a4 o. I8 c+ Q2 g! [" L
      bubbleSort(arr);
& r7 W4 A6 u' P0 a       Date date2 = new Date();
( E/ p  o6 N; X9 j' y5 O( ~( X       String date2Str = simpleDateFormat.format(date2);6 [+ C5 q# A' U# x
      System.out.println("排序后的时间" + date2Str);$ d3 y( g; D# v1 ]7 ]( e( [! b4 ~" v
; ?1 H% M. l: {
3 \1 ?7 R# Z9 T6 m0 |# g

: y; d" s4 _, k. Y( C- m$ M/ l! j- W5 F& P/ O# J2 _
}
3 G, h" J! N) d/ ?1 n2 k- G# W; \
- r7 f3 x  p4 m, o; q) E! ]" j/ W/ f( x2 E7 X) M3 Q+ t3 L; F3 B- d5 Z
public static void bubbleSort(int[] arr) {
# P0 W! j2 Q1 K5 m       //好好理解一下、由此可知，他的时间复杂度为O(n*n)
2 u8 d! F: c* p5 `* l' ?7 b       int temp = 0;
3 D. ?5 _. E- e7 ~  v3 R9 {8 @) G9 @7 [( Q# g3 P& F
" _$ \. |/ S' D9 d4 N& a( b$ e
      boolean flag = false;4 o7 j4 \$ o" x) `9 P
      for (int j = 0; j < arr.length - 1; j++) {
7 N2 a( r) {- `: Z- }$ ?5 |          for (int i = 0; i < arr.length - 1 - j; i++) {
7 g$ Z! K) u' K3 L             //如果前面的数比后面的数大，则交换9 x; b8 ?2 w! I& r8 ?# e& b
            if (arr > arr[i+1]) {! N  r% Y, ^8 R& H
                  flag = true;//在这里把flag值为true8 r' W/ |) L. H! V& M4 c
                  temp = arr;" o; {" u- X( w+ D# d9 [" \
                  arr = arr[i + 1];* B6 P4 W. q/ @" J7 r* R
                  arr[i + 1] = temp;1 s* Q7 x! E3 J& Q7 q
            }  B. N; b1 }- J$ l
         }
: K0 i8 Y# ^' R: ^          //在内部循环的时候进行查询( L8 K: H1 B1 x8 {- ^. _
         if (!flag) {//说明在第一趟排序过程中一次交换都没有发生。
& b+ ~# q' A. ^* `1 O$ ]             break;4 |7 S9 x  L" f9 {7 L( Q1 q
         } else {4 ?! _' b0 l7 H0 u/ E
            flag = false;//没有这个就是执行一遍就没了，要让他进行下次继续
" S: C) C. k, k- x3 E+ q. A          }
0 Z6 `! w, z$ C6 F       }
: q8 g3 s2 F# l& t }/ q! \: F2 W  H8 f! C4 ?
}' |5 A  f8 K* t0 e$ ~
) c! ~8 G# J5 G1 W

, \& }/ \. P5 P- X# O8 n5 d' s" k( j# s2 N$ T
2、效果, |0 v7 C* K: o* F/ P7 U, z$ T2 O

/ u  q6 S' x+ L+ @
' @- d* J. [* x% F
) G/ ?. w& @4 A$ c" g8 L. I0 ?5 l% }5 a" l& o& n7 z- V
7 b- ~+ x; @* F" Q4 U