程序员需要知道的10大基础算法及python代码实现

一、快速排序算法

快速排序（Quicksort）是对冒泡排序的一种改进。
原理：快速排序由C. A. R. Hoare在1960年提出。它的基本思想是：通过一趟排序将要排序的数据分割成独立的两部分，其中一部分的所有数据，都比，另外一部分的所有数据，都要小，然后再按此方法对这两部分数据分别进行快速排序，整个排序过程可以递归进行，以此达到整个数据变成有序序列。

设要排序的数组是A[0]……A[N-1]，首先任意选取一个数据（通常选用数组的第一个数）作为关键数据，然后将所有比它小的数都放到它左边，所有比它大的数都放到它右边，这个过程称为一趟快速排序。值得注意的是，快速排序不是一种稳定的排序算法，也就是说，多个相同的值的相对位置也许会在算法结束时产生变动。

一趟快速排序的算法是：

• 1）设置两个变量i、j，排序开始的时候：i=0，j=N-1；
• 2）以第一个数组元素作为关键数据，赋值给key，即key=A[0]；
• 3）从j开始向前搜索，即由后开始向前搜索(j–)，找到第一个小于key的值A[j]，将A[j]和A[i]的值交换；
• 4）从i开始向后搜索，即由前开始向后搜索(i++)，找到第一个大于key的A[i]，将A[i]和A[j]的值交换；
• 5）重复第3、4步，直到i=j；(3,4步中，没找到符合条件的值，即3中A[j]不小于key,4中A[i]不大于key的时候改变j、i的值，使得j=j-1，i=i+1，直至找到为止。找到符合条件的值，进行交换的时候i，j指针位置不变。另外，i==j这一过程一定正好是i+或j-完成的时候，此时令循环结束）。

data = [45,3,2,6,3,78,5,44,22,65,46]
 
def quickSort(data, start, end):
    i = start
    j = end
    # i与j重合时，一次排序结束
    if i >= j:
        return
    # 设置最左边的数为基准值
    flag = data[start]
    while i < j:
        while i<j and data[j] >= flag:
            j -= 1
        # 找到右边第一个小于基准的数，赋值给左边i。此时左边i被记录在flag中
        data[i] = data[j]
        while i<j and data[i] <= flag:
            i += 1
        # 找到左边第一个大于基准的数，赋值给右边的j。右边的j的值和上面左边的i的值相同
        data[j] = data[i]
    # 由于循环以i结尾，循环完毕后把flag值放到i所在位置。
    data[i] = flag
    # 除去i之外两段递归
    quickSort(data, start, i-1)
    quickSort(data, i+1, end)
 
quickSort(data,0, len(data)-1)
print data

二、堆排序算法（参考）

原理：堆排序（Heapsort）是指利用堆这种数据结构所设计的一种排序算法。堆是一个近似完全二叉树的结构，并同时满足堆积的性质：即子结点的键值或索引总是小于（或者大于）它的父节点。这个过程其实就是先构建一个最大/最小二叉堆，然后不停的取出最大/最小元素（头结点），插入到新的队列中，以此达到排序的目的。如下图所示。
堆（二叉堆）：可以视为一棵完全的二叉树，完全二叉树的一个“优秀”的性质是，除了最底层之外，每一层都是满的，这使得堆可以利用数组来表示（普通的一般的二叉树通常用链表作为基本容器表示），每一个结点对应数组中的一个元素。

def big_endian(arr, start, end):
   root = start
   while True:
       child = root * 2 + 1   # 左孩子
       if child > end:        # 孩子比最后一个节点还大 也就意味着最后一个叶子节点了 就得跳出去一次循环已经调整完毕
           break
       if child + 1 <= end and arr[child] < arr[child + 1]:   # 为了始终让其跟子元素的较大值比较 如果右边大就左换右，左边大的话就默认
           child += 1
       if arr[root] < arr[child]:     # 父节点小于子节点直接换位置 同时坐标也得换这样下次循环可以准确判断是否为最底层是不是调整完毕
           arr[root], arr[child] = arr[child], arr[root]
           root = child
       else:                            # 父子节点顺序正常 直接过
           break
            
            
def heap_sort(arr):
   # 无序区大根堆排序
   first = len(arr) // 2 - 1
   for start in range(first, -1, -1):   # 从下到上，从右到左对每个节点进调整 循环得到非叶子节点
       big_endian(arr, start, len(arr) - 1)  # 去调整所有的节点
   for end in range(len(arr) - 1, 0, -1):
       arr[0], arr[end] = arr[end], arr[0]   # 顶部尾部互换位置
       big_endian(arr, 0, end - 1)          # 重新调整子节点的顺序  从顶开始调整
   return arr
    
    
def main():
   l = [3, 1, 4, 9, 6, 7, 5, 8, 2, 10]
   print(heap_sort(l))  # 原地排序
    
if __name__ == "__main__":
   main() 

三、归并排序

原理：归并排序（MERGE-SORT）是建立在归并操作上的一种有效的排序算法,该算法是采用分治法（Divide and Conquer）的一个非常典型的应用。将已有序的子序列合并，得到完全有序的序列；即先使每个子序列有序，再使子序列段间有序。若将两个有序表合并成一个有序表，称为二路归并。
算法步骤：

• 1.申请空间，使其大小为两个已经排序序列之和，该空间用来存放合并后的序列
• 2.设定两个指针，最初位置分别为两个已经排序序列的起始位置
• 3.比较两个指针所指向的元素，选择相对小的元素放入到合并空间，并移动指针到下一位置
• 4.重复步骤3直到某一指针达到序列尾
• 5.将另一序列剩下的所有元素直接复制到合并序列尾

def merge_sort(arr):
    sort(arr, 0, len(arr)-1)

def sort(arr, low, high):
    if low < high:
        mid = (low + high) // 2
        sort(arr, low, mid)
        sort(arr, mid+1, high)
        merge(arr, low, mid, high)

def merge(arr, low, mid, high):
    container = []    # 用于存储有序数字
    i, j = low, mid+1
    while i <= mid and j <= high:
        if arr[i] <= arr[j]:
            container.append(arr[i])
            i += 1
        else:
            container.append(arr[j])
            j += 1
    if i <= mid:
        container.extend(arr[i:mid+1])
    elif j <= high:
        container.extend(arr[j:high+1])
    arr[low:high+1] = container
 
# 做10次测试
import random as r
for i in range(0,10):
    arr = [r.randint(-10, 100) for i in range(0,50)]
    merge_sort(arr)
    print(arr, end='\n\n')

四、二分查找算法(聚会玩的猜数字)

二分查找算法是一种在有序数组中查找某一特定元素的搜索算法。

搜素过程从数组的中间元素开始，如果中间元素正好是要查找的元素，则搜素过程结束；如果某一特定元素大于或者小于中间元素，则在数组大于或小于中间元素的那一半中查找，而且跟开始一样从中间元素开始比较。

如果在某一步骤数组为空，则代表找不到。这种搜索算法每一次比较都使搜索范围缩小一半。折半搜索每次把搜索区域减少一半，时间复杂度为Ο(logn) 。

def bin_search(data_list, val):    
    low = 0                         # 最小数下标    
    high = len(data_list) - 1       # 最大数下标    
    while low <= high:        
        mid = (low + high) // 2     # 中间数下标        
        if data_list[mid] == val:   # 如果中间数下标等于val, 返回            
            return mid        
        elif data_list[mid] > val:  # 如果val在中间数左边, 移动high下标            
            high = mid - 1        
        else:                       # 如果val在中间数右边, 移动low下标            
            low = mid + 1    
    return # val不存在, 返回None
ret = bin_search(list(range(1, 10)), 3)
print(ret)

五、BFPRT(线性查找算法)

目标：是解决从n个数中选择第k大或第k小的数这个经典问题的著名算法。BFPRT算法，又称为中位数的中位数算法，由5位大牛（Blum 、 Floyd 、 Pratt 、 Rivest 、 Tarjan）提出，并以他们的名字命名。
算法的思想是修改快速选择算法的主元选取方法，提高算法在最坏情况下的时间复杂度。
算法步骤：

• 1.将n个元素每5个一组，分成n/5(上界)组。
• 2.取出每一组的中位数，任意排序方法，比如插入排序。
• 3.递归的调用selection算法查找上一步中所有中位数的中位数，设为x，偶数个中位数的情况下设定为选取中间小的一个。
• 4.用x来分割数组，设小于等于x的个数为k，大于x的个数即为n-k。
• 5.若i==k，返回x；若i<k，在小于x的元素中递归查找第i小的元素；若i>k，在大于x的元素中递归查找第i-k小的元素。

终止条件：n=1时，返回的即是i小元素

from mergeSort_recursion import mergesort
import random
 
def partion(a, m, m_index):
	#对a进行排序，使得比m小的元素放在m前面，比m大的元素放在m后面
	#输入：m_index（m在a中的index）
	#返回m前面, m后面各自元素的数目,以及m在新数组中的index
	
	#将m与数组第一个元素交换位置，然后即可像快速排序一样将所有元素以m为中间元素
	#分到左右两边
	tmp = a[0]
	a[0] = m
	a[m_index] = tmp
 
	i = 0
	j = len(a)-1
	control_m = a[0]
	while i < j:
		while i< j and a[j] >= control_m:
			j -= 1
 
		a[i] = a[j]
 
		while i < j and a[i] <= control_m:
			i += 1
		a[j] = a[i]
 
	#此时i = j， a[i]应该是最终的控制关键字所在位置
	a[i] = control_m
	print("m:{},after partion, a:{}".format(m, a))
 
	return i, len(a)-i-1, i
 
 
def bfprt(a, k):
	#得到a中第k大的元素
 
	if len(a) < 5:
		#元素数目不足5个时，排序后取index为k-1的数,即为第k大的元素
		#由于只有在元素数目很小时才使用排序，因此时间复杂度很小，可以看作常数时间复杂度
		mergesort(a,0, len(a)-1)
		return a[k-1]
 
	total_num = len(a)
	splits = total_num//5   #一共分成这么多组
 
	#获取每一个分组的中位数
	split_medians = []
	for i in range(splits):
		cur = mergesort(a[i*5:(i+1)*5],0, 4)
		mid = cur[2]
		split_medians.append(mid)
 
	#递归调用bfprt算法，求这些中位数的中第splits//2大的元素，也就是中位数的中位数
	m = bfprt(split_medians, splits//2)
	#求出m在a中的index
	m_index = [i for i in range(total_num) if a[i] == m][0]
 
	#根据m对a进行划分，线性复杂度
	#num1， num2:小于m的元素的数目， 大于m的元素数目
	num1, num2, m_index = partion(a, m, m_index)
	if k == num1+1:
		return m
	elif k <= num1:
		#说明在s1集合中
		return bfprt(a[:m_index], k)
	else:
		return bfprt(a[m_index+1:], k-1-m_index)
 
 
a = [5, 3, 1, 8, 2,10, 15, 18, 11,13, 16, 17, 12, 19, 0, 6, 4, 7, 9, 14]
random.shuffle(a)
k = 3
print(bfprt(a,7))

六、DFS（深度优先搜索）

深度优先搜索算法（Depth-First-Search），是搜索算法的一种。

它沿着树的深度遍历树的节点，尽可能深的搜索树的分支。当节点v的所有边都己被探寻过，搜索将回溯到发现节点v的那条边的起始节点。

这一过程一直进行到已发现从源节点可达的所有节点为止。如果还存在未被发现的节点，则选择其中一个作为源节点并重复以上过程，整个进程反复进行直到所有节点都被访问为止。DFS属于盲目搜索。

深度优先搜索是图论中的经典算法，利用深度优先搜索算法可以产生目标图的相应拓扑排序表，利用拓扑排序表可以方便的解决很多相关的图论问题，如最大路径问题等等。一般用堆数据结构来辅助实现DFS算法。
算法步骤：

• 1.访问顶点v；
• 2.依次从v的未被访问的邻接点出发，对图进行深度优先遍历；直至图中和v有路径相通的顶点都被访问；
• 3.若此时图中尚有顶点未被访问，则从一个未被访问的顶点出发，重新进行深度优先遍历，直到图中所有顶点均被访问过为止。

class DFS():
    def __init__(self,n):
        self.numlen=n
        self.result=[0 for i in range(n)]
        self.book=[0 for i in range(n)]
    def dfs(self,s):
        step=s-1
        if step==self.numlen:
            r=''
            for i in range(self.numlen):
                r+=str(self.result[i])
            print(r)
            return
        for i in range(self.numlen):
            if self.book[i]==0:
                self.result[step]=i+1
                self.book[i]=1
                self.dfs(s+1)
                self.book[i]=0
                #print(i,self.book[i])
        return

dfs=DFS(4)
dfs.dfs(1)

七、BFS(广度优先搜索)

广度优先搜索算法（Breadth-First-Search），是一种图形搜索算法。简单的说，BFS是从根节点开始，沿着树(图)的宽度遍历树(图)的节点。

如果所有节点均被访问，则算法中止。BFS同样属于盲目搜索。一般用队列数据结构来辅助实现BFS算法。

算法步骤：

• 1.首先将根节点放入队列中。
• 2.从队列中取出第一个节点，并检验它是否为目标。如果找到目标，则结束搜寻并回传结果。否则将它所有尚未检验过的直接子节点加入队列中。
• 3.若队列为空，表示整张图都检查过了——亦即图中没有欲搜寻的目标。结束搜寻并回传“找不到目标”。
• 4.重复步骤2。
  

 # 图的深度优先遍历
 # 1.利用栈实现
 # 2.从源节点开始把节点按照深度放入栈，然后弹出
 # 3.每弹出一个点，把该节点下一个没有进过栈的邻接点放入栈
 # 4.直到栈变空
 def dfs(node):
     if node is None:
         return
    nodeSet = set()
    stack = []
    print(node.value)
    nodeSet.add(node)
    stack.append(node)
    while len(stack) > 0:
        cur = stack.pop()               # 弹出最近入栈的节点
        for next in cur.nexts:         # 遍历该节点的邻接节点
            if next not in nodeSet:    # 如果邻接节点不重复
                stack.append(cur)       # 把节点压入
                stack.append(next)      # 把邻接节点压入
                set.add(next)           # 登记节点
                print(next.value)       # 打印节点值
                break                   # 退出，保持深度优先

BFC与DFC的区别：

	实现方法	基本思想	解决问题	N规模
DFS	栈/递归	回溯法，一次访问一条路，更接近人的思维方式,	所有解问题，或连通性问题	不能太大,<=200
BFS	队列	分治限界法，一次访问多条路，每一层需要存储大量信息	最优解问题，如最短路径	可以比较大，因为可以用队列解决,<=1000

八、Dijkstra算法

目标：迪科斯彻算法使用了广度优先搜索解决非负权有向图的单源最短路径问题，算法最终得到一个最短路径树。该算法常用于路由算法或者作为其他图算法的一个子模块。

该算法的输入包含了一个有权重的有向图G，以及G中的一个来源顶点S。我们以V表示G中所有顶点的集合。

每一个图中的边，都是两个顶点所形成的有序元素对。(u,v)表示从顶点u到v有路径相连。我们以E表示G中所有边的集合，而边的权重则由权重函数w:E→[0,∞]定义。因此，w(u,v)就是从顶点u到顶点v的非负权重（weight）。

边的权重可以想像成两个顶点之间的距离。任两点间路径的权重，就是该路径上所有边的权重总和。已知有V中有顶点s及t，Dijkstra算法可以找到s到t的最低权重路径(例如，最短路径)。

这个算法也可以在一个图中，找到从一个顶点s到任何其他顶点的最短路径。对于不含负权的有向图，Dijkstra算法是目前已知的最快的单源最短路径算法。
算法步骤：

• 1.初始时令S={V0},T={其余顶点}，T中顶点对应的距离值，若存在<V0,Vi>，d(V0,Vi)为<V0,Vi>弧上的权值；若不存在<V0,Vi>，d(V0,Vi)为∞。
• 2.从T中选取一个其距离值为最小的顶点W且不在S中，加入S
• 3.对其余T中顶点的距离值进行修改：若加进W作中间顶点，从V0到Vi的距离值缩短，则修改此距离值

重复上述步骤2、3，直到S中包含所有顶点，即W=Vi为止

MAX_value = 999999
 
 
def dijkstra(graph, s):
    # 判断图是否为空，如果为空直接退出
    if graph is None:
        return None
    dist = [MAX_value]*len(graph)
    dist[s] = 0
    S = []
    Q = [i for i in range(len(graph))]
    dist_init = [i for i in graph[s]]
    while Q:
        u_dist = min([d for v, d in enumerate(dist_init) if v in Q])
        u = dist_init.index(u_dist)
 
        S.append(u)
        Q.remove(u)
 
        for v, d in enumerate(graph[u]):
            if 0 < d < MAX_value:
                if dist[v] > dist[u]+d:
                    dist[v] = dist[u]+d
                    dist_init[v] = dist[v]
    return dist
 
 
if __name__ == '__main__':
    graph_list = [ [0, 9, MAX_value, MAX_value, MAX_value, 14,15,MAX_value],
                    [9, 0, 24, MAX_value, MAX_value, MAX_value,MAX_value,MAX_value],
                    [MAX_value, 24, 0, 6, 2, 18,MAX_value,19],
                    [MAX_value, MAX_value, 6, 0, 11,MAX_value,MAX_value, 6],
                    [MAX_value,MAX_value, 2, 11, 0, 30,20, 16],
                    [14,MAX_value,18,MAX_value,30,0,5,MAX_value],
                    [15,MAX_value,MAX_value,MAX_value,20,5,0,44],
                    [MAX_value,MAX_value,19,6,16,MAX_value,44,0]]
 
    distance = dijkstra(graph_list, 0)
    print(distance)

九、动态规划算法

目标：动态规划（Dynamicprogramming）是一种在数学、计算机科学和经济学中使用的，通过把原问题分解为相对简单的子问题的方式求解复杂问题的方法。

动态规划常常适用于有重叠子问题和最优子结构性质的问题，动态规划方法所耗时间往往远少于朴素解法。

动态规划背后的基本思想非常简单。大致上，若要解一个给定问题，我们需要解其不同部分（即子问题），再合并子问题的解以得出原问题的解。

通常许多子问题非常相似，为此动态规划法试图仅仅解决每个子问题一次，从而减少计算量：一旦某个给定子问题的解已经算出，则将其记忆化存储，以便下次需要同一个子问题解之时直接查表。这种做法在重复子问题的数目关于输入的规模呈指数增长时特别有用。

算法步骤：

• 1.最优子结构性质。如果问题的最优解所包含的子问题的解也是最优的，我们就称该问题具有最优子结构性质（即满足最优化原理）。最优子结构性质为动态规划算法解决问题提供了重要线索。
• 2.子问题重叠性质。子问题重叠性质是指在用递归算法自顶向下对问题进行求解时，每次产生的子问题并不总是新问题，有些子问题会被重复计算多次。

动态规划算法正是利用了这种子问题的重叠性质，对每一个子问题只计算一次，然后将其计算结果保存在一个表格中，当再次需要计算已经计算过的子问题时，只是在表格中简单地查看一下结果，从而获得较高的效率。

关于动态规划最经典的问题当属背包问题：下例。

def bag(n,c,w,v):
  res=[[-1 for j in range(c+1)] for i in range(n+1)]
  for j in range(c+1):
    res[0][j]=0
  for i in range(1,n+1):
    for j in range(1,c+1):
      res[i][j]=res[i-1][j]
      if j>=w[i-1] and res[i][j]<res[i-1][j-w[i-1]]+v[i-1]:
        res[i][j]=res[i-1][j-w[i-1]]+v[i-1]
  return res
def show(n,c,w,res):
  print('最大价值为:',res[n][c])
  x=[False for i in range(n)]
  j=c
  for i in range(1,n+1):
    if res[i][j]>res[i-1][j]:
      x[i-1]=True
      j-=w[i-1]
  print('选择的物品为:')
  for i in range(n):
    if x[i]:
      print('第',i,'个,',end='')
  print('')
if __name__=='__main__':
  n=5
  c=10
  w=[2,2,6,5,4]
  v=[6,3,5,4,6]
  res=bag(n,c,w,v)
  show(n,c,w,res)

十、朴素贝叶斯分类算法

朴素贝叶斯分类算法是一种基于贝叶斯定理的简单概率分类算法。贝叶斯分类的基础是概率推理，就是在各种条件的存在不确定，仅知其出现概率的情况下，如何完成推理和决策任务。

概率推理是与确定性推理相对应的。而朴素贝叶斯分类器是基于独立假设的，即假设样本每个特征与其他特征都不相关。

朴素贝叶斯分类器依靠精确的自然概率模型，在有监督学习的样本集中能获取得非常好的分类效果。在许多实际应用中，朴素贝叶斯模型参数估计使用最大似然估计方法，换言之朴素贝叶斯模型能工作并没有用到贝叶斯概率或者任何贝叶斯模型。

尽管是带着这些朴素思想和过于简单化的假设，但朴素贝叶斯分类器在很多复杂的现实情形中仍能够取得相当好的效果。