LeetCode之二叉树

1 二叉树层次遍历

1.1 思路

就是直接循环+List

1.2 code

public class Solution {
    public static void main(String[] args) {
        TreeNode root = new TreeNode(1);
        root.left = new TreeNode(2);
        root.right = new TreeNode(3);
        root.left.left = new TreeNode(4);
        root.right.left = new TreeNode(5);

        System.out.println(new Solution().levelOrder(root));
    }

    public ArrayList<ArrayList<Integer>> levelOrder (TreeNode root) {
        // write code here
        if (root == null) {
            return new ArrayList<>();
        }

        ArrayList<ArrayList<Integer>> result = new ArrayList<>();

        List<TreeNode> level = Collections.singletonList(root);
        while (!(level == null || level.size() == 0)) {
            result.add(getLevelValue(level));
            level = getNextLevel(level);
        }

        return result;
    }

    public ArrayList<Integer> getLevelValue(List<TreeNode> level) {
        if (level == null || level.size() <= 0) {
            return new ArrayList<>();
        }
        ArrayList<Integer> levelValues = new ArrayList<>(level.size());
        for (TreeNode node : level) {
            if (node == null) {
                continue;
            }
            levelValues.add(node.val);
        }

        return levelValues;
    }

    public List<TreeNode> getNextLevel(List<TreeNode> level) {
        if (level == null || level.size() <= 0 || allNodesWithoutChilds(level)) {
            return new ArrayList<>();
        }
        List<TreeNode> nextLevel = new ArrayList<>();
        for (TreeNode node : level) {
            if (node == null) {
                continue;
            }
            nextLevel.add(node.left);
            nextLevel.add(node.right);
        }

        return nextLevel;
    }

    public boolean allNodesWithoutChilds(List<TreeNode> level) {
        if (level == null || level.size() == 0) {
            return true;
        }
        for (TreeNode node : level) {
            if (node == null) {
                continue;
            }
            if (node.left != null || node.right != null) {
                return false;
            }
        }

        return true;
    }
}


class TreeNode {
  int val = 0;
  TreeNode left = null;
  TreeNode right = null;
  public TreeNode(int val) {
    this.val = val;
  }
}

2 已知前序和中序遍历顺序，求后续遍历顺序

2.1 思路

前序遍历：根—>左孩子—>右孩子
中序遍历：左孩子—>根—>右孩子
后序遍历：左孩子—>右孩子—>根
所谓的前中后指的是根的位置，而左右孩子顺序是不变的。

例如已知前序遍历是DBACEGF，中序遍历是ABCDEFG，那么由前序遍历先根，可知道D是树的根，再看在中序遍历中D左边是ABC，所以可知道ABC一定在D的左子树上，而EFG在D的右子树上。
那么前序遍历为BAC,中序遍历为ABC，所以B为根，在中序遍历中A在B的左边，C在B的右边，所以A为B的左孩子，C为B的有孩子。

2.2 Code

import java.util.Scanner;

class Node
{
    public char value;
    public Node left;
    public Node right;

    public Node (char c)
    {
        this.value = c;
    }
}



public class Main {
    public static void main(String[] args) {
        Scanner scanner = new Scanner( System.in);
        while(scanner.hasNext())
        {
            String preOrder = scanner.nextLine();
            String midOrder = scanner.nextLine();

            Node root = regression(midOrder, preOrder);

            postOderPrint(root);
        }
    }

    private static Node regression(String midOrder, String preOrder) {
        if(midOrder.length() == 0 || preOrder.length() == 0)
        {
            return null;
        }

        final char r = preOrder.charAt(0);
        final String leftMid = midOrder.substring(0, midOrder.indexOf(r));
        final String rightMid = midOrder.substring(1 + midOrder.indexOf(r));
        final String leftHead = preOrder.substring(1, 1+leftMid.length());
        final String rightHead = preOrder.substring(1 + leftMid.length());

        final Node root = new Node(r);
        root.left = regression(leftMid,leftHead);
        root.right = regression(rightMid, rightHead);

        return root;
    }

    private static void postOderPrint(Node root) {
        if(root != null)
        {
            postOderPrint(root.left);
            postOderPrint(root.right);
            System.out.print(root.value);
        }
    }
}

2.3 测试用例

DBACEGF
ABCDEFG


ACBFGED

3 二叉树先序遍历

public class Solution {
    public static void main(String[] args) {
        TreeNode root = new TreeNode(1);
        root.left = new TreeNode(2);
        root.right = new TreeNode(3);
        root.left.left = new TreeNode(4);
        root.right.left = new TreeNode(5);

        int[] preOder = new Solution().preorderTraversal(root);
        for (int i = 0; i < preOder.length; i++) {
            System.out.print(preOder[i] + ", ");
        }
    }

    public int[] preorderTraversal (TreeNode root) {
        if (root == null) {
            return new int[0];
        }

        List<Integer> result = new ArrayList<>();
        preOrder(root, result);

        int[] resultArr = new int[result.size()];
        for (int i = 0; i < result.size(); i++) {
            resultArr[i] = result.get(i);
        }
        return resultArr;
    }

    public void preOrder(TreeNode root, List<Integer> result) {
        if (root == null) {
            return;
        }
        result.add(root.val);
        preOrder(root.left, result);
        preOrder(root.right, result);
    }
}