二叉查找树--C++

最新推荐文章于 2022-11-30 20:54:57 发布
最新推荐文章于 2022-11-30 20:54:57 发布
阅读量317 收藏
点赞数
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/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;
}

春秋一阕任琦行
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
C++二叉查找树
p=f/s
08-07 201
#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++代码
05-24
在C++中实现二叉查找树，一般会定义一个结构体或类来表示树节点，包括键、值和子节点指针。然后，提供一系列成员函数来执行基本操作，如`insert`（插入）、`search`（查找）、`delete`（删除）。以下是C++实现二叉...
二叉查找树（c++）
DONGJING1108的博客
08-08 195
下图无比现实 二叉查找树又名二叉排序树、二叉搜索树、BST(Binary Search Tree)。首先知道它的基础数据结构。 它是一颗二叉树（带权），通常会用结构体实现（数组或者指针——个人比较喜欢用数组，之后的代码也是用数组来实现的）。 为什么用数组呢？ 因为写的舒服，一个字爽 struct node{ int l, r, val; //左孩子，右孩子...
C++二叉搜索树
默的博客
05-05 582
C++二叉搜索树1、概念2、操作2.1增加（插入）2.2删除2.3查找2.4修改3、 二叉搜索树的性能分析4、模拟实现代码 1、概念 二叉搜索树又称二叉排序树，它或者是一棵空树，或者是具有以下性质的二叉树： 若它的左子树不为空，则左子树上所有节点的值都小于根节点的值； 若它的右子树不为空，则右子树上所有节点的值都大于根节点的值； 它的左右子树也分别为二叉搜索树。 2、操作 2.1增加（插入） 树为空，直接插入，返回true； 树不为空，判断根节点数据大小，根数据大往左边找，否则往右边找，找到返回true；
c++实现二叉查找树示例
09-04
在C++中实现二叉查找树，我们需要定义两个类，一个是数据节点`dNode`，另一个是二叉树节点`bstNode`，以及一个用于操作二叉查找树的类`bst`。 首先，数据节点`dNode`包含了三个成员变量：`name`表示姓名，`age`表示...
二叉查找树C++实现
12-23
在C++中实现二叉查找树，我们需要定义一个结构体或类来表示树节点，包括节点的值、指向左子节点和右子节点的指针。以下是一个简单的C++实现框架： ```cpp struct TreeNode { int val; TreeNode* left; TreeNode*...
C++二叉查找树实现过程详解
12-22
什么是二叉查找树 　在数据结构中，有一个奇葩的东西，说它奇葩，那是因为它重要，这是树。而在树中，二叉树又是当中的贵族。二叉树的一个重要应用是它们在查找中的应用，于是有了二叉查找树。 使二叉树成为一颗...
c++实现二叉查找树
11-15
### C++ 实现二叉查找树 #### 一、引言 本文将详细介绍如何使用C++来实现一个二叉查找树(Binary Search Tree, BST)，包括其基本操作：插入、删除、遍历等，并通过示例代码进行解释。二叉查找树是一种非常重要的数据...
二叉查找树（C++实现）
玉米味土豆片
05-02 271
       其实所谓的二叉搜索树、二叉查找树、二叉排序树都是同一种东西，顾名思义Binary Search Tree是一种有利于查找数据的数据结构。其实在实际场景中用得最多的是红黑树，也是一种特殊的二叉平衡树；而二叉平衡树又是一种特殊的二叉查找树，也就是说，二叉查找树是一种范围很大的二叉树类别。当在二叉查找树中查找元素的时候，BSTree从根节点出发，通过比较查找目标与当前节点的数值，判断下一步...
c++ 二叉搜索树
Hedenghui777的博客
06-22 290
在这里为什么我们需要学习二叉搜索树呢？ 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 1922
若要删除8，这里采用右树最左节点的替换法，右树的最左节点就是10自己，如果这样写会有错误，while循环都不会进去，minparent就是空，而后面minParent->_left = min->_right;用左子树的最大节1点或右子树的最小节点4，若采用右树的最小节点，交换3和4删除4之后，删除3，但还有一个子节点5，我们让5成为6的左节点。若果要删除跟节点，而且左为空，若要删除8，我们更新根节点即可，让根节点指向10。若果要删除跟节点，而且右为空，若要删除8，让根节点指向3即可。
【C++】二叉搜索树
ly_6699的博客
05-01 4265
**二叉搜索树又叫二叉排序树，它或者是一颗空树**，或者是具有以下性质的二叉树： - 若它的左子树不为空，则左子树上的所有结点都小于根节点上的值 - 若它的右子树不为空，则右子树上的所有结点都大于根节点上的值 - 它的左右子树也分别是二叉搜索树
【 C++ 】二叉搜索树
bit_zyx的博客
09-03 985
目录 1、二叉搜索树的概念 2、二叉搜索树的实现 ①、结点类 ②、二叉搜索树的类 2.1、默认成员函数 构造函数 拷贝构造函数 赋值运算符重载函数 析构函数 2.2、中序遍历 2.3、Insert插入函数 ............
二叉搜索树（C++）
mmz123_的博客
01-27 2539
文章目录二叉搜索树概念与操作二叉搜索树的概念二叉搜索树的操作查找插入删除二叉搜索树的应用二叉树的性能分析 二叉搜索树概念与操作 二叉搜索树的概念 二叉搜索树又称二叉排序树，若它的左子树不为空，则左子树上所有节点的值都小于根节点的值；若它的右子树不为空，则右子树上所有节点的值都大于根节点的值，它的左右子树也分别未二叉搜索树。也可以是一颗空树。 int a[] = { 5, 3, 4, 1, 7, 8, 2, 6, 0, 9 }; 二叉搜索树的操作 查找 迭代： Node* Find(const K&am
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值