二叉搜索树（BST）

二叉搜索树（BST）

---

现在呢我们要学习的数据结构呢就是：树 树这种数据结构对我来说还是有点难度的，一个是我基础不太好，一个是我觉得我用到的不多，所以我从考研之后呢算是第二次比较系统的学习了。 废话不多说，come on！

二叉搜索树的定义：

---

• 二叉搜索树(Binary Search Tree)，又名二叉排序树(Binary Sort Tree)。

• 二叉搜索树是具有有以下性质的二叉树：

1. 若左子树不为空，则左子树上所有节点的值均小于或等于它的根节点的值。
2. 若右子树不为空，则右子树上所有节点的值均大于或等于它的根节点的值。
3. 左、右子树也分别为二叉搜索树。
4. 二叉树第i层上的结点数目最多为 2{i-1} (i≥1)。
5. 深度为k的二叉树至多有2{k}-1个结点(k≥1)。
6. 包含n个结点的二叉树的高度至少为log2 (n+1)。
7. 在任意一棵二叉树中，若终端结点的个数为n0，度为2的结点数为n2，则n0=n2+1。

---

二叉树的操作：

例如：

1、 查找
2、 插入
3、 删除

二叉树的结点构建：

class Node():
    def __init__(self,value):
        self.value=value
        self.left=None
        self.right=None

---

查找

1. 判断是否为父节点
2. 不是父节点时判断是否比父节点小，则在左子树找
3. 比父节点大，则在右子树找
4. 重复过程，找不到返回None

    def find(self, node, parent, x):
        if node is None:
            return False, node, parent
        if x == node.value:
            return True, node, parent
        if x < node.value:
            return self.find(node.left, node, x)
        else:
            return self.find(node.right, node, x)

插入

1. 若比根小，判断左子树不存在，插入左子树，若存在，在左子树继续找
2. 若比根大，判断右子树不存在，插入右子树，若存在，在右子树继续找
3. 直到操作完毕

 def insert(self, x):
        flag, n, p = self.find(self.root, self.root, x)
        if not flag:
            new = Node(x)
            if x > p.value:
                p.right = new
            else:
                p.left = new

找最大最小值

• 最小值在最最最左叶子，最大值在最右右右边叶子

def max(root):
    if root.left:
        return max(root.left)
    else:
        return root.value
def min(root):
    if root.right:
        return max(root.right)
    else:
        return root.value

删除
删除分三种情况

• 如果待删除的节点是叶子节点，那么可以立即被删除
• 如果节点只有一个儿子，则将此节点parent的指针指向此节点的儿子，然后删除节点
• 如果节点有两个儿子，则将其右子树的最小数据代替此节点的数据，并将其右子树的最小数据删除

    def delete(self,x):
        flag, n, p = self.find(self.root, self.root, x)
        if not flag:
            return False
        else:
            if n.left is None:
                if n==p.left:
                    p.left=n.right
                else:
                    p.right=n.right
                del n
            elif n.right is None:
                if n.right is None:
                    if n==p.left:
                        p.left=n.left
                    else:
                        p.right=n.left
                del n
            else:
                pre=n.right
                if pre.left is None:
                    n.value=pre.value
                    n.right=pre.right
                    del pre
                else:
                    next=pre.left
                    while next is not None:
                        pre=next
                        next=next.left
                    n.value=next.value
                    pre.left=next.right
                    del next

二叉树遍历
1. 先序遍历

1. 访问根节点
2. 先序遍历左子树
3. 先序遍历右子树

2. 中序遍历

1. 中序遍历左子树

2. 访问根节点

3. 中序遍历右子树

3. 后序遍历

1. 后序遍历左子树

2. 后序遍历右子树

3. 访问根节点

    #中序
    def preOrderTraverse(self,node): 
        if node is not None:
            print(node.value)
            self.preOrderTraverse(node.left)
            self.preOrderTraverse(node.right)
     #前序
    def inOrderTraverse(self,node):
        if node is not None:
            self.inOrderTraverse(node.left)
            print(node.value)
            self.inOrderTraverse(node.right)
     #后序
    def postOrderTraverse(self,node):
        if node is not None:
            self.postOrderTraverse(node.left)
            self.postOrderTraverse(node.right)
            print(node.value)

总的代码：

class Node():
    def __init__(self,value):
        self.value=value
        self.left=None
        self.right=None
class BST:
    def __init__(self,node_list):
        self.root=Node(node_list[0])
        for data in node_list[1:]:
            self.insert(data)

    def find(self, node, parent, x):
        if node is None:
            return False, node, parent
        if x == node.value:
            return True, node, parent
        if x < node.value:
            return self.find(node.left, node, x)
        else:
            return self.find(node.right, node, x)

    def insert(self, x):
        flag, n, p = self.find(self.root, self.root, x)
        if not flag:
            new = Node(x)
            if x > p.value:
                p.right = new
            else:
                p.left = new

    def max(self,root):
        if root.left:
            return max(root.left)
        else:
            return root.value

    def min(self,root):
        if root.right:
            return max(root.right)
        else:
            return root.value

    def delete(self,x):
        flag, n, p = self.find(self.root, self.root, x)
        if not flag:
            return False
        else:
            if n.left is None:
                if n==p.left:
                    p.left=n.right
                else:
                    p.right=n.right
                del n
            elif n.right is None:
                if n.right is None:
                    if n==p.left:
                        p.left=n.left
                    else:
                        p.right=n.left
                del n
            else:
                pre=n.right
                if pre.left is None:
                    n.value=pre.value
                    n.right=pre.right
                    del pre
                else:
                    next=pre.left
                    while next is not None:
                        pre=next
                        next=next.left
                    n.value=next.value
                    pre.left=next.right
                    del next

    def preOrderTraverse(self,node):
        if node is not None:
            print(node.value)
            self.preOrderTraverse(node.left)
            self.preOrderTraverse(node.right)
    def inOrderTraverse(self,node):
        if node is not None:
            self.inOrderTraverse(node.left)
            print(node.value)
            self.inOrderTraverse(node.right)
    def postOrderTraverse(self,node):
        if node is not None:
            self.postOrderTraverse(node.left)
            self.postOrderTraverse(node.right)
            print(node.value)

a=[49, 38, 65, 97, 60, 76, 13, 27, 5, 1]
bst=BST(a)
bst.preOrderTraverse(bst.root)