#include <iostream>
#include <stack>
#include <queue>
using namespace std;
//a b d # g # # # c e # # f h # # #
//树结点
struct TreeNode
{
TreeNode* lChild;
char data;
TreeNode* rChild;
};
//二叉树类
class BinaryTree
{
public:
BinaryTree()
{
this->root = NULL;
}
void createBinaryTree(TreeNode* &t) //先序序列创建二叉树
{
char value;
cin >> value;
if (value != '#')
{
t = new TreeNode;
t->data = value;
createBinaryTree(t->lChild);
createBinaryTree(t->rChild);
}
else
{
t = NULL;
return;
}
}
void preOrder01(TreeNode* t) //先序遍历(运用递归算法)
{
if (t != NULL)
{
cout << t->data << " ";
preOrder01(t->lChild);
preOrder01(t->rChild);
}
}
void preOrder02() //非递归先序遍历 (应用栈)
{
stack<TreeNode*>stk;
TreeNode* t = this->root;
while (t != NULL || !stk.empty())
{
if (t != NULL)
{
cout << t->data << " ";
stk.push(t);
t = t->lChild;
}
else
{
t = stk.top();
stk.pop();
t = t->rChild;
}
}
}
void inOrder01(TreeNode* t) //中序遍历(运用递归算法)
{
if (t != NULL)
{
inOrder01(t->lChild);
cout << t->data << " ";
inOrder01(t->rChild);
}
}
void inOrder02() //非递归中序遍历(应用栈)
{
stack<TreeNode*>stk;
TreeNode* t = this->root;
while (t != NULL || !stk.empty())
{
if (t != NULL)
{
stk.push(t);
t = t->lChild;
}
else
{
t = stk.top();
cout << t->data << " ";
stk.pop();
t = t->rChild;
}
}
}
void postOrder(TreeNode* t) //后序遍历(运用递归算法)
{
if (t != NULL)
{
postOrder(t->lChild);
postOrder(t->rChild);
cout << t->data << " ";
}
}
void levelOrder() //层次遍历(应用队列)
{
queue<TreeNode*>q;
TreeNode* t = this->root;
q.push(t);
while (!q.empty())
{
t = q.front();
cout << t->data << " ";
q.pop();
if (t->lChild != NULL) { q.push(t->lChild); }
if (t->rChild != NULL) { q.push(t->rChild); }
}
}
void copyTree(TreeNode* &oldT, TreeNode* &newT) //复制二叉树
{
if (oldT != NULL)
{
newT = new TreeNode;
newT->data = oldT->data;
copyTree(oldT->lChild, newT->lChild);
copyTree(oldT->rChild, newT->rChild);
}
else
{
newT = NULL;
return;
}
}
int getDepth(TreeNode* t) //获得二叉树深度
{
if (t != NULL) { return max(getDepth(t->lChild), getDepth(t->rChild)) + 1; }
else { return 0; }
}
int nodeCount(TreeNode* t) //获得结点个数
{
if (t != NULL) { return nodeCount(t->lChild) + nodeCount(t->rChild) + 1; }
else { return 0; }
}
int LeafCount(TreeNode* &t) //获得叶子结点个数
{
if (t == NULL) { return 0; }
if (t->lChild == NULL && t->rChild == NULL)
{
return 1;
}
else if(t->lChild != NULL || t->rChild != NULL)
{
return LeafCount(t->lChild) + LeafCount(t->rChild);
}
}
public:
TreeNode* root; //指向根结点的指针
};
int main() {
BinaryTree bt;
bt.createBinaryTree(bt.root);
cout << "---------------遍历--------------" << endl;
cout << "递归先序遍历:";
bt.preOrder01(bt.root);
cout << endl;
cout << "非递归先序遍历:";
bt.preOrder02();
cout << endl;
cout << "递归中序遍历:";
bt.inOrder01(bt.root);
cout << endl;
cout << "非递归中序遍历:";
bt.inOrder02();
cout << endl;
cout << "递归后序遍历:";
bt.postOrder(bt.root);
cout << endl;
cout << "层次遍历:";
bt.levelOrder();
cout << endl;
cout << "------------复制二叉树-----------" << endl;
BinaryTree bt02;
bt02.copyTree(bt.root, bt02.root);
cout << "先序遍历新树:";
bt02.preOrder01(bt02.root);
cout << endl;
cout << "----------获得二叉树深度----------" << endl;
cout << "树的深度:" << bt.getDepth(bt.root) << endl;
cout << "-----------获得结点个数-----------" << endl;
cout << "结点个数:" << bt.nodeCount(bt.root) << endl;
cout << "---------获得叶子结点个数---------" << endl;
cout << "叶子结点个数:" << bt.LeafCount(bt.root) << endl;
system("pause");
return 0;
}
结果如下: