二叉樹遍歷相關

樹的結構爲

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;
}