二叉查找树

自己写的二叉查找树。练练手

#include <iomanip>
#include <iostream>
using namespace std;
template <typename Elem>
struct BTreeNode
{
Elem data;
BTreeNode<Elem>*leftchild;
BTreeNode<Elem>*rightchild;
BTreeNode<Elem>*parent;
BTreeNode():leftchild(nullptr),rightchild(nullptr),parent(nullptr)
{}
};
template <typename Elem>
class BTree
{
friend BTreeNode<Elem>;
private:
BTreeNode<Elem>*root;
static int m;
static int n;
void Create_theBTree(Elem data);
void PreOrder(BTreeNode<Elem>*p);
void InOrder(BTreeNode<Elem>*p);
void PostOrder(BTreeNode<Elem>*p);
void Clear(BTreeNode<Elem>*p);
public:
BTree();
~BTree();
void initial_theBTree(Elem);


int count_Leaf(BTreeNode<Elem>*p);
int count_Node(BTreeNode<Elem>*p);
int count_Depth(BTreeNode<Elem>*p);


void PreOrder_Traverse();
void InOrder_Traverse();
void PostOrder_Traverse();


BTreeNode<Elem>* Tree_Search(BTreeNode<Elem>*p,Elem data);
void BTreeNode_Insert(BTreeNode<Elem>*p,Elem data);
void BTreeNode_Delete(BTreeNode<Elem>*p,Elem data);


BTree<Elem>& operator=(const BTree<Elem>*A);
BTreeNode<Elem>* getRoot()
{
return root;
}
BTreeNode<Elem>* compare(BTreeNode<Elem>*p,Elem data);
};
template <typename Elem>
int BTree<Elem>::m=0;
template <typename Elem>
int BTree<Elem>::n=0;
template <typename Elem>
BTree<Elem>::BTree():root(nullptr){}
template <typename Elem>
BTree<Elem>::~BTree(){   clear(root);}
template <typename Elem>
void BTree<Elem>::Create_theBTree(Elem data)
{
BTreeNode_Insert(root,data);
}
template <typename Elem>
void BTree<Elem>::PreOrder(BTreeNode<Elem>*p)
{
if(p!=nullptr)
{
cout<<p->data<<" ";
PreOrder(p->leftchild);
PreOrder(p->rightchild);
}
}
template <typename Elem>
void BTree<Elem>::InOrder(BTreeNode<Elem>*p)
{
if(p!=nullptr)
{
InOrder(p->leftchild);
cout<<p->data<<" ";
InOrder(p->rightchild);
}
}
template <typename Elem>
void BTree<Elem>::PostOrder(BTreeNode<Elem>*p)
{
if(p!=nullptr)
{
PostOrder(p->leftchild);
PostOrder(p->rightchild);
cout<<p->data<<" ";
}
}
template <typename Elem>
void BTree<Elem>::Clear(BTreeNode<Elem>*p)
{
if(p!=nullptr)
{
BTreeNode<Elem> *del=p;
BTreeNode<Elem> *left=p->leftchild;
BTreeNode<Elem> *right=p->rightchild;
delete p;
Clear(left);
Clear(right);
}
}
template <typename Elem>
void BTree<Elem>::initial_theBTree(Elem EndTag)
{
cout<<"Please input the number into the Binary Tree"<<endl;
Elem number;
cout<<"Please input the value:";
cin>>number;
while(number!=EndTag)
{
Create_theBTree(number);
cout<<"Please input the value:";
cin>>number;
}
}
template <typename Elem>
void BTree<Elem>::PreOrder_Traverse()
{
PreOrder(root);
}
template <typename Elem>
void BTree<Elem>::InOrder_Traverse()
{
InOrder(root);
}
template <typename Elem>
void BTree<Elem>::PostOrder_Traverse()
{
PostOrder(root);
}
template <typename Elem>
int BTree<Elem>::count_Depth(BTreeNode<Elem>*ptr)
{
if (ptr == NULL) return 0;
else
{
return count_Depth(ptr->left) + count_Depth(ptr->right) + 1;
}
}
template <typename Elem>
int BTree<Elem>::count_Leaf(BTreeNode<Elem>*ptr)
{
if (ptr == NULL) return 0;
else
{
if (ptr->left == NULL&&ptr->left == NULL)
m = m + 1;
else
{
count_Leaf(ptr->left);
count_Leaf(ptr->right);
}
return m;
}
}
template <typename Elem>
int BTree<Elem>::count_Node(BTreeNode<Elem>*ptr)
{
if (ptr == NULL) return 0;
else
{
if (ptr->left != NULL&&ptr->right != NULL)
{
count_Node(ptr->left);
count_Node(ptr->right);
}
if (ptr->left == NULL&&ptr->right != NULL)
{
n = n + 1;
count_Node(ptr->right);
}
if (ptr->left != NULL&&ptr->right == NULL)
{
n = n + 1;
count_Node(ptr->left);
}
return n;
}
}
template <typename Elem>
BTreeNode<Elem>* BTree<Elem>::Tree_Search(BTreeNode<Elem>*p,Elem dat)
{
if(p!=nullptr)
{
if(p->data==dat)
return p;
else
{
Tree_Search(p->leftchild,dat);
Tree_Search(p->rightchild,dat);
}
}
}
template <typename Elem>
void BTree<Elem>::BTreeNode_Insert(BTreeNode<Elem>*p,Elem data)
{
BTreeNode<Elem> *back = new BTreeNode<Elem>;
BTreeNode<Elem> *current = p;
while (current!=NULL)
{
back = current;
if (current->data < x)
{
current = current->leftchild;
}
else
{
current = current->rightchild;
}
}
if (x>back->data)
{
back->leftchild = newnode;
newnode->parent=back;
}
else
{
back->rightchild = newnode;
newnode->parent=back;
}
}
template <typename Elem>
BTreeNode<Elem>* BTree<Elem>::compare(BTreeNode<Elem>*p,Elem dat)
{
if(p!=nullptr)
{
compare(p->leftchild,data);
if(p->data>dat)
return p->parent;
compare(p->rightchild,data);
}
if(p==nullptr)
{
cout<<"Could not found the node!"<<endl;
exit(0);
}
}
template <typename Elem>
void BTree<Elem>::BTreeNode_Insert(BTreeNode<Elem>*p,int dat)
{
if(p!=nullptr)
{
BTreeNode<Elem>*current=compare(p,data);
BTreeNode<Elem>*newnode=new BTreeNode<Elem>;
newnode->data=dat;
current->leftchild=newnode;
newnode->leftchild=current->leftchild->leftchild;
newnode->parent=current;
current->leftchild->leftchild->parent=newnode;
}
}
template <typename Elem>
void BTree<Elem>::BTreeNode_Delete(BTreeNode<Elem>*p,int data)
{
if(p!=nullptr)
{
BTreeNode<Elem>*current=compare(p,data);
BTreeNode<Elem>*del=current->leftchild;
if(del->rightchild!=nullptr)
Clear(del->rightchild);
current->leftchild->leftchild->parent=current;
current->leftchild->parent->leftchild=current->leftchild->leftchild;
delete del;
}
}
int main()
{
cout<<"Please create a binary tree:"<<endl;
cout<<"Please input the endTag:";
int endTag;
cin>>endTag;
BTree<int> Lemonda;
Lemonda.initial_theBTree(endTag);
cout<<"PreOrder:"<<endl;
Lemonda.PreOrder_Traverse();
cout<<endl;
cout<<"InOrder:"<<endl;
Lemonda.InOrder_Traverse();
cout<<endl;
cout<<"PostOrder:"<<endl;
Lemonda.PostOrder_Traverse();
cout<<endl;
cout<<"The depth of the tree is:"<<Lemonda.count_Depth(Lemonda.getRoot())<<endl;
cout<<"Please input the data to delete:";
int data;cin>>data;
Lemonda.BTreeNode_Delete(Lemonda.getRoot(),data);
cout<<"InOrder:"<<endl;
Lemonda.InOrder_Traverse();
cout<<endl;

system ("pause");
return 0;




}

没有注释