二叉树 —— OJ题目详解

1.二叉树的前序遍历

二叉树的前序遍历比较简单，但是在力扣上写这个接口需要注意几个点：

int* preorderTraversal(struct TreeNode* root, int* returnSize) {
    
}

• preorderTraversal 的返回值是动态开辟的数组，里面存放的是前序遍历的顺序
• int* returnSize 这个参数记录的是遍历到的数据个数，因为函数的返回值只能有一个，所以我们通它来记录，当用户需要数据个数时，直接查看该指针变量即可

 代码：

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

void _preOrder(struct TreeNode* root, int* a,int* i){
    if(root == NULL)
    return;

    a[*i] = root->val; //记录当前节点，到数组中
    (*i)++;            //数组下标+1

    _preOrder(root->left,a,i);  //接着遍历左子树
    _preOrder(root->right,a,i); //然后遍历右子树 

}

//returensize是记录数组的元素个数，我们要返回给用户的是遍历数的数组
int* preorderTraversal(struct TreeNode* root, int* returnSize) {

    *returnSize = TreeSize(root);//遍历树，得到数据个数

    int* a = (int*)malloc(sizeof(int) * (*returnSize));//动态开辟数组空间

    int i = 0;
    _preOrder(root ,a,&i);//前序遍历
    return a;

}

2.检查两棵树是否相同

思路： 

利用前序遍历，先比较当前节点是否相同，紧接着比较左子树与右子树

代码：

bool isSameTree(struct TreeNode* p, struct TreeNode* q) {
    if(p == NULL && q == NULL) //如果pq都为NULL，返回真
        return true;

    if(p == NULL || q == NULL)  //代码到这里，只有2种可能，1.pq其中一个为NULL，2两个都不为NULL
                               //如果其中一个为NULL，说明另一个一定不是NULL，则pq不相等，不用
        return false;          //比较了，返回false


    if(p->val != q->val)  // 代码到这，说明pq都不为NULL，直接比较即可

        return false;    //比较qp相等没有用意义，要看它们不相等，可以直接出结果

    return isSameTree(q->left,p->left) //在比较左右子树，右子树
    && isSameTree(q->right,p->right);
}

3.对称二叉树

 思路：

观察示例一：一颗对称的二叉树，我的左子树根节点 == 你的右子树根节点、我的右子树根节点 == 你的左子树根节点。有一个地方不符合此规则，则此树不是对称二叉树

所以示例一是一颗对称二叉树，我们代码则使用递归的方法，先比较当前两棵树的根节点是否相同，在比较这两颗树的左右子树是否对称

代码：

bool _isSymmetric(struct TreeNode* q,struct TreeNode* p)
{
    //先比较当前两颗子树的根节点是都相同
    if(p == NULL && q == NULL) 
        return true;

    if(p == NULL || q == NULL)  //代码到这里，只有2种可能，1.pq其中一个为NULL，2两个都不为NULL
        return false;

    if(p->val != q->val)// 比较根节点是否相同
        return false;

    return _isSymmetric(q->left,p->right)   //q节点的左子树，与p节点的右子树比
    && _isSymmetric(q->right,p->left);     //q节点的右子树，与p节点的左子树比
}
bool isSymmetric(struct TreeNode* root) {
    return _isSymmetric(root->left,root->right);
}

4.另一棵树的子树

思路：

题目给出了root树与subRoot树，让我们看看sybRoot树是否是root树中的一个子树

 1.那么我们首先要做的是：如何找出root树的所有子树？

其实这个很简单，我们只需要遍历到root树的每一个节点就相当于找到了root树的所有子树，因为每一个节点都是某棵树的根节点，通过根节点自然得到了一节树

2.找到了所有子树之后我们要做的自然依次与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(q->left,p->left)
    && isSameTree(q->right,p->right);
}

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

    if(root == NULL)//subRoot树上的节点数量范围是[1, 1000]，所以当遍历到的子树为NULL时返回false
        return false;

     //当某一个子树的根节点与subRoot根节点相同时，开始比较两棵树是否相同
     //当两颗树相同则直接出结果，不用接着去找了，返回ture 
    if(root->val == subRoot->val &&
    isSameTree(root,subRoot))
        return true;

    //接着去遍历左子树与右子树，一边找到了就不用再继续找了，整体就是前序遍历的去遍历每一颗子树
    return isSubtree(root->left,subRoot) || isSubtree(root->right,subRoot);
}

5.二叉树的构建及遍历

利用，用户输入的数组先构建一颗二叉树，在进行中序遍历即可 

代码：

#include <stdio.h>
#include<stdlib.h>
typedef char BTDataType;

typedef struct BinaryTreeNode {
    BTDataType _data;
    struct BinaryTreeNode* _left;
    struct BinaryTreeNode* _right;
} BTNode;

BTNode* BuyNode(BTDataType x) {

    BTNode* newnode = (BTNode*)malloc(sizeof(BTNode));
    if (newnode == NULL) {
        perror("Buynode()::malloc()");
        return newnode;
    }

    newnode->_data = x;
    newnode->_left = NULL;
    newnode->_right = NULL;
    return newnode;
}

// 二叉树中序遍历
void BinaryTreeInOrder(BTNode* root) {
    if (root == NULL) {
        return;
    }

    BinaryTreeInOrder(root->_left);//左子树
    printf("%c ", root->_data);//根节点
    BinaryTreeInOrder(root->_right);
}

// 通过前序遍历的数组"ABD##E#H##CF##G##"构建二叉树
BTNode* BinaryTreeCreate(BTDataType* a,int* pi) {

    //根，左子树，右子树

    if (a[(*pi)] == '#') {
        (*pi)++;
        return NULL;
    }

    BTNode* newnode = BuyNode(a[(*pi)++]);

    newnode->_left = BinaryTreeCreate(a,pi);
    newnode->_right  = BinaryTreeCreate(a,pi);

    return newnode;
}

int main() {
    char arr[101];
    scanf("%s",arr);
    int count = 0;
    BTNode* tree = BinaryTreeCreate(arr,&count);   //构建二叉树
    BinaryTreeInOrder(tree);                      //中序遍历二叉树
    return 0;
}

6.翻转二叉树

思路： 

依旧是使用递归，先翻转左子树，在翻转右子树。由于翻转后，左右子树的根节点没有动，最后在将根节点翻转即可完成当前树的翻转

代码：

void _invertTree(struct TreeNode* root)
{
    if(root == NULL)
    return;

    _invertTree(root->left);   //翻转左子树
    _invertTree(root->right);  //翻转右子树

    //在将自己左右子树的根节点交换，即可完成翻转
    struct TreeNode* temp = root->left;
    root->left = root->right;
    root->right = temp;
}
struct TreeNode* invertTree(struct TreeNode* root) {
    _invertTree(root);

    return root;
}

7.平衡二叉树

平衡二叉树： 每个节点的左右子树的深度相差不超过1

思路： 

遍历二叉树的每一个节点，算它们的高度差超过1吗，超过就不是平衡二叉树

代码：

int TreeHight(struct TreeNode* root)//求高度
{
    if(root == NULL)
    return 0;

    int left = TreeHight(root->left);
    int right = TreeHight(root->right);

    return left > right ? left + 1 : right + 1;
}

//走前序遍历，依次遍历每个节点，并求节点左子树与右子树的高度差 >1?
bool isBalanced(struct TreeNode* root) {
    if(root == NULL)
    return true;

    //比较当前节点左右子树高度差
    int left = TreeHight(root->left);   
    int right = TreeHight(root->right);
    if(abs(left-right) > 1)
    return false;

    if(isBalanced(root->left) == 0)  //遍历左子树
    return false;

    if(isBalanced(root->right) == 0)  //遍历右子树
    return false;

    return true; //代码到这说明它就是一颗平衡二叉树
}