Examples of binary tree algorithm and KMP algorithm implemented by python
- 2020-04-02 13:35:47
- OfStack
It mainly includes: preorder traversal, middle order traversal, post-order traversal, hierarchical traversal, non-recursive preorder traversal, non-recursive in-order traversal, and non-recursive post-order traversal
#!/usr/bin/env python
#-*- coding:utf8 -*-
class TreeNode(object):
def __init__(self, data=None, left=None, right=None):
self.data = data
self.left = left
self.right = right
class Tree(object):
def __init__(self, root=None):
self.root = None
def makeTree(self, data, left, right):
self.root = TreeNode(data, left, right)
def is_empty(self):
""" Whether is empty """
if self.root is None:
return True
return False
def preOrder(self, r):
""" The former sequence traversal """
if not r.is_empty():
print r.root.data
if r.root.left is not None:
r.preOrder(r.root.left)
if r.root.right is not None:
r.preOrder(r.root.right)
def inOrder(self, r):
""" In the sequence traversal """
if not r.is_empty():
if r.root.left is not None:
r.preOrder(r.root.left)
print r.root.data
if r.root.right is not None:
r.preOrder(r.root.right)
def postOrder(self, r):
""" Subsequent traversal """
if not r.is_empty():
if r.root.left is not None:
r.preOrder(r.root.left)
print r.root.data
if r.root.right is not None:
r.preOrder(r.root.right)
def levelOrder(self, r):
""" Level traversal """
if not r.is_empty():
s = [r]
while len(s) > 0:
temp = s.pop(0) # First pop first append To the point
if temp and temp.root is not None:
print temp.root.data
if temp.root.left is not None:
s.append(temp.root.left)
if self.root.right is not None:
s.append(temp.root.right)
def preOrder1(self, r):
""" non-recursive The former sequence traversal """
stack = []
current = r
while len(stack) > 0 or (current and not current.is_empty()):
while current and not current.is_empty():
print current.root.data
stack.append(current)
current = current.root.left
if len(stack) > 0:
current = stack.pop()
current = current.root.right
def inOrder1(self, r):
""" non-recursive In the sequence traversal """
stack = []
current = r
while len(stack) > 0 or (current and not current.is_empty()):
while current and not current.is_empty():
stack.append(current)
current = current.root.left
if len(stack) > 0:
current = stack.pop()
print current.root.data
current = current.root.right
def postOrder1(self, r):
""" non-recursive Subsequent traversal """
stack = []
current = r
pre = None
while len(stack) > 0 or (current and not current.is_empty()):
if current and not current.is_empty():
stack.append(current)
current = current.root.left
elif stack[-1].root.right != pre:
current = stack[-1].root.right
pre = None
else:
pre = stack.pop()
print pre.root.data
def leaves_count(self, r):
""" Find the number of leaf nodes """
if r.is_empty():
return 0
elif (not r.root.left) and (not r.root.right):
return 1
else:
return r.root.left.leaves_count(r.root.left) + r.root.right.leaves_count(r.root.right)
if __name__ == '__main__':
""" Binary tree """
ra, rb, rc, rd, re, rf = Tree(), Tree(), Tree(), Tree(), Tree(), Tree()
ra.makeTree("a", None, None)
rb.makeTree("b", None, None)
rc.makeTree("c", None, None)
rd.makeTree("d", None, None)
re.makeTree("e", None, None)
rf.makeTree("f", None, None)
r1, r2, r3, r4, r = Tree(), Tree(), Tree(), Tree(), Tree()
r1.makeTree("-", rc, rd)
r2.makeTree("*", rb, r1)
r3.makeTree("+", ra, r2)
r4.makeTree("/", re, rf)
r.makeTree("-", r3, r4)
r.preOrder(r)
r.inOrder(r)
r.postOrder(r)
r.levelOrder(r)
print r.leaves_count(r)
I learned KMP algorithm when I was in college, but I found that I forgot it when I read it recently, so I went to read the book again and wrote down the algorithm in python:
def kmp(text, pattern):
"""kmp algorithm """
pattern = list(pattern)
next = [-1] * len(pattern)
#next function
i, j = 1, -1
for i in range(1, len(pattern)):
j = next[i - 1]
while True:
if pattern[i - 1] == pattern[j] or j == -1:
next[i] = j + 1
break
else:
j = next[j]
# Cycle comparison
i, j = 0, 0
while i < len(text) and j < len(pattern):
if text[i] == pattern[j] or j == -1:
i += 1
j += 1
else:
j = next[j]
# Returns the result If it matches, return the matching location, otherwise -1
if j == len(pattern):
print i � j
else:
print -1