//============================================================================
//
// > File :
// > Author : flowertree
// > Time : 2016年4月24日
// > Algorithm : 二叉树的三种递归遍历和非递归
//
//============================================================================
#include <iostream>
#include <stdio.h>
#include <string.h>
#include <algorithm>
#include <queue>
#include <stack>
using namespace std;
//树节点
struct treenode
{
int value;
treenode * left;
treenode * right;
treenode()
{
this -> value = 0;
this -> left = NULL;
this -> right = NULL;
}
};
treenode n[10];
int nodepool = 1;
//获得树节点地址
treenode * getTreeNode()
{
return &n[nodepool++];
}
//创建树
treenode * initTree(treenode * head, int number)
{
queue<treenode *> q;
q.push(head);
treenode * temp;
while(number < 7)
{
temp = q.front();
q.pop();
treenode * a = getTreeNode();
a -> value = number++;
temp -> left = a;
q.push(a);
treenode * b = getTreeNode();
b ->value = number++;
temp -> right = b;
q.push(b);
}
return head;
}
//输出树
void printTree(treenode * head, int blank)
{
if(head == NULL)
return ;
for(int i = 0; i < blank; i++)
cout << ' ';
cout << head -> value << endl;
blank += 4;
printTree(head -> left, blank);
printTree(head -> right, blank);
}
//递归先序遍历
void prePrintTree(treenode * head)
{
if(head == NULL)
return ;
cout << head -> value << " ";
prePrintTree(head -> left);
prePrintTree(head -> right);
}
//递归中序遍历
void inPrintTree(treenode * head)
{
if(head == NULL)
return ;
inPrintTree(head -> left);
cout << head -> value << " ";
inPrintTree(head -> right);
}
//递归后序遍历
void posPrintTree(treenode * head)
{
if(head == NULL)
return ;
posPrintTree(head -> left);
posPrintTree(head -> right);
cout << head -> value << " ";
}
//非递归先序遍历(用栈,不能用队列)
void noRePrePrintTree(treenode * head)
{
stack<treenode *> p;
p.push(head);
treenode * temp;
while(!p.empty())
{
temp = p.top();
p.pop();
cout << temp -> value << " ";
if(temp -> right != NULL)
p.push(temp -> right);
if(temp -> left != NULL)
p.push(temp -> left);
}
}
//非递归中序遍历
void noReInPrintTree(treenode * head)
{
if(head == NULL)
return ;
stack<treenode *> p;
p.push(head);
treenode * temp = head;
while(!p.empty() || (temp != NULL))
{
if(temp != NULL)
{
p.push(temp -> left);
temp = temp -> left;
}
else
{
p.pop();
if(p.empty())
continue;
temp = p.top();
cout << temp -> value << " ";
p.pop();
p.push(temp -> right);
temp = temp -> right;
}
}
}
//非递归后序遍历(方式1:用两个栈)
void noRePosPrintTree1(treenode * head)
{
if(head == NULL)
return ;
stack<treenode *> p1;
stack<treenode *> p2;
p1.push(head);
while(!p1.empty())
{
treenode * temp = p1.top();
p1.pop();
p2.push(temp);
if(temp -> left != NULL)
{
p1.push(temp -> left);
}
if(temp -> right != NULL)
{
p1.push(temp -> right);
}
}
while(!p2.empty())
{
treenode * temp = p2.top();
p2.pop();
cout << temp -> value << " ";
}
}
//非递归后序遍历(方式2:用1个栈)
void noRePosPrintTree2(treenode * head)
{
if(head == NULL)
return ;
stack<treenode * > p;
treenode * last;
last = NULL;
treenode * now;
p.push(head);
while(!p.empty())
{
now = p.top();
if(now -> left != NULL && now -> left != last && now -> right != last)
{
p.push(now -> left);
}
else if(now -> right != NULL && now -> right != last)
{
p.push(now -> right);
}
else
{
cout << now -> value << " ";
last = now;
p.pop();
}
}
}
int main()
{
treenode head;
int number = 1;
//创建一个3层的满二叉树
treenode * h = initTree(&head, number);
int blank = 0;
//输出树
printTree(h, blank);
//递归先序遍历
cout << "递归先序遍历" << endl;
prePrintTree(h);
cout << endl;
//递归中序遍历
cout << "递归中序遍历" << endl;
inPrintTree(h);
cout << endl;
//递归后序遍历
cout << "递归后序遍历" << endl;
posPrintTree(h);
cout << endl;
//非递归先序遍历
cout << "非递归先序遍历" << endl;
noRePrePrintTree(h);
cout << endl;
//非递归中序遍历
cout << "非递归中序遍历" << endl;
noReInPrintTree(h);
cout << endl;
//非递归后序遍历方式1:用2个栈
cout << "非递归后序遍历1" << endl;
noRePosPrintTree1(h);
cout << endl;
//非递归后序遍历方式2:用1个栈
cout << "非递归后序遍历2" << endl;
noRePosPrintTree2(h);
cout << endl;
system("PAUSE");
return 0;
}
二叉树的遍历方式-递归与非递归
最新推荐文章于 2020-10-22 20:52:26 发布