Binary Tree
- Root: the upper node in the tree
- Left leaf node
- Right leaf node
- Subtree
- Complete sub-tree
- A root node, leaf nodes around
- Incomplete subtree
- Root, leaf nodes left
- The root node, the right leaf node
- Root
- Features: Each node can act as a sub-root node of a tree
- Complete sub-tree
definition:
class Node(object):
def __init__(self,item):
self.item = item
self.left = None
self.right = None
class Tree(object):
def __init__(self): # 构建一颗空树
self.root = None # 永远指向二叉树中的根节点
def insert(self,item):
"""按照自上到下，从左到右的准则插入新的节点"""
node = Node(item)
cur = self.root
if not cur: # 这里不设防的话，如果二叉树根节点为空，下面的obj.left就会报错
self.root = node
return
q = [cur] # 列表中存放需要迭代的根节点
while q:
obj = q.pop(0) # 按顺序迭代取第一个元素，满足从上到下，从左到右
if not obj.left: # 如果存在就添加到列表中，分析他的子节点有没有空的
obj.left = node
break
if not obj.right:
obj.right = node
break
q.append(obj.left)
q.append(obj.right)
def travel(self):
"""广度遍历"""
cur = self.root
q = [cur] # [None,None]这种情况是存在的
if not cur: # 这里不设防的话，如果二叉树根节点为空，下面的obj.left就会报错
return
while q:
obj = q.pop(0)
print(obj.item)
if obj.left:
q.append(obj.left)
if obj.right:
q.append(obj.right)
use:
tree = Tree()
tree.insert(1)
tree.insert(3)
tree.insert(2)
tree.insert(5)
tree.insert(6)
tree.insert(4)
tree.insert(7)
tree.travel()
1
3
2
5
6
4
7
tree = Tree()
tree.travel() # 不报错就行，测试下
Binary tree traversal
-
Breadth traversal
- The code (Travel) in traverse, is traversed breadth. From top to bottom traversal is called progressive breadth traversal.
- Lateral traverse, one level output
-
Depth traversal: longitudinal traverse. Before the desired form postorder acting subtree. In front of the preamble of after referring to the position of the root node in the subtree
- Preamble: about root, traversing the first sub-tree root, traversing the nodes in the left subtree is the right node then
- In order: left and right root
- After the sequence: about Root
-
Realize the idea of the depth of traversal
- Depth traversal is required to effect a child every tree
- The difference between the sub-tree and sub-trees reflected in the root node.
- If a write function that can be a child node in the tree is traversed to the effect of the function in other subtrees can traverse the entire tree depth.
definition:
class Node(object):
def __init__(self,item):
self.item = item
self.left = None
self.right = None
class Tree(object):
def __init__(self): # 构建一颗空树
self.root = None # 永远指向二叉树中的根节点
def insert(self,item):
"""按照自上到下，从左到右的准则插入新的节点"""
node = Node(item)
cur = self.root
if not cur: # 这里不设防的话，如果二叉树根节点为空，下面的obj.left就会报错
self.root = node
return
q = [cur] # 列表中存放需要迭代的根节点
while q:
obj = q.pop(0) # 按顺序迭代取第一个元素，满足从上到下，从左到右
if not obj.left: # 如果存在就添加到列表中，分析他的子节点有没有空的
obj.left = node
break
if not obj.right:
obj.right = node
break
q.append(obj.left)
q.append(obj.right)
def travel(self):
cur = self.root
q = [cur] # [None,None]这种情况是存在的
if not cur: # 这里不设防的话，如果二叉树根节点为空，下面的obj.left就会报错
return
while q:
obj = q.pop(0)
print(obj.item)
if obj.left:
q.append(obj.left)
if obj.right:
q.append(obj.right)
def forward(self,root): # 根左右
if not root:
return
print(root.item)
self.forward(root.left) # 递归
self.forward(root.right)
def middle(self,root): # 左根右
if not root:
return
self.middle(root.left)
print(root.item)
self.middle(root.right)
def back(self,root): # 左右根
if not root:
return
self.back(root.left)
self.back(root.right)
print(root.item)
use:
tree = Tree()
tree.insert(1)
tree.insert(3)
tree.insert(2)
tree.insert(5)
tree.insert(6)
tree.insert(4)
tree.insert(7)
tree.back(tree.root)
5
6
3
4
7
2
1
Sorting binary tree
Sort personal understanding binary ***:
- Before always felt sort of binary tree + in order to traverse the deep will be positive sequence elements arranged in a bit of magic, but I kept thinking suddenly some perception, this method is not so magical:
- Above diagram, for example, 3 to the right (the right child node and below), no matter which element, no matter how to find, definitely better than 3 large; element 8 to the left, absolutely than 8 hours; element 5 on the right than the absolute 5 large
- This can understand, right? 5, for example, if I did not I have the right elements in large, how he did not become my left child, or a child node becomes the left child node beneath it? First, it would pass with me
- So like to understand it, sort binary tree middle (in order) means to the left and right to the root of ordering principles:
- Traversing 3, left side 2, 2 traversal, a left side, a traverse, left empty, output 1, Right empty, returns to the left 2,2 completed, output 2, 2 right traverse right is empty, 3,3 return to the left traversal is complete, the output 3, right 8,8 3 left traverse 5, 5,5 traverse left empty, output 5, 7, 7 left right traversal 5, 6, traverse 6,6 empty at the output 6, 7 to return to the output 7, the right side is empty, return to 5, 8 to return to the output 8, the right side is empty, return to 3, the end of
- Before a question that only 5 to 6 output as early as 5 above, then I wanted to understand, as long as 6 5 on the right, below or to the right, he definitely larger than 5, otherwise, it will only be added when the original 5 the left!
definition:
class Node(object):
def __init__(self,item):
self.item = item
self.left = None
self.right = None
class SortTree(object):
def __init__(self):
self.root = None
def add(self,item):
node = Node(item)
cur = self.root
if not cur: # 排序二叉树根节点不存在，该元素就直接作为根节点
self.root = node
return
while 1:
if node.item > cur.item: # 如果大于你，就作为你的右子节点
if not cur.right: # 不存在就直接赋值
cur.right = node
break
else: # 如果右子节点已经存在，就与右子节点再进行比较
cur = cur.right
else:
if not cur.left:
cur.left = node
break
else:
cur = cur.left
def middle(self,root): # 左根右
if not root:
return
self.middle(root.left)
print(root.item)
self.middle(root.right)
use:
alist = [3,8,5,7,6,2,1]
tree = SortTree()
for item in alist:
tree.add(item)
tree.middle(tree.root) # 排序二叉树+中序深层遍历 会得到正序排列的元素
# 上面的alist换成[3,8,6,7,5,2,1]结果依然是正序排列，因为如果先6后5，到时候5就会作为6的左子节点，还是会先输出5，这方法真他妈神奇
1
2
3
5
6
7
8
Binary search
- Binary search can only be in effectOrdered sequence, The following are defined forBinary integer function lookup。
Binary integer function lookup
def find(items,item):
"""
第一个参数items必须是 有序序列；
item是我们要在item中查找的元素
"""
low_index = 0
high_index = len(items) - 1
find = False
# 因为是有序排列的list，所以如果都不在最小值最大值范围内，那循环查找不是浪费时间吗？
if item < items[low_index] or item > items[high_index]:
return find
# while not find: # 这种也可以，但是没有下面的严谨
while low_index <= high_index: # 这个=很重要，不然上图中的第一种情况就会查找失败
middle_index = (high_index + low_index) // 2 # 取中间索引
if items[middle_index] > item:
high_index = middle_index - 1
# 是不是好奇为啥要-1，由于我们一直是通过中间索引对应值与目标值进行比较，这样漏掉一个值会不会导致这个数据逃过检验呢？在有序序列内的元素都是整数的情况下是不会的，考虑绝对情况，漏掉的这个数据最多也就是中间值左侧的这个数，而我们high-1也正好是那个数，而之后的中间值绝对只会<=目标值，也就是说以后变动的只会是low索引值，而我们允许最大索引值=最小索引值，那么在一次次low+1的情况下，早晚会查找到这个元素
elif items[middle_index] < item:
low_index = middle_index + 1 # 同理，如果要针对非整数，那这个+1/-1就需要做出变动
else: # 中间序列对应值正好就是目标值
find = True
break
return find
use:
alist = [1,2,3,4,5,6,7,8,9]
print(find(alist,6))
print(find(alist,8))
True
True