二叉树遍历相关

树的结构为

public class TreeNode {
    public int val;
    public TreeNode left;
    public TreeNode right;
    public TreeNode(int x) 
    { 
        val = x; 
    }
}

---

判断一个结点是否存在于二叉树中

递归判断即可

public boolean ifExits(TreeNode root, TreeNode target){
    if(root == null) return false;
    else if(root == target) return true;
    else return ifExits(root.left, target)||ifExits(root.right, target);
}

---

二叉树的遍历(先序，中序，后序)递归/非递归

先序遍历

public void preOrderByRecursive(TreeNode root){
    if(root == null) return;
    System.out.print(root.val);
    preOrderByRecursive(root.left);
    preOrderByRecursive(root.right);
}
public List<Integer> preOrder(TreeNode root){
    List<Integer> ls = new ArrayList<Integer>();
    Deque<TreeNode> deque = new ArrayDeque<TreeNode>();
    if(root != null) deque.add(root);
    TreeNode tmp;
    while(!deque.isEmpty()){
        tmp = deque.removeLast();
        ls.add(tmp.val);
        if(tmp.left != null)deque.add(tmp.left);
        if(tmp.right != null)deque.add(tmp.right);
    }
    return ls;
}

中序遍历

public void inOrderByRecursive(TreeNode root){
    if(root == null) return;
    inOrderByRecursive(root.left);
    System.out.print(root.val);
    inOrderByRecursive(root.right);
}
public List<Integer> inOrder(TreeNode root){
    List<Integer> ls = new ArrayList<Integer>();
    Deque<TreeNode> deque = new ArrayDeque<TreeNode>();
    TreeNode tmp = root;
    while(tmp != null){
        deque.add(tmp);
        tmp = tmp.left;
    }
    while(!deque.isEmpty()){
        tmp = deque.removeLast();
        ls.add(tmp.val);
        tmp = tmp.right;
        while(tmp != null){
            deque.add(tmp);
            tmp = tmp.left;
        }
    }
    return ls;
}

后序遍历

public void postOrderByRecursive(TreeNode root){
    if(root == null) return;
    postOrderByRecursive(root.left);
    postOrderByRecursive(root.right);
    System.out.print(root.val);
}
public void postOrder(TreeNode root){
    List<Integer> ls = new ArrayList<Integer>();
    Deque<TreeNode> deque = new ArrayDeque<TreeNode>();
    Set<TreeNode> set = new HashSet<TreeNode>();
    if(root != null) deque.add(root);
    while(!deque.isEmpty()){
        TreeNode tmp = deque.pollLast();
        if(set.contains(tmp)){
            ls.add(tmp.val);
            deque.removeLast();
        }else{
            set.add(tmp);
            if(tmp.right != null) deque.add(tmp.right);
            if(tmp.left != null) deque.add(tmp.left);
        }
    }
    return ls;
}

---

层次遍历

层次遍历主要应用队列来解决，由于要分清每一层，因此采用两个队列保存一层及其下一层

从上到下
Binary Tree Level Order Traversal
https://leetcode.com/problems/binary-tree-level-order-traversal/
Given a binary tree, return the level order traversal of its nodes’ values. (ie, from left to right, level by level).
就是正常的层次遍历，注意必须从左向右

public List<List<Integer>> levelOrder(TreeNode root) {
       List<List<Integer>> ls = new ArrayList<List<Integer>>();
       Deque<TreeNode> parent = new ArrayDeque<TreeNode>(), son = new ArrayDeque<TreeNode>(), tmp;
       List<Integer> sls;
       if(root != null) parent.add(root);
       while(!parent.isEmpty()){
            sls = new ArrayList<Integer>();
            while(!parent.isEmpty()){
                TreeNode tn = parent.pollFirst();
                sls.add(tn.val);
                if(tn.left != null) son.add(tn.left);
                if(tn.right != null) son.add(tn.right);
            }
            ls.add(sls);
            if(!son.isEmpty()){
                tmp = son;
                son = parent;
                parent = tmp;
            }
       }
       return ls;
}

从下到上
Binary Tree Level Order Traversal II
https://leetcode.com/problems/binary-tree-level-order-traversal-ii/
Given a binary tree, return the bottom-up level order traversal of its nodes’ values. (ie, from left to right, level by level from leaf to root).
可以在将每层列表加入时，每次插入第一个（采用Linkedlist比较好）

public List<List<Integer>> levelOrderBottom(TreeNode root) {
       List<List<Integer>> ls = new LinkedList<List<Integer>>();
       Deque<TreeNode> parent = new ArrayDeque<TreeNode>(), son = new ArrayDeque<TreeNode>(), tmp;
       List<Integer> sls;
       if(root != null) parent.add(root);
       while(!parent.isEmpty()){
            sls = new ArrayList<Integer>();
            while(!parent.isEmpty()){
                TreeNode tn = parent.pollFirst();
                sls.add(tn.val);
                if(tn.left != null) son.add(tn.left);
                if(tn.right != null) son.add(tn.right);
            }
            ls.add(0,sls);
            if(!son.isEmpty()){
                tmp = son;
                son = parent;
                parent = tmp;
            }
       }
       return ls;
}

ZigZag遍历方式层次遍历
Binary Tree Zigzag Level Order Traversal
https://leetcode.com/problems/binary-tree-zigzag-level-order-traversal/
Given a binary tree, return the zigzag level order traversal of its nodes’ values. (ie, from left to right, then right to left for the next level and alternate between).
For example:Given binary tree {3,9,20,#,#,15,7}

    3
   / \
  9  20
    /  \
   15   7
return 
[
  [3],
  [20,9],
  [15,7]
]

正常层次遍历，只是设置一个标志位，标志每一层该正序加入或者逆序插入。

public List<List<Integer>> zigzagLevelOrder(TreeNode root) {
       List<List<Integer>> ls = new ArrayList<List<Integer>>();
       Deque<TreeNode> parent = new ArrayDeque<TreeNode>(), son = new ArrayDeque<TreeNode>(), tmp;
       List<Integer> sls;
       int flag = 0;
       if(root != null) parent.add(root);
       while(!parent.isEmpty()){
            sls = (flag == 0) ? new ArrayList<Integer>(): new LinkedList<Integer>();
            while(!parent.isEmpty()){
                TreeNode tn = parent.pollFirst();
                if(flag == 0) sls.add(tn.val);
                else sls.add(0, tn.val);
                if(tn.left != null) son.add(tn.left);
                if(tn.right != null) son.add(tn.right);
            }
            ls.add(sls);
            flag = flag ^ 1;
            if(!son.isEmpty()){
                tmp = son;
                son = parent;
                parent = tmp;
            }
       }
       return ls;
}