手把手教你写二叉查找树Binary Search Tree（1）

最新推荐文章于 2020-11-29 07:52:26 发布
最新推荐文章于 2020-11-29 07:52:26 发布
阅读量350 收藏
点赞数
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_39688949/article/details/78153962
版权
本文详细讲解了二叉查找树（BST）的实现过程，包括构造函数、析构函数、插入函数、删除操作以及查找功能。通过逐步添加代码的方式，适合初学者理解BST的操作，并提供了前序、中序、后序遍历的实现。
摘要由CSDN通过智能技术生成

参考资料：《数据结构与算法分析》（第三版英文版）

书本题目：5.15

其实是做作业的时候顺便复习一下二叉查找树，顺便把自己写代码时的过程记录下来。虽然代码可能比较丑，但应该对于新手而言是比较友好的，可以了解如何一步一步实现BST的函数的。同时更深入理解一下返回值为Node*类型的Help函数。

说明：BST为Binary Search Tree，二叉查找树.Node为节点，即二叉查找树的节点。代码加粗部分为每次新增的代码

首先建立Node节点，每个节点只有1个整数类型的public数据成员

#pragma once
#include <iostream>
using namespace std;
class Node 
{
public:
	int x;
	Node* left;
	Node* right;

	Node(int val, Node* l = NULL, Node* r = NULL) {
		x = val;
		left = l;
		right = r;
	}
	~Node() {};
};


随后建立BST类，里面只有一个数据成员根节点root，为Node*类型。

1。初始化

我们首先要实现构造函数和析构函数。

构造函数其实就是将root指向新new出来的Node对象。

析构函数中借用了一个clearHelp（）函数，其参数为任意BST）的将被删除一个根节点rt（因为这样才能实现递归）。使用递归从左子树遍历到右子树，当发现某一节点的左右子树均为空的时候，删除该节点。随后逆流而上，向上删除。

#pragma once
#include "Node.h"
class BST
{
public:
	Node* root;

	BST(int val) {
		root = new Node(val, NULL, NULL);
	}
	~BST() {
		clearHelp(root);
	}
	void clearHelp(Node* rt) {
		if (rt == NULL) return;
		clearHelp(rt->left);
		clearHelp(rt->right);
		delete rt;
	}
};


2.。增

实现插入函数insert();

首先，在Node类里面分别实现设置左节点和右节点的setleft()和setRight()函数

///Node 类

#pragma once
#include <iostream>
using namespace std;
class Node 
{
public:
	int x;
	Node* left;
	Node* right;

	Node(int val, Node* l = NULL, Node* r = NULL) {
		x = val;
		left = l;
		right = r;
	}
	~Node() {};


	void setLeft(Node* l) {
		left = l;
	}
	void setRight(Node* r) {
		right = r;
	}
};
随后在BST类里面在InsertHelp（Node* ,int）函数的帮助下完成insert（int）函数.。 原理（递归）：从根节点出发，首先检测该节点是否为空，为空则返回一个新创建的节点。若不为空，则将要被插入的值val与当前按节点的值x比较，当val小于x时，向左继续往下走，否则向右继续往下走，进行新一轮检测。在新一轮检测中，把当前根节点的rt的左孩子rt->left作为新的根节点 再次调用

insertHelp里面有3个重要的地方值得关注。

第一个是nsertHelp的返回类型是Node*  类型。

第二个是当前根节点不为空的setLeft()。这个是为了保证插入val之后维护好BST的用的。这要自己慢慢体会。

第三个是节点为空NULL时的返回

#pragma once
#include "Node.h"
class BST
{
public:
	Node* root;

	BST(int val) {
		root = new Node(val, NULL, NULL);
	}
	~BST() {
		clearHelp(root);
	}
	void clearHelp(Node* rt) {
		if (rt == NULL) return;
		clearHelp(rt->left);
		clearHelp(rt->right);
		delete rt;
	}


	void insert(int val)
	{
		insertHelp(root, val);
	}
	Node* insertHelp(Node* rt, int val) {
		if (root == NULL)
			return new Node(val, NULL, NULL);
		if (val < rt->x)
		{
			rt->setLeft(insertHelp(rt->left, val));
		}
		else
		{
			rt->setRight(insertHelp(rt->right, val));
		}
	}
	
};

3。删

删除整个树的最小值，先用一根指针指向含有最小值的节点，再将这个节点的父节点的左指针指向这个节点的右孩子，而不在意这个节点的右孩子是否为空。

同样注意递归，setLeft(),以及Help返回类型为Node*这三个要点。

#pragma once
#include "Node.h"
class BST
{
public:
	Node* root;

	BST(int val) {
		root = new Node(val, NULL, NULL);
	}
	~BST() {
		clearHelp(root);
	}
	void clearHelp(Node* rt) {
		if (rt == NULL) return;
		clearHelp(rt->left);
		clearHelp(rt->right);
		delete rt;
	}


	void insert(int val)
	{
		insertHelp(root, val);
	}
	Node* insertHelp(Node* rt, int val) {
		if (root == NULL)
			return new Node(val, NULL, NULL);
		if (val < rt->x)
		{
			rt->setLeft(insertHelp(rt->left, val));
		}
		else
		{
			rt->setRight(insertHelp(rt->right, val));
		}
	}

	Node* findMin(Node* rt) {
		if (rt->left==NULL) return rt;
		else
			return findMin(rt->left);
	}
	Node* deleteMin(Node* rt) {
		if (rt->left == NULL)
			return rt->right;
		else {
			rt->setLeft(deleteMin(rt->left));
			return rt;
		}
	}
	void deleteMin(){
		Node *temp = findMin(root);
		root = deleteMin(root);
		delete temp;
	}

};

删除带有特定值val的节点

同样注意递归，setLeft(),以及返回类型为Node*这三个要点。

#pragma once
#include "Node.h"
class BST
{
public:
	Node* root;

	BST(int val) {
		root = new Node(val, NULL, NULL);
	}
	~BST() {
		clearHelp(root);
	}
	void clearHelp(Node* rt) {
		if (rt == NULL) return;
		clearHelp(rt->left);
		clearHelp(rt->right);
		delete rt;
	}
	void insert(int val)
	{
		insertHelp(root, val);
	}
	Node* insertHelp(Node* rt, int val) {
		if (root == NULL)
			return new Node(val, NULL, NULL);
		if (val < rt->x)
		{
			rt->setLeft(insertHelp(rt->left, val));
		}
		else
		{
			rt->setRight(insertHelp(rt->right, val));
		}
	}


	Node* findMin(Node* rt) {
		if (rt->left==NULL) return rt;
		else
			return findMin(rt->left);
	}
	Node* deleteMin(Node* rt) {
		if (rt->left == NULL)
			return rt->right;
		else {
			rt->setLeft(deleteMin(rt->left));
			return rt;
		}
	}
	void deleteMin(){
		Node *temp = findMin(root);
		root = deleteMin(root);
		delete temp;
	}


	Node* removeHelp(Node* rt, int val)
	{
		if (rt == NULL) return NULL; 
		if (val < rt->x) rt->setLeft(removeHelp(rt->left, val)); 
		if (val > rt->x) rt->setRight(removeHelp(rt->right, val));
		else {
			Node* temp = rt;
			if (rt->left == NULL) {
				rt = rt->right;
				delete temp;
			}
			else if (rt->right == NULL) {
				rt = rt->left;
				delete temp;
			}
			else  //左右节点均为空或者左右节点均不为空
			{
				Node* temp = findMin(rt->right);  //找到右子树最小值
				rt->x = temp->x; 	           //将右子树的最小值赋给rt值
				rt->setRight(deleteMin(rt->right));  // 将rt的右子树设为删除最小值后的新右子数
				delete temp;
			}
		}
		return rt;
	}
	void remove(int val)
	{
		root = removeHelp(root, val);
	}
};

4。查

查找是否含有特定值val的节点，有则返回true,否则返回false.

#pragma once
#include "Node.h"
class BST
{
public:
	Node* root;

	BST(int val) {
		root = new Node(val, NULL, NULL);
	}
	~BST() {
		clearHelp(root);
	}
	void clearHelp(Node* rt) {
		if (rt == NULL) return;
		clearHelp(rt->left);
		clearHelp(rt->right);
		delete rt;
	}
	
	void insert(int val)
	{
		insertHelp(root, val);
	}
	Node* insertHelp(Node* rt, int val) {
		if (root == NULL)
			return new Node(val, NULL, NULL);
		if (val < rt->x)
		{
			rt->setLeft(insertHelp(rt->left, val));
		}
		else
		{
			rt->setRight(insertHelp(rt->right, val));
		}
	}


	Node* findMin(Node* rt) {
		if (rt->left==NULL) return rt;
		else
			return findMin(rt->left);
	}
	Node* deleteMin(Node* rt) {
		if (rt->left == NULL)
			return rt->right;
		else {
			rt->setLeft(deleteMin(rt->left));
			return rt;
		}
	}
	void deleteMin(){
		Node *temp = findMin(root);
		root = deleteMin(root);
		delete temp;
	}

	Node* removeHelp(Node* rt, int val)
	{
		if (rt == NULL) return NULL;
		if (val < rt->x)   rt->setLeft(removeHelp(rt->left, val));
		if (val > rt->x) rt->setRight(removeHelp(rt->right, val));
		else {
			Node* temp = rt;
			if (rt->left == NULL) {
				rt = rt->right;
				delete temp;
			}
			else if (rt->right == NULL) {
				rt = rt->left;
				delete temp;
			}
			else
			{
				Node* temp = findMin(rt->right);
				rt->x = temp->x;
				rt->setRight(deleteMin(rt->right));
				delete temp;
			}
		}
		return rt;
	}
	void remove(int val)
	{
		root = removeHelp(root, val);
	}

	Node* findHelp(Node* rt, int val)
	{
		if (rt == NULL) return NULL;
		else if (val < rt->x) return findHelp(rt->left, val);
		else if (val > rt->x) return findHelp(rt->right, val);
		else return rt;
	}
	bool is_Exist(int val) {
		if (findHelp(root, val) == NULL) return false;
		else return true;
	}
};

5。改，其实到这里大家应该都知道怎么写了，在findHelp函数的帮助下找到要被替换的值，对其进行修改。若找不到，则插入新值。

6。前序遍历，中序遍历，后序遍历  （其实是以 根节点的位置来命名这三种遍历的），下面看代码

//前序遍历 根->左->右
	void preorderTraverseHelp(Node* rt) {
		if (rt == NULL) return ;
		//else activity(rt);  当前节点不为空的话，对当前节点进行操作，这个操作是任意的,
		 cout << rt->x<<endl; // 如对当前节点的值进行输出。
		preorderTraverseHelp(rt->left);
		preorderTraverseHelp(rt->right);
	}
	//实现函数封装
	void preorderTraverse() {
		 preorderTraverseHelp(root);
	}


	//中序遍历  左->根->右
	void inorderTraverseHelp(Node* rt) {
		if (rt == NULL) return;
		 inorderTraverseHelp(rt->left);
		 cout << rt->x << endl;
		 inorderTraverseHelp(rt->right);
	}
	void inorderTraver() {
		inorderTraverseHelp(root);
	}

	//后序遍历  左->右->根
	void postorderTraverseHelp(Node* rt)
	{
		if (rt == NULL) return;
		postorderTraverseHelp(rt->left);
		postorderTraverseHelp(rt->right);
		cout << rt->x << endl;
	}
	void postorderTraverse()
	{
		postorderTraverseHelp(root);
	}
7。做题。在main.cpp里面 

#include "BST.h"
int main() {
	BST* tree = new BST(15);
	tree->insert(20);
	tree->insert(25);
	tree->insert(18);
	tree->insert(16);
	tree->insert(5);
	tree->insert(7);
	cout << endl << "preorder:" <<endl;
	tree->preorderTraverse();
	cout << endl << endl << "inorder;"<<endl ;
	tree->inorderTraver();
	cout << endl << endl << "postorder:"<<endl	 ;
	tree->postorderTraverse();


	system("pause");
}
运行结果



weixin_39688949
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
二叉搜索树的第K个节点：递归中用参数返回值。
学无止境
03-28 399
题目描述 给定一颗二叉搜索树，请找出其中的第k大的结点。例如， 5 / \ 3 7 /\ /\ 2 4 6 8 中，按结点数值大小顺序第三个结点的值为4。 思路： 1.二叉搜索树的中序遍历结果就是从小到大排序的结果。所以中序遍历的第K个节点即为所求。 2.递归中要得到值，不一定要返回值，可以返回值为void,然后在参数中，通过“地址“或引用的形式修改参数的值， 即得到
二叉搜索树（Binary Search Tree）
Piers的博客
06-26 496
树一直是算法领域的核心之一。二叉搜索树又是树的主要用处之一。一旦学好了二叉搜索树，就可以设计很多高效的程序。
二分搜索法和二叉搜索树
oreo的博客
10-03 978
1二分搜索法 二分搜索法是一个很常用的搜索方法，但是它要求数组必须是一个有序的数组，不然二分搜索就失去了意义。二分搜索是说我们将整个数组分成左右两个部分，让中间的数据和targe进行比较，如果target > arr[mid]表示target在右半区域；如果target <arr[mid]，说明target在左半区域；如果target == arr[mid]说明找到了，返回mide就行。 二分搜索法可以用递归方法和循环方法实现，它们的逻辑都是相同的：如果不在该区域，就根据mid调整...
二叉搜索树(Binary Search Tree)
qq_21058391的博客
10-05 421
二叉搜索树，也叫做二叉排序树。这种结构查找元素非常的高效。 在JS里面构建这种结构，有2种方法 1）通过嵌套的对象  2）通过嵌套的数组 下面我们给出嵌套的对象来实现这种结构 /* 二叉搜索树，二叉排序树，Binary Search Tree 这里我们使用嵌套的对象(nested object) */ function BinarySearchTree() { var Node
【数据结构】----平衡二叉树怎么自己画？
热门推荐
何新生(Daniel) 勇敢坚毅真正之才智乃刚毅之志向。 —— 拿破仑
01-08 3万+
【数据结构】平衡二叉树怎么自己画？        是什么？     要了解平衡二叉树，先得了解什么是二叉树？ 二叉树定义： 在计算机中，二叉树是每一个节点最多有两个子树的结构。通常子树被称作“左子树（left subtree）”“右子树（right subtree）”. 二叉树常被用于实现二叉树查找和二叉堆。 什么是平衡二叉树：      平衡二叉树（Balan
BST.rar_binary search tree_二叉搜索树
09-19
二叉搜索树（Binary Search Tree，BST）是一种特殊类型的二叉树，它的每个节点都包含一个键（key）、一个关联的值、一个指向左子树的引用和一个指向右子树的引用。在二叉搜索树中，对于任意节点，其左子树中的所有...
JS中的算法与数据结构之二叉查找树（Binary Sort Tree）实例详解
10-16
二叉查找树（Binary Sort Tree，BST）是数据结构中的一种特殊树形结构，它具有以下特点：每个节点都有一个键值，且左子树中所有节点的键值小于当前节点，右子树中所有节点的键值大于当前节点。这种特性使得二叉查找...
二叉查找树 减治法——C++代码
05-24
二叉查找树（Binary Search Tree，BST）是一种特殊的二叉树数据结构，它的每个节点都包含一个键（key）、一个关联的值、一个指向左子树的引用和一个指向右子树的引用。在二叉查找树中，对于任意节点，其左子树中的...
二叉查找树python二叉查找树源码
最新发布
11-22
二叉查找树（Binary Search Tree，BST），也称为二叉排序树，是一种特殊的二叉树数据结构。它的每个节点都包含一个键（key）、一个关联的值、一个指向左子节点的指针和一个指向右子节点的指针。在二叉查找树中，对于...
avl.rar_AVL树_binary search tree
09-24
AVL树是一种自平衡二叉查找树（Binary Search Tree，简称BST），由Georgy Adelson-Velsky和Emanuel Landis在1962年提出，因此得名AVL，AV是两位发明者名字的首字母。在AVL树中，任何节点的两个子树的高度最大差别不...
二叉树详解 binary tree && binary search tree
爱.NET
02-28 194
本文参考stanford大学一位计算机教授所写的关于二叉树的文章： http://download.csdn.net/detail/stevemarbo/4097865 二叉树，一个经典的数据结构，它包含一个指向左子树的指针，一个指向右指数的指针，和一个数据元素 二叉搜索树，在二叉树的基础上，它的左子树的值都小于它，它的右子树的值都大于它 树本身就是一个递归定义的数据结构，所以...
二分搜索树（Binary search tree)
10-15 2057
二叉搜索树（Binary Search Tree，BST）是一颗典型的二叉树，任何节点的键值大于等于该节点左子树中的所有键值，小于等于该节点右子树中的所有键值。 未完待续。。；。。
二叉搜索树（Binary Search Tree）的查找
song_hui_xiang
08-15 1207
二叉查找树（Binary Search Tree），（又：二叉搜索树，二叉排序树）它或者是一棵空树，或者是具有下列性质的二叉树： 若它的左子树不空，则左子树上所有结点的值均小于它的根结点的值； 若它的右子树不空，则右子树上所有结点的值均大于它的根结点的值； 它的左、右子树也分别为二叉排序树。 /* 二叉搜索树（Binary Search Tree）也称二叉排序树或者二叉查找树 1.非空左
简单二叉搜索树（Binary Search Tree,简称BST）
weixin_44118591的博客
04-08 192
二叉搜说树的概念:首先它必须是一棵二叉树，其(根>左)&&(根<右). ps:此处的所讲不包含相同的节点。 例：6,3,8,2,5,1,7 代码实现此二叉搜索树： #include<iostream> #include<stdlib.h> using namespace std; typedef struct node { int d...
二叉查找树的原理与实现 Binary Search Tree
LUCKYOJ
10-31 1613
二叉查找树是一种特殊的二叉树。其树结点的结构和普通二叉树一样。所不同的是，我们对二叉查找树的建立和修改操作都需要使其始终满足一个条件：对于树中的每个结点X，它的左子树中所有关键字值小于X的关键值，而它的右子树中所有关键字大于X的关键值。     正是这个条件二叉查找树的建立和修改操作和普通二叉树不一样，需要按照一定的规则。这一规则赋予二叉查找树一些性质。 二叉查找树具有的性质： 1、二叉查找
编程算法 - 二叉搜索树(binary search tree) 代码(C)
Mystra
07-21 3518
二叉搜索树(binary search tree) 代码(C)本文地址: http://blog.csdn.net/caroline_wendy二叉搜索树(binary search tree)可以高效的进行插入, 查询, 删除某个元素, 时间复杂度O(logn).简单的实现方法如下.代码:/* * main.cpp * * Created on: 2014.7.20 * Au
Binary Search Tree的实现 C++版
csdn_ning的博客
10-29 1210
// 定义二叉检索树类 template class BST { private: BSTNode* root; int nodecount; void clearhelp(BSTNode*); BSTNode* inserthelp(BSTNode*, const Key&); BSTNode* deletemin(BSTNode*); BSTNode* getmi
【Leetcode】Recover Binary Search Tree
nxtgo
09-14 1996
Two elements of a binary search tree (BST) are swapped by mistake. Recover the tree without changing its structure. Note: A solution using O(n) space is pretty straight forward. Could you devise a
线索二叉树怎么画_C/C++后台开发学习笔记(五)-树、二叉树
weixin_40000131的博客
11-29 1325
一、树(1)树的概念树（Tree）是n(n>=0）个结点的有限集。n=0时称为空树。在任意一颗非空树中：（1）有且仅有一个特定的称为根（Root）的结点；（2）当n>1时，其余结点可分为m(m>0)个互不相交的有限集T1、T2、…Tm,其中每一个集合本身又是一颗树，并且称为根的子树（subTree），如图:概念说了那么多，还不如来图的实在。实话说的好有图有真相。(2)其他重要概念...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值