二叉排序树节点的删除(C++,算法导论),前中后序遍历(递归/非递归,栈实现),按层次遍历(队列实现)

由于代码中包含了二叉树，栈，队列三种结构的实现，为了文件结构更清晰，我会列出各文件名以及它们各自所实现的功能。

栈和队列只是为二叉树而创建的，所以它们的头文件只是实现了最基本的函数，如压栈，出栈，入队列，出队列，获取节点元素……

二叉树实现了节点插入和删除，数据搜索按照算法导论一书而来；先序，中序，后序的递归和非递归算法，非递归算法使用栈实现；按层次遍历用队列实现。

栈，队列和二叉树均采用了类模板，而栈和队列的节点当中存放的是二叉树的节点，所以如果你想看懂下面的代码，最好知道类模板的用法。在完成这些代码之前，我对类模板还停留在一知半解的层面，但是完成了它们之后，才逐渐明白了一些类模板的妙处。

栈的实现头文件：Stack.h

#ifndef STACK_H_INCLUDED
#define STACK_H_INCLUDED
#include <iostream>
using namespace std;
template<class T>
struct Stack_Node
{
T Date;
Stack_Node* Next_Node;
Stack_Node(T  date=0)
{
Date=date;
Next_Node=NULL;
}
};
template<class T>
class Stack
{
int Node_Count;
Stack_Node<T>* Top_Point;
public:
Stack(int node_count=0)
{
Node_Count=node_count;
Top_Point=NULL;
}
~Stack()
{
Clear_Stack();
}
Stack_Node<T>* Get_Top()
{
return Top_Point;
}
int Get_Node_count()
{
return Node_Count;
}
void Print_Stack()//从栈顶开始输出，测试所用函数
{
Stack_Node<T>*p=Top_Point;
while(p!=NULL)
{//如果不是系统定义类型，比如类，下句cout则无法输出。
cout<<p->Date<<"  ";
if(p->Next_Node==NULL)  return;
p=p->Next_Node;
}
}
void  Push_Stack_Node(T date)//节点入栈顶
{
Stack_Node<T>*p=new Stack_Node<T>(date);
p->Next_Node=Top_Point;
Top_Point=p;
Node_Count++;
}
bool Popup_Stack_Node()//弹出栈顶节点
{
if(Node_Count<=0)  return false;
Stack_Node<T>*p=Top_Point;
Top_Point=Top_Point->Next_Node;
delete p;
Node_Count--;
}
T Get_Top_Date()//获取栈顶元素
{
return Top_Point->Date;
}
void Clear_Stack()//清空栈
{
for(int i=1; i<=Node_Count; i++)
{
Stack_Node<T>*p=Top_Point;
Top_Point=Top_Point->Next_Node;
delete p;
}
Node_Count=0;
}
};

#endif // STACK_H_INCLUDED

队列的实现：Queue.h

#ifndef QUEUE_H_INCLUDED
#define QUEUE_H_INCLUDED
#include <iostream>
using namespace std;
template<class T>
struct Queue_Node
{
T Date;
Queue_Node* Next_Node;
Queue_Node(T  date=0)
{
Date=date;
Next_Node=NULL;
}
};
template<class T>
class Queue
{
int Node_Count;
Queue_Node<T>* Head_Point;
Queue_Node<T>* Tail_Point;
public:
Queue(int node_count=0)
{
Node_Count=node_count;
Head_Point=NULL;
Tail_Point=NULL;
}
~Queue()
{
Clear_Queue();
}
Queue_Node<T>* Get_Head()
{
return Head_Point;
}
T Get_Head_Date()
{
return Head_Point->Date;
}
int Get_Node_count()
{
return Node_Count;
}
void Print_Queue()//队列的输出
{
Queue_Node<T>*p=Head_Point;
while(p!=NULL)
{
cout<<p->Date<<"  ";
if(p->Next_Node==NULL)  return;
p=p->Next_Node;
}
}
void  Push_Queue_Node(T date)//队列尾部插入元素
{

Queue_Node<T>*p=new Queue_Node<T>(date);
if(Node_Count==0)
{
Head_Point=p;
Tail_Point=p;
Node_Count++;
return;
}
Tail_Point->Next_Node=p;
Tail_Point=Tail_Point->Next_Node;
Node_Count++;
}
bool Popup_Queue_Node()//队列头部插入元素
{
if(Node_Count<=0)  return false;
Queue_Node<T>*p=Head_Point;
Head_Point=Head_Point->Next_Node;
delete p;
Node_Count--;
}
void Clear_Queue()//清空队列
{
for(int i=1; i<=Node_Count; i++)
{
Queue_Node<T>*p=Head_Point;
Head_Point=Head_Point->Next_Node;
delete p;
}
Node_Count=0;
}
};
#endif // QUEUE_H_INCLUDED

二叉树的实现：Bnary_Trees.h

#ifndef BINARY_TREES_H_INCLUDED
#define BINARY_TREES_H_INCLUDED
#include <iostream>
#include"Stack.h"
#include"Queue.h"
using namespace std;
template<class T>
struct Trees_node
{
T Date;
Trees_node* Left_Children;
Trees_node* Right_Children;
Trees_node(T date=0)
{
Date=date;
Left_Children=NULL;
Right_Children=NULL;
}
};
template<class T>
class Binary_Trees
{
Trees_node<T>  *Root_Point;
public:
Binary_Trees(T date=0)
{
Root_Point=new Trees_node<T>(date);
}
Trees_node<T> * Get_Root()
{
return Root_Point;
}
T Get_Date(Trees_node<T> *node)
{
return node->Date;
}
//获得子二叉树的最小值的指针
Trees_node<T>* Get_Minimum(Trees_node<T>* p)
{
while(p->Left_Children!=NULL)
{
p=p->Left_Children;
}
return p;
}
//获得子二叉树的最大值的指针
Trees_node<T>* Get_Maximum(Trees_node<T>* p)
{
while(p->Right_Children!=NULL)
{
p=p->Right_Children;
}
return p;
}
//先序遍历递归算法
void Pre_Print_Trees_Re(Trees_node<T> *node)
{
if(node)
{
cout<<node->Date<<"  ";
Pre_Print_Trees_Re(node->Left_Children);
Pre_Print_Trees_Re(node->Right_Children);
}
}
//先序遍历非递归算法，栈实现
void Pre_Print_Trees()
{
Trees_node<T>*p=Root_Point;
Stack<Trees_node<int>*>  Pre;
while(p!=NULL||Pre.Get_Node_count())
{
if(p!=NULL)
{
cout<<p->Date<<"  ";
Pre.Push_Stack_Node(p);
p=p->Left_Children;
}
else
{
p=Pre.Get_Top_Date();
Pre.Popup_Stack_Node();
p=p->Right_Children;
}
}
}
//中序遍历递归算法
void In_Print_Trees_Re(Trees_node<T> *root_node)
{
if(root_node)
{
In_Print_Trees_Re(root_node->Left_Children);
cout<<root_node->Date<<"  ";
In_Print_Trees_Re(root_node->Right_Children);
}
}
//中序遍历非递归算法，栈实现
void In_Print_Trees()
{
Trees_node<T>*p=Root_Point;
Stack<Trees_node<int>*>  In;
while(p!=NULL||In.Get_Node_count())
{
if(p!=NULL)
{
In.Push_Stack_Node(p);
p=p->Left_Children;
}
else
{
p=In.Get_Top_Date();
In.Popup_Stack_Node();
cout<<p->Date<<"  ";
p=p->Right_Children;
}

}
}
//后序遍历递归算法
void Post_Print_Trees_Re(Trees_node<T> *root_node)
{
if(root_node)
{
In_Print_Trees_Re(root_node->Left_Children);
In_Print_Trees_Re(root_node->Right_Children);
cout<<root_node->Date<<"  ";
}
}
//后序遍历非递归算法，栈实现
void Post_Print_Trees()
{
Stack<Trees_node<int>*>  Post,Read;
Post.Push_Stack_Node(Root_Point);
while (Post.Get_Node_count())
{
Trees_node<T> *p = Post.Get_Top_Date();
Post.Popup_Stack_Node();
Read.Push_Stack_Node(p);//逆序压入栈中
if (p->Left_Children) Post.Push_Stack_Node(p->Left_Children);
if (p->Right_Children) Post.Push_Stack_Node(p->Right_Children);
}
while(Read.Get_Node_count())
{
cout<<Get_Date(Read.Get_Top_Date())<<"   ";
Read.Popup_Stack_Node();
}
}
//按层次遍历，队列实现
void  Layer_Print_Trees()
{
if (Root_Point == NULL) return ;

Trees_node<T> *p = Root_Point;
Queue<Trees_node<T> *> Layer;
Layer.Push_Queue_Node(p);
while(Layer.Get_Node_count())
{
p=Layer.Get_Head_Date();
Layer.Popup_Queue_Node();
cout<<p->Date<<"  ";
if (p->Left_Children) Layer.Push_Queue_Node(p->Left_Children);
if (p->Right_Children) Layer.Push_Queue_Node(p->Right_Children);
}
}
//搜索数据的递归方法
Trees_node<T>* Search_Node_Re(Trees_node<T> *root_node,T date)
{
if(root_node==NULL||root_node->Date==date)
return  root_node;
if(date<root_node->Date)    return  Search_Node(root_node->Left_Children,date);
else   return  Search_Node(root_node->Right_Children,date);
}
//搜索数据的非递归方法
Trees_node<T>* Search_Node(Trees_node<T> *root_node,T date)
{//如果没有找到节点，返回空的指针，可以用于bool判断
while(root_node!=NULL&&root_node->Date!=date)
{
if(date<root_node->Date)  root_node=root_node->Left_Children;
else  root_node=root_node->Right_Children;
}
return root_node;
}
bool Insert_Node(T date)
{
Trees_node<T> *q,*p,*r;
p=new Trees_node<T>(date);
q=NULL;
r=Root_Point;
while(r!=NULL)
{
q=r;
if(date<r->Date) r=r->Left_Children;
else if(date>r->Date) r=r->Right_Children;
else//if(date=r->Date)
return false;
}
if(q==NULL) Root_Point=p;
else if(date<q->Date)  q->Left_Children=p;
else q->Right_Children=p;
return true;
}
//删除节点的辅助函数
void Trans_Plant(Trees_node<T> *delete_parent,Trees_node<T> *delete_node,Trees_node<T> * replace_node)
{
if(delete_parent==NULL)  Root_Point=replace_node;
else if(delete_node==delete_parent->Left_Children)
delete_parent->Left_Children=replace_node;
else //if(delete_node==delete_parent->Right_Children)
delete_parent->Right_Children=replace_node;

}
//删除节点是根据算法导论而写，四种情况的分析
bool  Delete_Node(T date)
{
Trees_node<T> *delete_parent=NULL;
Trees_node<T> *delete_node=Root_Point;
Trees_node<T> *replace_parent;
Trees_node<T> *replace_node;
while(delete_node!=NULL&&delete_node->Date!=date)//查找删除节点以及它的双亲节点
{

delete_parent=delete_node;
if(date<delete_node->Date)  delete_node=delete_node->Left_Children;
else  delete_node=delete_node->Right_Children;
}
if(!delete_node)  return false;//如果没有该节点，返回Error

if(delete_node->Left_Children==NULL)//处理了两种情况，无孩子和只有右孩子
Trans_Plant(delete_parent,delete_node,delete_node->Right_Children);
else if(delete_node->Right_Children==NULL)//处理只有左孩子的情况
Trans_Plant(delete_parent,delete_node,delete_node->Left_Children);
else   //if(delete_node->Left_Children!=NULL&&delete_node->Left_Children!=NULL)
{//处理有左右孩子的情况
replace_node=delete_node->Right_Children;
replace_parent=delete_node;
while(replace_node->Left_Children!=NULL)//代替被删除节点只能是它的前驱节点或者后继节点，
{          //这儿查找它的后继节点作为替补，前驱和后继指的是中序遍历的前后节点
replace_parent=replace_node;
replace_node=replace_node->Left_Children;
}
if(delete_node!=replace_parent)  //替换节点不是删除节点的孩子节点
{
Trans_Plant(delete_parent,replace_node,replace_node->Right_Children);
replace_node->Right_Children=delete_node->Right_Children;
}
Trans_Plant(delete_parent,delete_node,replace_node);
replace_node->Left_Children=delete_node->Left_Children;
}
return  true;
}
};

#endif // BINARY_TREES_H_INCLUDED

测试文件如下：main.cpp

#include <iostream>
#include"Binary_Trees.h"
using namespace std;
int main()
{
cout<<"二叉树的测试如下："<<endl<<endl;
Binary_Trees< int> Test(5);
Test.Insert_Node(4);
Test.Insert_Node(6);
Test.Insert_Node(9);
Test.Insert_Node(7);
Test.Insert_Node(8);
Test.Insert_Node(2);
Test.Insert_Node(9);
Test.Insert_Node(10);
Test.Insert_Node(3);
Test.Insert_Node(1);
Test.Layer_Print_Trees();
cout<<endl;
if(Test.Search_Node(Test.Get_Root(),3))
{
cout<<"Find!";
}
else
{
cout<<"Not Find!";
}
cout<<Test.Get_Date(Test.Get_Maximum(Test.Get_Root()));
cout<<endl;
Test.Delete_Node(1);
//  Test.In_Print_Trees_Re(Test.Get_Root());
cout<<endl;
cout<<Test.Get_Date(Test.Get_Root());
cout<<endl;
cout<<"栈的测试如下："<<endl<<endl;
Stack<int> Test1;
Test1.Push_Stack_Node(1);
Test1.Push_Stack_Node(2);
Test1.Push_Stack_Node(4);
Test1.Print_Stack();
cout<<endl;
Test1.Popup_Stack_Node();
//  Test1.Popup_Stack_Node();
//  Test1.Popup_Stack_Node();
//Test1.Clear_Stack();
cout<<Test1.Get_Top_Date();
Test1.Print_Stack();
cout<<endl;
cout<<"队列的测试如下："<<endl<<endl;
Queue<int> Test2;
Test2.Push_Queue_Node(5);
Test2.Push_Queue_Node(8);
Test2.Push_Queue_Node(9);
Test2.Print_Queue();
cout<<endl;
Test2.Popup_Queue_Node();
//  Test2.Print_Queue();
//  Test2.Clear_Queue();
Test2.Push_Queue_Node(8);
Test2.Push_Queue_Node(5);
Test2.Push_Queue_Node(8);
Test2.Push_Queue_Node(9);
//   Test2.Clear_Queue();
Test2.Print_Queue();
cout<<endl;
return 0;
}