题目要求:
根据平衡二叉树的抽象数据类型的定义,使用二叉链表实现一个平衡二叉树。
二叉树的基本功能:
1、平衡二叉树的建立
2、平衡二叉树的查找
3、平衡二叉树的插入
4、平衡二叉树的删除
5、平衡二叉树的销毁
6、其他:自定义操作
编写测试main()函数测试平衡二叉树的正确性。
头文件:
BalancedTree.h
#include<iostream>
#include<vector>
#include<algorithm>
#include<queue>
using namespace std;
template<class T>class BiNode
{
public:
T val;
BiNode<T> *lch;
BiNode<T> *rch;
BiNode(T v) :val(v), lch(NULL), rch(NULL) {}; //构造函数
BiNode() :lch(NULL), rch(NULL) {}; //构造函数
//BinaryTreeNode(keyType v):value(v),m_pLeft(nullptr),m_pRight(nullptr){}
};
template<class T>class BST
{
public:
BST(T r[], int n); //构造函数
//~BST(); //析构函数
void destroy();
void Release(BiNode<T>*root);//析构辅助函数
bool Search(BiNode<T>*R, T key); //查找关键字key
BiNode<T> *insertBiNode(BiNode<T> *&root, T val); //插入结点
void Delete(BiNode<T>*&R); //删除结点
bool DeleteBST(BiNode<T>*&R, T key); //删除关键字key
int height(BiNode<T>* root); //判断树的高度
bool isBalanced(BiNode<T>* root); //判断树是否为二叉平衡树
int diff(BiNode<T> *root); //计算平衡因子
BiNode<T> *balance(BiNode<T> *root); //平衡操作
void inorder(BiNode<T>* root, vector<int>&res);
vector<int> inorderTraversal(BiNode<T>* root); //中序遍历函数
vector<vector<T>> levelOrder(BiNode<T>* root); //层序遍历函数
//旋转函数集
BiNode<T> *LL_Rotation(BiNode<T> *root);
BiNode<T> *LR_Rotation(BiNode<T> *root);
BiNode<T> *RL_Rotation(BiNode<T> *root);
BiNode<T> *RR_Rotation(BiNode<T> *root);
BiNode<T>*root; //根节点
};
//计算平衡因子
template<class T>
int BST<T>::diff(BiNode<T> *root)
{
if (root == NULL)
return 0;
return height(root->lch) - height(root->rch);
}
//四个旋转操作
template <class T>
BiNode<T> *BST<T>::LL_Rotation(BiNode<T> *root)
{
BiNode<T> *temp = root->lch;
root->lch = temp->rch;
temp->rch = root;
return temp;//返回要旋转子树的主结点
}
template <class T>
BiNode<T> *BST<T>::RR_Rotation(BiNode<T> *root)
{
BiNode<T> *temp = root->rch;
root->rch = temp->lch;
temp->lch = root;
return temp;
}
template <class T>
BiNode<T> *BST<T>::LR_Rotation(BiNode<T> *root)
{//先进行RR操作,再进行LL操作
//注意这里一定要对root->m_Pleft重新赋值
root->lch = RR_Rotation(root->lch);//先对root后的左结点进行RR操作
return LL_Rotation(root);//再对root进行LL操作
}
template <class T>
BiNode<T> *BST<T>::RL_Rotation(BiNode<T> *root)
{//先进行LL操作,再进行RR操作
//注意这里一定要对root->m_pRight重新赋值
root->rch = LL_Rotation(root->rch);//先对root后的右结点进行LL操作
return RR_Rotation(root);//再对root进行RR操作
}
//平衡操作
template <class T>
BiNode<T> *BST<T>::balance(BiNode<T> *root)
{
int dis = diff(root);//计算结点的平衡因子
if (dis > 1) {//左
if (diff(root->lch) > 0)
return LL_Rotation(root);
else
return LR_Rotation(root);
}
else if (dis < -1) {//右
if (diff(root->rch) < 0)
return RR_Rotation(root);
else
return RL_Rotation(root);
}
return root;//无需转换时记得返回root
}
//插入结点
template <class T>
BiNode<T> * BST<T>::insertBiNode(BiNode<T> *&root, T val) //树的根节点和要插入的值
{
if (root == NULL)
{
root = new BiNode<T>(val);
return root;
}
if (val == root->val)
{
return root;
}
else if (val < root->val)
{
//root->lch = insertBiNode(root->lch,val);
insertBiNode(root->lch, val);
root = balance(root); //注意这里是把平衡后的返回置temp赋值给root
return root;
}
else {
//root->rch = insertBiNode(root->rch,val);
insertBiNode(root->rch, val);
root = balance(root);
return root;
}
}
//构造函数
template<class T>
BST<T>::BST(T r[], int n) //构造函数
{
root = NULL;
for (int i = 0; i < n; i++)
insertBiNode(root, r[i]);
}
template<class T>
int BST<T>::height(BiNode<T>* root) //判断树的高度
{
if (root == NULL)
{
return 0;
}
else
{
return max(height(root->lch), height(root->rch)) + 1;
}
}
template<class T>
bool BST<T>::isBalanced(BiNode<T>* root) //判断树是否为二叉平衡树
{
if (root == NULL)
{
return true;
}
else
{
return abs(height(root->left) - height(root->right)) <= 1 && isBalanced(root->left) && isBalanced(root->right);
}
}
//中序遍历
template<class T>
void BST<T>::inorder(BiNode<T>* root, vector<int>&res)
{
if (!root)
return;
inorder(root->lch, res);
res.push_back(root->val);
inorder(root->rch, res);
}
template<class T>
vector<int> BST<T>::inorderTraversal(BiNode<T>* root)
{
vector<T>res;
inorder(root, res);
return res;
}
//层序遍历
template<class T>
vector<vector<T>> BST<T>::levelOrder(BiNode<T>* root)
{
vector <vector <T>> ret;
if (!root)
{
return ret;
}
queue<BiNode<T>*>q;
q.push(root);
while (!q.empty())
{
int currentLevelSize = q.size();
ret.push_back(vector <T>());
for (int i = 1; i <= currentLevelSize; ++i)
{
auto node = q.front(); q.pop();
ret.back().push_back(node->val);
if (node->lch) q.push(node->lch);
if (node->rch) q.push(node->rch);
}
}
return ret;
}
//查找函数
template<class T>
bool BST<T>::Search(BiNode<T>*R, T key)
{
if (R == NULL)
return false;
if (key == R->val)
return true;
else if (key < R->val)
return Search(R->lch, key);
else
return Search(R->rch, key);
}
//删除函数
template<class T>
bool BST<T>::DeleteBST(BiNode<T>*&R, T key)
{
if (R == NULL)
return false;
else
{
if (key == R->val)
{
Delete(R);
return true;
}
else if (key < R->val)
return DeleteBST(R->lch, key);
else
return DeleteBST(R->rch, key);
}
}
template<class T>
void BST<T>::Delete(BiNode<T>*&R)
{
BiNode<T>*q, *s;
if (R->lch == NULL)
{
q = R;
R = R->rch;
delete q;
}
else if (R->rch == NULL)
{
q = R;
R = R->lch;
delete q;
}
else
{
q = R;
s = R->lch;
while (s->rch != NULL)
{
q = s;
s = s->rch;
}
R->val = s->val;
if (q != R)
q->rch = s->lch;
else
R->lch = s->lch;
delete s;
}
}
析构函数
//template<class T>
//BST<T>::~BST()
//{
// Release(root);
//}
//
template<class T>
void BST<T>::Release(BiNode<T>*root)
{
if (root)
{
Release(root->lch);
Release(root->rch);
delete root;
}
}
template<class T>
void BST<T>::destroy()
{
Release(root);
}
主函数main.cpp
#include<iostream>
#include<vector>
#include"BalancedTree.h"
using namespace std;
void print(BST<int>bt);
int main()
{
int arr[] = { 13,24,37,90,53 };
//3,7,9,11,15,14,16,18,26
int n = sizeof(arr) / sizeof(arr[0]);
BST<int>bt(arr,n);
print(bt);
cout << "请输入你想插入的数字" << endl;
int insernum;//插入数字
cin >> insernum;
bt.insertBiNode(bt.root, insernum);
print(bt);
cout << "请输入你想查找的数字" << endl;
int sernum;//查找数字
cin >> sernum;
if (bt.Search(bt.root, sernum))
cout << "查到" << endl;
else
cout << "未查到" << endl;
cout << "请输入你想删除的数字" << endl;
int delnum;//删除数字
cin >> delnum;
if (bt.DeleteBST(bt.root, delnum))
cout << "删除成功" << endl;
else
cout << "删除失败" << endl;
print(bt);
bt.destroy();
//bt.~BST();
}
void print(BST<int>bt)
{
cout << "中序遍历的结果为:" << endl;
vector<int>res;
res = bt.inorderTraversal(bt.root);
for (int i : res)
cout << i << " ";
cout << endl;
cout << "层序遍历的结果为:" << endl;
int conlev = 0;//层数
vector<vector<int>>ret;
ret = bt.levelOrder(bt.root);
for (vector<int> i : ret)
{
cout << ++conlev << "层" << endl;
for (int j : i)
{
cout << j << " ";
}
cout << endl;
}
cout << "树的平衡因子为:";
cout << bt.diff(bt.root) << endl;
cout << endl;
}
样例原理图示:
结果展示:
参考代码C++ 平衡二叉树的创建_love music.的博客-CSDN博客
及北邮C++数据结构课本二叉搜索树部分
leetcode中序遍历与层序遍历