剑指offer系列（59）按之字形顺序打印二叉树

题目描述

请实现一个函数按照之字形打印二叉树，即第一行按照从左到右的顺序打印，第二层按照从右至左的顺序打印，第三行按照从左到右的顺序打印，其他行以此类推。

思路分析

队列方法：在剑指offer（60）题基础上，再加入一个判断层数奇偶的方法

代码大同小异 不多赘述

双栈法：奇数栈节点出栈时，偶数栈把该节点的左右子节点进栈（先左再右），由于先进后出的特点，偶数栈节点出栈是自然就是倒序的了。

             而偶数栈节点出栈时，奇数栈把该节点的左右子节点进栈（先右再左），由于先进后出的特点，奇数栈节点出栈是自然就是正序的了。

代码

队列写法

import java.util.ArrayList;
import java.util.Collections;
import java.util.LinkedList;
import java.util.Queue;


public class 按之字形顺序打印二叉树 {
	ArrayList<ArrayList<Integer> > Print(TreeNode pRoot) {
		ArrayList<ArrayList<Integer>> list = new ArrayList<ArrayList<Integer>>();
        if (pRoot == null){
        	return list;
        }
        Queue<TreeNode> queue = new LinkedList<TreeNode>();
        ArrayList<Integer> list1 = new ArrayList<Integer>();
        queue.offer(pRoot);
        int start = 0;  //当前层数已添加节点数
        int end = 1;   //当前层数目标添加节点数
        int count = 1; //记录当前层数
        while (!queue.isEmpty()){
        	TreeNode temp = queue.poll(); 
        	list1.add(temp.val);
        	start++;
        	if (temp.left != null) {
				queue.offer(temp.left);
			}
        	if (temp.right != null) {
				queue.offer(temp.right);
			}
        	if (start == end) {
				end = queue.size(); //本层的所有节点已出队，队列中所剩刚好是下一层的全部节点
				start = 0;
				list1 = judge(count, list1);
				list.add(list1);
				count++;
				list1 = new ArrayList<Integer>();
			}
        }
        return list;    		
    }
	public ArrayList<Integer> judge(int count,ArrayList<Integer> list1){
		if (count%2 == 1) {
			return list1;
		}
		else {
			Collections.reverse(list1);
			return list1;
		}
	}
	
	public class TreeNode {
	    int val = 0;
	    TreeNode left = null;
	    TreeNode right = null;
	    
	    public TreeNode(int val) {
	        this.val = val;
	    }
	}
}

结果

双栈法

public ArrayList<ArrayList<Integer> > Print(TreeNode pRoot) {
		int layer = 1;  //记录层数
		Stack<TreeNode> stack1 = new Stack<TreeNode>();
		Stack<TreeNode> stack2 = new Stack<TreeNode>();
		ArrayList<ArrayList<Integer>> list = new ArrayList<ArrayList<Integer>>();
		if (pRoot == null) {
			return list;
		}
		stack1.push(pRoot);
		while (!stack1.isEmpty() || !stack2.isEmpty()){
			if (layer%2 == 1) {
				ArrayList<Integer> list1 = new ArrayList<Integer>();
				while ( !stack1.isEmpty() ){
					TreeNode tempNode = stack1.pop();
					if (tempNode != null) {
						list1.add(tempNode.val);
						stack2.push(tempNode.left);
						stack2.push(tempNode.right);
					}
				}
				if ( !list1.isEmpty() ) {
					list.add(list1);
					layer++;
				}
			}
			else {
				ArrayList<Integer> list1 = new ArrayList<Integer>();
				while ( !stack2.isEmpty() ){
					TreeNode tempNode = stack2.pop();
					if (tempNode != null) {
						list1.add(tempNode.val);
						stack1.push(tempNode.right);
						stack1.push(tempNode.left);
					}
				}
				if ( !list1.isEmpty() ) {
					list.add(list1);
					layer++;
				}
			}
		}
		return list;
		
	}

结果