搜索二叉树代码框架（复习）

已于 2022-04-29 17:47:33 修改
阅读量1.2k 收藏
点赞数
分类专栏： 算法 文章标签： 数据结构
于 2022-04-27 23:17:05 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_51641706/article/details/124450914
版权
本文详细介绍了二叉搜索树的查找、插入和删除操作的迭代与递归实现。通过模板化的步骤，阐述了在不同情况下如何处理节点的插入和删除，包括处理空节点、单子节点和双子节点的情况。同时，给出了AC代码示例，涵盖了递归和迭代两种方法，帮助读者巩固二叉搜索树的基本操作。
摘要由CSDN通过智能技术生成

前言：复习就不想用长篇大论来解释二叉搜索了，尽量用模板化的框架来帮助写二叉搜索的增删改。对于find和insert还是好记得，但是erase确实情况太多，不多写没办法记

文章目录

迭代版

find

find步骤：

  1. 比key大往右早，比key大往左找
  2. 用一个cur指针像遍历链表一样去找
  3. 找到返回对应的Node

总结：根据二叉搜索的性质像遍历链表一样找到对应的节点。

代码：

node* find(const k& key)
	{
		if (root == nullptr) return nullptr;
		node* cur = root;
		while (cur)
		{
			if (key < cur->key) cur = cur->left;
			else if (key > cur->key) cur = cur->right;
			else return cur;
		}
		return nullptr;
	}

insert

insert步骤：

  1. 在find的基础上加多一个parent指针
  2. 用cur和parent像遍历链表一样找到合适的位置
  3. 比key大就往右，比key小就往左
  4. 找到合适的位置new一个节点然后用parent指向它
  5. 如果根为空，就创建一个根

如果熟悉这个流程，就不要看流程了，没用。
直接看强调的细节
1.用parent指向新创建的节点时要比较新的key和parent的key的大小，若新节点大，用parent的right连newnode。若新节点小，用parent的left连newnode。

这个细节在写二叉搜索代码是最重要的。增和删都必须要做！！！

代码：

bool insert(const k& key, const v& val)
	{
		if (root == nullptr)
		{
			root = new node(key, val);
			return true;
		}
		node* cur = root, * parent = nullptr;
		while (cur)
		{
			if (key < cur->key) {
				parent = cur;
				cur = cur->left;
			}
			else if (key > cur->key) {
				parent = cur;
				cur = cur->right;
			}
			else return false;//重复不插入
		}

		node* newnode = new node(key, val);
		if (parent->key > key) parent->left = newnode;
		else parent->right = newnode;
		return true;
	}

erase

erase步骤：

  1. 先找到对应的节点
  2. 考虑四种情况：分别是节点左右孩子为空，左孩子为空，右孩子为空，左右孩子都不为空。前三种种情况再细分这个节点是否为根节点
  3. 左右孩子为空且该点是根节点的话，把root = nullptr再删除。不是根的话直接删除
  4. 左孩子为空且是根节点，直接让root = root -> right，并删除原先的根节点。不是根节点的话，根据insert讲的分类操作来让目标点的父亲节点继承目标点的孩子节点。并删除目标点
  5. 右孩子为空和4同理，记住必须分类
  6. 左右孩子都不为空不需要考虑是否为根。找到左子树最大的点或者右子树最小的点。然后删除它，并把它的key和value拷贝给原来要删除的节点。删除完还要继承最小/最大节点的孩子。继承的时候也要分类讨论。
  7. 如果点6想写成递归的话，可以找到最小或者最大节点，然后递归调用自己去删除。这样就不用处理继承问题了。删除完再把最小/最大节点的值拷贝给原来要删除的节点
bool erase(const k& key)
	{
		node* cur = root, * parent = nullptr;

		while (cur)
		{
			if (key < cur->key)
			{
				parent = cur;
				cur = cur->left;
			}
			else if (key > cur->key)
			{
				parent = cur;
				cur = cur->right;
			}
			else
			{
				if (cur->left == nullptr && cur->right == nullptr)
				{
					if (parent == nullptr) root = nullptr;
					else if (cur->key < parent->key) parent->left = nullptr;
					else parent->right = nullptr;
					delete cur;
					cur = nullptr;
				}
				else if (cur->right == nullptr)
				{
					if (parent == nullptr && cur == root) root = root->left;
					else if (cur->val < parent->val) parent->left = cur->left;
					else parent->right = cur->left;
					delete cur;
					cur = nullptr;
				}
				else if (cur->left == nullptr)
				{
					if (parent == nullptr && cur == root) root = root->right;
					else if (cur->val < parent->val) parent->left= cur->right;
					else parent->right = cur->right;
					delete cur;
					cur = nullptr;
				}
				else
				{
					node* minNode = cur->left, *parent = cur;
					while (minNode->right)
					{
						parent = minNode;
						minNode = minNode->right;
					}
					//递归
					/*int mk = minNode->key, mv = minNode->val;
					this->erase(mk);
					cur->key = mk;
					cur->val = mv;*/
					if (parent->key < minNode->key) parent->right = minNode->left;
					else parent->left = minNode->left;
					cur->key = minNode->key;
					cur->val = minNode->val;
					delete minNode;
					minNode = nullptr;
				}
				return true;
			}
		}
		return false;
	}

递归版

不懂迭代的思路是写不出递归的。

find（两种写法）

思路
1.比key大往右找，比key小往左找
2.找不到返回null
3.找到返回root

node* _find(const k& key, node* root)
{
	if (root == nullptr) return nullptr;
	else if (root->key < key) return _find(key, root->right);
	else if (root->key > key) return _find(key, root->left);
	else return root;
}

不知道是否记得我们学二叉树的时候必做的一道题，给一个val，找这个节点。

如下：

TreeNode find(TreeNode root, int val) {
    if (root == null) {
        return null;
    }
    // 前序位置
    if (root.val == val) {
        return root;
    }
    // root 不是目标节点，去左右子树寻找
    TreeNode left = find(root.left, val);
    TreeNode right = find(root.right, val);
    // 看看哪边找到了
    return left != null ? left : right;
}

其实也可以改用到我们二叉搜索树的查找里面。

node* _find(node* root, const k& key)
{
	if (root == nullptr) return nullptr;
	if (root->key == key) return root;
	node* left = nullptr, * right = nullptr;
	if (root->key < key) right = _find(root->right, key);
	else left = _find(root->left, key);

	return left ? left : right;
}

insert（两种写法）

insert有两种写法：
一种是有返回值得写法，一种是没有返回值得写法。这里推荐没有返回值得写法。

有返回值的写法：
思路：
1.如果找到空的位置，直接创建一个新的节点，并返回
2.如果比key小，往左子树插入。如果比key大，往右子树插入。
3.插入完成之后返回根节点root。
总体而言就是前序遍历

node* _insert1(const k& key, const v& val, node* root)
{
	if (root == nullptr)
	{
		root = new node(key, val);
		return root;
	}
	else if (root->key < key) root->right = _insert1(key, val, root->right);
	else if (root->key > key) root->left = _insert1(key, val, root->left);
	return root;
}

没有返回值的写法：
思路：我们知道，插入节点需要知道新节点的父亲是谁。没有返回值很难做到这一点，但是有一个很好的办法，就是引用参传。

void _insert2(const k& key, const v& val, node*& root)
{
	if (root == nullptr)
		root = new node(key, val);
	else if (root->key < key)
		_insert2(key, val, root->right);
	else
		_insert2(key, val, root->left);
}

讲解一下这是如何把父亲节点和新节点连起来的。
root是一个引用，在传参的时候，它有可能传给了root->right,也可能传给了root->left，因此root有一个别名就是上一层的root->right/left指针。因此我们可以借助这个指针来连接父节点和新节点。（你只要记住，此时的root就是父亲节点的左指针或者右指针就行了。）
在这里插入图片描述
root =new node()的意思其实就是父亲节点的右/左指针指向新插入的节点

erase

erase用递归写还是先找再删的流程
1.找
2.删，分三种情况。（和迭代一样），**其中第一种和第二种由于是继承的操作，因此用引用可以直接解决问题了。**第三种情况还是得用迭代的方法来做，此时引用不起作用了，因为要找右边最小的节点，离root很远了。

void _erase(const k& key, node*& root)
{
	if (root == nullptr) return;
	else if (root->key < key) _erase(key, root->right);
	else if (root->key > key) _erase(key, root->left);
	else
	{
		if (root->left == nullptr)
		{
			node* del = root;
			root = root->right;
			delete del;
			del = nullptr;
		}
		else if (root->right == nullptr)
		{
			node* del = root;
			root = root->left;
			delete del;
			del = nullptr;
		}
		else
		{
			node* minNode = root->right, *parent = root;
			while (minNode->left)
			{
				parent = minNode;
				minNode = minNode->left;
			}
			k minkey = minNode->key;
			v minval = minNode->val;
			if (parent->key < minNode->key) parent->right = minNode->right;
			else parent->left = minNode->right;
			delete minNode;
			root->key = minkey, root->val = minval;
		}
	}
}

说一下：第一种情况和第二种情况的root = root->right,其实就是父亲节点的右指针指向了删除节点的下一个节点。（root->right = root->right->right)

题目

复习完模板把这两道模板题分别用递归和迭代写一下
搜索二叉树插入
ac递归代码：

class Solution {
public:
    void insert(TreeNode*& root, int val)
    {
        if(root == nullptr)
        {
            root = new TreeNode(val);
            return;
        }
        if(root->val < val) insert(root->right, val);
        else insert(root->left, val);
    }
    TreeNode* insertIntoBST(TreeNode* root, int val) {
        insert(root, val);
        return root;
    }
};

ac迭代代码：

class Solution {
public:
    TreeNode* insertIntoBST(TreeNode* root, int val) {
        if(root == nullptr)
        {
            return new TreeNode(val);
        }
        TreeNode* cur = root, *parent = nullptr;
        while(cur)
        {
            parent = cur;
            if(cur->val < val) cur = cur->right;
            else cur = cur->left;
        }

        TreeNode* newnode = new TreeNode(val);
        if(parent->val < val) parent->right = newnode;
        else parent->left = newnode;
        return root;
    }
};

删除搜索二叉树节点
ac递归代码：

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode() : val(0), left(nullptr), right(nullptr) {}
 *     TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
 *     TreeNode(int x, TreeNode *left, TreeNode *right) : val(x), left(left), right(right) {}
 * };
 */
class Solution {
public:
    void erase(TreeNode*& root, int key)
    {
        if(root == nullptr) return;
        if(root->val < key) erase(root->right, key);
        else if(root->val > key) erase(root->left, key);
        else
        {
            if(root->left == nullptr)
            {
                TreeNode* del = root;
                root = root->right;
                delete del;
            }
            else if(root->right == nullptr)
            {
                TreeNode* del = root;
                root = root->left;
                delete del;
            }
            else
            {
                TreeNode* minNode = root->right, *parent = root;
                while(minNode->left)
                {
                    parent = minNode;
                    minNode = minNode->left;
                } 
                int k = minNode->val;
                if(parent->val < minNode->val) parent->right = minNode->right;
                else parent->left = minNode->right;
                delete minNode;
                root->val = k;
            }
        }
    }
    TreeNode* deleteNode(TreeNode* root, int key) {
        erase(root, key);
        return root;
    }
};

迭代ac代码：

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode() : val(0), left(nullptr), right(nullptr) {}
 *     TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
 *     TreeNode(int x, TreeNode *left, TreeNode *right) : val(x), left(left), right(right) {}
 * };
 */
class Solution {
public:
    TreeNode* deleteNode(TreeNode* root, int val) {
        TreeNode* cur = root, *parent = nullptr;
        while(cur)
        {
            if(cur->val < val)
            {
                parent = cur;
                cur = cur->right;
            }
            else if(cur->val > val)
            {
                parent = cur;
                cur = cur->left;
            }
            else
            {
                if(cur->left == nullptr)
                {
                    if(parent == nullptr && cur == root)
                    {
                        root = root->right;
                        delete cur;
                        cur = nullptr;
                    }
                    else
                    {
                        if(parent->val < cur->val)
                            parent->right = cur->right;
                        else
                            parent->left = cur->right;
                        delete cur;
                        cur = nullptr;
                    }
                }
                else if(cur->right == nullptr)
                {
                    if(parent == nullptr && cur == root)
                    {
                        root = root->left;
                        delete cur;
                        cur = nullptr;
                    }
                    else
                    {
                        if(parent->val > cur->val)
                            parent->left = cur->left;
                        else
                            parent->right = cur->left;
                        delete cur;
                        cur = nullptr;
                    }
                }
                else
                {
                    TreeNode* minNode = cur->right, *parent = cur;
                    while(minNode->left)
                    {
                        parent = minNode;
                        minNode = minNode->left;
                    }

                    int v = minNode->val;
                    if(parent->val < minNode->val) parent->right = minNode->right;
                    else parent->left = minNode->right;
                    delete minNode;
                    cur->val = v;
                }
            }
        }
        return root;
    }
};
小丑小丑小丑
关注
专栏目录
如何全局搜索框架内代码
x631617479的博客
05-10 1934
最近在看关于spring如何操作事务的源码，除了打印ALL等级的日志可以大体把控事务流程外有时候还想通过关键字搜索框架里的源码，找了挺久偶然发现 以事务代码为例 先把log等级提升到ALL 根据打印的日志找到流程所经过类的class 以idea为例 点击上方的现在源码 打开搜索 选择scope标签 All Places 即可搜索 ...
搜索的基本框架
霜叶的博客
10-30 1242
1、搜索与推荐 用户从海量文本中获取信息主要通过两个途径，搜索和推荐；搜索和推荐的区别在于，搜索是通过输入一定的信息，获取对应的信息，是一个主动获取信息的过程。推荐则是app/web根据用户的历史行为数据，猜测用户的喜好，进行内容的推送。 2、搜索分类 2.1.搜索分类 一般搜索分为大搜和垂搜，大搜就是像百度、google、bing等对相关网页进行搜素。垂搜指的是某一领域的搜索，比如爱奇艺中的视频检索、淘宝的商品检索、贝壳的房子搜索等。 2.2、搜索基本模块 ...
【数据结构】二叉树基本代码总结
@宁兰 的博客
10-06 1793
二叉树上完好一段时间了，但有些问题一直没有解决，所以趁此机会灭了这些问题并一并整理下来，方便复习及以后深入学习 结构框架 基本性质 存储方式及基本结构 层次遍历、顺序转链式非递归及垂直输出 前序遍历的递归非递归及快速排序 中序遍历的递归非递归及汉诺塔问题 后序遍历的递归非递归及深度求解与删除 中序与其外二者之一结合求真实二叉树 1. 基本性质 双亲为 ai ,左孩子为 a2i ,右...
复习框架
u012197749的博客
09-20 196
作者：Oscarwin 链接：https://www.zhihu.com/question/34574154/answer/253165162 来源：知乎 著作权归作者所有。商业转载请联系作者获得授权，非商业转载请注明出处。   extern关键字作用 static关键字作用 volatile是干啥的 说说const的作用，越多越好 new与malloc区别 C++多态性与虚函数表 C...
树论复习--算法框架
weixin_52688663的博客
06-15 241
关于树论的复习算法框架
第五章 树与二叉树--以下代码由C语言实现
weixin_40290845的博客
03-24 1108
王道学习 5.1 知识框架 5.2 树的基本概念 5.2.1 树的定义 树是n (n≥0)个节点的有限集。当n=0时，称为空树。在任意一棵非空树中应满足: 1）有且仅有一个特定的称为根的结点。 2)当n>1时，其余节点可分为m (m>0)个互不相交的有限集T,T2…,Tm，其中每个集合本身又是一棵树，并且称为根的子树。 显然，树的定义是递归的，即在树的定义中又用到了其自身，树是一种递归的数据结构。树作为一种逻辑结构，同时也是一种分层结构，具有以下两个特点: 1）树的根结点没有前驱，除根结点外的
第5章 树与二叉树
a131529的博客
06-09 1059
包含双亲表示法、孩子表示法以及孩子兄弟表示法。线索二叉树的目的是加快对二叉树的遍历。包含前序、中序、后序和层序。
LeetCode：二叉树刷题（篇章一）
可乐的博客
01-16 1064
二叉树LeetCode刷题集合 (篇章一)[] (篇章二)[] (篇章三)[] 文章目录二叉树LeetCode刷题集合前言一、二叉树解题框架二、相关题目1.二叉树的前、中、后遍历1.1 二叉树的前序遍历1.2 二叉树的中序遍历1.3 二叉树的后序遍历2. 其他入门题目2.1 LeetCode104. 二叉树的最大深度2.2 LeetCode543. 二叉树的直径总结 前言   本人刷小题小白，参考 labuladong 的算法小抄的刷题指南，开启《二插树》的刷题之路，解题方法并非原创，使用C++和P
【详细整理】二叉树的遍历+力扣617合并二叉树 226翻转二叉树
m0_37636691的博客
06-22 209
文章目录一、二叉树遍历构架二、遍历举例三、遍历架构实操——力扣题1、617 合并二叉树（1）题目：（2）分析解答2、226翻转二叉树（1）题目（2）分析解答 一、二叉树遍历构架 刚开始刷二叉树的题，边刷边学，第一次接触二叉树，递归真是看得人：我是谁 我在哪，整理一下今天学的内容，复习同时以便以后自己查阅。如果有错误或者疏漏，欢迎大家补充交流。 二叉树遍历构架： void traverse(TreeNode root){ if(root == null){ retur
二叉排序树与平衡二叉树的实现
12-26
中序遍历二叉树算法的框架是： 若二叉树为空，则空操作； 否则(1)中序遍历左子树（L）； (2)访问根结点（V）； (3)中序遍历右子树（R）。 中序遍历二叉树也采用递归函数的方式，先访问左子树2i,然后访问根结点...
validnumberleetcode自动机-coderjia-to-architect:JiA同学的代码人生，各种优秀语言、框架、中间件、神
07-06
JiA同学的代码人生，梦想成长为一名优秀的Architect（a7t）。成长一名优秀的a7t之前，需要不断提升自己的技术广度及深度。成长过程都记录在此，方便自己归纳知识点与复习。 目录 Java 基础 集合 IO 并发 JVM 计算机...
数据结构和Java集合框架
12-07
5. **树**：具有层级关系的数据结构，二叉树在搜索、排序等问题中广泛应用，红黑树是一种自平衡二叉查找树，能保证插入、删除和查找的效率。 6. **图**：表示对象之间的复杂关系，如网络拓扑、社交网络等。 Java...
北航机试复习指南20201
08-08
- **数据结构与算法**：如树结构（根节点、叶节点、父节点的关系），可能涉及到二叉树、搜索树、图等数据结构，以及查找、排序、最短路径等相关算法。 - **递归与迭代**：在处理树形结构时，递归和迭代是常见的解题...
Java面试复习体系总结（2021版,持续更新）
热门推荐
Viper的程序员修炼手册
02-26 11万+
Java面试复习体系总结（2021版） 一、Java基础 内容 Java基础（一）：Java集合框架（超详细解析，看完面试不再怕） Java基础（二）：迭代器（Iterator）（含使用方法详解） Java基础 （三）：LinkedList（含使用方法详解） Java基础（四）：ArrayList（含使用方法详解） Java基础（五）：HashSet（使用方法详解） Java基础（六）：HashMap（使用方法详解） Java基础（七）：栈 Stack（使用方法详解）
数据结构，问题 F: 括弧匹配检验
nick_912912的博客
11-02 218
假设表达式中允许包含两种括号：圆括号和方括号，其嵌套的顺序随意，如（［ ］（））或［（［ ］［ ］）］等为正确的匹配，［（ ]）或（［ ］（ ）或 ( ( ) ) ）均为错误的匹配。输入一个只包含圆括号和方括号的字符串，判断字符串中的括号是否匹配，匹配就输出 “OK” ，不匹配就输出“Wrong”。匹配就输出 “OK” ，不匹配就输出“Wrong”。现在的问题是，要求检验一个给定表达式中的括弧是否正确匹配？输入仅一行字符（字符个数小于255）输入一个字符串：［（［］［］）］，输出：OK。
python数据类型-8-数据结构-Queue (队列)
Lookontime的博客
10-30 308
在python数据类型系列文章中已经介绍了 python的各种数据类型，队列（Queue）是一种非常重要的数据结构，但并不是python的数据类型，队列遵循先进先出（FIFO）的原则，即先插入的元素先被移除，主要的用途是为了支持线程安全和高效的队列操作而设计的！
数据结构(8.7_1)——外部排序
最新发布
m0_65240792的博客
11-03 83
输出缓冲区1空了用归并段1的下一块元素补上 ..... 顺序的两个归并段方法一样..... 由于文件总块数无法改变，所以只能对归并趟数进行改变 注意：k不能无限增大、若k太大了也会增加内部归并所需时间在缓冲区内直接排序
代码随想录：从中后/中前遍历序列构造二叉树
qq_74924951的博客
10-30 305
两种遍历生成二叉树
Java笔试代码实战演练及提交指南
因此，应聘者需要掌握常见数据结构（如链表、栈、队列、二叉树、堆、图等）和算法（如排序算法、搜索算法、动态规划、贪心算法等）。对于笔试题目中可能出现的算法问题，需要能够编写清晰、高效的代码实现。 3. ...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值