python 二叉树实现

二叉树实现思想

　　1、把每个节点都看作是一个对象包含以下特征：

　　　　　　节点的当前值

　　　　　　节点的左孩子（存储比当前节点值小的节点对象）

　　　　　　节点右孩子（存储比当前节点值大的节点对象）

　　2、二叉树就是以根节点开始的连续的对象串

代码实现：

# -*- coding:utf-8  -*-
# 日期：2018/6/12 8:09
# Author:小鼠标


# 节点对象
class Node:
    def __init__(self):
        self.left_children = None
        self.right_children = None
        self.value = None

# 二叉树对象
class tree:
    def __init__(self):
        self.root = False
        self.front_list = []
        self.middle_list = []
        self.after_list = []
    # 生成二叉树
    def create_tree(self,n=0,l=[]):
        if l == []:
            print("传入的列表为空")
            return
        if n > len(l)-1:
            print("二叉树生成")
            return
        node = Node()
        node.value = l[n]
        if not self.root:
           self.root = node
           self.list = l
        else:
            self.add(self.root,node)
        self.create_tree(n+1,l)
    # 添加节点
    def add(self,parent,new_node):
        if new_node.value > parent.value:
            # 插入值比父亲值大，所以在父节点右边
            if parent.right_children == None:
                parent.right_children = new_node
            else:
                self.add(parent.right_children,new_node)
        else:
            # 插入值比父亲值小，所以在父节点左边
            if parent.left_children == None:
                parent.left_children = new_node
            else:
                self.add(parent.left_children,new_node)
    # 前序(先中再左最后右)
    def front(self,node=None):
        if node == None:
            node = self.root
        # 输出当前节点
        self.front_list.append(node.value)
        # 先判断左枝
        if not node.left_children == None:
            self.front(node.left_children)
        # 再判断右枝
        if not node.right_children == None:
            self.front(node.right_children)
        # 返回最终结果
        return self.front_list
    # 中序(先左再中最后右)
    def middle(self,node=None):
        if node == None:
            node = self.root
        # 先判断左枝
        if not node.left_children == None:
            self.middle(node.left_children)
        # 输出当前节点
        self.middle_list.append(node.value)
        # 再判断右枝
        if not node.right_children == None:
            self.middle(node.right_children)
        return self.middle_list
    # 后序(先左再右最后中)
    def after(self,node=None):
        if node == None:
            node = self.root
        # 先判断左枝
        if not node.left_children == None:
            self.after(node.left_children)
        # 再判断右枝
        if not node.right_children == None:
            self.after(node.right_children)
        self.after_list.append(node.value)
        return self.after_list

    # 搜索
    def search(self,v,node=None):
        if node == None:
            node = self.root
        if node.value == v:
            return True
        if v > node.value:
            if not node.right_children == None:
                return self.search(v, node.right_children)
        else:
            if not node.left_children == None:
                return self.search(v, node.left_children)
        return False
if __name__ == '__main__':
    # 需要建立二叉树的列表
    list = [4, 6, 3, 1, 7, 9, 8, 5, 2]
    t = tree()
    t.create_tree(0,list)
    res = t.front()
    print('前序',res)
    res = t.middle()
    print('中序',res)
    res = t.after()
    print('后序',res)
    i = t.search(8)
    print('8是否在二叉树中',i)

　　中心就是递归判断传值，递归取值，很简单，下一步就是优化二叉树，二叉树的左旋，右旋，实现平衡二叉树。