二叉查找树--C++

最新推荐文章于 2025-04-15 20:35:13 发布
最新推荐文章于 2025-04-15 20:35:13 发布
阅读量364 收藏
点赞数
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/u010876646/article/details/54139512
版权 
#include "stdafx.h"
#include <iostream>
using namespace std;



/*
二叉查找树的性质：
1.二叉排序树或为空树
2.若左子树不为空，则左子树中所有节点的值均小于或等于根节点
3.若右子树不为空，则右子树中所有节点的值均大于或等于跟节点
4.左右子树也为二叉排序树
（5.二叉排序树采用中序历遍（从左到右）输出的时候是有序的）
*/

//#define T int

//节点数据结构
template<class V,class K>
struct NODE{
	V value;
	K key;
	NODE *left;
	NODE *right;
	NODE(K key_,V value_,NODE *left_,NODE *right_)
	{
		value = value_; key = key_;
		left = left_; right = right_;
	}
	NODE(K key_,V value_)
	{
		value = value_; key = key_;
		left = NULL; right = NULL;
	}
	NODE()
	{}
};

//插入，根节点不能为空，键值不可重复 ,插入失败返回false:（1）键值重复（2）参数为NULL（3）根为空
//插入的节点必须是使用new分配的，因为要采用delete释放
template<class V,class K>
bool insert(NODE<V,K> *root, NODE<V,K> *node)
{
	if(NULL == node){
		return false;
	}
	//空树
	if(NULL == root){
		return false;
	}
	//非空树
	NODE<V,K> *pointer = root;//指向二叉树的指针
	//找出插入的所在节点
	while(true)
	{
		if(pointer->key == node->key){
			return false;
		}
		else if(node->key > pointer->key){
			if(pointer->right != NULL){
				pointer = pointer->right;
			}
			else{
				pointer->right = node;
				return true;
			}
		}
		else{
			if(pointer->left != NULL){
				pointer = pointer->left;
			}
			else{
				pointer->left = node;
				return true;
			}
		}
	}
}

//中序历遍
template<class V,class K>
void middlePrint(const NODE<V,K> * const node)
{
	if(NULL == node)
		return;
	if(NULL != node->left){
		middlePrint<V,K>(node->left);
	}
	//cout<<node->key<<"-"<<node->value<<endl;//中序，就是在中间输出，前序与后序同理
	cout<<node->key<<" ";
	if(NULL != node->right){
		middlePrint<V,K>(node->right);
	}
}

//查找 返回NULL表示没找到
template<class V,class K>
NODE<V,K>* search( NODE<V,K> *root, K key)
{
	NODE<K,V> *re = new NODE<K,V>();
	if(NULL == root)
		return NULL;
	NODE<V,K> *pointer = root;
	while(true)
	{
		if(pointer->key == key)
		{
			re->key = key;
			re->value = pointer->value;
			return re;
		}
		else if(key > pointer->key)
		{
			if(NULL == pointer->right){
				return NULL;
			}
			else{
				pointer = pointer->right;
			}
		}
		else{
			if(NULL == pointer->left){
				return NULL;
			}
			else{
				pointer = pointer->left;
			}
		}
	}
}

//删除--如果不存在就返回false
template<class V,class K>
bool delete_node(NODE<V,K> **root, K key)
{
	NODE<V,K> *p = *root;
	NODE<V,K> *parent = *root;
	NODE<V,K> *temp = NULL;
	while(p != NULL)
	{
		if(p->key == key)
			break;
		else if(key > p->key){
			parent = p;
			p = p->right;
		}
		else{
			parent = p;
			p = p->left;
		}
	}
	//如果没找到就返回false
	if(NULL == p)
		return false;
	//删除
	//要删除的节点为根节点
	if(*root == p)
	{
		temp = *root;
		//右子树不为空
		if(NULL != p->right)
		{
			//右子树的左子树为空
			if(NULL == p->right->left)
			{
				p->right->left = p->left;
				*root = p->right;
			}
			//右子树的左子树不为空
			else
			{
				NODE<V,K> *p1 = p->right->left;
				while(p1->left != NULL)
				{
					parent = p1;
					p1 = p1->left;
				}
				if(p1->right == NULL)
				{
					parent->left = NULL;
					p1->left = (*root)->left;
					p1->right = (*root)->right;
					*root = p1;
				}
				else
				{
					parent->left = p1->right;
					p1->left = (*root)->left;
					p1->right = (*root)->right;
					*root = p1;
				}
			}
		}
	}
	//叶子节点
	else if(NULL == p->left && NULL == p->right)
	{
		if(parent->left == p)
		{
			temp = parent->left;
			parent->left = NULL;
		}
		else
		{
			temp = parent->right;
			parent->right = NULL;
		}
	}
	//该节点只有左子树或又子树
	else if(NULL == p->left || NULL == p->right)
	{
		temp = p;
		if(parent->left == p)
		{
			if(p->left != NULL)
				parent->left = p->left;
			else
				parent->left = p->right;
		}
		else
		{
			if(p->left != NULL)
				parent->right = p->left;
			else
				parent->right = p->right;
		}
	}
	//左右子树皆不为空
	else if(p->left != NULL && p->right != NULL)
	{
		temp = p;
		//右子树的左子树为空
		if(NULL == p->right->left)
		{
			p->right->left = p->left;
			if(parent->left == p)
				parent->left = p->right;
			else
				parent->right = p->right;
		}
		//右子树的左子树不为空
		else
		{
			NODE<V,K> *p1 = p->right->left;
			NODE<V,K> *parent2 = p->right;
			while(p1->left != NULL)
			{
				parent2 = p1;
				p1 = p1->left;
			}
			parent2->left = p1->right;
			p1->left = p->left;
			p1->right = p->right;
			if(parent->left == p)
				parent->left = p1;
			else 
				parent->right = p1;
		}

	}

	if(temp != NULL){
		delete temp;
		return true;
	}
	else
		return false;
}

int _tmain(int argc, _TCHAR* argv[])
{
	NODE<int,int> *root = new NODE<int,int>(50,50);
	for(int i = 0;i < 20; i++)
	{
		int key = rand()%100;
		int value = rand()%100;
		NODE<int,int> *node = new NODE<int,int>(key,value);
		insert<int,int>(root,node);
		cout<<key<<" ";
	}
	cout<<endl;
	middlePrint<int,int>(root);
	cout<<"-------------------"<<endl;
	NODE<int,int> *node = search<int,int>(root,35);
	if(NULL == node){
		cout<<"不存在的Key"<<endl;
	}
	else{
		cout<<node->key<<"-"<<node->value<<endl;
	}
	cout<<"-------------------"<<endl;//2 5 18 21 27 34 35 41 47 50 61 62 67 69 71 78 81 91 92 95
	//delete_node(&root,2);			  //  5 18 21 27 34 35 41 47 50 61 62 67 69 71 78 81 91 92 95
	//delete_node(&root,5);			  //2   18 21 27 34 35 41 47 50 61 62 67 69 71 78 81 91 92 95
	//delete_node(&root,18);		  //2 5    21 27 34 35 41 47 50 61 62 67 69 71 78 81 91 92 95
	//delete_node(&root,21);		  //2 5 18    27 34 35 41 47 50 61 62 67 69 71 78 81 91 92 95
	//delete_node(&root,27);		  //2 5 18 21    34 35 41 47 50 61 62 67 69 71 78 81 91 92 95
	//delete_node(&root,34);		  //2 5 18 21 27    35 41 47 50 61 62 67 69 71 78 81 91 92 95
	//delete_node(&root,35);		  //2 5 18 21 27 34    41 47 50 61 62 67 69 71 78 81 91 92 95
	//delete_node(&root,41);		  //2 5 18 21 27 34 35    47 50 61 62 67 69 71 78 81 91 92 95
	//delete_node(&root,47);		  //2 5 18 21 27 34 35 41    50 61 62 67 69 71 78 81 91 92 95
	//delete_node(&root,50);		  //2 5 18 21 27 34 35 41 47    61 62 67 69 71 78 81 91 92 95
	//delete_node(&root,61);		  //2 5 18 21 27 34 35 41 47 50    62 67 69 71 78 81 91 92 95
	//delete_node(&root,62);		  //2 5 18 21 27 34 35 41 47 50 61    67 69 71 78 81 91 92 95
	//delete_node(&root,67);		  //2 5 18 21 27 34 35 41 47 50 61 62    69 71 78 81 91 92 95
	//delete_node(&root,69);		  //2 5 18 21 27 34 35 41 47 50 61 62 67    71 78 81 91 92 95
	//delete_node(&root,71);		  //2 5 18 21 27 34 35 41 47 50 61 62 67 69    78 81 91 92 95
	//delete_node(&root,78);		  //2 5 18 21 27 34 35 41 47 50 61 62 67 69 71    81 91 92 95
	//delete_node(&root,81);		  //2 5 18 21 27 34 35 41 47 50 61 62 67 69 71 78    91 92 95
	//delete_node(&root,91);		  //2 5 18 21 27 34 35 41 47 50 61 62 67 69 71 78 81    92 95
	//delete_node(&root,92);		  //2 5 18 21 27 34 35 41 47 50 61 62 67 69 71 78 81 91    95
	//delete_node(&root,95);		  //2 5 18 21 27 34 35 41 47 50 61 62 67 69 71 78 81 91 92   
	middlePrint<int,int>(root);		  //2 5 18 21 27 34 35 41 47 50 61 62 67 69 71 78 81 91 92 95
	getchar();
	return 0;
}

C++二叉查找树
p=f/s
08-07 249
#include <iostream> using namespace std; template <class T> class BST; template <class T> class Element { public : T key; }; template <class T> class BstNode { friend class BST<T>; public: //private: Element<T&.
【C++、数据结构】二叉排序树（二叉查找树、二叉搜索树）（图解+完整代码）
金哥的博客
10-22 2119
二叉搜索树/二叉排序树/二叉查找树：创建、插入、查找、删除（非递归以及递归版本代码），以及超详细步骤图解
二叉查找树（c++）
DONGJING1108的博客
08-08 241
下图无比现实 二叉查找树又名二叉排序树、二叉搜索树、BST(Binary Search Tree)。首先知道它的基础数据结构。 它是一颗二叉树（带权），通常会用结构体实现（数组或者指针——个人比较喜欢用数组，之后的代码也是用数组来实现的）。 为什么用数组呢？ 因为写的舒服，一个字爽 struct node{ int l, r, val; //左孩子，右孩子...
【C++】二叉搜索树
最新发布
2301_79825793的博客
04-15 1010
二叉搜索树的概念、操作、实现、应用及效率分析
C++二叉搜索树
2301_76197086的博客
08-27 1031
详解二叉搜索树的基本操作，以及二叉搜索树的K模型和KV模型
二叉查找树 减治法——C++代码
05-24
在C++中实现二叉查找树，一般会定义一个结构体或类来表示树节点，包括键、值和子节点指针。然后，提供一系列成员函数来执行基本操作，如`insert`（插入）、`search`（查找）、`delete`（删除）。以下是C++实现二叉...
一种高效二叉查找树---红黑树
12-30
### 一种高效二叉查找树——红黑树 #### 一、引言 在计算机科学领域，二叉查找树(Binary Search Tree, BST)是一种非常重要的数据结构，它能够有效地实现查找、插入和删除等基本操作。然而，在某些情况下，普通的...
c++实现二叉查找树示例
09-04
在C++中实现二叉查找树，我们需要定义两个类，一个是数据节点`dNode`，另一个是二叉树节点`bstNode`，以及一个用于操作二叉查找树的类`bst`。 首先，数据节点`dNode`包含了三个成员变量：`name`表示姓名，`age`表示...
二叉查找树C++实现
12-23
在C++中实现二叉查找树，我们需要定义一个结构体或类来表示树节点，包括节点的值、指向左子节点和右子节点的指针。以下是一个简单的C++实现框架： ```cpp struct TreeNode { int val; TreeNode* left; TreeNode*...
二叉查找树（C++实现）
玉米味土豆片
05-02 328
       其实所谓的二叉搜索树、二叉查找树、二叉排序树都是同一种东西，顾名思义Binary Search Tree是一种有利于查找数据的数据结构。其实在实际场景中用得最多的是红黑树，也是一种特殊的二叉平衡树；而二叉平衡树又是一种特殊的二叉查找树，也就是说，二叉查找树是一种范围很大的二叉树类别。当在二叉查找树中查找元素的时候，BSTree从根节点出发，通过比较查找目标与当前节点的数值，判断下一步...
c++ 二叉搜索树
Hedenghui777的博客
06-22 391
在这里为什么我们需要学习二叉搜索树呢？ map和set特性需要先铺垫二叉搜索树，而二叉搜索树也是一种树形结构。 二叉搜索树的特性了解，有助于更好的理解map和set。 1.二叉搜索树 1.1 二叉搜索树概念 二叉搜索树又称二叉排序树，它或者是一棵空树，或者是具有以下性质的二叉树: 若它的左子树不为空，则左子树上所有节点的值都小于根节点的值 若它的右子树不为空，则右子树上所有节点的值都大于根节点的值 它的左右子树也分别为二叉搜索树 int a [] = {5,3,4,1,7,8,2,6,0,9}; 1.
C++——二叉搜索树
weixin_49449676的博客
11-30 2087
若要删除8，这里采用右树最左节点的替换法，右树的最左节点就是10自己，如果这样写会有错误，while循环都不会进去，minparent就是空，而后面minParent->_left = min->_right;用左子树的最大节1点或右子树的最小节点4，若采用右树的最小节点，交换3和4删除4之后，删除3，但还有一个子节点5，我们让5成为6的左节点。若果要删除跟节点，而且左为空，若要删除8，我们更新根节点即可，让根节点指向10。若果要删除跟节点，而且右为空，若要删除8，让根节点指向3即可。
C++实现范型二叉查找树代码详解
下面，我们来详细分析一下二叉查找树C++代码中可能涉及的知识点。 ### 1. 类设计与模板（范型类） 在C++中，模板是实现泛型编程的一种机制，它允许定义函数或类时不指定具体的类型，而是在使用时才指定。使用模板...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值