数据结构与算法总结——二叉查找树及其相关操作

最新推荐文章于 2022-07-18 08:00:00 发布
最新推荐文章于 2022-07-18 08:00:00 发布
阅读量170 收藏 1
点赞数
分类专栏： 数据结构与算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/winter_wu_1998/article/details/84325414
版权

  • 我实现了如下操作

    • 插入，查找，删除，最大值
    • 树的高度，子树大小
    • 二叉树的范围和，范围搜索
    • 树的前序，中序，后序三种遍历
    • rank
    • 前驱节点
      • 现在想来下面用的方法还是比较复杂的，其实直接中序遍历一下就好了

  • 在这一版本的代码中，我使用了类模板将接口与实现分离，在这之中，遇到了许多问题：

    • 当类模板和实现分别在两个文件中实现时，需要直接包含实现文件而不是模板文件
    • 实现文件中，返回类中自定义的数据结构（如结构体）前要加上类名，并且要在前面加入typename关键词，否则会报错，
      • 如：typename BST<Comparable>::node*

  • 在使用C++实现的时候，也有很多收获：

    • 对于不改变数据的函数，最好在声明的最后加上const
      • 不可在声明为const的函数中使用不是const的函数
      • 在const函数中，所有的成员指针（包括this）都变成的常数指针
    • 使用传引用操作可以使得insert和delete函数无需返回值
    • 在模板中使用了常引用代替值作为返回值，因为返回参数可能不是基本类型，这么做可以避免不必要的拷贝
//BST.h

#include <iostream>

using namespace std;

template<typename Comparable>
class BST
{
public:
	struct node
	{
		Comparable elements;
		node* left;
		node* right;
		size_t count;

		node(Comparable Elements, node* Left, node* Right, size_t Count)
			:elements(Elements), left(Left), right(Right), count(Count) {}
	};

	node* root;

	explicit BST(); 
    node* & search(const Comparable& x) ;
	const Comparable & findMax();
	void insert(Comparable x);
	void del(const Comparable& x);
	bool isEmpty() const;
	size_t size(node* n) const;
	void printTree(const string & x) const;
	size_t height() const;
	const Comparable & rank(size_t x) const;
	const Comparable & precessor(const Comparable& x);
	size_t rangeSum(const Comparable& x, const Comparable& y);
	void rangeSearch(const Comparable& x, const Comparable& y);


private:
    node* & search(node*  & root, const Comparable& x) ;
	node* & findMax(node* & root);
	void insert(node* & root, Comparable x);
	void del(node* & root, const Comparable& x);
	void preOrder( node* const &  root) const; //为什么 root 一定要是常量指针？
	void postOrder( node* const & root) const;
	void inOrder( node* const & root) const;
	void levelOrder( node* const & root) const;
	size_t height(const node* root) const;
	const Comparable & rank(size_t x, const node*  root) const;
	Comparable & precessor(const Comparable& x,  node* root);
	node* getNode( //注意要传入指针的引用才能改变指针
		const Comparable& x, node* root, node* & parent, node* & firstRightParent);
	size_t rangeSum(const Comparable& x, const Comparable& y, node* root);
	void rangeSearch(const Comparable& x, const Comparable& y, node* root);

};



//BST.cpp

#include "BST.h"
#include <queue>


template <typename Comparable>
BST<Comparable>::BST()
{
	root = nullptr;
	
}

template <typename Comparable>
size_t BST<Comparable>::size(node* n) const
{
	return (n == nullptr) ? 0 : n->count;
}

template <typename Comparable>
 typename  BST<Comparable>::node* & BST<Comparable>::search(const Comparable& x)  
{
	return search(root, x);
}

template<typename Comparable>
const Comparable & BST<Comparable>::findMax() 
{
	return findMax(root)->elements;
}

template<typename Comparable>
bool BST<Comparable>::isEmpty() const
{
	return root == nullptr;
}

template<typename Comparable>
void BST<Comparable>::insert(Comparable x)
{
	insert(root, x);
}

template<typename Comparable>
void BST<Comparable>::del(const Comparable& x)
{
	del(root, x);
}

template<typename Comparable>
void BST<Comparable>::printTree(const string & x) const
{
	if (x == "preorder")
		preOrder(root);
	else if (x == "postorder")
		postOrder(root);
	else if (x == "inorder")
		inOrder(root);
	else if (x == "levelorder")
		levelOrder(root);
	else
		throw "Wrong input!";
}

template <typename Comparable>
size_t BST<Comparable>::height() const
{
	return height(root);
}

template <typename Comparable>
const Comparable & BST<Comparable>::rank(size_t x) const
{
	return rank(x, root);
}

template <typename Comparable>
const Comparable & BST<Comparable>::precessor(const Comparable& x) 
{
	return precessor(x, root);
}


template <typename Comparable>
size_t BST<Comparable>::rangeSum(const Comparable& x, const Comparable& y)
{
	return rangeSum(x, y, root);
}

template <typename Comparable>
void BST<Comparable>::rangeSearch(const Comparable& x, const Comparable& y)
{
	rangeSearch(x, y, root);
}

/*private*/
/

///

template <typename Comparable>
void BST<Comparable>::rangeSearch(const Comparable& x, const Comparable& y, node* root)
{
	if (root == nullptr)
		return;
	else if (root->elements >= x && root->elements <= y)
	{
		rangeSearch(x, y, root->left);
		cout << root->elements << endl;
		rangeSearch(x, y, root->right);
	}
	else if (root->elements < x)
		rangeSearch(x, y, root->right);
	else
		rangeSearch(x, y, root->left);
}


template <typename Comparable>
size_t BST<Comparable>::rangeSum(const Comparable& x, const Comparable& y, node* root)
{
	if (root == nullptr)
		return 0;
	else if (root->elements >= x && root->elements <= y)
		return root->elements + rangeSum(x, y, root->left) + rangeSum(x, y, root->right);
	else if (root->elements < x)
		return rangeSum(x, y, root->right);
	else
		return rangeSum(x, y, root->left);
}


template <typename Comparable>
typename  BST<Comparable>::node* BST<Comparable>::getNode(
	const Comparable& x,   node* root,  node* & parent,  node* & firstRightParent)
{
	while (root)
	{
		if (root->elements == x)
			return root;
		
		parent = root;
		
		if (root->elements > x)
			root = root->left;
		else
		{
			firstRightParent = root;
			root = root->right;
		}
	}

	return nullptr;
}

template <typename Comparable>
 Comparable & BST<Comparable>::precessor(const Comparable& x,  node* root) 
{
	if (root == nullptr)
		throw "emptt tree";

	 node* parent = nullptr;
	 node* firstRightParent = nullptr;

	 node* now = getNode(x, root, parent, firstRightParent);

	if (now == nullptr)
		throw "now such value";
	int a = 0;

	if (now->left != nullptr)
		return findMax(now->left)->elements;
	else if (parent == nullptr)
		throw "no precessor";
	else if (parent->right == now)
		return parent->elements;
	else if (firstRightParent == nullptr)
		throw "no precessor";
	else
		return firstRightParent->elements;
}


template <typename Comparable>
const Comparable & BST<Comparable>::rank(size_t x, const node*  root) const
{
	if (root == nullptr)
		throw "empty tree";

	size_t left = size(root->left);
	if (left == x)
		return root->elements;
	else if (left > x)
		return rank(x, root->left);
	else
	
		return rank(x - left - 1, root->right);
	
}


template <typename Comparable>
size_t BST<Comparable>::height(const node* root) const
{
	if (root == nullptr)
		return 0;
	else
	{
		size_t left = height(root->left);
		size_t right = height(root->right);
		return 1 + (left > right ? left : right);
	}
		
}

template<typename Comparable>
typename  BST<Comparable>::node* & BST<Comparable>::search(node* & root, const Comparable& x) 
{
	if (root == nullptr)
		throw "No such element!";
	else if (root->elements == x)
		return root;
	else if (root->elements > x)
		return search(root->left, x);
	else if (root->elements < x)
		return search(root->right, x);

}

template<typename Comparable>
typename BST<Comparable>::node* & BST<Comparable>::findMax(node* & root) 
{
	if (root == nullptr)
		throw "Empty tree!";
	else if (root->right == nullptr)
		return root;
	else
		return findMax(root->right);
}

template<typename Comparable>
void BST<Comparable>::insert(node* & root, Comparable x)
{
	if (root == nullptr)
	{
		root = new node(x, nullptr, nullptr, 1);
		return;
	}
	else if (root->elements < x)
		insert(root->right, x);
	else if (root->elements > x)
		insert(root->left, x);
	else
		; //duplicated value, do nothing

	root->count = size(root->left) + size(root->right) + 1;
}

template<typename Comparable>
void BST<Comparable>::del(node* & root, const Comparable& x)
{
	if (root == nullptr)
		throw "No such elements!";
	else if (root->elements < x)
		del(root->right, x);
	else if (root->elements > x)
		del(root->left, x);
	else
	{
		
		if (root->left == nullptr && root->right == nullptr)//no child
		{
			delete root;
			root = nullptr;
		}
		else if (root->left == nullptr || root->right == nullptr)// one child
		{
			auto temp = root;
			if (root->left == nullptr)
			{
				root = root->right;
				delete temp;
			}
			else if (root->right == nullptr)
			{
				root = root->left;
				delete temp;
			}
		}
		else //two children
		{
			auto & repalce = findMax(root->left);
			root->elements = repalce->elements;
			auto temp = repalce;
			repalce = repalce->left;
			delete temp;
		}
	}
}

template<typename Comparable>
void  BST<Comparable>::preOrder( node* const &  root) const
{
	if (root != nullptr) 
	{
		cout << root->elements << endl;
		preOrder(root->left);
		preOrder(root->right);
	}
}

template<typename Comparable>
void  BST<Comparable>::postOrder(node* const &  root) const
{
	if (root != nullptr)
	{
		postOrder(root->left);
		postOrder(root->right);
		cout << root->elements << endl;
	}
	

}

template<typename Comparable>
void  BST<Comparable>::inOrder(node* const &  root) const
{
	if (root != nullptr)
	{
		postOrder(root->left);
		cout << root->elements << endl;
		postOrder(root->right);
	}
}

template<typename Comparable>
void BST<Comparable>::levelOrder(node* const &  root) const
{
	queue<node*> q;
	q.push(root);
	while (!q.empty())
	{
		auto curNode = q.front();
		cout << curNode->elements << endl;
		q.pop();
		if (curNode->left != nullptr) 
			q.push(curNode->left);
		if (curNode->right != nullptr)
			q.push(curNode->right);
	}
}
_萤火
关注
专栏目录
数据结构——查找(二叉排序树)
weixin_47924016的博客
09-15 1516
二叉排序树查找定义二叉排序树构造二叉排序树查找递归和非递归算法二叉排序树插入递归和非递归算法二叉排序树删除递归和非递归算法二叉排序树查找定义二叉排序树构造二叉排序树查找递归和非递归算法二叉排序树插入递归和非递归算法二叉排序树删除递归和非递归算法。
《数据结构与算法》——树与二叉树的应用之二叉排序树（Binary Sort Tree）总结
Kwzc4的博客
08-15 682
《数据结构与算法》——树与二叉树的应用之二叉排序树（Binary Sort Tree）总结 它来了，它来了，二叉排序树挥舞着它的两个子树向我们走来了~ 纠结于复习树和森林的遍历还是树的应用时，天气太热，不纠结了，点点豆豆，点到谁就是谁~ 目录 《数据结构与算法》——树与二叉树的应用之二叉排序树（Binary Sort Tree）总结 定义 方法实现 构建方法 插入方法 查找方法 ...
《数据结构》二叉排序树查找性能总结
明哥的专栏
12-16 8496
二叉排序树查找性能分析 1. 一棵二叉查找树的平均查找长度（ASL），见下图公式（1）。2. 一棵满二叉排序树的平均查找长度，见下图公式（2）。 3. 一棵斜二叉排序树的平均查找长度，见下图公式（3）。             由上面可以分析得知，对于二叉排序查找性能，最坏是斜树情况下的查找，最好的在一棵满树状态下查找。也就是说性能在公式（2）和公式（3）计算的值之间。当然一实际中，一
排序算法
小白将
04-16 1017
排序算法排序是最基本的算法之一，常见的排序算法有插入排序、希尔排序、选择排序、冒泡排序、堆排序、归并排序及快速排序。每个排序算法的时间复杂度是不同的，但是最优的时间复杂度是O(NlogN)。有些排序算法是原址排序（即不需要额外空间），也有一些是非原址排序，这也是需要注意的特点。同样地，还要注意排序算法是否是稳定排序，这有时候很重要。这篇文章简单地介绍各个排序算法的思想，然后使用C++实现各个排序算法
【排序】快速排序
小米子的成长日记
07-18 965
对于C++，快速排序(quicksort)历史上一直是实践中已知最快的泛型排序算法，其平均运行时间是O(NlogN)。
用实例来理解IComparable和IComparer
起个名字好难啊
08-26 1005
接口的功能 我想大家都是知道的，书上已经讲的天花烂醉了 但是烦人的是大部分初学者包括我死活看不懂他们说的是什么意思，昨晚在C#高级编程中看了看总算 理解 了 一点点的小作用，在此记录下以便以后拾遗   主要是通过Array的Sort方法来理解的 Sort方法要 通过对象去继承IComparable接口来实现排序（当然也有其它办法），我想入门这可能就是对这句话有点不理解，在下面会有
数据结构与算法详解——二叉查找树篇（附c++实现代码）
JMasker的博客
05-23 1476
目录二叉树相关概念和术语二叉树特殊类型二叉树的存储链式存储顺序存储二叉树的遍历二叉查找树查找插入删除完整代码 二叉树相关概念和术语   二叉树的递归定义为：二叉树是一棵空树，或者是一棵由一个根节点和两棵互不相交的，分别称作根的左子树和右子树组成的非空树；左子树和右子树又同样都是二叉树。 度：一个节点拥有子树的数目称为结点的度，叶子结点的度为0。 叶子结点：也称为终端结点，没有子树的结点或者度为零的结点。 结点的层次：从根结点开始，假设根结点为第1层，根节点的子结点为第2层，依此类推，如果某一个结点位于第L
数据结构与算法——二叉搜索树、二叉平衡树、红黑树 总结
nswdiphone6的博客
03-12 656
二叉排序树，平衡二叉树，红黑树总结 二叉排序树 二叉排序树，相信大家都接触过，二叉查找树的特点就是左子树的节点值比父亲节点小，而右子树的节点值比父亲节点大，如图 基于二叉查找树的这种特点，我们在查找某个节点的时候，可以采取类似于二分查找的思想，快速找到某个节点。n 个节点的二叉查找树，正常的情况下，查找的时间复杂度为 O（logn）。 之所以说是正常情况下，是因为二叉查找树有可能出现一种极端的情况，例如 这种情况也是满足二叉查找树的条件，然而，此时的二叉查找树已经近似退化为一条链表，这样的二叉查找树的查
【数据结构】基于树的查找法——二叉排序树（C语言）
weixin_51450101的博客
03-07 2206
二叉排序树又称二叉查找树，它是一种特殊的二叉树。其定义为：二叉排序树或者是一棵空树，或者是具有如下性质的二叉树： ① 若它的左子树非空，则左子树上所有结点的值均均小于根结点的值。 ② 若它的左子树非空，则左子树上所有结点的值均均大于（或大于等于）根结点的值。 ③ 它的左右子树也分别为二叉排序树。
排序算法通用头文件——template_head.h
犹有傲霜枝的博客
08-15 714
排序算法C++实现的通用头文件 // template_head.h #pragma once //#include "../sort_algorithms/BinaryHeap.tpp" #include <vector> #include <string> template <typename Container> void printList(Container& list) { for (auto &x : list) { std::co
C++ - 模板(template)中typename的使用方法
热门推荐
Mystra
04-17 4万+
模板(template)中typename的使用方法 http://blog.csdn.net/caroline_wendy/article/details/23910709 声明template参数时, 前缀关键字class和typename可以互换; 使用关键字typename标识嵌套从属类型名称, 但不需在基类列表和成员初始化列表内使用. 从属名称(dependent names): 模板(templat
C++中typename关键字的使用方法和注意事项
Sannysha的专栏
12-08 777
1， 什么地方使用？用在模板定义里，标明其后的模板参数是类型参数。    例如 templateT foo(const T& t, const Y& y){//....};templaceclass CTest{private: T t;public: //...}    其实，这里最常用的是使用关键字class，而且二者功能完全相同，这里的cl
C++ const成员函数
Mr_scott_j的博客
08-18 425
Const关键字 const可以用于替换#define 使用宏定义可能并不会加入记号表(symbol table) 例如： #define PI 3.14159 const double Pi = 3.14159; 而对于const与指针同时出现的情况：如果const在’ * ’ 左侧，则被指物为常量；如果const在’ * '右侧，则指针本身为常量；如果出现两次，则都为常量。 const TreeNode* root;// TreeNode const * root;//exactly the sam
readonly const IComparable
chpdirector84的专栏
03-24 543
C#语言有两种不同的常量机制：一种为编译时（compile-time）常量，一种为运行时（runtime）常量。我们说运行时常量优于编译时常量。编译时常量比运行时常量稍微快一点，但却缺乏灵活性。编译时常量只可以用于基元类型（包括内建的整数类型和浮点类型）、枚举类型或字符串类型。因为只有这些类型才允许我们在初始化器中指定有意义的常量值private const DateTime _cla
二叉搜索树
Big_Study_Father的博客
09-25 176
title: 二叉搜索树 categories: 工具 tags: DataStructure STL堆的那段代码初看的时候一脸懵，百度了一下才发现是树… 好，我学，我学… BSTree.h文件 #include<iostream> using namespace std; namespace BST { template<class Comparable>...
6-1 二叉树 - 13. 二叉树的深度
国家一级致癌物
11-16 1785
请编写函数，求二叉树的深度。 函数原型 int BinTreeDepth(const TNODE *root); 说明：root 为二叉树的根指针，函数值为二叉树的深度。 在头文件 BinTree.h 中声明函数，在程序文件 BinTree.c 中编写函数。 BinTree.h … int BinTreeDepth(const TNODE *root); … BinTree.c … /* 你提交的代码将被嵌在这里 */ 裁判程序 main.c #include <stdio.h> #inclu
二叉查找树与数据结构——树的探索与操作
"这是一份关于二叉树算法和数据结构的PPT，重点讲解了二叉树，特别是二叉查找树的概念、表示方法以及操作，包括查找、插入和删除等基本操作，还提到了哈夫曼编码的实现。" 在计算机科学中，树是一种非常重要的非...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值