二叉树遍历（Java）

前言

参考：
[1]优快云-Yadoer
[2]jianshu-阿菜的博客

代码

二叉树数据结构以及基本操作如下，具体思路看参考。建树过程利用的是前序和中序遍历结果列表。

package com.company;

import sun.reflect.generics.tree.Tree;

import java.util.Arrays;
import java.util.LinkedList;
import java.util.Stack;

/**
 *  binary tree's structure is like this:
 *
 *        1
 *      /   \
 *     2     3
 *    /     / \
 *   4     5   6
 *    \       /
 *     7     8
 */


public class BinaryTree {
    static class TreeNode {
        int val;
        TreeNode left;
        TreeNode right;
        TreeNode(int val){
            this.val = val;
        }
    }

    public static TreeNode reConstructBinaryTree(int[] pre, int[] vin){
        if (pre == null || pre.length == 0){
            return null;
        }

        int rootVal = 0;
        rootVal = pre[0];
        if (pre.length==1){
            return new TreeNode(rootVal);
        }

        int rootIdx = 0;
        for(int i =0; i<vin.length; i++){
            if (rootVal == vin[i]){
                rootIdx = i;
                break;
            }
        }

        TreeNode root = new TreeNode(rootVal);
        root.left = reConstructBinaryTree(Arrays.copyOfRange(pre, 1,rootIdx+1), Arrays.copyOfRange(vin, 0, rootIdx));
        root.right = reConstructBinaryTree(Arrays.copyOfRange(pre, rootIdx+1, pre.length), Arrays.copyOfRange(vin, rootIdx+1, vin.length));
        return root;
    }

    public static void recursionPreorderTraversal(TreeNode root){
        if (root != null) {
            System.out.println(root.val);
            recursionPreorderTraversal(root.left);
            recursionPreorderTraversal(root.right);
        }
    }

    public static void recursionMidorderTraversal(TreeNode root){
        if (root != null) {
            recursionMidorderTraversal(root.left);
            System.out.println(root.val);
            recursionMidorderTraversal(root.right);
        }
    }

    public static void recursionPostorderTraversal(TreeNode root){
        if (root != null) {
            recursionPostorderTraversal(root.left);
            recursionPostorderTraversal(root.right);
            System.out.println(root.val);
        }
    }

    public static void preorderTraversal(TreeNode root){
        Stack<TreeNode> treeNodeStack = new Stack<TreeNode>();
        TreeNode node = root;
        while(node != null || !treeNodeStack.isEmpty()){
           if (node != null){
                System.out.println(node.val);
                treeNodeStack.push(node);
                node = node.left;
            }else{
               node = treeNodeStack.pop();
               node = node.right;
           }
        }
    }

    public static void midorderTraversal(TreeNode root){
        Stack<TreeNode> treeNodeStack = new Stack<TreeNode>();
        TreeNode node = root;
        while(node != null || !treeNodeStack.isEmpty()){
            if(node != null ){
                treeNodeStack.push(node);
                node = node.left;
            }else{
                node = treeNodeStack.pop();
                System.out.println(node.val);
                node = node.right;
            }
        }
    }

    public static void postorderTraversal(TreeNode root) {
        Stack<TreeNode> treeNodeStack = new Stack<TreeNode>();
        TreeNode node =root;
        TreeNode lastVisit = root;
        while(node != null || !treeNodeStack.isEmpty()){
            while(node != null ){
                treeNodeStack.push(node);
                node = node.left;
            }
            node = treeNodeStack.peek();
            if (node.right == null || node.right == lastVisit){
                System.out.println(node.val);
                node = treeNodeStack.pop();
                lastVisit = node;
                node = null;
            }else {
                node = node.right;
            }
        }
    }

    public static void levelTraversal(TreeNode root) {
        if (root == null ){
            return;
        }
        LinkedList<TreeNode> treeNodeLinkedList = new LinkedList<TreeNode>();
        treeNodeLinkedList.add(root);
        while(!treeNodeLinkedList.isEmpty()){
            TreeNode node = treeNodeLinkedList.pop();
            System.out.println(node.val);
            if (node.left != null){
                treeNodeLinkedList.add(node.left);
            }
            if (node.right != null) {
                treeNodeLinkedList.add(node.right);
            }
        }
    }
	
	/**
	 *更新：查找某个路径和为target值的路径，这里需要注意的是将一个seq记录到最终res中
	 *需要new ArrayList<Integer>(seq);因为直接传递的是引用。
	 */

     static class FindPath{
         private static ArrayList<ArrayList<Integer>> res = new ArrayList<ArrayList<Integer>>();
         private static ArrayList<Integer> seq = new ArrayList<Integer>();
         public static ArrayList<ArrayList<Integer>> findPath(TreeNode root, int target){
             if (root == null ) return res;
             seq.add(root.val);
             target -= root.val;
             if (target == 0 && root.left == null && root.right == null){
                 res.add(new ArrayList<Integer>(seq));
             }
             findPath(root.left, target);
             findPath(root.right, target);
             seq.remove(seq.size()-1);
             return res;
         }
    }

    public static void main(String[] args){
        int[] pre = new int[]{1,2,4,7,3,5,6,8};
        int[] vin = new int[]{4,7,2,1,5,3,8,6};
        TreeNode root = reConstructBinaryTree(pre, vin);
        System.out.println("pre_rec=======");
        recursionPreorderTraversal(root);
        System.out.println("pre=======");
        preorderTraversal(root);
        System.out.println("mid_rec=======");
        recursionMidorderTraversal(root);
        System.out.println("mid=======");
        midorderTraversal(root);
        System.out.println("post_rec=======");
        recursionPostorderTraversal(root);
        System.out.println("post=======");
        postorderTraversal(root);
        System.out.println("level=======");
        levelTraversal(root);

        System.out.println("find path: 9");
        System.out.println(FindPath.findPath(root, 9));
    }
}