查看: 3432|回复: 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]) {6 o) ?: t9 }6 q
      //             temp = arr;5 {+ u9 t/ ]  S) G; p
      //             arr = arr[i + 1];
5 n$ ^  o/ l4 I$ t8 e9 R       //             arr[i + 1] = temp;
+ s& ~- F. g$ S8 m& Z6 y* a2 W       //          }0 ~4 m  `$ p8 e6 I
      //       }
5 I: N9 V, T2 r( q) Z- d2 Z       //2、第二糖就是把倒数第二大的排到倒数第二位
" y2 ]3 X+ s! v! C0 ?# ?. F       //  for (int i = 0; i < arr.length - 1 - 1; i++) {  l/ p3 Q5 d1 `# ^4 F( s! X2 f
      //          //如果前面的数比后面的数大，则交换
+ m" D' S" w- o, Y$ u( P* y       //          if (arr > arr[i+1]) {
" W5 d6 J8 E4 V$ {" k. @       //             temp = arr;
8 S' d+ p: _& x" R/ J% B1 M; t2 c" Y       //             arr = arr[i + 1];
0 y5 Y4 s1 J- G/ \* O+ H# N" }. X  ^       //             arr[i + 1] = temp;' R8 u6 c+ I4 ?3 @
      //          }
0 c/ A9 v3 U. B) |7 G, e& n# Q       //       }
! ~) U! n4 _# R! L2 T       //3、第三糖排序，以此内推& m4 m6 ?$ P' Q8 o& n
      //for (int i = 0; i < arr.length - 1 - 1 - 1; i++) {7 I- C# y4 z+ @4 Z- X5 _
      //          //如果前面的数比后面的数大，则交换, ]4 o4 a3 z4 y, b# _0 K
      //          if (arr > arr[i+1]) {/ W5 o9 \) r2 g/ b& s+ B
      //             temp = arr;
- t# Z2 K  C) f. O" Z+ G       //             arr = arr[i + 1];3 o! }5 ^/ F. {, H; [0 A# M
      //             arr[i + 1] = temp;; D1 L! ?* |# x, `
      //          }0 @5 L, e( I/ g0 x# i
      //       }
& A$ o8 E; p% b4 }       //4、第四次排序，以此内推
! \2 S( p) r) b7 |7 j# |. l, P       //for (int i = 0; i < arr.length - 1 - 1 - 1 - 1 i++) {3 [" {7 X  [( v$ D% s7 o0 D
      //          //如果前面的数比后面的数大，则交换- P9 J5 M9 X# L" s0 M5 ^1 e, x3 y
      //          if (arr > arr[i+1]) {
7 H" I4 X0 _2 k  T: l       //             temp = arr;* l9 c, E  x* @1 G; ]
      //             arr = arr[i + 1];
1 Y: y+ l5 ?2 v- H6 w       //             arr[i + 1] = temp;, c/ v5 k' W. `$ l
      //          }
1 a5 d! ~7 ~' w8 s7 I3 Q       //       }
9 l( u3 p' I* N6 p6 ~       int temp = 0;//零时变量，用来将最大的数值排在最后
1 [! b0 k' a0 F: l+ e8 W       for (int i = 0; i < arr.length - 1; i++) {% J: B  q+ m, x3 Q
         //如果前面的数比后面的数大，则交换
3 J3 c8 b- @1 M6 @* Y          if (arr > arr[i+1]) {" G/ b% t/ Y( M" f0 |' P4 {
            temp = arr;
' U* q( o' N" e! I- t  [             arr = arr[i + 1];1 h+ b: [; s2 E4 ]# G7 R2 f
            arr[i + 1] = temp;* i9 |" h2 e( v" @3 U4 V
         }
# B6 {$ l  F: g. W       }
, V1 ~) L' d* ^$ _# q7 ]9 h' N% F" }1 m$ s! B

6 D% A& M. \+ m; N       for (int i = 0; i < arr.length - 1 - 1; i++) {2 ]  e: Q6 ]& _5 F7 S
         //如果前面的数比后面的数大，则交换) O6 R# O* K6 D# V7 U2 N; m7 q3 q
         if (arr > arr[i+1]) {5 N. r9 _8 T; Z9 U
            temp = arr;
  F: M- @" j; }. M! M             arr = arr[i + 1];; o6 S- Z) T" I; P4 i; V9 w
            arr[i + 1] = temp;+ k4 C  ^- a0 A: R; o4 M( |
         }
) t/ `4 }& b" ?       }
! M; ]5 i3 {* R5 P% j5 x
: _) h7 _: M0 _% i) \& V/ E
+ _2 v* k0 l! H+ I       for (int i = 0; i < arr.length - 1 - 1 - 1; i++) {) y  _, D4 r$ C0 w" F
         //如果前面的数比后面的数大，则交换2 \! f8 i1 H: S' M; n+ o  ?0 {  S
         if (arr > arr[i+1]) {
8 t* x7 J6 t. t& v6 K             temp = arr;
& i/ \1 i8 i" O# ~/ Z( a  q" `             arr = arr[i + 1];
4 f* v0 P& ?/ K% A" O4 G5 ^             arr[i + 1] = temp;; P: t; w! C/ S1 Q6 D* U
         }
3 ?3 \& _4 K! t0 g  K" S       }" L5 s1 \5 s. m  c7 V$ M
5 V7 C& C' G) `9 v

8 x' [! R: v; }' `       for (int i = 0; i < arr.length - 1 - 1 -1 - 1; i++) {
( I: T& n6 P3 A- Y4 x% c. _0 z          //如果前面的数比后面的数大，则交换# v7 C  Q2 m3 {5 F5 x# D
         if (arr > arr[i+1]) {
  b( s5 g5 P' ?. d/ Y& B. m             temp = arr;
; l$ O/ J) Z. p+ Y6 ^             arr = arr[i + 1];
. g2 @# F! l9 N6 Y# q2 h             arr[i + 1] = temp;* S6 I3 X& l/ G* R* I( {6 l
         }
* B9 Y0 u! G( b' z8 I       }9 A) D3 M0 m( ~$ G( F' s6 G/ O

6 s0 U; N. Q9 t
% }( ]$ n1 t% W/ M$ s; Q; L       System.out.println("hello " + Arrays.toString(arr));
+ \* I( e3 Y- S       //------------------------------------------------------------------------------------6 |/ e3 r( z# Y# j& D( U: }
      //根据上面的观察可以知道了撒，可以再用一套循环解决
( |8 V8 K9 s( X+ w8 q8 Q4 L; t4 Z% P$ D! m7 W- D
% g; q( o! P- u* A6 g
. E! U0 C- h' T) r0 V5 Z# ~0 E4 Z5 t, d
% b3 K6 P+ k% @% j, U) ]0 O4 l
      //好好理解一下、由此可知，他的时间复杂度为O(n*n)
* j/ O" F7 t8 Z: A% I. H       for (int j = 0; j < arr.length - 1; j++) {8 C6 _" [* E3 T7 ^, b4 Y
         for (int i = 0; i < arr.length - 1 - j; i++) {
8 z2 I* |, o! q. B& x0 a% W, ^             //如果前面的数比后面的数大，则交换1 l* F; T  ]: z6 w# s0 _9 D
            if (arr > arr[i+1]) {
7 J6 _0 `: u9 n                   temp = arr;- ^5 C' k! ^# F' j1 C
                  arr = arr[i + 1];8 q  `. ^( e4 }& M1 r% l0 B
                  arr[i + 1] = temp;
: J- s% E: `5 K5 P             }
2 N8 e- D. n4 U$ N! X          }5 X! J& G) i& P9 }# C8 _3 X
      }% F3 P. u6 i$ T" G! K
}
9 [* A4 c( R* {! G; l$ Y4 \}
4 B8 h* X! f2 K三、冒泡排序的优化
1、思路
9 u$ J% V- ~4 X* u" c. k如果我们发现在某一糖过程中，没有进行一次交换，提前终止
- i- I- V6 f3 H# Y1 h2、代码实现
package cn.mldn;
3 n$ R" D- S9 c9 Z5 f7 X4 }9 b" K8 H) x) l/ {6 O9 b1 V. v
- w5 W1 I( j' e
import java.util.Arrays;
9 {# B7 k" x* n9 Y* E: N
# ~4 a4 D0 z6 b9 l4 p4 O
* a9 c$ {9 w9 Y+ g* Jpublic class BubbleSort {
2 H/ R- [# f4 A2 ~, U  p& f. ?; } public static void main(String[] args) {( A+ b# i9 \8 [9 a5 b
      int[] arr = {3,9,-1,10,-2};; ?' x( n- p5 O2 a! M0 ]
      //大致过程
0 ]8 y- h( Y! Z7 b( ^$ o* @/ d       //1、第一步就是第一轮排序得到最大值于最后
. }1 x% L# J4 Q( ^" M       //  for (int i = 0; i < arr.length - ; i++) {
$ A0 T# h6 Q) b0 a/ y3 ?       //          //如果前面的数比后面的数大，则交换  l$ T0 \! g6 \/ v! N) O7 V' m" Q
      //          if (arr > arr[i+1]) {
2 C9 C2 G' x# W3 E" t       //             temp = arr;, g9 t6 E, ?* J$ S; F3 @
      //             arr = arr[i + 1];
- O9 c$ e8 P1 O# ]/ _% N0 {       //             arr[i + 1] = temp;
2 A$ |  A! S0 _       //          }7 ?/ J$ E3 r* a& }( W; l
      //       }
3 [5 F6 s- Q2 H+ e& l, {       //2、第二糖就是把倒数第二大的排到倒数第二位
1 R  `9 n" f9 O3 g7 C1 e3 |       //  for (int i = 0; i < arr.length - 1 - 1; i++) {
$ W4 J5 m9 f5 ]       //          //如果前面的数比后面的数大，则交换; E8 u) ^7 `  ]9 \9 h4 M+ s# X" m
      //          if (arr > arr[i+1]) {- f3 x% _# M; ^* K6 Q1 [4 I
      //             temp = arr;
4 \, Q7 u, `: A& D. q/ O) {       //             arr = arr[i + 1];
* T2 J( [1 M6 ^: z# M       //             arr[i + 1] = temp;0 i+ A' f3 L  p6 \- x* `4 w4 W9 U
      //          }' l& i% u$ |4 Q3 {+ g% W' b& ]
      //       }
* L- T$ q$ A( d. v: P& D  e       //3、第三糖排序，以此内推& c% e1 k' m3 y
      //for (int i = 0; i < arr.length - 1 - 1 - 1; i++) {
! ]; Y# o5 f! @- W: N8 K" M9 t       //          //如果前面的数比后面的数大，则交换3 |! Y/ H  c9 }6 J
      //          if (arr > arr[i+1]) {
# h6 Z+ f  j) D$ d. q       //             temp = arr;
( D5 l2 s3 s$ F6 H8 _# F       //             arr = arr[i + 1];
3 ^( A) O! \: ?       //             arr[i + 1] = temp;
$ V: a7 |  ?& z3 j, ~: s3 S       //          }5 S- S, s# v; n# U
      //       }3 h; Y- U: K3 B  q' O( _* H
      //4、第四次排序，以此内推
  e" J# j$ y. \) M       //for (int i = 0; i < arr.length - 1 - 1 - 1 - 1 i++) {
1 w* D1 s; D6 Y/ N  B       //          //如果前面的数比后面的数大，则交换/ C* q7 f0 ~7 \
      //          if (arr > arr[i+1]) {
( y$ ~9 K" G6 l6 B( H4 V2 p/ l$ k# c       //             temp = arr;
) T2 [  J/ F: U3 `. N& o       //             arr = arr[i + 1];" Z: e" {% }9 q, K8 p0 N  T7 U
      //             arr[i + 1] = temp;/ N7 a0 N( s7 ]- i+ n# w  E
      //          }
9 W4 S% R: {+ J- q5 b       //       }: k/ F2 L6 P! g8 r& b& H
      /*int temp = 0;//零时变量，用来将最大的数值排在最后5 U; l  ~9 V& n6 d
      for (int i = 0; i < arr.length - 1; i++) {3 m# j+ U9 f  ^; W$ t! b
         //如果前面的数比后面的数大，则交换* Q- o( M2 c, N3 X
         if (arr > arr[i+1]) {
& F6 a" u2 r- Q: `1 D0 @! F. w3 x. G             temp = arr;
% o. G' d4 c7 R9 B6 x( }             arr = arr[i + 1];
3 J* {$ \: Z% ?* _% l3 z; H8 O6 b             arr[i + 1] = temp;
- d1 ]5 u& e$ R/ R          }. A) b4 u/ E7 m8 y% W( Y, c6 w
      }1 y, o" Y5 L4 _; D% O; i* D6 ~8 P- o* y
0 I* `- ]/ X5 }5 y8 s7 i

4 u# J! m- ]: K2 x3 C3 V2 ~$ Q       for (int i = 0; i < arr.length - 1 - 1; i++) {
: p% h3 e: V0 G- `! Q4 F8 H; s          //如果前面的数比后面的数大，则交换
) `! @, a+ a" e7 P; w/ o* r* _          if (arr > arr[i+1]) {
/ a% `7 G+ q6 Z7 B' K0 X. X6 K             temp = arr;
, Z% s1 E4 \8 w             arr = arr[i + 1];
( W9 i6 g' W. c4 H9 B5 h             arr[i + 1] = temp;  ]% S9 l# d4 x8 i: Z3 M
         }- j6 y& ?0 S% @7 m( f8 _; d
      }0 G/ j0 v9 z3 B6 @1 P& U5 n3 E
% @) V2 y4 _% i& i/ J% S" U; Z
# W9 i+ B5 ]' }
      for (int i = 0; i < arr.length - 1 - 1 - 1; i++) {/ |' _9 h2 _  h& A
         //如果前面的数比后面的数大，则交换5 @/ Z! L8 Q/ R6 v2 e& S
         if (arr > arr[i+1]) {
- y8 c9 ?, k* R6 E& X2 K             temp = arr;
; p! @  C$ N) H( c             arr = arr[i + 1];: a5 A: q6 b# h: d% _: I+ w
            arr[i + 1] = temp;0 _# F2 D! w% I6 J8 V0 ?
         }2 v! t5 _' l  T+ Y
      }4 m2 h$ |( a* W: n
  H- U) E; p9 A9 G* q- g
; e' b8 D2 U, _. P
      for (int i = 0; i < arr.length - 1 - 1 -1 - 1; i++) {8 I0 A! C9 U" T7 e
         //如果前面的数比后面的数大，则交换7 ]" b8 \2 j3 L! G/ j
         if (arr > arr[i+1]) {' ]5 I" M5 e" @( w& @
            temp = arr;
/ H5 \5 [, l. F/ c% ~             arr = arr[i + 1];/ m! k* x: e) N5 ?
            arr[i + 1] = temp;
9 F- I/ v, Q; i' q; |          }8 H; G0 Z& A( h* I" w  p1 F9 p
      }*// f4 ]* d# F  A& A7 y
# h& m7 V2 S: ?

- f. O" Z  p, M       System.out.println("hello " + Arrays.toString(arr));
  a5 V9 e8 K* w       //------------------------------------------------------------------------------------
) R/ L4 D( u6 m       //根据上面的观察可以知道了撒，可以再用一套循环解决1 Y! b5 R$ e6 C6 t; _9 k
2 C# D' z# @8 d) x- r7 q, o9 |
+ L! j! O% r5 n$ }
; S& s4 a, R* g" a! i
1 |$ a' F* E% y  Y6 A6 @1 z( F
' U1 |& `5 c( g" @* U
4 o8 o6 w) Q7 ]: p0 u/ n! q
      //好好理解一下、由此可知，他的时间复杂度为O(n*n)) m( Y# w4 C3 m( P0 Q* N7 }
      int temp = 0;
: F+ b1 y( v- b: x
3 G5 Z4 Y7 j# b+ I5 L$ p' l
! p: q% t( `6 P% ~% L       boolean flag = false;
/ [2 I% J) n; y' a+ P8 H       for (int j = 0; j < arr.length - 1; j++) {% q0 U: O" m$ @5 t7 w
         for (int i = 0; i < arr.length - 1 - j; i++) {0 q+ Z8 _8 F& Z3 P4 ~/ \1 I
            //如果前面的数比后面的数大，则交换
. q$ M% D8 |& t4 a0 n9 l- {             if (arr > arr[i+1]) {
- s# x) f) J% W  S6 Z                   flag = true;//在这里把flag值为true
! N5 T, J; [4 ~) M% D9 p                   temp = arr;( |( E; l+ C4 W
                  arr = arr[i + 1];
; G3 N' r: Q* _0 o! s+ M4 m! Y* j                   arr[i + 1] = temp;. J5 v& ?) s! D0 k: e; Z: a% e
            }3 K$ z4 h8 w; g3 Y
         }3 u% o$ ~' ?7 r# X/ e1 p
         //在内部循环的时候进行查询
, F7 w% R' |1 t          if (!flag) {//说明在第一趟排序过程中一次交换都没有发生。9 j  Z# e2 F8 @! i0 b+ O
            break;
7 F0 D7 I& \9 ~3 m) B          } else {
7 {+ _9 c9 Z1 a             flag = false;//没有这个就是执行一遍就没了，要让他进行下次继续
  O# ]3 M- r; K( G0 R! _7 w          }! c+ ^7 O! G9 R6 Y( K9 `9 F- C: l+ f  }
      }5 r$ \, s) ^+ R# l5 e- y
+ o( |; u) t# Z8 B0 X

0 q5 g8 e- w; o" _& J+ \+ K( G       System.out.println("world " + Arrays.toString(arr));1 x+ I  h7 J2 X4 N" x
}
5 G% }0 w# {. o; C}
7 y3 [% A: t( L' |9 k四、将上面的代码封装为一个方法
9 Y& |& i! [- t1 @public class BubbleSort {0 |" P; x/ F$ y! _
public static void main(String[] args) {# `' k) S* l4 R9 ?( @+ `6 E
      int[] arr = {3,9,-1,10,-2};4 j; T9 d# i6 J# k, u0 E) Y

" T2 X# y" |9 }) \  r1 v" S* h7 {7 o1 X/ s, ]3 [8 M
      bubbleSort(arr);
* ]7 |3 U. L# O       System.out.println("world " + Arrays.toString(arr));
7 l8 \2 {. f, t7 x# e; N4 R }
+ y6 g$ i+ [+ c1 }: w9 D" R  ?3 l4 |/ c$ Q7 j' T3 u4 V# e# k

7 }6 N9 u' `3 R& t6 w public static void bubbleSort(int[] arr) {
4 ~/ `: O* `" X+ ~' ]: h       //好好理解一下、由此可知，他的时间复杂度为O(n*n): ?; N: [$ e- t) ~
      int temp = 0;" [5 R1 l3 H% \7 N+ A, n9 {8 B

5 g3 L7 P$ Y, m# [7 e+ P; c
7 |! q; }  K2 [3 ~: f0 {1 C       boolean flag = false;- O) D+ T0 W/ N$ k1 B* L
      for (int j = 0; j < arr.length - 1; j++) {6 B! Y4 ~+ y* m' {* j  q& A
         for (int i = 0; i < arr.length - 1 - j; i++) {0 g( {: j6 |4 M/ K2 c/ v# x  ?
            //如果前面的数比后面的数大，则交换
6 T" s4 X& p5 P1 t2 D             if (arr > arr[i+1]) {' S- O# p" @# e2 g  @! |
                  flag = true;//在这里把flag值为true
$ Q! M* U( C9 Z8 Z' O                   temp = arr;
* ^# g+ T5 |/ F. B# H) S                   arr = arr[i + 1];& k8 z# v  E8 L/ c$ |2 T
                  arr[i + 1] = temp;
6 J: _$ R& X2 L' a7 A) Z             }
, ?1 |/ a: i3 K# i+ `$ i$ E# Z          }% M" ?- t! A4 p# n# s& ?: i4 x0 |
         //在内部循环的时候进行查询
5 g  G& \8 C! D. U* W          if (!flag) {//说明在第一趟排序过程中一次交换都没有发生。
. j5 f% o* V2 K+ E2 x2 `( r             break;3 _- B: N6 y0 O! s% ~; p
         } else {9 o( R1 W: K' N/ ]
            flag = false;//没有这个就是执行一遍就没了，要让他进行下次继续
5 T7 t; _" q" P          }
& _7 |% [2 e4 \# U. i       }4 J' f$ }+ l) y/ K8 U
}% I, N4 L1 X" G9 {9 f6 s5 ~
}1 y' I8 d& z0 ^: U% @
五、测试一下冒泡排序的时间复杂度
1、代码是实现
import java.text.SimpleDateFormat;3 _' C- A. ]0 n* K4 v
import java.util.Arrays;, `1 Z+ ]5 m& i# @% b
import java.util.Date;4 ]9 t  O! @+ q- X# l

) I( c3 b. ~* ?- r9 t8 z  d! S' W  T& W" L
public class BubbleSort {% M( B/ R9 E1 Y9 O1 N: E
public static void main(String[] args) {
0 D6 V# b  M" u2 R$ x) \       //1、创建80000个数据来测试一下我们的性能0 l. d- g  e  v" h# L$ e
      int[] arr = new int[80000];
9 [! @! e' \0 w       for (int i = 0; i < 80000; i++) {
' g4 q- p5 _. q$ S4 ]1 g          arr = (int)(Math.random()*80000);//生成0到80000的数3 H( Q/ {" k* L
      }, F; v2 }0 p$ V* B/ P, M
      //2、输出时间
& p3 }" |, B  M- m# G% Z# a       Date date1 = new Date();
7 M% g  D, k. Y5 I! D6 T       SimpleDateFormat simpleDateFormat = new SimpleDateFormat("yyyy-mm-dd HH:mm:ss");//格式化% A8 b$ Z, R$ d+ P& q& {& R, A  j
      String date1Str = simpleDateFormat.format(date1);
1 ]  n+ i* C: t% Z; C       System.out.println("排序前的时间" + date1Str);, D3 s& G7 z5 }( f% A$ L
      bubbleSort(arr);7 c& q! T: s6 A, D; Q9 Q  X
      Date date2 = new Date();
2 w7 s' B$ x. s7 W! R9 s6 a; \9 @5 t       String date2Str = simpleDateFormat.format(date2);
9 @2 R2 x' G$ c5 M       System.out.println("排序后的时间" + date2Str);0 e1 X, O9 u& ^& p6 J- E0 ?
# R; r% C. {- R4 y% N

, F" k! H5 S* Y* B: E5 A  |6 y$ R5 O( C6 b2 T! u2 k! Z7 R* K; B
  f: W- `7 c* P
}
1 B) o- @2 [& g7 z* o% `
, u  t" G, H' {( `$ f0 U/ r& B& [5 d
public static void bubbleSort(int[] arr) {
: Q0 `6 @' u6 Z9 ~& x       //好好理解一下、由此可知，他的时间复杂度为O(n*n)
8 ?& |8 V" S) o, k/ M       int temp = 0;% n7 K# i8 n; F" [* f# W) ?0 ?
  a: t" A+ k- |' r6 g, x

9 O. j2 o+ Z2 s* ?: Q1 e* U% S       boolean flag = false;# D% Z8 w  M0 q- X0 j
      for (int j = 0; j < arr.length - 1; j++) {
, F, ?5 ?6 s  Q4 ^          for (int i = 0; i < arr.length - 1 - j; i++) {' o  i$ a: N: V: m# P
            //如果前面的数比后面的数大，则交换
9 m; J) l, d4 t( v- e, l% q             if (arr > arr[i+1]) {- U- V# W0 `" B, ]6 G
                  flag = true;//在这里把flag值为true: n8 [& q+ x" U
                  temp = arr;/ X) K: N: v) _0 Y8 a( W. R
                  arr = arr[i + 1];
+ m( E3 G9 u- F" m                   arr[i + 1] = temp;
0 S+ x8 K, l( `: M2 }             }
/ b# Y) f7 L$ L  N" _          }
. F0 X0 w+ Z. O3 j- R, H0 j          //在内部循环的时候进行查询$ Q" t3 A3 _! ?9 g
         if (!flag) {//说明在第一趟排序过程中一次交换都没有发生。
( [; F. n1 X  q  w' {             break;
. P/ k0 {6 F9 U4 Y7 E          } else {& H# u0 A) [  h: D/ L9 i
            flag = false;//没有这个就是执行一遍就没了，要让他进行下次继续9 ]$ T( H; ]/ e- E5 E( b, }* T' V8 X( m
         }$ `4 |% d1 j: ^  p" H, r4 `, Y" c
      }) _, z3 I& O# w( x
}+ D* \+ y8 v: h0 j4 b9 R. B3 j
}0 M+ G% o& Y' d

5 q- G* a5 B* }" ^
1 V, d2 E* _& f. H& \$ b
4 |4 |$ U3 S( [0 E& a  x7 j0 u3 ~2、效果; `% W- I& K* H; b! B4 i
4 E: [" z5 Z9 V4 g0 b- W

( G* i% \, ]* b, d  `, d
# l/ C+ g8 ~- N& c3 n3 S8 j4 v
& P7 v: T4 N6 S# i; ]
- u8 d5 n3 s1 {* i5 w