查看: 3255|回复: 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]) {
8 x8 R, P- }5 E; `$ i- Z" P       //             temp = arr;
2 @" p& M5 X) N! K& g! J       //             arr = arr[i + 1];: j" z! v1 t" n* e/ |1 g) I
      //             arr[i + 1] = temp;3 H5 q, ~% D5 E( M& B' z
      //          }1 t, X; a& N! S' d( t4 S4 T3 _
      //       }
8 [  n/ \- L/ C& E# a; L! L. s, D       //2、第二糖就是把倒数第二大的排到倒数第二位
# ^- u4 a( W3 O/ H8 d       //  for (int i = 0; i < arr.length - 1 - 1; i++) {, \4 ?! b7 q( y) @
      //          //如果前面的数比后面的数大，则交换
7 W8 m! |8 D, W: ]8 k       //          if (arr > arr[i+1]) {* \4 B6 d" Z, T% ?- ^
      //             temp = arr;7 s' f$ u6 _$ N8 C3 v
      //             arr = arr[i + 1];% M3 |! c( {7 [& i6 L- u5 T
      //             arr[i + 1] = temp;' k& v" e) U# Z
      //          }* h" C- w* A; f
      //       }, |/ K9 j& U, {5 \0 h+ N3 g, s
      //3、第三糖排序，以此内推4 E5 L) a8 C9 T/ n* o2 H4 f, a/ v
      //for (int i = 0; i < arr.length - 1 - 1 - 1; i++) {
  B) M) D  M( O       //          //如果前面的数比后面的数大，则交换$ O: ?: U& Z! u1 Q1 j
      //          if (arr > arr[i+1]) {+ N" s& `5 r0 \5 N: N
      //             temp = arr;
& G! u6 m: u0 N       //             arr = arr[i + 1];! W5 o/ i6 r$ F/ z1 ]
      //             arr[i + 1] = temp;" h6 ?& H1 y* N: B
      //          }' ^5 f6 v( f3 `( L8 w
      //       }$ a) p3 R$ V7 {: W  R, d, ^
      //4、第四次排序，以此内推
/ Z) {0 @5 L3 D3 S' u       //for (int i = 0; i < arr.length - 1 - 1 - 1 - 1 i++) {
+ w- R5 J' T6 u8 ^- q- G" k       //          //如果前面的数比后面的数大，则交换+ L  J' y, ^2 V+ [  @6 V% s: x
      //          if (arr > arr[i+1]) {" ?0 a  B: M" b0 F, y
      //             temp = arr;
! S4 _0 o& A# m# s6 [) @       //             arr = arr[i + 1];
9 B6 q; H; u5 N" K7 U, F0 d       //             arr[i + 1] = temp;" G- U4 m/ l! N+ M7 b1 ~) W' W
      //          }
8 y5 _9 `0 s/ s  ]  d! w$ `       //       }0 U) l# X) \7 r8 Z8 @2 I4 S1 {
      int temp = 0;//零时变量，用来将最大的数值排在最后
: \* [/ `# _, I3 g( R9 V       for (int i = 0; i < arr.length - 1; i++) {/ N' @7 l, e) \
         //如果前面的数比后面的数大，则交换& y6 J* V! I& ?0 x! P
         if (arr > arr[i+1]) {5 }: V' g# K5 w3 K2 b
            temp = arr;
, Y1 E, {* K' G7 G2 _( z0 T; K             arr = arr[i + 1];+ S/ j9 \6 X: h( i* W
            arr[i + 1] = temp;
2 v. G( _( V0 e3 ?" @          }# ?! ?  v% [0 B5 y' M: q
      }  r' ?8 u1 O% Q

* |1 E( R( q! ^! B& w3 l6 i
% ^9 f' Q7 l6 g2 l% `, U* [       for (int i = 0; i < arr.length - 1 - 1; i++) {
) n: [+ I# z0 C  `          //如果前面的数比后面的数大，则交换- Z2 S/ q1 h$ i2 `2 D7 F$ j
         if (arr > arr[i+1]) {9 z+ x0 G4 y- m0 [" Z
            temp = arr;3 N4 k# }! u$ A+ H$ X1 k
            arr = arr[i + 1];
/ I1 X1 a$ U" l+ A3 ^7 U7 [             arr[i + 1] = temp;+ ?1 ^3 ^! j! t* h
         }# L1 M5 L' ?( H) M  [# w
      }
. m; p5 o& |* |& w/ |& s1 b+ f' j& |3 R3 i' `) f% i

/ z3 L6 ^+ d, x" r5 Q       for (int i = 0; i < arr.length - 1 - 1 - 1; i++) {
6 D0 P1 E5 K! C          //如果前面的数比后面的数大，则交换
& Z9 h5 l# v. H2 G+ L/ p4 Z5 d/ v          if (arr > arr[i+1]) {
$ b4 k% q7 j# _! t& l) n             temp = arr;* }$ O: b# ]: Z' W
            arr = arr[i + 1];
- Z6 [5 K- k! ~# [3 {* r             arr[i + 1] = temp;
; K: c% m! x6 W1 P3 \4 z/ k          }
( R2 b' G9 _5 s% }" S       }
0 t( ~6 S1 l1 h6 V/ D* N/ C4 L& P0 s6 ^" q! V

6 ^' X8 e2 d0 D  ?! t       for (int i = 0; i < arr.length - 1 - 1 -1 - 1; i++) {9 t6 K' b& D' w/ L: s: _. p
         //如果前面的数比后面的数大，则交换' ?! [0 b' ~: V8 T' v* H$ @
         if (arr > arr[i+1]) {
: t- C- p; x/ Y* q1 T2 U3 G             temp = arr;
6 N$ A/ X$ q3 j8 e* b' R+ s             arr = arr[i + 1];
# _. f" F  Y6 v3 Q; h             arr[i + 1] = temp;) t# p6 ]9 _5 b- c* K+ @4 G4 M
         }
! \" w  Z9 a6 ~  m5 Q% X       }. X" O4 C. N' G

, J: D8 `0 F" N9 L# B! `1 ]* J. o6 \* B) i) R3 d* w
      System.out.println("hello " + Arrays.toString(arr));7 C5 r) k; I6 h  z1 u/ @' ^& T; C
      //------------------------------------------------------------------------------------
9 d; s( ^6 @# t' Q3 L       //根据上面的观察可以知道了撒，可以再用一套循环解决  m& ]& t0 g4 s6 b
5 \) A2 }$ ^3 Q% y

( K* \/ K' l- i3 s+ S9 _( r  L9 `. c; }( n5 w- d) G0 s2 [. r
$ S5 l: q) |7 {9 j
      //好好理解一下、由此可知，他的时间复杂度为O(n*n). G8 u9 E! Z* J+ Z
      for (int j = 0; j < arr.length - 1; j++) {# V9 d, e1 z& H+ o* B1 W6 D
         for (int i = 0; i < arr.length - 1 - j; i++) {9 @) ~7 ^4 z; Q" E2 L9 j% v( o5 k
            //如果前面的数比后面的数大，则交换
5 [9 U# `- G" C; d             if (arr > arr[i+1]) {
- z; ~: S% c) ^3 s' ?$ ]! `                   temp = arr;
0 D7 B( i% U$ X# E                   arr = arr[i + 1];8 ~2 ^8 `5 Z4 d9 L
                  arr[i + 1] = temp;, Y/ Q" A+ v; v/ W8 K2 e  u
            }" Z$ d9 L1 E: n
         }
, l+ p; H: y, d$ c  c) w* O! x- B       }0 E! {- g$ s* e: A' {& y
}+ }0 U" A. X2 X6 y( G
}
" b  `# o9 R0 j' X5 Q1 ~- p* K三、冒泡排序的优化
1、思路
9 ]" {( p! k) Z0 q如果我们发现在某一糖过程中，没有进行一次交换，提前终止
5 [) C) l1 ?2 i1 h$ J1 A" ~2、代码实现
package cn.mldn;
& _& Z4 s! _' i1 n  j/ J& r: @- [+ I; q5 m9 {" H

- @% }( \) C2 x$ p* M' v3 v7 d, zimport java.util.Arrays;! B3 n) G' ~1 E! W' k* Q" F
8 M2 e5 v4 @% N* {, {
) i- k, B" ^& }+ }" K" L, \
public class BubbleSort {
- X. v$ H3 x9 H% x! l: s5 U public static void main(String[] args) {7 e1 K8 Y; V+ F: @3 t
      int[] arr = {3,9,-1,10,-2};
% x: i# L! \6 A9 Z! |       //大致过程& C7 C* y7 ]' h* D5 h9 d
      //1、第一步就是第一轮排序得到最大值于最后
8 g% r* r; b6 M% t, B       //  for (int i = 0; i < arr.length - ; i++) {' m  J8 N5 C2 f3 [/ Y8 L
      //          //如果前面的数比后面的数大，则交换6 k0 S! r8 y9 `. a0 K7 N2 p0 z9 g
      //          if (arr > arr[i+1]) {; H$ l* K/ D) j( m9 C. k# y% e
      //             temp = arr;# D: U$ K1 n: D9 K! l
      //             arr = arr[i + 1];
/ O) L$ v1 n! i; q8 ~" S       //             arr[i + 1] = temp;3 k# C! @8 q9 A5 n+ j( O# Q
      //          }
4 {) ?. G% o) Y8 o0 e3 C       //       }4 Z) r# O, o2 y/ k1 y- I+ c
      //2、第二糖就是把倒数第二大的排到倒数第二位- s- t7 F7 E0 ~  O7 J
      //  for (int i = 0; i < arr.length - 1 - 1; i++) {5 Z4 t! h9 k, f8 T1 V
      //          //如果前面的数比后面的数大，则交换/ u2 X- r1 n. L7 s4 b; E2 C
      //          if (arr > arr[i+1]) {( E, V6 c( b2 d0 K- [/ V$ A. d( G
      //             temp = arr;  R% f) a( y! J* |- P5 O
      //             arr = arr[i + 1];
% P3 S! r) l; L. f0 m* u: X       //             arr[i + 1] = temp;; r& a' d* X: Z" D
      //          }9 c3 `. M- Q! @0 U% ~1 T1 l) L
      //       }- W! n- ?3 L+ M  d( i2 e1 V
      //3、第三糖排序，以此内推9 }7 D; o) }' E. o) e
      //for (int i = 0; i < arr.length - 1 - 1 - 1; i++) {
5 Q: Z6 b) ?3 A% q+ ~       //          //如果前面的数比后面的数大，则交换
9 C  N; k9 \6 h       //          if (arr > arr[i+1]) {) Z; K. B8 q2 E5 P
      //             temp = arr;
# J* n9 D" p* {) c3 I( ?       //             arr = arr[i + 1];
( G0 P1 Z6 D4 k+ I8 r. X* {* J       //             arr[i + 1] = temp;/ j$ |! l7 O) d$ b( i
      //          }
: h# K1 u- N1 z4 W8 D9 @, k8 Q* w       //       }. v; F9 M+ b. z1 ?9 r
      //4、第四次排序，以此内推
3 a/ n- Z* t% @% f- y       //for (int i = 0; i < arr.length - 1 - 1 - 1 - 1 i++) {
$ N: r! e! r+ E4 r       //          //如果前面的数比后面的数大，则交换
$ r- a- l; R  M( Q4 d* C$ |       //          if (arr > arr[i+1]) {
$ J! J6 K. x) ^       //             temp = arr;* U3 O- K2 ?1 [# e; R7 A
      //             arr = arr[i + 1];
2 w3 c5 |3 w4 Z! z; ~7 o2 j       //             arr[i + 1] = temp;
2 y( E3 R6 v8 n# u% p# P       //          }" a0 A9 a, ^& I$ x
      //       }
. a* W" }4 \# f0 T/ A       /*int temp = 0;//零时变量，用来将最大的数值排在最后
" `& V9 m5 G" u8 T0 P       for (int i = 0; i < arr.length - 1; i++) {
# ]; f2 c3 B# I4 f          //如果前面的数比后面的数大，则交换
1 E8 ^: w! {1 A  }2 Z  J& h  x+ a          if (arr > arr[i+1]) {  v! Z) ?% \/ O+ v* X6 D: f5 s3 Z0 x
            temp = arr;$ l' _4 X& ~4 ^+ k# a( U
            arr = arr[i + 1];
+ |* \. ~6 H3 c& B3 W0 y" X             arr[i + 1] = temp;
) c& t. m; K- Z% v  N% Q          }
) @2 {$ u( W: v8 O  m; j* o% y       }
( [' F4 R% J6 K$ M5 q4 H, r/ C4 Z$ i3 o/ s0 x1 t% @% h. I9 j
( ?3 E) e. @) I6 _0 Q% Z- ?+ [
      for (int i = 0; i < arr.length - 1 - 1; i++) {
) J! `# Y& |, `+ x" W# U          //如果前面的数比后面的数大，则交换
$ I' _1 r' D9 q; E7 M7 Q3 ~% W3 P          if (arr > arr[i+1]) {
1 T: @0 I% t3 D% ^+ @             temp = arr;1 a- C9 I5 L$ @" i4 P# Q0 y
            arr = arr[i + 1];
$ I. p% I, d  {! L             arr[i + 1] = temp;
1 n0 Z4 \  c; \, I9 v  J4 ^+ o          }  d" w$ g' L/ L8 D' `0 z2 v
      }9 I. V/ S& R! i  x" C1 V0 o. s

' _1 H4 N7 J( Q8 G, Q6 e# |+ Z0 [+ {
  m+ U* z( o$ @! {. C       for (int i = 0; i < arr.length - 1 - 1 - 1; i++) {: t/ b2 R$ O/ M' e0 a/ ?% o4 }6 Q
         //如果前面的数比后面的数大，则交换
4 [& f  }8 _9 L          if (arr > arr[i+1]) {
' m" ?" s2 I( N2 V- D5 F             temp = arr;
2 u* [- C/ K/ F5 ]& G4 y             arr = arr[i + 1];4 p& u" `  Q! d* f0 j& y
            arr[i + 1] = temp;
" P6 [* c8 _  J. j" M8 }. W$ u2 Y          }: W$ A8 o2 B* L
      }
$ g* Z- N' q" \; b$ J8 p8 N
6 i3 B2 v- G7 ]- K9 A2 L% D& a/ d$ h3 f
      for (int i = 0; i < arr.length - 1 - 1 -1 - 1; i++) {
8 q+ R3 y( N% w% H+ J$ p# C          //如果前面的数比后面的数大，则交换1 t, ]# h7 d% T! h, a
         if (arr > arr[i+1]) {& k. ]6 E& f2 o  q( L
            temp = arr;1 C$ P- h0 B* C
            arr = arr[i + 1];, f8 l* t$ y$ L( [4 i
            arr[i + 1] = temp;/ |; h9 J+ N9 O# [3 a( Y
         }$ h& \. t2 T! U  c. r
      }*/
) A: G: `; m5 d: l9 d' T) r- k) V+ k4 C# i5 {; J

- C$ Z" j6 Q9 B0 Q       System.out.println("hello " + Arrays.toString(arr));; G  w2 g8 H; Z0 L7 m' q, n9 L! u
      //------------------------------------------------------------------------------------
' r. t8 K/ k" f+ \( z1 l4 d0 a2 [       //根据上面的观察可以知道了撒，可以再用一套循环解决9 M5 A6 C3 Q/ l& @- E/ `& v/ x' ]/ z

8 x0 Q* [6 f  T* L* V5 L) T" W7 [
3 g$ K9 u" T. B" K
# n5 ~; M  Y1 T+ a4 ^
$ |5 S3 j: L$ q4 u% m, ^/ U- |
+ J9 }. |2 y! T2 C& G' h/ R
      //好好理解一下、由此可知，他的时间复杂度为O(n*n)3 ]- \0 _- H1 w4 f1 {6 k& P! ^
      int temp = 0;
3 Z# F- |! ~3 N. l8 w
' M/ u9 a. s& `) y# P9 Y; m: [2 ^" N0 ?4 f: v$ y
      boolean flag = false;
0 U, c9 }; e, V, V2 k       for (int j = 0; j < arr.length - 1; j++) {* }; R/ |$ h2 P2 i% s' e
         for (int i = 0; i < arr.length - 1 - j; i++) {& E: V' \9 D+ k4 @2 c' h. Z0 i+ B
            //如果前面的数比后面的数大，则交换8 l# {$ p+ w' V0 S2 w; u1 I
            if (arr > arr[i+1]) {& A5 L7 B) p! W: R
                  flag = true;//在这里把flag值为true. ]4 {3 _9 G3 M" o( X$ C6 n8 ]- e8 i
                  temp = arr;0 x7 H9 ^9 c% S6 b
                  arr = arr[i + 1];
% t% I/ G% I3 _+ r; Q3 h6 o! D4 w! \                   arr[i + 1] = temp;
" D- G4 _: w& w             }( Y# ~9 P' S8 Q- `" t
         }+ {( ?/ _$ G$ D* b
         //在内部循环的时候进行查询  x/ C0 ^2 T! U% X
         if (!flag) {//说明在第一趟排序过程中一次交换都没有发生。
) q. d9 v: Q3 ^             break;
4 w0 \; y( R8 r. }4 M          } else {
" c+ S; \; K% Y             flag = false;//没有这个就是执行一遍就没了，要让他进行下次继续0 Q! u1 ]# e6 N- T
         }
0 }* E3 ?* h' M$ t: j: u       }' N. C! q8 L" }

( B% R! _! n1 o9 T; x. {( c" l  v* _1 O- T( D
      System.out.println("world " + Arrays.toString(arr));6 Y/ u" k! Z' S
}  z1 D2 O  ]8 S! [) w: s' f
}' ?& a2 }) V! e( q0 B9 y% Q
四、将上面的代码封装为一个方法
- F/ o+ z$ F" U  K% @public class BubbleSort {
, i' m, r6 @0 ` public static void main(String[] args) {' Z3 a$ y5 P+ c& v# `/ H
      int[] arr = {3,9,-1,10,-2};
: U4 Z) f/ B. y  I9 D  A- C/ d$ h
- m) K2 a2 g, _/ Z/ q- y% V9 r, C- ]. ~6 A8 d& `! T: d  P
      bubbleSort(arr);
1 l4 n" w  g$ M- y: F       System.out.println("world " + Arrays.toString(arr));
; k5 ^) Z1 v2 K: ]$ E }1 u9 U4 z1 q$ n4 w3 z

+ J! X6 W3 p0 k! u% v0 c4 ^$ l
. J3 b4 j) h7 p' N; j public static void bubbleSort(int[] arr) {9 _( F% X$ Q% l) j! i4 L! ?" W
      //好好理解一下、由此可知，他的时间复杂度为O(n*n)
- ?: {1 ^. v/ `       int temp = 0;
. F( f( M" K1 H; C( ~0 r) h/ t
' S* j8 L# G6 G; N
& u7 h: C, {1 C' j8 z0 ^" c       boolean flag = false;
6 K  f( d$ U$ T, n: g0 ~7 {       for (int j = 0; j < arr.length - 1; j++) {) t- B. b; s5 v
         for (int i = 0; i < arr.length - 1 - j; i++) {6 j% m/ T2 H1 E- r. I. o& B0 i
            //如果前面的数比后面的数大，则交换" V& ]6 W- M, s" ?
            if (arr > arr[i+1]) {4 ~$ Y- X$ l' a' l
                  flag = true;//在这里把flag值为true; N( S4 t5 h3 f5 I( ]
                  temp = arr;
: X1 x* ?! ?' a0 K! \- g  S                   arr = arr[i + 1];5 t2 p  `0 U; f7 l
                  arr[i + 1] = temp;) t% e) O+ Q* X% M# l; K0 e4 z. C$ v
            }2 e$ g1 C; w; ]6 L
         }
& w/ o1 {" s1 n5 B, A' x* `          //在内部循环的时候进行查询
6 a; S. @& _4 E8 u          if (!flag) {//说明在第一趟排序过程中一次交换都没有发生。$ [* }- [$ S# j" v
            break;
) N9 w: `$ D, ]2 F( a7 E          } else {& W0 z( A! B: i3 j. O: v
            flag = false;//没有这个就是执行一遍就没了，要让他进行下次继续
- l( W. Z4 R+ h- A          }" Z' N9 D/ e- D
      }
' V* M% D6 T; W$ K }
* B0 s' M0 B" w1 q: ?6 c}
/ ]& f6 C  D2 r五、测试一下冒泡排序的时间复杂度
1、代码是实现
import java.text.SimpleDateFormat;) E& d# a3 I4 T+ Z0 a  V+ P
import java.util.Arrays;- f' a( g) v7 I- h6 |7 A
import java.util.Date;
4 a6 Z$ N- W' R& t8 b; d
* O& J6 N6 a% \, o! _7 N
7 v0 ]- u0 a& r- m5 C# r2 rpublic class BubbleSort {9 U  q' F/ b. t! j3 t7 P7 V
public static void main(String[] args) {7 E% e( W7 D; r% w( H
      //1、创建80000个数据来测试一下我们的性能2 E0 R* I6 O0 V8 y: a9 w. [: w
      int[] arr = new int[80000];
9 t: O  `4 o4 J       for (int i = 0; i < 80000; i++) {+ f* p8 D4 K7 Y/ R) X( g9 D9 y8 X
         arr = (int)(Math.random()*80000);//生成0到80000的数. L7 j9 U( {1 ?3 b9 x% J) v# _; u1 A
      }
$ ^" E8 \  o3 p       //2、输出时间" E% N  M$ D1 E5 c; w+ R
      Date date1 = new Date();
( m$ t/ J0 w3 c  D       SimpleDateFormat simpleDateFormat = new SimpleDateFormat("yyyy-mm-dd HH:mm:ss");//格式化$ J! V- n; y# F# l  R
      String date1Str = simpleDateFormat.format(date1);& T1 }& m7 W0 u- V. {% x
      System.out.println("排序前的时间" + date1Str);1 i% ]6 h! m/ E& r; X
      bubbleSort(arr);
/ g- z! v& |" b  S9 C6 J7 n" V       Date date2 = new Date();
$ K4 V8 \1 n3 r. U% [( E: U       String date2Str = simpleDateFormat.format(date2);  U" J1 w+ `" b/ I
      System.out.println("排序后的时间" + date2Str);
& ^' O' e" H; }9 r" o9 [( d% [6 n' B& R( o

% v+ u" f3 V) W# j
& C+ k0 A7 l% V0 K- z, T. B% N# t1 m9 L7 u1 w; p
}9 \  F: [/ p% I: f3 |
$ Y3 x4 i. p$ h) t

6 e1 |6 P, G; c3 o1 G. y) i public static void bubbleSort(int[] arr) {0 }* K5 W* z. y
      //好好理解一下、由此可知，他的时间复杂度为O(n*n); P+ i  w7 H: e) R) J1 @
      int temp = 0;+ {0 Z- z8 w4 R8 j

5 t, f9 P# A  C2 |' O; g% x) G* R2 f9 C
      boolean flag = false;3 m% R' s4 c$ L+ Q& c. f  ]
      for (int j = 0; j < arr.length - 1; j++) {
1 Z6 c( \: b/ `/ k( q) t7 M. G1 V          for (int i = 0; i < arr.length - 1 - j; i++) {
1 ]# {9 G+ i5 P- f/ d3 A9 k             //如果前面的数比后面的数大，则交换
' |- k" G# y$ g6 A7 f% M             if (arr > arr[i+1]) {8 A5 f/ E1 }% A8 V6 a: e
                  flag = true;//在这里把flag值为true
5 n6 P3 P4 S4 E& s                   temp = arr;9 Z0 o7 G5 ^+ C: v: ?$ L( v7 z$ p
                  arr = arr[i + 1];
. u1 }6 ^" l& ]% p, b+ l; u                   arr[i + 1] = temp;2 R5 h0 Y) K- J9 Y5 M/ ^% |$ d
            }1 @- D+ z, a& c0 S9 l, G* ]
         }
3 n' D6 k- A* j/ {& k1 ?          //在内部循环的时候进行查询# R4 P: H- f  M/ b8 ]
         if (!flag) {//说明在第一趟排序过程中一次交换都没有发生。" L& r) P! z6 R( D4 v' C) x% g0 F
            break;5 N0 s4 d2 y! ]
         } else {
8 E4 k. C: }  {2 w! Z( O             flag = false;//没有这个就是执行一遍就没了，要让他进行下次继续
, Z; c, U* d# G' @          }+ |& T7 a6 ?8 h
      }: [$ {2 c, V5 M$ \6 `- G
}, \+ M; g  r. }1 f0 j* H( p; j
}! r/ i# Q- ]4 Q- ~& C  A

9 Z, _2 A6 u' [, B; m' I
! j' M6 m: s; O" f, U$ c% C9 Z/ Z; K& |7 M, U) q* M% x
2、效果
1 ^( B7 r% o4 Z4 r, d& V6 x) k* m% r# S* U! ?& f

. F2 J1 r! O1 d4 [
0 z7 \' B1 e9 O& l; E
0 a; |0 @1 n/ j/ g. S
) q0 t4 x" f* Z2 X