# 二叉树的非递归遍历

526人阅读 评论(0)
#ifndef __BINARYTREE_H__
#define __BINARYTREE_H__

#include <iostream>
#include <stack>
#include <queue>

using namespace std;

template <class Elem>
class BinaryTree
{
public:
BinaryTree();
void prevCreateTree();     //按先序序列创建二叉树
void prevOrderTraverse();  //先序遍历二叉树
void inOrderTraverse();    //中序遍历二叉树
void postOrderTraverse();  //后序遍历二叉树
void levelOrderTraverse(); //层序遍历二叉树
void setFlag(Elem f);
const Elem &getFlag() const;

private:
struct BiTreeNode
{
Elem elem;
struct BiTreeNode *lChild;
struct BiTreeNode *rChild;
BiTreeNode(Elem e)
:elem(e), lChild(NULL), rChild(NULL)
{
}
};

BiTreeNode *root;
Elem flag;                 //在创建二叉树时要有一个标记来表示创建到叶子结点了

void prevCreateTree(BiTreeNode *&root, const Elem &flag); //按先序序列创建二叉树
void prevOrderTraverse(BiTreeNode *root);                 //先序遍历二叉树
void inOrderTraverse(BiTreeNode *root);                   //中序遍历二叉树
void postOrderTraverse(BiTreeNode *root);                 //后序遍历二叉树
void levelOrderTraverse(BiTreeNode *root);                //层序遍历二叉树
};

template <class Elem>
BinaryTree<Elem>::BinaryTree()
:root(NULL)
{
}

template <class Elem>
void BinaryTree<Elem>::prevCreateTree()
{
prevCreateTree(root, getFlag());
}

template <class Elem>
void BinaryTree<Elem>::prevOrderTraverse()
{
prevOrderTraverse(root);
}

template <class Elem>
void BinaryTree<Elem>::inOrderTraverse()
{
inOrderTraverse(root);
}

template <class Elem>
void BinaryTree<Elem>::postOrderTraverse()
{
postOrderTraverse(root);
}

template <class Elem>
void BinaryTree<Elem>::levelOrderTraverse()
{
levelOrderTraverse(root);
}

template <class Elem>
void BinaryTree<Elem>::setFlag(Elem f)
{
flag = f;
}

template <class Elem>
const Elem &BinaryTree<Elem>::getFlag() const
{
return flag;
}

template <class Elem>
void BinaryTree<Elem>::prevCreateTree(BiTreeNode *&root, const Elem &flag)
{
Elem e;
if(cin >> e && e != flag)
{
BiTreeNode *node = new BiTreeNode(e);
root = node;
prevCreateTree(root->lChild, flag);
prevCreateTree(root->rChild, flag);
}
}

template <class Elem>
void BinaryTree<Elem>::prevOrderTraverse(BiTreeNode *root)
{
stack<BiTreeNode*> treeStack;
if(root == NULL)
{
return ;
}
else
{
treeStack.push(root);          //根结点入栈
}

while(!treeStack.empty())
{
BiTreeNode *topNode = treeStack.top();
cout << topNode->elem << endl; //遍历栈顶元素
treeStack.pop();               //栈顶元素出栈
if(topNode->rChild != NULL)    //右孩子入栈
{
treeStack.push(topNode->rChild);
}
if(topNode->lChild != NULL)    //左孩子入栈
{
treeStack.push(topNode->lChild);
}
}
}

template <class Elem>
void BinaryTree<Elem>::inOrderTraverse(BiTreeNode *root)
{
stack<BiTreeNode*> treeStack;
BiTreeNode *tempNode = NULL;

if(root == NULL)
{
return ;
}
else
{
treeStack.push(root);         //根结点入栈
tempNode = root->lChild;      //标记左孩子
}

while(!treeStack.empty() || tempNode != NULL)
{
if(tempNode != NULL)
{
treeStack.push(tempNode);    //如果左孩子不为空，入栈
tempNode = tempNode->lChild; //再次标记左孩子
}
else
{
//如果左孩子为空，则遍历栈顶元素，然后遍历右子树
BiTreeNode *topNode = treeStack.top();
cout << topNode->elem << endl;
treeStack.pop();
tempNode = topNode->rChild;
}
}
}

template <class Elem>
void BinaryTree<Elem>::postOrderTraverse(BiTreeNode *root)
{
//正在学习ing...
}

template <class Elem>
void BinaryTree<Elem>::levelOrderTraverse(BiTreeNode *root)
{
queue<BiTreeNode*> treeQueue;
if(root == NULL)
{
return ;
}
else
{
treeQueue.push(root);
}

while(!treeQueue.empty())
{
BiTreeNode *frontNode = treeQueue.front();
cout << frontNode->elem << endl;
treeQueue.pop();
if(frontNode->lChild != NULL)
{
treeQueue.push(frontNode->lChild);
}
if(frontNode->rChild != NULL)
{
treeQueue.push(frontNode->rChild);
}
}
}
#endif

0
0

* 以上用户言论只代表其个人观点，不代表CSDN网站的观点或立场
个人资料
• 访问：26830次
• 积分：500
• 等级：
• 排名：千里之外
• 原创：21篇
• 转载：0篇
• 译文：0篇
• 评论：0条
文章存档