查看: 3525|回复: 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% B) u" p5 q8 h7 Y8 @       //             temp = arr;8 {, n9 w# Z" ?) m
      //             arr = arr[i + 1];
4 t! W; q! T7 w7 `* y       //             arr[i + 1] = temp;
. _1 N8 E: [3 j- l$ k       //          }
& s: l- p8 T4 Z  ]. ]. J1 P       //       }0 R6 x; V+ Y8 h& C" F
      //2、第二糖就是把倒数第二大的排到倒数第二位2 s: x: l. F7 D
      //  for (int i = 0; i < arr.length - 1 - 1; i++) {
! v! |& k# v4 G2 ^+ W. H) j9 H  r       //          //如果前面的数比后面的数大，则交换
( I1 [' S+ H, f+ y1 n: O       //          if (arr > arr[i+1]) {5 W5 H; T0 Q1 z3 `& ^, X; a
      //             temp = arr;
* a6 W. e. m, T8 d) V7 O       //             arr = arr[i + 1];+ @4 v' j; F& \
      //             arr[i + 1] = temp;
; O: n) D6 x+ a       //          }. u8 O* A  U8 R0 C; f$ m
      //       }
% j4 G% |  V7 u8 W  [       //3、第三糖排序，以此内推# ]; ?. p& ]5 x  {& s/ C
      //for (int i = 0; i < arr.length - 1 - 1 - 1; i++) {
9 ?, }* Y  y+ }& ~       //          //如果前面的数比后面的数大，则交换
, B- [2 B% W. o7 w& w       //          if (arr > arr[i+1]) {
+ I& M( r/ l' [       //             temp = arr;
) E2 o  F7 j# ^# ]$ o9 N       //             arr = arr[i + 1];3 f1 J7 q( C& v9 S$ d' W: e; F$ t
      //             arr[i + 1] = temp;3 x' Z0 r' R7 z6 P; h% D
      //          }
* j. X- j" e" ], S- i       //       }- a, d7 ~, z1 {1 K; l; ]
      //4、第四次排序，以此内推
; L& I4 j  P$ x8 E# E! o$ l       //for (int i = 0; i < arr.length - 1 - 1 - 1 - 1 i++) {
) k' P+ I1 Y  G- g: d       //          //如果前面的数比后面的数大，则交换! b3 b& c4 ?! D& _' h
      //          if (arr > arr[i+1]) {5 T+ b) ]/ x% R. K* h  w
      //             temp = arr;' t+ d  u. {' C, P
      //             arr = arr[i + 1];( r- @) ?8 w9 i2 N
      //             arr[i + 1] = temp;
. t5 `2 `& e  b7 h       //          }
* v2 i- {1 k3 d7 d       //       }- U; Y) F& f  W0 H# }
      int temp = 0;//零时变量，用来将最大的数值排在最后
7 y# D3 l# ]6 ]1 u6 i9 b       for (int i = 0; i < arr.length - 1; i++) {, r4 X8 g( r& a, }" s- f6 x5 j
         //如果前面的数比后面的数大，则交换2 |9 F6 E- J" O- Q
         if (arr > arr[i+1]) {" b% K4 ^$ \# D- X9 I8 R. e
            temp = arr;
2 z% \4 i3 _( A0 [, O8 s% N             arr = arr[i + 1];2 M* o4 C; `% [6 g' p
            arr[i + 1] = temp;5 u2 K* T, k) Y  ?" Z. i/ y
         }
- G1 [: y% y" O       }! t4 }- g% O6 Y$ v0 c6 R5 Z6 X9 Z( D4 r
9 c! X6 V. m: L) V; N

# z5 `# J, B, x0 o6 o/ p1 p, l       for (int i = 0; i < arr.length - 1 - 1; i++) {
7 {4 E9 ?. N- u& l" e6 T          //如果前面的数比后面的数大，则交换
7 U  ?" r0 N( h0 Y          if (arr > arr[i+1]) {3 {) F6 _) n8 B( g( C
            temp = arr;7 H: m% E- \# N, V" R
            arr = arr[i + 1];
2 N8 a2 q4 g. {1 s/ H) }             arr[i + 1] = temp;' e# {* w% ~$ u+ p2 B) z
         }, d. O+ a1 i4 G% i- T
      }& q5 ]3 U9 W$ j3 Z" l0 N8 W

" K9 q- i$ t: V0 ~% S
' k5 |- d1 @' P) M- C. U( K       for (int i = 0; i < arr.length - 1 - 1 - 1; i++) {0 k' f/ \/ M: k5 ~5 b4 X
         //如果前面的数比后面的数大，则交换+ ]1 B$ K$ g! r, o, x1 o- |
         if (arr > arr[i+1]) {/ n0 t! k/ F# l' i5 t6 }
            temp = arr;$ x. ^( b" @) G0 `
            arr = arr[i + 1];
1 k+ e1 n$ b% d( x+ K8 G             arr[i + 1] = temp;
2 t# Q% G/ [+ `          }5 N& {2 S& |' T/ k# W' e' S, U
      }" k0 l9 @, ^! A
( x; N$ ~8 L! l# f3 }
/ j1 D7 \' y  T
      for (int i = 0; i < arr.length - 1 - 1 -1 - 1; i++) {% j3 P0 t9 }! z- h: M" `
         //如果前面的数比后面的数大，则交换
% ^' o( ~7 H/ f% {; s, c/ p' ~  X          if (arr > arr[i+1]) {! P: D* @* h7 b( D
            temp = arr;/ [, ^# v) [8 B' r+ U( G3 H0 d
            arr = arr[i + 1];; ]. x) D: F  Y4 c4 K7 n
            arr[i + 1] = temp;/ }9 d5 V' [4 q8 v& A) j' G
         }) L) ]7 W' c( q: Z
      }+ m" U! S" |/ |- g

6 B0 F0 Q$ z3 w" p
& j" U" U+ F' t$ _       System.out.println("hello " + Arrays.toString(arr));
% d6 u; g$ c& j1 D$ f  `5 w$ `: Y9 O       //------------------------------------------------------------------------------------. _, F0 h1 o" v
      //根据上面的观察可以知道了撒，可以再用一套循环解决
( x4 q6 \$ [# f- z, b! I) s! o: K* X+ k2 A, F$ ^, `8 j& n& Q3 s: i

1 Y0 j9 D& M. k2 J1 i& `- u) o8 K; X  Y+ E6 K5 Z6 j6 r

) H/ \$ b9 C% l* K: L6 S- W       //好好理解一下、由此可知，他的时间复杂度为O(n*n)
1 u  M# I# u, t8 E2 h       for (int j = 0; j < arr.length - 1; j++) {
6 _. N2 [5 j' E" F4 Y( d          for (int i = 0; i < arr.length - 1 - j; i++) {$ D8 ]$ g6 \( D6 E
            //如果前面的数比后面的数大，则交换
5 B) k8 u' f' k. h             if (arr > arr[i+1]) {! t1 }6 h& s- Y1 C  X
                  temp = arr;
' Q* T" A$ |8 N5 P! {: F                   arr = arr[i + 1];
! F; }% Z! G) ?8 h, c# X2 B% K                   arr[i + 1] = temp;8 _4 s, O5 D4 |, D$ \+ j* d) R: u
            }1 \* O( M- |) l- A+ X: ?
         }
1 O6 q( V" W- n* R8 \7 e       }
# y* L! E, k& w }
$ V( N6 [9 X& e7 D" a% N, ]" O3 x}2 z9 O! J5 @* S/ p
三、冒泡排序的优化
1、思路
1 d1 L; Q8 _3 \( r3 t) b如果我们发现在某一糖过程中，没有进行一次交换，提前终止7 h/ ^7 X: b  D+ A7 Z
2、代码实现
package cn.mldn;8 R" O9 v( V: W( k* Q9 j4 G

5 Y( P% X1 F, Q$ J( B5 U$ M
/ A  o: e# e% {' N- {import java.util.Arrays;
- f5 _6 R  J  V/ |1 V6 \" v: }- S
% v) t9 n5 O* ?% f
7 O, Q4 g2 \, {: V' g. m5 P9 m% _public class BubbleSort {& U0 n& h! Q0 L, U- g1 S# r6 ?$ d
public static void main(String[] args) {
5 J2 ~% R: [& T) C5 _# R       int[] arr = {3,9,-1,10,-2};
. l$ P6 u4 R: w. a- e1 C       //大致过程
) j+ A* w: G3 Z/ l8 O  l  M       //1、第一步就是第一轮排序得到最大值于最后6 b" D' X1 J5 d) R8 w1 u7 |, H) n
      //  for (int i = 0; i < arr.length - ; i++) {
. U1 P& D- g5 ]' n0 Z  I9 `       //          //如果前面的数比后面的数大，则交换
! t% M* F8 A! I0 O. c+ j  _' H       //          if (arr > arr[i+1]) {
; \( ]$ V. A1 t0 c! w$ y9 i0 a       //             temp = arr;3 N  ]- N/ |  w" W/ f6 A) j. ]
      //             arr = arr[i + 1];
; P) o; ?% w$ S- L/ x       //             arr[i + 1] = temp;( m, @# u! U6 a& h
      //          }
1 L% ?# K; T1 Z# I# v4 E4 u$ ]       //       }) z! A4 ]7 q& I
      //2、第二糖就是把倒数第二大的排到倒数第二位1 Q; Z  {  w+ r, [
      //  for (int i = 0; i < arr.length - 1 - 1; i++) {/ M0 [! w" }, z2 v* A  @
      //          //如果前面的数比后面的数大，则交换
* v; F6 |: A+ G' Q* |  S       //          if (arr > arr[i+1]) {0 a4 G7 W$ @  Y0 A# B* q! q
      //             temp = arr;/ u- Z+ C# F7 p- b# C
      //             arr = arr[i + 1];
- {) ?+ w+ H: ^% U$ s6 v       //             arr[i + 1] = temp;
1 d! _9 e1 d$ j  K  l2 [% S       //          }
7 L' f% a/ }9 \" {6 p5 k6 G  ]       //       }- Z# v3 d1 r4 g6 Z  G- p
      //3、第三糖排序，以此内推1 g- T1 y5 P' k  p
      //for (int i = 0; i < arr.length - 1 - 1 - 1; i++) {
9 Q  C$ Q' i0 ]- R( ^       //          //如果前面的数比后面的数大，则交换
& n" w7 E5 F& V  U9 Z0 j       //          if (arr > arr[i+1]) {0 y* Y3 Q! @" A
      //             temp = arr;4 v; S# A! B/ w" F' X3 ^5 r! R
      //             arr = arr[i + 1];0 b- u8 Y. ?7 n) A# `* G9 g
      //             arr[i + 1] = temp;* b  s# A3 @  b% R, s( Y
      //          }  d1 [+ J/ N! [3 d/ Q' L
      //       }* }$ z* P6 H/ V9 n, z3 [
      //4、第四次排序，以此内推
6 g: m# Q9 n+ g8 E       //for (int i = 0; i < arr.length - 1 - 1 - 1 - 1 i++) {- ^0 F6 w! J1 g' w+ P- n1 n8 |
      //          //如果前面的数比后面的数大，则交换4 d& M2 ]# P: G; u
      //          if (arr > arr[i+1]) {! n! u! S% N8 K% ?
      //             temp = arr;
# Q6 x: q& L- O7 V6 R2 R       //             arr = arr[i + 1];" w5 |7 S) H  l) Q5 K8 E" a' V
      //             arr[i + 1] = temp;9 W% y  V- T  u- V, N+ t  u
      //          }
; v! N. h7 r3 M2 P       //       }
. B4 A) U0 K& Q' t  Z1 d       /*int temp = 0;//零时变量，用来将最大的数值排在最后# y/ u' @- b  l4 I
      for (int i = 0; i < arr.length - 1; i++) {
, s1 n# ]. Q  S. b/ p7 V' o3 m. b          //如果前面的数比后面的数大，则交换
% M- e3 D9 L& T4 G" r$ O          if (arr > arr[i+1]) {
5 y- `  r9 W1 G. G  a% G             temp = arr;/ L; C- v8 m3 }4 x3 N, O
            arr = arr[i + 1];$ W+ l4 T1 L2 W, k4 p
            arr[i + 1] = temp;
0 F  s$ j5 d. u; A0 A% F          }
0 p- V1 E, Z) }& T5 \- |( G7 g; _/ Z       }# o. {- x# T  `

6 ?% F5 V6 a9 {4 u: G$ `6 u# [1 p+ k
      for (int i = 0; i < arr.length - 1 - 1; i++) {* D7 ^7 d7 ~# k) C! q
         //如果前面的数比后面的数大，则交换- V1 t, ]" i& ]' d
         if (arr > arr[i+1]) {
, v" J; `) J, j2 W2 @6 s& Q% S/ X             temp = arr;
* \7 N, K2 ]' h# Q             arr = arr[i + 1];
* P, W) q3 y/ ?, S& S, Y% D             arr[i + 1] = temp;: M: n' C& Y) h7 c  ~
         }
  Q+ |7 X1 W* @/ N8 t# s       }
5 p, t+ r5 p$ \4 W, p$ ~6 ]7 @+ t) P( L/ Y
. U  n2 V- U7 Y9 ~& ~$ \  j
      for (int i = 0; i < arr.length - 1 - 1 - 1; i++) {
& w$ S; O% Q: V( m# I          //如果前面的数比后面的数大，则交换8 k. ?7 o# e0 q% D. F. }
         if (arr > arr[i+1]) {
  x% v# I; C) K5 f' K             temp = arr;
5 b# l) }/ I3 d  i4 v+ c! N2 a             arr = arr[i + 1];  l5 C- }/ K8 X3 K3 ~: a# Y
            arr[i + 1] = temp;6 _9 B! L0 ^- E  v7 _8 L
         }
: o7 l9 m( i' [0 U( o" P/ f       }4 r% ]# M) g5 P  a2 ?( o. }3 b

! E* W  p, B9 M& Z% x# w& T3 N/ h+ X0 A6 v  F+ b4 g, _6 O
      for (int i = 0; i < arr.length - 1 - 1 -1 - 1; i++) {
% d0 N$ k! S2 s9 ^7 u          //如果前面的数比后面的数大，则交换
2 ~) ]+ J3 |/ H( Q: d          if (arr > arr[i+1]) {: Q5 H! F) Q, h; Y+ B7 k
            temp = arr;$ \' w3 c5 E9 D9 A3 @
            arr = arr[i + 1];
) K4 [' c: W; _) w* I* K, w             arr[i + 1] = temp;
/ \! m6 y, w* f) F" r) [          }# }) K( @+ N2 x
      }*/
0 ?: F. y( J$ {& L: t  k
' r7 {0 c5 I8 r
4 a2 {+ t, ?# J2 M' c* @0 u3 Y       System.out.println("hello " + Arrays.toString(arr));
' v) ?, G2 }3 p6 J, W9 k9 d       //------------------------------------------------------------------------------------
! a2 j6 m% w) t) H+ c( O       //根据上面的观察可以知道了撒，可以再用一套循环解决
  \/ b$ z6 D. J$ X# ~
$ r) V' `; \. E' Z* H* P
% Q( I' Z/ T. b6 q/ N8 l) K% j9 O8 ?. M# ~2 Y
; R+ T4 f- g$ a, ~6 H  V

) h5 `$ u8 ?1 }+ H
" P, b# d7 F" b: g# I) o       //好好理解一下、由此可知，他的时间复杂度为O(n*n)
4 L: @0 ]# I8 a! Q       int temp = 0;
; {7 A* E7 Z/ C) ?1 h" A+ T8 k8 m, h) \

3 i9 n. R+ ]. B       boolean flag = false;
2 U' `" R! B( l; U       for (int j = 0; j < arr.length - 1; j++) {% B5 K  \8 s( x6 h, q0 f' Z5 ?9 j
         for (int i = 0; i < arr.length - 1 - j; i++) {
' l: p9 @3 J0 n! y             //如果前面的数比后面的数大，则交换5 V+ d! \6 _- t  M/ B
            if (arr > arr[i+1]) {
/ [; ]; d; |* z. c+ ^+ m* L. b/ A, o                   flag = true;//在这里把flag值为true
: z* }* L: o" X% p                   temp = arr;
6 c) e; N  Z: W: O  }                   arr = arr[i + 1];
- F% \/ Y" C; L; A' Y) ?, K6 {                   arr[i + 1] = temp;# r' `6 x; @7 _* J) j, n/ h, J
            }  @; D2 }5 ^, o6 y
         }/ C0 c7 w" O; p' T8 Z
         //在内部循环的时候进行查询
! u# N' }  A4 c% o          if (!flag) {//说明在第一趟排序过程中一次交换都没有发生。
8 w- S9 G9 r; v* n7 @0 K  G: h- e             break;  w0 t; d0 l7 w7 w
         } else {
% n% @9 u7 g* ?$ F1 f             flag = false;//没有这个就是执行一遍就没了，要让他进行下次继续0 m  o) `) R9 d+ D: D" R
         }. r. @9 @' s; o4 Z
      }# v( a: k2 d$ c! a" C
6 J5 [  U/ N( A; Q4 Y
2 @6 n) F3 A! b. p2 w5 M# |2 v0 I
      System.out.println("world " + Arrays.toString(arr));- Y2 N, T& I5 q9 _
}( A; {' y+ Y4 l
}2 T( j6 {1 Q. K% B& T# r
四、将上面的代码封装为一个方法# x+ u2 a& R# Q; [" U. h5 L7 |5 Y' d
public class BubbleSort {7 |7 {5 D# Y% e
public static void main(String[] args) {4 H0 A  A4 ?: f+ N6 e
      int[] arr = {3,9,-1,10,-2};
+ Y5 `) U- t$ q& X" K6 ~4 {
& x! I" D8 l8 A* P6 V/ [6 p5 Z
9 @9 ]" {7 m* j. g8 D7 y* Y       bubbleSort(arr);
% Z0 e* k# K5 _; p$ }       System.out.println("world " + Arrays.toString(arr));5 \  ^: e: ~9 M  _8 z5 z2 e& i2 [
}
! R& c* [" ^: ?1 \' q  ~" x2 t; {# ^; U3 T- P& x6 w. L8 w& w
' v" a% }' P0 P+ ]
public static void bubbleSort(int[] arr) {
3 S' V) o2 c7 i+ R  Y/ C  H       //好好理解一下、由此可知，他的时间复杂度为O(n*n)
1 r5 Y/ |: }8 N2 ~  S" i       int temp = 0;
: W/ O6 k6 \$ W( _# J: w( L' [. P5 I6 U. B/ O" b
3 k; b( K2 P1 Y- [0 U
      boolean flag = false;* b* h8 D1 h/ {
      for (int j = 0; j < arr.length - 1; j++) {6 ]3 s) I; z9 s0 h5 L! N! q
         for (int i = 0; i < arr.length - 1 - j; i++) {& s! @7 S. W, p* f
            //如果前面的数比后面的数大，则交换- Z7 q1 d# L- u- U: k
            if (arr > arr[i+1]) {
0 N9 G: x7 z1 ]! j& t- {                   flag = true;//在这里把flag值为true& u7 J& s7 o2 X$ p- {7 u4 Q$ z
                  temp = arr;8 A" o2 i! s, b
                  arr = arr[i + 1];
% o. ?' g* l( n& t' O+ m# L                   arr[i + 1] = temp;
4 N, O8 A# [1 M( w* [$ ?             }
; b& Q! P5 ^" w& R4 e# e3 J          }. B+ k8 g8 I# w: l: g+ T+ j
         //在内部循环的时候进行查询
% j+ b% ~1 H, L; i5 n( i          if (!flag) {//说明在第一趟排序过程中一次交换都没有发生。
+ L6 e5 Q4 d4 `6 n             break;9 S) d; W; v  @+ @; @
         } else {. C0 Y& U% [# o( k5 {1 S- J; @
            flag = false;//没有这个就是执行一遍就没了，要让他进行下次继续& C( o( C7 y6 m
         }: }( U# _: d& `+ E. c) ]
      }  G) n8 k9 T) n1 v) M7 h1 ^$ U" z
}, U# W9 |6 f6 P/ K$ e( C' t0 C" ]
}% d, q3 p) P/ s( J* V
五、测试一下冒泡排序的时间复杂度
1、代码是实现
import java.text.SimpleDateFormat;
  l4 p! ?6 h6 N9 ?import java.util.Arrays;# u/ `! C4 `4 }% @/ d# J
import java.util.Date;
& @' f1 v, n: W5 s& I$ f  {8 |
* z: ]$ l( W  g) g2 i5 O
8 x+ W  Y; s; f  R7 A0 Bpublic class BubbleSort {
/ _" U4 k' g: w, M public static void main(String[] args) {
0 J( `3 C* {1 ^# u! Q# |% x       //1、创建80000个数据来测试一下我们的性能6 J  C, x( v8 E& V# c8 p
      int[] arr = new int[80000];' y- ^& M& @. k1 e, r- N
      for (int i = 0; i < 80000; i++) {
% \7 Z6 ]" V- r+ E; Q5 h          arr = (int)(Math.random()*80000);//生成0到80000的数
( P; ^1 ]' h/ `( Z/ Q2 L- \       }6 D4 s% d& t& S
      //2、输出时间, o0 \4 v+ U$ y; u7 {0 u3 H7 \! ?
      Date date1 = new Date();" s* Y2 j4 r9 j/ \/ a( S+ l/ Q/ f
      SimpleDateFormat simpleDateFormat = new SimpleDateFormat("yyyy-mm-dd HH:mm:ss");//格式化# e" I  B3 o  s  j0 j
      String date1Str = simpleDateFormat.format(date1);
, P0 V" ]8 B) T6 _6 J       System.out.println("排序前的时间" + date1Str);
# @0 q% d( L) e! z       bubbleSort(arr);
% W1 D2 f+ [! ^' f9 t2 A       Date date2 = new Date();; o" \8 s( t2 Z/ b2 h. E7 V
      String date2Str = simpleDateFormat.format(date2);
$ Z4 a" O, F# g0 t7 g7 ^       System.out.println("排序后的时间" + date2Str);
4 b" A- r* k. f8 y1 V: w6 G! r( \& m1 B$ {5 N

, g# {7 T' x  X) G8 }
& J7 j: \- O+ `! j
6 j* u6 j. n0 w$ b6 L- B }
' G/ S4 Z4 u  a6 X; Y9 y1 t
1 f( w: |( }' {9 S" s3 B7 s2 v4 j! p) @
public static void bubbleSort(int[] arr) {  ?* C5 f2 u: l. O/ i' t" c& }
      //好好理解一下、由此可知，他的时间复杂度为O(n*n)
4 F! c# a: v4 i, {2 v       int temp = 0;
. ]( v) r% G; b. K
+ ]( }7 A: f5 s) e  ?2 E& E. P' F5 V8 ^) d
      boolean flag = false;
( q! W" o  u' k8 A7 c& I5 y0 C! o       for (int j = 0; j < arr.length - 1; j++) {: O5 o, b9 l- j/ d
         for (int i = 0; i < arr.length - 1 - j; i++) {0 E! @1 I7 J9 i: S% a7 Q
            //如果前面的数比后面的数大，则交换
. E8 i9 ~+ J! m# C& H             if (arr > arr[i+1]) {0 D# t# ]5 u9 n5 c6 l! t- i) A, {
                  flag = true;//在这里把flag值为true' N/ I- V. }- D1 t/ z( t3 f
                  temp = arr;
7 J5 P6 W9 X5 \. ?. r                   arr = arr[i + 1];5 ?$ |9 \$ W4 T) f8 O
                  arr[i + 1] = temp;2 {* L: _& y, T: O" c
            }" j' [4 y/ M: e3 h! K" Z) E+ F
         }
. a8 G: M" J8 _" D          //在内部循环的时候进行查询5 R! Z; }' k% S1 s% Z9 w1 G
         if (!flag) {//说明在第一趟排序过程中一次交换都没有发生。3 J" X# v. f+ P4 ~
            break;
$ d4 H+ c0 B2 ^+ `          } else {3 @! P# v; x; _/ T) z
            flag = false;//没有这个就是执行一遍就没了，要让他进行下次继续
1 o- @5 K+ Y; G, Z          }( X- `4 k) L: O. V4 T. p: [
      }
% P2 g+ M2 U( z( {- [. w5 C* Q }6 J! C+ t) S5 J. M2 G
}0 l: W4 {" h: Q5 g

) L& Z% D: o( H& v3 s' F& e
; A/ P" B& c5 \" }' A2 ~; V, x7 a6 b6 k& W$ Z# W
2、效果* I* L; p8 t# ?8 r/ \! k

4 C; E- x. L4 |4 \6 N  ]4 l  ?! y7 Z3 ?/ }
$ N7 B; D% ^. K

: A( E) M$ |4 E9 f, B* e; v
4 v$ a: t* ]; F5 m7 O: ~