
def search(self,key):
    bt=self._root   #bt为树的实例化
    while bt:
      entry=bt.data    #树的根结点
      if key < entry:
        bt=bt.left
      elif key > entry:
        bt=bt.right
      else:
          Return entry
    return None

二叉排序树插入

1.若二叉排序树为空树，则新插入的结点是新的根结点

2.若二叉排序树非空，则新插入的结点是新的叶子结点，且插入的位置由查找过程得到

二叉排序树删除

在查找成功之后进行，删除之后必须保持二叉排序树的特征。

被删除的结点是叶子结点

只需要把其双亲节点中相应指针域的值改为“空”

被删除的结点只有左子树或只有右子树

其双亲节点的相应指针域的值改为“指向被删除结点的左子树或右子树”

被删除的结点既有左子树，也有右子树

以其前替代之，然后再删除该前驱结点

最后实例：


class BSTNode:
    def init(self, data, left=None, right=None):
        self.data = data      #节点储存的数据
        self.left = left       #节点左子树
        self.right = right     #节点右子树
class BinarySortTree:
    #基于BSTNode类的二叉查找树。维护一个根节点的指针。
    def init(self):
        self._root = None
    def is_empty(self):
        return self._root is None
    def search(self, key):
        bt = self._root
        while bt:
            entry = bt.data
            if key < entry:
                bt = bt.left
            elif key > entry:
                bt = bt.right
            else:
                return entry
        return None
 
    def insert(self, key):          #插入操作
        bt = self._root
        if not bt:
            self._root = BSTNode(key)
            return
        while True:
            entry = bt.data
            if key < entry:
                if bt.left is None:
                    bt.left = BSTNode(key)
                    return
                bt = bt.left
            elif key > entry:
                if bt.right is None:
                    bt.right = BSTNode(key)
                    return
                bt = bt.right
            else:
                bt.data = key
                return
 
    def delete(self, key):    #删除操作
        p, q = None, self._root     #维持p为q的父节点，用于后面的链接操作
        if not q:
            print("空树！")
            return
        while q and q.data != key:
            p = q
            if key < q.data:
                q = q.left
            else:
                q = q.right
            if not q:               #当树中没有关键码key时，结束退出。
                return
        #上面已将找到了要删除的节点，用q引用。而p则是q的父节点或者None（q为根节点时）。
        if not q.left:
            if p is None:
                self._root = q.right
            elif q is p.left:
                p.left = q.right
            else:
                p.right = q.right
            return
        #查找节点q的左子树的最右节点，将q的右子树链接为该节点的右子树
        r = q.left
        while r.right:
            r = r.right
        r.right = q.right
        if p is None:
            self._root = q.left
        elif p.left is q:
            p.left = q.left
        else:
            p.right = q.left
 
    def iter(self):
        #实现二叉树的中序遍历,展示二叉查找树. 使用python列表作为一个栈。
        stack = []
        node = self._root
        while node or stack:
            while node:
                stack.append(node)
                node = node.left
            node = stack.pop()
            yield node.data
            node = node.right
 
if name == '__main__':
    lis = [62, 58, 88, 48, 73, 99, 35, 51, 93, 29, 37, 49, 56, 36, 50]
    print("排序前：")
    for i in lis:
        print(i, end=" ")
    bs_tree = BinarySortTree()
    print()
    print("排序后：")
    for i in range(len(lis)):
        bs_tree.insert(lis[i])
    for i in bs_tree:
        print(i, end=" ")
    print()
    print("插入55后：")
    bs_tree.insert(55)
    for i in bs_tree:
        print(i, end=" ")
    print()
    print("删除58后：")
    bs_tree.delete(58)
    for i in bs_tree:
        print(i, end=" ")
    print()
    print("查找4：")
    print(bs_tree.search(4))
    print("查找55：")
print(bs_tree.search(55))

平衡二叉树

一种盖度平衡的排序二叉树，其每一个节点的左子树和右子树的高度差最多等于1，只可能是-1, 0 和 1。

特性：

1.肯定是二叉排序树；

2.因子绝对值不超过1；

3.其左子树和右子树都是平衡二叉树。

右边的就是平衡二叉树

构建平衡二叉树

最后实例：


#在计算二叉树的最大深度的基础上，判断是否满足平衡二叉树的条件。
class TreeNode:
    def init(self, x):
        self.val = x
        self.left = None
        self.right = None
 
 
class Solution(object):
    def isBalanced(self, root):
        if not root:
            return True
        if self.depth(root) == -1:  #选择-1作为返回和判断条件
            return False
        else:
            return True
 
    def depth(self, root):
        if not root:
            return 0
        left = self.depth(root.left)
        if left == -1:  #选择-1作为返回和判断条件
            return -1
        right = self.depth(root.right)
        if right == -1:
            return -1
        if left > right + 1 or right > left + 1:
            return -1
        return max(left + 1, right + 1)

声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/秋刀鱼在做梦/article/detail/993232