二叉树遍历（非递归版）

在数据量较小时，和递归版本的时间是差不多的，额因为还没有去看算法的那个计算时间复杂度和空间复杂度的东西，所以对那个不懂，只能用最直观的测试时间来判断速度

文件"trees.h"

#include<iostream>
using namespace std;

template<class T>
class My_stack;

template<class T>
class Node		//结点类
{
private:
	T data;
	Node<T> *next;
public:
	Node()
	{
		next=NULL;
	}
	Node(T d)
	{
		data=d;
		next=NULL;
	}
	friend My_stack<T>;
};

template<class T>
class My_stack
{
private:
	Node<T> *head;
public:
	My_stack()
	{
		head=new Node<T>();
	}

	bool empty() const
	{
		return (head->next==0);
	}

	void push(T d)	//入栈
	{
		Node<T> *p=new Node<T>(d);
		p->next=head->next;
		head->next=p;
	}

	T top()	//返回栈顶元素
	{
		if(empty())
		{
			cout<<"stack is empty."<<endl;
			exit(1);
		}
		Node<T> *p=head->next;
		T temp=p->data;
		return temp;
	}

	void pop()	//弹出栈顶元素
	{
		Node<T> *p=head->next;
		head->next=p->next;
		delete p;
	}

};


class BinTree;

class BinNode
{
private:
	int data;
	int tag;//用于作为是否为第一次入栈的标志
	BinNode *lchild;
	BinNode *rchild;
	friend class BinTree;
};

class BinTree
{
private:
	BinNode *root;

public:
	BinTree()
	{
		root=0;
	}

	BinNode *Get_Root()
	{
		return root;
	}

	BinNode *Create_Tree(BinNode *r)	//先序建立二叉树
	{
		int d;
		cout<<"输入数据(0代表空)：";
		cin>>d;
		if(d==0)
			return NULL;
		else
		{
			r=new BinNode;
			r->data=d;
			r->lchild=Create_Tree(r->lchild);
			r->rchild=Create_Tree(r->rchild);
		}
		root=r;
		return r;
	}

	bool _empty()
	{
		return (root==0);
	}

	void PreOrder_rec(BinNode *r)	//先序遍历
	{
		My_stack<BinNode *> s;
		BinNode *p=r;
		while(p || !s.empty())
		{
			if(p)
			{
				cout<<p->data<<"  ";
				s.push(p);
				p=p->lchild;
			}
			else
			{
				p=s.top();
				s.pop();
				p=p->rchild;
			}
		}
	}

	void InOrder_rec(BinNode *r)	//中序遍历
	{
		My_stack<BinNode *> s;
		BinNode *p;
		p=r;
		while(p || !s.empty())
		{
			if(p)
			{
				s.push(p);
				p=p->lchild;
			}
			else
			{
				p=s.top();
				s.pop();
				cout<<p->data<<"  ";
				p=p->rchild;
			}
		}
	}

	void PostOrder_rec(BinNode *r) //后序遍历
	{
		My_stack<BinNode *> s;
		BinNode *p=r;
		do
		{
			if(p)
			{
				p->tag=0;
				s.push(p);
				p=p->lchild;
			}
			else
			{
				p=s.top();
				s.pop();
				if(p->tag==0)
				{
					p->tag=1;
					s.push(p);
					p=p->rchild;
				}
				else
				{
					cout<<p->data<<"  ";
					p=NULL;
				}
			}
		}while(p || !s.empty());
	}

	int Leaf_rec(BinNode *r)	//计算叶子结点数目
	{
		My_stack<BinNode *> s;
		int sum=0;
		if(!r)
			return 0;
		else
		{
			s.push(r);
			do
			{
				r=s.top();
				s.pop();
				if(r->lchild==0 && r->rchild==0)
					sum=sum+1;
				else
				{
					if(r->lchild)
						s.push(r->lchild);
					if(r->rchild)
						s.push(r->rchild);
				}
			}while(!s.empty());
		}
		return sum;
	}

};

测试函数"main.cpp"

#include"trees.h"
#include<time.h>

int main()
{
	BinTree tree;
	BinNode *p=tree.Get_Root();
	p=tree.Create_Tree(p);

	if(!tree._empty())
		cout<<"二叉树不空"<<endl;
	
	clock_t star=clock(),end(0);
	cout<<"先序遍历二叉树：";
	tree.PreOrder_rec(p);
	cout<<endl;

	cout<<"中序遍历二叉树：";
	tree.InOrder_rec(p);
	cout<<endl;

	cout<<"后序遍历二叉树：";
	tree.PostOrder_rec(p);
	cout<<endl;
	end=clock();
	cout<<"这段代码运行时间为："<<(double)(end-star)<<"ms"<<endl;
	
	cout<<"二叉树叶子节点数为："<<tree.Leaf_rec(p)<<endl;

	return 0;
}

输入和上一篇文章的是一样的，下面是输出结果

输入数据(0代表空)：5
输入数据(0代表空)：3
输入数据(0代表空)：2
输入数据(0代表空)：1
输入数据(0代表空)：0
输入数据(0代表空)：0
输入数据(0代表空)：0
输入数据(0代表空)：4
输入数据(0代表空)：0
输入数据(0代表空)：0
输入数据(0代表空)：8
输入数据(0代表空)：6
输入数据(0代表空)：0
输入数据(0代表空)：7
输入数据(0代表空)：0
输入数据(0代表空)：0
输入数据(0代表空)：9
输入数据(0代表空)：0
输入数据(0代表空)：0
二叉树不空
先序遍历二叉树：5  3  2  1  4  8  6  7  9
中序遍历二叉树：1  2  3  4  5  6  7  8  9
后序遍历二叉树：1  2  4  3  7  6  9  8  5
这段代码运行时间为：20ms
二叉树叶子节点数为：4
Press any key to continue