第5章 树和二叉树(4)

3. 后序遍历(LRD)

C++ Codes:

template<class T>
class Tree
{
public:
	TreeNode<T> *Root;
	Tree(TreeNode<T> *root)
	{
		this->Root=root;
	}
	void LevelOrder()
	{
		Tree<T>::LevelOrder2(this->Root);
		//Tree<T>::LevelOrder1(this->Root);
	}
private:
	//递归后序遍历
	static void LevelOrder1(TreeNode<T> *current_node)
	{
		if(current_node->Left!=0)
		{
			LevelOrder1(current_node->Left);
		}
		if(current_node->Right!=0)
		{
			LevelOrder1(current_node->Right);
		}
		cout<<current_node->Value<<endl;
	}
	//非递归后序遍历
	static void LevelOrder2(TreeNode<T> *current_node)
	{
		//SeqStack为一个栈，1000为其最大容量
		SeqStack<TreeNode<T>*> stack1=SeqStack<TreeNode<T>*>(1000);
		SeqStack<TreeNode<T>*> stack2=SeqStack<TreeNode<T>*>(1000);
		stack1.Push(current_node);
		while(!stack1.IsEmpty())
		{
			current_node=stack1.Pop();
			if(current_node->Left!=0)
			{
				stack1.Push(current_node->Left);
			}
			if(current_node->Right!=0)
			{
				stack1.Push(current_node->Right);
			}
			stack2.Push(current_node);
		}
		while(!stack2.IsEmpty())
		{
			cout<<stack2.Pop()->Value<<endl;
		}
	}
};

    TreeNode<int> *node1=new TreeNode<int>(0,0,1);
	TreeNode<int> *node2=new TreeNode<int>(0,0,2);
	TreeNode<int> *node3=new TreeNode<int>(node1,node2,3);
	TreeNode<int> *node4=new TreeNode<int>(0,0,4);
	TreeNode<int> *node5=new TreeNode<int>(0,0,5);
	TreeNode<int> *node6=new TreeNode<int>(node3,node4,6);
	TreeNode<int> *node7=new TreeNode<int>(node5,node6,7);
	TreeNode<int> *node8=new TreeNode<int>(0,0,8);
	TreeNode<int> *node9=new TreeNode<int>(0,0,9);
	TreeNode<int> *node10=new TreeNode<int>(node8,node9,10);
	TreeNode<int> *node11=new TreeNode<int>(node10,0,11);
	TreeNode<int> *node12=new TreeNode<int>(node7,node11,12);
	Tree<int> *tree=new Tree<int>(node12);
	tree->LevelOrder();

Python Codes:

from LinkStack_LinkQueue import LinkStack
from Queue import Queue

class TreeNode:
    def __init__(self,left=0,right=0,value=0):
        self.Left=left
        self.Right=right
        self.Value=value

class Tree:
    def __init__(self,root):
        self.Root=root 
    def LevelOrder(self):
        #Tree.__LevelOrder2(self.Root)
        Tree.__LevelOrder1(self.Root)           
    @staticmethod
    def __LevelOrder1(current_node):
        if current_node.Left!=0:
            Tree.__LevelOrder1(current_node.Left)
        if current_node.Right!=0:
            Tree.__LevelOrder1(current_node.Right)
        print current_node.Value
    @staticmethod
    def __LevelOrder2(current_node):
        stack=LinkStack()
        queue=LinkStack()
        queue.Push(current_node)
        while not queue.IsEmpty():
            current_node=queue.Pop()
            if not current_node.Left==0:
                queue.Push(current_node.Left)
            if not current_node.Right==0:
                queue.Push(current_node.Right)
            stack.Push(current_node)
        while not stack.IsEmpty():
            print stack.Pop().Value

from Tree import Tree,TreeNode

node1=TreeNode(value=1)
node2=TreeNode(node1,0,2)
node3=TreeNode(value=3)
node4=TreeNode(value=4)
node5=TreeNode(node3,node4,5)
node6=TreeNode(node2,node5,6)
node7=TreeNode(node6,0,7)
node8=TreeNode(value=8)
root=TreeNode(node7,node8,10)
tree=Tree(root)
tree.LevelOrder()