【算法导论】二叉查找树的操作C++实现

本代码为算法导论第12章中，伪代码的C++实现：

#include <iostream>
#include <vector>
using namespace std;
/*二叉查找树结构*/
typedef struct BSTree
{
int node_value;
struct BSTree * left;
struct BSTree * right;
struct BSTree * parent;
}Tree;
Tree * root = NULL;
/*****构造二叉查找树**********************************************/
void CreateBSTree(Tree * root,int node_value);
Tree * CreateBSTree(int * array_list,int array_length);
void Print(Tree* root);
/***************************************************************/
int Minimum(Tree * p);
Tree * TreeMinimum(Tree * root);
int Maximum(Tree * p);
Tree * TreeMaximum(Tree * root);
Tree * FindNode(Tree * root,int node_value);
Tree * Successor(Tree * root);
Tree * PredeSuccessor(Tree * p);
bool DeleteTreeNode(Tree * root,int node_value);
bool DeleteTreeNode(Tree * n);
/***************************************************************/
int main(int argc,char * argv[])
{
//int list[]={5,3,4,9,1,7,11};
int list[]={15,5,16,3,12,20,10,13,18,23,6,7};
root = CreateBSTree(list,12);
std::cout<<"Cearte BSTree."<<std::endl;
//Print(root);
//std::cout<<Successor(FindNode(root,4))->node_value;
//Print(root);
//std::cout<<std::endl;
//DeleteTreeNode(root,15);
//Print(root);
Tree * t = FindNode(root,18);
std::cout<<PredeSuccessor(t)->node_value;
getchar();
return 0;
}
/*找出树中的最小节点
p数的根节点
*/
int Minimum(Tree * p)
{
Tree * t = TreeMinimum(p);
if(t != NULL)
{
return t->node_value ;
}
else
{
return -1;
}
}
Tree * TreeMinimum(Tree * p)
{
if(p->left == NULL)
{
return p;
}
TreeMinimum(p->left);
}
/*找出树中的最大节点*/
int Maximum(Tree * p)
{
Tree * t = TreeMaximum(root);
if(t != NULL)
{
return t->node_value ;
}
else
{
return -1;
}
}
Tree * TreeMaximum(Tree * p)
{
if(p->right == NULL)
{
return p;
}
TreeMaximum(p->right);
}
/*假定所有的节点值都不相同，找到一个节点的指针
p树的根节点，
node_value要查找的节点的值
*/
Tree * FindNode(Tree * p,int node_value)
{
if(p == NULL)
{
return NULL;/*递归返回标志*/
}
if(p->node_value == node_value)
{
return p;
}
if(p->node_value < node_value)
{
FindNode(p->right, node_value);
}
else
{
FindNode(p->left, node_value);
}
}
/*找出一个节点的后继结点*/
Tree * Successor(Tree * p)
{
if(p == NULL)
{
return NULL;
}
if(p->right != NULL)
{
return TreeMinimum(p->right);
}
Tree * t = p->parent ;
while((t != NULL) && (p == t->right))
{
p = t;
t = t->parent ;
}
return t;
}
/*找到一个节点的前驱节点
p为节点的指针
*/
Tree * PredeSuccessor(Tree * p)
{
if(p == NULL)
{
return NULL;
}
else if(p->left != NULL)
{/*如果左子树不为空，则前驱为其左子树的最大值节点*/
return TreeMaximum(p->left);
}
else
{
Tree * t = p->parent ;
while((t != NULL) && (p == t->left))
{/*注意节点t的方向，这个与寻找后继节点相反*/
p = t;
t = t->parent;
}
return t;
}
}
/*删除一个节点
p为树根节点指针
node_value要删除的节点的值
*/
bool DeleteTreeNode(Tree * p,int node_value)
{
Tree * t = FindNode(p,node_value);
if(t == NULL)
{
return false;
}
if((t->left == NULL)&&(t->right == NULL))
{/*没有子节点*/
Tree* tmp = t;
if(tmp->parent->left == tmp)
{
tmp->parent->left = NULL;
}
else
{
tmp->parent->right = NULL;
}
delete tmp;
tmp = NULL;
}
else if((t->left == NULL)||(t->right == NULL))
{/*一个子节点*/
Tree* tmp = t;
if(tmp->parent->left == tmp)
{
tmp->parent->left = (tmp->left ==NULL)?tmp->right :tmp->left;
}
else
{
tmp->parent->right = (tmp->left ==NULL)?tmp->right :tmp->left;
}
delete tmp;
tmp = NULL;
}
else
{/*两个子节点*/
Tree* s = Successor(t);
if(s == NULL)
{
return false;
}
t->node_value = s->node_value ;
DeleteTreeNode(s);
}
}
/*删除一个节点
p为树根节点指针
*/
bool DeleteTreeNode(Tree * n)
{
if(n == NULL)
{
return NULL;
}
else if((n->left == NULL)&&(n->right == NULL))
{/*没有子节点*/
Tree* tmp = n;
if(tmp->parent->left == tmp)
{
tmp->parent->left = NULL;
}
else
{
tmp->parent->right = NULL;
}
delete tmp;
tmp = NULL;
}
else if((n->left == NULL)||(n->right == NULL))
{/*一个子节点*/
Tree* tmp = n;
if(tmp->parent->left == tmp)
{
tmp->parent->left = (tmp->left ==NULL)?tmp->right :tmp->left;
}
else
{
tmp->parent->right = (tmp->left ==NULL)?tmp->right :tmp->left;
}
delete tmp;
tmp = NULL;
}
else
{/*两个子节点*/
Tree* s = Successor(n);
if(s == NULL)
{
return false;
}
n->node_value = s->node_value ;
DeleteTreeNode(s);
}
}
/*生成二叉查找树*/
Tree * CreateBSTree(int * array_list,int array_length)
{
if(array_length <= 0)
{
return false;
}
Tree * root = NULL;
root = new BSTree();
root->left = NULL;
root->right = NULL;
root->parent = NULL;
root->node_value = array_list[0];
for(int i=1;i<array_length;i++)
{
CreateBSTree(root,array_list[i]);
}
return root;
}
void CreateBSTree(Tree * root,int node_value)
{
if(root == NULL)
{
return ;
}
if(root->node_value > node_value)
{
if(root->left == NULL)
{
Tree * node = new Tree();
node->left = NULL;
node->right = NULL;
node->node_value = node_value;
node->parent = root;
root->left = node;
}
else
{
CreateBSTree(root->left,node_value);
}
}
else
{
if(root->right == NULL)
{
Tree * node = new Tree();
node->left = NULL;
node->right = NULL;
node->node_value = node_value;
node->parent = root;
root->right = node;
}
else
{
CreateBSTree(root->right,node_value);
}
}
}
/*中序排序输出二叉查找树*/
void Print(Tree* root)
{
if(root == NULL)
{
return ;
}
Print(root->left);
std::cout<<root->node_value<<"\t";
Print(root->right);
}

【算法导论】二叉查找树的操作C++实现

mal

相关推荐

python实现二叉查找树

数据结构--二叉查找树

数据结构与算法之美_25_红黑树（上）：为什么工程中都用红黑树这种二叉树？

看懂这篇文章，玩转二叉查找树

《深入浅出话数据结构》系列之什么是B树、B+树？为什么二叉查找树不行？

LeetCode 二叉查找树（BST)

Mysql索引——B-Tree/B+Tree架构

MySQL索引-B+树（看完你就明白了）

查找算法——二叉查找树

数据结构-二叉树和二叉查找树

JavaScript实现简单二叉查找树

AVL平衡二叉树详解与实现

JavaScript数据结构之二叉查找树的定义与表示方法

数据结构之二叉查找树Java实现源码及注释

js代码实现二叉查找树的算法

二叉查找树解析及其C++实现

python实现二叉查找树实例代码

AVL树-自平衡二叉查找树(Java实现)

为什么MySQL数据库索引选择使用B+树?

浅谈AVL树,红黑树,B树,B+树原理及应用

算法：二叉查找树进阶[TEMP]

算法：二叉查找树进阶