Algorithm Review 3 二分搜索树

最新推荐文章于 2023-09-07 10:48:37 发布
最新推荐文章于 2023-09-07 10:48:37 发布
阅读量441 收藏 1
点赞数
分类专栏： 移动开发
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/amurocrash/article/details/71313630
版权

前面两篇讲的排序，熟悉算法应用的童鞋都知道，排序其实是很多算法的子过程，也就是说很多算法在执行自己前，都要先对数据进行排序，才能发挥算法的核心优势。所以排序说完了，下面就要说算法的一个核心应用，搜索。

一、二分查找法
二分查找法的思想非常朴实和经典，可以想象一样比如我们猜别人的年龄，一开始肯定是根据他的长相外貌特征，说一个大概的数字，如果对方说不对，那我们一定会追问对方是大了还是小了，而说出来的第一个数字其实就是二分查找法中使用的中点。
使用二分查找法有个前提，必须是有序数组才能使用二分查找法。
用图来表示的话很简单：
这里写图片描述

每次找到数组的中点v，看看是否等于我们要找的数值，如果等于则完成任务，否则小于则在v左边继续执行二分查找，反之则在右边。
上代码：

template<typename Item>
int binarySearch(Item arr[], int length, Item target)
{
    int l = 0;
    int r = length - 1;

    while(l <= r)
    {

        int mid = l + (r - l) / 2;

        if(target == arr[mid])
        {
            return mid;
        }

        if(target > arr[mid])
        {
            l = mid + 1;
        }
        else
        {
            r = mid - 1;
        }

    }

    return -1;

}

注意看mid取值的时候没有使用(l + r) / 2，为的是防止数据溢出。

二、二分搜索树
二分搜索树使用了字典的数据存储方式，也就是我们常用的keyValue。操作的时候只要操作key，然后根据key拿出其中的value就可以了。
二分搜索树是一颗二分树，但不是完全二分树，它有以下几个特性：
每个节点的键值大于左叶子；
每个节点的键值小于右叶子；
以左右叶子为根节点的树仍然是二分搜索树；
因为二分搜索树不是完全二分树，所以较难用数组来进行存储，这里必须用到链表的结构。
一个典型的二分搜索树长这样：
这里写图片描述
先定义一个二分搜索树节点的结构体：

struct Node
    {
        Key key;
        Value value;
        Node* left;
        Node* right;

        Node(Key key, Value value)
        {
            this->key = key;
            this->value = value;
            this->left = this->right = NULL;
        }

        Node(Node* otherNode)
        {
            this->key = otherNode->key;
            this->value = otherNode->value;
            this->left = otherNode->left;
            this->right = otherNode->right;
        }
    };

下面来讲二分搜索树的几个核心操作的代码，这里用到了大量的递归，大家看代码的时候可以体会到递归在这里的应用是多么的巧妙：

1.插入节点
让当前需要插入的元素e，与根节点的元素r进行对比，如果e小于r，则让e与r的左叶子为根节点的树继续进行对比，如此递归；如果e等于r，这里执行的更新当前节点的操作，当然根据不同的场景也可以进行其他操作，这里默认是更新；如果e大于r，则让e与r的右叶子为根节点的树进行对比，如此递归。

Node* insert(Node* node, Key key, Value value)
    {
        if(node == NULL)
        {
            count++;
            return new Node(key, value);
        }

        if(key == node->key)
        {
            node->value = value;
        }
        else if(key < node->key)
        {
            node->left = insert(node->left, key, value);
        }
        else
        {
            node->right = insert(node->right, key, value);
        }

        return node;
    }

希望大家好好递归在这里运用；

2.查找节点
根据二分搜索树的性质很容易想到查找节点的方法，让当前需要查找的元素e，与根节点的元素r进行对比，如果e == r，那就已经找到；如果e < r，则就到以r的左叶子为树的二分搜索树中去递归查找；同理e > r，则就到以r的右叶子为树的二分搜索树中去递归查找。

bool contain(Node* node, Key key)
    {
        if(node == NULL)
        {
            return false;
        }

        if(key == node->key)
        {
            return true;
        }
        else if(key < node->key)
        {
            return contain(node->left, key);
        }
        else
        {
            return contain(node->right, key);
        }
    }

    Value* search(Node* node, Key key)
    {
        if(node == NULL)
        {
            return NULL;
        }

        if(key == node->key)
        {
            return &(node->value);
        }
        else if(key < node->key)
        {
            return search(node->left, key);
        }
        else
        {
            return search(node->right, key);
        }
    }

这里写了两个方法，一个判断数据是否存在，一个则是真正的搜索，返回key对应的value指针。理解了原理的话，用递归来写算法真的是很简单。

3.深度优先遍历
这里写图片描述

这三种遍历是典型的代码比解释好写的…… 直接上代码

void preOrder(Node* node)
    {
        if(node != NULL)
        {
            cout << node->key << ", ";
            preOrder(node->left);
            preOrder(node->right);
        }
    }

    void inOrder(Node* node)
    {
        if(node != NULL)
        {
            inOrder(node->left);
            cout << node->key << ", ";
            inOrder(node->right);
        }
    }

    void postOrder(Node* node)
    {
        if(node != NULL)
        {
            postOrder(node->left);
            postOrder(node->right);
            cout << node->key << ", ";
        }
    }

    void destroy(Node* node)
    {
        if(node != NULL)
        {
            destroy(node->left);
            destroy(node->right);

            delete node;
            count--;
        }
    }

大家可以看到，代码真的很简单，只是cout的位置不一样而已，cout这句代码是可以换成对当前节点的其他任意复杂操作的。注意看最后一个destroy方法，其实一个二分搜索树的类在析构内部的Node链表的时候，用的就是后序遍历。

4.广度优先遍历
简单来说就是一层一层地来看二分搜索树上的数据。在代码编写的时候需要用到辅助的数据结构：队列。

void levelOrder()
    {
        queue<Node*> q;
        q.push(root);

        while(!q.empty())
        {
            Node* node = q.front();
            q.pop();

            cout << node->key <<", ";

            if(node->left)
            {
                q.push(node->left);
            }

            if(node->right)
            {
                q.push(node->right);
            }
        }

    }

每次把根节点的数据放入队列，然后出队，再遍历它的左右节点，分别入队，如此递归循环。这样就能一层一层的拿出二分搜索树中的数据。

5.获取最小和最大节点
获取最小节点的方法很简单，根据二分搜索树的特性，只要一直顺着左叶子递归找，直到找到一个不再有左叶子的节点为止。
最大节点就是反过来去右叶子找。

Node* getMin(Node* node)
    {
        if(node->left == NULL)
        {
            return node;
        }

        return getMin(node->left);
    }

    Node* getMax(Node* node)
    {
        if(node->right == NULL)
        {
            return node;
        }

        return getMax(node->right);
    }

6.删除最小、最大节点
学会了找到最小最大节点之后，删除这两种节点也是很容易的：
最小节点，拿到该节点的右叶子（因为最小节点不可能有左叶子），并把右叶子的指针取代原节点指针就行。
最大节点反之亦然。

Node* removeMin(Node* node)
    {
        if(node->left == NULL)
        {
            Node* right = node->right;

            count--;
            delete node;

            return right;
        }

        node->left = removeMin(node->left);

        return node;
    }

    Node* removeMax(Node* node)
    {
        if(node->right == NULL)
        {
            Node* left = node->left;
            count--;
            delete node;
            return left;
        }

        node->right = removeMax(node->right);

        return node;

    }

7.删除任意节点
任意节点删除和6所述的删除最大的区别就是会存在一种情况，被删除的节点左叶子右叶子都存在。根据二分搜索树的特点，我们只要用当前节点右叶子中的最小节点或者左叶子中的最大节点来替换掉当前被删除节点就可以了。

Node* remove(Node* node, Key key)
    {
        if(node == NULL)
        {
            return NULL;
        }

        if(key < node->key)
        {
            node->left = remove(node->left, key);
            return node;
        }
        else if(key > node->key)
        {
            node->right = remove(node->right, key);
            return node;
        }
        //key == node->key
        else
        {

            if(node->left == NULL)
            {
                Node* right = node->right;
                delete node;
                count--;

                return right;
            }
            else if(node->right == NULL)
            {
                Node* left = node->left;
                delete node;
                count--;

                return left;
            }
            //node->left != NULL && node->right != NULL
            else
            {
                Node* s = new Node(getMin(node->right));
                count++;
                s->left = node->left;
                s->right = removeMin(node->right);

                delete node;
                count--;

                return s;
            }

        }
    }

最后上一下完整的二分搜索树的代码：

//
//  BST.h
//  IndividualTestCpp
//
//  Created by Amuro on 2017/5/5.
//  Copyright © 2017 Amuro. All rights reserved.
//

#ifndef BST_h
#define BST_h

#include <iostream>
#include <string>
#include <queue>
using namespace std;

template <typename Key, typename Value>
class BST
{
private:
    struct Node
    {
        Key key;
        Value value;
        Node* left;
        Node* right;

        Node(Key key, Value value)
        {
            this->key = key;
            this->value = value;
            this->left = this->right = NULL;
        }

        Node(Node* otherNode)
        {
            this->key = otherNode->key;
            this->value = otherNode->value;
            this->left = otherNode->left;
            this->right = otherNode->right;
        }
    };

    Node* root;
    int count;

    Node* insert(Node* node, Key key, Value value)
    {
        if(node == NULL)
        {
            count++;
            return new Node(key, value);
        }

        if(key == node->key)
        {
            node->value = value;
        }
        else if(key < node->key)
        {
            node->left = insert(node->left, key, value);
        }
        else
        {
            node->right = insert(node->right, key, value);
        }

        return node;
    }

    bool contain(Node* node, Key key)
    {
        if(node == NULL)
        {
            return false;
        }

        if(key == node->key)
        {
            return true;
        }
        else if(key < node->key)
        {
            return contain(node->left, key);
        }
        else
        {
            return contain(node->right, key);
        }
    }

    Value* search(Node* node, Key key)
    {
        if(node == NULL)
        {
            return NULL;
        }

        if(key == node->key)
        {
            return &(node->value);
        }
        else if(key < node->key)
        {
            return search(node->left, key);
        }
        else
        {
            return search(node->right, key);
        }
    }

    void preOrder(Node* node)
    {
        if(node != NULL)
        {
            cout << node->key << ", ";
            preOrder(node->left);
            preOrder(node->right);
        }
    }

    void inOrder(Node* node)
    {
        if(node != NULL)
        {
            inOrder(node->left);
            cout << node->key << ", ";
            inOrder(node->right);
        }
    }

    void postOrder(Node* node)
    {
        if(node != NULL)
        {
            postOrder(node->left);
            postOrder(node->right);
            cout << node->key << ", ";
        }
    }

    void destroy(Node* node)
    {
        if(node != NULL)
        {
            destroy(node->left);
            destroy(node->right);

            delete node;
            count--;
        }
    }

    Node* getMin(Node* node)
    {
        if(node->left == NULL)
        {
            return node;
        }

        return getMin(node->left);
    }

    Node* getMax(Node* node)
    {
        if(node->right == NULL)
        {
            return node;
        }

        return getMax(node->right);
    }

    Node* removeMin(Node* node)
    {
        if(node->left == NULL)
        {
            Node* right = node->right;

            count--;
            delete node;

            return right;
        }

        node->left = removeMin(node->left);

        return node;
    }

    Node* removeMax(Node* node)
    {
        if(node->right == NULL)
        {
            Node* left = node->left;
            count--;
            delete node;
            return left;
        }

        node->right = removeMax(node->right);

        return node;

    }

    Node* remove(Node* node, Key key)
    {
        if(node == NULL)
        {
            return NULL;
        }

        if(key < node->key)
        {
            node->left = remove(node->left, key);
            return node;
        }
        else if(key > node->key)
        {
            node->right = remove(node->right, key);
            return node;
        }
        //key == node->key
        else
        {

            if(node->left == NULL)
            {
                Node* right = node->right;
                delete node;
                count--;

                return right;
            }
            else if(node->right == NULL)
            {
                Node* left = node->left;
                delete node;
                count--;

                return left;
            }
            //node->left != NULL && node->right != NULL
            else
            {
                Node* s = new Node(getMin(node->right));
                count++;
                s->left = node->left;
                s->right = removeMin(node->right);

                delete node;
                count--;

                return s;
            }

        }
    }

public:

    BST()
    {
        root = NULL;
        count = 0;
    }

    int size()
    {
        return count;
    }

    bool isEmpty()
    {
        return count == 0;
    }

    void insert(Key key, Value value)
    {
        this->root = insert(root, key, value);
    }

    bool contain(Key key)
    {
        return contain(root, key);
    }

    Value* search(Key key)
    {
        return search(root, key);
    }

    void preOrder()
    {
        preOrder(root);
    }

    void inOrder()
    {
        inOrder(root);
    }

    void postOrder()
    {
        postOrder(root);
    }

    void levelOrder()
    {
        queue<Node*> q;
        q.push(root);

        while(!q.empty())
        {
            Node* node = q.front();
            q.pop();

            cout << node->key <<", ";

            if(node->left)
            {
                q.push(node->left);
            }

            if(node->right)
            {
                q.push(node->right);
            }
        }

    }

    Key getMin()
    {
        if(count == 0)
            return NULL;

        return getMin(root)->key;
    }

    Key getMax()
    {
        if(count == 0)
            return NULL;

        return getMax(root)->key;
    }

    void removeMin()
    {
        if(count == 0)
            return;

        root = removeMin(root);
    }

    void removeMax()
    {
        if(count == 0)
            return;

        root = removeMax(root);
    }

    void remove(Key key)
    {
        root = remove(root, key);
    }

    ~BST()
    {
        destroy(root);
    }

};

void testBST()
{
    BST<int, string> bst = BST<int, string>();

    bst.insert(10, "a");
    bst.insert(8, "b");
    bst.insert(2, "c");
    bst.insert(7, "d");
    bst.insert(1, "e");
    bst.insert(13, "f");
    bst.insert(4, "g");
    bst.insert(6, "h");

    bst.preOrder();
    cout << endl;

    bst.inOrder();
    cout << endl;

    bst.postOrder();
    cout << endl;

    bst.levelOrder();
    cout << endl;

    cout << bst.getMin() << ", " << bst.getMax() << endl << endl;

    cout << "do delete" << endl;
    bst.removeMin();
    bst.removeMin();
    bst.removeMax();

    bst.levelOrder();
}

#endif /* BST_h */

对比下二分搜索树和其他数据结构的搜索效率，明显是优于普通数组的。
这里写图片描述

另外，二分搜索树有个重大的缺陷，就是如果按照1，2，3，4这样的顺序插入数据时，得到的二分搜索树是这样的：
这里写图片描述

没错，退化成了链表，想要解决这个问题，需要用到更复杂的平衡二叉树，常见的就是红黑树，有兴趣的同学可以继续深入研究。

amurocrash
关注
专栏目录
Random Walks: A Review of Algorithms and Applications2020翻译
weixin_45562632的博客
05-08 815
Random Walks: A Review of Algorithms and Applications2020翻译 在翻译的时候公式太多，公式部分有些乱码。如果需要可以看看本文的文字，感兴趣的话直接去看原文公式。 摘要: 随机漫步被称为随机过程，它描述了数学空间中包含一系列随机步骤的路径。它在数学和计算机科学等各个学科中越来越受欢迎。再者，在量子力学中，量子游动可以看作经典随机游动的量子类似物。经典随机漫步和量子漫步可用于计算节点之间的邻近度和提取网络中的拓扑。各种随机游走相关模型可以应用于不同的领域，
Algorithm Review 4 跳表
amurocrash的专栏
08-22 194
跳表的思想起点来自二分搜索，大家都知道一个排好序的数组进行二分搜索是很容易的，就是每次选择中间的数据，看看比要搜索的数据大还是小，大的话就向右搜索，小的话就向左搜索，复杂度是惊人的O(log(n))，比如42 亿个数据中用二分查找一个数据，最多也只需要比较 32 次。 但是对于redis这样的工具来说，会有频繁的插入删除操作，我们知道数组的插入删除操作性能是比较低的，因为需要O(n)次的移动。而对插入删除友好的是链表，只要断开指针前后调一下就好了，但问题是找到需要插入的位置是很麻烦的，需要遍历一遍链表，所以
数据结构与算法一览（树、图、排序算法、搜索算法等）- Review
qq_44992559的博客
04-17 650
4.树 4.1二叉树 4.2B树与B+树 4.3哈夫曼(霍夫曼)树:Huffman Tree4.4线段树:略 4.5红黑树:简5.图 5.1图论概念5.2图的存储 5.3最小生成树(Minimum spanning Tree，MST) 5.3.1定义 5.3.2最小生成树算法:Kruskal算法-加边(边权从小到大)5.3.3最小生成树算法:Prim算法-加点(距离从小到大)5.4最小直径生成树:略 5.5欧拉图:通过所有边且每条边恰好—次 5.6哈密顿图:所有顶点一次且且每个顶点恰好—次5.7拓扑排序
【综】A review of bicycle-sharing service planning problems
panbaoran913的博客
03-30 1727
本文参考本文介绍的新型自行车共享服务规划过程，从战略、战术和运营决策层对现有的自行车共享服务计划问题（BSPPs）文献进行了回顾和系统分类。确定并讨论了当前的研究差距。根据新多样性、现实性、完整性和技术四大类，提出了这三个决策层问题的未来研究方向。本文还指出了多级BSPP以及自行车共享系统与现有多式联运系统集成的未来重要研究方向。关键词：自行车共享服务规划问题自行车搬迁自行车道网络设计自行车站设计搬迁服务规划需求管理。
遥感影像分类方法
qq_44951617的博客
09-21 1万+
摘要：遥感影像的分类作为其他遥感技术的一项基础内容，对后续遥感的应用具有一定的现实意义。计算机技术和遥感技术的飞速发展，遥感影像的分类方法从最初的人工目视解译不断发展，经历了从手动到半自动再到近全自动的发展过程。从遥感影像分类的全过程来说，仍然没有达到全自动分类。本文加入了深度学习分类方法，与传统的监督分类、非监督分类进行对比，简单介绍各种分类方法的基本思想和应用，最后进行总结并展望未来的发展。 关键词：影像分类；监督分类；非监督分类；深度学习 内容为整理内容并非文献仅供参考
经典文献阅读之--A Review of Motion Planning（轨迹规划回顾）
lovely_yoshino的博客
06-14 1万+
对于自动驾驶以及机器人而言，除了SLAM以外，另一个比较重要的部分就是轨迹规划了。而最近作者看到了几篇比较好的文章，分别为《》、《》、《》这里就结合各个文章阐述的要点给各位对轨迹规划进行科普，以便了解未来几年需要解决的差距和挑战。
NLP之GPT-3：《 Language Models are Few-Shot Learners》的翻译与解读
近期请国内外头部出版社可尽快私信博主！——心比天高，仗剑走天涯，保持热爱，奔赴向梦想！低调，谦虚，自律，反思，成长，还算是比较正能量的博主，公益免费传播……内心特别想在AI界做出一些可以推进历史进程影响力的东西(兴趣使然，有点小情怀，也有点使命感呀)…
07-29 1万+
​ NLP之GPT-3：《 Language Models are Few-Shot Learners》的翻译与解读 目录 相关文章 《GPT-3: Language Models are Few-Shot Learners》的翻译与解读 Abstract 摘要 1 Introduction 介绍 2 Approach方法 3 Results 结果 4 Measuring and Preventing Memorization Of Ben
论文笔记：一分类及其在大数据中的潜在应用综述
最新发布
爱学习爱运动的专栏
09-07 1279
论文：A literature review on one‑class classification and its potential applications in big data发表：Journal of Big Data在严重不平衡的数据集中，使用传统的二分类或多分类通常会导致对具有大量实例的类的偏见。在这种情况下，对少数类实例的建模和检测是非常困难的。一分类(OCC)是一种检测与已知类实例相比较的异常数据点的方法，可以用于解决与严重不平衡数据集相关的问题，这在大数据中尤其常见。
基于3D关节点的人体动作识别综述
热门推荐
yeluohanchan的博客
12-04 6万+
文基于3D关节点的人体动作识别综述 原文：2016，Pattern Recognition： 3D skeleton-based human action classification: A survey 摘要 近年来，基于深度序列的人体动作分类的研究越来越多，出现了基于不同数据源：深度图或RGB视频的3D人体关节的人体动作分类的方法以及特征表示方法。 本文...
Algorithm-Android-Review.zip
09-17
例如，用二分查找提高搜索效率，用哈希表快速定位数据，用图算法解决复杂的路由问题。 2. UI优化：在Android用户界面设计中，动画和滑动效果的流畅性是用户体验的重要指标。通过算法优化，如缓存策略、帧率控制、预...
[论文笔记]A systematic review of fuzzing based on machine learning techniques
Rac1ne的博客
01-04 1443
A systematic review of fuzzing based on machine learning techniques Wang, Yan, Peng Jia, Luping Liu, Cheng Huang和Zhonglin Liu. 《A Systematic Review of Fuzzing Based on Machine Learning Techniques》. 编辑 Tao Song. PLOS ONE 15, 期 8 (2020年8月18日): e0237749. http
Deep Learning-Based Video Coding: A Review and A Case Study
weixin_30325487的博客
06-13 2061
郑重声明：原文参见标题，如有侵权，请联系作者，将会撤销发布！ 1、Abstract: 　　本文主要介绍的是2015年以来关于深度图像/视频编码的代表性工作，主要可以分为两类：深度编码方案以及基于传统编码方案的深度工具。对于深度编码方案，像素概率建模和自动编码器是两种方法，分别可以看作是预测编码方案和变换编码方案。对于深度工具，有几种使用深度学习来执行帧内预测、帧间预测、跨通道预测、概率分...
Java常用加密技术和代码总结
amurocrash的专栏
07-15 1万+
Java常用加密技术和代码总结，还通过一些生活中容易理解的场景来解释算法复杂的逻辑。
Android实现一个简单的课程表
amurocrash的专栏
05-28 1万+
课程表要做复杂要考虑的东西很多，这里只说实现界面的一个简单的思路：ScrollView嵌套七个（一周七天）LinearLayout， 而每个LinearLayout又能封装成一个课程表View的ViewItem，都继承自FrameLayout。下面上代码：         首先是课程表每一天的item，现在默认一天是7节课，后面可设置成可拓展用代码实现，这里现在xml里写死： <Linear
Activity Dialog样式的那些坑
amurocrash的专栏
11-03 5795
讲道理，先允许我吐槽一下google的api，我找了一天多的资料也没找到除了在manifest中配置外，其他的实现Activity对话框样式的方法。这对app来说可能无所谓，但是SDK因为大部分情况下不能使用xml配置文件，会导致大量的特性要去寻求代码的解决方案，而谷歌基本都没有提供这样方案的官方文档，只能自己看源码去倒推，甚至很多时候还要反射来做。 坑1： Dialog样式的Activity是
气泡随机分布界面的实现
amurocrash的专栏
04-29 4554
废话不多说，最近需求要实现一个这样的界面，如下图：         整体界面要求为气泡大致位置在屏幕某个区域，但圆心本身位置在该区域内随机，气泡半径，背景色也随机。然后界面展示时有一个漂浮出来的动画效果，气泡之间可以有遮挡但不可以挡住字，点击换一批的时候，重复以上所述动画效果，所有随机值刷新。
android仿网易新闻下拉刷新上拉关闭容器
amurocrash的专栏
09-17 4470
学习到了一个阶段需要总结，对程序员来说最好的总结方式就是把最近掌握的内容写一个demo出来，自定义View也看了蛮久了，最近一直在用网易新闻app，感觉下拉刷新上拉关闭的用户体验非常舒服，所以就自己照着写一个给最近的学习一个总结吧。     这次没有直接继承ViewGroup而是直接继承了LinearLayout，所以onMeasure就不需要自己折腾了，下面直接上代码，然后讲解下思路： pa
Android NDK开发技术与技巧总结
amurocrash的专栏
07-08 4062
Android NDK技术深度总结，同时提供了一些作者自己研究的开发技巧，尤其是C开发时JNI源码的自动提示和测试技巧
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值