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整除了,则结果即为3a。如果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));
}
}