Zhang Phil

（2）在sorted函数里面，循环迭代的对亲代数组变异，因为进化的目标适应度是1，所以，当变异后的子代染色体适应度为1时候，退出循环，也即排序结束。排序结果 [1, 2, 3, 4, 5, 6, 7, 8]排序结果 [1, 2, 3, 4, 5, 6, 7, 8]排序结果 [1, 2, 3, 4, 5, 6, 7, 8]排序结果 [1, 2, 3, 4, 5, 6, 7, 8]排序结果 [1, 2, 3, 4, 5, 6, 7, 8]排序结果 [1, 2, 3, 4, 5, 6, 7, 8]

【代码】均匀交叉，遗传算法(Genetic Algorithm,GA)，python。

程序跑了10次，每一次在rws()函数中产生一个随机概率数值r，然后在rws()函数内部比较r与累积概率的大小，确定被选中的概率是p[?输出结果证实了我们的猜想，p[1]=0.49被选中的概率最高，在10次的随机筛选中，p[1]=0.49被选中了4次(4/10)。显然，p(s2)=0.49概率最大，被选中的概率最高。遗传算法(Genetic Algorithm，GA)的轮盘赌选择，python。一个简单的例子说明在遗传算法中使用的轮盘赌方法。

摩尔投票法，Boyer–Moore majority vote algorithm，也被称作多数投票法，求解众数的算法（Majority Vote Algorithm）。

Huffman哈夫曼树（霍夫曼树，赫夫曼树）在通信领域最主要的应用是数据编码，假设现在有A、B、C、D、E五个字符，它们出现的概率或者权值不同，从A到E，权值依次降低，那么就可以用哈夫曼最优二叉树对其进行编码。from binarytree import Node, get_parentdef app(): data = [(1, 'E'), (3, 'D'), (7, 'C'), (9, 'B'), (11, 'A')] huffman_tree = build_huffman

Huffman Tree哈夫曼树（霍夫曼树、赫夫曼树）权值路径长度WPL计算计算定义：把构建成功的哈夫曼树的每一个边缘节点（叶子）值乘以该节点到根的路径长度，最后求合。import randomfrom binarytree import Node, get_parentdef app(): data = [] # 生成随机测试数据。 for i in range(5): d = random.randint(1, 50) data

Huffman Tree，哈夫曼树（又被称为霍夫曼树、赫夫曼树），是一种基于贪心算法思想构建的二叉树，贪心算法寻求在建树过程中局部最优，最终迭代达到全局最优，从中可以看出，Huffman树的构建也体现了动态规划思想。Huffman Tree的贪心算法思想，寻找一种二叉树，使得WPL带路权的最小二叉树，因此，哈夫曼树也称为最优二叉树。现在基于binarytree，用Python构建哈夫曼树：import randomfrom binarytree import Nodedef app():

每一个节点包含值和指向下一个节点的指针。当前节点指向下一个节点是一个对象，直接打印是一串不容易识别的序列号，因此把下一个节点的值装入到当前节点，易于阅读和调试。

networkx节点node样式style定制化，Pythonimport networkx as nxfrom matplotlib import pyplot as pltKEY = 'key'def app(): G = nx.DiGraph() plt.figure(figsize=(12, 10), dpi=100) G.add_node(G.number_of_nodes()) G.add_node(G.number_of_nodes())

BST二叉搜索树查找节点元素，binarytree，Pythonimport randomimport binarytreedef app(): t = binarytree.bst(height=5, is_perfect=False) print(t) print('-----') idx = random.randint(1, t.size - 1) target = t.levelorder[idx].value # 从节点中随机找一个值

BST二叉搜索树插值建树re-balance再平衡构建AVL(Adelson-Velskii & Landis)平衡二叉搜索树import randomimport binarytreefrom matplotlib import pyplot as pltimport networkx as nx"""BST二叉搜索树插值建树re-balance再平衡构建AVL(Adelson-Velskii & Landis)平衡二叉搜索树"""LEFT = 'left'

networkx构建BST二叉搜索树，Pythonimport randomfrom matplotlib import pyplot as pltimport networkx as nxLEFT = 'left'RIGHT = 'right'def app(): SIZE = 10 data = [] for i in range(SIZE): data.append(i) random.shuffle(data) # da

原理：BFS广度搜索遍历后，从最后一个节点逆行向上，直到出发源点，没往上爬一层，高度加1。import networkx as nxdef get_node_height(G, number): height = 0 successors = G.successors(number) if len(list(successors)) == 0: height = 0 # print(number, '高度', height)

networkx有向图或树的root根节点，Python原理：networkx有向图或者一棵树，它的根节点（root节点），没有前驱（前继），或者称之为父节点。根据这一个原理，遍历所有networkx的节点，如果该节点没有前继节点（父节点），那么该节点就是整个有向图或树的root根节点。def get_root_node(G): node = None for n in G.nodes(data=True): predecessors = G.predecessor

BST二叉搜索树插入节点建树并找出失衡节点，networkx，Pythonimport randomfrom matplotlib import pyplot as pltimport networkx as nxPARENT = 'parent'LEFT = 'left'RIGHT = 'right'def app(): SIZE = 5 data = [] for i in range(SIZE): data.append(i)

思路：二叉搜索树之所以不平衡，发生在插入新节点后，那么沿着新插入节点，逆向沿着当前节点的父节点，一路检测节点平衡因子，当发现绝对值>1的平衡因子，即为最近的失衡点。def check_unblance(root, number): ret = None un_blance_node = None for n in root.levelorder: if n.value == number: un_blance_node = n

package demo;import java.util.ArrayList;import java.util.Collections;/** * * 反转一个List，关键是使用Collections工具类 * * @author Phil * */public class Demo { public static void main(String[] args)

这里仅仅把一连串随机数据插入到BST二叉树中：import randomimport binarytreefrom binarytree import get_parentdef app(): data = [] for i in range(10): data.append(i) random.shuffle(data) my_tree = None while len(data) > 0: d = data

完全二叉树小顶堆插入和删除节点，非递归，binarytree，Pythonimport binarytreefrom binarytree import heap, get_parentdef app(): # 构建一个小顶堆 hp = heap(height=3, is_max=False, is_perfect=False) print(hp) print('-') # 在堆中插入一个节点 values = hp.values va

二叉搜索树BST广度优先搜索遍历BFS计算树高度，非递归，binarytree，python基本原理：首先对二叉树搜索树进行BFS广度优先搜索遍历，搜索遍历后的节点访问依次顺序的存放在数组中，那么此时数组中最后一个节点，即是树中距离根最远的节点。然后用这个节点逆向的沿着父节点一层一层的往上爬，每爬一层就计数为1，直到根节点没有了父节点为止，算法结束。最终累计的计数即为树的高度。也就是说，广度遍历搜索是一种层次推进的搜索遍历，具体在BST二叉树搜索树中，一层代表数的高度1，对层高计数，即为该树的高度。

注意当节点非空，且在右子树高度减去左子树高度前，先给非空节点高度加1。对于本身高度为0的节点，意味着没有左右子树，直接返回平衡因子0。程序中直接使用了binarytree为每个节点的高度值属性height。from binarytree import bstdef app(): t = bst(height=4, is_perfect=False) print(t) print('-----') factors = [] for n in t.le

直接使用图中的节点父子关系循环遍历，不像之前那样在数组内操作排序。import randomfrom binarytree import build, get_parentdef app(): data = [] SIZE = 10 for i in range(SIZE): data.append(i) random.shuffle(data) my_tree = build(data) print(my_tree)

把一个无序的binarytree二叉树堆调整成一个标准大顶堆，非递归，pythonimport randomfrom binarytree import builddef app(): data = [] SIZE = 10 for i in range(SIZE): data.append(i) # 随机打乱数据 random.shuffle(data) my_tree = build(data) print('

一个简单的功能，把一个数组的全部数据反向（逆向）反转，比如，现在数组中的数据顺序为：[1，2，3，4，5]，要求把数组中数据全部反转为[5，4，3，2，1]python实现 ：def app(): data = [] for i in range(10): data.append(i) print('交换前', data) i = 0 j = len(data) - 1 while (i < j): #

binarytree二叉树节点DFS广度优先遍历，递归，python从左至右，逐层展开，递归实现。import randomfrom binarytree import builddef app(): data = [] for i in range(10): data.append(i) random.shuffle(data) root = build(data) root.pprint(index=False, delimi

binarytree二叉树节点的深度遍历，递归，pythonimport randomfrom binarytree import builddef app(): data = [] for i in range(13): data.append(i) random.shuffle(data) root = build(data) root.pprint(index=True, delimiter=',') paths =

binarytree二叉树节点的深度遍历，python注意对已经访问过的节点的处理，在while循环中，如果在栈回退时候，遇到之前访问过的节点，则直接弹出。弹出的情况还有一种就是该节点没有左右子节点了，表明到了尽头。import randomfrom binarytree import builddef app(): data = [] for i in range(8): data.append(i) random.shuffle(data)

import randomfrom binarytree import builddef app(): data = [] for i in range(9): data.append(i) random.shuffle(data) root = build(data) root.pprint(index=True, delimiter=',') print('binarytree标准遍历', root.values) .

选择排序符合人类直观，容易理解。工作过程：（第一轮）先选择数组array的第一个元素，即array[0]作为被对比对象，然后从数组array的第2个位置即array[1]（常规情况如此，当然你也可以从右边开始），扫描整个数组，找出最小的数据min_value，然后将这个min_value和array数组中的第一个数据（即array[0]）交换。(第二轮)选择数组中的第二个元素，即array[1]，然后从array[1]后面的数据中选择最小的数据与array[1]交换。如此循环往复，最终多轮，直到

binarytree用来构建二叉树堆很便利，比如：from binarytree import tree, Node, build, get_parentdef app(): my_tree = tree(height=3, is_perfect=False) print(my_tree.pprint(index=True)) print('-') root = Node(1) # index: 0, value: 1 root.left = Node

（1）Dijkstra Algorithm算法结束后，在代码生成的二维网格图中所有节点的权值即为出发点（源点）到当前节点的最短路径。（2）通过每个节点中保存的parent指针一路逆行往上迭代查找，直到出发点（源点），即为出发点到当前节点的最短路径。parent指针指向了到当前节点的最短路径父节点。（3）本例中网格图中所有邻接边权值为1。（4）Dijkstra Algorithm在本例中作为一种广度优先搜索寻找最短路径，在每个节点中加入的parent指针，将其形成一定程度具有深度的寻路思想。这..

import randomimport networkx as nximport matplotlib.pyplot as pltWALKABLE = 'walkable'PARENT = 'parent'VISITED = 'visited'def my_graph(): M = 7 N = 9 G = nx.grid_2d_graph(m=M, n=N) pos = nx.spring_layout(G, iterations=100) ...

import randomimport networkx as nximport matplotlib.pyplot as pltWALKABLE = 'walkable'PARENT = 'parent'VISITED = 'visited'def my_graph(): M = 7 N = 9 G = nx.grid_2d_graph(m=M, n=N) pos = nx.spring_layout(G, iterations=100) ...

运行代码，跑几轮，看看程序选的路线如何。此时查找open_list中所有节点的具有最小F值的节点 V' （此处是 V' 撇，不是 V，表示V选好后，进行第二轮选点的那个节点），V' 选出来后，再次把 V' 所有相邻的节点加入到open_list中，同时把 V' 从open_list中删掉，并把V' 加入到close_list中去。逆向的从终点开始，找出终点保存的父节点指向谁，然后逆向，然后再找到终点的父节点的父节点......，一路逆行查找，直到查找到父节点为出发点为止，即为A*选出来的路径。

（1）Bellman Ford Algorithm，贝尔曼-福特算法，图中搜索遍历最短路径的一种适应性强的算法。Bellman Ford Algorithm可以应用在负值边权的图，这和dijkstra最短路径算法有差异，dijkstra不适应于存在负边权的图。Bellman Ford Algorithm是一种广度优先搜索最短路径策略。经过全部迭代后，每一个节点中保存的权值（node weight），即为从起始点（一般为0）到该节点的最小路径值。（2）Bellman Ford Algorithm在迭代开始

（1）深度优先搜索遍历，通常使用栈来保存遍历搜索过的节点记录。当搜索到的节点没有子节点，意味着达到了尽头，开始回退。回退的过程其实就是把栈顶的节点弹出（删掉），然后再次在栈中读第一个元素（本例是列表实现的栈，即为0号元素）。（2）每个节点用一个标志位标记当前节点是否已经访问过，如果访问过，压入栈顶。（3）每次迭代独取当前顶点V时候，同时要把顶点V的子节点压入栈。import networkx as nximport matplotlib.pyplot as plt# 记录搜索路径s

Breadth First Search，广度优先搜索（遍历），BFS实现一般基于队列。队列在广度优先搜索遍历中是关键点。（1）队列Q在弹出最左边头部的节点V的同时，要把与V邻接的子节点立即加入队列Q的尾部。然后在while循环中重复处理（弹出最最左边头部的节点）。直到队列的长度为0，循环结束，也即算法完成遍历搜索。（2）本例基于networkx实现，networkx提供了节点、图、边的现成工具，只需要按照需要记录节点的访问情况，当每一个节点作为顶点被弹出时候，标记它为已访问（visited=tru

DFS又称为深度优先遍历，在图论中用于搜索图中的点和路径。简单写一个Python实现，图的表示用networkx。networkx本身提供了节点连接的结构已经提供了对节点状态值保存的便捷手段。在每个节点中存放一个visited值，boolean类型，如果已经访问过，记为true，不再搜索遍历。import networkx as nximport matplotlib.pyplot as plt# 记录搜索路径search_path = []def my_graph(): #

自己用Python写的Dijkstra实现，练手import randomimport timeimport networkx as nximport matplotlib.pyplot as pltfrom collections import dequedef my_graph(): # 随机图6个node，8条edge G = nx.gnm_random_graph(6, 8) # 为图中的边增加随机的权 dict_edgs = {}

import networkx as nximport matplotlib.pyplot as pltdef my_graph(): # 构造一个有权边的无向图，然后找出最小生成树 G = nx.Graph() # 无向图 nodes = ['a', 'b', 'c', 'd', 'e', 'f'] G.add_nodes_from(nodes) G.add_edges_from([('a', 'b', {'weight': 6}), ...