《剑指offer第二版》七

1. 重建二叉树

（1）题目描述

输入某二叉树的前序遍历和中序遍历的结果，请重建该二叉树。假设输入的前序遍历和中序遍历的结果中都不含重复的数字。
例如，给出
前序遍历 preorder = [3,9,20,15,7]
中序遍历 inorder = [9,3,15,20,7]
返回如下的二叉树：

    3
   / \
  9  20
    /  \
   15   7

（2）题目分析

对于二叉树的前序遍历，根节点一定优先打印，因此二叉树的根节点为前序遍历的第一个数，而对于二叉树的中序遍历，确定了根节点，则左右子树一定在根节点的左右两侧。因此首先根据前序遍历，确定根节点，然后去中序遍历中找到根节点，则根节点的左右两侧即为二叉树的左右子树。

（3）代码

package swordOffer.day7;

import charpter3.Node;
import charpter3.test1;

/**
 * @author chengzhengda
 * @version 1.0
 * @date 2020-04-01 14:44
 * @desc
 */
public class t31 {

    public static Node buildTree(int[] preorder, int[] inorder) {
        // 已知二叉树前序遍历的第一个节点为头结点，而中序遍历的头结点可以将二叉树的左右子树分开
        if (preorder == null || inorder == null) {
            return null;
        }
        return rebuildTree(preorder, 0, preorder.length - 1, inorder, 0, inorder.length - 1);

    }

    public static Node rebuildTree(int[] preorder, int preBegin, int preEnd, int[] inorder, int inBegin, int inEnd) {
        if (preBegin > preEnd || inBegin > inEnd) {
            return null;
        }
        Node root = new Node(preorder[preBegin]);
        for (int i = inBegin; i <= inEnd; i++) {
            if (inorder[i] == preorder[preBegin]) {
                root.left = rebuildTree(preorder, preBegin + 1, preBegin + (i - inBegin), inorder, inBegin, i - 1);
                root.right = rebuildTree(preorder, preBegin + (i - inBegin) + 1, preEnd, inorder, i + 1, inEnd);
            }
        }
        return root;
    }

    public static void main(String[] args) {
        int pre[] = {1, 2};
        int indi[] = {2, 1};
        Node head = buildTree(pre, indi);
        test1.preOrder(head);
    }
}

2. 剪绳子

（1）题目描述

给你一根长度为 n 的绳子，请把绳子剪成整数长度的 m 段（m、n都是整数，n>1并且m>1），每段绳子的长度记为 k[0],k[1]…k[m] 。请问 k[0]k[1]…*k[m] 可能的最大乘积是多少？例如，当绳子的长度是8时，我们把它剪成长度分别为2、3、3的三段，此时得到的最大乘积是18。
示例 1：
输入: 2
输出: 1
解释: 2 = 1 + 1, 1 × 1 = 1

（2）题目分析

本题可以以3为边界进行求解，首先将n分别除以3，以及对3求余，便得到了a和b，如果n<=3,则结果为n-1。如果b=0，则说明n被3整除了，则结果即为3^{a。如果b==1，则结果为3}(a-1)5，如果b==2，则结果为3^a4。

（3）代码

package swordOffer.day7;

/**
 * @author chengzhengda
 * @version 1.0
 * @date 2020-04-01 16:56
 * @desc
 */
public class t32 {
    public static int cuttingRope(int n) {
        if (n <= 3) {
            return n - 1;
        }
        int a = n / 3;
        int b = n % 3;

        if (b == 0) {
            return (int) Math.pow(3, a);
        }
        if (b == 1) {
            return (int) Math.pow(3, a - 1) * 4;
        }
        return (int) Math.pow(3, a) * 2;
    }

    public static void main(String[] args) {
        System.out.println(cuttingRope(5));
    }
}

3. 树的子结构

（1）题目描述

输入两棵二叉树A和B，判断B是不是A的子结构。(约定空树不是任意一个树的子结构)
B是A的子结构， 即 A中有出现和B相同的结构和节点值。
例如:
给定的树 A:

     3
    / \
   4   5
  / \
 1   2

给定的树 B：

   4 
  /
 1

返回 true，因为 B 与 A 的一个子树拥有相同的结构和节点值。

（2）题目分析

二叉树的问题基本上都可以用递归来解决，本题只需要通过先序遍历不断递归，即可求解。

（3）代码

package swordOffer.day7;

import leetcode.week2.TreeNode;

/**
 * @author chengzhengda
 * @version 1.0
 * @date 2020-04-01 20:17
 * @desc
 */
public class t33 {
    public static boolean isSubStructure(TreeNode A, TreeNode B) {
        return (A != null && B != null) && ((isSameStructure(A, B)) ||
                isSubStructure(A.left, B) || isSubStructure(A.right, B));
    }

    public static boolean isSameStructure(TreeNode A, TreeNode B) {

        if (B == null) {
            return true;
        }
        if (A == null || !A.data.equals(B.data)) {
            return false;
        }
        return isSameStructure(A.left, B.left) && isSameStructure(A.right, B.right);
    }

    public static void main(String[] args) {
        TreeNode node11 = new TreeNode(4);
        TreeNode node12 = new TreeNode(1);
        TreeNode node13 = new TreeNode(5);
        TreeNode node14 = new TreeNode(2);
        TreeNode node15 = new TreeNode(3);
        node11.left = node12;
        node11.right = node13;
        node12.left = node14;
        node12.right = node15;

        TreeNode node21 = new TreeNode(1);
        TreeNode node22 = new TreeNode(2);
        TreeNode node23 = new TreeNode(3);
        node21.left = node22;
        node21.right = node23;

        System.out.println(isSubStructure(node11, node21));
    }
}

4. 二叉树的镜像

（1）题目描述

请完成一个函数，输入一个二叉树，该函数输出它的镜像。

例如输入：

     4
   /   \
  2     7
 / \   / \
1   3 6   9

镜像输出：

     4
   /   \
  7     2
 / \   / \
9   6 3   1

（2）题目分析

本题通过递归，不断交换二叉树的左右子树，最后得到的结果即为原二叉树的镜像。

（3）代码

package swordOffer.day7;


import charpter3.Node;
import charpter3.test1;

/**
 * @author chengzhengda
 * @version 1.0
 * @date 2020-04-05 10:33
 * @desc
 */
public class t34 {
    public static Node mirrorTree(Node root) {
        if (root == null) {
            return null;
        }
        Node temp = root.left;
        root.left = root.right;
        root.right = temp;
        mirrorTree(root.left);
        mirrorTree(root.right);
        return root;
    }

    public static void main(String[] args) {
        Node node11 = new Node(4);
        Node node12 = new Node(1);
        Node node13 = new Node(5);
        Node node14 = new Node(2);
        Node node15 = new Node(3);
        node11.left = node12;
        node11.right = node13;
        node12.left = node14;
        node12.right = node15;
        Node res = mirrorTree(node11);
        test1.preOrder(res);
    }
}

5. 对称的二叉树

（1）题目描述

请实现一个函数，用来判断一棵二叉树是不是对称的。如果一棵二叉树和它的镜像一样，那么它是对称的。

例如，二叉树 [1,2,2,3,4,4,3] 是对称的。

    1
   / \
  2   2
 / \ / \
3  4 4  3

但是下面这个 [1,2,2,null,3,null,3] 则不是镜像对称的:

    1
   / \
  2   2
   \   \
   3    3

（2）题目分析

通过不断对比二叉树的左子树的左子树与右子树的右子树，以及左子树的右子树及右子树的左子树，即可判断二叉树是否为对称二叉树。

（3）代码

package swordOffer.day7;

import leetcode.week2.TreeNode;

/**
 * @author chengzhengda
 * @version 1.0
 * @date 2020-04-05 10:54
 * @desc
 */
public class t35 {
    public static boolean isSymmetric(TreeNode root) {
        if (root == null) {
            return true;
        }
        return isTwoNodeSym(root.left, root.right);
    }

    public static boolean isTwoNodeSym(TreeNode node1, TreeNode node2) {
        if (node1 == null && node2 == null) {
            return true;
        }
        if (node1 == null || node2 == null || !(node1.data.equals(node2.data))) {
            return false;
        }
        return isTwoNodeSym(node1.left, node2.right) && isTwoNodeSym(node1.right, node2.left);

    }

    public static void main(String[] args) {
        TreeNode node11 = new TreeNode(4);
        TreeNode node12 = new TreeNode(1);
        TreeNode node13 = new TreeNode(1);
        TreeNode node14 = new TreeNode(2);
        TreeNode node15 = new TreeNode(3);
        TreeNode node16 = new TreeNode(3);
        TreeNode node17 = new TreeNode(2);
        node11.left = node12;
        node11.right = node13;
        node12.left = node14;
        node12.right = node15;
        node13.left = node16;
        node13.right = node17;
        System.out.println(isSymmetric(node11));
    }
}