二叉树基础oj练习【11道题】

最新推荐文章于 2024-05-30 10:46:44 发布
最新推荐文章于 2024-05-30 10:46:44 发布
阅读量925 收藏 27
点赞数 14
分类专栏： 数据结构（C语言实现） 数据结构题目详解（c） 文章标签： 数据结构 c语言 算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/aaa114514aaaa/article/details/138868531
版权

二叉树基础oj练习

1.单值二叉树

题目：

单值二叉树

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

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

示例 1：

img

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

示例 2：

img

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

提示：

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

思路：

image-20240512232747144

如图所示，我们采取前序遍历二叉树，让每个根都去和他的左子树和右子树的值去比较。

一旦有不同就返回false，都相同就一直遍历，直至找到叶子结点，也就是root是NULL的时候，返回true。

代码：

struct TreeNode 
{
    int val;
    struct TreeNode* left;
    struct TreeNode* right;
};

bool isUnivalTree(struct TreeNode* root)
{
    // 如果一开始就是NULL 那就相当于全部节点都是NULL
    // 如果一直判断都找不到不一样的值，就说明全都是一样的，
    // 如果全部前序遍历的递归函数全部都返回true，那就是单值二叉树
    if (root == NULL)
        return true;

    // 让当前根节点，去和左右孩子对比
    if (root->left && root->left->val != root->val)
        return false; // 不一样就返回false

    if (root->right && root->right->val != root->val)
        return false;

    // 这里其实就是前序遍历二叉树
    return isUnivalTree(root->left) && isUnivalTree(root->right);
}

2.二叉树的最大深度

题目：

二叉树的最大深度

给定一个二叉树 root ，返回其最大深度。

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

示例 1：

img

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

示例 2：

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

提示：

  • 树中节点的数量在 [0, 104] 区间内。
  • -100 <= Node.val <= 100

思路：

求出左子树的深度和右子树的深度，判断谁大， 大的就 + 1

代码：

struct TreeNode
{
    int val;
    struct TreeNode* left;
    struct TreeNode* right;
    
};


int maxDepth(struct TreeNode* root)
{
    if (root == NULL)
        return 0;

    // 计算左子树的深度 和 右子树的深度
    int leftdepth = maxDepth(root->left);
    int rightdepth = maxDepth(root->right);

    // 判断谁大，大的深度+1 就是最大深度
    return leftdepth > rightdepth ? leftdepth + 1 : rightdepth + 1;
}

3.翻转二叉树

题目：

翻转二叉树

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

示例 1：

img

输入：root = [5,7,9,8,3,2,4]
输出：[5,9,7,4,2,3,8]

提示：

  • 树中节点数目范围在 [0, 100] 内
  • -100 <= Node.val <= 100

思路：

  • 如果root不为空，那就交换其左子树和右子树

image-20240513120414247

然后让每个左子树和右子树都要调转顺序就行了

代码：

思路1：
struct TreeNode 
{
    int val;
    struct TreeNode* left;
    struct TreeNode* right;
};

typedef struct TreeNode TreeNode;

// 第一种思路 (前序)
TreeNode* mirrorTree(TreeNode* root)
{
    if (root == NULL)
        return  NULL;

    // 让根原本指向的左子树和右子树 调转  
    // 让指向左子树的指针，指向右子树，指向右子树的指针指向左子树
    TreeNode* tmp = root->left;
    root->left = root->right;
    root->right = tmp;

    // 每个左子树和右子树都要翻转
    mirrorTree(root->left);
    mirrorTree(root->right);

    ret
思路2：
// 第二种思路 (中序和后序结合)
TreeNode* mirrorTree(TreeNode* root)
{
    if (root == NULL)
    {
        return NULL;
    }
    else
    {
        // 先让左子树翻转，翻转完会返回左子树的根节点，让指向右子树的指针指向这个节点
        // 右子树同理
        // 这样就实现了根节点的左右子树翻转
        TreeNode* right = root->right;
        root->right = mirrorTree(root->left);
        root->left = mirrorTree(right);

        return root;
    }

}

4.二叉树的前序遍历

题目：

二叉树的前序遍历

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

示例 1：

img

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

示例 2：

输入：root = []
输出：[]

示例 3：

输入：root = [1]
输出：[1]

示例 4：

img

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

示例 5：

img

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

提示：

  • 树中节点数目在范围 [0, 100] 内
  • -100 <= Node.val <= 100

思路：

  1. 其实就是要让二叉树前序遍历
  2. 但是题目需要我们将遍历到的节点的值放进数组里面，而我们又不知道二叉树有多少个节点，这样就不知道数组要开辟多少空间，
  3. 因此我们需要先编写一个获取二叉树节点个数的函数
  4. 然后就让前序遍历二叉树，把遍历到的值放进数组中就行了
  5. 但是需要注意的是，传数组的下标i进去的时候，需要传址调用（因为我们采用递归来实现前序遍历）

代码：

struct TreeNode 
{
    int val;
    struct TreeNode* left;
    struct TreeNode* right;
    
};

/*
 * Note: The returned array must be malloced, assume caller calls free().
 */

    typedef struct TreeNode TreeNode;

// 获取二叉树的节点个数
int TreeSize(TreeNode* root)
{
    if (root == NULL)
    {
        return 0;
    }

    return 1 + TreeSize(root->left) + TreeSize(root->right);
}

// 前序遍历  （递归实现）
void _preorderTraversal(TreeNode* root, int* retArr, int* pi)
{
    if (root == NULL)
        return;

    retArr[(*pi)] = root->val; // i 的值我们通过解引用去拿到
    (*pi)++;


    _preorderTraversal(root->left, retArr, pi);
    _preorderTraversal(root->right, retArr, pi);
}

int* preorderTraversal(struct TreeNode* root, int* returnSize)
{
    // 创建一个数组 空间个数是二叉树的节点数
    int* retArr = (int*)malloc(sizeof(int) * TreeSize(root));

    // 前序遍历 (要把二叉树节点的值 放进retArr数组中)
    int i = 0;
    _preorderTraversal(root, retArr, &i);
    // 这里是一定要传 i的地址的，不然每次递归的时候，都会开辟新的函数栈帧，i的值无法被改变。 传值调用
    // 传地址进去就是 传址调用

    *returnSize = TreeSize(root);

    return retArr;
}

要注意递归展开的过程，理解了就能知道为什么要传址调用了。

5.二叉树的中序遍历

题目：

二叉树的中序遍历

给定一个二叉树的根节点 root ，返回 它的 中序 遍历 。

示例 1：

img

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

示例 2：

输入：root = []
输出：[]

示例 3：

输入：root = [1]
输出：[1]

提示：

  • 树中节点数目在范围 [0, 100] 内
  • -100 <= Node.val <= 100

思路：

中序遍历 - 左子树 ——根——右子树

除了要在递归的时候注意顺序，其他思路和前序是一样的。

代码：

typedef struct TreeNode TreeNode;

// 获取二叉树节点个数
int TreeSize(TreeNode* root)
{
    if (root == NULL)
        return 0;

    // 二叉树节点个数 = 1 + 左子树节点个数 + 右子树节点个数
    return 1 + TreeSize(root->left) + TreeSize(root->right);
}

// 中序遍历
void _inorderTraversal(TreeNode* root, int* retArr, int* pi)
{
    if (root == NULL)
        return;

    // 这里我们要中序遍历，【左子树 根 柚子树】
    _inorderTraversal(root->left, retArr, pi);

    retArr[(*pi)] = root->val;
    (*pi)++;

    _inorderTraversal(root->right, retArr, pi);
}


int* inorderTraversal(struct TreeNode* root, int* returnSize)
{
    // 要将遍历到的节点放进数组中
    // 我们不知道二叉树节点多少，也就不知道数组要开辟多少空间。因此需要自己写一个获取二叉树节点个数的函数
    int size = TreeSize(root);
    int* retArr = (int*)malloc(sizeof(int) * size);

    //中序遍历）（递归实现）
    int i = 0;
    _inorderTraversal(root, retArr, &i);

    *returnSize = size;

    return retArr;
}

6.二叉树的后序遍历

题目：

二叉树的后序遍历

给你一棵二叉树的根节点 root ，返回其节点值的 后序遍历 。

示例 1：

img

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

示例 2：

输入：root = []
输出：[]

示例 3：

输入：root = [1]
输出：[1]

提示：

  • 树中节点的数目在范围 [0, 100] 内
  • -100 <= Node.val <= 100

思路：

后序遍历 - 左子树——右子树——根

注意递归时的调用顺序，其他思路和前序中序差不多。

代码：

struct TreeNode 
{
    int val;
    struct TreeNode* left;
    struct TreeNode* right;
    
};

/*
 * Note: The returned array must be malloced, assume caller calls free().
 */

typedef struct TreeNode TreeNode;

// 获取二叉树的节点个数
int TreeSize(TreeNode* root)
{
    if (root == NULL)
    {
        return 0;
    }

    return 1 + TreeSize(root->left) + TreeSize(root->right);
}

// 后序遍历
void _postorderTraversal(TreeNode* root, int* retArr, int* pi)
{
    if (root == NULL)
        return;

    // 后序遍历 【左子树 右子树 根】
    _postorderTraversal(root->left, retArr, pi);
    _postorderTraversal(root->right, retArr, pi);

    retArr[(*pi)] = root->val;
    (*pi)++;
}

int* postorderTraversal(struct TreeNode* root, int* returnSize)
{
    // 要将遍历到的节点放进数组中
    // 我们不知道二叉树节点多少，也就不知道数组要开辟多少空间。因此需要自己写一个获取二叉树节点个数的函数
    int size = TreeSize(root);
    int* retArr = (int*)malloc(sizeof(int) * size);

    // 后序遍历（递归实现）
    int i = 0;
    _postorderTraversal(root, retArr, &i);

    *returnSize = size;

    return retArr;
}

7.相同的树

题目：

相同的树

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

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

示例 1：

img

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

示例 2：

img

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

示例 3：

img

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

提示：

  • 两棵树上的节点数目都在范围 [0, 100] 内
  • -104 <= Node.val <= 104

思路：

  1. 首先我们要对传进来的两个树，是否是空树进行判断。
  2. 不是空树我们就要去判断他们的结构是否相同，也是为了防止对NULL进行解引用
  3. 结构都相同那就去判断他们的值是否相同，不同就返回false
  4. 然后通过递归去判断两个数的每一个节点是否相同

代码：

struct TreeNode 
{
    int val;
    struct TreeNode* left;
    struct TreeNode* right;
};

bool isSameTree(struct TreeNode* p, struct TreeNode* q)
{
    // 判断传进来的两棵树是否是空树
    if (p == NULL && q == NULL)
        return true;

    // 为了防止对NULL解引用，我们要先对其结构判断是否相同
    if (p != NULL && q == NULL)
        return false;
    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);
}

8.对称二叉树

题目：

对称二叉树

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

示例 1：

img

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

示例 2：

img

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

提示：

  • 树中节点数目在范围 [1, 1000] 内
  • -100 <= Node.val <= 100

**进阶：**你可以运用递归和迭代两种方法解决这个问题吗？

思路：

  1. 首先我们要判断传进来的树是否是空树，空树就是true。
  2. 然后我们要判断根的左子树和右子树结构是否轴对称，结构都不轴对称，false
  3. 结构轴对称了我们就要去判断其值是否轴对称

代码:

struct TreeNode 
{
    int val;
    struct TreeNode* left;
    struct TreeNode* right;
};

typedef struct TreeNode TreeNode;

bool isMirror(TreeNode* left, TreeNode* right)
{
    // 判断左右子树的结构
    if (left == NULL && right == NULL)
        return true;
    // 左子树或这样右子树有一个是NULL 就是false
    if (right == NULL || left == NULL)
        return false;

    // 除了结构要对称，也要判断其值是否轴对称
    return (left->val == right->val) &&
        isMirror(left->left, right->right) &&
        isMirror(left->right, right->left);
}

bool isSymmetric(struct TreeNode* root)
{
    // 判断传进来的树是否为空
    if (root == NULL)
        return true;

    // 判断每个左子树右子树是否轴对称
    return isMirror(root->left, root->right);
}

9.另一棵树的子树

题目：

另一棵树的子树

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

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

示例 1：

img

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

示例 2：

img

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

提示：

  • root 树上的节点数量范围是 [1, 2000]
  • subRoot 树上的节点数量范围是 [1, 1000]
  • -104 <= root.val <= 104
  • -104 <= subRoot.val <= 104

思路：

让root上的每一课树都去和subRoob这课树去比较是否相同。

在比较树是否相同的时候，要注意结构和值都要比较是否相同。

递归到NULL就要返回

代码：

struct TreeNode 
{
    int val;
    struct TreeNode* left;
    struct TreeNode* right;
};

// 判断两棵树是否相同
bool isSameTree(struct TreeNode* p, struct TreeNode* q)
{
    // 判断传进来的两棵树是否是空树
    if (p == NULL && q == NULL)
        return true;

    // 为了防止对NULL解引用，我们要先对其结构判断是否相同
    if (p != NULL && q == NULL)
        return false;
    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。

    // 先让root根结点去和subRoot进行比较
    if(isSameTree(root, subRoot))
        return true;

    // 走到这里，说明根节点不包含subRoob这棵树
    // 那就继续让root中的左子树和右子树 去比较
    return isSubtree(root->left, subRoot) || isSubtree(root->right, subRoot);
}

如果理解困难就去画递归展开图

image-20240513202057395

10.平衡二叉树

题目：

平衡二叉树

给定一个二叉树，判断它是否是 平衡二叉树

示例 1：

img

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

示例 2：

img

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

示例 3：

输入：root = []
输出：true

提示：

  • 树中的节点数在范围 [0, 5000] 内
  • -104 <= Node.val <= 104

思路：

  1. 求出每个根结点的左子树和右子树的高度， 判断其相减的绝对值是否小于等于1
  2. 如果小于等于1 ，那这个根结点代表的子树是平衡二叉树， 但是这样就ok了嘛？
  3. 不是，我们还有继续遍历二叉树，必须是每个子树都是平衡二叉树，整个树才是平衡二叉树。
  4. 因此我们还要接着遍历，判断根结点的左子树代表的子树是否是平衡二叉树，右子树代表的子树是否是平衡二叉树，直至遍历完全部的子树。

image-20240513221453719

代码：

struct TreeNode 
{
    int val;
    struct TreeNode* left;
    struct TreeNode* right;
};

// 计算传进来的树 的最大深度
int MaxDepth(struct TreeNode* root) // 时间复杂度为O（N）
{
    if (root == NULL)
        return 0;

    // 左子树和右子树的深度都要计算
    int leftdepth = MaxDepth(root->left);
    int rightdepth = MaxDepth(root->right);

    // 树的深度 = 左子树/右子树 的最大深度 + 1
    return leftdepth > rightdepth ? leftdepth + 1 : rightdepth + 1;
}

bool isBalanced(struct TreeNode* root) // 时间复杂度为 O(N^2)
{
    // 如果传进来的根结点，是空，那说明这个根结点代表的子树是平衡二叉树
    if (root == NULL)
        return true;

    // 如果不是空就去计算这个根节点 左子树和右子树的深度 并判断其相减的绝对值是否<=1
    int leftdepth = MaxDepth(root->left);
    int rightdepth = MaxDepth(root->right);
    if (abs(leftdepth - rightdepth) > 1)
        return false;

    // 每一个根结点(每一个根节点都代表一个子树)都要去判断是否是平衡二叉树
    return isBalanced(root->left) && isBalanced(root->right);
}

尽管上面我们的代码可以实现功能，但是我们的时间复杂度是O(N^2)。

这是因为我们的代码是采用的前序遍历二叉树，会有大量的重复计算——就比如，其实我们再调用第一次函数的时候，所有节点的左右子树的深度都被计算过了，但是我们仍然会进行重复计算。 这就导致我们的代码效率比较低下。

那我们是否可以做到优化呢？

其实是可以的，我们可以采用后序遍历二叉树。

从最后的左右子树开始计算其深度，并判断是否为平衡二叉树，如果是就返回深度，往上遍历，这样子处理，每个根节点的深度就只用被计算一次，并且遇到不是平衡二叉树的根节点，也可以及时退出递归。

image-20240514012209623

注意了，这个过程是后序遍历实现的

思路讲完了，我们来实现一下代码：

优化后代码：

bool _isBalanced(struct TreeNode* root, int* pdepth)
{
    // 判断传进来的根节点是否是NULL
    if(root == NULL)
    {
        *pdepth = 0;
        return true;
    }
    
    // 后序遍历 

    // 先递归左子树
    int leftdepth = 0; // 记录左子树的深度
    if(_isBalanced(root->left, &leftdepth) == false)
        return false; // 不是平衡二叉树就不用带上高度的计算了

    // 递归右子树
    int rightdepth = 0; //记录右子树的深度
    if(_isBalanced(root->right, &rightdepth) == false)
        return false; // 不是平衡二叉树就不用带上高度的计算了
    
    int gas = leftdepth - rightdepth;
    if(abs(gas) > 1)
        return false;

    // 走到这里 说明，当前节点是平衡二叉树，那就计算高度
    *pdepth = leftdepth > rightdepth ? leftdepth + 1 : rightdepth + 1;
    return true;
}

bool isBalanced(struct TreeNode* root)  // 时间复杂度是O(N)
{

    //计算其每个左右子树的深度，并判断其是否为平衡二叉树
    // 为了提高效率使用后序遍历二叉树
    // 我们使用子函数去实现后序遍历

    int depth = 0;
    return _isBalanced(root, &depth); // 传第二个参数的目的是判断的同时，带高度 这样才能实现时间复杂度的优化
}

11.二叉树的构建和遍历（清华考研题）

题目：

二叉树遍历_牛客题霸_牛客网 (nowcoder.com)

描述

编一个程序，读入用户输入的一串先序遍历字符串，根据此字符串建立一个二叉树（以指针方式存储）。 例如如下的先序遍历字符串： ABC##DE#G##F### 其中“#”表示的是空格，空格字符代表空树。建立起此二叉树以后，再对二叉树进行中序遍历，输出遍历结果。

输入描述：

输入包括1行字符串，长度不超过100。

输出描述：

可能有多组测试数据，对于每组数据， 输出将输入字符串建立二叉树后中序遍历的序列，每个字符后面都有一个空格。 每个输出结果占一行。

示例1

输入：

abc##de#g##f###

输出：

c b e g d f a

思路：

  1. 先通过前序遍历构建出这个二叉树的。
  2. 然后再用中序遍历去访问这课二叉树

image-20240514094443879

代码：

#include <stdio.h>


typedef struct TreeNode
{
    char val;
    struct TreeNode* left;
    struct TreeNode* right;
}TreeNode;

void InOrder(TreeNode* root)
{
    if(root == NULL)
        return;
    
    // 中序遍历
    InOrder(root->left);
    printf("%c ", root->val);
    InOrder(root->right);
} 

TreeNode* CreateTree(char* str, int* pi)
{
    // 判断此时是否为NULL 
    if(str[*pi] == '#')
    {
        (*pi)++;
        return NULL;
    }
    else 
    {
        // 不为NULL就要构建节点
        TreeNode* root = (TreeNode*)malloc(sizeof(TreeNode));

        // 根据先序构建二叉树 【根——左子树——右子树】
        root->val = str[*pi];
        (*pi)++;

        root->left = CreateTree(str, pi); 
        root->right = CreateTree(str, pi);
        
        return root;
    }
}

int main() 
{
    // 让用户输入以先序遍历的字符串
    char str[100];
    scanf("%s", str);

    // 根据字符串去先序构建二叉树
    int i = 0;
    TreeNode* root = CreateTree(str, &i);// 为了让所有递归用的是同一个i 必须传地址

    // 中序遍历二叉树
    InOrder(root);

    return 0;
}
WZF-Sang
关注
  • 14
    点赞
  • 踩
  • 27
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
实验4.二叉树基础题.cpp
05-23
实验4.二叉树基础题.cpp
二叉树面试题 树和二叉树总结.doc
02-24
二叉树面试题 树和二叉树考研试题总结
二叉树基础OJ练习
m0_65105533的博客
04-03 94
二叉树的OJ练习
二叉树基础oj练习
xiguazkb123的博客
01-24 356
1. 单值二叉树。Oj链接 2. 检查两颗树是否相同。OJ链接 3. 对称二叉树。OJ链接 4. 二叉树的前序遍历。 OJ链接 5. 二叉树中序遍历 。OJ链接 6. 二叉树的后序遍历 。OJ链接 7. 另一颗树的子树。OJ链接 8.二叉树遍历
二叉树基础oj练习-
Dingyuan0的博客
05-25 147
二叉树 按照规则，二叉树的遍历有：前序/中序/后序的递归结构遍历： 前序遍历(Preorder Traversal 亦称先序遍历)——访问根结点的操作发生在遍历其左右子树之前。 中序遍历(Inorder Traversal)——访问根结点的操作发生在遍历其左右子树之中（间）。 后序遍历(Postorder Traversal)——访问根结点的操作发生在遍历其左右子树之后。 题目链接 1.链接: 单值二叉树 2.链接: 相同的树 3.链接: 对称二叉树 4.链接: 二叉树的前序遍历 5.链接: 二叉树
数据结构之二叉树基础oj练习
weixin_56054625的博客
03-21 481
1.单值二叉树 力扣https://leetcode-cn.com/problems/univalued-binary-tree/ 以上是递归图解思路：这样的思路非常不好想到。 也就是利用了我们的分治思想和逆向思维。 首先说说这里的分治思想： 分治也就是要一层一层地分治下去判断。 第一个if语句在这里起到了非常关键的作用，为什么这样说呢？ 这个if函数我们设计者的本意可能是防止root为空时，那么也属于单值二叉树，但是听过我们画了递归图后发现，这个if函数竟然在后面强大地起到了判断..
（C语言）二叉树经典oj题练习
博主qq1077644249
08-16 656
我们先自己定义一个二叉树结构体类型，然后基于分治的思想，递归构建二叉树，构建二叉树先malloc出根节点然后再构建左子树，右子树即可。因为字符串需要构建之后指针向后移动找到下一个字符，所以需要定义一个i下标，通过传址调用把i的地址传过去，实现对下标i的控制。构建之后i下标向后移动，指针指向’#‘代表到了空节点了完成返回NULL即可。如果一个树的左子树与右子树镜像对称，那么这个树是对称的。 > 因此，如果同时满足下面的条件，两个树互为镜像： > 1、它们的两个根结点具有相同的值 > 2、每个树的右子树都与
数据结构之二叉树基础OJ练习对称二叉树
小赵小赵福星高照的博客
09-19 223
对称二叉树 题目来源：对称二叉树 题目描述： 给定一个二叉树，检查它是否是镜像对称的。 例如，二叉树 [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 解题思路： 判断一个二叉树是不是镜像对称，也是需要用到分治的思想，判断一颗二叉树是否对称，相当于判断它的左右子树是不是镜像对称，判断两个左
【数据结构】二叉树经典OJ练习
Edward_Asia的博客
11-15 2829
前言 本章只是二叉树的部分简单练习，对于这部分题目大多比较简单，但重要的不是能过OJ，而是深入理解每一道题的解题原理。 多思考，勤动手，才是正解。对于编程，我们要做到画图半小时，写代码五分钟；而不是写代码五分钟，调试三十分钟。 理解递归思想，分治思想，温故而知新~ 1.单值二叉树 单值二叉树 根据题目描述，判断二叉树的每个节点的值是否相同。 方法： 先判断根节点与左右子节点的值是否相等。 进而递归判断左右子树的根节点与左右子节点的值是否相等。 代码如下： bool isU.
二叉树的OJ练习题
qq_54717101的博客
10-21 813
单值二叉树，二叉树的最大深度，翻转二叉树，相同的树，二叉树的前序遍历，判断一颗二叉树是否是平衡二叉树，另一颗树的字树，对称二叉树
【数据结构和算法】二叉树基础oj练习
2401_84412624的博客
04-20 630
关于分布式，限流+缓存+缓存，这三大技术（包含：ZooKeeper+Nginx+MongoDB+memcached+Redis+ActiveMQ+Kafka+RabbitMQ）等等。这些相关的面试也好，还有手写以及学习的笔记PDF，都是啃透分布式技术必不可少的宝藏。以上的每一个专题每一个小分类都有相关的介绍，并且小编也已经将其整理成PDF啦《互联网大厂面试真题解析、进阶开发核心学习笔记、全套讲解视频、实战项目源码讲义》点击传送门即可获取！F。
二叉树_二叉树的基础操作_
09-30
实现了二叉树的相关功能，比如节点的定义，树的生成，遍历等基本操作
二叉树练习题及答案.docx
12-05
。。。
java基础面试题重建二叉树
05-12
java基础面试题重建二叉树提取方式是百度网盘分享地址
C语言序列化与反序列化--TCL中支持的数据结构（二）
最新发布
weixin_44939146的博客
05-30 718
如果您计划在您的平台上使用tpl的f格式字符序列化double，首先要确保您的double是64位的。变长数组可以包含简单或复杂的元素——例如，整型数组A(i)，整型/双精度对数组A(if)，甚至是嵌套数组A(A(if))。一般来说，尽可能使用固定长度的数组，必要时使用可变长度的数组。)都有自己的索引号。将索引号传递给tpl_pack和tpl_unpack，以指定要处理哪个变长数组(或者索引号为0的情况下的非数组)。当您解包二进制缓冲区时，tpl将自动分配它，并将用它的地址和长度填充tpl_bin结构。
Java实现数据结构---数组
大自然的代码搬运工
05-28 293
数组是（Array）是的变量所组成的集合，数组中的每一个变量为称为。数组是最简单、最常用的数据结构。数组下标从开始。
数据结构-堆排序问题
Jason_from_China的博客
05-27 305
在建堆之后，函数进入一个循环，每次循环中，它将堆顶元素（当前堆中的最小元素）与当前堆的最后一个元素交换。然后，堆的大小减少 1，并且对剩余的堆进行向下调整以保持最小堆性质。如果相反的话，会导致根节点变化，从而导致逻辑混乱，数组里面的数值少的时候是不明显的，但是多的时候就不行了。函数来构建一个小顶堆（最小堆）。：循环继续进行，直到堆的大小减小到 0。1，需要在数组里面进行排序，我们可以采取在数组建堆。函数实现了一个堆排序算法，它接收一个整数数组。2，然后交换收尾元素，每次调整的数值减少1。
C-数据结构-树状存储的基本实现
aqiangdeba的博客
05-27 926
main.c320。
二叉树前中后序练习题
02-14
很好，我可以为您提供一些二叉树的前中后序遍历练习题。 1. 给定一棵二叉树，请按照前序遍历的顺序输出所有的节点。 2. 给定一棵二叉树，请按照中序遍历的顺序输出所有的节点。 3. 给定一棵二叉树，请按照后序...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值