二叉树经典例题

二叉树：

    static class Node {
        private int data;
        private Node left;
        private Node right;

        public Node() {

        }

        public Node(int data) {
            this.data = data;
        }

        public int getData() {
            return data;
        }

        public void setData(int data) {
            this.data = data;
        }

        public Node getLeft() {
            return left;
        }

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

        public Node getRight() {
            return right;
        }

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

1、分别先序、中序、后序遍历二叉树

递归：

思路：注意与打印位置的关系

先序：

    public static void method(Node node) {
        if (node == null) {
            return;
        }
        System.out.println(node.data);
        method(node.left);
        method(node.right);
    }

中序：

    public static void method(Node node) {
        if (node == null) {
            return;
        }
        method(node.left);
        System.out.println(node.data);
        method(node.right);
    }

后序：

    public static void method(Node node) {
        if (node == null) {
            return;
        }
        method(node.left);
        method(node.right);
        System.out.println(node.data);
    }

非递归：

先序：

思路：通过栈，当前节点的右节点压栈，输出当前节点，当前指向左节点。左边为空时出栈

    public static void method(Node head) {
        if (head == null) {
            return;
        }
        Stack stack = new Stack();
        Node node = head;

        while (node != null || stack.size() != 0) {
            if (node == null) {
                node = (Node) stack.pop();
            }

            System.out.println(node.data);
            if (node.right != null) {
                stack.add(node.right);
            }

            node = node.left;
        }

    }

中序：

思路：将左节点全部压入栈中，弹出时指向弹出节点的右节点

如果当前节点的左节点不为空，压入栈中，且当前节点指向左节点。

为空的话，指向栈中弹出节点，输出当前节点，并指向当前节点的右节点。

    public static void method(Node head) {
        if (head == null) {
            return;
        }
        Stack stack = new Stack();
        Node node = head;

        while (node != null || stack.size() != 0) {
            if (node != null) {
                stack.add(node);
                node = node.left;
            } else {
                node = (Node) stack.pop();
                System.out.println(node.data);
                node = node.right;
            }

        }

    }

后序：

思路：后序的顺序是 “ 左右中”， 反转过来也就是 “ 中左右” 与先序类似，所以方法就是先用类似先序的方法 以 “ 中左右” 的顺序压入栈中，再用另一个栈反转。

    public static void method(Node head) {
        if (head == null) {
            return;
        }
        Node node = head;
        Stack<Node> stack = new Stack();
        Stack<Node> result = new Stack();
        while (node != null || stack.size() != 0) {
            if (node == null) {
                node = stack.pop();
            }

            result.add(node);

            if (node.left != null) {
                stack.add(node.left);
            }
            node = node.right;
        }

        while (result.size() != 0) {
            System.out.println(result.pop().data);
        }
    }

2、按层遍历二叉树。

思路：

输出当前节点，并将当前节点的左右节点都放入队列中

    public static void method(Node head) {
        Queue<Node> queue = new ArrayBlockingQueue<>(100);
        Node node = head;
        while (queue.size() != 0 || node != null) {
            System.out.println(node.getData());
            if (node.left != null) {
                queue.add(node.left);
            }
            if (node.right != null) {
                queue.add(node.right);
            }

            node = queue.poll();
        }

    }

 

3、求一个节点的后继（中序遍历时，当前节点的下一个节点）。二叉树结构如下：有一个parent指针指向父节点。

public class Node { 
    public int value; 
    public Node left;
    public Node right;
    public Node parent;
public Node(int data) { this.value = data; }
}

思路： 

1、当前节点有右节点的话，后继就是当前节点右子树的最左节点。

2、否则的话，就找当前子树是左子树（不是的话继续向上找）的父节点。

    public static Node method(Node head) {
        Node node = head;
//        返回右子树的最左子树
        if (node.right != null) {
            node = node.right;
            while (node.left != null) {
                node = node.left;
            }
            return node;
        }
//        返回当前子树为左子树的父节点
        while (node.parent != null) {
            if (node == node.parent.left) {
                return node.parent;
            }
            node = node.parent;
        }
        return null;
    }

4、二叉树的序列化和反序列化。

（1）先序：

非递归 先序 序列化

思路：类比先序遍历。

    public static String method(Node head) {
        StringBuilder stringBuilder = new StringBuilder();
        Node node = head;
        Stack<Node> stack = new Stack<>();
        while (stack.size() != 0 || node != null) {
            if (node == null) {
                stringBuilder.append("null_");
                node = stack.pop();
            }
            stringBuilder.append(node.getData() + "_");
            if (node.right != null) {
                stack.add(node.right);
            } else {
                stringBuilder.append("null_");
            }
            node = node.left;
        }
        return stringBuilder.toString();
    }

1_2_4_null_null_5_8_null_null_9_null_null_3_6_null_null_7_null_

递归 先序 序列化

    public static String method2(Node node) {

        StringBuilder stringBuilder = new StringBuilder();

        if (node == null) {
            return "null_";
        }

        stringBuilder.append(node.getData() + "_");
        stringBuilder.append(method2(node.left));
        stringBuilder.append(method2(node.right));
        return stringBuilder.toString();
    }

递归 先序 反序列化

思路：类似于遍历。

    public static Node method(String string) {
        Queue<String> queue = new LinkedList<>();
        String[] splits = string.split("_");
        for (String split : splits) {
            queue.add(split);
        }
        return method4(queue);
    }

    public static Node method4(Queue<String> queue) {

        if (queue.peek().equals("null")) {
            queue.poll();
            return null;
        }

        Node node = new Node(Integer.parseInt(queue.poll()));
        node.left = method4(queue);
        node.right = method4(queue);
        return node;
    }

------------------------------------------------------------------------------------------------------------------------------------------------------------------------ 

（2）分层 

非递归 按层 序列化

思路：遍历。

    public static String method4(Node head) {
        Node node = head;
        StringBuilder stringBuilder = new StringBuilder();
        Queue<Node> queue = new LinkedList<>();
        if (node != null) {
            stringBuilder.append(node.data + "_");
            queue.add(node);
        } else {
            stringBuilder.append("null_");
        }

        while (!queue.isEmpty()) {
            node = queue.poll();
            if (node.left != null) {
                queue.add(node.left);
                stringBuilder.append(node.left.data + "_");
            }else {
                stringBuilder.append("null_");
            }

            if (node.right != null) {
                queue.add(node.right);
                stringBuilder.append(node.right.data + "_");
            } else {
                stringBuilder.append("null_");
            }

        }
        return stringBuilder.toString();
    }

非递归 按层 反序列化

    public static Node method(String string) {
        String[] splits = string.split("_");
        Queue<Node> nodeQueue = new LinkedList<>();
        Node node;
        int index = 0;

        node = helpMethod(splits[index++]);
        Node head = node;
        if (node != null) {
            nodeQueue.offer(node);
        }

        while (!nodeQueue.isEmpty()) {
            node = nodeQueue.poll();

            node.left = helpMethod(splits[index++]);
            node.right = helpMethod(splits[index++]);
            if (node.left != null) {
                nodeQueue.offer(node.left);
            }

            if (node.right != null) {
                nodeQueue.offer(node.right);
            }
        }
        return head;

    }

5、判断是否为平衡二叉树。

平衡二叉树：每个节点的左右子树高度相差不大于1（<= 1）。

思路：递归，每深入一层，当前高度加1，左右子树高度差 <= 1 时，返回高的子树高度，否则返回-1.

    public static boolean method(Node head) {
        Node node = head;
        int balance = isBalance(node, 1);
        if (balance != -1) {
            return true;
        }
        return false;
    }

    public static int isBalance(Node head, int level) {
        Node node = head;
        if (node == null) {
            return level - 1;
        }
        int leftHeight = isBalance(node.left, level+1);
        int rightHeight = isBalance(node.right, level+1);
        if (Math.abs(leftHeight - rightHeight) <= 1) {
            return Math.max(leftHeight, rightHeight);
        } else {
            return -1;
        }
    }

6、判断是否为搜索二叉树（中序遍历有序）

思路1：中序遍历一遍，再看是否有序

    public static boolean method(Node head) {
        Node node = head;
        Queue<Integer> queue = new LinkedList<>();
        method1(node, queue);
        int temp = queue.poll();
        for (Integer integer : queue) {
            if (integer < temp) {
                return false;
            }
            temp = integer;
        }
        return true;
    }

    public static Queue<Integer> method1(Node head, Queue<Integer> queue) {
        Node node = head;
        if (node == null) {
            return null;
        }
        method1(node.left, queue);
        queue.add(node.data);
        method1(node.right, queue);
        return queue;
    }

思路2、根据非递归中序遍历，遍历时看当前数是否大于等于上一个数。

    public static boolean method(Node head) {
        Node node = head;
        Stack<Node> stack = new Stack<>();
        while (node.left != null) {
            node = node.left;
        }
        int temp = node.data;
        node = head;

        while (!stack.isEmpty() || node != null) {
            if (node == null) {
                node = stack.pop();
                if (node.data >= temp) {
                    temp = node.data;
                } else {
                    return false;
                }
                node = node.right;
            }
            if (node != null) {
                stack.add(node);
                node = node.left;
            }
        }
        return true;
    }

7、判断一棵树是否为完全二叉树（叶子节点从左向右）

思路：分层遍历，记一个标记 isleaf ，如果当前节点为叶子节点， 之后的节点就不能有子树。

    public static boolean method(Node head) {
        Queue<Node> queue = new LinkedList<>();
        Node node = head;
        Boolean isLeaf = false;
        if (node != null) {
            queue.add(node);
        }

        while (!queue.isEmpty()) {

            node = queue.poll();
            if (node.left != null) {
                if (isLeaf == true) {
                    return false;
                }
                queue.add(node.left);
            } else {
                isLeaf = true;
            }

            if (node.right != null) {
                if (isLeaf == true) {
                    return false;
                }
                queue.add(node.right);
            }else {
                isLeaf = true;
            }
        }

        return true;
    }

8、求一棵完全二叉树的节点个数。要求时间复杂度小于O（n）。

思路：当前节点右子树的最左节点如果存在的话，左子树就是满二叉树。

否则，右子树就是满二叉树。

满二叉树很容易算，然后再看不满的那一边

时间复杂度为（logn)^2 ,因为每次都是按层数遍历一遍

    public static int getNumber(Node head) {
        return getNumber(head, 1, getHeight(head));
    }
    /**
     * @param node
     * @param level 当前节点所在层数
     * @param height 最大的所求完全二叉树的高度（不变）
     * @return
     */
    public static int getNumber(Node node, int level, int height) {
        int num = 0;
        if (node == null) {
            return 0;
        }
//        当前树右子树的最左节点存在
        if (getHeight(node.right) + level == height) {
//            左子树为满二叉树
            num += (int) Math.pow(2, height - level);
//            右子树重复当前过程
            num += getNumber(node.right, level + 1, height);
        } else {
            num += Math.pow(2, getHeight(node.right));
            num += getNumber(node.left, level + 1, height);
        }
        return num;
    }

    /**
     * 获取当前完全二叉树的高度（最左节点的高度）
     * @param head
     * @return
     */
    public static int getHeight(Node head) {
        Node node = head;
        int height = 0;
        while (node != null) {
            height++;
            node = node.left;
        }
        return height;
    }