数据结构-二叉树:C++模板类递归实现与非递归实现

C++模板类递归实现与非递归实现二叉树遍历

实现的功能: 

1.存储，2.前序遍历，3.中序遍历，4.后序遍历，5.层序遍历。

递归实现二叉树代码：

//二叉树-二叉链表-递归********************************************************************
//输入示范：
// A A
// B C :AB##C## B C :ABD##E##CF##G##
// D E F G

#include <iostream>

using namespace std;

#define NODE_NUM 1000

template <class DataType>
struct BiNode
{
DataType data;
BiNode<DataType> *lchild, *rchild;
};
template <class DataType>
class BiTree
{
public:
BiTree(){ root = Create(root); }
~BiTree(){ Release(root); }
void PreOrder(){ PreOrder(root); } //前序遍历
void InOrder(){ InOrder(root); } //中序遍历
void PostOrder(){ PostOrder(root); }//后序遍历
void LevelOrder(); //层次遍历
private:
BiNode <DataType> *root;
BiNode <DataType> *Q_tree[NODE_NUM];
int tree_front, tree_rear;
BiNode<DataType> *Create(BiNode<DataType>* bt);
void Release(BiNode<DataType>* bt);
void PreOrder(BiNode<DataType>* bt);
void InOrder(BiNode<DataType>* bt);
void PostOrder(BiNode<DataType>* bt);
};
template <class DataType>
void BiTree<DataType>::PreOrder(BiNode<DataType>* bt)//前序遍历
{

if (bt != NULL)
{
cout << bt->data<<" ";
PreOrder(bt->lchild);
PreOrder(bt->rchild);
}
}
template <class DataType>
void BiTree<DataType>::InOrder(BiNode<DataType>* bt)//中序遍历
{
if (bt == NULL)
return;
else
{
InOrder(bt->lchild);
cout << bt->data << " ";
InOrder(bt->rchild);
}
}
template <class DataType>
void BiTree<DataType>::PostOrder(BiNode<DataType>* bt)//后序遍历
{
if (bt == NULL)
return;
else
{
PostOrder(bt->lchild);
PostOrder(bt->rchild);
cout << bt->data << " ";
}
}
template <class DataType>
void BiTree<DataType>::LevelOrder()//层序遍历
{
BiNode<DataType> *q_node = (BiNode<DataType> *)malloc(sizeof(BiNode<DataType>));
BiNode<DataType> *qq = (BiNode<DataType> *)malloc(sizeof(BiNode<DataType>));
tree_front = tree_rear = -1;
if (root == NULL)
return;
Q_tree[++tree_rear] = root;//数组Q_tree中Q[0]存整个二叉树，Q[1]、Q[2]存第二层的子树，Q[3]、Q[4]存第三层子树，以此类推
while (tree_front != tree_rear)
{
q_node = Q_tree[++tree_front];
cout << q_node->data << " ";//按层显示该位置上子树的根节点，即层序遍历
if (q_node->lchild != NULL)
Q_tree[++tree_rear] = q_node->lchild;
if (q_node->rchild != NULL)
Q_tree[++tree_rear] = q_node->rchild;
}
}
template <class DataType>
BiNode<DataType>* BiTree<DataType>::Create(BiNode<DataType>* bt)//前序遍历生成二叉链表，如A的两个子节点BC，则输入应为AB##C##
{
DataType ch_tree;
cout << "请输入节点:";
cin >> ch_tree;
if (ch_tree == '#')
bt = NULL;

else
{
bt = new BiNode<DataType>;
bt->data = ch_tree;
bt->lchild = Create(bt->lchild);
bt->rchild = Create(bt->rchild);
}
return bt;
}
template <class DataType&
b983
gt;
void BiTree<DataType>::Release(BiNode<DataType>* bt)//释放内存
{
if (bt != NULL)
{
Release(bt->lchild);
Release(bt->rchild);
delete bt;
}
}
//主函数
int main()
{
BiTree<char> my_tree;
cout << "前序遍历:";
my_tree.PreOrder();
cout << endl;
cout << "中序遍历:";
my_tree.InOrder();
cout << endl;
cout << "后序遍历:";
my_tree.PostOrder();
cout << endl;
cout << "层序遍历:";
my_tree.LevelOrder();
cout << endl;
return 0;
}非递归实现二叉树代码：

//二叉树--非递归实现********************************************************************
//输入示范：
// A A
// B C :AB##C## B C :ABD##E##CF##G##
// D E F G

#include <iostream>
#include <queue>
#include<stack>
using namespace std;

template <class DataType>
struct BiNode
{
DataType data;
BiNode<DataType> *lchild, *rchild;
};
template <class DataType>
class BiTree
{
public:
BiTree(){ root = Create(root); } //生成二叉树
~BiTree(){ Release(root); } //释放内存
void PreOrder(){ PreOrder(root); } //前序遍历
void InOrder(){ InOrder(root); } //中序遍历
void PostOrder(){ PostOrder(root); } //后序遍历
void LevelOrder(){ LevelOrder(root); }//层次遍历

private:
BiNode <DataType> *root;
BiNode<DataType> *Create(BiNode<DataType>* bt);
void Release(BiNode<DataType>* bt);
void PreOrder(BiNode<DataType>* bt);
void InOrder(BiNode<DataType>* bt);
void PostOrder(BiNode<DataType>* bt);
void LevelOrder(BiNode<DataType>* bt);
};

template <class DataType>
void BiTree<DataType>::PreOrder(BiNode<DataType>* bt)//前序遍历
{
stack< BiNode<DataType> *> stack;
while (bt != NULL || !stack.empty())
{
while (bt != NULL)
{
cout << bt->data << " ";
stack.push(bt);
bt = bt->lchild;
}
if (!stack.empty())
{
bt = stack.top();
stack.pop();
bt = bt->rchild;
}
}
}
template <class DataType>
void BiTree<DataType>::InOrder(BiNode<DataType>* bt)//中序遍历
{
stack< BiNode<DataType> *> stack;
while (bt != NULL || !stack.empty())
{
while (bt != NULL)
{
stack.push(bt);
bt = bt->lchild;
}
if (!stack.empty())
{
bt = stack.top();
stack.pop();
cout << bt->data << " ";
bt = bt->rchild;
}
}
}
template<class DataType>
void BiTree<DataType>::PostOrder(BiNode<DataType>* bt)//后序遍历
{
//要保证根结点在左孩子和右孩子访问之后才能访问，
//因此对于任一结点P，先将其入栈。如果P不存在左孩子和右孩子，则可以直接访问它；
//或者P存在左孩子或者右孩子，但是其左孩子和右孩子都已被访问过了，则同样可以直接访问该结点。
//若非上述两种情况，则将P的右孩子和左孩子依次入栈，这样就保证了每次取栈顶元素的时候，
//左孩子在右孩子前面被访问，左孩子和右孩子都在根结点前面被访问。
if (bt == NULL)
return;
stack<BiNode<DataType>*> stack;
stack.push(bt);
BiNode<DataType>* pre = NULL;
BiNode<DataType>* cur;
while (!stack.empty())
{
cur = stack.top();
if (cur->lchild == NULL && cur->rchild == NULL ||
(pre != NULL) && (pre == cur->lchild || pre == cur->rchild))//上一次访问的是当前节点的左子树
{
cout << cur->data << " ";
stack.pop();
pre = cur;
}
else
{
if (cur->rchild)
stack.push(cur->rchild);
if (cur->lchild)
stack.push(cur->lchild);
}
}
}
template<class DataType>
void BiTree<DataType>::LevelOrder(BiNode<DataType>* bt)//层序遍历
{
//层次遍历需要queue来实现，思路：
//@1初始化queue
// if root为空 返回
//@2 push(root)
//@3 while(queue不为空)
// s <-- queue.front()
// queue.pop()
// 输入s.data
// if(s的左子树不空)
// s的左子树入队
// if(s的右子树不空)
// s的右子树入队

queue<BiNode<DataType>*> queue_q;
BiNode<DataType>* tree_s = bt;
if (tree_s == NULL)
return;
queue_q.push(tree_s);
while (!queue_q.empty())
{
tree_s = queue_q.front();
queue_q.pop();
cout << tree_s->data << " ";
if (tree_s->lchild)
queue_q.push(tree_s->lchild);
if (tree_s->rchild)
queue_q.push(tree_s->rchild);

}
}
template <class DataType>
BiNode<DataType>* BiTree<DataType>::Create(BiNode<DataType>* bt)//前序遍历生成二叉链表，如A的两个子节点BC，则输入应为AB##C##
{
DataType ch_tree;
cout << "请输入节点:";
cin >> ch_tree;
if (ch_tree == '#')
bt = NULL;

else
{
bt = new BiNode<DataType>;
bt->data = ch_tree;
bt->lchild = Create(bt->lchild);
bt->rchild = Create(bt->rchild);
}
return bt;
}
template <class DataType>
void BiTree<DataType>::Release(BiNode<DataType>* bt)//释放内存
{
if (bt != NULL)
{
Release(bt->lchild);
Release(bt->rchild);
delete bt;
}
}
//主函数
int main()
{
BiTree<char> my_tree;
cout << endl;
cout << "前序遍历:";
my_tree.PreOrder();
cout << endl;
cout << "中序遍历:";
my_tree.InOrder();
cout << endl;
cout << "后序遍历:";
my_tree.PostOrder();
cout << endl;
cout << "层序遍历:";
my_tree.LevelOrder();
cout << endl;
return 0;
}
参考博客：

http://blog.csdn.net/zhembrace/article/details/52974139