查看: 3476|回复: 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]) {+ Z" |+ R: h% g" U0 x, |
      //             temp = arr;
. Q* i# R: a4 Z  i: o       //             arr = arr[i + 1];% i( y/ w' K6 k# U. U$ ]
      //             arr[i + 1] = temp;/ A' m) {# X  v" }: @( `
      //          }, C# M7 B$ S3 h5 h6 n$ m* u
      //       }4 Y& }- B* X2 v, |
      //2、第二糖就是把倒数第二大的排到倒数第二位# K; i: z" z; I! [/ S% r" B/ ^# e
      //  for (int i = 0; i < arr.length - 1 - 1; i++) {
' t3 o; I* ~% ?  P       //          //如果前面的数比后面的数大，则交换" k' J3 ?6 T2 P. j; ]) E
      //          if (arr > arr[i+1]) {
' L8 W, y6 p# ^2 e, }       //             temp = arr;
# P" N- H& K% R8 `2 b! q" \3 E2 c       //             arr = arr[i + 1];
  B% ^1 A. b$ S0 y$ O       //             arr[i + 1] = temp;/ W8 R9 ?* c2 F1 y0 R4 C8 @
      //          }
/ C+ F1 _/ \7 x8 J       //       }0 R% o+ x+ o6 N! [2 u
      //3、第三糖排序，以此内推  G& ]0 i3 k3 v
      //for (int i = 0; i < arr.length - 1 - 1 - 1; i++) {- S: {. m; D8 i9 r, m9 d  |
      //          //如果前面的数比后面的数大，则交换
+ x0 U) v" W6 p8 C6 C: a       //          if (arr > arr[i+1]) {
; ~) t4 Z4 `& H: M. {+ d3 b7 [& N; E4 ~       //             temp = arr;" f1 j2 }0 S, q' j, @9 e+ U+ V
      //             arr = arr[i + 1];% K! H" s" O" `  K
      //             arr[i + 1] = temp;1 I5 S- B; t  V
      //          }
1 Z  H: ?1 c4 F7 u* p  R. {4 y& u       //       }7 F1 a- w* a, }: Y
      //4、第四次排序，以此内推8 O& H) e; i) W) k; e# }! t' t
      //for (int i = 0; i < arr.length - 1 - 1 - 1 - 1 i++) {: J) J( @/ }3 D9 X" [- @' h- F+ ~/ i
      //          //如果前面的数比后面的数大，则交换+ Q  E0 X" e4 Z& a
      //          if (arr > arr[i+1]) {# j) n# l/ t2 w
      //             temp = arr;
% m4 u' ]4 f8 I9 }# T: V       //             arr = arr[i + 1];9 V% V$ b5 W9 R% R7 l; `
      //             arr[i + 1] = temp;! ]7 J7 F- F0 v
      //          }! t; F& P1 g  s/ m3 i% c
      //       }
# j" H+ `0 b2 z9 J. H       int temp = 0;//零时变量，用来将最大的数值排在最后5 P4 C3 b+ g# o# W
      for (int i = 0; i < arr.length - 1; i++) {: {/ L: O' ]% v# G% f! @: V) U6 t
         //如果前面的数比后面的数大，则交换$ d* R6 O- M4 Y9 d8 S. C
         if (arr > arr[i+1]) {, t$ a* u% @- x  N& d
            temp = arr;# r% r4 E: g. `6 j
            arr = arr[i + 1];3 a: }/ n7 n* O6 j
            arr[i + 1] = temp;
5 F8 B+ _: Z9 A6 P8 D. c: v6 Q* b- }6 N          }" r, U  m1 y0 i/ @2 v" D$ o0 q4 M4 o4 }5 |
      }% |2 \$ e$ o& `% L0 m& m& y& G" p& x
. d2 h9 C5 C4 _

1 S: e; a8 p8 U" i       for (int i = 0; i < arr.length - 1 - 1; i++) {
, I0 x/ {' j( b/ u          //如果前面的数比后面的数大，则交换
) A! c% ?$ ~+ `6 O8 O5 q          if (arr > arr[i+1]) {) a8 Y# Z/ m" z; [2 X# f
            temp = arr;  M" n4 `8 y7 v$ A8 A) T
            arr = arr[i + 1];  Z$ C3 c7 K9 i" l9 R/ y( a
            arr[i + 1] = temp;! |, R/ _# C; J" p+ m/ r# I1 T
         }
( x" B( l; D2 _0 v7 R       }' S  J9 R5 r. ~9 \' F2 K( T
  U0 b: J1 e6 ^6 M. W
- ?! t+ |# R; [8 P( F* @
      for (int i = 0; i < arr.length - 1 - 1 - 1; i++) {" c5 a6 W9 g  p7 S
         //如果前面的数比后面的数大，则交换
4 y* z$ \: X' @* ]7 R2 M/ [          if (arr > arr[i+1]) {5 ]8 T! D( A& w$ ~
            temp = arr;
! T* B/ L* l3 c* a+ B& M             arr = arr[i + 1];
( Z+ N9 n3 _3 N             arr[i + 1] = temp;
6 [& _1 Q3 I1 \" o          }
" D. C( ^3 K+ Q& o       }
# G; D* d. q+ F/ `. {0 p* k1 ]" v2 g9 f# m9 }( a

# C: f* o2 ~9 ]! K. ~. R3 m( ]       for (int i = 0; i < arr.length - 1 - 1 -1 - 1; i++) {
: c  z# A# u6 u, G" |5 |          //如果前面的数比后面的数大，则交换
, M; K; }; o5 d% V  p          if (arr > arr[i+1]) {3 @( l$ F5 l' x# t8 O* k4 N
            temp = arr;" [9 b: @$ m$ ?8 L
            arr = arr[i + 1];1 J" \5 T" o: K8 R& S
            arr[i + 1] = temp;
% V, P3 a. v! m1 x3 `5 f          }
( \) `+ A& p' K9 V9 g( T" q       }
1 V$ n4 j+ a8 S6 p0 U' j- p: I) I8 b; k- X. t: i, z
. Y& K6 T+ \+ v
      System.out.println("hello " + Arrays.toString(arr));
9 n. Q% Q* ]+ D       //------------------------------------------------------------------------------------, E8 h! `. c; ~) W4 j
      //根据上面的观察可以知道了撒，可以再用一套循环解决( ~7 T2 N: ?% O
" }; K/ v" H, r, ?7 r1 o
" d1 n, b& n9 d* N! K5 I5 D- r+ G  t) C
1 S8 K' g7 x8 Y+ ?

, {$ @8 t" A# u9 y       //好好理解一下、由此可知，他的时间复杂度为O(n*n)
; }  Z+ G7 N# G       for (int j = 0; j < arr.length - 1; j++) {
2 ]* W1 K) R. y! J, Z& d3 ^. ?1 [# X          for (int i = 0; i < arr.length - 1 - j; i++) {
5 H, |2 e! v+ B' @7 N, D7 r             //如果前面的数比后面的数大，则交换
' @$ K# u* M; O$ D4 t! l             if (arr > arr[i+1]) {
/ p4 F: ?( {9 s. m# u) J7 h& A                   temp = arr;( _2 S  z6 W4 w7 j& h% T) U
                  arr = arr[i + 1];
# p3 T" ^3 d8 D9 l: U                   arr[i + 1] = temp;; x. x5 I" {' C1 g" I0 l! B
            }
, W( {% s9 z2 v          }9 G/ w0 g6 I' ^6 G" P  l
      }
" |* X1 a: a+ | }$ {" ?, F% ^! y( T* a# s
}
5 @5 N, u; N% @% L6 i三、冒泡排序的优化
1、思路4 V8 T, h( c: N6 `3 x) C
如果我们发现在某一糖过程中，没有进行一次交换，提前终止/ v' v( j5 p) Y4 |. G$ C, T$ k
2、代码实现
package cn.mldn;6 T- x+ b7 ?3 n/ q" j9 z

" z! ?0 b; N+ l" I. D$ w( Y9 r
3 G2 H3 F! v/ W8 ]% ~import java.util.Arrays;
; C" a6 c% L) _) `2 N; e4 J& `7 g, m8 c6 L0 i, C

0 G* A0 d: h4 h6 K3 Jpublic class BubbleSort {" D0 u: C; M& m1 \4 u) b- v
public static void main(String[] args) {
) y# G: N+ Q' K% z/ v& G       int[] arr = {3,9,-1,10,-2};1 e& S# o# C* T6 D6 ~9 W/ s8 v' X; U( l
      //大致过程
$ O; H- t  }- ^# L       //1、第一步就是第一轮排序得到最大值于最后- L, e& j& K% K
      //  for (int i = 0; i < arr.length - ; i++) {
+ Y, d" N: ?8 L       //          //如果前面的数比后面的数大，则交换
8 s1 Q0 l& X/ m       //          if (arr > arr[i+1]) {
5 ^3 _+ E& t2 i9 M+ |( ^8 `2 T       //             temp = arr;
4 ~7 c$ C) ~2 X* B       //             arr = arr[i + 1];
1 K8 |1 y1 w1 f* Y2 D$ Y: V  G       //             arr[i + 1] = temp;+ @1 X- e' V' x
      //          }" |6 b9 d4 n. G, Y$ @, [# `$ c
      //       }4 T3 {$ u, b, p
      //2、第二糖就是把倒数第二大的排到倒数第二位
* ?! l+ b5 _7 d# H       //  for (int i = 0; i < arr.length - 1 - 1; i++) {* D7 c* @# O4 T0 }' S% F8 o; d
      //          //如果前面的数比后面的数大，则交换& d* h- J2 }; ~! f, X. h
      //          if (arr > arr[i+1]) {4 S; N) A2 v! i$ P3 d: ]
      //             temp = arr;
0 H1 N! B& C) _& a* P. _6 O       //             arr = arr[i + 1];
3 I* K3 P! M% O* k4 s) x       //             arr[i + 1] = temp;
* m/ i. J; G9 t- D: G8 A7 b. M0 h       //          }" |% ~8 U# M4 z( f+ ~8 V# L2 Y
      //       }
1 U8 Q) W- X# g       //3、第三糖排序，以此内推2 F" \1 \: X$ l' \+ G. q5 F
      //for (int i = 0; i < arr.length - 1 - 1 - 1; i++) {: F4 ?. K; b1 @: u
      //          //如果前面的数比后面的数大，则交换* G2 c4 N7 L- X& W, e! \2 M5 J. Q
      //          if (arr > arr[i+1]) {5 k. K$ ?& D5 v  }0 X
      //             temp = arr;
9 U, n- P& g# B5 o% Y' u9 a       //             arr = arr[i + 1];
0 u# {. z$ C, c0 B. r3 K1 I       //             arr[i + 1] = temp;+ H% g7 c& B8 n. [
      //          }& ?6 M8 E: I; E3 e1 R" ^! e. j
      //       }5 l9 p6 d5 `) c2 q
      //4、第四次排序，以此内推
( `! l" f5 c: ]7 R       //for (int i = 0; i < arr.length - 1 - 1 - 1 - 1 i++) {# s( a* F8 R' r  a
      //          //如果前面的数比后面的数大，则交换9 ~8 w/ R3 N8 A! p' ^; M
      //          if (arr > arr[i+1]) {
: I8 L. h$ Q( B  Y       //             temp = arr;. q4 X8 O3 a* L0 i4 K1 q# H4 O
      //             arr = arr[i + 1];# Z5 x7 O: E7 W- w( k7 a
      //             arr[i + 1] = temp;  T) l* A; P" n7 L$ j8 x+ I: @& {
      //          }2 E: |! T7 B. R( a
      //       }8 Z9 @( u# S1 Q: o
      /*int temp = 0;//零时变量，用来将最大的数值排在最后2 k* T- g2 R$ [3 k* f1 F0 f3 A
      for (int i = 0; i < arr.length - 1; i++) {
# G& [/ l  E0 k, H4 H0 g- C8 _          //如果前面的数比后面的数大，则交换
  L) T& h1 l' }7 U. H          if (arr > arr[i+1]) {6 h" |1 q% x. v
            temp = arr;2 \2 a5 L) |9 W( N; }/ R
            arr = arr[i + 1];4 J; L4 ?3 I% C% T
            arr[i + 1] = temp;: p  v3 I  r8 x
         }
- F+ \, G% @0 d0 v( T       }" a- z7 O6 p5 w) e
8 q2 }: {% V. b9 |4 A1 D+ L: R
( D- ^* d5 q! o( R/ k4 s* d
      for (int i = 0; i < arr.length - 1 - 1; i++) {
) M# U+ s( k: V2 S+ B9 E" J          //如果前面的数比后面的数大，则交换
, t: w* A9 O' b, a6 }          if (arr > arr[i+1]) {
: u+ D7 r/ A* [7 C, [             temp = arr;2 v# ^9 c; q, g$ L
            arr = arr[i + 1];
' A+ {2 b$ {! V( M/ K% T0 \5 n2 c             arr[i + 1] = temp;
4 k. w* _6 \8 E* P# U          }
1 X. F" ~* i5 O       }
3 M4 x% D0 D" [6 {$ f& W7 e
. s/ `8 Y3 ]! a% g- ^, n  U
; H1 Q: T: e7 C3 ]% `3 k       for (int i = 0; i < arr.length - 1 - 1 - 1; i++) {
6 c4 T6 K+ y0 m: S          //如果前面的数比后面的数大，则交换! t" R! F& J+ O! b9 s: K' j
         if (arr > arr[i+1]) {4 w# g( k, O3 U' z# Q' Q! q
            temp = arr;7 G3 N, n! ^. T$ O0 W) ?" [
            arr = arr[i + 1];
) X0 J1 Y5 D/ U0 d             arr[i + 1] = temp;
' ?' o* g9 K5 {2 p          }
* v" N* ^+ X7 x% x. Z& G       }. V. i9 `  J/ }0 q

! M- W7 i! M: O
. d9 X' _) H0 z  ]4 X/ E       for (int i = 0; i < arr.length - 1 - 1 -1 - 1; i++) {
' m; w( P6 k: N* X4 j1 {5 m          //如果前面的数比后面的数大，则交换9 R- d+ [. ?" ]
         if (arr > arr[i+1]) {
3 }5 n0 a# K6 ?% z, b             temp = arr;" Q) e& e5 J8 U9 E. }
            arr = arr[i + 1];
% v6 H8 p8 w3 e" q6 }6 @             arr[i + 1] = temp;
1 K# u- A3 c% n# `          }
% O8 f% S7 J; N+ Z* A       }*/0 c( _" c) W0 B* R1 k

7 Q( b& w* r$ d1 p( o5 T9 F& k  D& q1 k: s3 P- Y; [- V% h5 l: |
      System.out.println("hello " + Arrays.toString(arr));
* C" k) B& J1 P! U$ ]       //------------------------------------------------------------------------------------* q* l* D+ j+ j
      //根据上面的观察可以知道了撒，可以再用一套循环解决
0 n7 u6 `& x9 p' j
9 k7 y9 ]1 W* Q; N9 ]* l, Y$ ~0 b( D1 n
$ t) i% B7 u/ [$ ]$ h$ H

5 A4 b$ b% y% u% y+ r; Y
  V5 d7 @, Q( ^& ]5 Q0 ]" i( ^3 ?. E4 A8 n% P% g& E
      //好好理解一下、由此可知，他的时间复杂度为O(n*n)
! C9 r; p, h5 o8 ~5 f. o/ e       int temp = 0;
% ~: N' f9 W* }, P( E' B. S8 f% f  h' K4 _- R8 F3 ]3 `

$ n% u$ K; z9 V       boolean flag = false;
" s% U! F& u0 q  Q5 u# H3 A$ S, |       for (int j = 0; j < arr.length - 1; j++) {
( p0 A# D6 K; o$ I          for (int i = 0; i < arr.length - 1 - j; i++) {7 g* n- T" x& |0 f, E% M1 G
            //如果前面的数比后面的数大，则交换& y5 L! M6 v' G5 k# c# _2 X
            if (arr > arr[i+1]) {. J+ k4 L9 }; C! M) r
                  flag = true;//在这里把flag值为true7 H, j8 n8 l; `$ t' ^; m5 Z
                  temp = arr;
0 Z: F6 X$ D$ C5 {! x                   arr = arr[i + 1];# H* k' \. _" |
                  arr[i + 1] = temp;0 e4 T) E, l2 P1 [5 R, C1 G$ x
            }. p1 V/ ~& ^0 e- n! ^
         }5 ^3 O: S* t' ~0 ]9 [4 Y
         //在内部循环的时候进行查询
  Z* Z  K. X! C          if (!flag) {//说明在第一趟排序过程中一次交换都没有发生。% J0 w" O; |  p- B% U0 L
            break;; S" E$ o6 V, }' v8 k( t
         } else {9 W) {8 g. G. [  U: O; }
            flag = false;//没有这个就是执行一遍就没了，要让他进行下次继续
0 R. `4 @5 N# s0 J+ C          }
( F  A( I# Y* P       }$ H6 K/ P* \+ Q" ]# I5 e8 B
/ c& i3 q" o% {7 H$ E
4 j1 n0 q$ y- x
      System.out.println("world " + Arrays.toString(arr));
( w0 o% j% a: e# M8 p }' X' v# |- h& J' h: r' A, ^
}
- a1 t$ [7 o) y( g, A6 R四、将上面的代码封装为一个方法& n8 v* @1 ~0 T9 S; H
public class BubbleSort {
' i- C7 S2 z0 A2 j- c4 Y public static void main(String[] args) {4 f9 U# T9 c- X" Q
      int[] arr = {3,9,-1,10,-2};
$ U+ ^3 H# N" J6 `2 W9 R% e5 V- z# f3 X/ A. R4 }
; [# e: z! d- M# m% Z4 j
      bubbleSort(arr);
+ u7 o1 ~/ R& r" {# W9 r: ~; c       System.out.println("world " + Arrays.toString(arr));
; u7 f& C7 h0 @ }
  e, W* Z# h6 ]  ~9 i# U/ G  D& t9 ]% I) Z8 [% O4 y

6 h  [6 B- N2 }# z, s public static void bubbleSort(int[] arr) {* X% _4 v. G* {( n
      //好好理解一下、由此可知，他的时间复杂度为O(n*n)+ Z$ Q9 S  }7 H; y& z; i6 Q
      int temp = 0;
/ w3 y* C. i  T; V+ l! T6 W
  ^& s& N9 `$ A7 {# u6 f2 x* g3 [; t/ i# D8 [
      boolean flag = false;
$ }. w8 R. q- l4 n( a4 f       for (int j = 0; j < arr.length - 1; j++) {) }  W. ?* P) c3 _; w4 P
         for (int i = 0; i < arr.length - 1 - j; i++) {
9 y& J. n5 l9 w9 t, G( W1 t             //如果前面的数比后面的数大，则交换, R" K2 a3 [! L; T, W! o( ~
            if (arr > arr[i+1]) {( P  U( N3 B, z  L
                  flag = true;//在这里把flag值为true
4 v8 c2 E0 v1 u! B2 M( ]. F                   temp = arr;
: ~1 N8 v9 L0 I& R: X1 v0 o                   arr = arr[i + 1];9 S- ~, n6 C2 ]
                  arr[i + 1] = temp;
) |! G. o- _6 ^. Y" R. h' |             }, Q( D/ o; v' B; ~3 w2 F% y* d0 w# P
         }) _3 G+ u( A0 M6 _7 J
         //在内部循环的时候进行查询7 s  e1 c5 [! M
         if (!flag) {//说明在第一趟排序过程中一次交换都没有发生。
) @( S' w) k* X6 [0 l5 k6 n             break;
- c& _0 T9 R! e; o          } else {+ e, J5 H, @4 t  n8 Q/ Q0 t5 q
            flag = false;//没有这个就是执行一遍就没了，要让他进行下次继续
8 {" q3 Q7 ~6 ~, F          }
" O# d* U. @& Q! O% U       }
6 t4 _* f0 R/ u# K }
* Q% J7 {. k3 p* B. X' M}
' K: ?+ w8 o' w7 P7 S/ {/ h. q五、测试一下冒泡排序的时间复杂度
1、代码是实现
import java.text.SimpleDateFormat;
1 C2 Y* w7 n0 @3 E, |' E- ^" @import java.util.Arrays;# A: |' o8 S) w, x+ x4 k: Z, u
import java.util.Date;; Y' E. k+ s% n+ r+ K

- d" j% V4 X( z' Q, V- C  E& W% t
& U. C" x/ x6 X5 ipublic class BubbleSort {
2 }% l2 u" z  p) s, {, a& h public static void main(String[] args) {
; _8 u9 ?! p5 B% l# V       //1、创建80000个数据来测试一下我们的性能
# `9 C) f! k: Q1 o( a1 U       int[] arr = new int[80000];
& W- E' H8 n# [& V+ Q       for (int i = 0; i < 80000; i++) {  N% p2 |6 m" l1 K
         arr = (int)(Math.random()*80000);//生成0到80000的数. n5 l2 o& d. s3 [3 M& y
      }
5 ?4 I  E6 t0 V/ ^9 V" A       //2、输出时间2 x9 n* y7 H* k) d* y+ X( A8 J" V4 t
      Date date1 = new Date();8 u; x: @% r) S4 Z( ^9 k2 r: {
      SimpleDateFormat simpleDateFormat = new SimpleDateFormat("yyyy-mm-dd HH:mm:ss");//格式化
! [8 B8 _$ M; ^; F- r# l       String date1Str = simpleDateFormat.format(date1);% X% j4 W9 X' A" u; A* W8 i
      System.out.println("排序前的时间" + date1Str);6 [$ l, w3 J4 x
      bubbleSort(arr);; K+ O: R$ y9 b
      Date date2 = new Date();
) h3 P* ?) Y& ]7 F% O) u5 B& j       String date2Str = simpleDateFormat.format(date2);" B# |; L3 k. n4 H
      System.out.println("排序后的时间" + date2Str);
# ?1 a9 l0 ]/ S% b/ F- Y8 U2 F* R8 c
( U5 I' D$ W4 w: u- _5 B

9 T1 V8 q+ R. w$ }! L
6 X4 N* j( r% b+ ]. H1 B* } }6 q& b$ x% {% x4 x  U7 q

; D# @$ s0 O6 e* \& o' C6 U. u# {+ o* J+ w: R& F% x+ L
public static void bubbleSort(int[] arr) {1 }+ [+ w  b# ]' K& P# ~
      //好好理解一下、由此可知，他的时间复杂度为O(n*n). Z3 {. Z5 w; V( _( `" y' E8 M* L
      int temp = 0;
, D/ k$ {: \/ t3 X) y  z. ^  R! R* x9 j: R8 X' f1 l
& M7 e* }3 ^/ K/ h& j
      boolean flag = false;5 A$ s* @) l; h/ }
      for (int j = 0; j < arr.length - 1; j++) {
/ I5 q4 e* C5 B# M+ I7 V          for (int i = 0; i < arr.length - 1 - j; i++) {  M6 j, d$ h1 t
            //如果前面的数比后面的数大，则交换
& g  l7 F4 ^: c: Q: W6 C2 M             if (arr > arr[i+1]) {3 x2 w: W- R$ i. H
                  flag = true;//在这里把flag值为true$ G8 T% S5 |7 E% y# }
                  temp = arr;
1 U( d) f* O, B6 k                   arr = arr[i + 1];4 H: u" m  Q1 f* M1 T
                  arr[i + 1] = temp;# L, y6 x: k% t) d
            }; M0 r; k3 i" z7 G, I; D  }  L
         }
1 @1 m4 p4 N  I, O5 ^3 H, t          //在内部循环的时候进行查询
+ ]- G1 G$ ^- f0 ^* T: c          if (!flag) {//说明在第一趟排序过程中一次交换都没有发生。: N5 }9 ]" n0 X% h, C
            break;3 v$ x* C, {# e. H4 w3 R; ]
         } else {
' u" U* v4 \6 C3 F             flag = false;//没有这个就是执行一遍就没了，要让他进行下次继续7 `8 }; Y: U) C6 ?5 B" c
         }
6 @# i) r5 E( y' @$ d9 D6 J  b1 o       }! _1 y- ~5 r2 V5 p
}
2 ~7 @) K+ ^: L8 r2 @9 S5 h}/ b% a( g0 W$ |7 c% A; y$ H! X) N

' d: X# i  C0 K% k# X/ |6 ~' G* N- j( b6 {

' A( J3 B/ A: A! G4 j4 T) Y2、效果
2 F/ d: J$ L. U% p6 ], B0 Z8 V
# n$ }6 \0 L) l1 c3 [, G/ f( O2 I, C  h/ m$ [8 k( s) A
" s( |$ D5 b, O/ i0 k% {0 u, e: D

4 E, `' i# t$ u% ]8 Q- O* E$ o1 w0 I* r7 d" O9 Z! }" m8 g