查看: 3487|回复: 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]) {
+ M$ j" R5 m* T       //             temp = arr;# A! K7 r1 d2 F/ j5 R0 E7 r
      //             arr = arr[i + 1];$ q8 R- f; t- j: a; W
      //             arr[i + 1] = temp;
: f5 G5 v  K0 \5 G* v       //          }
- `, B& e! _$ T5 k4 B) T# L       //       }
0 f% |! Z7 u$ \       //2、第二糖就是把倒数第二大的排到倒数第二位* S" S- A' h, J
      //  for (int i = 0; i < arr.length - 1 - 1; i++) {
) S* m8 n  y& z       //          //如果前面的数比后面的数大，则交换# A. d' Q2 g( D6 E* U* M
      //          if (arr > arr[i+1]) {
# d) c& @5 h+ X7 P5 h       //             temp = arr;) P2 o( R. R0 y- d/ W  N
      //             arr = arr[i + 1];
7 {+ S% ~1 r* j/ K       //             arr[i + 1] = temp;
2 }, y6 q- q* g2 C       //          }5 b- _& U1 y/ b! }6 [3 e) M7 G
      //       }
; x; d: M& K  J  L$ l. r       //3、第三糖排序，以此内推0 b, b  S2 L( N( |
      //for (int i = 0; i < arr.length - 1 - 1 - 1; i++) {) o7 I+ E, r* M) |* Y0 _( Q% y
      //          //如果前面的数比后面的数大，则交换- j% C, Q$ J2 ]& m) P
      //          if (arr > arr[i+1]) {) L" d) {$ @/ Q6 N
      //             temp = arr;; p; q) _. J8 R5 N! F& Y- \; ~
      //             arr = arr[i + 1];& I( t0 N% O6 v2 P3 W2 b* N/ o' Z
      //             arr[i + 1] = temp;
2 z0 Z. J& K& E' X! c- w       //          }
- [: l: Y; t. }$ R8 E       //       }
' [8 T3 B  M4 \  P1 K3 K* x       //4、第四次排序，以此内推- q4 N- t3 K1 Z6 s7 `0 Y% v: G* ~
      //for (int i = 0; i < arr.length - 1 - 1 - 1 - 1 i++) {, B; f0 j  M2 M' O) j, g! L
      //          //如果前面的数比后面的数大，则交换
4 G5 T% z. c. x8 y8 T/ x) F7 W2 @       //          if (arr > arr[i+1]) {3 D; ?, ?: S& X, _/ A- y( N
      //             temp = arr;& e: o8 N; `2 g4 j8 }" O
      //             arr = arr[i + 1];
$ m: z5 N& O+ \. c       //             arr[i + 1] = temp;
7 p7 n/ l* K9 w, g2 J       //          }& W9 N+ V+ U) H$ F
      //       }0 y  h0 z" i7 O; f2 v" J
      int temp = 0;//零时变量，用来将最大的数值排在最后% k/ i- o6 C4 ~& |
      for (int i = 0; i < arr.length - 1; i++) {2 B) r3 F9 p. w" Z& N5 T
         //如果前面的数比后面的数大，则交换' G: }2 U. |  |1 N4 u
         if (arr > arr[i+1]) {
! {0 o, @  r/ U; ~! `  ]             temp = arr;
! b$ e) P* H3 Q$ m# K3 R             arr = arr[i + 1];5 p6 _- M, n$ y$ A5 V% k; p" J
            arr[i + 1] = temp;
# [7 d! z3 \+ f' L2 D          }
% N6 z* I( w  y- P- w% F       }
3 O( F# ^& }" t0 K! `, W" a1 u3 C
0 d# n3 i5 B6 L2 ?( L6 X( b
      for (int i = 0; i < arr.length - 1 - 1; i++) {3 @" x* @' |- x( X! i) E
         //如果前面的数比后面的数大，则交换$ T8 ]6 H; O8 K2 O
         if (arr > arr[i+1]) {
, n' A7 o* W2 }6 r1 b& V/ h             temp = arr;
" d( Y" T- m7 c             arr = arr[i + 1];7 \5 o% C: q) y+ o9 Z/ p
            arr[i + 1] = temp;
6 V# I* I) q3 d9 {0 `9 \; B          }
, R# w" n: d; n9 f$ [9 @       }, F& O' G9 A3 n' H% y! V
5 W1 f7 U' N7 F7 d  n, q" X0 F/ B. c

: J/ l' H. Y1 V. w' }4 K       for (int i = 0; i < arr.length - 1 - 1 - 1; i++) {
# b8 R% W3 f1 j4 Y% C% k" d& _9 y  e          //如果前面的数比后面的数大，则交换. f5 h3 E6 U# R$ [! J! Y' U7 D8 O
         if (arr > arr[i+1]) {
0 a/ j4 u' D# z4 K( ]             temp = arr;( s# v9 J# H* q5 Y' T) u3 x: c
            arr = arr[i + 1];- c2 Q$ j  o; V
            arr[i + 1] = temp;
1 W& h8 i; z3 R- E# y          }- T  f* J7 u- p
      }; J' c( M2 ]; D! y4 r$ l
7 C! S1 h/ N* q7 q3 k7 E

8 ^' @: Y7 Q- p8 x* O" d4 Y       for (int i = 0; i < arr.length - 1 - 1 -1 - 1; i++) {
6 e9 x0 U+ W" x8 Y. q0 L          //如果前面的数比后面的数大，则交换4 [( W$ H6 v# a! X) b- u7 v% g) c8 V: e
         if (arr > arr[i+1]) {: k& E6 T" v7 }& j& [
            temp = arr;
' m& O- b2 p* u$ E4 |! p1 a6 W             arr = arr[i + 1];% q' ~8 T# q0 n" b
            arr[i + 1] = temp;  \- t9 Z- D0 F2 a$ l8 j
         }
  C( ^* p! Q9 b/ L- t4 o$ a1 F       }
6 P# d3 ^- I0 f: S1 F( p: v( U' r) N& a# o) ^
; p7 c; l& z- @
      System.out.println("hello " + Arrays.toString(arr));" q. ~; ]! F# F
      //------------------------------------------------------------------------------------
) z/ B2 U% Z4 }) p8 @% b3 G* N0 h       //根据上面的观察可以知道了撒，可以再用一套循环解决
. K. i& r- _( [' E/ g# ~3 }$ U, t/ s+ w

8 \4 i7 P5 o( P- b3 y( R0 q& a+ G% ]5 Q* P- `$ `1 ~% n9 N

, b' \. A% H) f: x       //好好理解一下、由此可知，他的时间复杂度为O(n*n), @' n" h5 n' E2 Q/ y% a2 H# v, [
      for (int j = 0; j < arr.length - 1; j++) {0 S8 T7 F# l7 g8 I1 {, M0 Y- D
         for (int i = 0; i < arr.length - 1 - j; i++) {
; X# Y' L  s& D/ H' h             //如果前面的数比后面的数大，则交换, H2 D% }: S( t. d6 G) {( q1 X
            if (arr > arr[i+1]) {
( R% e  }* c. h2 B3 P- |) B7 c                   temp = arr;2 E& ]! V5 ]+ p0 X5 F) Z9 c& D
                  arr = arr[i + 1];
# {$ P7 L' b! i                   arr[i + 1] = temp;
* I( ~7 a9 D3 ?) A9 w& Q5 }/ L/ t- f6 Q             }
8 B" e# F" |; s5 _$ ]$ @          }2 h/ y0 C! W: m, S# v6 d: Y; x
      }
2 T& D! _& Z) g, O3 i' f }
, k- ]" s* E3 R8 h, t% W/ |, S. h}8 J, x4 Y. V8 u8 I' x
三、冒泡排序的优化
1、思路; W+ e6 Y3 B# L& R4 [' G3 P+ D
如果我们发现在某一糖过程中，没有进行一次交换，提前终止
, f0 A9 E: K/ R2、代码实现
package cn.mldn;$ f  J. K# d* s" |# W* f" @

7 ?" i# {8 o3 m* G
- v: l/ }) N" gimport java.util.Arrays;& P5 o# n: Z0 l- Q4 ?
2 }' F$ o# W7 A1 S' U

/ H' c9 Y6 l& {& K5 z& J5 a/ {# mpublic class BubbleSort {
4 {% c3 g, g# |2 w! f; h- X public static void main(String[] args) {
9 n0 j3 z: {: ], U       int[] arr = {3,9,-1,10,-2};* I* `& P# I8 O- r  }" j2 X
      //大致过程
7 }& q3 ?6 c  i- p/ |- r3 f0 X       //1、第一步就是第一轮排序得到最大值于最后" r" r( @6 k0 I8 r. B
      //  for (int i = 0; i < arr.length - ; i++) {* O$ i; U' U. B5 u; j; B
      //          //如果前面的数比后面的数大，则交换1 ~6 L; P/ W9 Y# ~5 m- v
      //          if (arr > arr[i+1]) {( J+ T9 V; _' j( c4 w# Q% Y5 Z4 l
      //             temp = arr;( o7 h& b' l6 S% I+ |- v
      //             arr = arr[i + 1];
6 z( L, E: Q# R# G       //             arr[i + 1] = temp;, h% G" L8 [0 E% `
      //          }' ?9 {% ~4 D9 q) K6 P
      //       }
8 u' p3 e5 |1 C) f       //2、第二糖就是把倒数第二大的排到倒数第二位: k% g" V9 O- X! X% W- Q
      //  for (int i = 0; i < arr.length - 1 - 1; i++) {
( p+ @" q7 h+ c. G" B! o       //          //如果前面的数比后面的数大，则交换
* Q, a2 A1 w2 f! ^3 y       //          if (arr > arr[i+1]) {" i* O$ j, G6 J; Z9 x
      //             temp = arr;/ q) u" P8 [5 {& S" {
      //             arr = arr[i + 1];( G3 n8 u5 O- t% L
      //             arr[i + 1] = temp;! p0 X/ q9 k7 I+ Z/ F
      //          }
0 }1 k# `7 N, I0 B- C7 W       //       }7 a# `5 `$ P' M8 ]9 W1 E. M
      //3、第三糖排序，以此内推
# y0 P; m- f. X       //for (int i = 0; i < arr.length - 1 - 1 - 1; i++) {2 l: ]: ?* A% E$ X6 \# A
      //          //如果前面的数比后面的数大，则交换+ X/ a' G# \7 _0 {1 l% a
      //          if (arr > arr[i+1]) {
5 ^( B' B4 V0 l9 z( U- R. i       //             temp = arr;
3 k( C& a5 d& F0 f, ~1 n& |4 `       //             arr = arr[i + 1];: ^* s! E/ f9 A9 L" ?
      //             arr[i + 1] = temp;' j. o' _  ^9 N4 J
      //          }6 b- ^! _2 z4 \# n- Q6 x  f
      //       }
( L0 t: _% Q" \/ W       //4、第四次排序，以此内推
3 T# j- o9 U- b& s; J! j8 N       //for (int i = 0; i < arr.length - 1 - 1 - 1 - 1 i++) {
9 b5 y% c# a; z' @& O! i7 v( r; D       //          //如果前面的数比后面的数大，则交换
* a3 z; ?; v% M7 P8 r0 r       //          if (arr > arr[i+1]) {" E5 i8 g! h5 C7 c5 X1 n% m1 {2 }0 I
      //             temp = arr;; E9 @% x/ e4 T( i! |1 q
      //             arr = arr[i + 1];) N1 u! V4 M, W& J9 i
      //             arr[i + 1] = temp;
& a" _9 G! |7 @0 i* o/ b       //          }
; {. o6 L; I# @* w, s; w6 f+ c6 {       //       }' ^7 o( b6 s3 N4 \" Y
      /*int temp = 0;//零时变量，用来将最大的数值排在最后% ^, r0 b/ e5 U- S8 V2 M$ w
      for (int i = 0; i < arr.length - 1; i++) {
8 m7 i* q7 q& x8 x          //如果前面的数比后面的数大，则交换& w. ]# k! ~8 J7 L# U* B" b, e
         if (arr > arr[i+1]) {
7 @5 K$ W3 A6 y; M9 s             temp = arr;: T0 C! n: J3 K8 k0 y' H
            arr = arr[i + 1];
) K/ p. X0 b- h             arr[i + 1] = temp;
% [  u; e" o' U  Z, w1 X          }9 P, L) [1 e2 @* T# u8 h! U- q
      }
6 c: U  N* v" K+ h, Y/ M5 D  v
! u; G/ K# |7 b! ~% v
% a+ q, L/ N. k8 T3 _/ @       for (int i = 0; i < arr.length - 1 - 1; i++) {0 F% ]: M8 b+ {
         //如果前面的数比后面的数大，则交换: R0 j% q: T# l( _% |( X, u4 J
         if (arr > arr[i+1]) {# k( h8 B+ F$ w$ L# z. ]* n2 |
            temp = arr;
& l/ @* B7 o  a( q% L# L             arr = arr[i + 1];
7 K/ i. c- V" t8 s9 F  y; a! z% M) n             arr[i + 1] = temp;# }, C4 I2 |1 O* o, S' p2 @4 x/ w$ {# x
         }
; s  `6 f# h3 n: |7 [: m. d       }
# F5 J: P1 Y' ^" h" m& d, p: j
& P* K# S) J( I
" h# o* ?' ]4 G# W       for (int i = 0; i < arr.length - 1 - 1 - 1; i++) {9 q  |3 A+ Q' }/ u& x" U( z
         //如果前面的数比后面的数大，则交换1 T/ m' O; _* ^& V" F6 W
         if (arr > arr[i+1]) {: v0 E) ~" ]& H) g( `" Q
            temp = arr;6 k, `. N* O  g. W6 y, W4 g
            arr = arr[i + 1];
4 ~) y- i, t' F% W: h  Y5 q9 E8 I8 g             arr[i + 1] = temp;
4 E' U, N+ W+ y6 A          }! c/ `6 k2 _. D8 X
      }- c% m4 |$ K; }9 I3 v% R; O

" M; p2 v' K, b5 [* a& c( q7 }* B; o* h- [0 |
      for (int i = 0; i < arr.length - 1 - 1 -1 - 1; i++) {
5 s, X' J5 U7 c) Z" ]" F( B          //如果前面的数比后面的数大，则交换
9 j$ B5 w! @/ _+ ]' o3 L# m          if (arr > arr[i+1]) {
) ^4 N8 t8 J; f. o5 B' j             temp = arr;
9 J4 Q# ^2 i3 H, _             arr = arr[i + 1];
' p" f9 C* Y/ T! i# L6 }/ M             arr[i + 1] = temp;- k( n" z' U- K
         }
. ?. P% h0 `" v$ }! }( Z+ d2 d5 D       }*/
; e2 }; o& f6 m; y
, c6 S# s  Y! \0 f: S" q
) [: ~" J: b' q- Z5 i* C: A2 b       System.out.println("hello " + Arrays.toString(arr));' i) z- b  P" x  ?- U& n: s
      //------------------------------------------------------------------------------------
; Q% e! c8 p5 d& L6 }" h. x' q       //根据上面的观察可以知道了撒，可以再用一套循环解决3 v5 S4 O% y4 g, S
. i* T% G4 I) F4 ?; |3 ^5 r  u% Q- G. Q

. D7 B  x: b  V/ g- C3 e9 u  u1 ~. l/ J; Z5 r7 z+ a: P

' A: j3 B+ N/ t( v# w# ]9 \. v8 Y! U9 k* Z$ n8 |
# M7 t+ Q  D& m# b. ?
      //好好理解一下、由此可知，他的时间复杂度为O(n*n)
" q) U5 O" C2 ]* a& h0 P       int temp = 0;
9 t4 V3 o: @1 G; _/ t
* n, X+ ^5 ?5 x2 f
; a/ i9 X$ U/ x, D: [- D5 B& C) C, A       boolean flag = false;" \# E+ @2 H* V0 j9 `
      for (int j = 0; j < arr.length - 1; j++) {9 r# b& ~, Q( ]2 g0 g! S1 C
         for (int i = 0; i < arr.length - 1 - j; i++) {: z% I3 s9 w$ ~3 r2 v
            //如果前面的数比后面的数大，则交换1 s6 ?/ f1 k& I9 s! I9 K
            if (arr > arr[i+1]) {1 \% C) u2 M: X, x# v0 c
                  flag = true;//在这里把flag值为true
8 `: O) w) A7 _, v                   temp = arr;) u7 I: i' u# O
                  arr = arr[i + 1];
# J( }# p* B0 v' k                   arr[i + 1] = temp;
" R9 @* U2 _0 D% G; w             }" d; v! `1 ?3 f  R
         }0 ~8 J- a/ L& F- Y4 ~
         //在内部循环的时候进行查询/ ?( G6 |/ v. O% v: o6 f8 [& N/ e
         if (!flag) {//说明在第一趟排序过程中一次交换都没有发生。/ c' L. L/ k, z: j4 F  C
            break;5 P) q7 A" |+ Y$ ]- b: m
         } else {
. U0 N+ y) q; E& t: H( j: t3 J3 O             flag = false;//没有这个就是执行一遍就没了，要让他进行下次继续% S! U9 F" i6 F7 A7 k' C
         }
1 C* D% B" [! `) s       }
4 Q  W  P  ?. k# b* V) x4 u. M7 S* ~3 n

  G. `6 r& T/ s0 B1 Y6 R3 b       System.out.println("world " + Arrays.toString(arr));4 U$ u  E1 i  F" F
}
; C2 F. x3 {/ y/ ?' M}
0 ], C3 W  e( K: Y6 z+ i0 z四、将上面的代码封装为一个方法5 J7 f6 v! j* m+ \" D4 Z7 ]: x
public class BubbleSort {6 W7 F: C; _7 ?
public static void main(String[] args) {
- j7 |) s( ^3 r, ?& b$ E9 C       int[] arr = {3,9,-1,10,-2};- z8 p7 q2 p+ d5 H  W
: f+ X0 M7 _* c; Y0 {+ R
' ?$ m3 V* [+ @, X+ s
      bubbleSort(arr);/ M8 g( ~9 T! `$ m  f) |  z1 D
      System.out.println("world " + Arrays.toString(arr));
) X. g/ K" e8 d) V- J! |' a% z6 W }
- v/ s6 f) p2 O% h) J4 H  v( t' T7 E" r+ f

% e4 Z$ Y& g9 F5 C5 N/ } public static void bubbleSort(int[] arr) {
3 W$ T* `3 k9 I/ v5 c, U7 X+ \       //好好理解一下、由此可知，他的时间复杂度为O(n*n)
# r/ O3 D8 y" k' A5 Q       int temp = 0;9 O* D; O& C: u' [7 p* d
1 Z3 y' ~! |: E
, m# O/ h/ X7 B1 K  W; }! h
      boolean flag = false;5 Y6 j7 i% P( P) I: ?0 J% b3 T3 S
      for (int j = 0; j < arr.length - 1; j++) {$ n/ {3 U7 F1 o( h
         for (int i = 0; i < arr.length - 1 - j; i++) {- {' q0 o8 S+ @
            //如果前面的数比后面的数大，则交换
( k  X6 Y2 z$ n             if (arr > arr[i+1]) {
( d- G4 p, f6 U- u4 C                   flag = true;//在这里把flag值为true
0 g" f! s1 c. _8 d7 G2 T                   temp = arr;
; ]" T# D' ?% v& Y) X$ V                   arr = arr[i + 1];) U( o0 t: z- S* z. L/ Z+ w
                  arr[i + 1] = temp;
& v$ _6 x* T8 n             }
" n6 F- ~2 s. y' X$ z          }& G/ r; l& a: m# l5 }
         //在内部循环的时候进行查询4 P; N( }' Z' @& {  L6 X5 c
         if (!flag) {//说明在第一趟排序过程中一次交换都没有发生。( T2 O: m; o, p" r/ T/ J, q
            break;5 k1 X6 y7 U5 b' n& F, T1 Z; d
         } else {
  _7 Y$ p& T" {5 h) v$ k0 r             flag = false;//没有这个就是执行一遍就没了，要让他进行下次继续) \3 V2 D- ~  l: ?7 o* D! T
         }
, P: F! Q: n3 r! e* o, y' ~4 [       }+ r; ]) j9 @6 \9 e+ [0 \# h3 Q6 K* m) k
}
+ `& T3 |+ X( o}  [5 u( i% w% g  A: z: s2 A. r
五、测试一下冒泡排序的时间复杂度
1、代码是实现
import java.text.SimpleDateFormat;
: @: a5 k, b% N# _import java.util.Arrays;
% K: W: {$ U" ], jimport java.util.Date;
: n% Z6 m* h1 Y' \  q( N4 v; G+ i
( O8 {1 M7 O, g' E1 }; R; G2 Y7 N
) i" V" N2 Z0 lpublic class BubbleSort {
- U7 P/ N3 n, m" e; i public static void main(String[] args) {: ~1 R0 n+ Z/ f) f2 j
      //1、创建80000个数据来测试一下我们的性能' Y0 T! m$ Y' a9 {5 h
      int[] arr = new int[80000];& ^' c) u9 c' j* M+ N1 o
      for (int i = 0; i < 80000; i++) {
  d4 A; Q4 y6 Y- {2 Z$ O          arr = (int)(Math.random()*80000);//生成0到80000的数
0 ?. k, s1 J( i       }
; P. g* a# Q$ z       //2、输出时间
! y& x: c" r: r) ?* T, b       Date date1 = new Date();
: W% C/ k: N2 n6 Q       SimpleDateFormat simpleDateFormat = new SimpleDateFormat("yyyy-mm-dd HH:mm:ss");//格式化/ v& U' B* H  z* [( {# H
      String date1Str = simpleDateFormat.format(date1);
" y. O7 H7 N6 a, o* \" R) x       System.out.println("排序前的时间" + date1Str);( A% h' n. N; M  n& t
      bubbleSort(arr);
1 m( V6 F; @, U$ N3 s6 r       Date date2 = new Date();  r! ~, P7 q4 G& L+ ?8 ~& N
      String date2Str = simpleDateFormat.format(date2);
6 u; ]8 `. b3 {! _: O8 N       System.out.println("排序后的时间" + date2Str);
0 b: |  o, Z9 w3 u0 P: g4 H2 [' X$ h) X1 r/ l
' P1 j0 R+ _8 A: K. v
2 ^* b( O  t) W' p4 f- L

4 L4 E! H0 n6 {) g }+ s. ?/ Y, [3 k+ }% h

) \' w. X1 H( \- n. c& y+ H( ^% F1 ]" j0 i) Z( P
public static void bubbleSort(int[] arr) {
* `. a; q7 A/ v5 _8 b8 t# N# r7 s       //好好理解一下、由此可知，他的时间复杂度为O(n*n)
4 \. f7 j# _( x- ~( t! U       int temp = 0;# l# j. t. F: @4 p1 v

  h6 @/ {7 `! _( U* V  v
- o4 h& B0 \; M: E; I) Z( T       boolean flag = false;
0 C0 R& i$ r7 G! B6 R% b( v       for (int j = 0; j < arr.length - 1; j++) {
) o. Y& |7 K1 |0 Y% A" M- m7 [* [          for (int i = 0; i < arr.length - 1 - j; i++) {
8 D7 v& k5 \4 Y$ H/ P7 q2 T             //如果前面的数比后面的数大，则交换- Z% |% ^1 u  E7 l' v
            if (arr > arr[i+1]) {
1 n9 `  T/ U2 K3 }& Y. u7 I1 [                   flag = true;//在这里把flag值为true
( M! \( ]: y( V5 N. _  |9 }$ ~                   temp = arr;: z. Y1 `6 U# S- j1 N+ W) J  j
                  arr = arr[i + 1];
# o  ]' o5 S, H5 E- J                   arr[i + 1] = temp;
" P* v9 j" u% \( K% x  O- v             }/ W3 e7 m+ N. s9 c, G/ r$ C. }
         }
9 x( G7 e8 W! Q+ X          //在内部循环的时候进行查询
4 ^% c1 v% I6 @- q0 ]          if (!flag) {//说明在第一趟排序过程中一次交换都没有发生。8 O/ B: }6 F4 j8 B
            break;0 [+ L( H3 ]0 }9 [' K4 l4 S3 {. z
         } else {" M) o! D# X: G. e
            flag = false;//没有这个就是执行一遍就没了，要让他进行下次继续/ f  O) M+ e1 p9 Y: V: `0 A+ \' v
         }
3 t1 d) p( m) n: b1 j       }% I) H# J) w8 x. F; b
}
+ v4 r+ w4 s' H}
# ?! W" ^* B$ q4 e  x2 v; Q, f  Z" ^  H# P  ^
- @4 L+ ?/ H5 }7 M6 d
5 Z" H( e. V8 B: ~8 y) H$ u4 _' ^+ p
2、效果+ B% l8 n- q0 i. B; l: d
: w, D" a0 d; B
$ d1 R/ L: _- D5 a3 [7 l/ V5 [3 L% A
& q" Y2 _8 a2 R9 M5 @* o
7 k" [' T/ w& A9 o. N# u

: v: ]$ P9 r) Q