二叉树的基本操作C++

二叉树实现

1.创建二叉树

2.递归输出二叉树

2.1递归先序输出

2.2递归中序输出

2.3递归后序输出

3.非递归输出

3.1非递归先序输出

3.2非递归中序输出

3.3非递归后序输出

4.层次遍历二叉树

5.求树高

6.求树叶子节点

7.按值查找对应节点，输出左孩子结点值和右孩子结点值

8.计算所有节点数

/*
二叉树实现
1.创建二叉树
2.递归输出二叉树
2.1递归先序输出
2.2递归中序输出
2.3递归后序输出
3.非递归输出
3.1非递归先序输出
3.2非递归中序输出
3.3非递归后序输出
4.层次遍历二叉树
5.求树高
6.求树叶子节点
7.按值查找对应节点，输出左孩子结点值和右孩子结点值
8.计算所有节点数
*/
#include<iostream>
#include<string>
#include<stack>
#include<deque>
#include<fstream>
using namespace std;

//const int MAX_N = 100;
//数据节点
class Node
{
public:
char data;//数据
class Node *lchild;//左节点
class Node *rchild;//右节点
};

//二叉树
class Tree
{
public:
Tree(){}
~Tree(){}

//构建二叉树
void Create(string name)
{
ifstream readfile;
string str;
readfile.open(name);
if (readfile.is_open())
{
getline(readfile, str);//读取一行
}
readfile.close();
CreateNode(str);//构建二叉树
}

//先序遍历非递归算法
void Disp()
{
if (t == NULL)
{
return;
}
stack<Node *> m_stack;//定义栈
m_stack.push(t);
while (!m_stack.empty())
{
Node *p = m_stack.top();//赋值一份当前双亲节点
cout << p->data << ends;
m_stack.pop();
if (p->rchild)//先存储右子树，确保先输出左子树
{
m_stack.push(p->rchild);
}
if (p->lchild)//后存储左子树
{
m_stack.push(p->lchild);
}
}

}

//非递归中序遍历二叉树
void DispMid()
{
if (t == NULL)
{
return;
}
Node *p = t;
stack<Node *>m_stack;
while (p != NULL || !m_stack.empty())
{
while (p != NULL)//一路直走至左下角
{
m_stack.push(p);
p = p->lchild;
}
if (!m_stack.empty())
{
p = m_stack.top();//备份当前栈顶地址
m_stack.pop();
cout << p->data << ends;
p = p->rchild;
}
}
}

//非递归后序遍历二叉树
void DispBehid()
{
if (t == NULL)
{
return;
}
Node *pre = NULL, *p = t;
stack<Node *>m_stack;
while (p != NULL || !m_stack.empty())
{
while (p != NULL)//一路直走至左下角
{
m_stack.push(p);
p = p->lchild;
}
p = m_stack.top();
//右子树为空或者已访问，输出当前节点
if (p->rchild == NULL || p->rchild == pre)
{
cout << p->data << ends;
pre = p;//将当前结点地址赋值pre作为下一次判断标志，防止重复访问
m_stack.pop();
p = NULL;//p赋值空以便访问右子树
}
else
{
p = p->rchild;//访问子树的右子树
}
}
}

//层次遍历
void level_display()
{
if (t == NULL)
{
return;
}
deque<Node *>m_qu;//定义队列
m_qu.push_back(t);//树根入队列
while (!m_qu.empty())
{
Node *p = m_qu.front();//拷贝当前对头
cout <<p->data << ends;//输出
m_qu.pop_front();
if (p->lchild)//左孩子入队列
{
m_qu.push_back(p->lchild);
}
if (p->rchild)//右孩子入队列
{
m_qu.push_back(p->rchild);
}
}
}

//递归先序遍历输出二叉树
void display()
{
cout << "递归先序：";
output(t);
cout << endl;
}

//递归中序遍历输出二叉树
void displayMid()
{
cout << "递归中序:";
outputMid(t);
cout << endl;
}

//递归后序遍历输出二叉树
void displayBhind()
{
cout << "递归后序";
outputBhind(t);
cout << endl;
}
//二叉树高度
void Height()
{
int height = get_height(t);
cout << "Height: " << height << endl;
}

//输出叶子节点值
void display_leaf()
{
cout << "Leaves: ";
output_leaf(t);
cout << endl;
}

//查找二叉树中值data域为elem的节点
void find_node(char elem)
{
Node *res = NULL;
res = find_node(t, elem, res);
if (res != NULL)
{
cout << "nice." << endl;
if (res->lchild)
{
cout << "left child:";
cout << leftchild(res)->data << endl;
}
if (res->rchild)
{
cout << "right child:";
cout << rightchild(res)->data << endl;
}
}
else
{
cout << "NO." << endl;
}
}

//计算节点数
void nodes_count()
{
int sum;
if (t == NULL)//若为空，则0个节点
{
sum = 0;
}
else
{
sum = node_count(t);
cout << "Total Nodes:" << sum + 1 << endl;
}
}
private:
Node *t;

//构建二叉树
void CreateNode(string str)
{
stack<Node *> m_stack;
Node *p;
int k;
while (str.length() != 0)
{
//若当前为'('，将双亲节点推入栈，下一位存储的p值作为左节点处理
if (str[0] == '(')
{
m_stack.push(p); k = 1;
}
//为右括号则栈顶退出一位
else if (str[0] == ')')
{
m_stack.pop();
}
//为','，则下一个字符作右节点处理
else if (str[0] == ',')
{
k = 2;
}
//存储值用作双亲结点
else
{
p = (Node *)malloc(sizeof(Node));
p->data = str[0];
p->lchild = p->rchild = NULL;
//树根为空时，将第一个节点作为树根并赋值给私有成员变量
if (t == NULL)
{
t = p;
}
//树根不为空
else
{
if (k == 1)//作为左节点处理，将栈中双亲节点的左指针指向当前节点
{
m_stack.top()->lchild = p;
}
else//作为右节点处理
{
m_stack.top()->rchild = p;
}
}
}
//重构串，除去首字符，并将串长度减小1
str.assign(str.substr(1, str.length() - 1));
}
}

//递归先序遍历输出二叉树
void output(Node *t)
{
if (t != NULL)//当树根不为空时
{
cout << t->data;//输出
if (t->lchild != NULL || t->rchild != NULL)//左/右结点不为空时递归到下一层
{
cout << "(";
output(t->lchild);
if (t->rchild != NULL)//当左节点遍历结束后，左节点递归返回一层，递归右节点
{
cout << ",";
}
output(t->rchild);
cout << ")";
}
}
}

//递归中序遍历二叉树
void outputMid(Node *t)
{
if (t == NULL)//空则返回
{
return;
}
else
{
cout << "(";
outputMid(t->lchild);//递归左孩子节点
if (t->rchild != NULL)
{
cout << ",";
}
cout << t->data;//输出
outputMid(t->rchild);//递归右孩子结点
cout << ")";
}
}

//递归后序遍历输出二叉树
void outputBhind(Node *t)
{
if (!t)//空则返回
{
return;
}
else
{
cout << "(";
outputBhind(t->lchild);//递归左孩子节点
if (t->rchild != NULL)
{
cout << ",";
}
outputBhind(t->rchild);//递归右孩子结点
cout << t->data;//输出
cout << ")";
}
}
//求树高
int get_height(Node *t)
{
int leftheight, rightheight;
if (t == NULL)//递归至不存在子节点时返回0
{
return 0;
}
else
{
leftheight = get_height(t->lchild);//递归求左子树高度
rightheight = get_height(t->rchild);//递归其右子树高度
return leftheight > rightheight ? leftheight+1 : rightheight+1;//递归返回时返回最大值
}
}

//查找左节点
Node *leftchild(Node *p)
{
return p->lchild;
}

//查找右节点
Node *rightchild(Node *p)
{
return p->rchild;
}

//输出叶子节点
void output_leaf(Node *t)
{
if (t != NULL)//树根不为空时
{
//当前节点没有子节点时输出节点数据
if (t->lchild == NULL&&t->rchild == NULL)
{
cout << t->data << ends;
}
output_leaf(t->lchild);//递归左子树
output_leaf(t->rchild);//递归右子树
}
}

//查找二叉树中值data域为elem的节点

Node * find_node(Node *t, char elem, Node *res = NULL)
{
//Node *res = NULL;
if (t == NULL)//若当前节点为空，则返回结束
{
return NULL;
}
else
{
if (t->data == elem)//若找到值，返回地址
{
//res = t;
return t;
}
else
{
if (res == NULL)//若保存结果的指针不为空，则递归查找左节点
{
res = find_node(t->lchild, elem, res);
}
if (res == NULL)//若保存结果的指针不为空，且左节点为搜索到，则递归查找右节点
{
res = find_node(t->rchild, elem, res);
}
}
return res;
}
}

//计算节点数
int node_count(Node *t)
{
int lcount = 0, rcount = 0;
if (t == NULL)//空则返回
{
return 0;
}
else
{
if (t->lchild != NULL)//遍历左孩子节点
{
lcount = node_count(t->lchild);
lcount += 1;
}
if (t->rchild != NULL)//遍历右孩子节点
{
rcount = node_count(t->rchild);
rcount += 1;
}
return lcount + rcount;//返回当前左右孩子节点数
}
}
};

int main()
{
Tree m_tree;
m_tree.Create("data");
m_tree.display();//递归先序输出
m_tree.displayMid();//递归中序输出
m_tree.displayBhind();//递归后序输出
m_tree.Height();//树高
m_tree.display_leaf();//叶子节点
cout << "非递归先序:";
//cout << "Fir:";
m_tree.Disp();//非递归先序遍历
cout << endl;
cout << "非递归中序:";
//cout << "Mid:";
m_tree.DispMid();//非递归中序遍历
cout << endl;
cout << "非递归后序:";
//cout << "Bac:";
m_tree.DispBehid();//非递归后序遍历
cout << endl;
cout << "层次遍历:";
m_tree.level_display();//层次遍历
cout << endl;
cout << "Input element:";
char elem;
cin >> elem;
m_tree.find_node(elem);//按节点值查找
m_tree.nodes_count();//计算节点数
return 0;
}

测试结果