面试常见算法2：对树的操作

最新推荐文章于 2024-04-18 11:06:01 发布
原创 最新推荐文章于 2024-04-18 11:06:01 发布 · 置顶 · 428 阅读 · 0 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。

本文详细介绍了二叉树的各种操作，包括遍历方法（先序、中序、后序及层次遍历）、寻找节点的前驱与后继、判断是否为平衡/搜索/完全二叉树、获取树的深度、按层遍历打印、二叉树对称问题及子结构判断等，并提供了丰富的示例代码。

摘要生成于 C知道 ，由 DeepSeek-R1 满血版支持， 前往体验 >

注：此博客不再更新，所有最新文章将发表在个人独立博客limengting.site。分享技术，记录生活，欢迎大家关注

1、树的遍历：先序/中序/后序/层次遍历

package sword_to_offer_tree;

import java.util.LinkedList;
import java.util.Queue;
import java.util.Stack;

public class PreInPosLayerTraversal {
    public static class Node {
        public int value;
        public Node left;
        public Node right;

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

    public static void preOrderRecur(Node head) {
        if (head == null) return;
        System.out.print(head.value + " ");
        preOrderRecur(head.left);
        preOrderRecur(head.right);
    }

    public static void inOrderRecur(Node head) {
        if (head == null) return;
        inOrderRecur(head.left);
        System.out.print(head.value + " ");
        inOrderRecur(head.right);
    }

    public static void posOrderRecur(Node head) {
        if (head == null) return;
        posOrderRecur(head.left);
        posOrderRecur(head.right);
        System.out.print(head.value + " ");
    }

    // 用栈实现，弹出当前节点，有右先压右，有左后压左
    // 先压右后压左，弹出为先弹左后弹右
    public static void preOrderUnRecur(Node head) {
        if (head == null) return;
        Stack<Node> stack = new Stack<>();
        stack.push(head);
        while (!stack.isEmpty()) {
            head = stack.pop();
            System.out.print(head.value + " ");
            // 有右先压右
            if (head.right != null) {
                stack.push(head.right);
            }
            // 有左后压左
            if (head.left != null) {
                stack.push(head.left);
            }
        }
        System.out.println();
    }

    // 用栈实现，当前节点不为空或者栈不为空继续：当前节点不为空，当前节点压入栈，当前节点往左跑（左边界一压压一溜）；当前节点为空，从栈中拿一个打印，当前节点向右跑
    public static void inOrderUnRecur(Node head) {
        if (head == null) return;
        Stack<Node> stack = new Stack<>();
        while (head != null || !stack.isEmpty()) {
            if (head != null) {
                stack.push(head);
                head = head.left;
            } else {
                head = stack.pop();
                System.out.print(head.value + " ");
                head = head.right;
            }
        }
        System.out.println();
    }

    // 后序：左-右-中
    // 通过 中-左-右(先序) -> 中-右-左，打印的时候不打印，存到栈里去，存完把所有栈中的元素打印 -> 左-右-中
    public static void posOrderUnRecur(Node head) {
        if (head == null) return;
        Stack<Node> stack = new Stack<>();
        Stack<Integer> printStack = new Stack<>();
        stack.push(head);
        while (!stack.isEmpty()) {
            head = stack.pop();
            // System.out.print(head.value + " ");
            printStack.push(head.value);
            // 有左先压左
            if (head.left != null) {
                stack.push(head.left);
            }
            // 有右后压右
            if (head.right != null) {
                stack.push(head.right);
            }
        }
        while (!printStack.isEmpty()) {
            System.out.print(printStack.pop() + " ");
        }
        System.out.println();
    }

    // 弹一个出来，把左边右边加进去
    public static void layerTraversal(Node head) {
        if (head == null) return;
        Queue<Node> queue = new LinkedList<>();
        queue.offer(head);
        while (!queue.isEmpty()) {
            head = queue.poll();
            System.out.print(head.value + " ");
            if (head.left != null) {
                queue.offer(head.left);
            }
            if (head.right != null) {
                queue.offer(head.right);
            }
        }
    }

    // for LinkedListHasLoopOrNot -- print tree
    public static void printTree(Node head) {
        System.out.println("Binary Tree:");
        printInOrder(head, 0, "H", 17);
        System.out.println();
    }

    public static void printInOrder(Node head, int height, String to, int len) {
        if (head == null) {
            return;
        }
        printInOrder(head.right, height + 1, "v", len);
        String val = to + head.value + to;
        int lenM = val.length();
        int lenL = (len - lenM) / 2;
        int lenR = len - lenM - lenL;
        val = getSpace(lenL) + val + getSpace(lenR);
        System.out.println(getSpace(height * len) + val);
        printInOrder(head.left, height + 1, "^", len);
    }

    public static String getSpace(int num) {
        String space = " ";
        StringBuffer buf = new StringBuffer("");
        for (int i = 0; i < num; i++) {
            buf.append(space);
        }
        return buf.toString();
    }


    public static void main(String[] args) {
        Node head = new Node(5);
        head.left = new Node(3);
        head.right = new Node(8);
        head.left.left = new Node(2);
        head.left.right = new Node(4);
        head.left.left.left = new Node(1);
        head.right.left = new Node(7);
        head.right.left.left = new Node(6);
        head.right.right = new Node(10);
        head.right.right.left = new Node(9);
        head.right.right.right = new Node(11);
        printTree(head);

        // recursive
        System.out.println("==============recursive==============");
        System.out.print("pre-order: ");
        preOrderRecur(head);
        System.out.println();
        System.out.print("in-order: ");
        inOrderRecur(head);
        System.out.println();
        System.out.print("pos-order: ");
        posOrderRecur(head);
        System.out.println();

        // unrecursive
        System.out.println("============unrecursive=============");
        System.out.print("pre-order: ");
        preOrderUnRecur(head);
        System.out.print("in-order: ");
        inOrderUnRecur(head);
        System.out.print("pos-order: ");
        posOrderUnRecur(head);

        // layer
        System.out.println("============layer=============");
        layerTraversal(head);
    }
}

2、找树中某个节点的前驱/后继节点

2.1 找后继节点

package sword_to_offer_tree;

// 后继节点，即中序遍历中的下一个节点
public class FindSuccessorNode {
    public static class Node {
        public int value;
        public Node left;
        public Node right;
        public Node parent;

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

    // 若有右子树，则为右子树上最左的节点；若没有右子树，则为第一个满足某种要求的父节点，要求是我在该父节点的左子树上
    public static Node findSuccessorNode(Node head) {
        if (head == null) return null;
        if (head.right != null) return findLeftMostNode(head.right);
        else return findFatherWhichIamInHisLeft(head);
    }

    public static Node findLeftMostNode(Node node) {
        while (node.left != null) {
            node = node.left;
        }
        return node;
    }

    public static Node findFatherWhichIamInHisLeft(Node node) {
        Node parent = node.parent;
        while (parent != null) {
            if (parent.left == node) {
                return parent;
            } else {
                node = parent;
                parent = parent.parent;
            }
        }
        return parent;
    }
    public static void main(String[] args) {
        Node head = new Node(6);
        head.parent = null;
        head.left = new Node(3);
        head.left.parent = head;
        head.left.left = new Node(1);
        head.left.left.parent = head.left;
        head.left.left.right = new Node(2);
        head.left.left.right.parent = head.left.left;
        head.left.right = new Node(4);
        head.left.right.parent = head.left;
        head.left.right.right = new Node(5);
        head.left.right.right.parent = head.left.right;
        head.right = new Node(9);
        head.right.parent = head;
        head.right.left = new Node(8);
        head.right.left.parent = head.right;
        head.right.left.left = new Node(7);
        head.right.left.left.parent = head.right.left;
        head.right.right = new Node(10);
        head.right.right.parent = head.right;

        Node test = head.left.left;
        System.out.println(test.value + " next: " + findSuccessorNode(test).value);
        test = head.left.left.right;
        System.out.println(test.value + " next: " + findSuccessorNode(test).value);
        test = head.left;
        System.out.println(test.value + " next: " + findSuccessorNode(test).value);
        test = head.left.right;
        System.out.println(test.value + " next: " + findSuccessorNode(test).value);
        test = head.left.right.right;
        System.out.println(test.value + " next: " + findSuccessorNode(test).value);
        test = head;
        System.out.println(test.value + " next: " + findSuccessorNode(test).value);
        test = head.right.left.left;
        System.out.println(test.value + " next: " + findSuccessorNode(test).value);
        test = head.right.left;
        System.out.println(test.value + " next: " + findSuccessorNode(test).value);
        test = head.right;
        System.out.println(test.value + " next: " + findSuccessorNode(test).value);
        test = head.right.right; // 10's next is null
        System.out.println(test.value + " next: " + findSuccessorNode(test));
    }
}

2.2 找前驱节点

package sword_to_offer_tree;

public class FindPrecursorNode {
    public static class Node {
        public int value;
        public Node left;
        public Node right;
        public Node parent;

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

    // 若有左子树，则为左子树上最右的节点；若没有左子树，则为第一个满足某种要求的父节点，要求是我在该父节点的右子树上
    public static Node findPrecursorNode(Node head) {
        if (head == null) return head;
        if (head.left != null) return findRightMost(head.left);
        else return findFatherWhichIamInHisRight(head);
    }
    public static Node findRightMost(Node node) {
        while (node.right != null) {
            node = node.right;
        }
        return node;
    }

    public static Node findFatherWhichIamInHisRight(Node node) {
        while (node.parent != null && node.parent.right != node)
            node = node.parent;
        return node.parent;
    }
    public static void main(String[] args) {
        Node head = new Node(6);
        head.parent = null;
        head.left = new Node(3);
        head.left.parent = head;
        head.left.left = new Node(1);
        head.left.left.parent = head.left;
        head.left.left.right = new Node(2);
        head.left.left.right.parent = head.left.left;
        head.left.right = new Node(4);
        head.left.right.parent = head.left;
        head.left.right.right = new Node(5);
        head.left.right.right.parent = head.left.right;
        head.right = new Node(9);
        head.right.parent = head;
        head.right.left = new Node(8);
        head.right.left.parent = head.right;
        head.right.left.left = new Node(7);
        head.right.left.left.parent = head.right.left;
        head.right.right = new Node(10);
        head.right.right.parent = head.right;

        Node test = head.right.right; // 10
        System.out.println(test.value + " previous: " + findPrecursorNode(test).value);
        test = head.right; // 9
        System.out.println(test.value + " previous: " + findPrecursorNode(test).value);
        test = head.right.left; // 8
        System.out.println(test.value + " previous: " + findPrecursorNode(test).value);
        test = head.right.left.left; // 7
        System.out.println(test.value + " previous: " + findPrecursorNode(test).value);
        test = head; // 6
        System.out.println(test.value + " previous: " + findPrecursorNode(test).value);
        test = head.left.right.right; // 5
        System.out.println(test.value + " previous: " + findPrecursorNode(test).value);
        test = head.left.right; // 4
        System.out.println(test.value + " previous: " + findPrecursorNode(test).value);
        test = head.left; // 3
        System.out.println(test.value + " previous: " + findPrecursorNode(test).value);
        test = head.left.left.right; // 2
        System.out.println(test.value + " previous: " + findPrecursorNode(test).value);
        test = head.left.left; // 1's previous is null
        System.out.println(test.value + " previous: " + findPrecursorNode(test));
    }
}

3、判断一棵树是否为平衡/搜索/完全二叉树

套路：
列出可能性，定出返回值类型，假定左树能给我这样的类型，假定右树也能给我这样的类型，再做判断。由于是递归函数，最后要写返回给上一级的类型是如何生成的。
利用树的遍历过程中返回一个节点三次，遍历左边的过程收集左子树的信息（要什么信息就设计一个结构记录下来），遍历右边的过程收集右子树的信息，最后整合。

3.1 判断一棵树是否为平衡二叉树（AVL树）

package sword_to_offer_tree;

public class IsBalancedTree {

    public static class Node {
        public int value;
        public Node left;
        public Node right;

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

    public static class ReturnData {
        public boolean isBalanced;
        public int height;

        public ReturnData(boolean isBalanced, int height) {
            this.isBalanced = isBalanced;
            this.height = height;
        }
    }

    public static ReturnData process(Node head) {
        if (head == null)
            return new ReturnData(true, 0);
        ReturnData leftData = process(head.left);
        ReturnData rightData = process(head.right);
        if (!leftData.isBalanced || !rightData.isBalanced || Math.abs(rightData.height - leftData.height) > 1) {
            return new ReturnData(false, 0);
        }
        return new ReturnData(true, Math.max(leftData.height, rightData.height) + 1);
    }

    public static boolean isBalancedTree(Node head) {
        return process(head).isBalanced;
    }

    public static void main(String[] args) {
        Node head = new Node(1);
        head.left = new Node(2);
        head.right = new Node(3);
        head.left.left = new Node(4);
        head.left.right = new Node(5);
        head.right.left = new Node(6);
        head.right.right = new Node(7);

        System.out.println(isBalancedTree(head));

    }
}

3.2 判断一棵树是否为搜索二叉树（BST，Binary Search Tree）

二叉树中序遍历的结果是依次升序的 <=> 该二叉树是一棵搜索二叉树

方法一：复用非递归的中序遍历，把打印该节点的值改成比较该节点的值是否比上一个节点的值大即可

package sword_to_offer_tree;

import java.util.Stack;

public class IsBSTReuseInorderTraversalUnRecur {
    // 复用非递归的中序遍历的函数
    // 二叉树中序遍历的结果是依次升序的 <=> 该二叉树是一棵搜索二叉树
    public static class Node {
        public int value;
        public Node left;
        public Node right;

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

    // 用栈实现，当前节点不为空或者栈不为空继续：当前节点不为空，当前节点压入栈，当前节点往左跑（左边界一压压一溜）；当前节点为空，从栈中拿一个打印，当前节点向右跑
    public static boolean isBST(Node head) {
        if (head == null) return true;
        int pre = Integer.MIN_VALUE;
        Stack<Node> stack = new Stack<>();
        while (head != null || !stack.isEmpty()) {
            if (head != null) {
                stack.push(head);
                head = head.left;
            } else {
                head = stack.pop();
                //System.out.print(head.value + " ");
                if (head.value > pre) {
                    pre = head.value;
                } else {
                    return false;
                }
                head = head.right;
            }
        }
        //System.out.println();
        return true;
    }

    // for LinkedListHasLoopOrNot -- print tree
    public static void printTree(Node head) {
        System.out.println("Binary Tree:");
        printInOrder(head, 0, "H", 17);
        System.out.println();
    }

    public static void printInOrder(Node head, int height, String to, int len) {
        if (head == null) {
            return;
        }
        printInOrder(head.right, height + 1, "v", len);
        String val = to + head.value + to;
        int lenM = val.length();
        int lenL = (len - lenM) / 2;
        int lenR = len - lenM - lenL;
        val = getSpace(lenL) + val + getSpace(lenR);
        System.out.println(getSpace(height * len) + val);
        printInOrder(head.left, height + 1, "^", len);
    }

    public static String getSpace(int num) {
        String space = " ";
        StringBuffer buf = new StringBuffer("");
        for (int i = 0; i < num; i++) {
            buf.append(space);
        }
        return buf.toString();
    }

    public static void main(String[] args) {
        Node head = new Node(4);
        head.left = new Node(2);
        head.right = new Node(6);
        head.left.left = new Node(1);
        head.left.right = new Node(3);
        head.right.left = new Node(5);

        printTree(head);
        System.out.println(isBST(head));
    }
}

方法二：复用查找后继节点的函数

package sword_to_offer_tree;

public class IsBSTReuseSuccessorNodeMethod {
    // 复用找到下一个节点的函数
    // 二叉树中序遍历的结果是依次升序的 <=> 该二叉树是一棵搜索二叉树
    public static class Node {
        public int value;
        public Node left;
        public Node right;
        public Node parent;

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

    // 若有右子树，则为右子树上最左的节点；若没有右子树，则为第一个满足某种要求的父节点，要求是我在该父节点的左子树上
    public static Node findSuccessorNode(Node head) {
        if (head == null) return null;
        if (head.right != null) return findLeftMostNode(head.right);
        else return findFatherWhichIamInHisLeft(head);
    }

    public static Node findLeftMostNode(Node node) {
        while (node.left != null) {
            node = node.left;
        }
        return node;
    }

    public static Node findFatherWhichIamInHisLeft(Node node) {
        Node parent = node.parent;
        while (parent != null) {
            if (parent.left == node) {
                return parent;
            } else {
                node = parent;
                parent = parent.parent;
            }
        }
        return parent;
    }

    public static boolean isBST(Node head) {
        Node successorNode = findSuccessorNode(head);
        while (head.value < successorNode.value && findSuccessorNode(successorNode) != null) {
            head = successorNode;
            successorNode = findSuccessorNode(head);
        }
        if (findSuccessorNode(successorNode) == null) return true;
        return false;
    }
    // for LinkedListHasLoopOrNot -- print tree
    public static void printTree(Node head) {
        System.out.println("Binary Tree:");
        printInOrder(head, 0, "H", 17);
        System.out.println();
    }

    public static void printInOrder(Node head, int height, String to, int len) {
        if (head == null) {
            return;
        }
        printInOrder(head.right, height + 1, "v", len);
        String val = to + head.value + to;
        int lenM = val.length();
        int lenL = (len - lenM) / 2;
        int lenR = len - lenM - lenL;
        val = getSpace(lenL) + val + getSpace(lenR);
        System.out.println(getSpace(height * len) + val);
        printInOrder(head.left, height + 1, "^", len);
    }

    public static String getSpace(int num) {
        String space = " ";
        StringBuffer buf = new StringBuffer("");
        for (int i = 0; i < num; i++) {
            buf.append(space);
        }
        return buf.toString();
    }

    public static void main(String[] args) {
        Node head = new Node(4);
        head.left = new Node(2);
        head.right = new Node(6);
        head.left.left = new Node(1);
        head.left.right = new Node(3);
        head.right.left = new Node(5);

        printTree(head);
        System.out.println(isBST(head));
    }
}

3.3 判断一棵树是否为完全二叉树

package sword_to_offer_tree;

import java.util.LinkedList;
import java.util.Queue;

public class IsCBT {
    public static class Node {
        public int value;
        public Node left;
        public Node right;

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

    // 队列按层遍历
    // 1、有右孩子没有左孩子，一定不是完全二叉树
    // 2、左右孩子不双全：有左没右，或者左右都没有，（开启一个阶段）后面遇到的节点都必须是叶节点，否则不是完全二叉树
    // 若不违反1和2，则这棵树是完全二叉树
    public static boolean isCBT(Node head) {
        if (head == null) return true;
        Queue<Node> queue = new LinkedList<>();
        boolean leafStage = false;
        queue.offer(head);
        while (!queue.isEmpty()) {
            head = queue.poll();
            Node l = head.left;
            Node r = head.right;
            if ((r != null && l == null) || (leafStage && !(l == null && r == null))) {
                return false;
            }
            if (l != null) {
                queue.offer(l);
            }
            if (r != null) {
                queue.offer(r);
            } else {
                leafStage = true;
            }
        }
        return true;
    }

    // for LinkedListHasLoopOrNot -- print tree
    public static void printTree(Node head) {
        System.out.println("Binary Tree:");
        printInOrder(head, 0, "H", 17);
        System.out.println();
    }

    public static void printInOrder(Node head, int height, String to, int len) {
        if (head == null) {
            return;
        }
        printInOrder(head.right, height + 1, "v", len);
        String val = to + head.value + to;
        int lenM = val.length();
        int lenL = (len - lenM) / 2;
        int lenR = len - lenM - lenL;
        val = getSpace(lenL) + val + getSpace(lenR);
        System.out.println(getSpace(height * len) + val);
        printInOrder(head.left, height + 1, "^", len);
    }

    public static String getSpace(int num) {
        String space = " ";
        StringBuffer buf = new StringBuffer("");
        for (int i = 0; i < num; i++) {
            buf.append(space);
        }
        return buf.toString();
    }

    public static void main(String[] args) {
        Node head = new Node(4);
        head.left = new Node(2);
        head.right = new Node(6);
        head.left.left = null;
        head.left.right = new Node(3);
        head.right.left = new Node(5);

        printTree(head);
        System.out.println(isCBT(head));

    }
}

4、得到树的深度

递归：左右子树高度的大者 + 1
非递归：按层遍历的思路

package sword_to_offer_tree;

import java.util.LinkedList;
import java.util.Queue;

public class GetTreeDepth {
    public static class TreeNode {
        int value = 0;
        TreeNode left = null;
        TreeNode right = null;

        public TreeNode(int value) {
            this.value = value;

        }
    }

    // recursively
    public static int TreeDepth1(TreeNode root) {
        if (root == null) {
            return 0;
        }
        return Math.max(TreeDepth1(root.left), TreeDepth1(root.right)) + 1;
    }

    // unrecursively
    // count为该层从队列中弹出的节点的个数，nextLayerCount为在队列中的元素个数，即下一层的节点的总个数
    public static int TreeDepth2(TreeNode root) {
        if (root == null) {
            return 0;
        }
        Queue<TreeNode> queue = new LinkedList<>();
        queue.offer(root);
        int depth = 0, count = 0, nextLayerCount = 1;
        while (!queue.isEmpty()) {
            root = queue.poll();
            count++;
            if (root.left != null) {
                queue.offer(root.left);
            }
            if (root.right != null) {
                queue.offer(root.right);
            }
            if (count == nextLayerCount) {
                nextLayerCount = queue.size();
                count = 0;
                depth++;
            }
        }
        return depth;
    }

    public static void printTree(TreeNode root) {
        System.out.println("Binary Tree:");
        printInOrder(root, 0, "H", 17);
        System.out.println();
    }

    public static void printInOrder(TreeNode root, int height, String to, int len) {
        if (root == null) {
            return;
        }
        printInOrder(root.right, height + 1, "v", len);
        String value = to + root.value + to;
        int lenM = value.length();
        int lenL = (len - lenM) / 2;
        int lenR = len - lenM - lenL;
        value = getSpace(lenL) + value + getSpace(lenR);
        System.out.println(getSpace(height * len) + value);
        printInOrder(root.left, height + 1, "^", len);
    }

    public static String getSpace(int num) {
        String space = " ";
        StringBuffer buf = new StringBuffer("");
        for (int i = 0; i < num; i++) {
            buf.append(space);
        }
        return buf.toString();
    }


    public static void main(String[] args) {
        TreeNode root = new TreeNode(5);
        root.left = new TreeNode(3);
        root.right = new TreeNode(8);
        root.left.left = new TreeNode(2);
        root.left.right = new TreeNode(4);
        root.left.left.left = new TreeNode(1);
        root.right.left = new TreeNode(7);
        root.right.left.left = new TreeNode(6);
        root.right.right = new TreeNode(10);
        root.right.right.left = new TreeNode(9);
        root.right.right.right = new TreeNode(11);
        printTree(root);
        System.out.println(TreeDepth1(root));
        System.out.println(TreeDepth2(root));
    }
}

5、按层遍历打印树的变体

package sword_to_offer_tree;

import java.util.ArrayList;
import java.util.LinkedList;
import java.util.List;
import java.util.Queue;

public class PrintTreeFromTopToBottom {
    public static class TreeNode {
        int value = 0;
        TreeNode left = null;
        TreeNode right = null;

        public TreeNode(int value) {
            this.value = value;
        }
    }

    public static void printArrayList(ArrayList<Integer> arrayList) {
        Integer[] array = arrayList.toArray(new Integer[arrayList.size()]);
        for (Integer i : array) {
            System.out.print(i + " ");
        }
        System.out.println();
    }

    public static void printDoubleArrayList(ArrayList<ArrayList<Integer>> arrayLists) {
        for (ArrayList<Integer> arrayList : arrayLists) {
            for (Integer i : arrayList) {
                System.out.print(i + " ");
            }
            System.out.println();
        }
    }

    public static ArrayList<Integer> getArrayListFromTopToBottom(TreeNode root) {
        ArrayList<Integer> arrayList = new ArrayList<>();
        if (root == null) return arrayList;
        Queue<TreeNode> queue = new LinkedList<>();
        queue.offer(root);
        while (!queue.isEmpty()) {
            TreeNode treeNode = queue.poll();
            arrayList.add(treeNode.value);
            if (treeNode.left != null) {
                queue.offer(treeNode.left);
            }
            if (treeNode.right != null) {
                queue.offer(treeNode.right);
            }
        }
        return arrayList;
    }

    public static void printFromTopToBottom(TreeNode root) {
        if (root == null) return;
        Queue<TreeNode> queue = new LinkedList<>();
        queue.offer(root);
        while (!queue.isEmpty()) {
            TreeNode treeNode = queue.poll();
            System.out.print(treeNode.value + " ");
            if (treeNode.left != null) {
                queue.offer(treeNode.left);
            }
            if (treeNode.right != null) {
                queue.offer(treeNode.right);
            }
        }
        System.out.println();
    }

    // count为该层从队列中弹出的节点的个数，nextLayerCount为在队列中的元素个数，即下一层的节点的总个数
    public static void printFromTopToBottomWithChangeLine(TreeNode root) {
        if (root == null) return;
        Queue<TreeNode> queue = new LinkedList<>();
        int count = 0;
        int nextLayerCount = 1;
        queue.offer(root);
        while (!queue.isEmpty()) {
            TreeNode treeNode = queue.poll();
            count++;
            System.out.print(treeNode.value + " ");
            if (treeNode.left != null) {
                queue.offer(treeNode.left);
            }
            if (treeNode.right != null) {
                queue.offer(treeNode.right);
            }
            if (count == nextLayerCount) {
                System.out.println();
                count = 0;
                nextLayerCount = queue.size();
            }
        }
    }

    public static ArrayList<ArrayList<Integer>> getDoubleArrayFromTopToBottomWithChangeLine(TreeNode root) {
        ArrayList<ArrayList<Integer>> arrayLists = new ArrayList<>();
        if (root == null) return arrayLists;
        Queue<TreeNode> queue = new LinkedList<>();
        ArrayList<Integer> layerList = new ArrayList<>();
        int count = 0;
        int nextLayerCount = 1;
        queue.add(root);
        while (!queue.isEmpty()) {
            TreeNode treeNode = queue.poll();
            layerList.add(treeNode.value);
            count++;
            if (treeNode.left != null) {
                queue.add(treeNode.left);
            }
            if (treeNode.right != null) {
                queue.add(treeNode.right);
            }
            if (count == nextLayerCount) {
                arrayLists.add(layerList);
                count = 0;
                nextLayerCount = queue.size();
                layerList = new ArrayList<>();
            }
        }
        return arrayLists;
    }

    public static void printTree(TreeNode root) {
        System.out.println("Binary Tree:");
        printInOrder(root, 0, "H", 17);
        System.out.println();
    }

    public static void printInOrder(TreeNode root, int height, String to, int len) {
        if (root == null) {
            return;
        }
        printInOrder(root.right, height + 1, "v", len);
        String val = to + root.value + to;
        int lenM = val.length();
        int lenL = (len - lenM) / 2;
        int lenR = len - lenM - lenL;
        val = getSpace(lenL) + val + getSpace(lenR);
        System.out.println(getSpace(height * len) + val);
        printInOrder(root.left, height + 1, "^", len);
    }

    public static String getSpace(int num) {
        String space = " ";
        StringBuffer buf = new StringBuffer("");
        for (int i = 0; i < num; i++) {
            buf.append(space);
        }
        return buf.toString();
    }


    public static void main(String[] args) {
        TreeNode root = new TreeNode(5);
        root.left = new TreeNode(3);
        root.right = new TreeNode(8);
        root.left.left = new TreeNode(2);
        root.left.right = new TreeNode(4);
        root.left.left.left = new TreeNode(1);
        root.right.left = new TreeNode(7);
        root.right.left.left = new TreeNode(6);
        root.right.right = new TreeNode(10);
        root.right.right.left = new TreeNode(9);
        root.right.right.right = new TreeNode(11);
        printTree(root);
        System.out.println("printArrayList(getArrayListFromTopToBottom(root)): ");
        printArrayList(getArrayListFromTopToBottom(root));
        System.out.println("printFromTopToBottom(root): ");
        printFromTopToBottom(root);
        System.out.println("printFromTopToBottomWithChangeLine(root): ");
        printFromTopToBottomWithChangeLine(root);
        System.out.println("printDoubleArrayList(getDoubleArrayFromTopToBottomWithChangeLine(root)): ");
        printDoubleArrayList(getDoubleArrayFromTopToBottomWithChangeLine(root));
    }
}

6、二叉树的对称问题

6.1 将二叉树改成自己的镜像

package sword_to_offer_tree;

import java.util.Stack;

public class MirrorOfBinaryTree {
    public static class TreeNode {
        int value = 0;
        TreeNode left = null;
        TreeNode right = null;

        public TreeNode(int value) {
            this.value = value;
        }
    }

    // recursively
    public static void Mirror1(TreeNode root) {
        if (root == null) return;

        TreeNode tmp = root.left;
        root.left = root.right;
        root.right = tmp;

        if (root.left != null) {
            Mirror1(root.left);
        }
        if (root.right != null) {
            Mirror1(root.right);
        }
    }
    
    // unrecursively
    // 手动压栈弹栈，先换下层再换上层 -> 弹栈时要求先弹出下层节点再弹出上层节点 -> 先将上层压栈后再将下层压栈
    public static void Mirror2(TreeNode root) {
        if (root == null) return;
        Stack<TreeNode> stack = new Stack<>();
        stack.push(root);
        while (!stack.isEmpty()) {
            TreeNode treeNode = stack.pop();
            if (treeNode.left != null || treeNode.right != null) {
                TreeNode tmp = treeNode.left;
                treeNode.left = treeNode.right;
                treeNode.right = tmp;
            }
            if (treeNode.left != null) {
                stack.push(treeNode.left);
            }
            if (treeNode.right != null) {
                stack.push(treeNode.right);
            }
        }
    }

    public static void printTree(TreeNode root) {
        //System.out.println("Binary Tree:");
        printInOrder(root, 0, "H", 17);
        System.out.println();
    }

    public static void printInOrder(TreeNode root, int height, String to, int len) {
        if (root == null) {
            return;
        }
        printInOrder(root.right, height + 1, "v", len);
        String val = to + root.value + to;
        int lenM = val.length();
        int lenL = (len - lenM) / 2;
        int lenR = len - lenM - lenL;
        val = getSpace(lenL) + val + getSpace(lenR);
        System.out.println(getSpace(height * len) + val);
        printInOrder(root.left, height + 1, "^", len);
    }

    public static String getSpace(int num) {
        String space = " ";
        StringBuffer buf = new StringBuffer("");
        for (int i = 0; i < num; i++) {
            buf.append(space);
        }
        return buf.toString();
    }

    public static void main(String[] args) {
        TreeNode root = new TreeNode(1);
        root.left = new TreeNode(-222222222);
        root.right = new TreeNode(3);
        root.left.left = new TreeNode(Integer.MIN_VALUE);
        root.right.left = new TreeNode(55555555);
        root.right.right = new TreeNode(66);
        root.left.left.right = new TreeNode(777);
        System.out.println("before Mirror1: ");
        printTree(root);
        Mirror2(root);
        System.out.println("after Mirror1: ");
        printTree(root);

        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);
        root.right.right = new TreeNode(6);
        root.left.left.right = new TreeNode(7);
        System.out.println("before Mirror1: ");
        printTree(root);
        Mirror2(root);
        System.out.println("after Mirror1: ");
        printTree(root);

        root = new TreeNode(1);
        root.left = new TreeNode(1);
        root.right = new TreeNode(1);
        root.left.left = new TreeNode(1);
        root.right.left = new TreeNode(1);
        root.right.right = new TreeNode(1);
        root.left.left.right = new TreeNode(1);
        System.out.println("before Mirror1: ");
        printTree(root);
        Mirror2(root);
        System.out.println("after Mirror1: ");
        printTree(root);
    }
}

6.2 判断一棵二叉树是否是对称的

package sword_to_offer_tree;

public class IsSymmetricalTree {
    public static class TreeNode {
        int value = 0;
        TreeNode left = null;
        TreeNode right = null;

        public TreeNode(int value) {
            this.value = value;
        }
    }

    public static boolean isSymmetrical(TreeNode root) {
        if (root == null) return true;
        return isSymmetrical(root.left, root.right);
    }

    // 对称位置相等
    private static boolean isSymmetrical(TreeNode left, TreeNode right) {
        if (left == null && right == null) return true;
        if (left == null || right == null) return false;
        if (left.value != right.value) return false;
        return isSymmetrical(left.right, right.left) && isSymmetrical(left.left, right.right);
    }

    public static void printTree(TreeNode root) {
        System.out.println("Binary Tree:");
        printInOrder(root, 0, "H", 17);
        System.out.println();
    }

    public static void printInOrder(TreeNode root, int height, String to, int len) {
        if (root == null) {
            return;
        }
        printInOrder(root.right, height + 1, "v", len);
        String val = to + root.value + to;
        int lenM = val.length();
        int lenL = (len - lenM) / 2;
        int lenR = len - lenM - lenL;
        val = getSpace(lenL) + val + getSpace(lenR);
        System.out.println(getSpace(height * len) + val);
        printInOrder(root.left, height + 1, "^", len);
    }

    public static String getSpace(int num) {
        String space = " ";
        StringBuffer buf = new StringBuffer("");
        for (int i = 0; i < num; i++) {
            buf.append(space);
        }
        return buf.toString();
    }

    public static void main(String[] args) {
        TreeNode root = new TreeNode(1);
        root.left = new TreeNode(-222222222);
        root.right = new TreeNode(3);
        root.left.left = new TreeNode(Integer.MIN_VALUE);
        root.right.left = new TreeNode(55555555);
        root.right.right = new TreeNode(66);
        root.left.left.right = new TreeNode(777);
        printTree(root);
        System.out.println(isSymmetrical(root));
        System.out.println("=============================");

        root = new TreeNode(1);
        root.left = new TreeNode(2);
        root.right = new TreeNode(2);
        root.left.left = new TreeNode(4);
        root.right.left = new TreeNode(5);
        root.right.right = new TreeNode(4);
        root.left.right = new TreeNode(5);
        printTree(root);
        System.out.println(isSymmetrical(root));
        System.out.println("==============================");

        root = new TreeNode(1);
        root.left = new TreeNode(1);
        root.right = new TreeNode(1);
        root.left.left = new TreeNode(1);
        root.right.left = new TreeNode(1);
        root.right.right = new TreeNode(1);
        root.left.left.right = new TreeNode(1);
        printTree(root);
        System.out.println(isSymmetrical(root));
        System.out.println("==============================");
    }
}

7、判断B树是否是A树的子结构

规定：空树不是任何树的子结构

package sword_to_offer_tree;

// 输入两棵二叉树A，B，判断B是不是A的子结构。（ps：我们约定空树不是任意一个树的子结构）
public class TreeBIsSubtreeOfTreeAOrNot {
    public static class TreeNode {
        int value = 0;
        TreeNode left = null;
        TreeNode right = null;

        public TreeNode(int value) {
            this.value = value;
        }
    }

    public static boolean isSubtree(TreeNode root1, TreeNode root2) {
        if (root1 == null || root2 == null) return false;
        boolean res = isSameOrMore(root1, root2);
        if (!res) {
            res = isSameOrMore(root1.left, root2);
        }
        if (!res) {
            res = isSameOrMore(root1.right, root2);
        }
        return res;
    }

    public static boolean isSameOrMore(TreeNode root1, TreeNode root2) {
        // root2子树已经遍历完了，true
        if (root2 == null) return true;
        // root1母树已经遍历完了但root2子树没有遍历完,false
        if (root1 == null) return false;

        if (root1.value != root2.value) return false;
        return isSameOrMore(root1.left, root2.left) && isSameOrMore(root1.right, root2.right);
    }

    public static void printTree(TreeNode head) {
        System.out.println("Binary Tree:");
        printInOrder(head, 0, "H", 17);
        System.out.println();
    }

    public static void printInOrder(TreeNode head, int height, String to, int len) {
        if (head == null) {
            return;
        }
        printInOrder(head.right, height + 1, "v", len);
        String value = to + head.value + to;
        int lenM = value.length();
        int lenL = (len - lenM) / 2;
        int lenR = len - lenM - lenL;
        value = getSpace(lenL) + value + getSpace(lenR);
        System.out.println(getSpace(height * len) + value);
        printInOrder(head.left, height + 1, "^", len);
    }

    public static String getSpace(int num) {
        String space = " ";
        StringBuffer buf = new StringBuffer("");
        for (int i = 0; i < num; i++) {
            buf.append(space);
        }
        return buf.toString();
    }

    public static void main(String[] args) {
        TreeNode root1 = new TreeNode(1);
        root1.left = new TreeNode(2);
        root1.right = new TreeNode(3);
        root1.left.left = new TreeNode(4);
        root1.left.right = new TreeNode(5);
        root1.right.left = new TreeNode(6);
        root1.right.right = new TreeNode(7);
        
        TreeNode root2 = new TreeNode(3);
        root2.left = new TreeNode(6);
        root2.right = new TreeNode(7);

        System.out.println("root1: ");
        printTree(root1);
        System.out.println("root2: ");
        printTree(root2);

        System.out.println(isSubtree(root1, root2));

        root1 = new TreeNode(8);
        root1.left = new TreeNode(8);
        root1.right = new TreeNode(7);
        root1.left.left = new TreeNode(9);
        root1.left.right = new TreeNode(2);
        root1.left.right.left = new TreeNode(4);
        root1.left.right.right = new TreeNode(7);

        root2 = new TreeNode(8);
        root2.left = new TreeNode(9);
        root2.right = new TreeNode(2);

        System.out.println("root1: ");
        printTree(root1);
        System.out.println("root2: ");
        printTree(root2);

        System.out.println(isSubtree(root1, root2));
    }
}

8、判断一个序列是否为某棵树的后序遍历序列

package sword_to_offer_tree;

/*输入一个整数数组，判断该数组是不是某二叉搜索树的后序遍历的结果。
  如果是则输出Yes,否则输出No。假设输入的数组的任意两个数字都互不相同。*/

public class IsPosTraversalSequenceOfBSTOrNot {
    /*BST的后序序列的合法序列是，对于一个序列S，最后一个元素是x （也就是根），
      如果去掉最后一个元素的序列为T，那么T满足：
      T可以分成两段，前一段（左子树）小于x，后一段（右子树）大于x，
      且这两段（子树）都是合法的后序序列。完美的递归定义。*/
    public static boolean isPosTraversalSequenceOfBST(int[] sequence) {
        if (sequence == null || sequence.length < 1) return false;
        return isPos(sequence, 0, sequence.length - 1);
    }

    public static boolean isPos(int[] sequence, int start, int end) {
        if (start >= end) return true;
        int i = start;
        // 如果是后序序列则start~i-1为小于sequence[end]的数，i~end-1为大于sequence[end]的数
        while (i < end && sequence[i] < sequence[end]) {
            i++;
        }
        // 验证i~end-1为大于sequence[end]的数
        for (int j = i; j < end; j++) {
            if (sequence[j] < sequence[end])
                return false;
        }
        return isPos(sequence, start, i - 1) && isPos(sequence, i, end - 1);
    }

    public static void main(String[] args) {
        int[] sequence = new int[]{7,4,6,5};
        System.out.println(isPosTraversalSequenceOfBST(sequence));
    }

}
红黑树精通指南：面试、实战与源码分析
张彦峰的博客
05-12 177万+
本文深入探讨了红黑树的基本原理、实现方法及其在实际应用中的重要性。红黑树是一种自平衡的二叉搜索树，通过一系列颜色标记和旋转操作保证了查找、插入和删除操作的时间复杂度始终保持在 O(log n) 级别。文章首先介绍了红黑树的关键性质和与 AVL 树的区别，分析了红黑树在数据库索引、内存管理等领域的应用。接着，详细讲解了红黑树的插入和删除操作，以及如何通过旋转和颜色调整保持树的平衡。最后，文章通过源码分析展示了红黑树在 Java 和 Linux 内核中的实现，帮助读者更好地理解这一数据结构的实际应用和开发过程。
二叉树前驱节点与后继节点
热门推荐
hpcds的博客
03-21 3万+
前驱节点：对一棵二叉树进行中序遍历，遍历后的顺序，当前节点的前一个节点为该节点的前驱节点； 后继节点：对一棵二叉树进行中序遍历，遍历后的顺序，当前节点的后一个节点为该节点的后继节点； 例如一颗完全二叉树（1,2,3,4,5,6,7），按照中序遍历后的顺序为：（4,2,5,1,6,3,7），1节点的前驱节点为：5，后继节点为6. 图1：二叉树 若每次遍历二叉树进行查找前驱节点或后继节点，复杂度太高...
对树的操作（二叉树）
weixin_34324081的博客
11-02 110
对二叉树的遍历： 　　先序遍历：【先访问根节点】 　　　　　　先访问根节点， 　　　　　　再先序访问左子树， 　　　　　　再先序访问右子树；　　————递归关系 　　中序遍历：【中间访问根节点】 　　　　　　中序遍历左子树， 　　　　　　再访问根节点， 　　　　　　再中序遍历右子树；　　————递归关系 　　后序遍历：【最后访问根节点】 　　　　　　先中序遍历左子树， 　　　...
面试中常见的算法整理——树
HakunaMatata的博客
10-02 476
一、递归 1. 树的高度 104.Maximum Depth of Binary Tree class Solution { public: int maxDepth(TreeNode* root) { if (!root) return 0; return 1 + max(maxDepth(root->left), maxDepth(root->right)...
树的操作
晴空
08-15 274
树的操作（Python） 树的前序、中序、后序遍历 def preOrder(root): if not root: return [] res = [] nodes = [root] while nodes: node = nodes.pop() res.append(node.val) if...
对树的几个基本操作函数
stevenzhou的专栏
02-01 669
//显示树中所有节点的值void show(tnode *root){ if (root) {  coutvalue  show(root->left);  show(root->right); }}//输入树的每层节点值void GetLayer(tnode*root,vector& v){ if (root == NULL)  return ; queue* > q; tnode *p
学习笔记—寻找二叉树的前驱节点和后继节点
Pichairen
07-02 5432
二叉树前驱节点和后继节点：一个二叉树中序遍历中某个节点的前一个节点叫该节点的前驱节点，某个节点的后一个节点叫后继节点 该题目中还有一个节点指向节点的父节点 parent，规定头节点的父亲节点的指针为空。 struct TreeNode{ int val; struct TreeNode* left; struct TreeNode* right; struct...
面试常见算法题
05-17
以下是一些常见的面试算法题及其详解： 1. **二分查找**：二分查找是一种在有序数组中寻找特定元素的搜索算法。它通过不断缩小查找范围，每次将查找区间减半，直到找到目标元素或确定其不存在。了解如何设计递归或...
数据结构、算法及常见面试题：java实现.zip
01-14
算法分类：排序算法（如冒泡排序、快速排序、归并排序），查找算法（如顺序查找、二分查找、哈希查找），图论算法（如Dijkstra最短路径算法、Floyd-Warshall算法、Prim最小生成树算法），动态规划，贪心算法，回溯法...
面试常见基础算法题总结
04-29
以下是对一些常见算法题目的详细解析： 1. **红黑树**：红黑树是一种自平衡二叉查找树，它保持了二叉搜索树的特性，同时通过特定的规则确保了操作的平均时间复杂度为O(log n)。红黑树广泛应用于STL的map和set中，...
Java面试黄金宝典：链表、树、图与大数据处理的关键算法解析
最新发布
03-27
使用场景及目标：① 掌握单链表、二叉树、图等常见数据结构的基本操作；② 学习如何高效处理海量数据，如去重、查找等；③ 理解平衡树的维护机制及其在数据库索引中的应用；④ 掌握动态规划的思想及其典型应用场景。...
数据结构（离散 | 链式存储--链表）
水里的鱼
05-16 1340
定义 n个结点离散分配，彼此通过指针相连，每个结点只有一个前驱结点，每个结点只有一个后继结点，首结点没有前驱结点，尾结点没有后继结点。 专业术语： （1）首结点：第一个有效结点 （2）尾结点：最后一个有效结点 （3）头结点：头结点的数据类型和首结点的类型一样；第一个有效结点之前的结点；头结点并不存放有效数据；加头结点的目的主要是为了方便对链表的操作 （4）头指针：指向头结点的指针变量 （5）尾指针...
在线索二叉树中找前驱后继
m0_64055811的博客
04-18 2877
在线索二叉树中，每个节点除了左右子节点指针外，还增加了两个标记位：ltag和rtag。其中，ltag表示左子节点是否为前驱，rtag表示右子节点是否为后继。通过这两个标记位，我们可以方便地找到任意节点的前驱和后继节点。
求二叉树中节点x的后继节点和前驱结点
weixin_46838716的博客
05-06 2077
1）画个图摸清楚，x节点的后继节点，x节点的前驱节点，它的本质是哪一个？这和左头右的中序遍历息息相关。 2）搞懂了核心思想，找前驱节点和后继节点并不难，分清楚x有没有左右树，这样就很快确定该怎么求。 3）笔试求AC，可以不考虑空间复杂度，但是面试既要考虑时间复杂度最优，也要考虑空间复杂度最优。
数据结构 - 双向链表
weixin_73869209的博客
09-07 1589
如上图所示,双向链表中包含了两个指针,一个指向前驱结点,一个指向后继节点,其中头结点没有前驱节点,尾结点没有后继节点前驱: 前驱指的是当前节点的前一个节点，即在链表中位于当前节点之前的节点。它可以通过前向指针（previous pointer）来访问。后继: 后继指的是当前节点的后一个节点，即在链表中位于当前节点之后的节点。它可以通过后向指针（next pointer）来访问。这篇博客大家应重点关注链表的设计,代码这个东西面试考的更多的是单链表,大家刷题更多的也是单链表,双向链表相对于就没有那么重要了。
后继节点和前驱节点
Cheng
03-23 1万+
后继节点：就是中序遍历排序中相对的后一个 每次找后继节点都是先找当前节点的右子树中的最左节点 如果没有右子树，则找当前节点的父节点，并且当前节点是父节点的左子树的节点。 红圈代表的是当前节点，箭头代表的后继节点，也就是中序遍历中相对当前节点的下一个。 public static class Node{ public int value; public Node left; publi...
二叉树的前驱和后继
鹰击长空
05-03 2万+
前提二叉树的几何结构和遍历路径，是查找前驱和后继的基础。结点分类几何结构千变万化，但单个结点必然和至多3点邻接：左（或右）父，左子和右子。按照“X”型助记，交叉点为研究对象。为求结点N的前驱结点Pre和后继结点Suc，设N的左子lchild，右子rchildm，N的左父亲lparent，右父亲rparent； 先后顺序同一几何结构，不同的遍历方式得到不同的遍历路径；具体到单个结点，也就有不同的前驱
左神课堂之寻找二叉树的前驱节点和后继节点
qq_40938077的博客
05-26 4050
前驱节点：二叉树中序遍历完成后和这个节点相邻的前面的节点为该节点的前驱节点 后继节点：二叉树中序遍历完成后和这个节点相邻的后面的节点为该节点的后继节点 中序遍历顺序：8-&gt;4-&gt;9-&gt;2-&gt;10-&gt;5-&gt;1-&gt;6-&gt;3-&gt;7 4号节点的前驱节点为8号节点，后继节点为9号节点。 正常的二叉树的数据结构： struct node {...
09.二叉搜索树的前驱节点和后继节点
程序员阿红的博客
01-20 2390
09.二叉搜索树的前驱节点和后继节点 二叉搜索树的前驱节点 先了解一下前驱节点 前驱节点：中序遍历时的前一个节点 但如果是二叉搜索树，前驱节点就是前一个比它小的节点 找前驱节点两种情况： 当前节点的左子树不为空。则一直遍历左子树的右节点，直至为null。 当前节点的左子树为空，则从父节点开始寻找前驱节点： 如果当前节点为父节点的右子树，则父节点即为前驱节点。例：7的前驱节点为6。 如果当前节点为父节点的左子树，则依次遍历父节点，直至遍历的节点为父节点的右子树为止。因为属于父节点的左
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值