二叉树是很重要的数据结构，在面试还是日常开发中都是很重要的角色。

首先是建立树的过程，对比C或是C++的实现来讲，其涉及到了较为复杂的指针操作，但是在面向对象的语言中，就不需要考虑指针, 内存等。首先我们需要定义一个树节点, 我们采用基于链表设计的节点, 首先定义一个数据域, 其次就是左孩子和右孩子。如下定义:

 

  # 树节点的定义

class Node:

    def __init__(self, data=-1, lchild=None, rchild=None):

        self.lchild = lchild  # 表示左子树

        self.rchild = rchild  # 表示右子树

        self.data = data  # 表示数据域

 

 

建立树的实现有两种，遍历建树与层次建树，这两种分别是基于堆栈和队列来实现的，先来看看最基本的递归建树。递归建树的过程无非就是一路走到底，但是需要将节点的左右孩子节点对其余的节点相关联起来。因此，我们可以如此来实现:

 

  def traversal_create(self, root):

data = input()

if data is "#":

return None

else:

root.data = data

root.lchild = self.traversal_create(root.lchild)

root.rchild = self.traversal_create(root.rchild)

return root

 

首先我们传入的参数是一个默认的节点，其data数据域为-1，然后我们接受输入的数据，赋值给节点数据域，然后就是递归了，将左右孩子节点关联起来。总体来讲，应该不难理解。

下面看看层次建树的实现，所谓层次建树其实就是基于队列的操作，利用队列先进先出的特点，每次我们访问一个节点的时候，将其存入队列中，待遍历玩当前节点的左右孩子节点，队列就弹出一个节点，之后的操作都是一样的。看看代码:

 

  def add(self, elem):

node = Node(elem)

# 根节点

if self.root.data == -1:

self.root = node

self.myQueue.append(self.root)

else:

treeNode = self.myQueue[0] # 记录结点

if treeNode.lchild is None:

treeNode.lchild = node

self.myQueue.append(treeNode.lchild)

else:

treeNode.rchild = node

self.myQueue.append(treeNode.rchild)

self.myQueue.popleft() # 弹出已经处理好左右子树的父结点

 

我们输入一个数据，然后根据数据初始化一个节点，放入队列中，随后就是访问的操作了。

树的三序遍历就不用说了，基于递归的，很好理解，那么基于队列以及堆栈的的遍历呢？对比下基于队列的建树，我们完全可以写出基于队列的遍历, 也是使用队列来存储节点，然后输出左右孩子的数据：

 

  # 层次遍历 使用队列

def queue_tarversal(self, root):

if root is None:

return

q = deque()

q.append(root)

while q:

node = q.pop()

print(node.data)

if node.lchild is not None:

q.append(node.lchild)

else:

q.append(node.rchild)

 

基于堆栈的呢？联想下堆栈的特点，我们一路沿着左子树遍历下去，同时使用堆栈来存储元素，然后在弹出遍历右孩子节点：

 

  # 使用堆栈来遍历

def stack_traversal(self, root):

if root is None:

return

mystack = []

node = root

while node or mystack:

while node:

print(node.data)

mystack.append(node)

node = node.lchild

node = mystack.pop()

node = node.rchild

 

数据结构是难点也是基础，不管怎么样都应该好好学习。

完整代码:



  

   ''' 二叉树的建立及实现 (递归与非递归) '''

from collections import deque



# 树节点的定义

class Node:

    def __init__(self, data=-1, lchild=None, rchild=None):

        self.lchild = lchild  # 表示左子树

        self.rchild = rchild  # 表示右子树

        self.data = data  # 表示数据域



class Create_Tree:

    def __init__(self):

        self.root = Node()  # 表示结点

        self.myQueue = deque()  # 使用队列不会有太多的内存开销


    # 按层次生成树

    def add(self, elem):

        node = Node(elem)

        # 根节点

        if self.root.data == -1:

            self.root = node

            self.myQueue.append(self.root)

        else:

            treeNode = self.myQueue[0]  # 记录结点

            if treeNode.lchild is None:

                treeNode.lchild = node

                self.myQueue.append(treeNode.lchild)

            else:

                treeNode.rchild = node

                self.myQueue.append(treeNode.rchild)

                self.myQueue.popleft()  # 弹出已经处理好左右子树的父结点


    # 递归建树

    def traversal_create(self, root):

        data = input()

        if data is "#":

            return None

        else:

            root.data = data

            root.lchild = self.traversal_create(root.lchild)

            root.rchild = self.traversal_create(root.rchild)

        return root


    # 前序遍历输出

    def digui(self, root):

        if root is None:

            return

        print(root.data)

        self.digui(root.lchild)

        self.digui(root.rchild)


    # 使用堆栈来遍历

    def stack_traversal(self, root):

        if root is None:

            return

        mystack = []

        node = root

        while node or mystack:

            while node:

                print(node.data)

                mystack.append(node)

                node = node.lchild

            node = mystack.pop()

            node = node.rchild


    # 层次遍历 使用队列

    def queue_tarversal(self, root):

        if root is None:

            return

        q = deque()

        q.append(root)

        while q:

            node = q.pop()

            print(node.data)

            if node.lchild is not None:

                q.append(node.lchild)

            else:

                q.append(node.rchild)



if __name__ == "__main__":

    elems = range(10)

    tree = Create_Tree()

    for i in elems:

        # 非递归建树，主要就是根据 队列FIFO的特点以及广度遍历的思路

        tree.add(i)


    # 递归建树

    # tree.traversal_create(tree.root)


    # 递归遍历

    tree.digui(tree.root)

    # 栈遍历

    # tree.stack_traversal(tree.root)

  

  View Code