【零基础学Python】常用的Python 算法示例代码

admin

【零基础学Python】常用的Python 算法示例代码


" l. u+ |* `1 a- [4 {
Python 常见的算法可以分为多个类别，包括排序算法、搜索算法、图算法、动态规划、递归算法等。
% w6 b3 y. c+ \5 ?, E$ V. @( d
8 ~* I$ l% r5 z0 u) R5 Z/ L3 b一、排序算法
6 @# }+ R) P  f* @" p9 i- H1.冒泡排序（Bubble Sort）：
原理：冒泡排序通过重复遍历待排序的列表，比较相邻的元素并交换它们的顺序。如果第一个元素比第二个大，就交换它们。这个过程会重复进行，直到没有交换发生，表示列表已经排序完成。
# {  v; P$ s9 c) l! @" R- c1 i
5 T: N7 y0 ]- }  Y- u( r( s时间复杂度：最坏和平均情况下是O(n²)，最好情况下是O(n)。

9 f1 V/ j8 [$ k3 r3 d1 K实现：

# coding: utf-8
def bubble_sort(arr):
2 g' @" d; |; U7 a8 E" d3 k9 ~  H( c    n = len(arr)
/ u8 b1 }: [% j$ r6 m- H    for nu in range(n):
( K4 R8 W0 M4 Z! [* C8 y; E        swapped = False
( o3 t! [7 p8 g# y  Q        for nu2 in range(0,n-nu-1):
            if arr[nu2] > arr[nu2+1]:
$ c$ x8 G) P- f! E- j1 X                arr[nu2],arr[nu2+1] = arr[nu2+1],arr[nu2]  #"""交换"""
3 @9 ?5 ^5 g6 ^0 a2 C$ v4 X                swapped = True
' q4 P, @" I. T) k5 E        if not swapped:
" g0 g- y1 g' P. l) ]" x            break   ##如果没有交换，提前结束
9 f. @  Q  a2 Q2 b    return arr
8 t  m4 ~" O! r5 n9 S  X0 u" \) T


示例：
8 M" X4 f' L* `( u/ U6 L" fprint(bubble_sort([23,65,28,12,29,10,70]))结果：
. F# S" A9 y9 l+ {[10, 12, 23, 28, 29, 65, 70]
. N8 w4 W% O# e8 o



# M( T( t8 W7 P% X

2.选择排序（Selection Sort）：
原理：选择排序每次从未排序的部分中选择最小（或最大）元素，将其放到已排序部分的末尾。重复这个过程，直到所有元素都被排序。

0 s9 t: M) @) X! C" c& Q9 a- c$ q时间复杂度：O(n²)。

! y" @3 ~" O1 `* I# Z6 [! t8 x实现：
6 l! Z' [: u, b/ B3 h" i" P- V#coding: utf-8
5 f# L& B% T6 z9 ^  L/ L: u- ]def select_sort(arr):
    number1 = len(arr)
! L. L3 }% Z$ Z& E7 H    for nem1 in range(number1):
- n2 q) U  h" W- f6 [2 D1 H        min_idx = nem1
        for number2 in range(nem1+1,number1):
            if arr[number2] <arr[min_idx]:
0 q/ |: P5 f: @* J9 u* A                min_idx = number2
                arr[nem1],arr[min_idx] = arr[min_idx],arr[nem1]  ##交换
# I6 \1 [& z; P, lreturn arr
) ^4 }7 j. Y/ o  H5 B) h( m
9 s; w# ~7 W1 y% {. Q
# 示例
4 y. `) E7 H8 `! n  E" zprint(select_sort([23,19,90,11,29,22]))
结果：[11, 22, 19, 29, 23, 90]
6 ^: V4 U1 k# I: ?- u
3 M: C% [1 i" X5 Z/ _- G9 k. t
3.快速排序（Quick Sort）：
5 o" l8 _# B% K2 ^7 L5 x原理：快速排序通过选择一个“基准”元素，将数组分为两部分：小于基准的元素和大于基准的元素。然后递归地对这两部分进行排序。
1 P. \. v8 i( Y, v" M- V
' z5 S( C: H& s时间复杂度：平均情况是O(n log n)，最坏情况是O(n²)（当选择的基准不理想时）。

) a/ N) s; X7 F7 t& Z" n实现：
2 ]( a4 K% I3 z% o, {

- G2 H0 Q% U7 b9 {def quick_sort(arr):
    if len(arr) <= 1:
        return arr
4 v, l, w( _! }& a, h1 a    pivot = arr[len(arr) // 2]  ##选择基数
( w- w5 q+ ^( }8 z- M- L1 ^8 L    left = [a for a in arr if a < pivot]
    middle = [a for a in arr if a == pivot]
    right = [a for a in arr if a > pivot]
    return quick_sort(left) + middle + quick_sort(right)
; t; z# r/ k+ G- a. l! N% j% e8 Z! h
9 W' g3 U: ]* O; q

# Y: y0 {% g; p- A/ ~# 示例
print(quick_sort([2,5,7,11,1,3,1]))
  y6 A8 w5 ?& O+ s! u
结果：
[1, 1, 2, 3, 6, 8, 10]

" W1 }  O! _3 ~) L) @( {4.插入排序（Insertion Sort）：
原理：插入排序将数组分为已排序和未排序两部分。每次从未排序部分取出一个元素，插入到已排序部分的合适位置。

时间复杂度：平均和最坏情况是O(n²)，最好情况是O(n)。

3 f- y' Z/ z) h8 D' y9 O实现：

1 X* J/ F4 @  x* h! Cdef insertin_sort(arr):
: X8 v$ ]! ?4 z# s. G    n = len(arr)
    for a in range(1,n):
2 j9 Q9 w0 t; J+ y1 @0 l4 G         key = arr[a]
$ K8 v; _3 f# X         b = a -1
         while b>=0 and key < arr[b]:
            arr[b+1] = arr[b]    ##移动元素
b -= 1
; S8 ?3 S9 y1 Z            arr[b +1] = key    ####插入值
# O9 J( p6 `, A/ B. Treturn arr


2 F' F% `; N2 J# T# 示例
print(insertin_sort([11,9,14,4,7]))
print(insertin_sort([12, 11, 13, 5, 6]))

# w- |$ I' i* F  U" n1 B2 u
结果：
& o4 n7 `0 H2 e, c% U4 F
) O$ j! k- O6 G  J1 ~) F[4, 7, 9, 11, 14]
[5, 6, 11, 12, 13]

6 X2 _' m' l4 W$ ^/ ]2 k. q8 Z6 B
5. 归并排序（Merge Sort）
, C. A' B5 `4 b  w8 @& d% z* ~原理：归并排序采用分治法，将数组分成两个子数组，分别对这两个子数组进行排序，然后将已排序的子数组合并成一个最终的排序数组。
1 w. \$ _8 m1 I: P0 |+ d
时间复杂度：O(n log n)。

2 i8 s2 J/ q) N( v/ \2 o* P实现：

/ l$ O4 P6 c% L9 T) ~+ Y1 Y#归并排序
: r) X( \% W& `6 j0 W+ E7 Odef merge_sort(arr):
    #如果数组长度小于等于1，则直接返回
" R' Y# [# N- Z, j& l4 S4 f: ~if len(arr)<=1:
      return arr
: K8 X+ L9 e% D; Z" O, Z
6 z/ E. B- Y6 c' r  s6 t    ##找中间索引
mid = len(arr)//2

    # 递归地对左右子数组进行排序
left = merge_sort(arr[:mid])
    right = merge_sort(arr[mid:])
0 ^0 R9 A4 N0 ^
  c9 m( b3 x( y6 s0 S    #合并已排序的子数组
return merage(left,right)

! j- Q6 h3 b, M$ Y& P& |& @& hdef merage(left,right):
    sorted_array = []
$ B& V% M" i/ }+ o" K    a = b = 0
    ##合并两个已排序的子数组
* ^2 p1 X0 Q( Z+ `3 F6 ywhile a < len(left) and b < len(right):
) r  Z: Z- }  e8 w' Q7 _$ u# ~2 Q        if left[a]< right[b]:
3 i1 E; c3 j) B! Y6 M          sorted_array.append(left[a])
4 P& p$ y6 M2 A7 N          a += 1
5 A3 j; H4 H7 X7 J/ q. q1 k        else:
          sorted_array.append(right[b])
          b += 1

    while a <len(left):
0 j3 c6 _6 g) B8 L        sorted_array.append(left[a])
) v; h: d( [8 U; _        a += 1
    while b<len(right):
        sorted_array.append(right[b])
        b += 1


; s8 F8 z2 F' c2 W- z! M: ?1 Q    return sorted_array

if __name__ == "__main__":
' K5 s/ K3 K" d8 ]  arr = [37,26,42,2,8,81,9]
9 i1 n4 A/ ^; @3 K  a' Y) ^) j& v  sorted_arr = merge_sort(arr)

  print("排序后的数组:",sorted_arr)


  J  O: `3 n4 t" {5 G9 J结果：
1 `- ]; H/ W0 ]$ K# b6 A+ q排序后的数组: [2, 8, 9, 26, 37, 42, 81]
& @) r4 C' Z4 w. ?! N

二、搜索算法
7 r2 H& F: e1 ?" p$ u1. 线性搜索（Linear Search）
; e) A: Y9 |9 ], a/ V0 `( `$ x线性搜索是一种简单的搜索算法，它通过逐个检查每个元素来查找目标值。
! b6 s0 B/ B/ K) ^7 u3 M
$ o: E* w1 I+ a  |
6 z. O9 k; X1 Z9 Kdef line_search(arr,target):
7 j8 ~( @) y) z7 s) c    for index,value in enumerate(arr):
: F/ }' \# ^5 X3 F' V        if value == target:
            return index   ###换回目标值的索引
return -1    ###如果未找到值，则返回-1
" t/ J- ~; |: g* q( {2 [( C#示例
arr = [2,5,1,6,9]
8 a, z* h% |# k$ _2 U' G3 s3 p* Ptarget = 9
result = line_search(arr,target)
% i& o" v  d+ r3 p3 ~5 n4 Bprint(f"目标值 {target}的索引是：{result}")
/ p) w* Y) q( b# L2 d

结果：
1 \2 [. H, t, g. ~* h# L/ |
目标值 9的索引是：4
& ?" A! [" y' x- F6 y0 F- c
5 ]; e% C: i9 j# C7 E) }& R8 F2. 二分搜索（Binary Search）
) K1 J; _/ T! @! j8 }( U- F, D( d二分搜索是一种高效的搜索算法，适用于已排序的数组。它通过将搜索范围减半来快速定位目标值。

def binary_search(arr,target):
    left,right=0,len(arr)-1
4 _. R' z9 y) l    while left <= right:
2 o+ q& r. ?+ |$ s0 x% O! x        mid = left + (right-left)//2
        if arr[mid]==target:
            return mid   ###返回目标值的索引
        elif arr[mid]<target:
. s+ i& B& M6 x  k! a& Y8 g# Q8 v            left = mid +1
        else:
4 I: L9 ?8 i; t/ S% n$ c3 ?( v! M            right = mid -1
    return -1    ##如果未找到，返回-1
  Z% k7 X2 o! N) d7 b/ M) a
' O/ J" {- l, D& ~2 O##示例
/ e  A- z* f. _" f$ Uarr = [11,12,13,14,15,16,17,18,19]
target = 15
* ~2 ^+ F8 T) ~) J5 ?( ~result = binary_search(arr,target)
1 {% T+ H$ j5 pprint(f"目标值 {target}的索引是：{result}")

/ l  d% m9 J" L1 n0 C& N% z6 k结果：
) x) O8 K% {4 t9 k4 l1 @7 }目标值 15的索引是：4
8 K+ k* Y( T! H
$ @5 d+ ]7 D/ ]7 O3. 深度优先搜索（Depth-First Search, DFS）
& Z) s4 b0 N9 w深度优先搜索通常用于树或图的遍历。它会尽可能深地搜索树的分支。
4 ~; y* x' y; ^& E7 r
def dfs(graph, node, visited=None):
    if visited is None:
+ s4 X& t5 C% Q5 Y1 }" ]8 ^! G        visited = set()
    visited.add(node)
    print(node)
, O8 S& m; ?9 F' q# O. [' l    for neighbor in graph[node]:
        if neighbor not in visited:
; }0 b+ ^. {8 H7 R& _" H/ e            dfs(graph, neighbor, visited)

1 d$ }  o2 q" w4 R- O2 g3 U" ~/ G# 示例
5 P- [) {/ E$ xgraph = {
    'A': ['B', 'C'],
    'B': ['D', 'E'],
1 ~+ B8 ^2 ~- R8 v3 T    'C': ['F'],
4 Y$ Y. B% e: w$ {    'D': [],
    'E': ['F'],
    'F': []
+ l, w$ T5 C$ J" h9 \8 Z' X}
dfs(graph, 'A')
% T! w- J, J, s- {4. 广度优先搜索（Breadth-First Search, BFS）
* c* F2 I* v2 V1 M广度优先搜索也是用于树或图的遍历，它逐层访问节点。
! j  [5 O4 w$ q: p
  k! O4 I* c2 j5 D. r% I9 x0 ^from collections import deque
' ~# M/ P- s- D. b
) g( D' m( E7 _) ~' `8 G8 i( ?def bfs(graph, start):
4 A0 L! C7 {/ W6 q& ]' L    visited = set()
    queue = deque([start])
% e5 y* ~: g3 l2 p8 B1 ?2 K! M# C   
    while queue:
. l- V8 k/ A$ H        node = queue.popleft()
        if node not in visited:
            visited.add(node)
            print(node)
            queue.extend(neighbor for neighbor in graph[node] if neighbor not in visited)
& t) }( N$ j7 \, H' ?) B* d( X- [; c
3 o) y$ Z& g( _- b# 示例
graph = {
    'A': ['B', 'C'],
5 O2 h" u( L2 @6 Y+ T    'B': ['D', 'E'],
    'C': ['F'],
    'D': [],
    'E': ['F'],
! E/ E7 n+ L1 z6 V- }    'F': []
}
bfs(graph, 'A')
9 S7 X5 V( r4 J三、动态规划
! \6 Z  P; ]3 D斐波那契数列（Fibonacci Sequence）：
def fibonacci(n):
    if n <= 1:
" r8 V7 m: R9 u; O        return n
    fib = [0, 1]
3 Q& {" Y8 u1 E  r- h    for i in range(2, n + 1):
- ?! a1 z7 }9 t! p% r8 f        fib.append(fib[i - 1] + fib[i - 2])
: n3 ^5 k8 e5 \/ H    return fib[n]
' _& Y& b: \8 b
# 示例
( n  E3 K4 p! Z- Hprint(fibonacci(10))  # 输出: 55
四、 图算法
* }& Y, b$ A2 N5 C深度优先搜索（DFS）：
. b( }  q% K2 v1 I8 l
7 M4 X; F9 z! E6 M# j/ Jdef dfs(graph, start, visited=None):
    if visited is None:
2 X5 C: L1 P# G% Y. X        visited = set()
: N9 }% |) F4 \1 h8 u- [4 g' G8 ^    visited.add(start)
! k; h5 U0 b1 _) ]8 M    for neighbor in graph[start]:
# T, v# N! ]6 ~! o* k7 y        if neighbor not in visited:
            dfs(graph, neighbor, visited)
    return visited

1 ?" q! R( ^% m4 E) Z+ o: V4 f# 示例
graph = {
    'A': ['B', 'C'],
    'B': ['A', 'D', 'E'],
$ j% Y0 C0 W$ l7 I    'C': ['A', 'F'],
8 q" q9 ^3 a% r' m* u1 G# R0 ]( u    'D': ['B'],
    'E': ['B', 'F'],
1 W  C3 @7 g3 a) `    'F': ['C', 'E']
( ]( [  X7 N: L" d$ g5 m# s' B}
/ T1 Z  a, x/ y5 Z( N9 @print(dfs(graph, 'A'))  # 输出: {'A', 'B', 'D', 'E', 'C', 'F'}
7 T+ s& v& Y+ Y% z  G五、递归算法
计算阶乘（Factorial）
9 b/ W" p& \; W4 Idef factorial(n):
    if n == 0:
6 d; A% E, \8 O; D        return 1
    else:
! T( @; C2 b' Z/ f7 l        return n * factorial(n - 1)

# 示例
print(factorial(5))  # 输出: 120
六、 回溯算法
. o1 z! }7 |5 {9 V' R& H解决八皇后问题：
def solve_n_queens(n):
. v: M7 P! k; l- {2 ^    def is_safe(board, row, col):
- [9 y) R3 ?- i, v        # 检查当前列是否安全
6 ?! O8 H- u, {6 s/ B% N( f" C        for i in range(row):
. [0 z3 y- e& L6 c$ E            if board == col or \
               board - i == col - row or \
               board + i == col + row:
                return False
' u& e. j) _; l# [8 O' \$ @* X        return True
4 ^3 _6 d" e% H2 @7 c
    def solve(board, row):
- r8 w+ G# S1 J& S4 Z+ l        if row == n:
! A& E3 h. V; u2 r            result.append(board[:])
$ x& L+ r/ K. N" O4 m4 i9 ]            return
# i: u/ f- A% C0 K: ]        for col in range(n):
            if is_safe(board, row, col):
3 {6 |/ h5 l4 ]9 X( h                board[row] = col
                solve(board, row + 1)
  C, K* ]! M9 a7 f% A( y% }5 r                # 在回溯时不需要重置，因为我们直接覆盖
- Q) k$ G# s$ N5 r8 Z( l; U4 K: X
5 D/ |! X5 q; D# n* j" f# w    result = []
7 S7 }7 r# p$ M, l# `' s$ c    board = [-1] * n  # 初始化棋盘
9 |" [1 `  {% x# N7 E: P    solve(board, 0)
+ `( {/ m+ \/ `$ j% e/ r* M    return result
& T- x* ]( j6 @" @( L
def print_solutions(solutions):
$ Z) G+ L6 X! x. ?) U$ R4 l    for board in solutions:
* q2 N0 x2 |: P! r        for row in board:
9 r, X1 c! I" d7 S' O. o            line = ['.'] * len(board)
; B  p3 m* _7 j, A7 l            line[row] = 'Q'
            print(' '.join(line))
& o3 _% Z) A0 a        print()
9 O! k; Q+ u5 j, c8 ?4 }4 @! V: `
if __name__ == "__main__":
. J, s2 {8 ^3 j* y/ e% H# U    n = 8  # 八皇后
3 I, {( s8 [( F0 f8 L    solutions = solve_n_queens(n)
; Q/ T2 W; m( C    print(f"找到 {len(solutions)} 种解决方案:")
: {( i' {* J% I- \2 q    print_solutions(solutions)
AI写代码


' V' J1 l$ P6 O: x3 L
& @  \+ ]6 J2 j2 x' [

7 L% h! q% P1 C& m; q% o/ v5 e

admin

常见的内部排序算法有：插入排序、希尔排序、选择排序、冒泡排序、归并排序、快速排序、堆排序、基数排序等。用一张图概括：
" ^, K) V" Q4 U3 ^; t
6 e6 M7 U5 z4 R% D图片


6 ]% W' Q/ a& q: T5 _图片
" \! B  X7 i8 J7 D) ^/ s关于时间复杂度

图片
0 i3 g9 ^& ^9 ^% c: h! }
! S: c' R9 x# Y* q# M
4 Q2 B" ~5 ]0 D% ^- j3 V5 y) g平方阶 (O(n2)) 排序 各类简单排序：直接插入、直接选择和冒泡排序。
3 u) V5 w, |& C) ~线性对数阶 (O(nlog2n)) 排序 快速排序、堆排序和归并排序；
O(n1+§)) 排序，§ 是介于 0 和 1 之间的常数。希尔排序
) ~# F* B6 L0 ~# k2 p线性阶 (O(n)) 排序 基数排序，此外还有桶、箱排序。
7 }! u- P- Z# A! x% x! \
& P. c& h- G5 E
图片
关于稳定性

图片


0 K" e. Z0 C6 n3 }  U( t5 T排序后 2 个相等键值的顺序和排序之前它们的顺序相同
稳定的排序算法：冒泡排序、插入排序、归并排序和基数排序。
不是稳定的排序算法：选择排序、快速排序、希尔排序、堆排序。

- o  h* a* |9 l/ S* H8 R8 R6 f( m
' n( E0 |. u& ]6 Y图片
  l* @2 f9 N" _* g8 B名词解释

2 c9 J* u, B5 E5 I图片

- E* H+ P( i% m0 \! Y7 N# w
) g9 J! h- @9 u$ rn：数据规模
% M6 P/ g' u( B( t0 k1 p$ W! Bk：“桶”的个数
In-place：占用常数内存，不占用额外内存
: [* ]% s7 p# G& |, f2 ]) ~Out-place：占用额外内存
2 F5 c% L$ ]7 g- H+ w# {# v2 @/ `

+ t& b( |1 L5 W4 O4 m图片
1、冒泡排序
2 k. c# F  s. B- g& T# r
图片

8 i3 S+ {! v3 d- J" x9 p
6 _; {, @& ~5 j  P冒泡排序（Bubble Sort）也是一种简单直观的排序算法。它重复地走访过要排序的数列，一次比较两个元素，如果他们的顺序错误就把他们交换过来。走访数列的工作是重复地进行直到没有再需要交换，也就是说该数列已经排序完成。这个算法的名字由来是因为越小的元素会经由交换慢慢“浮”到数列的顶端。
7 n1 I% }! v1 r) _
! i. Z( f+ A; i# z- n+ u作为最简单的排序算法之一，冒泡排序给我的感觉就像 Abandon 在单词书里出现的感觉一样，每次都在第一页第一位，所以最熟悉。冒泡排序还有一种优化算法，就是立一个 flag，当在一趟序列遍历中元素没有发生交换，则证明该序列已经有序。但这种改进对于提升性能来说并没有什么太大作用。

（1）算法步骤
比较相邻的元素。如果第一个比第二个大，就交换他们两个。
0 g# n7 @! Y* y- Z' Q3 z对每一对相邻元素作同样的工作，从开始第一对到结尾的最后一对。这步做完后，最后的元素会是最大的数。
9 E' i3 M* i1 f% b8 U针对所有的元素重复以上的步骤，除了最后一个。
持续每次对越来越少的元素重复上面的步骤，直到没有任何一对数字需要比较。
8 K  n. n1 S+ a$ W; a9 ~（2）动图演示
图片
（3）Python 代码
1 B, A6 a. u& s: H# B- adef bubbleSort(arr):
    for i in range(1, len(arr)):
        for j in range(0, len(arr)-i):
            if arr[j] > arr[j+1]:
                arr[j], arr[j + 1] = arr[j + 1], arr[j]
2 b" W/ B$ P% |% W' M7 h0 B$ U7 ^    return arr

! H$ Y' k: j" D
5 ^& D( _. E: ]0 `2 }4 \% L图片
2、选择排序

3 n2 L! P+ d# M) D/ M! n' m图片
选择排序是一种简单直观的排序算法，无论什么数据进去都是 O(n²) 的时间复杂度。所以用到它的时候，数据规模越小越好。唯一的好处可能就是不占用额外的内存空间了吧。

（1）算法步骤
& q, J* ^* s' f+ t首先在未排序序列中找到最小（大）元素，存放到排序序列的起始位置
再从剩余未排序元素中继续寻找最小（大）元素，然后放到已排序序列的末尾。
, D6 w( J- R" G  a# d% Q: A( |1 ]重复第二步，直到所有元素均排序完毕。
（2）动图演示
图片
（3）Python 代码
- n, V$ _7 H& J' bdef selectionSort(arr):
! P' c5 Q' b( f% B' K. e5 O    for i in range(len(arr) - 1):
' G! \9 O' d+ C+ {& N9 Y        # 记录最小数的索引
        minIndex = i
        for j in range(i + 1, len(arr)):
            if arr[j] < arr[minIndex]:
4 T* W' T% @+ F" }7 _# _  D6 _$ y                minIndex = j
9 w% v9 I- V& a* |! H# ^        # i 不是最小数时，将 i 和最小数进行交换
        if i != minIndex:
            arr[i], arr[minIndex] = arr[minIndex], arr[i]
* r4 R( }2 ]8 x9 B/ B    return arr
, Z0 I3 m% z' D
% f. j3 g) m  \1 u0 g, h
9 @* v% Z8 q/ b4 _: H图片
3、插入排序
3 S0 }! r2 d( C. G
1 F: Q7 g# @. t) u图片
插入排序的代码实现虽然没有冒泡排序和选择排序那么简单粗暴，但它的原理应该是最容易理解的了，因为只要打过扑克牌的人都应该能够秒懂。插入排序是一种最简单直观的排序算法，它的工作原理是通过构建有序序列，对于未排序数据，在已排序序列中从后向前扫描，找到相应位置并插入。
! g$ o3 Q/ i5 P/ T8 Q
插入排序和冒泡排序一样，也有一种优化算法，叫做拆半插入。

7 h" E7 I, k/ _3 P/ W) l! w, I（1）算法步骤
将第一待排序序列第一个元素看做一个有序序列，把第二个元素到最后一个元素当成是未排序序列。

5 e/ m! t4 g4 x) f从头到尾依次扫描未排序序列，将扫描到的每个元素插入有序序列的适当位置。（如果待插入的元素与有序序列中的某个元素相等，则将待插入元素插入到相等元素的后面。）

（2）动图演示
图片
) G3 B( g1 O9 X& p; Y: t（3）Python 代码
! ~+ i2 Q( N, F4 O* j: s2 U  x9 Tdef insertionSort(arr):
    for i in range(len(arr)):
9 Y; D' ^  k# E2 S9 Z9 F        preIndex = i-1
        current = arr[i]
        while preIndex >= 0 and arr[preIndex] > current:
; {' q- i( i# B/ ?            arr[preIndex+1] = arr[preIndex]
5 ]' Y+ j* w9 J% I7 g            preIndex-=1
        arr[preIndex+1] = current
; Y5 u6 O( ^- s. P% u* _    return arr
+ j: T$ V  _* C/ ~) E6 M& N
" h9 t  u* @$ n5 i3 `3 @7 f
图片
9 a0 `$ d2 p/ x. |6 j4、希尔排序

图片
希尔排序，也称递减增量排序算法，是插入排序的一种更高效的改进版本。但希尔排序是非稳定排序算法。
3 q5 B$ ^) I; T/ G
+ e% y. e* v# E4 g- _% e, T. D希尔排序是基于插入排序的以下两点性质而提出改进方法的：
- `' G8 [  e, b5 q
3 ^/ o3 F% N7 v7 }8 }插入排序在对几乎已经排好序的数据操作时，效率高，即可以达到线性排序的效率；
8 P5 U2 O: o" L但插入排序一般来说是低效的，因为插入排序每次只能将数据移动一位；
希尔排序的基本思想是：先将整个待排序的记录序列分割成为若干子序列分别进行直接插入排序，待整个序列中的记录“基本有序”时，再对全体记录进行依次直接插入排序。

（1）算法步骤
0 U  D. D# [% d0 j3 M7 @选择一个增量序列 t1，t2，……，tk，其中 ti > tj, tk = 1；
按增量序列个数 k，对序列进行 k 趟排序；
每趟排序，根据对应的增量 ti，将待排序列分割成若干长度为 m 的子序列，分别对各子表进行直接插入排序。仅增量因子为 1 时，整个序列作为一个表来处理，表长度即为整个序列的长度。
; J& H8 H+ {- k9 V0 o  {- D7 D6 l（2）Python 代码
def shellSort(arr):
    import math
* n6 `# {( d' V  [! z# i    gap=1
    while(gap < len(arr)/3):
        gap = gap*3+1
4 U! B- T9 }# `. o/ J    while gap > 0:
        for i in range(gap,len(arr)):
! n) R  [9 i# T, J' a- o1 {            temp = arr[i]
            j = i-gap
: w( m; V  M: p3 S            while j >=0 and arr[j] > temp:
                arr[j+gap]=arr[j]
9 e# Q, E' R$ Y0 a- h                j-=gap
            arr[j+gap] = temp
" l& v1 S: B. g8 v# f! s        gap = math.floor(gap/3)
0 D9 r$ k5 M7 k2 r7 U  H6 n: ?) C    return arr
8 G4 P. V) K6 J

图片
; ]! c7 q4 f- l( n: x/ w; k5、归并排序

2 s) t3 I6 O4 f3 K4 J8 ?8 u4 o图片
归并排序（Merge sort）是建立在归并操作上的一种有效的排序算法。该算法是采用分治法（Divide and Conquer）的一个非常典型的应用。

作为一种典型的分而治之思想的算法应用，归并排序的实现由两种方法：
% m9 N# y( k) U
1 |6 v* d- E9 |% [% e( m自上而下的递归（所有递归的方法都可以用迭代重写，所以就有了第 2 种方法）；
4 K6 \# d/ w7 F自下而上的迭代；
3 r, Z+ b5 q2 N0 J4 }4 L和选择排序一样，归并排序的性能不受输入数据的影响，但表现比选择排序好的多，因为始终都是 O(nlogn) 的时间复杂度。代价是需要额外的内存空间。
5 w, v" V' F6 f$ {5 e
7 H. r3 x* a0 ~* v（1）算法步骤
; S4 A# v* V5 z% z8 R申请空间，使其大小为两个已经排序序列之和，该空间用来存放合并后的序列；
, w7 H, w. Y* a) ^2 b0 x' W
设定两个指针，最初位置分别为两个已经排序序列的起始位置；

0 p4 k# n& R2 Y2 k* [) ~比较两个指针所指向的元素，选择相对小的元素放入到合并空间，并移动指针到下一位置；

重复步骤 3 直到某一指针达到序列尾；
# O1 b5 j/ _2 O0 \2 w, E: T
  v) b7 ]% M. \; N1 T* g2 ^1 p/ {5 m将另一序列剩下的所有元素直接复制到合并序列尾。

（2）动图演示
图片
1 l. y7 L( J$ |（3）Python 代码
def mergeSort(arr):
    import math
    if(len(arr)<2):
/ e, J5 c+ T  p& j        return arr
    middle = math.floor(len(arr)/2)
9 ~* y- F' z' h5 j; f2 Q& C+ n8 W    left, right = arr[0:middle], arr[middle:]
: w5 e( o$ F* l( L% X; ]    return merge(mergeSort(left), mergeSort(right))

' d% {# s; {- |def merge(left,right):
( h& F) M8 x( }    result = []
    while left and right:
$ t$ J) b( ~% z3 P" ^! c/ `1 @( q        if left[0] <= right[0]:
            result.append(left.pop(0));
        else:
            result.append(right.pop(0));
* G2 g7 }/ ?7 v2 @9 |    while left:
6 `3 r* N4 S5 @8 }' I        result.append(left.pop(0));
4 M+ [8 H: R% ?* R- |- m1 o    while right:
! Z$ j3 O; }( _  T; g  Q& a* ^        result.append(right.pop(0));
    return result

* p7 Z- u5 [9 y: `0 B
图片
6、快速排序
; _) g/ ^# V7 I. Q) b# V4 G
' h$ S- N' U& |6 V3 j6 E- V' c图片
快速排序是由东尼·霍尔所发展的一种排序算法。在平均状况下，排序 n 个项目要 Ο(nlogn) 次比较。在最坏状况下则需要 Ο(n2) 次比较，但这种状况并不常见。事实上，快速排序通常明显比其他 Ο(nlogn) 算法更快，因为它的内部循环（inner loop）可以在大部分的架构上很有效率地被实现出来。

快速排序使用分治法（Divide and conquer）策略来把一个串行（list）分为两个子串行（sub-lists）。
# m* j# G8 u9 L# ~- L
4 F- T+ M. d: A  x4 W- g$ Z快速排序又是一种分而治之思想在排序算法上的典型应用。本质上来看，快速排序应该算是在冒泡排序基础上的递归分治法。

快速排序的名字起的是简单粗暴，因为一听到这个名字你就知道它存在的意义，就是快，而且效率高！它是处理大数据最快的排序算法之一了。虽然 Worst Case 的时间复杂度达到了 O(n²)，但是人家就是优秀，在大多数情况下都比平均时间复杂度为 O(n logn) 的排序算法表现要更好，可是这是为什么呢，我也不知道。好在我的强迫症又犯了，查了 N 多资料终于在《算法艺术与信息学竞赛》上找到了满意的答案：

快速排序的最坏运行情况是 O(n²)，比如说顺序数列的快排。但它的平摊期望时间是 O(nlogn)，且 O(nlogn) 记号中隐含的常数因子很小，比复杂度稳定等于 O(nlogn) 的归并排序要小很多。所以，对绝大多数顺序性较弱的随机数列而言，快速排序总是优于归并排序。

4 v: S4 [) C0 {0 j& Z3 ]（1）算法步骤
① 从数列中挑出一个元素，称为 “基准”（pivot）;

② 重新排序数列，所有元素比基准值小的摆放在基准前面，所有元素比基准值大的摆在基准的后面（相同的数可以到任一边）。在这个分区退出之后，该基准就处于数列的中间位置。这个称为分区（partition）操作；
1 s: ?! V: e. V7 e5 G
③ 递归地（recursive）把小于基准值元素的子数列和大于基准值元素的子数列排序；

2 B' C. }# m5 g/ F# O递归的最底部情形，是数列的大小是零或一，也就是永远都已经被排序好了。虽然一直递归下去，但是这个算法总会退出，因为在每次的迭代（iteration）中，它至少会把一个元素摆到它最后的位置去。
4 o( c2 {0 _4 Y9 @) W
（2）动图演示
# Z2 T6 p4 h2 u图片
（3）Python 代码
' v. V) J3 t: E: p$ d% Sdef quickSort(arr, left=None, right=None):
    left = 0 if not isinstance(left,(int, float)) else left
    right = len(arr)-1 if not isinstance(right,(int, float)) else right
    if left < right:
        partitionIndex = partition(arr, left, right)
; Y: [/ _1 [2 ~3 q5 p9 ?; V        quickSort(arr, left, partitionIndex-1)
' h; N6 Z/ N4 A; I+ ~) \! [+ }        quickSort(arr, partitionIndex+1, right)
    return arr

def partition(arr, left, right):
# Q3 j1 p4 g! l4 v    pivot = left
    index = pivot+1
    i = index
    while  i <= right:
- ?3 I4 Y1 N# p+ z$ Z- M2 t' I        if arr[i] < arr[pivot]:
            swap(arr, i, index)
            index+=1
        i+=1
    swap(arr,pivot,index-1)
    return index-1
4 U+ T$ M9 ]/ t% O; o' m, {, Q
def swap(arr, i, j):
9 m& [' P1 k% W7 L  V1 c8 L1 x8 a, L    arr[i], arr[j] = arr[j], arr[i]


图片
, o7 x! {! f' [" [# l4 B, Q7、堆排序

图片
堆排序（Heapsort）是指利用堆这种数据结构所设计的一种排序算法。堆积是一个近似完全二叉树的结构，并同时满足堆积的性质：即子结点的键值或索引总是小于（或者大于）它的父节点。堆排序可以说是一种利用堆的概念来排序的选择排序。分为两种方法：

3 Q' c# b; e' W大顶堆：每个节点的值都大于或等于其子节点的值，在堆排序算法中用于升序排列；
小顶堆：每个节点的值都小于或等于其子节点的值，在堆排序算法中用于降序排列；
堆排序的平均时间复杂度为 Ο(nlogn)。

( U/ V  q9 ]3 j（1）算法步骤
创建一个堆 H[0……n-1]；
把堆首（最大值）和堆尾互换；
把堆的尺寸缩小 1，并调用 shift_down(0)，目的是把新的数组顶端数据调整到相应位置；
重复步骤 2，直到堆的尺寸为 1。
（2）动图演示
图片
" r% ~& d, X. A6 _0 {" _" w（3）Python 代码
def buildMaxHeap(arr):
% ^3 c- R1 S& ~' X9 k    import math
    for i in range(math.floor(len(arr)/2),-1,-1):
- ?& a$ D5 B3 v. n- `8 R2 r, c        heapify(arr,i)

def heapify(arr, i):
    left = 2*i+1
0 _0 x, Q% P" C5 t* X0 Z- c- [    right = 2*i+2
    largest = i
    if left < arrLen and arr[left] > arr[largest]:
        largest = left
    if right < arrLen and arr[right] > arr[largest]:
& o; E/ n% K# @, o        largest = right
1 ]' f- l# R  M; X1 f
    if largest != i:
% \" A6 K1 [# b4 s5 R' y, v* c8 e        swap(arr, i, largest)
+ ~8 g' o; T. [  c: l1 l# \2 b: E  [        heapify(arr, largest)

def swap(arr, i, j):
0 |8 F. k/ E. X# _) F2 D    arr[i], arr[j] = arr[j], arr[i]
' Q- c: [7 X% d6 Y/ ~1 ~- x( D1 R6 z
, g; ~+ {6 n: xdef heapSort(arr):
    global arrLen
    arrLen = len(arr)
2 ^% }/ N. K* j5 e    buildMaxHeap(arr)
9 ?8 U0 N7 i- c5 m    for i in range(len(arr)-1,0,-1):
        swap(arr,0,i)
( i/ o  K8 R' [% K  G" j' }3 n        arrLen -=1
/ A% k& @6 d0 u% k* m8 Y, o        heapify(arr, 0)
    return arr


图片
8、计数排序
  i! h- b0 b2 b" A
图片
计数排序的核心在于将输入的数据值转化为键存储在额外开辟的数组空间中。作为一种线性时间复杂度的排序，计数排序要求输入的数据必须是有确定范围的整数。
! Y$ `; Z, _8 o& O
（1）动图演示
7 ^7 I  Q$ l; }/ C0 O- a8 M" m图片
（2）Python 代码
' d, s9 |/ T& g( a' l, Qdef countingSort(arr, maxValue):
    bucketLen = maxValue+1
, c" D5 Y( {' C    bucket = [0]*bucketLen
    sortedIndex =0
8 i( R( r8 y( q    arrLen = len(arr)
- k: G6 U7 O0 f+ E. V/ o/ H    for i in range(arrLen):
        if not bucket[arr[i]]:
            bucket[arr[i]]=0
( n8 u8 L- V* n/ [* o4 x/ S1 d        bucket[arr[i]]+=1
% Z* u; R) X& s  f" {" B    for j in range(bucketLen):
        while bucket[j]>0:
) `0 X. p  p) @  P7 m9 t            arr[sortedIndex] = j
            sortedIndex+=1
. A9 [9 b" |9 o7 t$ m) c1 a  ?, u4 b            bucket[j]-=1
" N1 z7 L; u  H: B' ^4 Y    return arr
( S/ ~& t) \/ p' E& U9 ^' N

" C# I% h2 M! b$ p图片
; X( w* h9 @0 c9、桶排序

图片
桶排序是计数排序的升级版。它利用了函数的映射关系，高效与否的关键就在于这个映射函数的确定。为了使桶排序更加高效，我们需要做到这两点：
6 e8 m5 d: j1 A! l% G& k2 `+ h
在额外空间充足的情况下，尽量增大桶的数量
# r% T; @. l' V- d- _8 g使用的映射函数能够将输入的 N 个数据均匀的分配到 K 个桶中
同时，对于桶中元素的排序，选择何种比较排序算法对于性能的影响至关重要。

什么时候最快
( c( m9 A' v# _8 Q6 U+ x当输入的数据可以均匀的分配到每一个桶中。
, p4 O, ^2 g2 g: `% b6 M
1 r8 F( E! M. s5 X; M) X什么时候最慢
当输入的数据被分配到了同一个桶中。
7 J' A# g7 Y8 o) h9 |
Python 代码
4 }+ z* {6 n  \( rdef bucket_sort(s):
0 n1 k* V6 m2 s# u$ E    """桶排序"""
1 S* q- z" V. |2 ^9 {( z% \6 ]3 L    min_num = min(s)
    max_num = max(s)
9 h) o: c& |/ G& |    # 桶的大小
    bucket_range = (max_num-min_num) / len(s)
    # 桶数组
9 l) ~; D) F; b+ ]) S    count_list = [ [] for i in range(len(s) + 1)]
6 ^" k# p& E" o4 s2 v9 X3 s    # 向桶数组填数
    for i in s:
        count_list[int((i-min_num)//bucket_range)].append(i)
    s.clear()
    # 回填，这里桶内部排序直接调用了sorted
    for i in count_list:
8 X3 F8 ]# e/ x3 |& |: ^1 w        for j in sorted(i):
            s.append(j)
$ n5 L/ d( H; _  Z/ }) }0 Z
, a- @& y  N9 x5 w# q' dif __name__ == __main__ :
/ s5 V" D6 x1 ~2 i9 h/ E5 J8 K3 ?    a = [3.2,6,8,4,2,6,7,3]
7 R  ?2 |! I3 Z" G2 h9 X" d    bucket_sort(a)
    print(a) # [2, 3, 3.2, 4, 6, 6, 7, 8]


- x. k+ ~2 V0 i0 m4 m: k4 ~图片
10、基数排序

: S9 g# v! u3 T  v  t2 o0 Q图片
基数排序是一种非比较型整数排序算法，其原理是将整数按位数切割成不同的数字，然后按每个位数分别比较。由于整数也可以表达字符串（比如名字或日期）和特定格式的浮点数，所以基数排序也不是只能使用于整数。

基数排序 vs 计数排序 vs 桶排序
/ H; l5 i0 \& S" R+ c& G/ T+ q+ Y基数排序有两种方法：

这三种排序算法都利用了桶的概念，但对桶的使用方法上有明显差异：
& K; D! I  E9 z( w6 M; f0 f9 H) b& r
基数排序：根据键值的每位数字来分配桶；
计数排序：每个桶只存储单一键值；
5 z" L# q$ V' v. T# `+ h/ O( E桶排序：每个桶存储一定范围的数值；
动图演示
图片
9 k$ i2 u8 x5 f% G$ iPython 代码
# }, i# l0 c0 j( h+ \' Q4 zdef RadixSort(list):
    i = 0                                    #初始为个位排序
  T' I4 Z6 r' x$ C    n = 1                                     #最小的位数置为1（包含0）
    max_num = max(list) #得到带排序数组中最大数
    while max_num > 10**n: #得到最大数是几位数
        n += 1
    while i < n:
        bucket = {} #用字典构建桶
        for x in range(10):
            bucket.setdefault(x, []) #将每个桶置空
! ?0 t* [* W2 \4 F! i        for x in list: #对每一位进行排序
0 `' U3 ~2 Z* Y9 c            radix =int((x / (10**i)) % 10) #得到每位的基数
            bucket[radix].append(x) #将对应的数组元素加入到相 #应位基数的桶中
- Z$ e! U! c" w0 i        j = 0
        for k in range(10):
            if len(bucket[k]) != 0: #若桶不为空
                for y in bucket[k]: #将该桶中每个元素
                    list[j] = y #放回到数组中
6 i; w4 A$ X* z- R% R                    j += 1
        i += 1
" g. ?' e: f7 {* V% J+ sreturn  list