二叉搜索树

已于 2022-05-18 21:59:23 修改
阅读量105 收藏
点赞数
分类专栏： 每日一题 文章标签： c++ 开发语言
于 2022-05-10 22:34:56 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_47872359/article/details/124697069
版权

铺垫知识：

0.0 二叉树的遍历

在这里插入图片描述
在这里插入图片描述

遍历分： 前序遍历、中序遍历、后续遍历

  1. 前序遍历(Preorder Traversal 亦称先序遍历)——访问根结点的操作发生在遍历其左右子树之前。
  2. 中序遍历(Inorder Traversal)——访问根结点的操作发生在遍历其左右子树之中（间）。
  3. 后序遍历(Postorder Traversal)——访问根结点的操作发生在遍历其左右子树之后。

整体代码：

typedef char BTDataType;
typedef struct BinaryTreeNode
{
	struct BinaryTreeNode* left;
	struct BinaryTreeNode* right;
	BTDataType data;
}BTNode;

BTNode* BuyNode(BTDataType x)
{
	BTNode* node = (BTNode*)malloc(sizeof(BTNode)); //创建了一个指针变量node
	if (node == NULL)
	{
		printf("malloc fail\n");
		exit(-1);
	}

	node->data = x;
	node->left = node->right = NULL;
	return node;
}

BTNode* CreatBinaryTree()
{
	BTNode* nodeA = BuyNode('A');
	BTNode* nodeB = BuyNode('B');
	BTNode* nodeC = BuyNode('C');
	BTNode* nodeD = BuyNode('D');
	BTNode* nodeE = BuyNode('E');
	BTNode* nodeF = BuyNode('F');

	nodeA->left = nodeB;
	nodeA->right = nodeC;
	nodeB->left = nodeD;
	nodeC->left = nodeE;
	nodeC->right = nodeF;

	return nodeA;
}

// 二叉树前序遍历 
void PreOrder(BTNode* root)
{
	if (root == NULL){
		printf("NULL ");
		return;
	}

	printf("%c ", root->data);  //根
	PreOrder(root->left);       //左子树
	PreOrder(root->right);      //右子树
}

// 二叉树中序遍历
void InOrder(BTNode* root)
{
	if (root == NULL){
		printf("NULL ");
		return;
	}

	InOrder(root->left);
	printf("%C ", root->data);
	InOrder(root->right);
}

int main()
{
	BTNode* root = CreatBinaryTree();
	PreOrder(root);
	printf("\n");
	InOrder(root);
	printf("\n");
}

0.1 前序遍历

代码部分

// 二叉树前序遍历 
void PreOrder(BTNode* root)
{
	if (root == NULL){
		printf("NULL ");
		return;  //return是回到调用我的地方
	}

	printf("%c ", root->data);  //根
	PreOrder(root->left);       //左子树
	PreOrder(root->right);      //右子树
}

流程图：
在这里插入图片描述

0.2 中序

代码部分：

void InOrder(BTNode* root)
{
	if (root == NULL){
		printf("NULL ");
		return;
	}

	InOrder(root->left);       //左子树
	printf("%C ", root->data); //根
	InOrder(root->right);      //右子树
}

流程图：
在这里插入图片描述

0.3 后序

作用：搜索查找一个数，最多查找高度次O(N)
概念：（二叉排序树）或者是一棵空树
在这里插入图片描述
int a[] ={5,3,4,1,7,8,2,6,0,9}
性质如下：

  1. 若左子树不为空，则左子树的所有节点 < 根节点的值
  2. 若右子树不为空，则右子树所有节点 > 根节点的值
  3. 左右子树也分别为二叉搜索树
    整体代码：
    BinarySerchTree.h
#pragma once

template<class K> //创建函数模板。k可以是任何类型
struct BSTreeNode
{
	BSTreeNode<K>* _left;
	BSTreeNode<K>* _right;
	K _key;

	BSTreeNode(const K& key)
		:_left(nullptr)
		, _right(nullptr)
		, _key(key)
	{}
};

template<class K>
struct BSTree
{
	typedef BSTreeNode<K>  Node; //将BSTreeNode<K>重命名为Node
public:
	BSTree()
		:_root(nullptr)
	{}

	bool Insert(const K& key)
	{
		if (_root == nullptr) //空树
		{
			_root = new Node(key); //new int(10)动态申请一个int类型的空间并初始化为10
			return true;           //在申请自定义类型的空间时，new会调用构造函数
		}
		Node* parent = nullptr;
		Node* cur = _root;

		while (cur)
		{
			if (cur->_key < key)  //比你大，往右走
			{
				parent = cur;
				cur = cur->_right;
			}
			else if (cur->_key > key)
			{
				parent = cur;
				cur = cur->_left;
			}
			else //相等则说明，值已经存在
			{
				return false;
			}
		}

		cur = new Node(key);
		//链接在左边还是右边，再进行一次判断
		if (parent->_key < key)
		{
			parent->_right = cur;
		}
		else
		{
			parent->_left = cur;
		}

		return true;
	}
	//**********解决方法*********
	void Inorder()
	{
		_Inorder(_root);
	}
	void _Inorder(Node* root) //中序
	{
		if (root == nullptr) //空树直接返回
		{
			return;
		}

		_Inorder(root->_left);  //先走左，再走根，后走右
		cout << root->_key << " ";
		_Inorder(root->_right);
	}
	//***************************
	bool Find(const K& key)
	{
		Node* cur = _root;
		while (cur)
		{
			if (cur->_key < key)
			{
				cur = cur->_right;
			}
			else if (cur->_key > key)
			{
				cur = cur->_left;
			}
			else
			{
				return true;
			}
		}
		return false;
	}
private:
	Node* _root;


};

void TestBSTree()
{
	BSTree<int> t;
	int a[] = { 5, 3, 4, 1, 7, 8, 2, 6, 0, 9 };
	for (auto e : a)
	{
		t.Insert(e);
	}
	//t._Inorder();//无法调用，调用需要根，但根私有，拿不到
	//解决方案，写一个子函数
	t.Inorder();
}

main.c

#include <iostream>
#include "BinarySerchTree.h"
using namespace std;
int main()
{
	TestBSTree();
	return 0;
}

1.0 插入

默认情况下不允许冗余，插入5（5本身已经存在，）故插入会返回FALSE。

  1. 空树 直接插入
  2. 非空树

在这里插入图片描述

bool Insert(const K& key)
	{
		if (_root == nullptr) //空树
		{
			_root = new Node(key);
			return true;
		}
		Node* parent = nullptr;
		Node* cur = _root;

		while (cur)
		{
			if (cur->_key < key)  //比你大，往右走
			{
				parent = cur;
				cur = cur->_right;
			}
			else if (cur->_key > key)
			{
				parent = cur;
				cur = cur->_left;
			}
			else //相等则说明，值已经存在
			{
				return false;
			}
		}

		cur = new Node(key);
		//链接在左边还是右边，再进行一次判断
		if (parent->_key < key)
		{
			parent->_right = cur;
		}
		else
		{
			parent->_left = cur;
		}

		return true;
	}

2.0 走中序 (排序+去重)

//**********解决方法*********
	void Inorder()
	{
		_Inorder(_root);
	}
	void _Inorder(Node* root) //中序
	{
		if (root == nullptr) //空树直接返回
		{
			return;
		}

		_Inorder(root->_left);  //先走左，再走根，后走右
		cout << root->_key << " ";
		_Inorder(root->_right);
	}

3.0 查找

bool Find(const K& key)
	{
		Node* cur = _root;
		while (cur)
		{
			if (cur->_key < key)
			{
				cur = cur->_right;
			}
			else if (cur->_key > key)
			{
				cur = cur->_left;
			}
			else
			{
				return true;
			}
		}
		return false;
	}

4.0 删除

1.没有孩子的节点
2.只有一个孩子的节点 （1.2合成一个情况，直接删除）
3.有两个孩子的节点 （替换法删除，左子树的最大的节点或者右子树的最小节点，进行替换 ）

第一种情况：直接删除：
删除8：左为空（被删除），让父亲的右指向我的右
删除1：左为空，让父亲的左指向我的右
在这里插入图片描述

在这里插入图片描述

讨论父亲左为空的情况，1）父亲的右指向我的右，2）父亲的左指向我的

左为空，如果父亲被干掉，则让右树为新的根。同理，右也相同。
if (parent == nullptr)
{
_root = cur->_right;
}
在这里插入图片描述

父亲是空情况（只有一个节点）左为空，则右孩子的根则为新的根，
右为空，则左孩子的根为新的根

             if (cur->_left == nullptr)//如果我的左为空
				{
					if (parent == nullptr)
					{
						_root = cur->_right;
					}
					else
					{
						if (parent->_left == cur)         //如果我是父亲的左，父亲的左指向我的右
							parent->_left = cur->_right;
						else
							parent->_right = cur->_right; //否则父亲的右指向我的右
					}

					delete cur;
				}
				else if (cur->_right == nullptr) //如果我的右为空
				{
					if (parent == nullptr) //要对父亲为空进行判断
					{
						_root = cur->_left;
					}
					else
					{
						if (parent->_left == cur)
							parent->_left = cur->_left;
						else
							parent->_right = cur->_left;
					}

					delete cur;
				}

左右都不为空

                else                             //左右都不为空
				{
					Node* minParent = cur;       //找右树的最左节点
					Node* min = cur->_right;
					while (min->_left)
					{
						minParent = min;        //min往下走，min给parent
						min = min->_left;
					}

					cur->_key = min->_key;             //把min的值覆盖过去，然后要把min删除（需要找min的父亲）

					if (minParent->_left == min)       //minParent有左树
						minParent->_left = min->_right; //替换法删除（minParent的左指向他的右）这样就把min删除了
					else
						minParent->_right = min->_right; //minParent的右指向min的右

					delete min;               //删除min
				}

假设删除5 替换法，找右树的最左节点
用6去覆盖5，然后在删除7的左树6
删除的话，找右树的最左节点。
在这里插入图片描述

假设删除7。第二种情况：右子树的根即为最左节点（无最左节点）
在这里插入图片描述

                else                             //左右都不为空
				{
					Node* minParent = cur;      
					Node* min = cur->_right;    //找右树的最左节点
					while (min->_left)          
					{
						minParent = min;        //min往下走，min给parent
						min = min->_left;       //找到了右树的最左节点
					}

					cur->_key = min->_key;             //把min的值覆盖过去，然后要把min删除（需要找min的父亲）

					//下面为删除min
					if (minParent->_left == min)       //minParent有左树
						minParent->_left = min->_right; //替换法删除（minParent的左指向他的右）这样就把min删除了
					else
						minParent->_right = min->_right; //minParent的右指向min的右

					delete min;               //删除min
				}

5.0 递归查找

Node* _FindR(Node* root, const K& key)
	{
		if (root == nullptr)
		{
			return nullptr;
		}

		if (root->_key < key)  
		{
			return _FindR(root->_right, key);
		}
		else if (root->_key > key)
		{
			return _FindR(root->_left, key);
		}
		else
		{
			return root;
		}
	}

6.0 插入

bool _InsertR(Node*& root, const K& key)   //注意此处的Node*& root，引用
	{
		if (root == nullptr)
		{
			root = new Node(key);         //*********
			return true;
		}

		if (root->_key < key)                    //大，则递归去右树去查找
			return _InsertR(root->_right, key);
		else if (root->_key > key)               
			return _InsertR(root->_left, key);
		else                                    //相等，不允许插入
			return false;
	}

在这里插入图片描述

3往下递归，root的值是空，但同时是3的节点的右指针的别名

7.0 搜索树的应用

  1. 搜索 key搜索模型 key/value搜索模型
  2. 排序+去重

搜索-> 在不在

白掰虾
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
二叉查找树
shibai906的博客
11-13 512
二叉查找树有这几个规则 1、若左子树不为空，那么左子树所有节点的值小于均小于他的根节点的值。 2、若右子树不为空，那么右子树的所有节点的值大于根节点的值。 3、左右子树也分别为二叉树排序树。 4、没有键值相等的节点。 注意：每个值都不能一样，如果有一样的，我们不需做考虑。 添加挺简单的，看下面的代码。 首先做准备 // 主要用来保存节点private Node<T> r...
数据结构-二叉搜索树 详解
HeartFireY的博客
06-06 2309
一、二叉搜索树 简介 二叉搜索树(BST, Binary Search Tree)是一种基于二叉树的树形数据结构，定义(满足的性质)如下 空树是二叉搜索树 若二叉搜索树的左子树不为空，则其左子树上所有点的权值均小于其根节点的权值； 若二叉搜索树的右子树不为空，则其右子树上所有点的权值均大于其根节点的权值； 二叉搜索树的左右子树均为二叉搜索树 不难发现，二叉搜索树是采用递归进行定
二叉排序树（二叉查找树、二叉搜索树）（图解+完整代码）
weixin_54186646的博客
04-25 7万+
图解二叉排序树（二叉查找树、二叉搜索树）的插入操作、查找操作、删除操作以及完整的代码实现
C#二叉搜索树插入算法实例分析
01-21
本文实例讲述了C#二叉搜索树插入算法。分享给大家供大家参考。具体实现方法如下： public class BinaryTreeNode { public BinaryTreeNode Left { get; set; } public BinaryTreeNode Right { get; set; } public...
Java创建二叉搜索树,实现搜索,插入,删除的操作实例
08-28
下面小编就为大家分享一篇Java创建二叉搜索树,实现搜索,插入,删除的操作实例，具有很好的参考价值，希望对大家有所帮助
二叉搜索树实例练习
09-05
一棵二叉查找树是按二叉树结构来组织的。这样的树可以用链表结构表示，其中每一个结点都是一个对象
树-98. 验证二叉搜索树-PYTHON
01-20
递归 # Definition for a binary tree node. # class TreeNode(object): # def __init__(self, x): # self.val = x # self.left = None # self.right = None class Solution(object): def isValidBST(self, root): ...
java实现 二叉搜索树功能
08-27
主要介绍了java实现 二叉搜索树功能,代码简单易懂，非常不错，具有一定的参考借鉴价值，需要的朋友可以参考下
Python实现二叉搜索树
12-24
二叉搜索树 我们已经知道了在一个集合中获取键值对的两种不同的方法。回忆一下这些集合是如何实现ADT（抽象数据类型）MAP的。我们讨论两种ADT MAP的实现方式，基于列表的二分查找和哈希表。在这一节中，我们将要...
C#创建二叉搜索树的方法
09-03
主要介绍了C#创建二叉搜索树的方法,涉及C#二叉搜索树的实现技巧,非常具有实用价值,需要的朋友可以参考下
Python实现二叉搜索树BST的方法示例
01-20
二叉排序树（BST）又称二叉查找树、二叉搜索树 二叉排序树(Binary Sort Tree)又称二叉查找树。它或者是一棵空树；或者是具有下列性质的二叉树： 1.若左子树不空，则左子树上所有结点的值均小于根结点的值； 2.若...
二叉搜索树_二叉搜索树_源码
10-04
一个简单的二叉搜索树的例程，使用不带自平衡的方法实现最简单的二叉搜索树。
陈越、何钦铭-数据结构作业12：是否同一棵二叉搜索树
04-20
给定一个插入序列就可以唯一确定一棵二叉搜索树。然而，一棵给定的二叉搜索树却可以由多种不同的插入序列得到。例如分别按照序列{2, 1, 3}和{2, 3, 1}插入初始为空的二叉搜索树，都得到一样的结果。于是对于输入的...
Java二叉搜索树基础原理与实现方法详解
08-19
主要介绍了Java二叉搜索树基础原理与实现方法,结合图文与实例形式详细分析了Java二叉搜索树的基本概念、原理、实现方法与操作注意事项,需要的朋友可以参考下
二叉搜索树的插入与删除(详细解析)
01-01
题目：创建一个类，类中的数据成员时一棵二叉搜索树，对外提供的接口有添加结点和删除结点这两种方法。用户不关注二叉树的情况。要求我们给出这个类的结构以及实现类中的方法。 思路添加结点：添加结点其实很容易，...
最优二叉搜索树
07-04
最优二叉搜索树详细的分析了最优二叉树的伪代码以及给出了算法设计，还包含一个例子用来更好的理解最优二叉搜索树的流程

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值