Java/C++利用队列实现二叉树的后序遍历

利用队列实现二叉树的后序遍历

首先我们有必要先来了解一下两种数据结构（栈和队列）以及它们的区别和应用

栈

栈是一种只能在一端进行插入和删除操作的特殊线性表。它按照后进先出的原则存储数据，先进入的数据被压入栈底，最后的数据在栈顶，需要读数据的时候从栈顶开始弹出数据（最后一个数据被第一个读出来）。栈具有记忆作用，对栈的插入与删除操作中，不需要改变栈底指针。

队列

队列是一种特殊的线性表，特殊之处在于它只允许在表的前端（front）进行删除操作，而在表的后端（rear）进行插入操作，和栈一样，队列是一种操作受限制的线性表。进行插入操作的端称为队尾，进行删除操作的端称为队头。队列中没有元素时，称为空队列。队列按照先进先出的原则存储数据。

深度优先搜索（DFS）与 广度优先搜索（BFS）

对于这两个搜索算法，在这里就不多说了，有兴趣自己去了解。

值得一提的是，在树的遍历当中，先序遍历，中序遍历，后序遍历都是属于深度优先，层次遍历是广度优先。而对于深度优先通常我们使用辅助栈，广度优先使用辅助队列。至于为什么，大家了解了这两种搜索应该就能明白。

如何实现

那么重点来了，为什么我们要去用队列实现本该用栈实现的后序遍历呢？
我也不知道，可是有些选题就是会让你做这个事儿。
其实用队列实现后序遍历的关键就是用队列实现栈，那这应该怎么实现呢？
其实也很简单，我们只需要让队列具有栈的特点即可，即我们需要从队尾取、移除元素。

具体实现

将队尾元素之前的元素，全部依次移除并循环加入队尾，这样原来的队尾元素就变成了队首。
给大家打个形象的比喻，就好比有10个人排队去即兴说唱，前面的9个人都比较紧张没有准备好，于是轮到他时他就跑到队伍末尾去，让后面一个人先上，直到原本排在最后的那个人胆子比较大，上台表演（出队）。重复这个过程，就能循环取出队尾元素。

代码（Java）：

import java.util.LinkedList;
import java.util.Queue;
import java.util.Scanner;
import java.util.Stack;

/*
利用队列实现后序遍历
    -->利用队列实现栈
 */
//ABDH00R00EJ00K00CFL00M00GN00O00
public class QueueToStark {

    //栈存放迭代版的最终结果并逆序输出
    public static Stack<Character> stack = new Stack<>();

    public static void main(String[] args) {
        QueueToStark queueToStark = new QueueToStark();

        System.out.print("请按先序遍历的顺序输入一个二叉树，空值用‘0’代替：");
        Scanner in = new Scanner(System.in);

        //StingBuffer 操作字符串
        StringBuffer sb = new StringBuffer(in.next());

        //构建二叉树
        BinNode root = queueToStark.creat_tree(sb);

        System.out.println("用队列实现后序遍历，迭代版：");
        queueToStark.traPostIt(root);

        System.out.println("\n" + "用队列实现后序遍历，递归版：");
        queueToStark.traPostRe(root);
    }

    //构建二叉树
    public BinNode creat_tree(StringBuffer sb){
        char c = sb.charAt(0);

        //当前节点
        BinNode root = null;

        //创建二叉树
        if (c == '0'){
            sb.deleteCharAt(0);  //转到下一个节点
            return null;
        }else {
            root = new BinNode(c);
            sb.deleteCharAt(0);
            root.leftChild = creat_tree(sb); //递归深入，构造左子树
            root.rightChild = creat_tree(sb); //构造右子树
            return root;
        }

    }

    /*
    后序遍历递归版
     */
    public void traPostRe(BinNode root){
        //如果节点为空，就返回
        if (root == null){
            return;
        }
        traPostRe(root.leftChild);
        traPostRe(root.rightChild);
        visit(root);
    }

    //访问节点
    public void visit(BinNode root){
        System.out.print(root.data + " ");
    }

    public void itVisit(BinNode root){
        stack.push(root.data);
    }

    //深入访问
    public Queue<BinNode> visitBranch(BinNode root,Queue<BinNode> q ){
        while (root != null){
            itVisit(root);
            q.add(root.leftChild);   //左孩子入队
            root = root.rightChild;  //深入右子树
        }
        return q;
    }


    /*
    后序遍历迭代版
     */
    public void traPostIt(BinNode root){
        Queue<BinNode> queue = new LinkedList<>();
        while (true){
            visitBranch(root,queue);

            //若队中没有元素，就跳出
            if (queue.isEmpty()){
                break;
            }

            root = getQueueLastAndDel(queue);  //获得队尾元素、并移除该元素
        }

        //输出结果
        int n = stack.size();
        for (int i = 0;i < n;i++){
            System.out.print(stack.pop() + " ");
        }

    }

    //获取、并删除队中最后一个元素---->即用 队列 实现 栈的pop操作
    public BinNode getQueueLastAndDel(Queue<BinNode> queue){
        for (int i = 1;i < queue.size();i++){
            queue.add(queue.remove());
        }
        BinNode last = queue.element();
        queue.remove();
        return last;
    }
}

//二叉树
class BinNode {
    char data;//节点值
    BinNode leftChild, rightChild; //左右孩子

    public BinNode(char data){
        this.data = data;
    }

}

#include<iostream>
#include<queue>
using namespace std;

typedef struct BinNode     
{
	char data;           //数值
	BinNode *rc;         //右孩子
	BinNode *lc;         //左孩子
}*Node;

void conver(queue<Node> &s)   //队列逆序转换取出队尾
{
	int n;
	n=s.size();
	for(int i=1;i<n;i++)
	{
		s.push(s.front());
		s.pop();
	}
	s.pop();
}

void creat_tree(Node &rt)      //构建二叉树
{
	char ch;
	ch = getchar();
	if ('0' == ch)
	{
		rt = NULL;
	}
	else 
	{
		rt = new BinNode;
		rt->data = ch;
		creat_tree(rt->lc);     //构建左子树    
		creat_tree(rt->rc);     //构建右子树
	}
}

static queue<char> t;           //静态全局队列，用于逆序输出
void visit(Node x)              //访问储存值
{
	t.push(x->data);
}

void visit_1(Node x)            //访问输出
{
	cout<<x->data<<" ";
}

static void visitBranch(Node x,queue<Node> &s)    //深入访问
{
	while(x)
	{
		visit(x);
		s.push(x->lc);       //左孩子入队
		x=x->rc;             //深入右子树
	}
}

void travPostIt(Node x)   //后序遍历迭代版
{
   queue<Node> s;
    while(true)
	{
	   visitBranch(x,s);
	   if(s.empty()) break;
	   x=s.back();
	   conver(s);
	}
}

void travPostRe(Node x)//后序遍历递归版
{
	if(!x)
		return;
	travPostRe(x->lc);
	travPostRe(x->rc);
	visit_1(x);
}

void print(queue<char> &t) //队列逆序输出
{
	while(t.size())
	{
		int n;
	    n=t.size();
	    for(int i=1;i<n;i++)
		{
		   t.push(t.front());
		   t.pop();
		}
	    cout<<t.front()<<" ";
	    t.pop();
	}
}

int main()
{
	BinNode *root = NULL;               //根节点
	cout << "Please enter the binary in pre-order,Null values are represented by '0':" << endl;
	creat_tree(root);        //创建二叉树
	travPostIt(root);
	cout<<"Post-order traversal of the iteration version:\n";
	print(t);
	cout<<endl;
	cout<<"Post-order traversal of the recursive version:\n";
	travPostRe(root);
	cout<<endl;
    return 0;
}

注：

分享一个有趣的事情，对二叉树的镜像使用先序遍历得到的结果，就是后序遍历结果的逆序。我在做一个课程设计时发现的，当时还粗鄙的给取了一个名字叫倒序遍历。。。
以上代码迭代版正是用此算法，至于正经的原版的后序遍历大家自己可以实现一下。