算法題之二叉樹的鋸齒形層次遍歷

 

題目描述：給出一棵二叉樹，返回其節點值的鋸齒形層次遍歷（先從左往右，下一層再從右往左，層與層之間交替進行）

解題思路：

1）這里可以先使用第一個棧來保存二叉樹第一層掃描的結果，然后彈出結點，

2）接着按左右子節點存入第二個棧；接着依次彈出第二個棧結點，按着右左子節點存入第一個棧；

3）依照上面步驟依次處理二叉樹結點，直到二叉樹結點處理完

 

package com.wc.tree;
//樹結構
public class TreeNode {
    TreeNode left;
    TreeNode right;
    
    int value;
    
    public TreeNode(int v)
    {
        this.value = v;
    }

    public TreeNode getLeft() {
        return left;
    }

    public void setLeft(TreeNode left) {
        this.left = left;
    }

    public TreeNode getRight() {
        return right;
    }

    public void setRight(TreeNode right) {
        this.right = right;
    }
}

package com.wc.tree;
import java.util.LinkedList;
import java.util.List;
import java.util.Stack;

public class Tree {
    //掃描方法
    public static List<Integer> scanTree(TreeNode root)
    {
        if(root == null)
            return null;
        
        List<Integer> list = new LinkedList<>();
        
        //判斷輸出是否反轉
        boolean isReverse = false;
        
        
        //保存從左到右輸出二叉樹結點
        Stack<TreeNode> stack = new Stack<>();
        
        //保存從右到左輸出二叉樹結點
        Stack<TreeNode> stackTwo = new Stack<>();
        
        stack.push(root);
        while(!stack.isEmpty() || 
              !stackTwo.isEmpty())
        {
            if(!isReverse)
            {
                System.out.print("[");
                while(!stack.isEmpty())
                {
                    TreeNode scanNode = stack.pop();
                    
                    System.out.print(scanNode.value + " ");
                    list.add(scanNode.value);
                    
                    //存入第二個棧
                    if(scanNode.left != null)
                        stackTwo.push(scanNode.left);
                    if(scanNode.right != null)
                        stackTwo.push(scanNode.right);
                }
                System.out.println("],");
                isReverse = true;
            }
            else
            {
                
                System.out.print("[");
                while(!stackTwo.isEmpty())
                {
                    TreeNode scanNode = stackTwo.pop();
                    System.out.print(scanNode.value + " ");

                    list.add(scanNode.value);
                    
                    //存入第一個棧
                    if(scanNode.right != null)
                        stack.push(scanNode.right);
                    if(scanNode.left != null)
                        stack.push(scanNode.left);
                }
                System.out.println("],");
                isReverse = false;
            }
        }
        
        return list;
    }

}

package com.wc.test;

import static org.junit.Assert.*;

import java.util.ArrayList;
import java.util.List;

import org.junit.After;
import org.junit.Before;
import org.junit.Test;

import com.wc.tree.Tree;
import com.wc.tree.TreeNode;
//測試代碼
public class TreeScanTest {

    private TreeNode rootNode; 
    @Before
    public void setUp() throws Exception {
        TreeNode root  = new TreeNode(3);
        TreeNode n1  = new TreeNode(9);
        TreeNode n2  = new TreeNode(20);
        
        root.setLeft(n1);
        root.setRight(n2);
        
        TreeNode n3  = new TreeNode(15);
        TreeNode n4  = new TreeNode(7);
        
        n2.setLeft(n3);
        n2.setRight(n4);
        rootNode = root;
    }

    @After
    public void tearDown() throws Exception {
    }

    @Test
    public void testScanTree() {
        List result = Tree.scanTree(rootNode);
        
        List<Integer> expectResult=new ArrayList();
        expectResult.add(3);
        expectResult.add(20);
        expectResult.add(9);
        expectResult.add(15);
        expectResult.add(7);
        
        assertEquals(expectResult, result);
    }

}

 打印結果如下：