* |2 {; S+ k/ \& J; p- R; Avoid swapTwoInts(int &a, int &b)) }" G5 X# e$ }) U
{ % U- C( d, ^1 e5 y+ q int temp = a; . b' d8 K. R/ L1 Q+ ]' o2 w a = b; " I; [5 ^5 w- O7 z9 K! m5 t7 [ b = temp;7 g k/ N" ~1 D! e3 l
}4 c/ @- y$ L2 F# t- d' \' R; I
1 & I3 Z p" ]% m5 R0 `2 1 b, l$ F! O+ A) V) r' K) i3 1 j' B( i3 z8 a) w' _* E2 `/ x4 1 Q) Y- e, L. P5 6 W: N( C) R' ?* P6* f" D- U1 @' z, ^0 j& T) ]
2. 线性阶O(n)6 l6 T; E0 U5 ~& c- u
* X3 P2 l8 ]' N8 b
在下面这段代码,for循环里面的代码会执行 n 遍,因此它消耗的时间是随着 n 的变化而变化的,因此可以用O(n)来表示它的时间复杂度。 ; C6 O4 @9 v/ l6 X5 ]! C4 E+ v $ u2 m& [" R4 g4 i! xint sum ( int n )3 C; S; |* j/ N' @" Z9 B* u) K
{ 2 Y+ k8 m! u" S% Z8 z/ m: L int ret = 0;, A q8 ]) ]( s( e
for ( int i = 0 ; i <= n ; i ++) 2 M. G( `! q& j { - E. ]5 k8 H* [/ }0 K& h ret += i;1 y" z- s, e5 E a) j( T
} % G3 ]# U; m/ |2 l) g) h) ~ return ret;. v; i- N5 H. t$ [6 M! w8 `# Y
}. W q* ~9 d v+ W
1* S& s2 S3 I# N( e8 \
2 & {6 g4 K2 R6 z1 p. }" o3, L0 m+ O) E8 c+ a/ e O0 L* h/ m
4 . a: L6 ~1 C3 I# r$ Y5 5 T, E, @0 t4 _; Y9 s6 % e" D: P3 Y! e- i* f) ` i7# b! _1 Q/ B. d
8, ?/ {% Q# p2 B% q Y0 h
98 t# z6 ?0 X: s" e' _
3. 平方阶O(n2)5 b7 h4 v( P% @+ u& r
当存在双重循环的时候,即把 O(n) 的代码再嵌套循环一遍,它的时间复杂度就是 O(n2) 了。( t4 _* @/ H0 p$ J7 w6 W0 D& B
7 \" L1 q/ `0 [1 N4 Q" ?, I$ g2 d ; A! E( n. o2 w8 [ g. k% C# N8 \void selectionSort(int arr[],int n){! i' [, |* j: Z9 R( J) l: S
for(int i = 0; i < n ; i++){7 U5 t8 Y |/ Y% n
int minIndex = i;# j0 F! A8 p$ Y
for (int j = i + 1; j < n ; j++ )& m; E$ @4 |1 z
if (arr[j] < arr[minIndex]) 2 C7 u5 |" F( O' ~, @' s7 i/ D( I7 { minIndex = j;6 l9 _/ S/ b7 P3 ]: x
swap ( arr, arr[minIndex]);" e/ M; L, f' w' d) q0 ?/ \
}8 L s# ~2 Q$ }! o o/ @
} # w. G+ I0 O* _- p1) M) E3 i: S7 _4 h, o
2 z8 c5 q0 x7 ]6 N3% P6 x' Q( d; u- v: W
4 9 j o5 R" a8 V& k5 * {- V# S0 @, b8 `# a, v6$ x ]5 k5 y# E, u2 W0 k
71 J" M9 P1 _' ?2 o2 E( G6 i8 F4 k
8; l [! G! }0 x \# s
9) w4 J# B; }. r/ {0 L+ a" G3 H: v! w
这里简单的推导一下) c$ ~4 |2 F% `" v% {) d
' L) K- A8 h1 O: |当 i = 0 时,第二重循环需要运行 (n - 1) 次 ( B5 C0 a8 ~9 ~2 ]/ h 7 ]* L0 A+ e& T: v; V! X当 i = 1 时,第二重循环需要运行 (n - 2) 次 8 ~. T, H+ V$ s$ C( v- ] 0 a/ J ^; m6 i4 q! |。。。。。。+ K7 ^* r" u# M" p& B
' B3 R+ Q' Z8 h- f6 F; R7 m, V
不难得到公式: % W9 B3 f# q2 ^& z+ j$ g/ O& H& C. b1 s w( A% f
(n - 1) + (n - 2) + (n - 3) + ... + 0 8 W! {9 M h# ?3 P9 s/ [! {" Y= (0 + n - 1) * n / 2. V( q3 n: V* ?- T7 i9 \: R( M
= O (n ^2) % Y7 v* J9 x% X H9 V6 ~) c1* l X* ^& w7 N# `2 B
26 I0 P( G7 H7 _; j, L) u% S
3 ) O" K; T, D; t9 n/ E5 h' x3 S: s+ o4. 对数阶O(logn) ' ?; {. w2 T' c # D% z0 L2 X- k4 { d M! N# ]5 I, J+ j3 Z! I
int binarySearch( int arr[], int n , int target){/ O8 w% ]9 g7 I
int l = 0, r = n - 1; : o4 K" v( ?, U9 J4 _. |9 }* S while ( l <= r) {# T" u, g* M5 M0 k
int mid = l + (r - l) / 2; s! }( ]1 i! ~$ O! b( S
if (arr[mid] == target) return mid; % X$ }) @# I W9 M; _" W3 m if (arr[mid] > target ) r = mid - 1; 1 S/ E% K* f0 i7 q. n else l = mid + 1; 7 N2 b1 R% ]5 M# r } * p) P( Z$ C: y% H return -1; + P! S0 N# d) q}4 g/ P# H! ^* t; `; n5 M
1! W. D* q' u$ N5 Z a4 E
2 $ s/ W: z! r( Z+ E p3 S% r, j3 0 g9 H. j& M ]8 @; c4$ ?$ P' A- e( F5 U6 ~
5 - H b0 X( h: p1 M+ r6$ [! ?) ^$ G* O4 N0 D. E7 }; k' ~( d' W
7 2 n7 ` Q: G+ _+ h S' u8; Q9 ~& k7 P7 r: s. Y4 }
9 4 V7 o7 h, m b$ U10 : R$ R! r6 o. u# N( O在二分查找法的代码中,通过while循环,成 2 倍数的缩减搜索范围,也就是说需要经过 log2^n 次即可跳出循环。$ @* B; d) k* v- o
- N, g3 x. C8 l' O五、不常见的时间复杂度 ! S- E# j9 ^9 R4 e. p5 _1. 最好情况时间复杂度(best case time complexity) 5 E; y- K2 B" }" I! F2 q: m最好情况时间复杂度就是,在最理想的情况下,执行这段代码的时间复杂度。在最理想的情况下,要查找的变量 x 正好是数组的第一个元素,这个时候对应的时间复杂度就是最好情况时间复杂度。1 p) S' o9 x9 K, g
5 @6 l% T* \5 g+ A% q2. 最坏情况时间复杂度(worst case time complexity) & O6 B( C, d4 f! Q. {最坏情况时间复杂度就是,在最糟糕的情况下,执行这段代码的时间复杂度。如果数组中没有要查找的变量 x,我们需要把整个数组都遍历一遍才行,所以这种最糟糕情况下对应的时间复杂度就是最坏情况时间复杂度。 3 k' u D- _' x1 Z* c1 j$ C' ~% d6 o9 b9 W& [. U$ D
最好、最坏情况时间复杂度指的是特殊情况下的时间复杂度。- G' E. ~7 k3 f! k: y: S
动图表明的是在数组 array 中寻找变量 x 第一次出现的位置,若没有找到,则返回 -1;否则返回位置下标。 ) \0 L# E2 Y( c0 p2 U( h8 C, l0 L: B8 V% _& ^8 l
int find(int[] array, int n, int x) {# n% g8 ]( Y% e9 k' t) S8 ~2 a
for ( int i = 0 ; i < n; i++) { & @/ E/ c0 [" ~/ }; Y* f0 T& W if (array == x) {6 h2 @0 }: ]6 S' O
return i;& X9 A7 }4 R+ [- Z5 c
break;7 j* M0 M1 {! M; F/ ?) }
} 8 f# K- g, N# ] }* E' @7 j$ I1 ?: g' o+ M; F
return -1; & g6 _9 Y) l# ?+ l1 B2 P} % F; {* y/ m+ K. f1 # V2 L' q' f0 l$ |28 {6 X$ r, R s& @
36 E! P* {* ~, [% D
42 U1 s% V- v' \
5 : m d( `& c1 q j1 ~6 . O0 {1 n3 Z( S- K6 i, O8 ]2 Z7 ' M. ~' L3 H1 k% P/ X. V87 B+ V9 _3 u: U3 o& H
9" j i, H7 A# b2 W% B" u+ M
在这里当数组中第一个元素就是要找的 x 时,时间复杂度是 O(1);而当最后一个元素才是 x 时,时间复杂度则是 O(n)。$ I' o7 ?- A9 L3 [6 Y$ u/ g! d