查找(1) 二叉搜索树

原创 2016年06月01日 14:57:45

定义和表示

搜索树支持许多动态集合操作,search\minimum\maximum\predecessor(前驱)\successor(后继)\insert\delete等,所以可以把搜索树作为字典或优先队列。
二叉搜索树以一棵二叉树组织的,他需要满足一些条件(性质)。
这里写图片描述

对于任何结点x, x的左子树的最大关键字不大于x结点的关键字,x的右子树的最小关键字不小于x结点的关键字。
二叉搜索树操作的最坏时间与树高成正比,上图中(a)是一个包含6结点,高度为2的二叉搜索树(也属于平衡树)。而(b)是一个包含相同关键字,高度为4的低效二叉搜索树。

我们用基于链表的形式表达二叉树。

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

class BinarySearchTree:
    def __init__(self):
        self.root = None
        self.nodeNum = 0

    def getRoot(self):
        return self.root

    def getNodeNum(self):
        return self.nodeNum

遍历

中根遍历:依次中根遍历左子树、输出根节点、中根遍历右子树。
先根遍历:依次输出根节点、先根遍历左子树、先根遍历右子树。
后根遍历:依次后根遍历左子树、后根遍历右子树、输出根节点。
层级遍历:从上到下,从左至右,从根到叶结点的依序遍历。
二叉树遍历的代码如下:

    #中根遍历递归版
    def inOrderRec(self,r):
        if r:
            self.inOrderRec(r.left)
            print(r.key,end=' ')
            self.inOrderRec(r.right)

    #中根遍历非递归版,借用栈       
    def inOrderWithStack(self):
        s = Stack()
        r = self.getRoot()
        while r or not s.isEmpty():
            if r:
                s.push(r)
                r = r.left
            else:
                r = s.pop()
                print(r.key,end = ' ')
                r = r.right

    #中根遍历非递归非栈版,Joseph M.Morris实现。主要思想利用线索二叉树
    #利用所有叶子结点的右指针,指向其后继结点,组成一个环,
    #在第二次遍历到这个结点时,由于其左子树已经遍历完了,则访问该结点。
    def inOrderNoRecNoStack(self):
        p = self.getRoot()
        r = None
        while p:
            q = p.left
            if q:
                while q is not r and q.right:
                    q = q.right
                if q is not r:
                    q.right = p
                    p = p.left
                    continue
                else:
                    q.right = None
            print(p.key,end=' ')
            r = p
            p = p.right

    #中根遍历非递归版,借用后继,该版本使用到了父指针进行回溯。
    def inOrder(self):
        r = self.getRoot()
        p = self.minMum(r)
        while p:
            print(p.key,end= ' ')
            p = self.successor(p)

    #先根遍历递归版
    def preOrderRec(self,r):
        if r:
            print(r.key,end=' ')
            self.preOrderRec(r.left)
            self.preOrderRec(r.right)

    #后根遍历递归版    
    def postOrderRec(self,r):
        if r:
            self.postOrderRec(r.left)
            self.postOrderRec(r.right)
            print(r.key,end=' ')

    #层级遍历,借用队列  
    def levelOrder(self):
        q = Queue()
        p = self.getRoot()
        while p:
            print(p.key, end=' ')
            if p.left:
                q.enqueue(p.left)
            if p.right:
                q.enqueue(p.right)
            if q.isEmpty():
                p = None
            else:
                p = q.dequeue()

查询

二叉搜索树的查询操作包括:search查找、minimum最小关键字和maximum最大关键字、predecessor前驱、successor后继。这里主要说一下怎么找出后继和前驱。其他的都很简单。
这里写图片描述
由上图举例,找出结点i的后继分两种情况:
①:如果i结点有右子树,那么i结点的后继就是i结点的右子树的最小关键字结点。比如15的后继是17,7的后继是9,等等。
②:如果i结点没有右子树,那么需要从i开始沿树而上直到遇到这样一个结点,该结点是其父结点的左孩子,那这个父结点就是i的后继。请仔细体会这个过程。
比如,根据上图给出要查找13的后继的过程。13的父结点是7,但是13不是7的左孩子,继续向上搜索,7的父结点是6,但是7不是6的左孩子,继续向上搜索,6的父结点是15,并且6是15的左孩子,结点15就是13的后继。
至于前驱的查找是后继查找的一种对称情况。

上述操作代码实现如下:

    def search(self,key):
        p = self.getRoot()
        while p and key is not p.key:
            if key < p.key:
                p = p.left
            else:
                p = p.right
        return p

    def minMum(self,p):
        while p.left:
            p = p.left
        return p

    def maxMum(self,p):
        while p.right:
            p = p.right
        return p

    def successor(self,p):
        if p.right:
            return self.minMum(p.right)
        x = p.parent
        while x and p is x.right:
            p = x
            x = x.parent
        return x

    def predecessor(self,p):
        if p.left:
            return self.maxMum(p.left)
        x = p.parent
        while x and p is x.left:
            p = x
            x = x.parent
        return x

插入和构建

对于插入一个结点来说,首先找到插入的合适位置,能保证二叉搜索树的性质。

    def insert(self,key):
        node = TreeNode(key)
        x = None
        p = self.getRoot()
        while p:
            x = p
            if node.key < p.key:
                p = p.left
            else:
                p = p.right
        node.parent = x
        if not x:
            self.root = node
        elif node.key < x.key:
            x.left = node
        else:
            x.right = node
        self.nodeNum += 1

有了插入操作,构建二叉树的代码就简单多了。

    #datalist = [key1,key2,...,keyn]
    def build(self,datalist):
        for key in datalist:
            self.insert(key)

删除

相对于插入操作,二叉搜索树的删除操作稍微复杂点。
以p为将要删除的结点分三种情况来具体说明:
①:p没有左孩子,用p的右孩子去代替p。这里其实包括了p有右孩子和p没有右孩子两种情况,用p的右孩子去代替p对于两种情况都是符合要求的。
②:p没有右孩子,即这种情况下,p有且仅有左孩子,把p的左孩子去代替p即可。
③:p有左孩子也有右孩子,找到p的后继psu(一定有),psu的关键字和卫星数据(如果有)复制给p,然后把问题转化为删除psu结点,而根据性质,psu一定没有左孩子,那又回到了情况①,按照①的处理方式即可。
这里有个关键点是结点替换过程。我们将其封装定义为_transplant子过程。

    #结点替换,v结点替换p结点
    def _transplant(self,p,v):
        if not p.parent:
            self.root = v
        elif p is p.parent.left:
            p.parent.left = v
        else:
            p.parent.right = v
        if v:
            v.parent = p.parent

    def delete(self,key):
        p = self.search(key) #找到所要删除的关键字的结点,可能没有
        if p:
            if not p.left: #case 1
                self._transplant(p, p.right)
            elif not p.right: #case 2
                self._transplant(p, p.left)
            else: #case 3
                x = self.minMum(p.right) #x是p的后继    
                p.key = x.key
                self._transplant(x, x.right) #问题退化到case 1 
            self.nodeNum -= 1

二叉搜索树上的每个基本操作都能在O(h)内完成,h为树的高度。在构建二叉搜索树的最坏情况下,树可能退化成单链,那操作的代价就会大大增加。~


版权声明:

相关文章推荐

算法导论思考题13-1:持久动态集合中的持久二叉搜索树

目标:实现13-1的思考题,要求是使用红黑树进行插入和删除的维护,同时要求这个数据结构是具有full persistence性质(可以对任意时刻的数据结构进行操作,产生多个分支),相关数据结构的操作为...

【 日常 】 二叉搜索树 17年3月31日21:45 [ 1 ]

/* 前言: 好多天前准备记录下自己的坎坷修仙的点滴,以后希望能留下【珍贵的回忆】,萌新的日常代码,大佬互喷 */ /*---------------------------------------...

二叉搜索树和红黑树概述以及模板实现(1)

最近研究了一下算法导论里面关于二叉搜索树和红黑树的一章,对于红黑树的内容虽然还没有完全消化吸收,写一篇blog算是对所有内容的一个复习和反思吧。 1. 二叉搜索树 二叉搜索树是一颗二叉树,要求对于...

算法导论 15章(1)最优二叉搜索树

#include #include using namespace std; class Result { public: Result(int n) { num = n+2; e =...

面试题1-将二叉搜索树转变成排序的双向链表

输入一棵二元查找树,将该二元查找树转换成一个排序的双向链表。要求不能创建任何新的结点,只调整指针的指向。        对于一棵二叉搜索树                 &#...

算法-树(1)—BST(二叉搜索树)

本文基于BST结构主要实现查找,删除功能 此种数据结构较为简单,主要分析添加查找删除功能 后附完整代码1.BST定义: 1).每个结点均有键值对,其中键值实现排序; 2)....

AVL平衡树 - 二叉搜索树的扩展1

1. AVL树的介绍AVL树是根据它的发明者G.M. Adelson-Velsky和E.M. Landis命名的。 它是最先发明的自平衡二叉查找树,也被称为高度平衡树。相比于”二叉查找树”,它的特点...
内容举报
返回顶部
收藏助手
不良信息举报
您举报文章:深度学习:神经网络中的前向传播和反向传播算法推导
举报原因:
原因补充:

(最多只允许输入30个字)