二叉树:二叉树要么为空,要么包含一个根节点,外加一个左子树和一个右子树,每个子树都是一个二叉树。
二叉搜索树:用树的结构表示有序集合;
二叉搜索树的每个子树都是一个二叉搜索树;
若左子树不为空,则左子树的任意节点的值都小于根节点的值;
若右子树不为空,则右子树的任意节点耳钉值都大于根节点的值
完美平衡二叉树:以满二叉树为参考,在最后一个层级以外的每一个层上,都包含了完整的节点。
完全二叉树:是平衡二叉树的一种特殊情况,最后一层的所有节点都是从左向右填充的。
二叉树的三种场景应用:堆,二叉搜索树,表达式树
#! /usr/bin/env python
# -*- coding: utf-8 -*-
'''
@author: liudaoqiang
@file: studycase
@time: 2018/9/25 21:54
'''
import unittest
class Node(object):
def __init__(self, data, next):
self._data = data
self._next = next
def __iter__(self):
cursor = self
while cursor != None:
yield cursor._data
cursor = cursor._next
class Array(object):
def __init__(self, capacity, fillValue=None):
self._items = list()
for index in range(capacity):
self._items.append(fillValue)
def __iter__(self):
return iter(self._items)
def __len__(self):
return len(self._items)
def __getitem__(self, index):
return self._items[index]
def __setitem__(self, index, newItem):
self._items[index] = newItem
def __str__(self):
return str(self._items)
class TwoWayNode(Node):
def __init__(self, data, prev=None, next=None):
Node.__init__(self, data, next)
self._prev = prev
class AbstractCollection(object):
def __init__(self, sourceCollection):
self._size = 0
for item in sourceCollection:
self.add(item)
def isEmpty(self):
return self._size == 0
def __add__(self, other):
result = type(self)(self)
for item in other:
result.add(item)
return result
def __len__(self):
return self._size
def __str__(self):
return str(self)
def __eq__(self, other):
if self is other: return True
if type(self) != type(other) or \
len(self) != len(other):
return False
else:
otherIter = iter(other)
for item in self:
if item != next(otherIter):
return False
return True
class AbstractStack(AbstractCollection):
"""AbstractStack of ArrayStack and LinkedStack"""
def __init__(self, sourceCollection=None):
AbstractCollection.__init__(self, sourceCollection)
def add(self, item):
self.push(item) # 在ArrayStack和LinkedStack实现push方法
class LinkedStack(AbstractStack):
def __init__(self, sourceCollection=None):
self._items = None
AbstractStack.__init__(self, sourceCollection)
# Accessors
def __iter__(self):
def visitNode(node):
if node != None:
visitNode(node._next)
templist.append(node._data)
templist = list()
visitNode(self._items)
return iter(templist)
def peek(self):
if self.isEmpty():
raise KeyError("The Stack is empty")
return self._items.data
def __str__(self):
return "{" + " ,".join(map(str, iter(self))) + "}"
# Mutator
def clear(self):
self._size = 0
self._items = None
def push(self, item):
self._items = Node(item, self._items)
self._size += 1
def pop(self):
if self.isEmpty():
raise KeyError("The stack is empty")
oldItem = self._items.data
self._items = self._items.next
self._size -= 1
return oldItem
class BSTNode(object):
"""Represents a node for a linked binary search tree."""
def __init__(self, data, left=None, right=None):
self.data = data
self.left = left
self.right = right
class LinkedBST(AbstractCollection):
"""A Linked-based binary search tree implementation"""
def __init__(self, sourceCollection):
self._root = None
AbstractCollection.__init__(self, sourceCollection)
def find(self, item):
# Helper function to search the binary tree
def recurse(node):
if node is None:
return None
elif item == node.data:
return node.data
elif item < node.data:
return recurse(node.left)
else:
return recurse(node.right)
# Top-level call on the root node
return recurse(self._root)
def inorder(self):
"""中序遍历"""
lyst = list()
def recurse(node):
if node != None:
recurse(node.left)
lyst.append(node.data)
recurse(node.right)
recurse(self._root)
return iter(lyst) # 返回一个迭代器
def postorder(self):
lyst = list()
def recurse(node):
pass
recurse(self._root)
return iter(lyst) # 返回一个迭代器
def levelorder(self):
lyst = list()
def recurse(node):
pass
recurse(self._root)
return iter(lyst) # 返回一个迭代器
def __iter__(self):
"""Supports a preorder traversal on a view of self."""
linkedstack = LinkedStack()
lyst = list()
linkedstack.push(self._root)
while not linkedstack.isEmpty():
temp = linkedstack.pop()
yield temp
if temp.right is not None:
linkedstack.push(temp.right)
if temp.left is not None:
linkedstack.push(temp.left)
def __str__(self):
def recurse(node, level):
s = ""
if node != None:
s += recurse(node.right, level + 1)
s += "| " * level
s += str(node.data) + "\n"
s += recurse(node.left, level + 1)
return s
return recurse(self._root, 0)
def add(self, item):
def recurse(node):
if item < node.data:
if node.left == None:
node.left = BSTNode(item)
elif node.right == None:
node.right = BSTNode(item)
else:
recurse(node.right)
if self.isEmpty():
self._root = BSTNode(item)
else:
recurse(self._root)
self._size += 1
def __contains__(self, item):
return self.find(item) != None
def clear(self):
self._root = None
self._size = 0
def remove(self, item):
"""Precondition: item is in self.
Raises: KeyError if item is not in self.
postcondition: item is removed from self."""
if not item in self:
raise KeyError("Item not in tree.""")
# Helper function to adjust placement of an item
def liftMaxInLeftSubtreeToTop(top):
# Replace top's datum with the maximum datum in the left subtree
# Pre: top has a left child
# Post: the maximum node in top's left subtree
# has been removed
# Post: top.data = maximum value in top's left subtree
parent = top
currentNode = top.left
while not currentNode.right == None:
parent = currentNode
currentNode = currentNode.right
top.data = currentNode.data
if parent == top:
top.left = currentNode.left
else:
parent.right = currentNode.left
# Begin main part of the method
if self.isEmpty(): return None
# Attempt to locate the node containing the item
itemRemoved = None
preRoot = BSTNode(None)
preRoot.left = self._root
parent = preRoot
direction = 'L'
currentNode = self._root
while not currentNode == None:
if currentNode.data == item:
itemRemoved = currentNode.data
break
parent = currentNode
if currentNode.data > item:
direction = 'L'
currentNode = currentNode.left
else:
direction = 'R'
currentNode = currentNode.right
# Return None if the item is absent
if itemRemoved == None: return None
# The item is present, so remove its node
# Case 1: The node has a left and a right child
# Replace the node's value with the maximum value in the
# left subtree
# Delete the maximium node in the left subtree
if not currentNode.left == None \
and not currentNode.right == None:
liftMaxInLeftSubtreeToTop(currentNode)
else:
# Case 2: The node has no left child
if currentNode.left == None:
newChild = currentNode.right
# Case 3: The node has no right child
else:
newChild = currentNode.left
# Case 2 & 3: Tie the parent to the new child
if direction == 'L':
parent.left = newChild
else:
parent.right = newChild
# All cases: Reset the root (if it hasn't changed no harm done)
# Decrement the collection's size counter
# Return the item
self._size -= 1
if self.isEmpty():
self._root = None
else:
self._root = preRoot.left
return itemRemoved
def replace(self, item, newItem):
"""
If item is in self, replaces it with newItem and
returns the old item, or returns None otherwise."""
probe = self._root
while probe != None:
if probe.data == item:
oldData = probe.data
probe.data = newItem
return oldData
elif probe.data > item:
probe = probe.left
else:
probe = probe.right
return None
class TestCase(unittest.TestCase):
pass
if __name__ == "__main__":
tree = LinkedBST()
print("Adding D B A C F E G")
tree.add("D")
tree.add("B")
tree.add("A")
tree.add("C")
tree.add("F")
tree.add("E")
tree.add("G")
print("\nTree structure:\n")
print(tree)