查看: 3526|回复: 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]) {: T" g) Y/ v0 G; A2 P  t$ Q% a
      //             temp = arr;+ W! N" ^: o- e) ~: @- f: Z
      //             arr = arr[i + 1];
6 p4 k8 c: w" v: q       //             arr[i + 1] = temp;( N0 _8 g& d. {' a0 e  F1 `5 m2 V1 s
      //          }8 ^) i' I3 a7 G4 b) D/ ]7 h
      //       }
+ U+ J2 B4 ^7 d- b7 D4 m) t0 T       //2、第二糖就是把倒数第二大的排到倒数第二位! i$ r4 E% Z) ^
      //  for (int i = 0; i < arr.length - 1 - 1; i++) {5 f* f4 s1 }. x8 g, b# _% i: k
      //          //如果前面的数比后面的数大，则交换( K# z! l5 z( a2 ^
      //          if (arr > arr[i+1]) {& [; E/ O% }7 i4 @
      //             temp = arr;' C4 w0 d9 P" x- T1 Q
      //             arr = arr[i + 1];
, O) e  N1 |# u4 u* v1 c       //             arr[i + 1] = temp;4 ?6 M% n  i& ?, W$ R
      //          }. Y4 h. _, K* `6 D3 c3 W2 b
      //       }. [2 o, C0 M. T) \! w$ R
      //3、第三糖排序，以此内推) P, a$ p, d: o2 S+ [. t: d; L
      //for (int i = 0; i < arr.length - 1 - 1 - 1; i++) {% \3 e; y1 a, q$ {! _4 C
      //          //如果前面的数比后面的数大，则交换9 g' N& t4 E" z
      //          if (arr > arr[i+1]) {
" j# ?9 N  D9 U* H9 u. j0 c       //             temp = arr;  @. v6 e! r! }+ h2 S* T3 L
      //             arr = arr[i + 1];
6 i( ?( ?: ]# E+ a       //             arr[i + 1] = temp;# k4 N7 e3 ^; r# f' d8 d# |- [
      //          }, a7 ?" J* g, }
      //       }
: [) b9 z" j3 x4 f* ?       //4、第四次排序，以此内推: r0 p8 [. S9 x" \
      //for (int i = 0; i < arr.length - 1 - 1 - 1 - 1 i++) {
( o$ ?4 Y3 }( K& {+ [2 X/ H       //          //如果前面的数比后面的数大，则交换
7 K5 I4 q3 V" a* \; x       //          if (arr > arr[i+1]) {! t3 a0 q6 a* b" I8 f; ]
      //             temp = arr;
9 s6 @, w0 j# A       //             arr = arr[i + 1];
3 @8 H+ y) N! O! j       //             arr[i + 1] = temp;
( |# Y$ c: K% A: T- e0 X       //          }
" d: |6 o! g. A/ b0 J2 a4 s$ N       //       }
- f6 r6 F; q" Z! j       int temp = 0;//零时变量，用来将最大的数值排在最后) a' q7 l5 f) _& `0 r
      for (int i = 0; i < arr.length - 1; i++) {
4 L, Q0 Z0 U7 ?+ Z0 R4 q) Q- ~          //如果前面的数比后面的数大，则交换7 B4 U* f, n0 e- i$ P$ V  c
         if (arr > arr[i+1]) {8 t& f2 }8 H; R: Y, _+ w) N
            temp = arr;* @$ [, X3 t. n1 d3 ?, ?! O+ R3 T& V
            arr = arr[i + 1];2 f( v. p& x3 r
            arr[i + 1] = temp;
; j7 L+ @! Z) l: v3 x2 _$ \$ E. r          }! l' c: c( k: j7 c
      }
: O5 _, W' Q) Q. _) }
  ^3 B" _4 V. A* @0 F
  o1 f, Q! {% `( k2 P       for (int i = 0; i < arr.length - 1 - 1; i++) {
$ v. r+ m' Z# ~- T- g          //如果前面的数比后面的数大，则交换
  u- d# ]- M. o# M! |7 i1 [          if (arr > arr[i+1]) {
* _) ?2 C5 u6 r9 V# ~" e+ ?             temp = arr;
( i5 E. A, ^4 y7 }$ r9 d- O$ l             arr = arr[i + 1];
* h* I7 A4 R  }6 g; ^             arr[i + 1] = temp;7 p5 h$ n, q5 m5 ]
         }0 F. g+ _1 |' P8 {
      }* V/ t8 \: |; v% P0 N- r7 h
; E% t3 t* k- i2 d# x' e( F, `

+ E+ X0 T) f" e" k0 _. x8 P       for (int i = 0; i < arr.length - 1 - 1 - 1; i++) {5 u* ~' ^+ N  r9 R- C  Q
         //如果前面的数比后面的数大，则交换
; t; V: ~+ D! {* _          if (arr > arr[i+1]) {
( W& B: G  M$ `) N+ m% b             temp = arr;
5 y0 E0 W2 ~9 A2 V' J4 m( k             arr = arr[i + 1];
# `" d' C1 i& t$ c$ y             arr[i + 1] = temp;7 e6 \! E3 |& U
         }
: o9 \3 N) {7 D" ]5 q1 A4 p       }- N' E8 ~6 |: J( M5 H$ W
$ _+ ?: [) ?. C- X, t

( q1 V' m+ a8 o7 ?$ l* L) T1 c: x       for (int i = 0; i < arr.length - 1 - 1 -1 - 1; i++) {0 t) O; T1 N. J
         //如果前面的数比后面的数大，则交换
1 B2 r2 E+ Y6 S$ m4 ]          if (arr > arr[i+1]) {
9 L; B/ ^4 I7 X% U, r& P4 U             temp = arr;
+ A3 S% b. S' s$ W: j1 a- G7 B) f/ K0 s             arr = arr[i + 1];( _/ A2 G# \# x/ Q
            arr[i + 1] = temp;
+ e2 d/ z* Q0 j) y% I0 u  ]          }
# C: C$ r: A+ B       }  ?" f/ N+ X! O7 M

2 x9 ^( h- a) J, v: _. m0 T$ {9 f$ V& O: U
      System.out.println("hello " + Arrays.toString(arr));) I" g0 n% S  j* r
      //------------------------------------------------------------------------------------
. Z7 p+ c2 e! s/ y3 b, J" G       //根据上面的观察可以知道了撒，可以再用一套循环解决
! H6 [- s6 o9 ~# H, v, I5 m5 F5 B' X/ A' H& K: R, S: o  x

! C" R" x5 ^# U9 p1 Q$ \, }( g3 ^: a- g$ M. o1 p, z/ Z
# S. T/ R6 }, y1 u
      //好好理解一下、由此可知，他的时间复杂度为O(n*n)6 z) E6 {# S* i
      for (int j = 0; j < arr.length - 1; j++) {* P" R6 W5 V, h, x, {
         for (int i = 0; i < arr.length - 1 - j; i++) {2 l/ k9 v* o* j/ J* P+ c9 `7 w
            //如果前面的数比后面的数大，则交换! t7 F( S1 o. |0 H" F  e# U
            if (arr > arr[i+1]) {; f+ g; _/ S5 K" _, n0 n
                  temp = arr;
" a& T2 j8 K2 ?; w# m+ j3 L                   arr = arr[i + 1];
$ d+ \7 c' P( ~3 N$ M. G                   arr[i + 1] = temp;8 ^# I/ @8 W; Y, n  w# Q7 R: n( ~
            }  ]* W" l$ j; m9 H- ]* c# ~7 {
         }
6 o8 V( x! q) {" X; ]       }" N7 T; J. L7 e; s
}. X0 E2 A0 l/ Q) i/ A5 T
}3 b# v! D$ D: I& {
三、冒泡排序的优化
1、思路
; D+ r) x" h4 ~' H1 ^9 |如果我们发现在某一糖过程中，没有进行一次交换，提前终止
: d  z; a( ]6 C$ t; n1 T: ?% E6 d# [2、代码实现
package cn.mldn;
" E. _9 p. e* S/ I& u$ F5 L3 Q) u4 u/ Z9 Q: O3 T4 E. h- g

( E5 H; y0 V; dimport java.util.Arrays;! B8 c! m# s/ D
* u, c% L3 C/ p+ j  t1 G& I) s
8 y- K6 E6 l/ ~$ N; D
public class BubbleSort {
: L# L9 s7 d9 R7 p' p: B5 V public static void main(String[] args) {6 O0 b1 {, X0 H
      int[] arr = {3,9,-1,10,-2};1 H& }1 I  ?! o9 V5 B! ~
      //大致过程
7 |5 w; w, H. D2 d- v: c" G       //1、第一步就是第一轮排序得到最大值于最后
! i) L5 s  a- I- ]- l       //  for (int i = 0; i < arr.length - ; i++) {7 L* c2 {4 u* I
      //          //如果前面的数比后面的数大，则交换
/ M  e' [& B6 r! O       //          if (arr > arr[i+1]) {: s% |0 H+ s, ], a- ~$ P/ F5 ~6 L
      //             temp = arr;" s- h! Z8 z5 |( S4 c
      //             arr = arr[i + 1];
- _5 t: a# ~3 V6 P( b# A, j       //             arr[i + 1] = temp;% K% A# \5 z& E- K
      //          }' o) T& h: R6 R% N8 O% L0 E; [- V
      //       }3 n' V/ D8 }: f/ o# y( c8 d
      //2、第二糖就是把倒数第二大的排到倒数第二位: X) l; K' L0 J4 c& q" a. s
      //  for (int i = 0; i < arr.length - 1 - 1; i++) {
# N$ w( n2 Y- D       //          //如果前面的数比后面的数大，则交换1 D# I3 K% f( k9 [) {, T) J* A  D
      //          if (arr > arr[i+1]) {
* e* X; O. S' o7 t/ }       //             temp = arr;
% `. u) A; v9 `, |9 @. h       //             arr = arr[i + 1];
7 q4 U( S/ k* \1 t; W6 d$ o3 i       //             arr[i + 1] = temp;
% w7 f* Q7 F# k* U2 S8 V       //          }
7 j  i0 ]8 c3 a       //       }
% I- w) ^/ M4 U/ ~! P! R  ]       //3、第三糖排序，以此内推( w; ]. s2 L, B, Z
      //for (int i = 0; i < arr.length - 1 - 1 - 1; i++) {
9 O( Y2 ]$ y  n- J7 v       //          //如果前面的数比后面的数大，则交换- {  W9 J3 T0 s$ N
      //          if (arr > arr[i+1]) {( H# _7 U6 V6 N3 h
      //             temp = arr;
/ A4 J6 T9 `+ H# h/ N       //             arr = arr[i + 1];) S$ `5 r, @4 M- p
      //             arr[i + 1] = temp;; |) d9 t8 G- u% d2 F
      //          }
% p# {6 i3 n, Z! q1 h" e  f' A% s       //       }
3 D7 L3 \% A$ v, N$ ]       //4、第四次排序，以此内推
$ c* M8 i! \- y' e       //for (int i = 0; i < arr.length - 1 - 1 - 1 - 1 i++) {3 e0 P; x. y+ \. J( Z6 J) s
      //          //如果前面的数比后面的数大，则交换7 x2 g; t9 I" }: k3 r' r3 }; l
      //          if (arr > arr[i+1]) {& S  o9 @) B; r# M0 |
      //             temp = arr;+ _' n6 \1 c- d' c3 i7 \
      //             arr = arr[i + 1];5 Z+ z4 q) q& f2 ^! M5 }+ m6 c2 T
      //             arr[i + 1] = temp;
0 M4 A4 L5 W- ?+ j       //          }
3 j# M1 D+ d9 }0 M3 _0 j- l       //       }! T  t- h) a5 @
      /*int temp = 0;//零时变量，用来将最大的数值排在最后
: t& I+ f! D8 f       for (int i = 0; i < arr.length - 1; i++) {
( c+ {+ ]6 b' A  M1 k$ R          //如果前面的数比后面的数大，则交换) Z4 \3 V6 M9 c! O" N% H
         if (arr > arr[i+1]) {+ A% U' F0 |' i& e
            temp = arr;
2 N% B+ ^$ Y: M6 c             arr = arr[i + 1];8 ?4 m4 i; ~% }
            arr[i + 1] = temp;% y4 R9 k) B9 U! E7 f
         }; b1 c6 h' y! ^. J9 R" ?  @
      }0 h% \# `! n3 b! w

3 K4 K) b$ g! x& g2 W+ A1 F
3 n, A3 C. |& P       for (int i = 0; i < arr.length - 1 - 1; i++) {" O! p. f3 S( p  l, o% l5 @+ p( d
         //如果前面的数比后面的数大，则交换, i* O5 t- X1 Y+ t; z# q
         if (arr > arr[i+1]) {
1 ]9 v0 Q. t, ]4 k/ G8 x$ ?5 p             temp = arr;1 p$ [8 N" A+ x4 o7 t$ l- J
            arr = arr[i + 1];0 _- j4 g" d2 z( V2 n, l+ r
            arr[i + 1] = temp;& f0 Y2 o* H# T( Y! N
         }. s' }# M/ t' C0 b2 k
      }" @% T+ F4 v- `- r

+ y  |2 f. F% U6 k4 t8 J
: f9 w- F& G; K/ `" N       for (int i = 0; i < arr.length - 1 - 1 - 1; i++) {
- p% B% ]/ h( N- H) y" T          //如果前面的数比后面的数大，则交换0 H7 U: r* L, ~0 G+ z
         if (arr > arr[i+1]) {
" h3 ?  t) y' R" r  g2 h2 O             temp = arr;  N4 A+ D. ~3 c8 l* i6 U
            arr = arr[i + 1];
, k) e( t# E4 w. n6 |# ?) \, q             arr[i + 1] = temp;- ^2 K  j. X0 ~; m0 O+ V3 [$ U
         }7 x) g& |7 m1 B: i+ y, Y$ K( l
      }
0 a8 H8 U% H. R  O
$ ^$ I7 U% E8 G" R
8 F3 q$ m7 I; S" q7 ?2 W       for (int i = 0; i < arr.length - 1 - 1 -1 - 1; i++) {
; ~9 l0 y$ E" ]# ^5 t          //如果前面的数比后面的数大，则交换
# s  L" P. v! V3 m3 R$ p3 g0 `          if (arr > arr[i+1]) {
+ M7 B0 O: _7 f0 E& T7 |$ C0 b             temp = arr;
            arr = arr[i + 1];& ~( `" }8 B' \: s' J: Z3 k: ^2 f
            arr[i + 1] = temp;& n- V# x0 e( s4 N* S) W$ W
         }4 U8 ]1 S2 U- s( V7 I& ~$ P
      }*// K0 m, `3 w$ l$ }: ^& s3 A

8 Z+ B& t* L% D9 D2 ~' I0 s0 Q. y6 j5 E8 n$ N0 s% d: F( ^
      System.out.println("hello " + Arrays.toString(arr));
' _! D4 a0 C& S/ A       //------------------------------------------------------------------------------------+ t4 W0 Z) \: w7 }
      //根据上面的观察可以知道了撒，可以再用一套循环解决& l. u4 H6 f8 Y; e& _. ?
9 b6 |7 d/ I. G$ N" w' `

6 f+ O* ~* E$ E0 f, y" f3 E+ k" y& F$ B5 N! ~6 `  O

; q& c7 H3 R" l. e7 }# @
, L9 a: A' y- L" F0 k# C2 b) _
8 D. T4 \$ V$ C       //好好理解一下、由此可知，他的时间复杂度为O(n*n)2 K% M" N7 f7 M7 x
      int temp = 0;+ F7 [! ^) e6 x; W+ v* @: k

8 B7 G' I' k+ P- o+ ?4 ~7 \& ?$ A2 _
; Z5 s" k2 e" s! s- ^, r( ]       boolean flag = false;
/ ]$ B% R4 M4 X; Z       for (int j = 0; j < arr.length - 1; j++) {
9 R0 W$ `; B2 {4 K) e          for (int i = 0; i < arr.length - 1 - j; i++) {7 V) a# N) K4 b* j) D' f8 r
            //如果前面的数比后面的数大，则交换
  U4 h2 {, g1 K) `             if (arr > arr[i+1]) {
# l5 u" t8 b( _' Y                   flag = true;//在这里把flag值为true% r- F  c9 j# H1 \! g
                  temp = arr;4 S6 H: I" r7 J
                  arr = arr[i + 1];
& S* ?% Q$ X/ G8 }0 K6 |: F2 B) t                   arr[i + 1] = temp;) U9 j7 n/ _6 V9 b
            }
! {* o$ J9 ^2 ]* I" J: Z$ J          }
5 Q+ \. I6 D1 b" w& Y' y          //在内部循环的时候进行查询
2 _8 D, a8 z4 w! T8 V          if (!flag) {//说明在第一趟排序过程中一次交换都没有发生。1 g2 ]6 w! E3 W- ~
            break;
: b- c& \. x; y; G7 a+ m* U          } else {" e* N* ?: V, e" n
            flag = false;//没有这个就是执行一遍就没了，要让他进行下次继续2 I7 u/ ^2 c" K3 @
         }
8 b" m; N0 K: Y7 N4 y+ ~5 K) g       }
! g% t: B! \& ^: l8 k) i3 P( }! Y) a. K) B% b8 O
' A( r9 z. q5 Q3 j
      System.out.println("world " + Arrays.toString(arr));
) [7 W4 `, F$ Z: ^& b }
0 _6 ~2 M$ Q8 ?}
& j5 y% z2 j! Z* f3 a4 |四、将上面的代码封装为一个方法
4 t" R( q6 b/ C# mpublic class BubbleSort {
. L/ b2 t2 s! ?& X6 z2 K0 } public static void main(String[] args) {
9 s# W+ U$ b  ~5 b1 b6 f       int[] arr = {3,9,-1,10,-2};
) Z" b% N. I6 j& l+ B9 z9 w- J5 U8 C
. n& n3 u3 @+ z' P1 J' W0 ~
0 P2 i( g; b4 q5 ^       bubbleSort(arr);
* G$ |1 P: K; H8 M/ m. y- l       System.out.println("world " + Arrays.toString(arr));
, G' Y+ g3 {9 K4 _7 `& I }: x1 E( j" b% t

% c1 q! m6 h' ^6 F" X' b' i, t+ P' M, V4 _, N
public static void bubbleSort(int[] arr) {9 G' S: y- J; V- N% M# H
      //好好理解一下、由此可知，他的时间复杂度为O(n*n)
+ L+ s5 P) R" u: y) y# U/ L; }       int temp = 0;2 g+ X7 F( ~1 u

) _6 h+ l7 ~* e1 {6 v6 ~
* S! {" g) O* {& y9 ~       boolean flag = false;
2 z3 b" P6 ?- D( H) N* ~       for (int j = 0; j < arr.length - 1; j++) {4 C8 Z% c( P" J; x  W
         for (int i = 0; i < arr.length - 1 - j; i++) {
- |9 _8 `8 |4 F8 i8 r9 n' W" q             //如果前面的数比后面的数大，则交换
- q0 L* ?8 O& d& `2 h6 D9 J6 c             if (arr > arr[i+1]) {
4 [( `7 W& d: h8 K                   flag = true;//在这里把flag值为true" A7 H$ E( j7 G0 W$ n
                  temp = arr;1 O3 f! T9 u6 t/ d( e' ]5 \
                  arr = arr[i + 1];% o4 i) G3 q6 v
                  arr[i + 1] = temp;
, N  ]/ a0 q0 o1 ^1 M             }
+ t* B+ c8 t% v          }/ f9 t' W( ~: o$ o: J2 L5 {+ f
         //在内部循环的时候进行查询9 a9 d$ G' N1 J& h& \" }& C
         if (!flag) {//说明在第一趟排序过程中一次交换都没有发生。& p% G/ i+ X5 z( ^$ i
            break;
; Q! |: \/ ~+ V2 r( `, Y4 q$ E          } else {. ~2 a, Q0 @) d5 M
            flag = false;//没有这个就是执行一遍就没了，要让他进行下次继续- e" s) x  n7 n
         }
2 I, o- O- x7 z: M6 s  b( N4 [       }
! s5 y1 L( Z. M- e' \9 U }) R5 J% |& _* {) ~) N
}
/ h8 i- C# k4 u8 F# S五、测试一下冒泡排序的时间复杂度
1、代码是实现
import java.text.SimpleDateFormat;
) L5 F4 [' z8 }( C: F$ T" Simport java.util.Arrays;3 S$ Q* }1 N, {
import java.util.Date;
) o: E9 V* m! a3 Z2 G4 B; s2 {$ x* l* y) P* y* ^/ P1 K

; G6 a9 f5 L; A& f$ B& ^public class BubbleSort {4 B: a  h  l1 Z$ d8 s9 b
public static void main(String[] args) {; g) g- \9 d1 B5 y
      //1、创建80000个数据来测试一下我们的性能
3 J/ L/ G1 b; e9 a       int[] arr = new int[80000];
/ e. n; E( z$ ^2 N" k       for (int i = 0; i < 80000; i++) {) D7 b+ [+ Y0 U+ ^: p" H8 B; Q1 u
         arr = (int)(Math.random()*80000);//生成0到80000的数
4 Z/ O' h3 i8 i: G       }; z; a; k: b9 c+ g5 B, `
      //2、输出时间
: y, A0 g  u, d# z$ E       Date date1 = new Date();
( O) m. C! s* M4 E! H       SimpleDateFormat simpleDateFormat = new SimpleDateFormat("yyyy-mm-dd HH:mm:ss");//格式化/ I! U, ?$ f2 A2 N7 e
      String date1Str = simpleDateFormat.format(date1);& T9 q7 V: x& y% W4 U
      System.out.println("排序前的时间" + date1Str);
5 |2 }4 u4 z) X7 K# a1 Y/ o8 U# L, ~       bubbleSort(arr);$ g1 ~/ Y4 o; ^. t! E* ?" T
      Date date2 = new Date();
* }. y& l* U7 L2 R1 l! O1 i1 W       String date2Str = simpleDateFormat.format(date2);+ r% p( M( P4 ~% g5 a% t
      System.out.println("排序后的时间" + date2Str);! N4 y* W- s  _/ s
1 H5 R0 u7 C7 x! q  X4 F7 c

2 t# w! k& W$ R2 s% d8 j( u7 j$ O( \: m- `6 i5 @- G

5 a& t, ~& ^) P8 \9 E/ F, s }
, z" [! g. _  F, N, [
1 i$ Z9 K( ~2 A' ?: P0 Z7 _% M8 |( R9 @) F2 M/ I2 G- `0 T0 X
public static void bubbleSort(int[] arr) {
9 T9 P, _# a3 q1 {- c, q       //好好理解一下、由此可知，他的时间复杂度为O(n*n)! B* R/ ~/ \' p) s. z
      int temp = 0;: r; ?: \7 \7 A) R. g
+ B. G4 o, F, ^! e  x- l
, P; L+ C& e3 r# a, N
      boolean flag = false;& E! }+ N( i1 S! ?
      for (int j = 0; j < arr.length - 1; j++) {" X8 `/ z# z3 y' d) Y
         for (int i = 0; i < arr.length - 1 - j; i++) {
# N) j9 j. [5 q" B2 E; c* Q             //如果前面的数比后面的数大，则交换% h1 P1 M. y. Y' o6 S
            if (arr > arr[i+1]) {' o  V3 J# ]. i* n
                  flag = true;//在这里把flag值为true
+ [' J& G4 t- n. t5 _                   temp = arr;+ w$ M' a! j; N
                  arr = arr[i + 1];# v2 T9 Z/ ^% X+ o$ T; x
                  arr[i + 1] = temp;  I  S8 \! e- e
            }
5 \& a, ~% c1 N4 q$ q          }
1 ^8 [) A8 }! B; g5 s; f          //在内部循环的时候进行查询$ ~: m, l/ D* C! m
         if (!flag) {//说明在第一趟排序过程中一次交换都没有发生。3 I8 n3 J% x% G5 E4 r
            break;
+ F  j5 L: V  z+ _5 Y. z/ b          } else {4 W; k9 J2 j: {/ \
            flag = false;//没有这个就是执行一遍就没了，要让他进行下次继续
# h1 ]: j1 j5 ?6 \: w! v' W          }8 w7 s5 l" q+ n0 m
      }
, j5 G! ^7 N' n% i# |+ r }
2 i7 E1 h" g1 M! t' j( h}9 p( J3 E7 i* Q

# v  O. S0 G6 f& o) c0 a- k# h% j6 V$ `( B) M3 c
8 v. [. |2 D# ^
2、效果3 I3 I9 K8 j. `( a9 W; B% F7 d
; D1 v# G' l1 [
: m; V( ^" W6 H' T4 e- H1 S) _
6 o! n8 O6 v/ _" F" p( C# c3 U

. |5 i; w9 _6 m4 v$ W- q) ~4 M+ w2 p6 K: \- i* b8 b7 O/ j( q