二叉树

二叉树的深度优先搜索，包括前序，中序，后序三种，这个序是站在父节点的角度说的，这样也好记忆一点。

（需要记住，左叉一直在右叉的前面，这个关系式稳定的）

根在前，就叫先序遍历。父--左--右

根在中，就叫中序遍历，左-父-右

根在后，就叫后序遍历，左-右-父

要想知二求一，必须得有中序遍历的结果。

推导的主要方法，是找出每个子树的根节点

 下面是层次遍历与深度遍历的程序Python

实现前序等深度查找，可以用递归的方式

#coding:utf-8

class Node(object):
    def __init__(self, item):
        self.item= item
        self.lchild=None
        self.rchild= None
class BinaryTree(object):
    def __init__(self):
        self.root =  None
    def add(self, item):
        node = Node(item)
        if self.root is None:     #防止空的情况出错
            self.root = node
            return
        queue = [self.root]
        while queue:    #直到这个队列为空停止，参见视频https://www.bilibili.com/video/av50524094/?p=51
            cur_node = queue.pop(0)
            if cur_node.lchild is None:
                cur_node.lchild = node
                return
            else:
                queue.append(cur_node.lchild)

            if cur_node.rchild is None:
                cur_node.rchild = node
                return
            else:
                queue.append(cur_node.rchild)

    def breadth_travel(self):
        """广度遍历"""
        out =[self.root]
        realout =[self.root.item]
        while out:
            cur_node = out.pop(0)
            if cur_node.lchild is None and cur_node.rchild is None:
                break
            if cur_node.lchild is not None:
                out.append(cur_node.lchild)
                realout.append(cur_node.lchild.item)
            if cur_node.rchild is not None:
                out.append(cur_node.rchild)
                realout.append((cur_node.rchild.item))
        return realout

    def preorder(self,node):
        if node is None:
            return
        print(node.item)
        self.preorder(node.lchild)
        self.preorder(node.rchild)

    def inorder(self,node):
        if node is None:
            return
        self.inorder(node.rchild)
        print(node.item)
        self.inorder(node.lchild)


    def postorder(self,node):
        if node is None:
            return
        self.postorder(node.rchild)
        self.postorder(node.lchild)
        print(node.item)



tree = BinaryTree()
tree.add(1)
tree.add(2)
tree.add(3)
tree.add(4)
tree.add(5)
tree.add(6)
print("广度优先（层次）")
print(list(tree.breadth_travel()))
print("前序")
tree.preorder(tree.root)

print("中序")
tree.inorder(tree.root)

print("后序")
tree.postorder(tree.root)

 

广度优先（层次）
[1, 2, 3, 4, 5, 6]
前序
1
2
4
5
3
6
中序
3
6
1
5
2
4
后序
6
3
5
4
2
1

超级好的视频资料推荐：https://www.bilibili.com/video/av50524094/?p=52