数据结构与算法⑮(第四章_下)二叉树OJ(力扣:144,965,104,110,226,100,101,572)

144. 二叉树的前序遍历

难度简单

给你二叉树的根节点 root ，返回它节点值的 前序 遍历。

示例 1：

输入：root = [1,null,2,3]

输出：[1,2,3]

示例 2：

输入：root = [ ]

输出：[ ]

示例 3：

输入：root = [1]

输出：[1]

示例 4：

输入：root = [1,2]

输出：[1,2]

示例 5：

输入：root = [1,null,2]

输出：[1,2]

提示：

• 树中节点数目在范围 [0, 100] 内

• -100 <= Node.val <= 100

进阶：递归算法很简单，你可以通过迭代算法完成吗？

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     struct TreeNode *left;
 *     struct TreeNode *right;
 * };
 */
/**
 * Note: The returned array must be malloced, assume caller calls free().
 */
int* preorderTraversal(struct TreeNode* root, int* returnSize){

}

解析代码：

ps（迭代算法我们要学了C++之后的高阶数据结构再实现）

int TreeSize(struct TreeNode* root)
{
    if(root==NULL)
    {
        return 0;
    }
    return 1 + TreeSize(root->left) + TreeSize(root->right);
}

void _preorderTraversal(struct TreeNode* root,int* array,int* pi) // (函数前面的_代表这个函数的子函数，通常用来递归)
{
    if(root==NULL)
    {
        return;
    }
    array[(*pi)++] = root->val;//注意这里就是要传i的地址的原因（不然每个栈帧都有一个i）
    _preorderTraversal(root->left,array,pi);
    _preorderTraversal(root->right,array,pi);
}

int* preorderTraversal(struct TreeNode* root, int* returnSize){
    int size = TreeSize(root);
    int* array=(int*)malloc(sizeof(int)*size);
    int i = 0;
    _preorderTraversal(root,array,&i);

    *returnSize=size;
    return array;
}

（写完这题可以去写写二叉树的中序遍历和后序遍历，都是一样的）链接：

94. 二叉树的中序遍历 - 力扣（LeetCode）

145. 二叉树的后序遍历 - 力扣（LeetCode）

965. 单值二叉树

难度简单

如果二叉树每个节点都具有相同的值，那么该二叉树就是单值二叉树。

只有给定的树是单值二叉树时，才返回 true；否则返回 false。

示例 1：

输入：[1,1,1,1,1,null,1]

输出：true

示例 2：

输入：[2,2,2,5,2]

输出：false

提示：

1. 给定树的节点数范围是 [1, 100]。

2. 每个节点的值都是整数，范围为 [0, 99] 。

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     struct TreeNode *left;
 *     struct TreeNode *right;
 * };
 */

bool isUnivalTree(struct TreeNode* root){

}

解析代码：

bool isUnivalTree(struct TreeNode* root) {
    if (root == NULL)//空结点就返回true
    {
        return true;
    }
    if (root->left && root->val != root->left->val)
    {
        return false;
    }
    if (root->right && root->val != root->right->val)
    {
        return false;
    }
    //走到这就是结点的左右孩子存在时的值都等于父亲的值（符合单值二叉树）
    //返回这个左子树和右子树都是单值二叉树（只要有一个不是就是false）
    return isUnivalTree(root->left) && isUnivalTree(root->right);
}

104. 二叉树的最大深度

难度简单

给定一个二叉树，找出其最大深度。

二叉树的深度为根节点到最远叶子节点的最长路径上的节点数。

说明: 叶子节点是指没有子节点的节点。

示例：

给定二叉树 [3,9,20,null,null,15,7]，

3

/ \

9 20

/ \

15 7

返回它的最大深度 3 。

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     struct TreeNode *left;
 *     struct TreeNode *right;
 * };
 */

int maxDepth(struct TreeNode* root){

}

解析代码：

/*int maxDepth(struct TreeNode* root) {
    if (root == NULL)
    {
        return 0;
    }
    return maxDepth(root->left) > maxDepth(root->right) 
           ? maxDepth(root->left) + 1 : maxDepth(root->right) + 1;
}*/  //这样写会有重复的递归计算，  优化：
int maxDepth(struct TreeNode* root) {
    if (root == NULL)
    {
        return 0;
    }
    int leftDepth = maxDepth(root->left);
    int rightDepth = maxDepth(root->right);
    return leftDepth > rightDepth ? leftDepth + 1 : rightDepth + 1;
}

110. 平衡二叉树

给定一个二叉树，判断它是否是高度平衡的二叉树。

本题中，一棵高度平衡二叉树定义为：

一个二叉树 每个节点 的左右两个子树的高度差的绝对值不超过 1 。

示例 1：

输入：root = [3,9,20,null,null,15,7]

输出：true

示例 2：

输入：root = [1,2,2,3,3,null,null,4,4]

输出：false

示例 3：

输入：root = []

输出：true

提示：

• 树中的节点数在范围 [0, 5000] 内

• -10^4 <= Node.val <= 10^4

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     struct TreeNode *left;
 *     struct TreeNode *right;
 * };
 */
bool isBalanced(struct TreeNode* root){

}

解析代码：

int maxDepth(struct TreeNode* root) {
    if (root == NULL)
    {
        return 0;
    }
    int leftDepth = maxDepth(root->left);
    int rightDepth = maxDepth(root->right);
    return leftDepth > rightDepth ? leftDepth + 1 : rightDepth + 1;
}

bool isBalanced(struct TreeNode* root){
    if(root == NULL)
    {
         return true;
    }
    //当前树的左右子树高度差不大于1，并且左右子树本身也是平衡树。
    return (abs(maxDepth(root->left) - maxDepth(root->right)) <= 1)
        && isBalanced(root->left) && isBalanced(root->right);
}

226. 翻转二叉树

难度简单

给你一棵二叉树的根节点 root ，翻转这棵二叉树，并返回其根节点。

示例 1：

输入：root = [4,2,7,1,3,6,9]

输出：[4,7,2,9,6,3,1]

示例 2：

输入：root = [2,1,3]

输出：[2,3,1]

示例 3：

输入：root = []

输出：[]

提示：

• 树中节点数目范围在 [0, 100] 内

• -100 <= Node.val <= 100

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     struct TreeNode *left;
 *     struct TreeNode *right;
 * };
 */

struct TreeNode* invertTree(struct TreeNode* root){

}

解析代码（一）：

struct TreeNode* invertTree(struct TreeNode* root) {
    if (root == NULL)
    {
        return NULL;
    }
    //把左孩子和右孩子交换一下
    struct TreeNode* tmp = root->left;
    root->left = root->right;
    root->right = tmp;
    //递归交换每一个结点和左孩子和右孩子
    invertTree(root->left);
    invertTree(root->right);
    return root;
}

解析代码（二）：

struct TreeNode* invertTree(struct TreeNode* root) {
    if (root == NULL)
    {
        return NULL;
    }
    //直接交换返回来的结点
    struct TreeNode* rightTmp = root->right;
    root->right = invertTree(root->left);
    root->left = invertTree(rightTmp);

    return root;
}

100. 相同的树

难度简单

给你两棵二叉树的根节点 p 和 q ，编写一个函数来检验这两棵树是否相同。

如果两个树在结构上相同，并且节点具有相同的值，则认为它们是相同的。

示例 1：

输入：p = [1,2,3], q = [1,2,3]

输出：true

示例 2：

输入：p = [1,2], q = [1,null,2]

输出：false

示例 3：

输入：p = [1,2,1], q = [1,1,2]

输出：false

提示：

• 两棵树上的节点数目都在范围 [0, 100] 内

• -10^4 <= Node.val <= 10^4

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     struct TreeNode *left;
 *     struct TreeNode *right;
 * };
 */

bool isSameTree(struct TreeNode* p, struct TreeNode* q){

}

解析代码：

bool isSameTree(struct TreeNode* p, struct TreeNode* q) {
    if (p == NULL && q == NULL)
    {
        return true;
    }
    if (p == NULL || q == NULL)//其中一个为空，另一个不为空
    {
        return false;
    }
    if (p->val != q->val)
    {
        return false;
    }
    //走到这就是结点相等，返回它们的左子树相等并且右子树相等
    return isSameTree(p->left, q->left)
        && isSameTree(p->right, q->right);
}

101. 对称二叉树

难度简单

给你一个二叉树的根节点 root ， 检查它是否轴对称。

示例 1：

输入：root = [1,2,2,3,4,4,3]

输出：true

示例 2：

输入：root = [1,2,2,null,3,null,3]

输出：false

提示：

• 树中节点数目在范围 [1, 1000] 内

• -100 <= Node.val <= 100

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     struct TreeNode *left;
 *     struct TreeNode *right;
 * };
 */
bool isSymmetric(struct TreeNode* root){

}

解析代码：

bool _isSymmetric(struct TreeNode* p, struct TreeNode* q) {
    if (p == NULL && q == NULL)
    {
        return true;
    }
    if (p == NULL || q == NULL)//其中一个为空，另一个不为空
    {
        return false;
    }
    if (p->val != q->val)
    {
        return false;
    }
    //和上面一题一样，到这返回一个树的左/右和另一个树的右/左相等
    return _isSymmetric(p->left, q->right)
        && _isSymmetric(p->right, q->left);
}

bool isSymmetric(struct TreeNode* root){
    if(root==NULL)
    {
        return true;
    }
    return _isSymmetric(root->left,root->right);
}

572. 另一棵树的子树

难度简单

给你两棵二叉树 root 和 subRoot 。检验 root 中是否包含和 subRoot 具有相同结构和节点值的子树。如果存在，返回 true ；否则，返回 false 。

二叉树 tree 的一棵子树包括 tree 的某个节点和这个节点的所有后代节点。tree 也可以看做它自身的一棵子树。

示例 1：

输入：root = [3,4,5,1,2], subRoot = [4,1,2]

输出：true

示例 2：

输入：root = [3,4,5,1,2,null,null,null,null,0], subRoot = [4,1,2]

输出：false

提示：

• root 树上的节点数量范围是 [1, 2000]

• subRoot 树上的节点数量范围是 [1, 1000]

• -10^4 <= root.val <= 10^4

• -10^4 <= subRoot.val <= 10^4

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     struct TreeNode *left;
 *     struct TreeNode *right;
 * };
 */

bool isSubtree(struct TreeNode* root, struct TreeNode* subRoot) {

}

解析代码：

bool isSameTree(struct TreeNode* p, struct TreeNode* q)
{
    if (p == NULL && q == NULL)
    {
        return true;
    }
    if (p == NULL || q == NULL)//其中一个为空，另一个不为空
    {
        return false;
    }
    if (p->val != q->val)
    {
        return false;
    }
    return isSameTree(p->left, q->left) 
        && isSameTree(p->right, q->right);
}

bool isSubtree(struct TreeNode* root, struct TreeNode* subRoot){
    if(root == NULL)
    {
        return false;
    }
    //遍历root的每一个结点和subRoot比较一下，一样就返回true
    if(isSameTree(root,subRoot))
    {
        return true;
    }
    //遍历root的每一个结点,有一个true就是true
    return isSubtree(root->left,subRoot) 
        || isSubtree(root->right,subRoot);
}

本篇完。（附下篇链接）

穿越回来复习顺便贴个链接：

数据结构与算法⑯(第四章_收尾)二叉树的层序遍历和一道OJ_GR C的博客-CSDN博客