查看: 3511|回复: 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]) {. i* [  r; N4 b1 S, H
      //             temp = arr;
% s9 P! K; c1 i       //             arr = arr[i + 1];7 |+ b4 r7 [# i+ C
      //             arr[i + 1] = temp;* K, @" r  s3 @0 W9 ]9 n7 Y
      //          }
* N4 x  C, t' i       //       }
3 Z1 ~% k* \& A) F8 v; |" o1 h       //2、第二糖就是把倒数第二大的排到倒数第二位
0 t* w; g: Y% V! H$ s4 ~       //  for (int i = 0; i < arr.length - 1 - 1; i++) {
- `$ c/ D- G' I1 v4 j/ b       //          //如果前面的数比后面的数大，则交换* h1 x+ W- B# Z0 `' J
      //          if (arr > arr[i+1]) {
) j* L% Z% _7 _6 V) e       //             temp = arr;4 W  ?6 Y  _* N% H
      //             arr = arr[i + 1];5 E* N& E  H% C. u: E) {$ l
      //             arr[i + 1] = temp;
2 R! d$ \3 ?+ ]2 w$ ?       //          }
+ Y) P& f! }7 P; L, V       //       }  k3 t( i$ G. j7 ?# Y9 }
      //3、第三糖排序，以此内推
! f9 V$ S( G9 p2 z5 ?! X/ ~       //for (int i = 0; i < arr.length - 1 - 1 - 1; i++) {( t: n6 }- w) S, c0 u
      //          //如果前面的数比后面的数大，则交换
) N% H/ p( I1 r7 n. D# U       //          if (arr > arr[i+1]) {
1 [- G' [( D) k" n- B       //             temp = arr;
3 r: q3 |* Z" }" V% b: J5 K5 v7 T       //             arr = arr[i + 1];; h2 \( V# W8 F1 T. Z/ V. f
      //             arr[i + 1] = temp;
: B! B  M! M5 h: W9 v: C       //          }- s/ v+ V1 i: `1 ?* }
      //       }3 C6 ~) D$ |2 H% V- w6 B4 o
      //4、第四次排序，以此内推1 z$ ~- v. x9 o3 h1 V
      //for (int i = 0; i < arr.length - 1 - 1 - 1 - 1 i++) {
' f) Z' q" s4 N) j% Q: v4 ]       //          //如果前面的数比后面的数大，则交换4 U  d6 z! d; ]
      //          if (arr > arr[i+1]) {& ?! p3 d9 d2 q
      //             temp = arr;
! K2 B; r% N3 z* u4 \4 \9 i       //             arr = arr[i + 1];
9 N4 U6 M0 R& U# Z  p       //             arr[i + 1] = temp;  A/ K& A+ l3 L
      //          }2 @5 s# C8 }  E& l  n- V
      //       }
2 H0 T8 M5 y( u8 C+ e8 N       int temp = 0;//零时变量，用来将最大的数值排在最后
0 C' G; l* M. r: p# j. o) O, T) T       for (int i = 0; i < arr.length - 1; i++) {
7 J0 [8 Z# a3 h, n$ q: E          //如果前面的数比后面的数大，则交换' Y8 n3 Y: d# {# S
         if (arr > arr[i+1]) {
0 C* K% g3 {6 C: [1 b" _             temp = arr;( w9 D4 B7 A- h  X2 K+ x9 @
            arr = arr[i + 1];
; r! \: j9 t9 A" a+ Q: q! e             arr[i + 1] = temp;
, l1 N' b" J3 p$ G; x          }
; A; }+ \; O1 j1 e3 [       }
2 I$ s0 l# K8 w, N& i8 l+ O8 v8 J0 R9 D* J

0 E  W" _7 f) p2 j9 i8 I- N       for (int i = 0; i < arr.length - 1 - 1; i++) {
2 _5 ~8 b- R# y& G/ O& W          //如果前面的数比后面的数大，则交换! J- I8 m  R" I6 `" q
         if (arr > arr[i+1]) {9 a" J) V# h3 n& T2 f. K
            temp = arr;; N$ K2 S* g/ n! s3 S0 H- `
            arr = arr[i + 1];
& v6 X, j$ e+ a+ E             arr[i + 1] = temp;
( k1 S7 D- a" Z          }
4 \3 F  r# l/ a6 t- G8 M       }
8 T0 n, N- m+ b, V- f3 [2 |# U; n/ |( ?3 S% U! V, g' b
% ]- X5 z$ {' N% F7 f5 y% f, o3 L
      for (int i = 0; i < arr.length - 1 - 1 - 1; i++) {
7 m# [: l7 z. x1 C( n- }          //如果前面的数比后面的数大，则交换3 t9 i8 ?$ ~8 }, A! ?
         if (arr > arr[i+1]) {3 V4 E  V% ?9 B; v" f+ j- p  K
            temp = arr;* [' x7 C1 c. K1 R
            arr = arr[i + 1];
) u+ S$ p* u, z1 `, T: Z6 o             arr[i + 1] = temp;3 J' n/ A/ X: t4 u( ~
         }! N. I" }% T& R5 j! ~: f* L) _
      }  y; \- g! U4 n
: i5 w/ [# ]1 ^
5 z: T0 S2 q: g9 s' i8 k3 J
      for (int i = 0; i < arr.length - 1 - 1 -1 - 1; i++) {
+ U' G$ {% F& J+ D7 q          //如果前面的数比后面的数大，则交换
0 y! E& }: G& ?( j          if (arr > arr[i+1]) {
" @& ^1 `; y3 p- C; |             temp = arr;
* F/ r( ?1 {+ k& h. d             arr = arr[i + 1];
$ T, D" V6 Y$ ~5 N3 M             arr[i + 1] = temp;7 A: y- Z# T( T, P/ d# ?
         }' t. K3 c: J% f3 |" C  W
      }# \& P5 G! d# u& H% e; J
9 N6 h6 W# n+ r- |/ J  c
3 E9 k- U2 [; q% H
      System.out.println("hello " + Arrays.toString(arr));
0 P7 s7 R* L; Z/ E* W       //------------------------------------------------------------------------------------
2 W: P, T) Y7 z( v0 k       //根据上面的观察可以知道了撒，可以再用一套循环解决- W0 d4 i! k: M: ~4 L9 y

  U2 k8 `+ g/ J* h/ g
3 L: T5 y# J! Q# y" \) |' a. _; _9 D. j/ K6 f
3 a" @" z" @, I; d2 J2 q, T
      //好好理解一下、由此可知，他的时间复杂度为O(n*n); U0 a" q1 g! l" S
      for (int j = 0; j < arr.length - 1; j++) {
# }, C" S' l) y! O. _. ^0 }1 u/ z- |          for (int i = 0; i < arr.length - 1 - j; i++) {- X8 A6 z, F% O# A4 v. Z
            //如果前面的数比后面的数大，则交换
+ t. @9 z0 w# \+ F0 r             if (arr > arr[i+1]) {% U# z" B" X# ~% F4 c
                  temp = arr;4 g+ A1 T1 ~9 _
                  arr = arr[i + 1];
" [, b' j( N% H9 f. P                   arr[i + 1] = temp;
* g" E) u% p- d) `0 k             }
6 P0 S' n  C1 Q, n! w          }- r2 C9 i, x# ~: Q
      }
1 F2 `1 ~+ \9 v1 g8 \$ A* z* j }
9 Z  k& t( `% z* g# M}
! v& t& e% V+ o6 }3 l三、冒泡排序的优化
1、思路) m/ P7 {' P/ }$ k! Q9 s, }
如果我们发现在某一糖过程中，没有进行一次交换，提前终止& C$ Z+ `7 I* x$ x% e8 ?
2、代码实现
package cn.mldn;
( Q7 ?) w# I, P8 c# Z6 `& C4 N# h+ J' ?: y: D

1 ?! {( F# r" X1 M% X. Aimport java.util.Arrays;
  V( A# h6 n5 I+ h- H
3 b' ]; T9 d- Q/ K: f1 L9 S  k( r" q' n$ {4 d- |
public class BubbleSort {. j: q' r' K$ v2 s
public static void main(String[] args) {
7 ^; ~( [2 F5 i7 l       int[] arr = {3,9,-1,10,-2};
' [( H# C" a; ?$ b8 w) V: ^) x       //大致过程
' {$ c% o. ~+ N* j/ x- c6 x6 Z       //1、第一步就是第一轮排序得到最大值于最后6 K' n7 P8 U, B( E; t4 i5 S' I( |
      //  for (int i = 0; i < arr.length - ; i++) {, P* h% ?8 l! M2 Q) K% J# K
      //          //如果前面的数比后面的数大，则交换
$ ^( Y, R7 M. \0 v/ Z) R       //          if (arr > arr[i+1]) {
& p& f* ~# ~" s# I+ ^0 h8 L1 |       //             temp = arr;  ]0 i* Q/ g; }
      //             arr = arr[i + 1];
! ^$ \3 `  l/ X2 v       //             arr[i + 1] = temp;' X9 W# q" ]: Y: D8 L
      //          }
9 s& b6 w% k9 t. X* K# s* x+ w       //       }0 \  S+ l/ Z, B+ q' i% ]& @& D8 {
      //2、第二糖就是把倒数第二大的排到倒数第二位2 t& }  w) s1 O! e5 P, @, H
      //  for (int i = 0; i < arr.length - 1 - 1; i++) {
6 o2 K; o1 H1 k0 L" J9 {4 m       //          //如果前面的数比后面的数大，则交换
2 x: ^4 d' W2 S5 _8 c2 d       //          if (arr > arr[i+1]) {+ \6 ?2 z' ^- r* c3 t8 @
      //             temp = arr;& v5 m! h) @/ y3 |% U9 W# E7 f4 |
      //             arr = arr[i + 1];2 l: p7 \1 B3 ?  G8 _7 j3 Z
      //             arr[i + 1] = temp;
7 x7 b  w: ~1 L: [) q$ g% {       //          }% Y$ }! l" p) D/ |
      //       }
& B0 R; [8 q' }( t/ [       //3、第三糖排序，以此内推/ X, o, N7 L0 E' L
      //for (int i = 0; i < arr.length - 1 - 1 - 1; i++) {
/ p; [8 u/ _' C6 |( v5 d( I. ^6 \       //          //如果前面的数比后面的数大，则交换
# \4 P. g$ V7 G: y) }. I( K       //          if (arr > arr[i+1]) {
  p% O$ T$ x3 c2 g5 @       //             temp = arr;6 ^9 y  M3 G3 x
      //             arr = arr[i + 1];# n# V- G8 ], ^
      //             arr[i + 1] = temp;
& L3 F+ g3 D% X, j5 d" E/ g       //          }. M' D6 a+ \/ X% J1 x4 O
      //       }
" D. l0 n. ~6 w7 o5 L       //4、第四次排序，以此内推$ T2 V' d9 }0 ]" O- t) [/ B1 H
      //for (int i = 0; i < arr.length - 1 - 1 - 1 - 1 i++) {
4 Y" ]. N" m3 G: p+ X! @       //          //如果前面的数比后面的数大，则交换
& ?% m% R9 a. B       //          if (arr > arr[i+1]) {
7 b! r3 g5 T/ [5 l" u0 X       //             temp = arr;
* v9 _0 D0 x  L9 {$ T# f# \) Y( ~       //             arr = arr[i + 1];
- @* D" ~! s6 {+ f1 @       //             arr[i + 1] = temp;, ^* g5 G5 |  |4 Z1 ?
      //          }" P( p& F$ w7 M3 K7 |
      //       }/ m/ m2 \  k, @2 L6 Q! f, V
      /*int temp = 0;//零时变量，用来将最大的数值排在最后
  w* W$ j8 Z' R5 [# N: F* x% n       for (int i = 0; i < arr.length - 1; i++) {
& N* p* p, ~2 O6 L7 y          //如果前面的数比后面的数大，则交换0 `4 `+ Y/ V, x
         if (arr > arr[i+1]) {
4 P& E, @3 \& ^- i             temp = arr;% _" ~- o1 O1 _, R, M
            arr = arr[i + 1];
; L5 J3 }# d) l             arr[i + 1] = temp;% O; \9 ]( R0 q. |8 ^- A
         }$ Q. k' I- I2 K) K& e, ]
      }
; k; m6 o$ D& U7 b5 K
: }1 ], C0 c) J1 J0 A! J3 E# y" l7 c8 j+ E3 Q
      for (int i = 0; i < arr.length - 1 - 1; i++) {
( p2 A3 `2 F) B8 w. I- ?          //如果前面的数比后面的数大，则交换; v+ B) `% S1 d
         if (arr > arr[i+1]) {" L. |7 Y. |; [' P
            temp = arr;0 T( C! c9 l+ D4 o
            arr = arr[i + 1];" X/ t6 W# Q, {+ s& j0 _" _
            arr[i + 1] = temp;
7 n+ L" N7 J  r! F9 I: v: F, X3 l; }          }/ r+ V4 o8 y! j/ K
      }1 F8 [& i; y$ {0 n( q
5 E% {' o- F4 [& S. l

) c, {# k1 J2 J! ~: K6 G       for (int i = 0; i < arr.length - 1 - 1 - 1; i++) {: W! s7 }9 |6 z0 H) C( M
         //如果前面的数比后面的数大，则交换
1 m3 }6 p2 ^8 G* {* M- e) J9 y          if (arr > arr[i+1]) {
& y8 l  {( s+ ^. y) `" ~             temp = arr;: \3 w4 h; w$ r
            arr = arr[i + 1];
4 n  R* x+ D1 N$ j: B! V             arr[i + 1] = temp;
' a$ K! e! x' Q          }
9 R+ s: I5 A0 y1 u( H       }
& o% N- a. `9 {! E: |! K' P
$ Q% \8 K# {7 V# L/ k$ ~, h9 b2 X: `( x/ b
      for (int i = 0; i < arr.length - 1 - 1 -1 - 1; i++) {
4 ]# q# s5 o" |: C  `1 \          //如果前面的数比后面的数大，则交换  ]# O, G4 q- j; e* Z6 h
         if (arr > arr[i+1]) {% {# e3 h0 F( u( C  D; G2 i0 `
            temp = arr;+ u  H9 g9 a8 f6 J6 f+ _
            arr = arr[i + 1];
1 _/ V" k) R- U1 _             arr[i + 1] = temp;
. g' L0 ?; L% E1 f          }3 `' t3 w. Q+ ~; r' x' ^; o- x
      }*/
" L& z/ `, T) f/ M9 z( q
1 S# ^; j* K0 w4 x" w# y$ H0 Z" u* \% h  T
      System.out.println("hello " + Arrays.toString(arr));
& o, E& g& h. X, X7 P# R       //------------------------------------------------------------------------------------
6 y9 w% V  P/ k       //根据上面的观察可以知道了撒，可以再用一套循环解决+ Q* x" b, x" w  r' k" k! g" ^
8 g7 q8 X) d1 {
" v+ l: |( S* P* b6 h0 J. o
5 Z0 A) m! Z. I

0 i$ X1 H5 m# X5 W( ]% F& s6 |/ W- L: U# t3 t

4 m' q: Q& Q3 C! s# m       //好好理解一下、由此可知，他的时间复杂度为O(n*n)$ B5 @5 t; l& G. T
      int temp = 0;
5 D7 B& n, z- J+ a, o$ y7 l, D

7 _" h6 V  I3 V( D( F       boolean flag = false;
# _+ N5 U5 w! g1 |* d. A       for (int j = 0; j < arr.length - 1; j++) {' J( ^7 q# |; x3 U# m2 ^
         for (int i = 0; i < arr.length - 1 - j; i++) {; S; y# j  Z. D7 y1 i, Q- d5 x
            //如果前面的数比后面的数大，则交换
* K' a  }: L3 v/ D- J% m) q1 n             if (arr > arr[i+1]) {3 p0 W" d% r8 t. P9 R8 f+ U
                  flag = true;//在这里把flag值为true
1 U8 M; g% e6 {- K                   temp = arr;
+ a8 x; m% t/ j4 ^. i- u                   arr = arr[i + 1];$ |  @* p0 A7 {5 ~
                  arr[i + 1] = temp;
# H8 k% r/ B% W6 }* h- D             }
8 i" P6 i$ H& d* X5 s          }6 y6 K. J' e2 K, m, z
         //在内部循环的时候进行查询! ?+ R9 t4 l: Z* `! B
         if (!flag) {//说明在第一趟排序过程中一次交换都没有发生。1 p# h! g- K) s+ O
            break;) u& i7 E/ y$ L4 K9 S) I4 H" i
         } else {, J' r# \5 D) M& k  g
            flag = false;//没有这个就是执行一遍就没了，要让他进行下次继续
9 g4 A, k7 H& z/ d          }2 F7 W0 p* ]" e3 m- E
      }* `" b8 E( |" u7 I5 P1 o1 {
% E; o' k3 \# O  N
" x4 V. x. l0 J; k  `
      System.out.println("world " + Arrays.toString(arr));9 i) g7 U' X* l1 ]; l
}7 G7 H8 X8 I3 ^$ X4 R, g, y( w
}
0 _/ B( K4 F. F# H! [3 r四、将上面的代码封装为一个方法' n5 @9 O  V; g  m3 _
public class BubbleSort {
  t' V0 [% _' [ public static void main(String[] args) {/ F( Z, {6 j7 X( G) i& n, @: z1 z
      int[] arr = {3,9,-1,10,-2};+ W! z$ k, @( I6 y

$ `9 R3 c( T2 s2 H
3 t" q  [$ P3 z9 X" N$ T; g       bubbleSort(arr);, g" |" \7 Y& _; _. h* B
      System.out.println("world " + Arrays.toString(arr));
# V0 u* H3 }# v, s }
2 C( I" L6 u, b. [' A# ~
9 E2 ]2 F) `6 C' t1 h4 \# x( M8 Y4 L* O7 ?. q# }# s
public static void bubbleSort(int[] arr) {$ \4 J/ H" j3 X& U5 b; }+ j/ D  X' q5 F
      //好好理解一下、由此可知，他的时间复杂度为O(n*n)3 Q* T' J7 \/ E
      int temp = 0;
8 @0 F4 p+ k% V$ w, {8 G6 m4 W# t5 Z: t7 V7 s1 P4 N# G9 K, d
" F5 c& M! ], x& t) y7 ~' \
      boolean flag = false;3 L$ s  K+ w* k4 ]0 e* [2 `
      for (int j = 0; j < arr.length - 1; j++) {; ]: L, R7 |  K& E' v1 _+ g+ F& g
         for (int i = 0; i < arr.length - 1 - j; i++) {+ T5 c+ ^3 \: k4 ]
            //如果前面的数比后面的数大，则交换
: S2 b( ~7 S$ d& G9 t             if (arr > arr[i+1]) {
$ A# y: G2 k9 H, H                   flag = true;//在这里把flag值为true9 P- @/ W& w1 ]! g/ B5 p& I
                  temp = arr;+ ^9 G9 W1 u# h( D7 o
                  arr = arr[i + 1];
4 i  ^/ A9 m5 T: m: y                   arr[i + 1] = temp;
6 {* l( w) D7 i( B! F( c2 ^: z             }
# }- K$ c, F5 m% G          }
0 ?2 Q, Y. ?( o8 X8 Y" M% ~, K2 J          //在内部循环的时候进行查询$ q: W! Z* z1 X# l: p' h. ]/ e4 m
         if (!flag) {//说明在第一趟排序过程中一次交换都没有发生。3 M$ I  q9 c6 ~- c/ j
            break;# T4 m2 r9 F. o" H7 ?
         } else {
, S/ |# t2 A' D& P+ a             flag = false;//没有这个就是执行一遍就没了，要让他进行下次继续" g  a2 Q+ s' E( L- }+ {1 w
         }
7 u7 d0 M7 H! `5 g8 [: U: T       }
+ Q9 f6 |. y& g# F$ M3 p# b# ~1 O9 q6 P }5 @$ L1 |& J+ c* |5 t6 T' v
}$ w- h& o: h$ C* x4 T' R" f0 u% p
五、测试一下冒泡排序的时间复杂度
1、代码是实现
import java.text.SimpleDateFormat;
: i/ \$ ?: m% eimport java.util.Arrays;  @, ~( O, e7 y) g* j
import java.util.Date;) _% _, }% r" w& t& c7 ]# \3 Y! @' F

) E- ]( o; S6 K& G. w/ O  L! C9 X$ _7 ?: g) G0 |7 G2 `9 ^
public class BubbleSort {" @& y9 y% V/ g
public static void main(String[] args) {$ c8 G% `) A0 c2 \* V
      //1、创建80000个数据来测试一下我们的性能$ F5 L; X2 d) K0 ~- n' `+ i
      int[] arr = new int[80000];
& @0 r: M1 J# q: p  M+ J       for (int i = 0; i < 80000; i++) {
) ]2 |, n1 Q9 `) r          arr = (int)(Math.random()*80000);//生成0到80000的数5 v3 Z. {1 \, Y7 q. u7 Q
      }
: @# z. b4 Z/ p       //2、输出时间
: Q7 m4 L: Z" E       Date date1 = new Date();# L" J% m6 X; ^7 J+ c, ~
      SimpleDateFormat simpleDateFormat = new SimpleDateFormat("yyyy-mm-dd HH:mm:ss");//格式化
/ Z# ]. p* ~6 c8 @) z4 N0 d! T2 R       String date1Str = simpleDateFormat.format(date1);, F9 c9 ^+ q  W: B# n
      System.out.println("排序前的时间" + date1Str);- r7 N3 M) P0 D, J
      bubbleSort(arr);! x9 n$ R. D/ T5 Q9 H1 k4 ^
      Date date2 = new Date();
- S  [0 M3 ?+ p6 b/ k( A7 _       String date2Str = simpleDateFormat.format(date2);# U$ j! H7 S) J+ I
      System.out.println("排序后的时间" + date2Str);1 e# _4 x* I5 p
" N2 u& p, K! o2 Z$ C

9 C, O: H+ |/ T( n% d
) H1 p: y5 u8 k" F0 a
/ Y2 H3 G+ o  T& P0 f }
& K, K7 P: e- m* I& ?4 m/ {% R; w. T) t/ ]
; a3 _7 Q0 T7 `; z
public static void bubbleSort(int[] arr) {5 U8 f8 R) $ `  k
      //好好理解一下、由此可知，他的时间复杂度为O(n*n)
1 y- A+ [( C" Z# c       int temp = 0;
2 F& z, j2 z& z8 t  ^6 A; q6 Q* \* @' f1 l9 r9 G- ~
. E5 C& G% _" O
      boolean flag = false;
" i$ w+ \# B0 c, C6 E$ T. \, h       for (int j = 0; j < arr.length - 1; j++) {" U2 L* Z  E5 S. j+ Q( E
         for (int i = 0; i < arr.length - 1 - j; i++) {( h  i) T2 J% a# R6 w; $ R
            //如果前面的数比后面的数大，则交换9 b% `. G* _) g" W
            if (arr > arr[i+1]) {
1 m  b7 r9 z7 Y" ]                   flag = true;//在这里把flag值为true
! `( ^4 S0 I9 m. X" M/ p                   temp = arr;
  ?" k. K4 L/ L& w8 s                   arr = arr[i + 1];
6 |( \7 _& H" A, w2 O# @$ @/ ~0 b. _                   arr[i + 1] = temp;
% L* \& p" o5 [/ {             }
, ^/ |. }5 t/ U% V          }/ W% ?) Z# }9 s0 o% r9 x
         //在内部循环的时候进行查询
$ x. F* z7 _$ b2 `& Q          if (!flag) {//说明在第一趟排序过程中一次交换都没有发生。. X/ a8 Q& o1 n$ K& D0 U
            break;. Q/ v$ H, [; {/ [2 ?: ?0 ?
         } else {
/ j6 z7 p5 K0 Z- X             flag = false;//没有这个就是执行一遍就没了，要让他进行下次继续
( U! C4 W! w2 }  E          }7 s4 L+ l" W8 U6 q& s5 x& d3 P
      }1 c/ a( j# t1 y& i0 \
}* ^, H5 N3 l4 m* N
}9 P4 S" ^# D3 U$ w$ K

( ^0 j1 \- P. n( ]# n8 i
  O) h4 u8 P2 ~# ?. L
- t  k+ u9 ], g: D2、效果
7 i5 e' J- Y) Z) A1 z4 C  ?2 ?! i

+ d7 [, _" C1 p' F) e% n" o4 H: [0 c( ^8 m6 ~: C4 m3 i" Y
& ]% j, u: h' P9 \, K

: O8 H* c% I) F7 ?4 _2 h