二叉樹的構造和七種遍歷算法

 

二叉樹的節點類：

class Node(object):
    def __init__(self, data):
        self.data = data
        self.left = None
        self.right = None

 構造一棵二叉樹：

class Build_Tree(object):
    def __init__(self):
        self.root = None
        self.queue = []
    def add(self, data):
        node = Node(data)
        if not self.root:
            self.root = node
        else:
            temp = self.queue[0]
            if not temp.left:
                temp.left = node
            elif not temp.right:
                temp.right = node
                self.queue.pop(0)
        self.queue.append(node)

l = [1,2,3,4,5,6,7,8,9]
tree = Build_Tree()
for i in l:
    tree.add(i)
root = tree.root

層次遍歷：

import sys

if sys.version > '3':     # python 2 3 queue 不兼容
    from queue import Queue
else:
    from Queue import Queue

def level_order(root):
    q = Queue()
    if root:
        q.put(root)
    while not q.empty():
        temp = q.get()
        if temp.left:
            q.put(temp.left)
        if temp.right:
            q.put(temp.right)
        level_res.append(temp.data)

level_res = []
level_order(root)
print 'level_res:', level_res

前序、中序、後序遍歷的遞歸方法：

def pre_order(root):
    if root:
        pre_res.append(root.data)
        pre_order(root.left)
        pre_order(root.right)

def mid_order(root):
    if root:
        mid_order(root.left)
        mid_res.append(root.data)
        mid_order(root.right)

def post_order(root):
    if root:
        post_order(root.left)
        post_order(root.right)
        post_res.append(root.data)

pre_res = []
pre_order(root)
print 'pre_res:', pre_res

mid_res = []
mid_order(root)
print 'mid_res:', mid_res

post_res = []
post_order(root)
print 'post_res:', post_res

前序遍歷的非遞歸形式：

def pre_order_without_recursion(root):
    s = []
    while root or s:
        if root:
            pre_res_without_rec.append(root.data)
            s.append(root.right)
            root = root.left
            #s.append(root.right)
        else:
            root = s.pop()

pre_res_without_rec = []
pre_order_without_recursion(root)
print 'pre_res_without_rec:', pre_res_without_rec

中序遍歷的非遞歸形式：

def mid_order_without_recursion(root):
    s = []
    while root or s:
        if root:
            s.append(root)
            root = root.left
        else:
            root = s.pop()
            mid_res_without_rec.append(root.data)
            root = root.right

mid_res_without_rec = []
mid_order_without_recursion(root)
print 'mid_res_without_rec:', mid_res_without_rec

後序遍歷的非遞歸形式：

def post_order_without_recursion(root):
    s = []
    pre = None
    while root:
        while root.left:
            s.append(root)
            root = root.left
        while root and (not root.right or root.right == pre):
            post_res_without_rec.append(root.data)
            pre = root
            if not s:
                return
            root = s.pop()
        s.append(root)
        root = root.right

post_res_without_rec = []
post_order_without_recursion(root)
print 'post_res_without_rec:', post_res_without_rec

 

二叉樹可以爲空