二叉树基础练习（C语言实现）

目录

二叉树基础练习

单值二叉树

检查两棵树是否相同

对称二叉树

二叉树的前序遍历

二叉树的中序遍历

二叉树的后序遍历

另一棵树的子树

二叉树前序构建

---

二叉树基础练习

单值二叉树

题目链接：965. 单值二叉树 - 力扣（LeetCode）

如果二叉树每个节点都具有相同的值，那么该二叉树就是 单值二叉树
只有给定的树是单值二叉树时，才返回 true；否则返回 false

思路解析：

本题可以考虑用到相等式的传递性，即a=b且b = c时，有a = c，代入到本题中，可以考虑当根节点与其孩子节点相同，孩子节点作为父亲节点与其孩子节点相同，那么此时可以说明根节点与最下方的孩子节点相同，层层递进，最后可以判断整体是否为单值

参考代码

/*
 * @lc app=leetcode.cn id=965 lang=c
 *
 * [965] 单值二叉树
 */

// @lc code=start
/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     struct TreeNode *left;
 *     struct TreeNode *right;
 * };
 */
bool isUnivalTree(struct TreeNode *root)
{
    // 注意空返回true，如果返回false则将空节点也作为了值判断
    if (root == NULL)
    {
        return true;
    }

    // 判断根节点与左孩子是否相同，不同返回false
    if (root->left != NULL && root->val != root->left->val)
    {
        return false;
    }

    // 判断根节点与右孩子是否相同，不同返回false
    if (root->right != NULL && root->val != root->right->val)
    {
        return false;
    }

    // 如果两个if都没有执行，说明根节点与其孩子相同，可以继续往下判断
    return isUnivalTree(root->left) && isUnivalTree(root->right);
}
// @lc code=end

检查两棵树是否相同

题目链接：100. 相同的树 - 力扣（LeetCode）

给你两棵二叉树的根节点 p 和 q ，编写一个函数来检验这两棵树是否相同。
如果两个树在结构上相同，并且节点具有相同的值，则认为它们是相同的。

思路解析：

本题推荐使用前序遍历的思路，如果根节点不相同，那么直接可以返回false，如果使用中序和后序，那么可能出现的情况是孩子比较完相等，但是回到比较根节点时，发现根节点不相同，那么孩子相同也没有意义，注意此题和上题有一点不一样的地方：因为本题是一个节点一个节点比较，每一次比较不论是孩子节点还是父亲节点都是独立比较，不需要在每一次比较中，将父亲节点和孩子节点比较，具体思路如下：

参考代码

/*
 * @lc app=leetcode.cn id=100 lang=c
 *
 * [100] 相同的树
 */

// @lc code=start
/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     struct TreeNode *left;
 *     struct TreeNode *right;
 * };
 */
bool isSameTree(struct TreeNode *p, struct TreeNode *q)
{
    // 使用前序遍历来进行递归
    // 此处需要判断根节点是否为空
    // 如果两个根节点均为空依旧返回true，根节点都为空说明就是空树，空树肯定相同
    if (p == NULL && q == NULL)
    {
        return true;
    }

    // 有一个根节点为空则返回false
    if (p == NULL || q == NULL)
    {
        return false;
    }
    // 因为前序可以先判断根节点，如果根节点不相同，则直接返回false
    if (p->val != q->val)
    {
        return false;
    }

    // 此处说明根节点相同
    return isSameTree(p->left, q->left) && isSameTree(p->right, q->right);
}
// @lc code=end

对称二叉树

题目链接：101. 对称二叉树 - 力扣（LeetCode）

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

思路解析：

本题可以考虑将一棵树分为两部分，一部分是左子树，一部分是右子树，先比较两棵树的根节点，再一棵树的左子树和另一棵树的右子树比较，再一棵树的右子树和另一棵树的左子树比较，不相等返回false

参考代码

/*
 * @lc app=leetcode.cn id=101 lang=c
 *
 * [101] 对称二叉树
 */

// @lc code=start
/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     struct TreeNode *left;
 *     struct TreeNode *right;
 * };
 */
// 子函数
bool _isSymmetric(struct TreeNode *leftTree, struct TreeNode *rightTree)
{
    // 如果左子树和右子树均为空返回true
    if (leftTree == NULL && rightTree == NULL)
    {
        return true;
    }

    // 如果左子树和右子树有一个为空返回false
    if (leftTree == NULL || rightTree == NULL)
    {
        return false;
    }

    if (leftTree->val != rightTree->val)
    {
        return false;
    }

    // 如果上面的if没有执行，说明二者相同
    return _isSymmetric(leftTree->left, rightTree->right) && _isSymmetric(leftTree->right, rightTree->left);
}

bool isSymmetric(struct TreeNode *root)
{
    // 因为本题设置的函数只有一个根参数，故需要创建一个子函数处理左子树和右子树问题
    return _isSymmetric(root->left, root->right);
}
// @lc code=end

二叉树的前序遍历

题目链接：144. 二叉树的前序遍历 - 力扣（LeetCode）

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

思路解析

本题直接使用前序遍历的思路即可，但是需要注意部分问题：

1. 因为本题中的前序遍历需要将数值存入连续的空间中然后返回该空间起始位置，故需要处理好返回的空间以及开辟的空间大小
2. 因为连续的空间在遍历过程中会使用到下标，每一个递归都是一个新的函数栈帧，那么需要处理下一次递归时下标的值

针对上面的问题，提出下面的解决方案：

1. 对于连续的空间就不开辟数组，而是在堆上开辟连续的空间，而处理开辟大小可以考虑判断是否存在根节点、左子树和右子树，具体思路如下：使用递归求大小，首先判断首先判断是否存在根节点，如果根节点都不存在那么就没必要开空间，再判断左子树和右子树是否为空，如果左子树为空返回0，如果右子树为空返回0，最后回到主调函数求出需要返回的空间大小

1. 因为需要在遍历的同时更改下标的数值，所以如果在形式参数时只是传递数值，那么在新的函数栈帧中将会被赋值为主调函数的值，而不是更新后的值，所以考虑用指针传递

参考代码

/*
 * @lc app=leetcode.cn id=144 lang=c
 *
 * [144] 二叉树的前序遍历
 */

// @lc code=start
/**
 * 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 CreateSpace(struct TreeNode *root)
{
    return root == NULL ? 0 : CreateSpace(root->left) + CreateSpace(root->right) + 1;
}

// 处理前序遍历
void _preOrderTranversal(struct TreeNode *root, int *data, int *i)
{
    if (root == NULL)
    {
        return;
    }

    data[(*i)++] = root->val;
    //此处需要传递变量i的指针，而不是变量i的值，因为如果传递值，在遍历左子树时并没有实际更改i中的值
    //在遍历左子树的过程中更改的i的数值只是在左子树遍历中有效，但是右子树接收到的i还是主调函数的i，此时会导致出现随机值
    _preOrderTranversal(root->left, data, i);
    _preOrderTranversal(root->right, data, i);
}

int *preorderTraversal(struct TreeNode *root, int *returnSize)
{
    // 开辟空间
    *returnSize = CreateSpace(root);
    int *p = (int *)malloc(sizeof(int) * (*returnSize));
    int i = 0;
    _preOrderTranversal(root, p, &i);
    return p;
}
// @lc code=end

二叉树的中序遍历

题目链接：94. 二叉树的中序遍历 - 力扣（LeetCode）

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

思路解析：

与二叉树的前序遍历类似

参考代码

/*
 * @lc app=leetcode.cn id=94 lang=c
 *
 * [94] 二叉树的中序遍历
 */

// @lc code=start
/**
 * 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 CreateSpace(struct TreeNode *root)
{
    return root == NULL ? 0 : CreateSpace(root->left) + CreateSpace(root->right) + 1;
}

// 处理中序遍历
void _inOrderTranversal(struct TreeNode *root, int *data, int *i)
{
    if (root == NULL)
    {
        return;
    }

    // 此处需要传递变量i的指针，而不是变量i的值，因为如果传递值，在遍历左子树时并没有实际更改i中的值
    // 在遍历左子树的过程中更改的i的数值只是在左子树遍历中有效，但是右子树接收到的i还是主调函数的i，此时会导致出现随机值
    _inOrderTranversal(root->left, data, i);
    data[(*i)++] = root->val;
    _inOrderTranversal(root->right, data, i);
}
int *inorderTraversal(struct TreeNode *root, int *returnSize)
{
    // 开辟空间
    *returnSize = CreateSpace(root);
    int *p = (int *)malloc(sizeof(int) * (*returnSize));
    int i = 0;
    _inOrderTranversal(root, p, &i);
    return p;
}
// @lc code=end

二叉树的后序遍历

题目链接：145. 二叉树的后序遍历 - 力扣（LeetCode）

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

思路解析：

与二叉树的前序遍历思路类似

参考代码

/*
 * @lc app=leetcode.cn id=145 lang=c
 *
 * [145] 二叉树的后序遍历
 */

// @lc code=start
/**
 * 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 CreateSpace(struct TreeNode *root)
{
    return root == NULL ? 0 : CreateSpace(root->left) + CreateSpace(root->right) + 1;
}

// 处理后序遍历
void _postOrderTranversal(struct TreeNode *root, int *data, int *i)
{
    if (root == NULL)
    {
        return;
    }

    // 此处需要传递变量i的指针，而不是变量i的值，因为如果传递值，在遍历左子树时并没有实际更改i中的值
    // 在遍历左子树的过程中更改的i的数值只是在左子树遍历中有效，但是右子树接收到的i还是主调函数的i，此时会导致出现随机值
    _postOrderTranversal(root->left, data, i);
    _postOrderTranversal(root->right, data, i);
    data[(*i)++] = root->val;
}
int *postorderTraversal(struct TreeNode *root, int *returnSize)
{
    // 开辟空间
    *returnSize = CreateSpace(root);
    int *p = (int *)malloc(sizeof(int) * (*returnSize));
    int i = 0;
    _postOrderTranversal(root, p, &i);
    return p;
}
// @lc code=end

另一棵树的子树

题目链接：572. 另一棵树的子树 - 力扣（LeetCode）

给你两棵二叉树 root 和 subRoot 。检验 root 中是否包含和 subRoot 具有相同结构和节点值的子树。如果存在，返回 true ；否则，返回 false 。
二叉树 tree 的一棵子树包括 tree 的某个节点和这个节点的所有后代节点。 tree 也可以看做它自身的一棵子树。

思路解析：

本题可以用到检查两棵树是否相同的函数，因为判断另一棵树是否是当前树的子树需要判断节点是否相等。每一个不为空的节点都有可能是子树，只需要遍历当前树的每一个节点与子树的节点比较找到根节点相同，就进入isSameTree函数进行比较剩余的左子树和右子树是否相等

参考代码

/*
 * @lc app=leetcode.cn id=572 lang=c
 *
 * [572] 另一棵树的子树
 */

// @lc code=start
/**
 * Definition for a binary tree node.
 * 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;
    }

    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;
    }

    if (isSameTree(root, subRoot))
    {
        return true;
    }

    return isSubtree(root->left, subRoot) || isSubtree(root->right, subRoot);
}
// @lc code=end

二叉树前序构建

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

描述
编一个程序，读入用户输入的一串先序遍历字符串，根据此字符串建立一个二叉树（以指针方式存储）。 例如如下的先序遍历字符串： ABC##DE#G##F### 其中“#”表示的是空格，空格字符代表空树。建立起此二叉树以后，再对二叉树进行中序遍历，输出遍历结果。
输入描述：
输入包括1行字符串，长度不超过100。
输出描述：
可能有多组测试数据，对于每组数据， 输出将输入字符串建立二叉树后中序遍历的序列，每个字符后面都有一个空格。 每个输出结果占一行。

思路解析：

参考代码

#define _CRT_SECURE_NO_WARNINGS 1

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <assert.h>

typedef char BTNDataType;
typedef struct BinaryTreeNode
{
    BTNDataType data;
    struct BinaryTreeNode* left;
    struct BinaryTreeNode* right;
}BTN;

BTN* CreateSpace(BTNDataType x)
{
    BTN* root = (BTN*)malloc(sizeof(BTN));
    assert(root);
    root->data = x;
    root->left = root->right = NULL;

    return root;
}

//生成树
BTN* BinaryTreeCreate(BTNDataType* a, int* pi)
{
    if (a[*pi] == '#')
    {
        //注意更改pi的值，否则会导致pi始终指向第一次遇到空的位置
        (*pi)++;
        return NULL;
    }

    //开辟空间
    BTN* root = CreateSpace(a[(*pi)]);
    (*pi)++;

    root->left = BinaryTreeCreate(a, pi);
    root->right = BinaryTreeCreate(a, pi);

    return root;
}

//中序遍历
void InOrder(BTN* root)
{
    if (root == NULL)
    {
        return;
    }

    InOrder(root->left);
    printf("%c ", root->data);
    InOrder(root->right);
}

int main() {
    //读取二叉树的数据
    char datac[100] = { 0 };
    scanf("%s", datac);
    //生成下标遍历数组
    int i = 0;
    BTN* root = BinaryTreeCreate(datac, &i);
    InOrder(root);
    return 0;
}