遍历二叉树——非递归遍历

“test.cpp”

<strong><span style="font-size:18px;">#include<iostream>
using namespace std;
#include<stack>
#include<queue>

template<class T>
struct BinaryTreeNode
{
T _data;
BinaryTreeNode<T>* _left;
BinaryTreeNode<T>* _right;

BinaryTreeNode(const T& data = T())
:_data(data)
,_left(NULL)
,_right(NULL)
{}
};

template<class T>
class BinaryTree
{
typedef BinaryTreeNode<T> Node;
public:
BinaryTree()
:_root(NULL)
{}
BinaryTree(const T* arr,size_t size,const T& invalid)
{
size_t index = 0;
_root = _GreateTree(arr,size,index,invalid);
}
~BinaryTree()
{
_Destory(_root);
}
BinaryTree(const BinaryTree<T>& bt)
{
_root = _Copy(bt._root);
}
BinaryTree& operator=(const BinaryTree<T>& bt)
{
if(this != &bt)
{
BinaryTree<T> bt2(bt);
swap(_root,bt2._root);
}
return *this;
}

void PrevOrder()
{
_PrevOrder(_root);
cout<<endl;
}
void InOrder()
{
_InOrder(_root);
cout<<endl;
}
void PostOrder()
{
_PostOrder(_root);
cout<<endl;
}
size_t Size()
{
size_t count = _Size(_root);
return count;
}
size_t Depth()
{
size_t depth = _Depth(_root);
return depth;
}
size_t LeafSize()
{
size_t count = _LeafSize(_root);
return count;
}
void PrevOrderNonR()//stack
{
stack<Node*> s;
Node* cur = _root;

while(cur || !s.empty())
{
while(cur)
{
cout<<cur->_data<<" ";
s.push(cur);
cur = cur->_left;
}

Node* top = s.top();
s.pop();
cur = top->_right;
}
cout<<endl;
}
void InOrderNonR()//stack
{
stack<Node*> s;
Node* cur = _root;

while(cur || !s.empty())
{
while(cur)
{
s.push(cur);
cur = cur->_left;
}

Node* top = s.top();
cout<<top->_data<<" ";
s.pop();
cur = top->_right;
}
cout<<endl;
}

void PostOrderNonR()//stack
{
stack<Node*> s;
Node* cur = _root;
Node* prev = NULL;

while(cur || !s.empty())
{
while(cur)
{
s.push(cur);
cur = cur->_left;
}

Node* top = s.top();
if(top->_right == NULL || top->_right == prev)
{
cout<<top->_data<<" ";
s.pop();
prev = top;
}
else
{
cur = top->_right;
}
}
cout<<endl;
}

void LayerOrderNonR()//queue
{
queue<Node*> q;
Node* cur = _root;
if(cur)
{
q.push(cur);
}

while(!q.empty())
{
Node* front = q.front();
cout<<front->_data<<" ";
q.pop();

if(front->_left)
{
q.push(front->_left);
}
if(front->_right)
{
q.push(front->_right);
}
}
cout<<endl;
}
protected:
size_t _LeafSize(Node* root)
{
size_t count = 0;

if(root->_left == NULL && root->_right == NULL)
{
count++;
return count;
}
if(root->_left)
{
count += _LeafSize(root->_left);
}
if(root->_right)
{
count += _LeafSize(root->_right);
}
return count;
}
size_t _Depth(Node* root)
{
if(root == NULL)
{
return 0;
}

size_t leftcount = _Depth(root->_left) + 1;
size_t rightcount = _Depth(root->_right) + 1;

return leftcount > rightcount ? leftcount : rightcount;
}
size_t _Size(Node* root)
{
if(root == NULL)
{
return 0;
}

return 1 + _Size(root->_left) + _Size(root->_right);
}
Node* _Copy(Node* root)
{
if(root == NULL)
{
return NULL;
}

//Node* cur = new Node(root);
_Copy(root->_left);
_Copy(root->_right);

return root;
}
void _Destory(Node* root)
{
if(root == NULL)
{
return;
}

Node* del = root;

_Destory(root->_left);
_Destory(root->_right);
delete del;
}
void _PostOrder(Node* root)
{
if(root == NULL)
{
return;
}

_PostOrder(root->_left);
_PostOrder(root->_right);
cout<<root->_data<<" ";
}
void _InOrder(Node* root)
{
if(root == NULL)
{
return;
}

_InOrder(root->_left);
cout<<root->_data<<" ";
_InOrder(root->_right);
}
void _PrevOrder(Node* root)
{
if(root == NULL)
{
return;
}

cout<<root->_data<<" ";
_PrevOrder(root->_left);
_PrevOrder(root->_right);
}
Node* _GreateTree(const T* arr,size_t size,size_t& index,const T& invalid)
{
Node* root = NULL;

if((index < size) && (arr[index] != invalid))
{
root = new Node(arr[index]);

root->_left = _GreateTree(arr,size,++index,invalid);
root->_right = _GreateTree(arr,size,++index,invalid);
}

return root;
}
private:
Node* _root;
};
void test()
{
int arr[10] = {1,2,3,'#','#',4,'#','#',5,6};
int size = sizeof(arr)/sizeof(arr[0]);

BinaryTree<int> bt(arr,size,'#');
bt.PrevOrder();
bt.PrevOrderNonR();
bt.InOrder();
bt.InOrderNonR();
bt.PostOrder();
bt.PostOrderNonR();
bt.LayerOrderNonR();
cout<<"size: "<<bt.Size()<<endl;
cout<<"depth: "<<bt.Depth()<<endl;
cout<<"leafsize: "<<bt.LeafSize()<<endl;

BinaryTree<int> bt2(bt);
bt2.PrevOrder();
bt2.PrevOrderNonR();

BinaryTree<int> bt3;
bt3 = bt;
bt3.PrevOrder();
bt3.PrevOrderNonR();
}
int main()
{
test();
return 0;
}
</span></strong>