数据结构 || 二叉树习题详解2

对称二叉树

• 描述： 给定一个二叉树，检查它是否是镜像对称的
  - 思路： 1. 对于二叉树是否对称，要比较的是根节点的左子树与右子树是不是相互翻转的，理解这一点就知道了其实我们要比较的是两个树（这两个树是根节点的左右子树），所以在递归遍历的过程中，也是要同时遍历两棵树。
  2.比较的是两个子树的里侧和外侧的元素是否相等 3. 遍历顺序只能是后序遍历，遍历两棵树比较内侧和外侧结点，即一个树的遍历顺序是左右中，另一个树的遍历顺序是右左中

bool compare(TreeNode* left, TreeNode* right) {
   
    // 首先排除空节点的情况
    if (left == NULL && right != NULL) return false;
    else if (left != NULL && right == NULL) return false;
    else if (left == NULL && right == NULL) return true;
    // 排除了空节点，再排除数值不相同的情况
    else if (left->val != right->val) return false;

    // 此时就是：左右节点都不为空，且数值相同的情况
    // 此时才做递归，做下一层的判断
    bool outside = compare(left->left, right->right);   // 左子树：左、 右子树：右
    bool inside = compare(left->right, right->left);    // 左子树：右、 右子树：左
    bool isSame = outside && inside;                    // 左子树：中、 右子树：中 （逻辑处理）
    return isSame;

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

二叉树的最大深度

• 描述： 给定一个二叉树，求最大深度。二叉树的深度为根结点到最远叶子结点的最长路径上的结点数。

• 求深度可以从上到下去查 所以需要前序遍历（中左右），而高度只能从下到上去查，所以只能后序遍历（左右中）

• 后序遍历求最大深度 递归法
  根结点的高度就是这棵树的最大深度，所以才可以使用后序遍历

    int getdepth(treenode* node) {
   
        if (node == null) return 0; //空节点
        int leftdepth = getdepth(node->left);       // 左  求左子树深度
        int rightdepth = getdepth(node->right);     // 右  求右子树深度
        int depth = 1 + max(leftdepth, rightdepth); // 中 取左右子树的最大值，根结点深度要加1
        return depth;
    }
    int maxdepth(treenode* root) {
   
        return getdepth(root);
    }

• 前序遍历

//二叉树最大深度  前序遍历法
int result;
void getdepth(TreeNode* node, int depth) {
   
    result = depth > result ? depth : result; // 中

    if (node->left == NULL && node->right == NULL) return;

    if (node->left) {
    // 左
        depth++;    // 深度+1
        getdepth(node->left, depth);
        depth--;    // 回溯，深度-1
    }
    if (node->right) {
    // 右
        depth++;    // 深度+1
        getdepth(node->right, depth);
        depth--;    // 回溯，深度-1
    }
    return;
}
int Maxdepth_2(TreeNode* root) {
   
    result = 0;
    if (root == 0) return result;
    getdepth(root, 1);
    return result;
}

• 层序遍历 迭代法

//二叉树最大深度 层序遍历法
int MaxDepth_3(TreeNode* root)
{
   
    if (root == NULL) return 0;
    queue<TreeNode*> que;
    vector<int> vec;
    if (root != NULL) que.push(root);
    int depth = 0;
    while (!que.empty())
    {
   
        int size = que.size();
        depth++;
        for(int i=0;i<size;i++)
        {
   
            TreeNode* p = que.front();
            que.pop();
            if (p->left) que.push(p->left);
            if (p->right) que.push(p->right);
        }
    }
    return depth;
}

二叉树的最小深度

• 描述： 给定一个二叉树，找出其最小深度。
  最小深度是从根节点到最近叶子节点的最短路径上的节点数量。
  说明: 叶子节点是指没有子节点的节点。

- 求二叉树的最小深度和求二叉树的最大深度的差别主要在于处理左右孩子不为空的逻辑

• 后序遍历递归法