查看: 3278|回复: 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]) {  \& m4 j3 `3 q/ j) v/ a% u
      //             temp = arr;
5 A, {* J4 G/ t" |* n$ i, R       //             arr = arr[i + 1];
# ?5 e1 x/ N, r) O- x& T       //             arr[i + 1] = temp;
1 v# I$ b$ v+ o/ _0 R       //          }
" ]( P1 J4 K% t5 ~5 B# S       //       }
" ~0 _0 W. C2 B4 O       //2、第二糖就是把倒数第二大的排到倒数第二位
1 A& m7 S$ ?$ d# r- E$ \2 i       //  for (int i = 0; i < arr.length - 1 - 1; i++) {
# f: n  a7 c: _, l7 N       //          //如果前面的数比后面的数大，则交换
/ g% h# \" n. n4 J% S0 h       //          if (arr > arr[i+1]) {
! Q( Z+ ?( D3 m) D# `       //             temp = arr;& @7 I. A' {2 n
      //             arr = arr[i + 1];
) ], w8 g- v1 g6 `8 U+ B# U& w       //             arr[i + 1] = temp;
# z, g0 ]. _! y$ d5 B' w  v8 a       //          }
' Q" p, n# e% D8 o5 M       //       }
1 R" }& ^* R6 j- E/ S7 A       //3、第三糖排序，以此内推
1 G5 a* Q5 I% t       //for (int i = 0; i < arr.length - 1 - 1 - 1; i++) {8 ]- x4 ~# `5 z8 b" L
      //          //如果前面的数比后面的数大，则交换: P; O: p+ s+ Z5 \3 J" v
      //          if (arr > arr[i+1]) {# G8 M( d5 O. J) h1 A/ o
      //             temp = arr;
  t; o8 A. n+ B) N% a" N: f( V       //             arr = arr[i + 1];
6 L. f2 q$ v2 ]9 q       //             arr[i + 1] = temp;. q8 C& f. a2 \! r( \4 p5 `
      //          }
, M' y4 z9 z; f0 {8 _5 A, U       //       }
4 h8 p" ^6 }4 t: @       //4、第四次排序，以此内推4 V& x; ~! _7 b/ ~
      //for (int i = 0; i < arr.length - 1 - 1 - 1 - 1 i++) {+ C' G2 m7 W) f
      //          //如果前面的数比后面的数大，则交换
" f6 s5 y8 N8 n9 e- u- |# |8 a       //          if (arr > arr[i+1]) {( J0 r+ ^# P' e2 A' }1 C( h
      //             temp = arr;$ Z6 l6 o' E: U; R5 C  F
      //             arr = arr[i + 1];. \7 t3 W0 g& a, ^3 {" E# l
      //             arr[i + 1] = temp;
" v7 z; B* U4 r. l       //          }$ M  Z9 O  N* [8 J
      //       }
0 |1 R1 Z0 o9 ]  q# @2 k- _& F       int temp = 0;//零时变量，用来将最大的数值排在最后
' d) P  E6 ]- h9 S& h       for (int i = 0; i < arr.length - 1; i++) {
3 ?. ?/ x# F: C" M  |. \          //如果前面的数比后面的数大，则交换
/ a" h; Z( j. c% E: I1 h* U          if (arr > arr[i+1]) {4 i+ J/ O+ e, N! A) u2 _, a
            temp = arr;
" ^; z" o$ l- V& f/ Y, Z# ?0 {             arr = arr[i + 1];
3 N4 i8 r1 \0 p; F             arr[i + 1] = temp;; F. ~2 p/ _3 P  ?+ L9 J1 T0 y
         }
# ]! X' e& K. d* H% k       }
& X+ A! T" a* v% Q0 ~: r4 r+ k( r+ {' P6 U$ ?0 k( y
  ?" ]  u( a/ s. W& I9 @, ?7 J% P+ c' L
      for (int i = 0; i < arr.length - 1 - 1; i++) {2 Q1 _7 m2 _* G3 w6 C1 [0 z, ?
         //如果前面的数比后面的数大，则交换9 W! Z6 f7 C& n& w: F8 d/ `7 Q
         if (arr > arr[i+1]) {% b+ h1 W: H, w9 }$ d
            temp = arr;
' R6 d4 [! J: ]& T             arr = arr[i + 1];
6 Q  p" y  F% n$ u; V0 b             arr[i + 1] = temp;
1 R* C5 q% R& B, T) j2 q) _: [          }
6 s) Q3 n# _0 `       }, ^1 E$ Z" `+ t1 p0 r3 j/ z+ O3 C
1 k8 v9 \: g) d( v  W) |+ M

: [9 e8 k* p0 J0 R) u; G       for (int i = 0; i < arr.length - 1 - 1 - 1; i++) {
2 z' ?7 a, F4 C6 p5 b% F          //如果前面的数比后面的数大，则交换$ P. s$ |' m: D6 F. y
         if (arr > arr[i+1]) {
5 q7 n* o% G" U; f- k# B% z             temp = arr;3 I6 Q5 g& {! t2 ]  L1 V9 g" ]
            arr = arr[i + 1];2 @% Z. g0 J1 }5 @: a
            arr[i + 1] = temp;3 M2 b7 R; k6 w' H, p$ U
         }
* f' X- S4 L4 C/ p7 F* x       }6 I9 Y( |1 S8 Z" @
6 \1 H1 b* s/ U4 F
3 C) F$ v8 B' F# m7 J6 C+ H
      for (int i = 0; i < arr.length - 1 - 1 -1 - 1; i++) {" G% [* l: F0 d, L4 w
         //如果前面的数比后面的数大，则交换
" u2 h( }* t2 X. l  Z! q& o) m          if (arr > arr[i+1]) {9 N. o, s4 v9 h8 b) a  M
            temp = arr;
8 x7 Z* g3 y& T/ k) Q             arr = arr[i + 1];
* z5 h$ Q# n3 w* `/ g$ @             arr[i + 1] = temp;
8 v& g$ C& {( P' U2 _: O! m/ L) |          }
0 ?& Z3 ^, f& ?+ R       }
  {# G: {0 z8 _
' H8 O6 }5 X& B% t8 Q' ~$ |
$ i7 v% T3 f, q       System.out.println("hello " + Arrays.toString(arr));9 `5 z; A0 O, }# p" \7 R
      //------------------------------------------------------------------------------------' }8 {; [0 i7 G% q$ q) z7 w6 i! u; L
      //根据上面的观察可以知道了撒，可以再用一套循环解决: G& P) b' R4 z5 C

; }; W/ s7 K% m. M6 _! D5 T* ]
- e$ l& }+ m3 v, S0 ]7 h. w) u( t. H7 r8 t

& H) P, Q$ e9 P+ {       //好好理解一下、由此可知，他的时间复杂度为O(n*n)' F& M" A$ m7 S  _8 E; N+ q  A0 I
      for (int j = 0; j < arr.length - 1; j++) {
4 {% a7 m2 L* o6 E! V2 f4 `! [& ]          for (int i = 0; i < arr.length - 1 - j; i++) {
# c, {- ^' q2 e6 I$ L$ ~* g: t             //如果前面的数比后面的数大，则交换
3 ?6 T/ Q3 `# R: d             if (arr > arr[i+1]) {5 |1 j7 [" O1 C0 e
                  temp = arr;
. _4 L7 c6 {& {3 E& A                   arr = arr[i + 1];$ U; I1 k$ x6 x4 o& y
                  arr[i + 1] = temp;2 {, t" z) ~# U7 ?
            }
0 {7 L7 C4 t  L& l! h          }% s, ]& d7 g! `0 D. h8 U
      }
/ F2 X# E4 m8 f! M6 \% ]3 V }
' f6 _% @6 ~# |/ V3 a! v}4 p7 u; F# F% U2 X' `
三、冒泡排序的优化
1、思路
* V" B8 Z/ F+ k1 O( e- Q5 E如果我们发现在某一糖过程中，没有进行一次交换，提前终止6 X; R# f5 z/ L9 Z  g* @
2、代码实现
package cn.mldn;+ @' E" @* I2 s& n
/ Z. t8 q4 l- d" b6 n+ h) ^0 Z7 s
( f1 B' C0 h" d# p, o6 x7 w
import java.util.Arrays;' B) j3 E7 T# C% z
' S2 I. s1 j1 \3 v7 B
$ U, e. C- I' X3 {9 J9 n/ W
public class BubbleSort {2 |" y* R+ t# A4 n5 T( x
public static void main(String[] args) {
' e% A: O& i0 u5 s       int[] arr = {3,9,-1,10,-2};
# G- y2 Y& @5 f  A+ a6 ~       //大致过程
8 l4 L  }- K4 F& i' v6 O0 f       //1、第一步就是第一轮排序得到最大值于最后
$ L( [+ m: A2 n: m. K  }7 _0 k       //  for (int i = 0; i < arr.length - ; i++) {
; h! c5 K! d8 T; B) x* w1 Z- a7 H/ n       //          //如果前面的数比后面的数大，则交换  y: j) H3 S, e) B
      //          if (arr > arr[i+1]) {# Q8 m% }6 O; [1 x9 l' `" D
      //             temp = arr;
$ K- C6 o6 d7 {6 n       //             arr = arr[i + 1];
* _3 W1 J# B5 n. m       //             arr[i + 1] = temp;, _( {0 d  W/ ?, t- A
      //          }; h+ i+ `' G$ p
      //       }( j( g. X" h) _) U3 z
      //2、第二糖就是把倒数第二大的排到倒数第二位1 z. Y, g7 y0 z- |
      //  for (int i = 0; i < arr.length - 1 - 1; i++) {- |8 {' l- e2 R% }
      //          //如果前面的数比后面的数大，则交换
' `& D$ y+ l' ?$ X0 v       //          if (arr > arr[i+1]) {0 S. |  f. r6 v+ H! I
      //             temp = arr;
3 X. m5 V7 r& b2 z( L- t       //             arr = arr[i + 1];& k: L5 _: f; {* C# q
      //             arr[i + 1] = temp;
& z0 @1 s" Y' s4 y1 ^/ y$ m7 C       //          }, G7 ~" C% X  A/ a  A
      //       }
. S* v2 e8 s% G& f# _       //3、第三糖排序，以此内推
0 Q" K! P6 Z1 H' ^: O3 y/ C       //for (int i = 0; i < arr.length - 1 - 1 - 1; i++) {7 X! q/ J0 x6 ?& S/ t
      //          //如果前面的数比后面的数大，则交换7 Y3 C- V3 f; ^3 i- R4 Z! C
      //          if (arr > arr[i+1]) {
) [4 r% D  ]: p* F       //             temp = arr;: @7 k9 D) [1 ^8 n! h# W6 U* |" S
      //             arr = arr[i + 1];
/ c2 d1 K( m: ?8 ?/ ~       //             arr[i + 1] = temp;
7 {2 E8 z+ g, T9 R' e       //          }% ~: b$ Q% o, Y* \
      //       }$ O  d9 m/ \6 v
      //4、第四次排序，以此内推( [/ }$ p# b9 O: R& V
      //for (int i = 0; i < arr.length - 1 - 1 - 1 - 1 i++) {
2 B7 I* n, x7 z9 W       //          //如果前面的数比后面的数大，则交换
' ]! `1 J9 b9 ?       //          if (arr > arr[i+1]) {
6 X& P7 s, N+ I( a+ @" F       //             temp = arr;- `4 t2 B/ u9 q1 ^# a
      //             arr = arr[i + 1];
4 _/ i6 z4 U, l: F& |. x1 x2 M       //             arr[i + 1] = temp;9 Z" A- m4 m3 m: m. D( T( S4 j+ H
      //          }
5 D2 s0 X. y/ I4 P       //       }4 C; a- ^6 B: u- Z- ]  a
      /*int temp = 0;//零时变量，用来将最大的数值排在最后
1 G& ^4 |) j8 E3 g, Z       for (int i = 0; i < arr.length - 1; i++) {5 L9 Q; `% M) L" F- @" x2 L
         //如果前面的数比后面的数大，则交换! f5 q$ ~9 ]: ^& p/ H: B) A( A6 S
         if (arr > arr[i+1]) {
0 M+ Z1 ^, K9 z) T- ]( G             temp = arr;
9 Y2 d* {& Z7 k  _             arr = arr[i + 1];! M9 Q& {# @6 Q' l
            arr[i + 1] = temp;
0 z( _4 G/ s1 t% A1 Q+ ]          }4 g: A/ }" Z5 k; u" g0 t0 J8 I
      }
; h% {( e. ?7 _& A
- ]9 a% y* D, z! ?$ k7 v1 f, Q; {' `) u4 B4 z- V
      for (int i = 0; i < arr.length - 1 - 1; i++) {8 [% \' v" E3 R; G) H& [% _
         //如果前面的数比后面的数大，则交换) {3 Z2 _7 f1 q- {% M7 D, h$ T
         if (arr > arr[i+1]) {$ H" G, H. c7 F0 X  C: O# O
            temp = arr;
8 _( f! Z  ~: D/ o* p% Q             arr = arr[i + 1];+ c8 Q; E7 }3 B' `; B. t/ F8 i
            arr[i + 1] = temp;
6 z  G3 Y- J- r1 \% R          }
  C4 i) r9 I. A6 I- C       }
  u3 j) V* c7 l/ A, B6 L+ f; K- B( A1 o( k5 {* }
" F; m( z3 q6 B" W, V
      for (int i = 0; i < arr.length - 1 - 1 - 1; i++) {6 b7 e7 J8 V! j1 v
         //如果前面的数比后面的数大，则交换
) K+ x9 {- Y6 L' P0 i: D          if (arr > arr[i+1]) {, {- h, }( A8 o* M4 h; O2 Z
            temp = arr;4 U8 y+ D, T$ Z8 H& d8 Q" W+ C
            arr = arr[i + 1];; r/ {' x  x0 z8 x6 ]6 n
            arr[i + 1] = temp;
6 X+ c3 h: o$ r3 N          }3 H. z6 B/ _! C0 x% D- ?% [+ N: h
      }
8 a1 ]* s+ ]- v/ h
5 {$ L4 e1 y8 h7 _7 ?8 B
9 V7 g1 K/ G6 e( O8 T) g       for (int i = 0; i < arr.length - 1 - 1 -1 - 1; i++) {
9 Y' r9 B* n, T0 j9 b          //如果前面的数比后面的数大，则交换
  s7 ~  {$ y  u) @          if (arr > arr[i+1]) {
+ L) B1 \# K" V" z" j             temp = arr;
5 U* \1 h1 l! g) J/ u5 l* b" ?             arr = arr[i + 1];$ e  v0 o6 e( K, h7 \% b
            arr[i + 1] = temp;
. [8 A/ w( E) ?+ P: G          }
2 o+ t' N' J  W9 h1 s       }*/7 S6 q. ^: X0 v8 _) ^
% P  Y& U' G0 \$ `$ j1 R
; c# F% |$ d6 l2 t% u, c; Y  w4 L5 Y
      System.out.println("hello " + Arrays.toString(arr));
0 i1 v' n2 _6 c' x8 d       //------------------------------------------------------------------------------------
3 T) s" Y* e2 P+ ]       //根据上面的观察可以知道了撒，可以再用一套循环解决
, K* I3 ], y* n
1 v) w' I% M1 b& Q( [# |6 Y  x  S1 q1 ]
2 t4 j$ A3 X+ u/ L

/ c7 ^1 ~/ R0 P: ]
% x1 b$ Z0 Z8 {1 J6 x2 `. L$ [- t  Y+ A& ]! }7 J) x
      //好好理解一下、由此可知，他的时间复杂度为O(n*n)
3 ?+ H8 K' n0 ]  M# o% h8 x- Z' k, n       int temp = 0;3 i/ s) Q. [& L6 U
+ p: [* f' R  D0 |

$ V. h0 }5 y, C# e$ C! |8 S       boolean flag = false;1 x. `& B; p' _! X+ m3 w
      for (int j = 0; j < arr.length - 1; j++) {
# @# u' j7 S* ^6 ^: ]          for (int i = 0; i < arr.length - 1 - j; i++) {( _! w# ^  ^/ Z4 U
            //如果前面的数比后面的数大，则交换4 O3 U) ], Z1 I+ a, K% e
            if (arr > arr[i+1]) {' Y5 \! N( H' G* f) [1 |2 W4 K! Y
                  flag = true;//在这里把flag值为true( j! {* P3 Q" y9 m; r, c! p
                  temp = arr;
* {8 K' V3 M9 u5 T                   arr = arr[i + 1];8 f( Z6 E$ g% _, d1 s) X
                  arr[i + 1] = temp;% N! t" e2 K$ j4 o
            }* M4 b7 c) K6 c9 R: j3 m
         }
. g5 |( {0 ~4 g1 s9 S: _( `8 n0 W; R          //在内部循环的时候进行查询
2 ]  ~7 `3 _  i7 I; p8 D$ P- _          if (!flag) {//说明在第一趟排序过程中一次交换都没有发生。
( _( y9 |! k9 c& ?! z             break;
9 ^2 I% B- U1 B/ m$ ~5 r          } else {+ r* @2 J. A2 }$ e9 }
            flag = false;//没有这个就是执行一遍就没了，要让他进行下次继续; C3 e' Z& w+ j5 ?
         }" t. C7 V' T1 d4 A/ x8 C5 y% x
      }
$ l+ `( Z: Q9 i) |/ h% _  V' k% ]% `& u8 ?: n: J) |( z

0 b1 p, _: a' _: k" ?, b$ R       System.out.println("world " + Arrays.toString(arr));
  {. \9 L( q' r  ]$ f# s1 ~ }
2 K. T4 Z4 q' G5 m: o2 |6 d7 P}# }6 d/ t3 n% m; z, a
四、将上面的代码封装为一个方法2 T  }6 g% f4 w* D! J% R! a4 l
public class BubbleSort {
( G' H5 }! c8 l: x3 C3 N6 I public static void main(String[] args) {
3 V$ U8 j( I" i. O/ W* s       int[] arr = {3,9,-1,10,-2};2 V9 f9 J3 L2 |* Q0 ^8 \3 r
* ?/ L# S* T2 D& {8 Y

1 j. c1 j$ [5 n& @/ e& y) S& Z       bubbleSort(arr);
' w4 k) Z2 f/ N: f6 B$ x       System.out.println("world " + Arrays.toString(arr));7 O' m" \5 Y0 w5 m  V
}) b1 e+ I5 C4 h0 \
* h3 D$ Z5 J/ _; R7 m
% Q, R7 A5 l, t3 ~
public static void bubbleSort(int[] arr) {4 _. I5 C9 o7 I  U7 X/ z" z1 @8 I
      //好好理解一下、由此可知，他的时间复杂度为O(n*n)
  Q; t# y9 S; G" n, B& A       int temp = 0;
$ z8 z* N0 k7 J! p( M0 B) o4 }* y0 M* Y% [' U& C

6 a  u7 L; p7 G( w1 P7 t$ f       boolean flag = false;' Q# w. D, A2 S
      for (int j = 0; j < arr.length - 1; j++) {
) G/ X, `+ L1 a; h, p          for (int i = 0; i < arr.length - 1 - j; i++) {; Z, Z7 j; P9 e, n  \% y: G/ |
            //如果前面的数比后面的数大，则交换
" {8 w) c' K6 c" ^! O. s             if (arr > arr[i+1]) {- j0 b% Z: o, @: ?
                  flag = true;//在这里把flag值为true) O; K, |) n$ M
                  temp = arr;6 `0 h6 v" l" G) @; c7 D
                  arr = arr[i + 1];
$ o7 l2 A. m1 r- O                   arr[i + 1] = temp;
5 `$ V' g: Y( I  W. Z. A             }# }! ]* v! W$ e$ F  X" Z* c
         }
/ l2 I4 H& n, i+ R8 T. M. ~2 S          //在内部循环的时候进行查询
0 L% u: i# G- Y( L8 w' W          if (!flag) {//说明在第一趟排序过程中一次交换都没有发生。
6 n2 d" |/ F3 H0 J" B             break;' D2 ~& L' f0 [
         } else {: i1 W- ]4 a1 j; J8 K7 `
            flag = false;//没有这个就是执行一遍就没了，要让他进行下次继续! G6 \, e$ m6 c/ b" E
         }% H) K. F) z# z! C" U
      }
! a# N/ e# d! b; s# Q }
7 k3 l5 i; V; [9 A9 j5 O}
+ ]. o# ]  C; }7 K/ ~五、测试一下冒泡排序的时间复杂度
1、代码是实现
import java.text.SimpleDateFormat;
0 G- M2 U+ v0 v' e# Oimport java.util.Arrays;; l  W; i$ \3 ?( j  z
import java.util.Date;! x) M7 }# F4 ]9 [) u  f

$ A, {& ?/ U$ r$ [1 m" p& U# m) l: b
public class BubbleSort {
+ c; h3 O* s* g. P public static void main(String[] args) {
+ E! |* c/ w1 a/ I/ h( ^) T  H       //1、创建80000个数据来测试一下我们的性能) S8 K/ f6 C: w3 H
      int[] arr = new int[80000];
0 m, S* A' D- J3 D' w  Y6 h       for (int i = 0; i < 80000; i++) {
# J3 u! |; ]( s% b* R          arr = (int)(Math.random()*80000);//生成0到80000的数
4 ]( _+ Q: N9 T8 Q9 b       }
% j9 N0 n8 b& o. p       //2、输出时间% R! L+ d/ I( n/ m  m& |
      Date date1 = new Date();
  ^* Z3 B8 q# _0 Y       SimpleDateFormat simpleDateFormat = new SimpleDateFormat("yyyy-mm-dd HH:mm:ss");//格式化' L1 u8 H5 S- I5 F
      String date1Str = simpleDateFormat.format(date1);
4 L  Q8 D5 a( k. _2 _' E8 |9 Q1 L       System.out.println("排序前的时间" + date1Str);
- M3 u; K1 {+ o% M- S4 f8 m       bubbleSort(arr);
2 r) E( y+ f+ c5 }& }: U8 W, x1 Z       Date date2 = new Date();8 W. ?. T2 b* W; O0 Y. P
      String date2Str = simpleDateFormat.format(date2);9 F1 [' v4 X! C) j) b. [
      System.out.println("排序后的时间" + date2Str);
! u. Q$ S& z3 H# m9 k/ n0 o5 z6 S, J- L: B7 ~

9 y1 ]( t% r! H3 S, F3 |( P4 {

; ?! @; Q% h. A9 b9 s% W" H }
3 ~3 ^+ G% |5 a0 G/ F6 j' g; o' a+ O2 z

: x' [2 J4 m, `$ L public static void bubbleSort(int[] arr) {
4 _) R0 }0 }' P: \- I5 O       //好好理解一下、由此可知，他的时间复杂度为O(n*n)
& V% |1 V! Q9 o# E/ {       int temp = 0;% H% L$ T1 w! ~  G& u3 l. Q9 c

. s6 }# `, A1 b  {% K! q8 s! f6 b/ k* ~0 ?4 r* z" c
      boolean flag = false;
, S' @4 V: {1 j+ O" S8 q2 R, s       for (int j = 0; j < arr.length - 1; j++) {
3 ^6 R$ Q. W1 g0 J8 e          for (int i = 0; i < arr.length - 1 - j; i++) {. z. Y; R6 ]- B7 z8 {+ o4 b' B* d
            //如果前面的数比后面的数大，则交换& t, \9 e) @- F, w7 G
            if (arr > arr[i+1]) {' u9 X4 e( F# W2 J% l: t
                  flag = true;//在这里把flag值为true
4 F. `2 `% k! M- Y( n; M                   temp = arr;
9 }0 q, s0 G) d+ e                   arr = arr[i + 1];2 ~  x; R% Y2 S& x
                  arr[i + 1] = temp;
* H+ C3 ~: d4 o8 i5 h             }
" h, @: [  h& o* G& A          }3 G5 b0 b3 l& |$ ^2 \8 W5 m3 m$ m
         //在内部循环的时候进行查询* U8 z) ]' [0 _: n" {8 ^. x. ]9 x
         if (!flag) {//说明在第一趟排序过程中一次交换都没有发生。
6 C2 z9 r% A8 k+ @9 y  q             break;8 m& i2 \0 O+ }
         } else {! }6 Z& j; I. S* h8 ^4 T: A
            flag = false;//没有这个就是执行一遍就没了，要让他进行下次继续
9 }+ w) c6 C; P9 L          }; V: H, Z# D+ z5 d3 t5 ~
      }. Y* A: u4 ?3 H; \
}
& f3 l- K' s, o3 o) B7 u}# N- y/ S. f% y( v$ i
8 J$ x$ R- x( T/ l( g- u

7 ?7 \1 @$ X" t: a- U
5 A# h  t4 k, y1 W' X1 V/ v2、效果
1 [, S, G+ s0 i5 E7 R6 ~) w& t; c# `6 _& U* i5 Z
9 c( k- V3 n' N; o( H' E9 \" H3 O/ z, }7 X

- i& j( F1 c5 b( y, K: h7 H8 E! ]% V4 N: L: b
! R, _9 R  l/ U) s