C++实现二叉搜索树BST,并实现多种方式遍历

最新推荐文章于 2022-05-14 21:40:09 发布
最新推荐文章于 2022-05-14 21:40:09 发布
阅读量823 收藏 1
点赞数
分类专栏： C语言 文章标签： c++ 开发语言 后端
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/AppWhite_Star/article/details/122134433
版权 
#pragma once
/*
	二叉查找树的操作：
    -插入
    -遍历
    -删除
    -修改
    -查询
    -清空
*/
class CBST
{
private:
    // 定义一个节点类型
    typedef struct tagNode {
        tagNode():m_pLeft(nullptr),m_pRight(nullptr),m_pParent(nullptr){};
        tagNode(int nVal, tagNode* pParent=nullptr, tagNode* pLeft=nullptr, tagNode* pRight=nullptr) :m_nVal(nVal),m_pLeft(pLeft), m_pRight(pRight), m_pParent(pParent){};
        int m_nVal; // 数据
        tagNode *m_pParent; // 父节点
        tagNode *m_pLeft; // 左孩子
        tagNode *m_pRight; // 右孩子
    }NODE,*PNODE;
public:
    CBST();
    CBST(const CBST& obj);
    CBST& operator=(const CBST& obj);
    ~CBST();
    // 插入
    bool Insert(int nVal);
    // 删除
    bool Delete(int nVal);
    // 修改
    bool Update(int nSrcVal,int nDstVal);
    // 查询
    bool Find(int nVal);
    // 清空
    void Clear();

    // 层序遍历 一层一层输出
    void LevelTraversal();
    // 递归前序遍历 根左右
    void MLR();
    // 递归中序遍历 左根右
    void LMR();
    // 递归后序遍历 左右根
    void LRM();

    // 中序使用循环
    void LMP_LOOP();
    // 前序使用循环
    void MLR_LOOP();
    // 后序使用循环
    void LRM_LOOP();
private:
    // 递归中序遍历 左根右
    void LMR(PNODE pNode);
    // 递归前序遍历 根左右
    void MLR(PNODE pNode);
    // 递归后序遍历 左右根
    void LRM(PNODE pNode);

    // 中序使用循环
    void LMP_LOOP(PNODE pNode);
    // 前序使用循环
    void MLR_LOOP(PNODE pNode);
    // 后序使用循环
    void LRM_LOOP(PNODE pNode);
private:
    // 查询并返回指针
    PNODE FindNode(int nVal);
    // 删除叶子节点
    void DeleteLeaf(PNODE pLeaf);
    // 删除单分节点
    void DeleteSingle(PNODE pSingle);
private:
    PNODE m_pRoot; // 根节点
};



#include "CBST.h"
#include <deque>
#include <stack>
#include <iostream>

using namespace std;

CBST::CBST()
{
	// 初始化根节点
	this->m_pRoot = nullptr; 
}

CBST::CBST(const CBST& obj)
{
	this->m_pRoot = nullptr;
	*this = obj;
}

CBST& CBST::operator=(const CBST& obj)
{
	if (this == &obj) return *this;
	// 清除自己
	Clear();
	// 拷贝obj
	/*
		通过队列完成层序遍历
	*/
	deque<CBST::PNODE> trees;
	/*
		根节点入队
		然后出队 打印，再依次把左右两边入队
		循环此操作
	*/
	trees.push_back(obj.m_pRoot);
	while (!trees.empty()) {
		// 获取队首
		auto temp = trees.front();
		Insert(temp->m_nVal); 
		// 弹出队首
		trees.pop_front();
		// 把左右两边入队
		if (temp->m_pLeft != nullptr) {
			trees.push_back(temp->m_pLeft);
		}
		if (temp->m_pRight != nullptr) {
			trees.push_back(temp->m_pRight);
		}
	}
	return *this;
}

CBST::~CBST()
{
	// 释放内存
	Clear();
}

/*
	插入元素
*/
bool CBST::Insert(int nVal)
{
	// 创建节点
	PNODE pNewNode = new NODE(nVal); // pNewNode 保存new出来的这个地址
	// 如果分配失败的话
	if(pNewNode == nullptr){
		return false;
	}
	// 如果分配成功的话
	if(this->m_pRoot == nullptr){
		// 如果现在是一颗空树
		this->m_pRoot = pNewNode; // 相当于和pNewNode一样保存第一个new出来的节点地址
		return true;
	}
	// 如果不是空树 开始遍历 直至某个节点的叶子节点为null就插入
	PNODE pNode = this->m_pRoot; // 用一个临时节点 表示根节点 不修改根节点的数据
	while(true){
		// 如果当前节点的值 大于我们要插入的值 左边
		if(nVal < pNode->m_nVal){
			if(pNode->m_pLeft != nullptr){
				// 如果还有左孩子继续判断
				pNode = pNode->m_pLeft;
			}else{
				// 当前节点插入到左边
				pNode->m_pLeft = pNewNode;
				// 保存父节点
				pNewNode->m_pParent = pNode;
				return true;
			}
		}else if(nVal > pNode->m_nVal){
			// 如果当前节点的值 小于我们要插入的值 右边
			if (pNode->m_pRight != nullptr) {
				// 如果还有右孩子 继续判断
				pNode = pNode->m_pRight;
			}else {
				// 当前节点插入到右边
				pNode->m_pRight = pNewNode;
				// 保存父节点
				pNewNode->m_pParent = pNode;
				return true;
			}
		}else{
			// 暂时不考虑相等
			return false;
		}
	}
	return true;
}

// 删除叶子节点
void CBST::DeleteLeaf(PNODE pLeaf)
{
	/*
		如果被删除的叶子节点是根节点
		因为只有根节点的话 根节点就是叶子节点
	*/
	// 获取父节点
	auto pParendNode = pLeaf->m_pParent;
	if (pParendNode == nullptr) {
		delete pParendNode; // 直接删除根节点
		pParendNode = nullptr;
		this->m_pRoot = nullptr; // 把根节点指针置为null
		return;
	}

	/*
		如果要删除的不是根节点
		判断这个叶子节点是在父亲的左边还是右边
		如果是在父亲的左边 那么就把父亲的左边置为null
		如果是在父亲的右边 那么就把父亲的右边置为null
	*/
	if(pParendNode->m_nVal > pLeaf->m_nVal){
		// 如果是左孩子 左孩子置空
		pParendNode->m_pLeft = nullptr;
	}else if(pParendNode->m_nVal < pLeaf->m_nVal){
		// 如果是右孩子 右孩子置空
		pParendNode->m_pRight = nullptr;
	}
	// 最后释放内存
	delete pLeaf; 
	pLeaf = nullptr;
}

/*
	删除单分支节点
*/
void CBST::DeleteSingle(PNODE pSingle)
{
	/*
		   p     p	        p       p	    
		  /  	   \       / 	     \    
		 S1    		 S1   S1 	   	  S1 
		/ 			/ 		\	   	   \ 	
	   C1 		   C1 		 C1 	    C1 	

					 ||
					 ||
					 ||
				\	 ||    /
				  \     /
				     \/

			   p     p	        p       p	    
			  /  	   \       / 	     \    
			 C1    		 C1   C1 	   	  C1 

		所以其实就是把单分支的孩子向上提就好了

	所以找到当前这个分支节点的父亲
	让当前这个分支节点的父亲直接指向这个分支的孩子就ok了
	*/
	
	/*
		获取要删除的这个单分支节点的父节点
	*/
	auto pParentNode = pSingle->m_pParent;
	/*
		判断这个节点是有左孩子还是右孩子 
		pLeftOrRightNode 为要删除的这个单分支节点的左孩子或者右孩子
	*/
	auto pLeftOrRightNode = pSingle->m_pLeft == nullptr ? pSingle->m_pRight : pSingle->m_pLeft;
	
	// 如果父节点为空 代表删除的是根节点
	if (pParentNode == nullptr){
		// 根节点 切换 为它的左右节点
		this->m_pRoot = pLeftOrRightNode;
		pLeftOrRightNode->m_pParent = nullptr; // 他作为新的根节点 没有父亲
		delete pSingle; // 释放根节点内存
		pSingle = nullptr;
		return; 
	}

	// 修改拿到的这个节点的父节点 为要删除的节点的父节点
	pLeftOrRightNode->m_pParent = pParentNode; // 就等于跳过中间那一层
	
	/*
		跳过中间那一层 开始提节点 到要删除节点的父亲的左右边 代替原来要删除的节点的位置
	*/
	if(pLeftOrRightNode->m_nVal < pParentNode->m_nVal){
		// 提上来的节点放左边
		pParentNode->m_pLeft = pLeftOrRightNode;
	}else if (pLeftOrRightNode->m_nVal > pParentNode->m_nVal){
		// 提上来的节点放右边
		pParentNode->m_pRight = pLeftOrRightNode;
	}
	// 释放内存
	delete pSingle;
	pSingle = nullptr;
}

/*
	根据值删除节点
*/
bool CBST::Delete(int nVal)
{
	/*
		如果要删除的是叶子节点 直接删除
		如果要删除的不是叶子节点：
		单分支：
			子节点向上提
		双分支：
			左子树里面最大最接近要删除的值的数的节点【只可能是叶子或者有左子树】
			右子树里面最小最接近要删除的值的数的节点【只可能是叶子或者有右子树】
			【选其中一种，无论选择哪一种
			最后都会变成叶子或者单分支类型
			然后再执行上面的操作即可】

		按照上面的思路 我们往下找下去只能是叶子或者单分支
	*/
	// 查询节点
	auto pNodeToDel = FindNode(nVal);
	if(pNodeToDel == nullptr){
		// 如果没找到这个节点 
		return false;
	}
	// 1.叶子
	// 如果找到的这个节点是一个叶子节点
	if(pNodeToDel->m_pLeft == nullptr && pNodeToDel->m_pRight == nullptr){
		DeleteLeaf(pNodeToDel);
		return true;
	}
	// 如果代码能走到这就代表它不是叶子 那么我们判断 如果有一边为空 就是单分支了
	// 2.单分支
	if(pNodeToDel->m_pLeft == nullptr || pNodeToDel->m_pRight == nullptr){
		DeleteSingle(pNodeToDel);
		return true;
	}
	// 这里就不用判断了 能走到这里一定就是双分支了 既不是叶子 也不是单分支
	// 3.双分支
	/*
		这里选用查找要删除的节点的左子树中的最大值来进行 值的替换和删除
	*/
	auto pMaxInLeft = pNodeToDel->m_pLeft; 
	// 当这个循环结束 我们就找到了 被删除节点中的左子树的最大值了
	while(pMaxInLeft->m_pRight != nullptr){
		pMaxInLeft = pMaxInLeft->m_pRight;
	}
	// 找到最大值了 和 原本的节点的值进行替换
	int tempVal = pNodeToDel->m_nVal;
	pNodeToDel->m_nVal = pMaxInLeft->m_nVal;
	pMaxInLeft->m_nVal = tempVal;
	// 交换值完毕 接着就是把 pMaxInLeft 给删掉
	// 它可能是叶子节点 也 可能是单分支
	// 如果他是叶子节点
	if (pMaxInLeft->m_pLeft == nullptr && pMaxInLeft->m_pRight == nullptr) {
		DeleteLeaf(pMaxInLeft);
		return true;
	}
	// 如果它是单分支
	else{
		DeleteSingle(pMaxInLeft);
		return true;
	}
}

/*
	根据原本的值找到节点
	然后进行更新
*/
bool CBST::Update(int nSrcVal, int nDstVal)
{
	/*
		先删除再插入即可
	*/
	if(Find(nSrcVal)){
		Delete(nSrcVal);
		Insert(nDstVal);
	}
	return false;
}

/*
	根据值查找是否有这个节点存在
*/
bool CBST::Find(int nVal)
{
	if (this->m_pRoot == nullptr) {
		// 如果是空树查找失败
		return false;
	}
	// 如果不是空树开始遍历
	PNODE pNode = this->m_pRoot;
	while(true){
		if(nVal < pNode->m_nVal){
			// 如果小于 向左边
			if(pNode->m_pLeft == nullptr){
				// 左边没有了
				return false; // 那就是没有找到
			}else{
				// 如果左边还有 向左边移动
				pNode = pNode->m_pLeft;
			}
		}else if(nVal > pNode->m_nVal){
			// 如果大于 向右边
			if(pNode->m_pRight == nullptr){
				// 右边没有了
				return false; // 那就是没有了
			}else{
				// 如果还有 向右边移动继续找
				pNode = pNode->m_pRight;
			}
		}else{
			// 相等
			return true;
		}
	}
	return false;
}

/*
	根据值查找节点
	如果找到了返回节点对应的指针
*/
CBST::PNODE CBST::FindNode(int nVal)
{
	/*
		根据值查找返回结点
	*/
	// 如果不是空树 从根节点开始
	PNODE pNode = this->m_pRoot;
	while (pNode != nullptr){ 
		// 小于找左边
		if(nVal < pNode->m_nVal){
			pNode = pNode->m_pLeft;
			// 大于找右边
		}else if(nVal > pNode->m_nVal){
			pNode = pNode->m_pRight;
		}else{
			// 相等直接返回
			return pNode;
		}
	}
	// 如果退出循环了那就是找不到
	return nullptr;
}

void CBST::Clear()
{
	while (this->m_pRoot != nullptr){
		Delete(this->m_pRoot->m_nVal);
	}
}

// 层序遍历
void CBST::LevelTraversal()
{
	/*
		通过队列完成层序遍历
	*/
	deque<CBST::PNODE> trees;
	if (this->m_pRoot == nullptr){
		cout << "空树" << endl;
		return;
	}
	/*
		根节点入队
		然后出队 打印，再依次把左右两边入队
		循环此操作
	*/
	trees.push_back(this->m_pRoot);
	while(!trees.empty()){
		// 获取队首
		auto temp = trees.front();
		// 弹出队首
		trees.pop_front();
		cout << temp->m_nVal <<  " ";
		// 把左右两边入队
		if(temp->m_pLeft != nullptr){
			trees.push_back(temp->m_pLeft);
		}
		if (temp->m_pRight != nullptr) {
			trees.push_back(temp->m_pRight);
		}
	}
	cout << endl;
}

// 前序遍历 根左右
void CBST::MLR()
{
	if (this->m_pRoot == nullptr) {
		cout << "空树" << endl;
		return;
	}
	MLR(this->m_pRoot);
}

// 中序遍历 左根右
void CBST::LMR()
{
	if (this->m_pRoot == nullptr) {
		cout << "空树" << endl;
		return;
	}
	LMR(this->m_pRoot);
}

// 后序遍历 左右根
void CBST::LRM()
{
	if (this->m_pRoot == nullptr) {
		cout << "空树" << endl;
		return;
	}
	LRM(this->m_pRoot);
}

// 中序使用循环
void CBST::LMP_LOOP()
{
	if (this->m_pRoot == nullptr) {
		cout << "空树" << endl;
		return;
	}
	LMP_LOOP(this->m_pRoot);
}

// 前序使用循环
void CBST::MLR_LOOP()
{
	if (this->m_pRoot == nullptr) {
		cout << "空树" << endl;
		return;
	}
	MLR_LOOP(this->m_pRoot);
}

// 后序使用循环
void CBST::LRM_LOOP()
{
	if (this->m_pRoot == nullptr) {
		cout << "空树" << endl;
		return;
	}
	LRM_LOOP(this->m_pRoot);
}

// 中序遍历 左根右
void CBST::LMR(PNODE pNode)
{
	// 开始递归
	if(pNode != nullptr){
		LMR(pNode->m_pLeft);
		cout << pNode->m_nVal << " ";
		LMR(pNode->m_pRight);
	}
}

// 前序遍历 根左右
void CBST::MLR(PNODE pNode)
{
	// 开始递归
	if (pNode != nullptr) {
		cout << pNode->m_nVal << " ";
		MLR(pNode->m_pLeft);
		MLR(pNode->m_pRight);
	}
}

// 后序遍历 左右根
void CBST::LRM(PNODE pNode)
{
	// 开始递归
	if (pNode != nullptr) {
		LRM(pNode->m_pLeft);
		LRM(pNode->m_pRight);
		cout << pNode->m_nVal << " ";
	}
}

// 中序使用循环
void CBST::LMP_LOOP(PNODE pNode)
{
	// 换行
	cout << endl;
	// 定义一个栈
	stack<CBST::PNODE> treesStack;
	// 根节点入栈
	treesStack.push(pNode);
	// 当栈不为空的时候
	while (!treesStack.empty()){
		if(pNode->m_pLeft != nullptr){
			// 如果左边不为空入栈
			treesStack.push(pNode->m_pLeft);
			pNode = pNode->m_pLeft;
			continue; // 直接进入下一次循环
		}
		// 如果左边为空 从栈里面取出来
		auto curNode = treesStack.top(); // 获取栈顶元素
		cout << curNode->m_nVal << " "; // 输出栈顶元素
		treesStack.pop(); // 弹出栈顶元素
		// 如果有右孩子 右孩子入栈
		if(curNode->m_pRight != nullptr){
			treesStack.push(curNode->m_pRight);
			pNode = curNode->m_pRight;
			continue;
		}
	}
}

// 前序使用循环
void CBST::MLR_LOOP(PNODE pNode)
{
	// 换行
	cout << endl;
	// 定义一个栈
	stack<CBST::PNODE> treesStack;
	/*
		一路向左输出根，如果根有右孩子 右孩子入栈
		如果输出之后没有右孩子
		右孩子出栈
		接着右孩子作为根 重复上面操作
	*/
	while(true){
		// 当前节点不为空的话
		while(pNode != nullptr){
			// 输出根的值
			cout << pNode->m_nVal << " ";
			// 判断有没有右孩子
			if(pNode->m_pRight != nullptr){
				// 入栈
				treesStack.push(pNode->m_pRight);
			}
			// 往左走
			pNode = pNode->m_pLeft;
		}

		// 如果栈为空了 遍历结束
		if (treesStack.empty()) {
			break;
		}

		// 退出这个循环就是左边为空了 需要从栈里面取出来一个
		// 如果左边为空 从栈里面取出来
		// 同时当前根节点修改为弹出来的这个元素
		pNode = treesStack.top(); // 获取栈顶元素
		treesStack.pop(); // 弹出栈顶元素
	}
}

// 后序使用循环
void CBST::LRM_LOOP(PNODE pNode)
{
	// 换行
	cout << endl;
	// 定义一个栈
	stack<CBST::PNODE> treesStack;
	// 记录最后一次输出的值
	PNODE pLastHandledNode = nullptr;

	while(true){

		// 一路向左入栈
		while(pNode != nullptr){
			treesStack.push(pNode);
			pNode = pNode->m_pLeft;
		}

		// 栈为空
		if(treesStack.empty()){
			break;
		}

		// 这样就左边全部入栈完毕了 访问栈顶
		auto curNode = treesStack.top();

		if(curNode->m_pRight == pLastHandledNode || curNode->m_pRight == nullptr){
			// 如果上一次输出的就是它的右节点 或者它没有右节点 那么它就可以处理了
			cout << curNode->m_nVal << " ";
			treesStack.pop(); // 出栈
			pLastHandledNode = curNode; // 更新上一次输出的节点
		}else{
			// 否则把处理右节点
			pNode = curNode->m_pRight;
		}
		
	}
}


#include <iostream>
#include <Windows.h>
#include "CBST.h"

using namespace std;

int main()
{
	int ary[] = {
		50,
		30,70,
		20,40,60,90,
		10,25,35,45,55,65,80,99,
		42,56,62,67,85,
		69
	};
	CBST BST;
	for(int i = 0; i < sizeof(ary)/sizeof(ary[0]); i++){
		BST.Insert(ary[i]);
	}
	// 接着测试删除 
	//BST.Delete(70);
	//BST.Delete(69);
	//BST.Delete(67);
	//BST.Delete(65);
	//BST.Delete(80);
	//BST.Delete(10);
	//BST.Delete(20);
	//BST.Delete(50);
	//BST.Delete(60);
	
	// 层序遍历
	// BST.LevelTraversal();

	// 中序遍历
	BST.LMR();
	BST.LMP_LOOP();
	// 先序遍历
	cout << endl;
	BST.MLR();
	BST.MLR_LOOP();
	// 后序遍历
	cout << endl;
	BST.LRM();
	BST.LRM_LOOP();

	CBST BST1;
	BST1 = BST;
	BST1.LRM_LOOP();
	system("pause");
	return 0;
}
Star_WPF上位机开发
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
C++实现二叉搜索树的查找(附完整源码)
希望我的博客，能帮上你解决学习中工作中所遇到的问题
02-01 465
二叉搜索树的查找算法: 在二叉搜索树 b 中查找 x 的过程为： 若 b 是空树，则搜索失败，否则： 若 x 等于 b 的根节点的数据域之值，则查找成功；否则： 若 x 小于 b 的根节点的数据域之值，则搜索左子树；否则： 查找右子树 */ // 在根指针 T 所指二叉查找树中递归地查找其关键字等于 key 的数据元素，若查找成功， // 则指针 p 指向該数据元素节点，并返回 TRUE，否则指针指向查找路径上访问的最终 // 一个节点并返回 FALSE，指针 f 指向 T 的双亲，其初始调用值为 NUL
PAT-A-1066 Root of AVL Tree (25 分) 创建平衡二叉查找树 C++题解
爱玲姐姐的博客
08-26 800
1066 Root of AVL Tree (25 分) 题目传送门：1066 Root of AVL Tree (25 分) 一、题目大意 给定一个数列，创建平衡二叉查找树 二、解题思路 这道题就是一个赤裸裸的构建平衡树的问题，然而我之前一直没有写过平衡树的代码，因为对平衡树的旋转不太理解。这次我不想绕过这个知识盲点了，在网上搜了博客学习平衡树的知识。 平衡树（AVL）的旋转操作参考了这篇博客：...
【C++】二叉搜索树（BST）
taoxing
07-11 787
一.基本介绍 特征： 二叉搜索树，也被称为二叉查找树、有序二叉树或者排序二叉树。 ∙\bullet∙ 一般来说输入的第一个数作为根结点，当继续输入数时，小于根结点的放在根结点左边，大于根结点的放在根结点右边。 ∙\bullet∙ 不只是根结点，每个子节点也符合左小右大的规律。 ∙\bullet∙ 如下图所示，输入数据8、3、10、1、6、14、4、7、13，得到下面的二叉搜索树。 下面我们来介绍BST的构成成分： ∙\bullet∙ 首先我们需要实现两个类：一个是BSTNode类（节点类）、一个为
BST树（二叉查找树）C++的实现
qq_41078889的博客
05-28 1726
二叉查找树（Binary Search Tree），也称二叉搜索树、有序二叉树（ordered binary tree），排序二叉树（orted binary tree），是指一棵空树或者具有下列性质的二叉树： 若任意节点的左子树不空，则左子树上所有节点的值均小于它的根节点的值； 若任意节点的右子树不空，则右子树上所有节点的值均大于它的根节点的值； 任意节点的左、右子树也分别为二叉查找树； ......
【数据结构】二叉查找树/二叉搜索树BST（附相关C++代码）
weixin_50941083的博客
05-14 873
本文内容将主要介绍二叉查找树的相关概念，与关于二叉查找树的重要操作，如添加节点、删除节点等。
BST二叉搜索树[c++实现]
m0_51510503的博客
02-27 485
这是从算法第四版上改过来的， 之后还会补充一点，先把这些当上来吧 #include<cstdio> #include<cstdlib> #include<ctime> #include<windows.h> #include<vector> #include<stack> #include<queue> #include<cstring> #include<string> #include<un
二叉查找树（BST）及二叉树的遍历
热门推荐
青萍之末的博客
05-18 1万+
一、二叉查找树（BST） 1、二叉查找树的特征   二叉查找树（BST）也称为二叉搜索树或二叉排序树。二叉查找树的节点包含键值key。二叉查找树或者是一棵空树，否则要求： 1. 若它的左子树不为空，那么左子树上所有节点的key都小于根节点的key。 2. 若它的右子树不为空，那么右子树上所有节点的key都大于根节点的key。 3. 它的左右子树也分别为二叉排序树。 2、二叉查...
AVL平衡树(二叉搜索树 c++实现)
WinForBest
10-30 599
AVL树简介 AVL树的名字来源于它的发明作者G.M. Adelson-Velsky 和 E.M. Landis。AVL树是最先发明的自平衡二叉查找树（Self-Balancing Binary Search Tree,简称平衡二叉树）。 一棵AVL树有如下必要条件： 条件一：它必须是二叉查找树。 条件二：每个节点的左子树和右子树的高度差至多为1。
C++类模板实现二叉搜索树(BST)与三种遍历
Rice__的博客
06-13 554
实现了基本的插入与查找(递归与迭代)功能 实现二叉树的三种遍历方式(迭代实现) 头文件如下 #pragma once #include<stack> #include<queue> template<class T> class BinarySearchTree; //树结点 template<class T> class TreeNode { public: TreeNode(const T& d) :data(d), left(0),.
BST的C++实现
吉大秦少游
10-04 1158
BST首先是二叉树，对应的二叉树定义和常用操作封装在以下头文件"bintree.h" // 二叉树的头文件 #ifndef bintree_h #define bintree_h #include <iostream> using namespace std; template<class Elem> struct BinNode{ Elem data; ...
二叉搜索树详解（C++实现）
沐白白的博客
04-14 1221
二叉搜索树的定义 二叉搜索树，也称有序二叉树,排序二叉树，是指一棵空树或者具有下列性质的二叉树： 若任意节点的左子树不空，则左子树上所有结点的值均小于它的根结点的值； 若任意节点的右子树不空，则右子树上所有结点的值均大于它的根结点的值； 任意节点的左、右子树也分别为二叉查找树。 没有键值相等的节点。 二叉搜索数中序遍历为有序数组 一、查找二叉搜索树中的某个元素 在二叉搜索树b中查找x的过程为： 若b是空树，则搜索失败，否则： 若x等于b的根节点的数据域之值，则查找成功；否则： 若x小于b的根节点的
bst实现C++类模版
hj1107402232的专栏
08-21 967
用类模版实现BST搜索二叉树，简单但不容易，其中的remove代码写的很好，讲四种情况集合在一起，代码精简，但不易看懂 头文件 /*#include//new const inline 构造函数 #include #include #ifndef BINARY_SEACH_TREE #define BINARY_SEACH_TREE template class BST { public:
二叉搜索树BST遍历
woaidanyang的博客
04-25 178
Python 二叉搜索树（BST）前序遍历： def dfs(root): if not root: return 执行操作 dfs(root.left) dfs(root.right) Python 二叉搜索树（BST）中序遍历： def dfs(root): if not root: return dfs(root.left) 执行操作 dfs(root.right) Python 二叉搜索树（BST）
二叉搜索树(BST)的c++实现，包括包括前序遍历，中序遍历，后序遍历，深度优先遍历，广度优先遍历，超级详细保姆级教程。
qq_42759932的博客
07-05 547
这里写自定义目录标题排序二叉树的c++实现新的改变功能快捷键合理的创建标题，有助于目录的生成如何改变文本的样式插入链接与图片如何插入一段漂亮的代码片生成一个适合你的列表创建一个表格设定内容居中、居左、居右SmartyPants创建一个自定义列表如何创建一个注脚注释也是必不可少的KaTeX数学公式新的甘特图功能，丰富你的文章UML 图表FLowchart流程图导出与导入导出导入 排序二叉树的c++实现 因为是一个较小的demo，并且本着方便初学者学习的原则，采用定义和实现在同一代码块，方便阅读。 首先定义一个
leetcode_653. 两数之和 IV - 输入 BST（C++，中序遍历+二分查找）
qq_45698847的博客
05-04 158
题目 原题链接 给定一个二叉搜索树和一个目标结果，如果 BST 中存在两个元素且它们的和等于给定的目标结果，则返回 true。 案例 1: 输入: 5 / \ 3 6 / \ \ 2 4 7 Target = 9 输出: True 案例 2: 输入: 5 / \ 3 6 / \ \ 2 4 7 Target = 2...
C++ BST的实现中， 内存分配的情况
a130737的专栏
07-19 1123
关于BST的实现代码， 参见上一个文章， 这里只是贴出代码： // Binary Search Tree - Implemenation in C++ // Simple program to create a BST of integers and search an element in it #include using namespace std; //Definition of
BST中序遍历（Iterative）
ToBeTrue
03-19 4283
首先来看下 recursive 的版本： void inorder(TreeNode* node) { if (node != NULL) { inorder(node->left); //左子树 print(node->val); //当前节点 inorder(node->right); //右子树
二叉搜索树（BST-Tree）(C++全)
weixin_48560325的博客
04-28 4830
目录 二叉搜索树基本概念 1，什么是根节点 2、什么是二叉搜索树 3、二叉搜索树结构 4、二叉搜索树的性质 5、复杂度 算法实现 1、创建一个二叉搜索树节点 2、打印二叉搜索树 3、二叉搜索树的插入 4、其他操作 （1）查找二叉搜索树的最大值 （2）查找二叉搜索树的最小值 （3）查找某一节点的前驱 （4）查找某一节点的后继 5、删除二叉搜索树的某一节点 步骤： 代码： 性能分析 二叉搜索树基本概念 1，什么是根节点 根结点（root）是树的一个组成部分，也
C++详解 二叉树的三种遍历方式
weixin_43335392的博客
03-28 4816
上一篇文章，讲了二叉树的创建——C++实现 链表存储二叉树 接下来讲解二叉树的三种遍历方式：先序(前序)遍历、中序遍历、后序遍历，三种方式都是DFS(Depth First Search)深度优先搜索，核心思想都是函数的递归(栈)，如果你能理解上面这篇文章中创建二叉树的具体过程，那么遍历就轻而易举 1.先序遍历 Former_Order_Traversel(BinTree_Node* p) { ...
二叉搜索树BST的C++实现
liuchenjane的博客
11-05 6382
BST 包含的功能：插入，删除，查找，查找某一结点的后续和前驱，中序遍历和前序遍历 这里，用于实验的二叉树: //二叉搜索树BST #include #include using namespace std; class TreeNode{ public: int key; TreeNode* left; TreeNode* right; TreeNode* p;//
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值