【alg4-查找】二叉查找树

最新推荐文章于 2021-05-27 23:37:51 发布
最新推荐文章于 2021-05-27 23:37:51 发布
阅读量217 收藏
点赞数
分类专栏： 算法 文章标签： 算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_41242680/article/details/110621393
版权

定义：一棵二叉查找树（BST），其中每个结点都含有一个Comparable的键（以及相关联的值）且每个结点的键都大于其左子树中的任意结点的键而小于右子树的任意结点的键。

二叉查找树是一种能够将链表插入的灵活性和有序数组查找的高效性结合起来的符号表实现。

基本实现

数据表示

和链表一样，我们嵌套定义了一个私有类来表示二叉查找树上的一个结点。每个结点都含有一个键、一个值、一条左链接、一条右链接和一个结点计数器。

查找

在二叉查找树中查找一个键的递归算法：如果树是空的，则查找未命中；如果被查找的键和根结点的键相等，查找命中，否则我们就（递归地）在适当的子数中继续查找。

和二分查找中每次迭代之后查找的区间就会减半一样，在二叉查找树中，随着我们不断向下查找，当前结点所表示的子树的大小也在减少。

对于命中的查找，路径在含有被查找的键的结点处结束。对于未命中的查找，路径的终点是一个空链接。

插入

递归插入的实现逻辑和递归查找很相似：如果树是空的，就返回一个含有该键值对的新结点；如果被查找的键小于根结点的键，我们会继续在左子树中插入该键，否则在右子树中插入该键。

最大键和最小键

如果根结点的左链接为空，那么一棵二叉查找树中最小的键就是根结点；如果左链接非空，那么树中的最小键就是左子树中的最小键。

向上取整和向下取整

如果给定的键key小于二叉查找树的根结点的键，那么小于等于key的最大键floor(key)一定在根结点的左子树中；如果给定的键key大于二叉查找树的根结点，那么只有当根结点右子树中存在小于等于key的结点时，小于等于key的最大键才会出现在右子树中，否则根结点就是小于等于key的最大键。
在这里插入图片描述

选择操作

假设我们想找到排名为k的键（即树中正好有k个小于它的键）。如果左子树中的结点数t大于k，那么我们就继续（递归地）在左子树中查找排名为k的键；如果t等于k，我们就返回根结点中的键；如果t小于k，我们就（递归地）在右子树中查找排名为（k-t-1）的键。
在这里插入图片描述

排名

如果给定的键和根结点的键相等，我们返回左子树中的结点总数t；如果给定的键小于根结点，我们会返回该键在左子树中的排名（递归计算）；如果给定的键大于根结点，我们会返回t+1（根结点）加上它在右子树中的排名（递归计算）。

删除最大键和删除最小键

对于deleteMin()，我们要不断深入根结点的左子树中直至遇见一个空链接，然后将指向该结点的链接指向该结点的右子树。此时已经没有任何链接指向要被删除的结点，因此它会被垃圾收集器清理掉。
在这里插入图片描述

删除操作

T.Hibbbard在1962年提出了解决删除一个拥有两个子结点的结点这个难题的第一个方法，在删除结点x后用它的后继结点填补它的位置，因为x有一个右子结点，因此它的后继结点就是其右子树中的最小结点。我们用以下步骤完成将x替换为它的后继结点的任务：

  • 将指向即将被删除的结点的链接保存为t；
  • 将x指向它的后继结点min(t.right)；
  • 将x的右链接（原本指向一棵所有结点都大于x.key的二叉查找树）指向deleteMin(t.right)，也就是在删除后所有结点仍然大于x.key的子二叉查找树；
  • 将x的左链接（本为空）设为t.left（其下所有的键都小于被删除的结点和它的后继结点）。

在递归调用后我们会修正被删除的结点的父结点的链接，并将由此结点到根结点的路径上的所有结点的计数器减1。
在这里插入图片描述

范围查找

使用中序遍历。

性能分析

在一棵二叉查找树中，所有操作在最坏情况下所需的时间都和树的高度成正比。

总的来说，二叉查找树的实现并不困难，且当树的构造和随机模型近似时在各种实际应用场景中它都能进行快速地查找和插入。但同时，在某些场景中二叉查找树在最坏情况下的恶劣性能仍然是不可接受的。二叉查找树的基本实现的良好性能依赖于其中的键的分布足够随机以消除长路径。但最坏情况在实际应用也有可能出现，比如用例将所有键按照顺序或者逆序插入符号表就会增加这种情况出现的概率。

简单的符号表实现的成本总结

算法最坏情况下的运行时间的增长数量级平均情况下的运行时间的增长数量级是否支持有序性相关的操作
算法查找插入查找命中插入是否支持有序性相关的操作
顺序查找（无序链表）NNN/2N否
二分查找（有序数组）lgNNlgNN/2是
二叉树查找（二叉查找树）NN1.39lgN1.39lgN是

代码

package section3_1;

import java.util.ArrayList;
import java.util.List;

public class BST<Key extends Comparable<Key>,Value> {

    private Node root;
    private class Node {
        private Key key;
        private Value val;
        private Node left,right;
        private int N;

        public Node(Key key, Value val, int n) {
            this.key = key;
            this.val = val;
            N = n;
        }
    }

    public int size() {
        return size(root);
    }

    public int size(Node x) {
        if (x == null) return 0;
        else return x.N;
    }

    public Value get(Key key) {
        return get(root,key);
    }

    public Value get(Node x,Key key) {
        if (x == null) return null;
        int cmp = key.compareTo(x.key);
        if (cmp > 0) {
            return get(x.right,key);
        } else if (cmp < 0) {
            return get(x.left,key);
        } else {
            return x.val;
        }
    }

    public void put(Key key,Value value) {
        root = put(root,key,value);
    }

    public Node put(Node x, Key key, Value value) {
        if (x == null) return new Node(key,value,1);
        int cmp = key.compareTo(x.key);
        if (cmp < 0) {
            x.left = put(x.left,key,value);
        } else if (cmp > 0) {
            x.right = put(x.right,key,value);
        } else {
            x.val = value;
        }
        x.N = size(x.left) + size(x.right) + 1;
        return x;
    }

    public Key min() {
        return min(root).key;
    }

    private Node min(Node x) {
        if (x.left == null) return x;
        return min(x.left);
    }

    public Key max() {
        return max(root).key;
    }

    private Node max(Node x) {
        if (x.right == null) return x;
        return max(x.right);
    }

    public Key floor(Key key) {
        Node x = floor(root,key);
        if (x == null) {
            return null;
        }
        return x.key;
    }

    private Node floor(Node x, Key key) {
        if (x == null) return null;
        int cmp = key.compareTo(x.key);
        if (cmp == 0) return x;
        if (cmp < 0) return floor(x.left,key);
        Node t = floor(x.right,key);
        if (t != null) return t;
        else return x;
    }

    public Key select(int k) {
        return select(root,k).key;
    }

    private Node select(Node x, int k) {
        if (x == null) return null;
        int t = size(x.left);
        if (t > k) return select(x.left,k);
        else if (t < k) return select(x.right,k-t-1);
        else return x;
    }

    public int rank(Key key) {
        return rank(key,root);
    }

    private int rank(Key key, Node x) {
        if (x == null) return 0;
        int cmp = key.compareTo(x.key);
        if (cmp < 0) return rank(key,x.left);
        else if (cmp > 0) return 1 + size(x.left) + rank(key,x.right);
        else return size(x.left);
    }

    public void deleteMin() {
        root = deleteMin(root);
    }

    private Node deleteMin(Node x) {
        if (x.left == null) return x.right;
        x.left = deleteMin(x.left);
        x.N = size(x.left) + size(x.right) + 1;
        return x;
    }

    public void delete(Key key) {
        root = delete(root,key);
    }

    public Node delete(Node x,Key key) {
        if (x == null) return null;
        int cmp = key.compareTo(x.key);
        if (cmp < 0) {
            x.left = delete(x.left,key);
        } else if (cmp > 0) {
            x.right = delete(x.right,key);
        } else {
            if (x.right == null) {
                return x.left;
            }
            if (x.left == null) {
                return x.right;
            }
            Node t = x;
            x = min(t.right);
            x.right = deleteMin(t.right);
            x.left = t.left;
        }
        x.N = size(x.left) + size(x.right) + 1;
        return x;
    }

    public Iterable<Key> keys() {
        return keys(min(),max());
    }

    public Iterable<Key> keys(Key lo, Key hi) {
        List<Key> list = new ArrayList<>();
        keys(root,list,lo,hi);
        return list;
    }

    private void keys(Node x, List<Key> list, Key lo, Key hi) {
        if (x == null) return;
        int cmplo = lo.compareTo(x.key);
        int cmphi = hi.compareTo(x.key);
        if (cmplo < 0) keys(x.left,list,lo,hi);
        if (cmplo <= 0 && cmphi >= 0) list.add(x.key);
        if (cmphi > 0) keys(x.right,list,lo,hi);
    }

    public static void main(String[] args) {
        int minlen = 1;
        BST<String,Integer> bst = new BST<>();
        String[] words = new String[]{
                "it","was","the","best","of","times","it","was","the","worst","of","times",
                "it","was","the","age","of","wisdom","it","was","the","age","of","foolishness",
                "it","was","the","epoch","of","belief","it","was","the","epoch","of","incredulity",
                "it","was","the","season","of","light","it","was","the","season","of","darkness",
                "it","was","the","spring","of","hope","it","was","the","winter","of","despair"
        };
        int idx = 0;
        while (idx < words.length) {
            String word = words[idx];
            if (word.length() < minlen) {
                idx++;
                continue;
            }
            if (bst.get(word) == null) {
                bst.put(word,1);
            } else {
                bst.put(word,bst.get(word)+1);
            }
            idx++;
        }

        int len = 0;
        for (String x:bst.keys()) {
            System.out.println(x + " " + bst.get(x));
            len++;
        }
        System.out.println(len);
    }
}

在这里插入图片描述

【LeetCode】求二叉树所有路径组成的整数和：Sum Root to Leaf Numbers
Arlingtonroad的博客
06-11 247
Given a binary tree containing digits from0-9only, each root-to-leaf path could represent a number. An example is the root-to-leaf path1->2->3which represents the number123. Find the total sum of all root-to-leaf numbers. Note:A leaf is a no...
《算法4》符号表以及二叉查找树
leonliu1995的博客
10-21 1457
符号表符号表就是键值对的集合，并且支持put和get操作。现实中符号表的应用非常广泛，所以这里介绍几种键值对的实现，主要是二叉查找树以及之后将要介绍的红黑树。一个值得注意的点就是，符号表里面不允许重复的key，也就是put一个键值对时，会先查找符号表里面是否含有这个key，有的话就更改这个key对应的值，没有的话就新加一个键值对两种简单实现：（1）使用无序链表的顺序查找我们维护一个无序链表，当我们查
【LeetCode每天一题】Sum Root to Leaf Numbers(二叉树所有根到叶节点之和)
aoaichen0637的博客
05-24 148
Given a binary tree containing digits from0-9only, each root-to-leaf path could represent a number. An example is the root-to-leaf path1->2->3which represents the number 123. Find the ...
LeetCode | Sum Root to Leaf Numbers（所有根结点到叶节点路径和的和）
solar一抹阳光的专栏
08-15 614
Given a binary tree containing digits from 0-9 only, each root-to-leaf path could represent a number. An example is the root-to-leaf path 1->2->3 which represents the number 123. Find the tota
Alg-4：算法可视化tiny库的实现
weixin_34395205的博客
01-08 145
好吧，准备好好实践一下《算法》这本书的内容的，有点讨厌的是这本书是以Java作为示例语言的（好吧，我承认我有语言偏见，Java就是臭）。其中有一个Std库，其中涉及到简化输入输出、随机数生成、算法可视化的内容。里面的大部分功能在Python中早就是标配了~~~。唯独有一个用于算法可视化的StdDraw类Python没有build-in包。扩展包到时有很多（如Matplotlib），但是只是要和书本...
alg10-11.rar_数据结构_C/C++_
08-12
可能的练习包括二叉搜索树、平衡树（AVL树、红黑树）的操作，如插入、删除和查找。 7. **图算法**：图结构用于表示对象之间的关系，如邻接矩阵或邻接表。可能的练习包括最短路径算法（Dijkstra算法、Floyd-Warshall...
leetcode小偷-alg-go:算法
07-01
leetcode小偷107+ 编码面试题及详细解答 动机 我正在建立一个最常出现的编码面试问题的数据库，我认为这些问题是最有价值和最有成效的。...将有序数组转换为平衡二叉搜索树 将有序链表转换为平衡二叉搜索
Opt_Alg.rar_Java Graphics_barnel4_java
09-24
标题中的"Opt_Alg.rar_Java Graphics_barnel4_java"暗示了这是一个关于优化算法（Opt_Alg）的Java编程项目，特别关注图形处理（Java Graphics）和可能的一个特定算法实现，如barnel4，这可能是作者或项目特有的命名...
kd树加速k-means：优化算法与实现
它的构建基于二叉搜索树，但在每个节点上，它不仅根据一个维度进行分割，而且会交替地在不同的维度上进行分割，从而能够快速查找最近邻。在k-means算法中，kd树可以用于存储数据点，通过查询kd树找到每个点最近的...
alg笔记adsfasdfasfs
最新发布
10-09
* 树的高级操作：二叉搜索树、平衡二叉树等 * 树的应用场景：leetcode 等平台上的各种题目 图论相关知识点： * 图论的基本概念：图、节点、边等 * 图论的高级概念：深度优先搜索、广度优先搜索等 * 图论的应用场景...
LintCode 二叉树的所有路径
Bloodyrabbits的博客
04-21 483
1.描述 给一棵二叉树，找出从根节点到叶子节点的所有路径。 哪家公司问你的这个题？ Airbnb Alibaba Amazon Apple Baidu Bloomberg Cisco Dropbox Ebay Facebook Google Hulu Intel Linkedin Microsoft NetEase Nvidia
【alg4-排序】堆排序
...
11-30 204
堆排序可以分为两个阶段。在堆的构造阶段中，我们将原始数组重新组织安排进一个堆中；然后在下沉排序阶段，我们从堆中按递减顺序取出所有元素并得到排序结果。 堆的构造：从右至左用sink()函数构造子堆。数组的每个位置都已经是一个子堆的根结点了，sink()对于这些子堆也适用。如果一个结点的两个子结点都已经是堆了，那么在该结点上调用sink()可以将它们变成一个堆。这个过程会递归地建立起堆的秩序。开始时我们只需要扫描数组中的一半元素，因为我们可以跳过大小为1的子堆。最后我们在位置1上调用sink()方法，扫描结束。
算法分析（algs4）
离开实践的理论是空洞的理论,没有理论指导的实践是盲目的实践
08-18 1370
时间： 算法增长数量级的分类                             典型的增长数量级函数                                                             内存： 变量的类型的内存
Leetcode每日一题：129.sum-root-to-leaf-numbers（求根到叶子节点数字之和）
CodeLuweir 的博客
10-29 240
思路：把二叉树遍历一遍，遍历过程中，左孩子的值=父节点的值*10+左孩子的值，右孩子同理，这样每次遍历到叶子节点，叶子节点的值都会改为该条路径的值，利用sum把这些值加起来即可； struct TreeNode { int val; TreeNode *left; TreeNode *right; TreeNode(int x) : val(x), left(NULL), right(NULL) {} }; int sumNumbers(TreeNode *root) .
剑指offer24：二叉树中和为某一值的路径
sa726663676的博客
02-21 133
题目描述 输入一颗二叉树的根节点和一个整数，按字典序打印出二叉树中结点值的和为输入整数的所有路径。路径定义为从树的根结点开始往下一直到叶结点所经过的结点形成一条路径。 示例1 输入 {10,5,12,4,7},22 返回值 [[10,5,7],[10,12]] 思路：使用带追溯路径的递归方法。 需要用到两个变量，一个变量用于追溯递归路径，一个变量用于记录满足条件的所有结果。 1.通过一个共享列表的pop和append的实现。优点：所有递归的栈都使用同一个列表可以减少内存消耗...
【LeetCode专题】树、二叉树、二叉搜索树
Nichkhun的博客
12-01 340
LeetCode94 二叉树的中序遍历 class Solution(object): def inorderTraversal(self, root): """ :type root: TreeNode :rtype: List[int] """ reslist=[] def inord...
【alg4-字符串】正则表达式
...
12-25 262
正则表达式 在许多应用程序中，我们查找子字符串时并没有被查找模式的完整信息。文本编辑器的用户可能希望仅指定模式的一部分，或是指定某种能够匹配若干个不同单词的模式，或是指定几种可以任意匹配的不同模式。 正则表达式用自然、简单而强大的3种操作组合来描述模式。 使用正则表达式描述模式 模式的描述由3种基本操作和作为操作数的字符组成。这里，我们用语言指代一个字符串的集合（可能是无限的），用模式指代一种语言的详细说明。 连接操作 当我们写出AB时，就指定了一种语言{AB}。它含有一个由两个字符组成的字符串，由A和B连
LeetCode-题目详解（五）：二叉搜索树【遍历、验证、属性、修改、构造、插入节点、删除节点、修剪】
u013250861的博客
05-27 425
遇到二叉搜索树，立刻想到这句话：「二叉搜索树（BST）的中序遍历是有序的」。这是解决所有二叉搜索树问题的关键。给定一个二叉树，判断其是否是一个有效的二叉搜索树。假设一个二叉搜索树具有如下特征：示例 1: 示例 2: 方法一：递归方法 方法二：中序递归遍历（判断节点的有序性） 方法三：中序递归遍历（转为有序数组） 思路简单：将中序遍历的值一个个存入一个list中。理解二叉搜索树后，明白二叉搜索树中序遍历后是个递增序列。最后判断list是否为一个递增序列即可。 255. 验证前序遍历序列二叉搜索树
二叉搜索树应用分析
yuluoxuanyuan1992的博客
09-19 403
二叉搜索树（B树）特性1.所有非叶子结点至多拥有两个儿子（Left和Right）；2.所有结点存储一个关键字；3.非叶子结点的左指针指向小于其关键字的子树，右指针指向大于其关键字的子树； 基本操作 搜索 struct TreeNode { int val; TreeNode * left; TreeNode * right;
Julia语言中的ALG1-ALG2算法研究
资源摘要信息:"ALG1-ALG2" ALG1-ALG2 作为一个标题，可能指向了一系列与算法1和算法2相关的资源或代码库。由于描述部分仅为"ALG1-ALG2"，这并没有提供额外的信息，因此我们需要更多地关注文件名称列表中的信息，即 ...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值