(数据结构)[python]（13）----二叉树

1.二叉树定义

二叉树是一种每个结点至多只有两个子树（即二叉树的每个结点的度不大于2），并且二叉树的子树有左右之分，其次序不能任意颠倒。

树的实现

class TreeNode():
    def __init__(self,data,firstchild,nextSibling):
        self.data = data
        self.firstchild = firstchild
        self.nextSibling = nextSibling
        

2.名词

根节点： 根结点(root)是树的一个组成部分,也叫树根。所有非空的二叉树中,都有且仅有一个根结点
边： 节点之间用边链接
树叶(叶子)： 也叫终端结点，是度为 0 的结点
兄弟： 同一双亲的孩子结点； 堂兄结点：同一层上结点；
祖父和孙子： 儿子的儿子
路径： 从根结点到树中某结点经过的分支构成了路径
深度： 深度是从根节点往下
高： 从结点x向下到某个叶结点最长简单路径中边的条数
祖先： 从根到该结点的所经分支上的所有结点子孙结点：以某结点为根的子树中任一结点都称为该结点的子孙
后裔： 如果有a-c存在那么a是c的祖先 c是a的后裔
真祖先： 后裔不等于祖先
真后裔： 后裔不等于祖先

3.二叉查找树（搜索树）

一种特殊的二叉树 左孩子比根节点小 根节点比右孩子小
添加 找到一个合适的位置 比根节点大往右找 比根节点小往左找
遍历（深度优先）
递归 删除的时候用

3.遍历

所谓的遍历其实就是按照某种搜索路径，遍历树中的每个结点。我们都知道二叉树由三个基本的单元组成：根结点、左子树、右子树，所以遍历整个二叉树就是遍历二叉树的三个基本单元，根据随机组合的原理，可以产生6中遍历方案：DLR、LDR、LRD、RDL、RLD、LRD,另外，遍历的时候，一般要求先左后右的，所以我们只会选择前三种遍历方案。

先序遍历（DRL）
（1）先访问根结点
（2）先序遍历左子树
（3）先序遍历右子树
中序遍历（LDR）
（1）先中序遍历左子树
（2）访问根结点
（3）中序遍历右子树
后序遍历（LRD）
（1）后序遍历左子树
（2）后序遍历右子树
（3）访问中节点

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

class Tree():#定义一个树，继承object
    def __init__(self):#定义树根为空 只是定义一个属性
        self.root = None
    #添加数据
    def add(self,data):#加
        node = TreeNode(data)
        if self.root == None:
            self.root = node
        else:
            currentNode = self.root
            while True:
                if data < currentNode.data:
                    if currentNode.left == None:
                        currentNode.left = node
                        break
                    else:
                        currentNode = currentNode.left
                        continue
                else:
                    if currentNode.right == None:
                        currentNode.right = node
                        break
                    else:
                        currentNode = currentNode.right
                        continue
    #是否包含数据
    def contains(self,data):
        flag = False
        if self.root == None:
            print("空树")
        else:
            currentNode = self.root
            while True:
                if currentNode.data == data:
                    flag = True
                    break
                else:
                    if data < currentNode.data:
                        if currentNode.left == None:
                            break
                        currentNode = currentNode.left
                    else:
                        if currentNode.right == None:
                            break
                        currentNode = currentNode.right
        return flag

    #查找最小值
    def findMin(self):
        temp_min = None
        if self.root == None:
            print("空树")
        else:
            currentNode = self.root
            while currentNode.left != None:#循环只要不等于空就等于它的左孩子
                currentNode = currentNode.left
                temp_min = currentNode.data#等于他的最小值
        return temp_min

    #查找最大值
    def findMax(self):
            temp_max = None
            if self.root == None:
                print("空树")
            else:
                currentNode = self.root
                while currentNode.left != None:  # 循环只要不等于空就等于它的左孩子
                    currentNode = currentNode.right
                    temp_max = currentNode.data  # 等于他的最小值
            return temp_max

    #删除
    def remove(self,root,data):
        #没有孩子的叶子节点
        if self.contains(data):#查有没有这个数据
            #树中有要删除的数据
            pre_currentNode = None
            currentNode = root
            while True:
                if currentNode.data == data:
                    #1.叶子节点
                    if currentNode.left == None and currentNode.right == None:
                        del  currentNode
                    #2.一个孩子的节点
                    elif currentNode.left==None and currentNode.right!=None:
                        if pre_currentNode==None:
                            self.root = currentNode.right
                            break
                        else:
                            if pre_currentNode.right == currentNode:
                                pre_currentNode.right = currentNode.right
                            else:
                                pre_currentNode.left = currentNode.right
                            break
                    elif currentNode.left != None and currentNode.right == None:
                        if pre_currentNode == None:
                            self.root = currentNode.left
                            break
                        else:
                            if pre_currentNode.right == currentNode:
                                pre_currentNode.right = currentNode.left
                            else:
                                pre_currentNode.left = currentNode.left
                            break
                    #3.两个孩子的节点

                    else:
                        minNode = currentNode.right
                    while minNode.left != None:
                        minNode = minNode.left
                    currentNode.data = minNode.data
                    self.remove(currentNode.right, minNode.data)
                    break
                else:
                    if data < currentNode.data:
                        pre_currentNode = currentNode
                        currentNode = currentNode.left
                    else:
                        pre_currentNode = currentNode
                        currentNode = currentNode.right
        else:
            #树中没有要删除的数据
            print("数据不存在")

    #遍历(深度优先)
    def showAll(self,root):
        if root==None:
            print("空树")
        else:
            if self.root.data==root.data:
                print(self.root.data)
            if root.left != None:
                print(root.left.data)
            if root.right != None:
                print(root.right.data)

tree = Tree()
tree.add(6)
tree.add(2)
tree.add(8)
tree.add(1)
tree.add(5)
tree.add(3)
tree.add(4)
tree.remove(tree.root,2)
tree.showAll(tree.root)