数据结构（Python语言描述） 常用二叉树--二叉搜索树

 

 Fu Xianjun. All Rights Reserved.

文章目录

• 前言
• 一、常用二叉树是什么？
• 二、使用步骤
  • 1.读入数据
• 总结

 

---

前言

常用的二叉树分为二叉搜索树、堆、哈夫曼树、平衡二叉树。

---

 

一、二叉搜索树是什么？

二叉搜索树又称二叉查找树，是二叉树的一种,如果二叉搜索树非空，则其具有以下特性。
(1)如果它的左子树非空，则左子树上所有节点的数值均小于根节点的数值。
(2)如果它的右子树非空，则右子树上所有节点的数值均大于根节点的数值。
(3)左、右子树本身又各是一棵二叉搜索树

二、使用步骤

1.读入数据

代码如下（示例）：

#搜索二叉树
#节点类
class Node(object):
    def __init__(self,val):
        self.val = val
        self.left = None
        self.right = None

#搜索二叉树类
class BinarySortTree(object):
    def __init__(self):
        self.root = None

    #查询，输入key，如果找到返回True，否则返回False
    def find(self,key):
        if self.root == None:
            return False
        cur = self.root
        while cur != None:
            if key == cur.val:
                return True
            elif key < cur.val:
                cur = cur.left
            else:
                cur = cur.right
        return False

    #插入
    def insert(self,key):
        newNode = Node(key)
        if self.root == None:
            self.root = newNode
        else:
            cur = self.root
            while cur!=None:
                if key < cur.val:
                    if cur.left == None:
                        cur.left = newNode
                        break
                    cur = cur.left
                else:
                    if cur.right == None:
                        cur.right = newNode
                        break
                    cur = cur.right
    #中序遍历
    def inordef_iterator(self,node):
        if node!=None:
            self.inordef_iterator(node.left)
            print(node.val,end= " ")
            self.inordef_iterator(node.right)

    #查找最小值，找到最左下角的节点值（没有左孩子）
    def getMinNode(self,node):
        if node.left == None:
            return node.val
        cur = node.left
        while cur.left != None:
            cur = cur.left
        return  cur.val

    #删除节点
    def delete(self,key):
        if self.root == None:
            return
        #首先，找到目标节点
        target = self.root
        targetParent = None
        while target != None:
            if key == target.val:
                break
            elif key < target.val:
                targetParent = target
                target = target.left
            else:
                target = target.right
        #没有找到要删除的目标节点
        if target == None:
            return

        #根据目标节点的三种不同类型，删除方法不同
        #1.目标节点是叶子节点
        if target.left == None and target.right == None:
            if target == self.root:
                self.root = None
            else:
                if targetParent.left == target:
                    targetParent.left = None
                else:
                    targetParent.right = None

        #2.目标节点是单支节点，有左孩子或者右孩子
        elif target.left == None or target.right == None:
            if target == self.root:
                if target.left != None:
                    self.root = target.left
                else:
                    self.root = target.right
            else:
                if targetParent.left == target:
                    if target.left != None:
                        targetParent.left = target.left
                    else:
                        targetParent.left = target.right
                else:
                    if target.left != None:
                            targetParent.right = target.left
                    else:
                        targetParent.right = target.right
        #3.目标节点是双支节点，有左右孩子


if __name__ == "__main__":
    bsTree = BinarySortTree()
    temp = [19,13,50,11,26,66,9,12,21,30,60,70]
    for i in temp:
        bsTree.insert(i)
    print(bsTree.find(61))
    print(bsTree.find(12))
    bsTree.inordef_iterator(bsTree.root)
    print()
    print(bsTree.getMinNode(bsTree.root.right.right))
    bsTree.delete(9)
    bsTree.inordef_iterator(bsTree.root)
    print()
    bsTree.delete(13)
    bsTree.inordef_iterator(bsTree.root)
    

---

总结

在二叉搜索树中，每个节点的关键字都大于其左子树中所有节点的关键字，同时小于其右子树中所有节点的关键字。对二又搜索树使用中序遍历得到的节点序列是一个按关键
字升序的序列。

二叉树的查找就是一个二分查找的过程，首先访问根节点，若其值等于关键字key，则查找成功；否则，当关键字小于根节点的值时继续在左子树中查找，当关键字大于根节点的值时继续在右子树中查找，直至查找成功或者碰到空树为止。对于一般的二叉搜索树来说，其查找的时间复杂度为O（logn），对于特殊情况的二叉树，如对于斜二叉树而言，其查找的时间复杂度为O（n），相当于普通的线性查找。