数据结构——树

# list of lists
# 在这种定义的情况下，根节点为t[0],左节点t[1],右节点为t[2]

def binary_tree(r):
    return [r,[],[]]

def insert_left(root,new_branch):
    t = root.pop(1) #左孩子
    if len(t) > 0: # 如果左孩子不为空，将其作为新分支的左孩子
        root.insert(1,[new_branch,t,[]])
    else:
        root.insert(1,[new_branch,[],[]])
    return root

def insert_right(root,new_branch):
    t = root.pop(2)
    if len(t) > 0:
        root.insert(2,[new_branch,[],t])
    else:
        root.insert(2,[new_branch,[],[]])
    return root

def get_root_val(root):
    return root[0]

def set_root_val(root,new_val):
    root[0] = new_val

def get_left_child(root):
    return root[1]

def get_right_child(root):
    return root[2]


# nodes and references
# 这种思想主要是构建一个类，并采用嵌套的方法，生成左右节点

class BinaryTree:
    def __init__(self,root):
        self.key = root
        self.left_child = None
        self.right_child = None

    def insert_left(self,new_node):
        if self.left_child == None:
            self.left_child = BinaryTree(new_node)
        else:
            t = BinaryTree(new_node)
            t.left_child = self.left_child
            self.left_child = t

    def indert_right(self,new_node):
        if self.right_child == None:
            self.right_child = BinaryTree(new_node)
        else:
            t = BinaryTree(new_node)
            t.right_child = self.right_child
            self.right_child = t

    def get_right_child(self):
        return self.right_child

    def get_left_child(self):
        return self.left_child

    def set_root_val(self,obj):
        self.key = obj

    def get_root_val(self):
        return self.key


# 树的遍历：先序遍历（中左右） 中序遍历（左中右） 后序遍历（左右中）
# 先中后都是对于根节点来说的

# 外界函数
def preorder(tree):
    if tree:
        print(tree.get_root_val())
        preorder(tree.get_left_child())
        preorder(tree.get_right_child())

def postorder(tree):
    if tree:
        postorder(tree.get_left_child())
        postorder(tree.get_right_child())
        print(tree.get_root_val())

def inorder(tree):
    if tree:
        postorder(tree.get_left_child())
        print(tree.get_root_val())
        postorder(tree.get_right_child())

# 类中函数
def preorder_inclass(self):
    print(self.key)
    if self.left_child:
        self.left_child.preorder_inclass()
    if self.right_child:
        self.right_child.preorder_inclass()


# 二叉搜索树（BST）
# 其或者是一颗空树，或者是具有以下性质的二叉树
# 若左子树不空，则左子树上所有节点的值均小于或者等于它的根节点的值
# 若右子树不空，则右子树上所有节点的值均大于或者等于它的根节点的值
# 左右子树也分别为二叉排序树

# 树中的节点定义如下
class Node:
    def __init__(self,data):
        self.data = data
        self.lchild = None
        self.rchild = None

    # 搜索（外界函数）
    def search(self,node,data):
        if node == None:
            return False
        if node.data == data:
            return True
        if node.data > data:
            return self.search(node.lchild,data)
        else:
            return self.search(node.rchild,data)

    # 查找二叉搜索树中的最大（小）值
    def findMin(self,root):
        if root.lchild:
            return self.findMin(root.lchild)
        else:
            return root.data

    def findMax(self,root):
        if root.rchild:
            return self.findMax(root.rchild)
        else:
            return root.data
    # 删除（类中函数）
    def delete(self,data):
        if not self:
            return None
        if data < self.data:
            self.lchild = self.lchild.delete(data)
        elif data > self.data:
            self.rchild = self.rchild.delete(data)
        else:
            if self.lchild == None:
                return self.rchild
            elif self.rchild == None:
                return self.lchild
            else:
                temp = self.findMin(self.rchild)
                self.data = temp
                self.rchild.delete(temp)
        return self


    # 搜索（类中函数）
    def find(self,data):
        if data == self.data:
            return True
        elif data < self.data:
            if self.lchild:
                return self.lchild.find(data)
            else:
                return False
        else:
            if self.rchild:
                return self.rchild.find(data)
            else:
                return False


    # 插入（类中函数）（需要return?）
    def insert(self,data):
        if data < self.data:
            if self.lchild:
                return self.lchild.insert(data)
            else:
                self.lchild = Node(data)
        else:
            if self.rchild:
                return self.rchild.insert(data)
            else:
                self.rchild = Node(data)