查看: 3505|回复: 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]) {0 z8 F8 _2 k. H& T# U3 q
      //             temp = arr;
6 b8 P( l* l4 l2 w- A$ ^$ j       //             arr = arr[i + 1];
' |% b+ s. I8 b  y0 F8 e; e0 I: t       //             arr[i + 1] = temp;$ _2 R; L! C; }0 r1 n' N' [
      //          }/ M" a  e  I% p7 w) p9 m5 B
      //       }1 w) F) Z+ L! J  T0 }* w! E! N$ k
      //2、第二糖就是把倒数第二大的排到倒数第二位5 X: o$ v; Z7 G7 h$ P
      //  for (int i = 0; i < arr.length - 1 - 1; i++) {! P0 t- o, P2 Z8 _4 M
      //          //如果前面的数比后面的数大，则交换8 p1 ~2 G7 o  |6 M  B/ ]
      //          if (arr > arr[i+1]) {
; M4 b( x, I' n: N- n. l       //             temp = arr;
, K# H& D! }+ e       //             arr = arr[i + 1];: A5 o' C: f' ^6 K4 }( J
      //             arr[i + 1] = temp;7 ?  P' H' t' [5 y! T( o
      //          }% w; n& ]+ B# o7 V' x$ R
      //       }/ O& Z" j1 h% T& _3 ]
      //3、第三糖排序，以此内推2 x9 j& h4 p/ ]+ V4 O6 }" ^, F& U
      //for (int i = 0; i < arr.length - 1 - 1 - 1; i++) {
      //          //如果前面的数比后面的数大，则交换
0 \1 h: y- U5 D8 @       //          if (arr > arr[i+1]) {7 p8 W* z; L9 j3 b
      //             temp = arr;
  K  W: r' z' D       //             arr = arr[i + 1];
8 }! X- k0 D' w( Q       //             arr[i + 1] = temp;
# E4 d" E# ]) m$ u) o- e: D% {       //          }
3 D- v4 o+ m- p6 |7 i& `" s       //       }
2 E0 Y6 M. l( F4 c  s' {       //4、第四次排序，以此内推
7 B( l3 j+ u5 }  X- a, R( _; X       //for (int i = 0; i < arr.length - 1 - 1 - 1 - 1 i++) {
1 K7 `6 ?- {9 _" M; S7 t  ^       //          //如果前面的数比后面的数大，则交换
( N, m( O/ R4 m! N       //          if (arr > arr[i+1]) {
2 E( o$ T5 P6 D8 O, U- V# t       //             temp = arr;; V( ]$ r2 w3 A3 r" m1 y2 d
      //             arr = arr[i + 1];
, A2 P, T) A$ Y% m       //             arr[i + 1] = temp;: |4 u" S- O- F4 g- o
      //          }) }7 u  w3 m+ r
      //       }
* O/ z5 a6 C! \* g/ N       int temp = 0;//零时变量，用来将最大的数值排在最后+ h8 `- y2 n2 W: o" r
      for (int i = 0; i < arr.length - 1; i++) {
/ K# W& J8 L" Q* d( S          //如果前面的数比后面的数大，则交换
1 I- p8 }7 y. q4 p          if (arr > arr[i+1]) {
* h& e# [; v! o" X! `             temp = arr;
0 g" \/ @0 H9 M% J$ n, I" n. b             arr = arr[i + 1];
* S7 R! D7 y7 M$ D             arr[i + 1] = temp;/ W3 y4 `7 n7 B0 f6 D7 N  x, `
         }
/ ?) u; ~$ ?" E  e! E       }2 E/ ^: `; N! g( I2 R2 _
# C" E' C' U- h! L1 o: y
9 ]# ]2 P4 C5 Y; M/ {
      for (int i = 0; i < arr.length - 1 - 1; i++) {
  ]: c# C* n9 X+ I          //如果前面的数比后面的数大，则交换
; k0 ]0 h9 M& x" Y9 k4 w3 T# F          if (arr > arr[i+1]) {( F; O/ R! `, X; t! E
            temp = arr;
3 u5 W) ]+ M8 A) w. c             arr = arr[i + 1];' q" u3 J* B2 ]+ S, J) H
            arr[i + 1] = temp;
0 p( g! ?$ H9 _& E' D" U( c) [" C1 ]          }% Y$ A9 F6 r$ a+ E! O- R
      }
7 j& ]! V% \6 r7 {2 s& L
3 p6 F/ J( x; p" U; O2 K# M3 R: A* m+ R' N
      for (int i = 0; i < arr.length - 1 - 1 - 1; i++) {
! Z, S+ l0 W$ ]9 a- J) x" G          //如果前面的数比后面的数大，则交换' |( I5 ]; [* b2 ~& R& k! R1 B5 u
         if (arr > arr[i+1]) {1 Y* c8 i4 y4 j
            temp = arr;0 p- ]2 l' `, E
            arr = arr[i + 1];9 o/ U) s) Q* Q" h6 h1 J. M
            arr[i + 1] = temp;
- K! i/ @$ P7 u& h6 c          }. @6 J, U. y( M1 `
      }
( n3 C) x2 o. D& F- J) d) f6 y+ O$ T# r% a" c9 }

: m' P/ ?# u& Q% k* Q       for (int i = 0; i < arr.length - 1 - 1 -1 - 1; i++) {
! s9 Z9 y( s6 M5 q7 [          //如果前面的数比后面的数大，则交换
# h$ N- f$ c) j3 |, C          if (arr > arr[i+1]) {
  C3 t. x3 k8 C             temp = arr;: m2 z( V  W7 ~) A, j; `
            arr = arr[i + 1];# L; `& s5 ]' e; q
            arr[i + 1] = temp;7 m" v" a) Y$ Q/ Q7 S, j
         }6 R4 m" q2 S$ \: b2 N& |. S- A
      }
- n3 N9 P/ e1 T; ?
: M4 y( `9 @: G2 a0 Q+ J/ `2 h9 U4 z, P- e. K% Q( {
      System.out.println("hello " + Arrays.toString(arr));9 L% D. E& H% l: j3 ?1 @2 [
      //------------------------------------------------------------------------------------' p7 w5 P% Z$ j; Z5 }& v' _- t
      //根据上面的观察可以知道了撒，可以再用一套循环解决9 j9 Q6 P7 O; U0 e
4 t3 F3 \' F0 e) T# K% ^0 ~( ], v

+ J, X: |& z+ @8 d+ G# M& p- {& u

- m) v3 X) B5 o4 C! v2 q$ ?       //好好理解一下、由此可知，他的时间复杂度为O(n*n)
7 E3 ~; @; p- d& x8 o% N7 Y       for (int j = 0; j < arr.length - 1; j++) {
# f' p' K* b) M' Y          for (int i = 0; i < arr.length - 1 - j; i++) {$ {5 e) B* z3 U' I2 j/ z0 x
            //如果前面的数比后面的数大，则交换( v5 p  Z1 O( f6 [6 E4 a
            if (arr > arr[i+1]) {8 P$ l; z5 ~2 L( W( m9 R0 A
                  temp = arr;8 Y( |2 e5 i2 ]! T5 l
                  arr = arr[i + 1];# a: a8 L6 m# b0 O1 v
                  arr[i + 1] = temp;
) D+ W! E+ t! k* w! ^9 [: f             }
: _0 P2 k$ F+ M4 V# G! d! C% Q7 [          }% ]+ F( A  C5 _) y. l& R1 h5 V
      }
. Q1 J$ @- e4 I0 R }
: }, v* |* n! A. F+ w, r}
9 {1 D, d- W0 J& z5 b三、冒泡排序的优化
1、思路) A0 m, K0 t) c  M! @* d( m5 N
如果我们发现在某一糖过程中，没有进行一次交换，提前终止
) Y! Z4 g& A* {! B8 x8 q+ t3 Y2、代码实现
package cn.mldn;3 g6 k' [8 T" b6 p2 z  w+ ]' q

, H0 |0 f9 t" E7 o/ ?1 x. \8 S5 K" `
import java.util.Arrays;
- B5 G7 c3 ~& ~8 U- ]7 x
% Q$ Z' t2 V* h1 R  z9 X7 V* d$ w+ E- G: l7 |
public class BubbleSort {% B) ?& V) i( d' E5 ~& I" a, Q
public static void main(String[] args) {. }. E. i) O4 w7 U
      int[] arr = {3,9,-1,10,-2};
- B& Z5 a6 R5 Z- _& w' Q5 _# h       //大致过程( I. s5 Y' o7 E! V% {& G
      //1、第一步就是第一轮排序得到最大值于最后
4 e/ H, T1 |7 O9 g( t       //  for (int i = 0; i < arr.length - ; i++) {  x6 S: M% X6 ^
      //          //如果前面的数比后面的数大，则交换, a( _7 p0 l) R0 a4 n4 d
      //          if (arr > arr[i+1]) {
- G* o# r$ P+ n2 l       //             temp = arr;
9 p! r/ w/ V2 C9 V7 Y- m       //             arr = arr[i + 1];
4 h9 e( c0 m( K4 E       //             arr[i + 1] = temp;
; _% K9 ]9 A1 Z1 @0 o" p/ M       //          }
; ]8 N3 d# P+ t8 D9 c       //       }7 j. ^) K. t6 r- ]% W3 G9 [- S
      //2、第二糖就是把倒数第二大的排到倒数第二位0 t( _% W, r& T0 T# j
      //  for (int i = 0; i < arr.length - 1 - 1; i++) {$ _) x% d/ J! q* w' I0 X. `+ Z' C
      //          //如果前面的数比后面的数大，则交换. a9 _/ U, e; N, C
      //          if (arr > arr[i+1]) {; F% g* X( r$ W& j4 Q
      //             temp = arr;
, z# v% u  i9 C& E$ w" D& _       //             arr = arr[i + 1];
( W. J9 J1 }1 i  Y( A* p       //             arr[i + 1] = temp;& l$ _5 l" o( C# ?
      //          }
5 b$ x4 D% d' @. F8 Z) [* F4 Z& c3 M       //       }
5 h% U3 Y6 m5 \       //3、第三糖排序，以此内推
, n6 K# Z1 Q7 R) r8 r" g8 ~       //for (int i = 0; i < arr.length - 1 - 1 - 1; i++) {
% N0 l) _; ^( ]% c' Y! h# f       //          //如果前面的数比后面的数大，则交换5 U  ^/ P+ G7 y# N1 g) f
      //          if (arr > arr[i+1]) {
2 }. k( @3 ^7 [" k0 S- O       //             temp = arr;
* j; S3 U6 h: P( P4 x       //             arr = arr[i + 1];6 ~) z# d8 S& s4 C. U
      //             arr[i + 1] = temp;
2 I; H$ f' p- C3 l: a* x       //          }
$ W8 W$ |! f$ I( x' }7 S7 j: P! O! U       //       }
0 {+ |# n0 ^& S8 H       //4、第四次排序，以此内推1 c  G9 `  K- ?; c
      //for (int i = 0; i < arr.length - 1 - 1 - 1 - 1 i++) {9 G. d8 u& W, _$ k
      //          //如果前面的数比后面的数大，则交换
* V% `# [& n# t: c- j; a) s% T4 j       //          if (arr > arr[i+1]) {
, H: d3 m- ?  l+ s. G2 I- B       //             temp = arr;
. r: k5 `- Y' U+ {       //             arr = arr[i + 1];8 v  ~% ~3 s6 I3 L
      //             arr[i + 1] = temp;" n" [1 n" k# P/ s1 R' T
      //          }- j, z! x0 `6 [
      //       }/ |7 n3 X' u5 s
      /*int temp = 0;//零时变量，用来将最大的数值排在最后
7 B$ D0 F9 A$ h) \       for (int i = 0; i < arr.length - 1; i++) {
6 N$ v! }3 L+ {/ s          //如果前面的数比后面的数大，则交换6 b8 a8 ]6 e! _  ~3 m
         if (arr > arr[i+1]) {2 ~- T/ g8 p3 Y2 d
            temp = arr;
- q8 Y+ D# |6 E             arr = arr[i + 1];
8 X& p: Q0 C) e; A5 B, z             arr[i + 1] = temp;
- C( G: k6 a# w! I          }
# N/ j- g  h2 Y+ \7 V& @. {6 m       }
! C. V) d5 `' g6 x/ F) O. H2 x9 G) m/ c) M# h5 i( k( V

5 K) |/ @# C; [( _& h% J       for (int i = 0; i < arr.length - 1 - 1; i++) {# T) }, Z/ z. P
         //如果前面的数比后面的数大，则交换
+ G* @$ @6 G7 v4 J) S2 o          if (arr > arr[i+1]) {
# k" a3 ?9 t2 d! S' A             temp = arr;
! H& g+ q# D8 }/ j             arr = arr[i + 1];
. E5 |( o& Y% P/ P: p5 q             arr[i + 1] = temp;
2 R$ @9 r$ `/ p$ U9 k  h% [! c          }
- Y6 P$ ?7 _; Z' `: M0 N1 K       }, P6 k6 N+ a& N7 V. D. H
* }3 e8 G; L* t# T! N1 Y; p  m
: g3 r; T5 `0 k7 e+ F" ?
      for (int i = 0; i < arr.length - 1 - 1 - 1; i++) {8 a9 I6 h( `! H7 \5 Q
         //如果前面的数比后面的数大，则交换% z3 f$ l2 x3 @2 v- Y) P
         if (arr > arr[i+1]) {
! T9 z3 Y* ?0 r& _$ q$ g8 t" B( o             temp = arr;  a; a3 N, X# q1 t( h7 j/ o( Y+ m
            arr = arr[i + 1];* }! E4 y( b$ X" Q+ Y
            arr[i + 1] = temp;, L1 p1 N" I, j' g$ u; g
         }9 k2 ~& b( d8 s6 B+ Y8 _# Q
      }
& F# @  I4 p: T) V1 r8 D5 N2 A
0 }1 s; R' J# a. {5 ~/ O5 l! e
5 {; m% q( `) q0 G, `: x2 u: K$ Z       for (int i = 0; i < arr.length - 1 - 1 -1 - 1; i++) {7 l0 x$ S6 n+ ~/ b7 e4 n1 ?
         //如果前面的数比后面的数大，则交换- ?! |  a3 U7 y& W7 _% B! W
         if (arr > arr[i+1]) {
. x2 T  I8 I2 w& ^* g             temp = arr;
3 T9 c7 j3 U6 T% |  l! d             arr = arr[i + 1];, _% e( G6 d. o5 i$ S' T
            arr[i + 1] = temp;) C% ?' ^" Z5 W" n8 D+ ?3 T
         }
5 P- ~! N( v/ Z  i4 H* \       }*/
# s) j- m+ a( x3 g+ K3 `8 b! y6 X# m  R- i8 D7 X! V
' o7 m8 d+ L  S+ c: z# ?7 ~( F8 O
      System.out.println("hello " + Arrays.toString(arr));
& o( ]" i) R/ ^  g       //------------------------------------------------------------------------------------: [( j' e$ e! S. T, s2 u( `- m
      //根据上面的观察可以知道了撒，可以再用一套循环解决
& b$ V, Q' X! |1 M* \7 E; j7 h
% V4 C/ k, }+ |
9 C- w4 t: E6 ?5 Y% M: |( s" r) ~8 i! g: R4 @- L6 x% K* W

* L* w5 I5 H$ L1 A5 A
* j+ q+ Q8 y$ p/ ~3 w
$ m/ K5 F4 P/ Y. Z       //好好理解一下、由此可知，他的时间复杂度为O(n*n)6 |* R. N5 D# i1 E/ X2 I4 G
      int temp = 0;
) D( D% p3 t+ U- W. j; u0 S' m: O5 Q
. Y- E: l. F, B- R% @) r, s2 j
      boolean flag = false;
( r7 e9 c+ N7 W; q$ Y! e. {& F' `       for (int j = 0; j < arr.length - 1; j++) {3 F3 W% \0 Z. \* R$ H
         for (int i = 0; i < arr.length - 1 - j; i++) {
8 y# X" h3 P( _6 `* N) `) @             //如果前面的数比后面的数大，则交换
( d) I9 G! S' t) K3 p- a( [             if (arr > arr[i+1]) {
8 w8 o$ I5 r/ x- ?+ O                   flag = true;//在这里把flag值为true
) x' G7 ?0 t& a% N7 {8 v4 }% @                   temp = arr;9 q' R' r6 C4 p. Z! l3 u
                  arr = arr[i + 1];1 r* f3 [7 M" p9 h8 e$ Z- ^% d
                  arr[i + 1] = temp;( R* r) C; }3 X0 R6 P( Y% [1 ~/ L
            }
& S* C* v6 r* f  t8 Q, e          }3 |0 v$ K4 _& p3 h  p9 F
         //在内部循环的时候进行查询/ R# m, o+ R' O: W4 M
         if (!flag) {//说明在第一趟排序过程中一次交换都没有发生。
* r& a  s+ z  C3 G% M* D             break;
2 `1 I3 z4 X% r$ i- P+ S9 d8 c          } else {
) ?( K6 a6 E, a             flag = false;//没有这个就是执行一遍就没了，要让他进行下次继续, ^( ^( b- J2 _
         }
3 }* i5 N0 k' N8 Y1 ?       }
5 \3 j- B( k7 A" I* T2 P$ V7 \8 z, b

6 p6 L4 T8 J8 t; ^2 z1 H       System.out.println("world " + Arrays.toString(arr));( l4 _. n0 K- j& h
}
  p- V2 d9 t6 l. U* Y& ~- r}
+ s- r+ |, [0 g% d4 f四、将上面的代码封装为一个方法4 o, y( p0 O9 y& j4 [2 T
public class BubbleSort {/ f: s, e3 C: U7 Y3 Y
public static void main(String[] args) {, [& T+ E/ }* Y7 t
      int[] arr = {3,9,-1,10,-2};
$ R- H) |' I: H& m4 G3 @0 [4 n0 V* {$ U9 P- n
) P4 q7 \; ]+ L) Q7 Q+ z
      bubbleSort(arr);
" Q8 R" I, g3 e$ P; c" t& R" c% w       System.out.println("world " + Arrays.toString(arr));
; v6 p9 q) V- v. S$ g4 Q, W1 t }
5 j2 ?: ^% Q; `# X8 ]. r5 c% w* ?/ z6 c  w, F: ]" A

" |) @: E* t: P& l/ |( {( y public static void bubbleSort(int[] arr) {
  Y/ w2 Z4 i* e) p; _% S       //好好理解一下、由此可知，他的时间复杂度为O(n*n)
& H& R7 T" j  X+ f3 U8 e' ?$ ?       int temp = 0;4 F  G; C, A5 d

1 d1 ?8 I7 S  ~7 f: Q( a3 l& Y  y  s5 g
      boolean flag = false;
' _! n" \; d4 o$ q! c1 J       for (int j = 0; j < arr.length - 1; j++) {! J4 l4 r+ J: [0 y, Z; q) P
         for (int i = 0; i < arr.length - 1 - j; i++) {) b1 P2 h, y2 k1 @
            //如果前面的数比后面的数大，则交换6 @' p8 E" t* N1 X. w
            if (arr > arr[i+1]) {+ P5 N7 p' H+ \( N
                  flag = true;//在这里把flag值为true
! g0 H5 `" d! }+ q                   temp = arr;
5 O+ \0 r* V( r* V                   arr = arr[i + 1];
5 k. o1 T( C, O9 S$ O! E/ t                   arr[i + 1] = temp;% i, k7 Q4 r  J5 }6 ?4 r' o
            }
2 X$ |; w0 I2 Z          }, D7 j5 r  @+ M/ @( i5 V4 y
         //在内部循环的时候进行查询4 L' {2 \- e5 s6 R8 m* x# X2 k  k
         if (!flag) {//说明在第一趟排序过程中一次交换都没有发生。
. u8 @# M* Y% J2 v6 B# v             break;
  ~0 b" @: r/ ~5 o+ a          } else {: b! U; B+ i2 a& t9 W: m( K0 t; y
            flag = false;//没有这个就是执行一遍就没了，要让他进行下次继续. \" D7 n" F: }% Y' [7 {# J1 D# _
         }# t4 x' @5 b2 j- h
      }6 T6 v+ W: [! b, p
}
! u6 q5 d9 W  W. |+ T}$ l7 ~" b2 X+ @
五、测试一下冒泡排序的时间复杂度
1、代码是实现
import java.text.SimpleDateFormat;
( K& l! R8 ~) f- I: I! ~import java.util.Arrays;; C8 F: L! L! h  h
import java.util.Date;
6 k# K6 a" H) s6 n$ X# z3 `6 }4 m
- ]  s/ N* s$ _) {& x( p
public class BubbleSort {
( R7 ^4 F, |- B# O% A2 F' ~ public static void main(String[] args) {$ d) F6 t( ^% Z
      //1、创建80000个数据来测试一下我们的性能$ V' g$ q) M2 o, I+ @1 m
      int[] arr = new int[80000];! r' J; D' w' C1 t% i& g! I: T
      for (int i = 0; i < 80000; i++) {
3 X% h5 n" U# {+ U          arr = (int)(Math.random()*80000);//生成0到80000的数: l. @0 i0 x9 R
      }
9 B. Q" J" a, s' N! h* o       //2、输出时间* p' i$ ^; }+ u; `4 Z5 I5 \7 l
      Date date1 = new Date();6 Z2 x/ w& l! w( |1 ]* H( Z* i- k
      SimpleDateFormat simpleDateFormat = new SimpleDateFormat("yyyy-mm-dd HH:mm:ss");//格式化; K1 N( Q4 }: }/ b9 R
      String date1Str = simpleDateFormat.format(date1);
( ]2 d$ h& }3 T4 y9 }' F       System.out.println("排序前的时间" + date1Str);
$ h& s- c: {# X5 d6 N' V       bubbleSort(arr);" I" M* C8 D/ ]
      Date date2 = new Date();
: ^( P: Z0 B$ L/ u       String date2Str = simpleDateFormat.format(date2);2 B7 `5 k2 K  Q( z8 a
      System.out.println("排序后的时间" + date2Str);
$ l- ]7 n$ K/ W. K$ d; m
; @% r: H/ {# |7 w; @
; l; f1 M& E) O7 |1 V: ?$ S% V* ^& R1 q, I6 F# t0 R/ ?/ D

" L- G0 h9 }7 E( R8 R1 d }
5 n1 P1 o4 X9 Y, Y- F+ D8 o: `6 @8 l& Y0 L" X7 K; P
/ \# N3 V  C1 H7 {/ T
public static void bubbleSort(int[] arr) {! ]$ Z( H+ e( E5 H% [1 G
      //好好理解一下、由此可知，他的时间复杂度为O(n*n)- k# H7 O/ k& h, ]
      int temp = 0;  K3 S1 E/ J, Z
1 Y  e6 W4 x7 T
4 U0 c& j& r1 e
      boolean flag = false;: F* \/ P: D+ v
      for (int j = 0; j < arr.length - 1; j++) {
) b/ _9 {9 N7 e1 R; J; d6 K          for (int i = 0; i < arr.length - 1 - j; i++) {: f. t7 z8 r# a+ E+ x5 r6 c
            //如果前面的数比后面的数大，则交换
# \; r5 g/ `1 X8 h4 B             if (arr > arr[i+1]) {& J# I# M2 \6 T0 @) g5 C4 l/ k5 Y
                  flag = true;//在这里把flag值为true; i4 Q0 S. t, O  y
                  temp = arr;3 {( D7 C; k! {. L! A% A
                  arr = arr[i + 1];2 r/ Q/ }2 |4 G( s
                  arr[i + 1] = temp;
& h2 G: q, b: `5 j             }
' e3 ?* p; B7 u% |9 a          }
/ Q1 s, ?7 F+ I& A! _% @          //在内部循环的时候进行查询3 A# x( w1 c5 ~$ Q3 `8 n& V" t8 B; D
         if (!flag) {//说明在第一趟排序过程中一次交换都没有发生。: V0 L/ [! E! j# O0 W
            break;- U5 P5 L. R5 t7 A% c. [8 V
         } else {
& L) r( I! p. P9 f8 H+ |# m! M             flag = false;//没有这个就是执行一遍就没了，要让他进行下次继续+ D' B& }* H5 g  k( q9 ?
         }/ H; W* O/ \& g5 J
      }; _! I; l( @  k4 K3 @" B( \
}+ c& {3 f( U! r7 M# c& C
}
$ g5 \5 q. n7 m; J4 q* s4 e$ h6 P* h6 f# a- U

/ X; }2 e, q- U& S7 F) ^3 [  K3 U9 p9 K% K; p% A
2、效果4 B* a* a; f' L% q/ _& C

# K* K' i) l8 ^4 |* I3 m1 Z
4 m9 ^& i: T% [+ ^- _4 D
8 b+ h/ r  H% x2 T- D* r8 a, R7 [7 i' u% P. |( [: D
6 v( a/ [; B8 J0 `3 s7 S