C++实现简单AVL树与二分搜索树

最新推荐文章于 2022-08-24 10:57:58 发布
最新推荐文章于 2022-08-24 10:57:58 发布
阅读量282 收藏 1
点赞数
分类专栏： C++ 数据结构 文章标签： AVL BST
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/kuaijg/article/details/95898889
版权

主要包括添加、删除、遍历等功能

#define _CRK_SECURE_NO_WARNINGS
#include <iostream>
#include <fstream>
#include <sstream>
#include <vector>
using namespace std;

int max(int a, int b) {
	return a > b ? a : b;
}

template<class K, class V>
class Node
{
public:
	K key;
	V value;
	int height;
	Node* left;
	Node* right;
	Node() {
		this->height = 0;
		this->left = NULL;
		this->right = NULL;
	}

	Node(K key, V value) {
		this->key = key;
		this->value = value;
		this->height = 1;
		this->left = NULL;
		this->right = NULL;
	}
};
template<class K, class V>
class BST {
public:
	BST() {
		root = NULL;
		size = 0;
	}
	int Size() {
		return size;
	}

	void add(K key, V value) {
		root = add(root, key, value);
	}
	bool Contains(K key) {
		return GetNode(root, key) != NULL;
	}

	Node<K, V>* GetNode(Node<K, V>* node, K key) {
		if (node == NULL) {
			return NULL;
		}
		if (key == node->key) {
			return node;
		}
		else if (key < node->key) {
			return GetNode(node->left, key);
		}
		else {
			return GetNode(node->right, key);
		}
	}
	V Get(K key) {
		Node<K, V>* node = GetNode(root, key);
		return node == NULL ? NULL : node->value;
	}
	void set(K key, V value) {
		Node<K, V>* node = GetNode(root, key);
		if (node == NULL) {
			return;
		}
		node->value = value;
	}
	Node<K, V>* minimum(Node<K, V>* node) {
		if (node->left == NULL) {
			return node;
		}
		return minimum(node->left);
	}

private:
	//node为根
	Node<K, V>* add(Node<K, V>* node, K e, V value) {
		if (node == NULL) {
			size++;
			return new Node<K, V>(e, value);
		}

		if (e < node->key) {
			node->left = add(node->left, e, value);
		}
		else if (e > node->key) {
			node->right = add(node->right, e, value);
		}
		else {
			node->value = value;
		}
		return node;
	}
private:
	Node<K, V>* root;
	int size;
};

template<class K, class V>
class AVLT {
public:
	AVLT() {
		root = NULL;
		size = 0;
	}
	int Size() {
		return size;
	}

	int GetHeight(Node<K, V>* node) {
		if (node == NULL) {
			return 0;
		}
		return node->height;
	}
	int Height() {
		return GetHeight(root);
	}
	int GetBalanceFactor(Node<K, V>* node) {
		if (node == NULL) {
			return 0;
		}
		return GetHeight(node->left) - GetHeight(node->right);
	}
	bool IsBST() {
		vector<K> keys;
		InOrder(root, keys);
		for (int i = 1; i < (int)keys.size(); i++) {
			if (keys[i - 1] > keys[i]) {
				return false;
			}
		}
		return true;
	}
	void InOrder(Node<K, V>* node, vector<K> keys) {
		if (node == NULL) {
			return;
		}
		InOrder(node->left, keys);
		keys.push_back(node->key);
		InOrder(node->right, keys);
	}
	bool IsBalanced() {
		return IsBalanced(root);
	}
	bool IsBalanced(Node<K, V>* node) {
		if (node == NULL) {
			return true;
		}
		int bf = GetBalanceFactor(node);
		if (abs(bf) > 1) {
			return false;
		}
		return IsBalanced(node->left) && IsBalanced(node->right);
	}

	void add(K key, V value) {
		root = add(root, key, value);
	}
	bool Contains(K key) {
		return GetNode(root, key) != NULL;
	}

	Node<K, V>* GetNode(Node<K, V>* node, K key) {
		if (node == NULL) {
			return NULL;
		}
		if (key == node->key) {
			return node;
		}
		else if (key < node->key) {
			return GetNode(node->left, key);
		}
		else {
			return GetNode(node->right, key);
		}
	}
	V Get(K key) {
		Node<K, V>* node = GetNode(root, key);
		return node == NULL ? NULL : node->value;
	}
	void set(K key, V value) {
		Node<K, V>* node = GetNode(root, key);
		if (node == NULL) {
			return;
		}
		node->value = value;
	}
	Node<K, V>* minimum(Node<K, V>* node) {
		if (node->left == NULL) {
			return node;
		}
		return minimum(node->left);
	}
	K minimumKey() {
		return minimum(root)->key;
	}
	V Remove(K key) {
		Node<K, V>* node = GetNode(root, key);
		if (node != NULL) {
			root = Remove(root, key);
			return node->value;
		}
		return NULL;
	}

	void preOrder()
	{
		preOrder(root);
	}
	void inOrder()
	{
		inOrder(root);
	}
	void postOrder()
	{
		postOrder(root);
	}

private:
	void preOrder(Node<K, V>*node) const
	{
		if (node != NULL)
		{
			cout << node->key << "," << node->value << ";";
			preOrder(node->left);
			preOrder(node->right);
		}
	}
	void inOrder(Node<K, V>*node) const
	{
		if (node != NULL)
		{
			inOrder(node->left);
			cout << node->key << "," << node->value << ";";
			inOrder(node->right);
		}
	}
	void postOrder(Node<K, V>*node) const
	{
		if (node != NULL)
		{
			postOrder(node->left);
			postOrder(node->right);
			cout << node->key << "," << node->value << ";";
		}
	}
	Node<K, V>* Remove(Node<K, V>* node, K key) {
		if (node == NULL) {
			return NULL;
		}
		Node<K, V>* ret;
		if (key < node->key) {
			node->left = Remove(node->left, key);
			ret = node;
		}
		else if (key > node->key) {
			node->right = Remove(node->right, key);
			ret = node;
		}
		else {
			if (node->left == NULL) {
				Node<K, V>* rn = node->right;
				node->right = NULL;
				size--;
				ret = rn;
			}
			else if (node->right == NULL) {
				Node<K, V>* ln = node->left;
				node->left = NULL;
				size--;
				ret = ln;
			}
			else
			{
				Node<K, V>* newroot = minimum(node->right);
				newroot->right = Remove(node->right, newroot->key);
				newroot->left = node->left;
				node->left = node->right = NULL;
				ret = newroot;
			}
		}
		if (ret == NULL) {
			return NULL;
		}
		ret->height = 1 + max(GetHeight(ret->left), GetHeight(ret->right));
		int balancefactor = GetBalanceFactor(ret);

		//左边较大，LL右旋转
		if (balancefactor > 1 && GetBalanceFactor(ret->left) >= 0) {
			return RightRotate(ret);
		}
		//左边较大，RR右旋转
		if (balancefactor < -1 && GetBalanceFactor(ret->right) <= 0) {
			return LeftRotate(ret);
		}
		//右边较大，LR左旋转，右旋转
		if (balancefactor > 1 && GetBalanceFactor(ret->left) < 0) {
			ret->left = LeftRotate(ret->left);
			return RightRotate(ret);
		}
		//右边较大，RL右旋转，左旋转
		if (balancefactor < -1 && GetBalanceFactor(ret->right) > 0) {
			ret->right = RightRotate(ret->right);
			return LeftRotate(ret);
		}
		balancefactor = GetBalanceFactor(node);
		if (abs(balancefactor) > 1) {
			cout << balancefactor << endl;
		}
		return ret;
	}


	//node为根
	Node<K, V>* add(Node<K, V>* node, K e, V value) {
		if (node == NULL) {
			size++;
			return new Node<K, V>(e, value);
		}
		else if (e < node->key) {
			node->left = add(node->left, e, value);
		}
		else if (e > node->key) {
			node->right = add(node->right, e, value);
		}
		else {
			node->value = value;
		}
		node->height = 1 + max(GetHeight(node->left), GetHeight(node->right));
		int balancefactor = GetBalanceFactor(node);

		//左边较大，LL右旋转
		if (balancefactor > 1 && GetBalanceFactor(node->left) >= 0) {
			return RightRotate(node);
		}
		//左边较大，RR右旋转
		if (balancefactor < -1 && GetBalanceFactor(node->right) <= 0) {
			return LeftRotate(node);
		}
		//右边较大，LR左旋转，右旋转
		if (balancefactor > 1 && GetBalanceFactor(node->left) < 0) {
			node->left = LeftRotate(node->left);
			return RightRotate(node);
		}
		//右边较大，RL右旋转，左旋转
		if (balancefactor < -1 && GetBalanceFactor(node->right) > 0) {
			node->right = RightRotate(node->right);
			return LeftRotate(node);
		}
		balancefactor = GetBalanceFactor(node);
		if (abs(balancefactor) > 1) {
			cout << balancefactor << endl;
		}
		return node;
	}
	Node<K, V>* RightRotate(Node<K, V>* y) {
		Node<K, V>* x = y->left;
		//右旋转
		y->left = x->right;
		x->right = y;
		//更新高度
		y->height = 1 + max(GetHeight(y->left), GetHeight(y->right));
		x->height = 1 + max(GetHeight(x->left), y->height);
		return x;
	}
	Node<K, V>* LeftRotate(Node<K, V>* y) {
		Node<K, V>* x = y->right;
		//左旋转
		y->right = x->left;
		x->left = y;

		//更新高度
		y->height = 1 + max(GetHeight(y->left), GetHeight(y->right));
		x->height = 1 + max(y->height, GetHeight(x->right));
		return x;
	}

private:
	Node<K, V>* root;
	int size;
};
int main(void)
{
	ifstream infile("D:\\Desktop\\Clianxi\\C++\\trie\\testfile\\1.Harry Potter and the Sorcerer's Stone.txt");
	if (!infile.is_open()) {
		return -1;
	}
	vector<string> words;
	BST<string, int> bst;

	AVLT<string, int> avlt;
	while (!infile.eof())
	{
		string line, tmp;
		while (infile >> tmp) {
			tmp.erase(0, tmp.find_first_not_of(" "));
			words.push_back(tmp);
			if (bst.Contains(tmp)) {
				bst.set(tmp, bst.Get(tmp) + 1);
			}
			else
				bst.add(tmp, 1);
			if (avlt.Contains(tmp)) {
				avlt.set(tmp, avlt.Get(tmp) + 1);
			}
			else
				avlt.add(tmp, 1);
		}
	}
	infile.close();
	cout << "不同单词" << bst.Size() << endl;
	cout << "___________" << endl;
	cout << "不同单词" << avlt.Size() << endl;
	cout << "___________" << endl;

	cout << "isBST  " << avlt.IsBST() << endl;

	cout << "isBanlanced  " << avlt.IsBalanced() << endl;

	int arr[] = { 3,2,1,4,5,6,7,16,15,14,13,12,11,10,8,9 };
	int i, len;
	AVLT<int, int> *tree = new AVLT<int, int>();

	cout << "依次添加：";
	len = sizeof(arr) / sizeof(arr[0]);
	for (i = 0; i < len; ++i)
	{
		cout << arr[i] << " ";
		tree->add(arr[i],0);
	}
	cout << "\n前序遍历：";
	tree->preOrder();
	cout << "\n中序遍历：";
	tree->inOrder();
	cout << "\n后序遍历：";
	tree->postOrder();
	cout << "\n高度: " << tree->Height() << endl;
	cout << "最小值: " << tree->minimumKey()<< endl;

	for (i = 0; i < len; ++i)
	{
		cout << "\n删除节点：" << i;
		tree->Remove(i);
		cout << "\n高度: " << tree->Height() << endl;
		cout << "中序遍历：";
		tree->inOrder();
	}
	system("pause");
	return 0;
}

主程序测试最后部分参考了https://blog.csdn.net/codernim/article/details/54744619

没事多喝白开水
关注
专栏目录
AVL树插入删除算法详解（有图） -- C++语言实现
FreeeLinux's blog
08-14 1万+
一：AVL树介绍 AVL树本质上还是一棵二叉搜索树，它的特点是： 1.本身首先是一棵二叉搜索树。 2.带有平衡条件：每个结点的左右子树的高度之差的绝对值（平衡因子）最多为1。在本文中用分别用-1，0，1定义左边树高，等高，右边树高。平衡因子用m_bf表示。 也就是说，AVL树，本质上是带了平衡功能的二叉查找树（二叉排序树，二叉搜索树）。 二：插入算法 由于AVL树具有BST树的
AVL树的c++实现
08-03
利用模板类以及智能指针shared_ptr写的关于AVL树的基本实现
从二叉查找树到平衡树：avl, 2-3树，左倾红黑树（含实现代码），传统红黑树...
weixin_30332241的博客
09-13 427
参考：自平衡二叉查找树，红黑树， 算法：理解红黑树 （英文pdf：红黑树） 目录 自平衡二叉树介绍 avl树 2-3树 LLRBT(Left-leaning red-black tree左倾红黑树 （代码见git） 2-3-4树和红黑树 avl和红黑树的比较 自平衡二叉查找树 诞生的目的： 它是为了解决二叉查找树的查找时间复杂度最差是O(n)的...
avl树的C++实现
Sunshine的专栏
03-30 1537
//3avl_tree_c++.h #ifndef AVL_TREE_cplusplus_H #define AVL_TREE_cplusplus_H #include using namespace std; template class AvlTree { public: AvlTree():root(NULL) {} AvlTree(const AvlTree &rhs): r
avl树的c++实现
算法虐我千百遍
09-20 632
最近在看c++，同时又在学习算法，所以这里我就用c++来写一些数据结构和算法。由于之前一直对avl耿耿于怀，所以我决定先把这个数据结构搞定，看来数据结构与算法分析上的描述（完全没有代码实现），我之前看了红黑的实现，所以觉得自己还是有信心完成的，于是拿起键盘自己独立实现了一发，事实证明，如果坚持不懈，那么自己能力范围之内的事情，我们一定可以做到！相比较于红黑树，avl树的实现在思路上是简单不少的，比
AVL树和2-3-4树详解
向上的"狼"的博客
08-24 434
AVL树和2-3-4树详解
C++平衡Avl树实现.zip
08-20
查找操作相对简单，因为AVL树已经保证了有序性，可以使用二分查找的方法。 ```cpp // 删除节点函数 AVLNode* deleteNode(AVLNode* root, int key); // 查找节点函数 AVLNode* search(AVLNode* root, int key); ```...
c++ 二分搜索树 二分查找树 binary search tree BST
11-24
在C++中，理解并掌握二分搜索树的概念、操作以及实现方法对于编程实践至关重要。二分搜索树的核心特性是每个节点的左子树仅包含比该节点小的元素，右子树则包含比该节点大的元素，这种特性使得搜索、插入和删除等...
树：使用AVL，Splay和二分搜索树进行练习
02-20
在本练习中，我们将重点讨论三种特殊的树类型：AVL树、Splay树和二分搜索树（也称为BST，Binary Search Tree）。这三种数据结构都是自平衡的，意味着它们能够通过特定的调整策略保持平衡，从而提高查询效率。 **AVL...
C++实现AVL树的详细解析和代码实现
AVL树（C++实现）统一旋转操作问题详解 AVL树是一种自平衡二叉搜索树，它可以保持树的平衡，提高搜索、插入和删除操作的效率。然而，在实现AVL树时，统一旋转操作是一个常见的问题。本文将详细介绍AVL树（C++实现）...
AVL树 C++ 实现
09-20
平衡二叉树(AVL)的C++实现。 用泛型写的。 IDE为VS2008 好像没别的了~ 就怎么个东西
树形数据结构总结二（AVL，2-3树，红黑树，B树，B+树）
weixin_33719619的博客
06-04 306
AVL AVL（平衡二叉树），它也是一种二分搜索树。它的特点是每个节点的左右子树之差不超过1。在某种特殊的情况下，普通的二分搜索树可能退化为链表，例如加入的元素顺序为1，2，3，4，5。这个时候查询的效率会从O(logn)退化为O(n)。而我们解决这种特定的情况就需要采用平衡二叉树来解决这个问题。 AVL的定义 AVL的每个节点的左子树小于(大于)该节点，右子树大于(小于)该节点，每个节点的左右子...
【数据结构】二叉搜索树，AVL树，2-3树，红黑树、B树B+树简单笔记
大吉的博客
08-14 671
包含了学习红黑树的前置知识，以及简单定义和实现
2-3、avl树
gzhanyf的博客
12-13 194
avl树，又叫平衡二叉搜索树，是在二叉搜索树的基础上建立的一种树，它相比bst，多了一个特性，就是任意一棵子树根节点的左右子树的高度差的绝对值不超过1，这是为了防止bst中最坏情况的出现，一棵avl树的深度为o(logN)。 对于节点的插入，有可能会导致树平衡条件被打破，因此，在插入时，需要对树进行结构调整，以重新满足平衡条件。 我们假设某棵子树的根节点为r，导...
查找：平衡2-3-4树、AVL树（平衡二叉树）、（左倾）红黑树
jinzhao1993的博客
01-15 2860
1. 平衡2-3-4树 一棵2-3-4树是这样一棵树：它或者为空，或者是由以下三类节点组成的树：2-节点，有1个关键字和由关键字划分的2个区间链接；3-节点，有2个关键字和由关键字划分的3个区间链接；4-节点，有3个关键字和4个区间链接。 一棵平衡2-3-4树是一棵2-3-4搜索树，其中所有指向空树的链接到树根的距离都相同。 插入操作在平衡2-3-4树中，每次进行插入仍然能在树中保持完美的
数据结构之2-3 树
靠脑袋是真滴记不住啊！！！！！！！！
05-14 5612
1.0 什么是2-3树 2-3 树是具有如下性质的树 对于每一个结点 他有1 或者2 个关键码 那么什么时候关键码为 1 个呢？ 或者说关键码为 1 个的时候有什么性质呢 当有一个关键码的时候 这个节点的子树会有两个 当这个节点的关键码有 2 个的时候 这个节点的子树是3个 他的所有叶子点都在树的同一层 除了上面外 他还有一些类似二叉排序树 任意节点的左子树的值小于这个节点第一个...
经典搜索算法之2-3-4树与红黑树
翻过一座座山
08-28 1061
1.2-3-4树     在笔者上篇文章中，介绍了B树和B+树，这里我所说的2-3-4树就是阶为4的B树。根据离散数学的图论相关知识，可以证明2-3-4树和红黑树是等价的。对于m阶(m指的结点的最大分支数)B树，其结点的值的个数n：1&lt;=n&lt;m。因此，对于2-3-4树，其结点的值的个数1&lt;=n&lt;4，如下图所示：                        2.红黑树...
AVL树详解（附c++代码）
u012148952的博客
08-14 5346
详解AVL树的左旋和右旋，以及插入和删除两种基本操作。并且实现一颗简单的AVL树
数据结构——2-3树
Benson的博客
02-04 8311
2-3树 2-3树的概念        前面讲到了二叉搜索树(BST)和二叉平衡树(AVL)，二叉搜索树在最好的情况下搜索的时间复杂度为O(logn)，但如果插入节点时，插入元素序列本身就是有序的，那么BST树就退化成一个线性表了，搜索的时间复杂度为O(n)。之所以会变成O(n)，是因为树的高度变大了，BST的比较次数最大是等于树的高度的。因此，如果想要减少比较次数，就需要降低树的高度。在插入
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值