二分查找树(BST)

最新推荐文章于 2024-07-31 14:15:59 发布
最新推荐文章于 2024-07-31 14:15:59 发布
阅读量557 收藏
点赞数
分类专栏： C/C++ 文章标签： 数据结构 算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/yqq1997/article/details/116783531
版权

BinarySerachTree

#pragma once

#include <iostream>
#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include <string>
#include <algorithm>
#include <vector>
#include <list>
#include <map>


#include <boost/format.hpp>


using namespace std;

template <typename T>
struct BinarySearchTree
{
protected:
	template <typename NodeDataType>  //必须声明模板
	struct TreeNode
	{
		NodeDataType	data;
		TreeNode		*pRight;
		TreeNode		*pLeft;
	};

protected:
	TreeNode<T>		*pRoot;
	size_t			nSize;




public:
	BinarySearchTree()
	{
		pRoot = nullptr;
		nSize = 0;
	}

	virtual ~BinarySearchTree()
	{
		//后续遍历(先释放子节点, 最后),释放空间
		if (nullptr != pRoot)
		{
			Destroy();
		}

	}

public:
	//插入
	void Insert(const T&  value)
	{
		_Insert(pRoot, value);
	}


	//删除
	void Delete(const T& value)
	{		
		_Remove(pRoot, value); 
	}

	//查找 
	bool Find(const T& value)
	{
		return   (nullptr == _Find(pRoot, value)) ? false : true;
	}

	//前序遍历
	std::string Preorder()
	{
		std::string strOrder;
		_Preorder(pRoot, strOrder);
		return strOrder;
	}

	//中序遍历
	std::string  Inorder()
	{
		std::string strOrder;
		_Inorder(pRoot, strOrder);
		return strOrder;
	}

	//后序遍历
	std::string  Postorder()
	{
		std::string strOrder;
		_Postorder(pRoot, strOrder);
		return strOrder;
	}


	//销毁
	void Destroy()
	{
		_Destroy(pRoot);
		pRoot = nullptr;
	}


protected:


	void _Destroy(TreeNode<T> *pNode)
	{
		if (nullptr == pNode)
			return;

		_Destroy(pNode->pLeft);
		_Destroy(pNode->pRight);

		delete pNode;
		pNode = nullptr;
	}



	//这里是指针的引用
	//如果用的是指针, 再改变左右子树时, 需要解引用拷贝
	void _Remove(TreeNode<T> * &pNode, const T& value)
	{
		if (nullptr == pNode) 
		{
			return ;
		}
		else if (pNode->data < value) 
		{
			 _Remove(pNode->pRight, value);
		}
		else if (pNode->data > value)  
		{
			_Remove(pNode->pLeft, value);
		}
		else // 找到了
		{
			//如果有左右子树
			if (nullptr != pNode->pLeft && nullptr != pNode->pRight)
			{
				//找到右子树中最小的节点
				TreeNode<T> *pTmp = pNode->pRight;
				for (; nullptr != pTmp->pLeft; pTmp = pTmp->pLeft) {};
				
				pNode->data = pTmp->data;
				_Remove(pNode->pRight,  pTmp->data);
			}
			else if (nullptr == pNode->pLeft)
			{
				TreeNode<T> *pTmp = pNode;
				pNode = pNode->pRight;
				//*pNode = *(pNode->pRight); //如果函数参数是  指针类型, 而不是指针引用类型, 则需要进行拷贝

				delete pTmp;
				return;
			}
			else if (nullptr == pNode->pRight)
			{
				TreeNode<T> *pTmp = pNode;
				pNode = pNode->pLeft;
				*pNode = *(pNode->pLeft);
				delete pTmp;
				return ;
			}

		}
	}



	TreeNode<T>* _Find(TreeNode<T> *pNode, const T& value)
	{
		if (nullptr == pNode)
			return nullptr;

		if (value == pNode->data)
			return pNode;
		else if (value > pNode->data)
			return _Find(pNode->pRight, value);
		else
			return _Find(pNode->pLeft, value);
	}

	void _Insert(TreeNode<T> * &pNode, const T& value)
	{
		//递归终止条件

		//空树
		if (nullptr == pNode)
		{
			pNode = new TreeNode<T>();
			pNode->data = value;
			pNode->pLeft = nullptr;
			pNode->pRight = nullptr;
			return;
		}

		//开始递归
		if (pNode->data < value)
		{
			_Insert(pNode->pRight, value);
		}
		else
		{
			_Insert(pNode->pLeft, value);
		}
	}


	void _Preorder(const TreeNode<T>* const pNode, std::string &strOrder)
	{
		//递归终止条件
		if (nullptr == pNode)
			return;

		if (!strOrder.empty()) strOrder += " ";
		strOrder += boost::str(boost::format("%d") % pNode->data);

		_Preorder(pNode->pLeft, strOrder);
		_Preorder(pNode->pRight, strOrder);
	}

	void _Inorder(const TreeNode<T>* const pNode, std::string &strOrder)
	{
		//递归终止条件
		if (nullptr == pNode)
			return;

		_Inorder(pNode->pLeft, strOrder);
		
		if (!strOrder.empty()) strOrder += " ";
		strOrder += boost::str(boost::format("%d") % pNode->data);

		_Inorder(pNode->pRight, strOrder);
	}

	void _Postorder(const TreeNode<T>* const pNode, std::string &strOrder)
	{
		//递归终止条件
		if (nullptr == pNode)
			return;

		_Postorder(pNode->pLeft, strOrder);
		_Postorder(pNode->pRight, strOrder);

		if (!strOrder.empty()) strOrder += " ";
		strOrder += boost::str(boost::format("%d") % pNode->data);
	}



public:
	void OutputGraph(const std::string &strDotFilePath, const char *pszDotExePath = nullptr)
	{
		std::ofstream  outFile(strDotFilePath, ios::out);
		if (!outFile.is_open())
		{
			std::cout << "open file " << strDotFilePath << "  failed." << std::endl;
			return;
		}

		outFile << "digraph G {" << endl;

		_OutputGraph(outFile, pRoot);

		outFile << "}" << endl;

		outFile.close();


	}

protected:
	void _OutputGraph(std::ofstream & outFile, const TreeNode<T> * const pNode)
	{
		if (nullptr == pNode)
			return;


		std::string strNodeAttr;
		strNodeAttr = "shape=record,  fillcolor=red, fontcolor=black";

		/*if (_IsRed(pNode)) {
			strNodeAttr = "shape=record,  style=filled, fillcolor=red, fontcolor=black";
		}
		else {
			strNodeAttr = "shape=record, color=black, style=filled, fillcolor=\"#B5B5B5\"";
		}*/

		outFile << pNode->data << "[label = \"<f0> | <f1> " << pNode->data << " | <f2> \"," << strNodeAttr << " ];" << endl;

		if (nullptr != pNode->pLeft)
		{
			_OutputGraph(outFile, pNode->pLeft);
			outFile << pNode->data << ":f0:sw->" << pNode->pLeft->data << ":f1;" << endl;
		}

		if (nullptr != pNode->pRight)
		{
			_OutputGraph(outFile, pNode->pRight);
			outFile << pNode->data << ":f2:se->" << pNode->pRight->data << ":f1;" << endl;
		}
	}


};

测试用例

// BinarySearchTree.cpp : 定义控制台应用程序的入口点。
//

#define BOOST_TEST_MAIN
//#define BOOST_TEST_MODULE example
#include <boost/test/included/unit_test.hpp>
#include <iostream>

#include "stdafx.h"


#include <iostream>
#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include <string>
#include <algorithm>
#include <vector>
#include <list>
#include <map>

#include "BinarySearchTree.hpp"

using namespace std;



BOOST_AUTO_TEST_SUITE(test1)
//
//BOOST_AUTO_TEST_CASE(test_insert) {
//	BinarySearchTree<int> bst;
//	bst.Insert(6);
//	bst.Insert(2);
//	bst.Insert(8);
//	bst.Insert(1);
//	bst.Insert(5);
//	bst.Insert(3);
//	bst.Insert(4);
//
//
//	std::string strPreOrder = bst.Preorder();
//	std::cout << "preorder: " << strPreOrder << std::endl;
//	BOOST_CHECK_EQUAL(strPreOrder , std::string("6 2 1 5 3 4 8"));
//
//
//	std::string strPostOrder = bst.Postorder();
//	std::cout << "postorder : " << strPostOrder << std::endl;
//	BOOST_CHECK_EQUAL( strPostOrder, std::string("1 4 3 5 2 8 6"));
//
//
//
//	std::string strInOrder = bst.Inorder();
//	std::cout << strInOrder << std::endl;
//	BOOST_CHECK_EQUAL(strInOrder , std::string("1 2 3 4 5 6 8"));
//
//	bst.Delete(2);
//
//	std::string strInOrder_AfterDelete = bst.Inorder();
//	std::cout <<  strInOrder_AfterDelete << std::endl;
//	BOOST_CHECK_EQUAL(strInOrder_AfterDelete, std::string("1 3 4 5 6 8"));
//
//
//	bst.Insert(7);
//	bst.Insert(11);
//	bst.Insert(10);
//	bst.Insert(13);
//
//	strInOrder = bst.Inorder();
//	std::cout << strInOrder << std::endl;
//	BOOST_CHECK_EQUAL(strInOrder, std::string("1 3 4 5 6 7 8 10 11 13"));
//
//
//	bst.Delete(8);
//
//	strInOrder = bst.Inorder();
//	std::cout << strInOrder << std::endl;
//	BOOST_CHECK_EQUAL(strInOrder, std::string("1 3 4 5 6 7 10 11 13"));
//}
//


//
//#include <ctime>
//BOOST_AUTO_TEST_CASE(test_random) 
//{
//
//	BinarySearchTree<int> bst;
//
//	srand(1573788896);
//
//	clock_t timeBegin = clock();
//	for (int i = 0; i < 5000000; i++)
//	{
//		int nRand = rand() % 4000000000;
//		if (!bst.Find(nRand))
//			bst.Insert(nRand);
//	}
//	clock_t timeEnd = clock();
//
//
//	//std::cout << bst.Inorder() << std::endl;
//
//	std::cout << "共耗时: " << timeEnd - timeBegin << endl;
//
//
//	//生成dot文件
//	bst.OutputGraph("test_binarysearchtree.dot", "D:\\Program Files (x86)\\Graphviz2.38\\bin");
//
//	//将dot文件转为 png文件
//	const char *pszCmd = "\"D:\\Program Files (x86)\\Graphviz2.38\\bin\\dot.exe\"   -Tsvg -o test_binarysearchtree.svg test_binarysearchtree.dot   ";
//	std::cout << pszCmd << std::endl;
//	system(pszCmd);
//
//}
//


#include <ctime>
BOOST_AUTO_TEST_CASE(test_random_2)
{
	clock_t timeBegin = clock();
	const int nMaxtimes = 10;
	BinarySearchTree<int> tst;
	for (int nTesttimes = 0; nTesttimes < 10; nTesttimes++)
	{

		srand(1573788896 + nTesttimes * 100);

		for (int i = 0; i < 5000000; i++)
		{
			int nRand = rand() % 4000000000;
			if (!tst.Find(nRand))
				tst.Insert(nRand);
		}
	}
	clock_t timeEnd = clock();
	std::cout << "共耗时: " << (double)(timeEnd - timeBegin ) / 10.0<< endl;  //3828.2


	timeBegin = clock();
	for (int nTesttimes = 0; nTesttimes < nMaxtimes * 1000000; nTesttimes++)
	{
		srand(1573788896 + nTesttimes * 200);
		int nRand = rand() % 4000000000;
		if (tst.Find(nRand))
		{
			//std::cout << "found :" << nRand << std::endl;
		}

	}
	timeEnd = clock();
	std::cout << "共耗时: " << timeEnd - timeBegin << endl;  //


	/*
	共耗时: 3981.3
	共耗时: 8727
	*/
}


BOOST_AUTO_TEST_SUITE_END()
youngqqcn
关注
专栏目录
二分搜索树（Binary Search Tree）
qq_48019875的博客
11-22 2844
目录树结构一、为什么要有树结构二、二分搜索树的基础 树结构 一、为什么要有树结构 树结构本身是一种天然的组织结构 高效 二、二分搜索树的基础
二分查找树BST (Binary Search Tree)
zuo_h_dr的博客
05-11 503
已知的存储方式及其操作的算法复杂度： 在中序遍历的意义下，每一二叉树都对应于某一序列 若该序列为有序向量，则可参照二分查找的算法 每次查找对应于从根到某一节点的路径时：最大比较次数 = 树高 + 1 这便引出了二分查找树： 定义： 二分查找树（Binary Search Tree） 或者是空树 或者其左右子树（L 和 R）都是 BST 如果 L 非空，max{L} &lt; r...
二分查找树(binary search tree)
qq_14952615的博客
08-25 3543
今天开始我们就会进入一些数据结构的部分了。今天第一个要讲的是一类特殊的数据结构，二分查找树。二分查找树的特点如下： 即根节点的数值一定小于左右子节点，其优势在于插入与查找时间较低为 同样，我们比较关心二分查找树的创建 插入 删除 首先说一下，我们在创建二分查找树的时候，也可以根据根节点数值小于子节点的规则一个一个的插入。所以创建与插入可以看成一起的。插入的时候也很简单，就是根据上述的特点，去找到一个比需要插入的值更小的根节点，然后看看插入到左节点还是右节点合适(还要考虑到后面的节点)，直接插入即可。
数据结构与算法-二分搜索树
最新发布
菜鸟小码的博客
07-31 1183
二分搜索树是一种特殊的二叉树，它具有独特的性质，使得在树中查找、插入和删除元素变得非常高效。本文将深入探讨二分搜索树的基本原理、实现步骤，并通过具体的案例代码详细说明二分搜索树的每一个细节。
二分搜索树
漫漫无期的博客
01-02 1756
二分搜索树（Binary Search Tree），也称为 二叉查找树 、二叉搜索树 、有序二叉树或排序二叉树。
数据结构之二分查找树
JXH_123的专栏
07-02 5761
二分查找树（也叫二叉查找树、二叉排序树）的提出是为了提供查找效率，之所以称为二分查找树，因为该二叉树对应着二分查找算法，查找平均的时间复杂度为o(logn)，所以该数据结构的提出是为了提高查找效率。
二分查找树完整代码：BST.java文件
05-26
二分查找树的全部操作代码：包括各种遍历操作，以及打印树形二叉树操作等；博客附带资源！
c++ 二分搜索树 二分查找树 binary search tree BST
11-24
二分搜索树（Binary Search Tree，简称BST）是计算机科学中一种非常重要的数据结构，它在处理有序数据时表现出高效性。在C++中，理解并掌握二分搜索树的概念、操作以及实现方法对于编程实践至关重要。二分搜索树的...
第六课_二分查找与二叉查找树.pdf
03-25
总而言之，二分查找与二叉查找树都是高效处理排序数据的算法和数据结构，它们在计算机科学和软件工程中扮演着重要的角色，尤其是在需要快速查找和排序的场景中。掌握这两者的原理和应用，对于提升编程能力和解决实际...
基于二分查找的有序符号表.zip_bst_基于二分查找的有序符号表_有序符号表_链表python实现
09-23
基于平行数组与二分查找的有序符号表是《算法》中的经典查找算法，本程序使用 Python 语言，实现有序符号表。 ST.py 包含两个类，ST 和 OrderedST。 ST是无序的符号表，基于链表实现。按照顺序将键值对插入链表。 ...
【数据结构与算法】之二分搜索树
醉逍遥的博客
10-08 811
二分搜索树（英语：Binary Search Tree），也称为 二叉查找树 、二叉搜索树 、有序二叉树或排序二叉树。它的左、右子树也都是二分搜索树。
算法自学笔记：二分查找树
Raine_Yang的博客
01-28 804
我们之前讲二叉堆的时候使用较不直观的方式实现树的数据结构：使用一个数组保存各节点，索引为k节点父节点为k/2，子节点为k * 2, k * 2 + 1 这一次，我们使用直观方式实现树结构：构造实际的节点类。类似于链表里的节点，不过每一个节点指向两个节点：left和right private Class Node { private Value value; private Key key; // Value and Key are generic variables for symbol tables
BinarySearchTree（二分查找树）
热门推荐
人生嘛！无非是左脚比右脚前，右脚再比左脚前，明天比今天好！
05-25 9万+
【代码】BinarySearchTree（二分查找树）
二分查找树
雪儿的专栏
06-11 513
~~~题目：       从线性结构转向支持快速查找和插入的结构。 插入31,41,59，26的二分查找树。 IntSetBST类定义了结点和根：      private:            int n,*v,vn;            struct node           {                int val;                node
BinarySearchTree
weixin_33858249的博客
03-18 81
2019独角兽企业重金招聘Python工程师标准>>> ...
二分查找树(Binary Search Tree)
风雨落
06-23 2281
对于查找这个操作，相信大家都不陌生 顺序查找 ( Sequential Searching )最直接的查找便是顺序查找 ( Sequential Searching )，其实就是从头到尾遍历一遍，看有无自己想要的元素，充满暴力，所以同时也意味着效率低下，时间复杂度O(n) ,所以要改进二分查找 ( Binary Searching )先决条件，要求序列有序这是一个二分查找的实现代码： int Bin
二分查找树（BST）
pixiuqinqin
01-08 401
这个出现频率比较高，为了防止忘了，写一下好了 二分查找树的性质（来自维基百科）： 若任意节点的左子树不空，则左子树上所有结点的值均小于或等于它的根结点的值；任意节点的右子树不空，则右子树上所有结点的值均大于它的根结点的值；任意节点的左、右子树也分别为二叉查找树。没有键值相等的节点（英语：no duplicate nodes）。 也就是说左子树的值 在九章算法那个网站
二分查找树BST(Binary Search Tree)
weixin_45039440的博客
07-23 151
二分查找树BST（Binary Search Tree）目的是为了提高查找的性能，其查找在平均和最坏的情况下都是logn级别，接近二分查找。其特点是：每个节点的值大于其任意左侧子节点的值，小于其任意右节点的值。 一.BST节点的构造 二分查找树的节点与普通二叉树的节点类似： typedef struct tree{ int num; //二叉树节点的值 struct tree *pLe...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值