算法训练Day16

最新推荐文章于 2025-11-30 21:05:18 发布

原创最新推荐文章于 2025-11-30 21:05:18 发布 · 85 阅读

0 ·

CC 4.0 BY-SA版权

文章标签：

#c++ #leetcode #算法 #数据结构

C++ 专栏收录该内容

27 篇文章

订阅专栏

文章介绍了使用不同遍历方法（深度优先和广度优先）解决二叉树的最大深度、最小深度和完全二叉树节点个数的问题。通过比较前序、中序、后序遍历以及层次遍历，阐述了遍历顺序对结果的影响，并强调了选择合适遍历策略的重要性。

2023年3月16日

今天的任务有三个

#二叉树的最大深度 104. 二叉树的最大深度 - 力扣（LeetCode）

class solution {
public:
    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); // 中
        return depth;
    }
    int maxdepth(treenode* root) {
        return getdepth(root);
    }
};

前序遍历

class solution {
public:
    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(treenode* root) {
        result = 0;
        if (root == NULL) return result;
        getdepth(root, 1);
        return result;
    }
};

层序遍历如下

class solution {
public:
    int maxdepth(treenode* root) {
        if (root == NULL) return 0;
        int depth = 0;
        queue<treenode*> que;
        que.push(root);
        while(!que.empty()) {
            int size = que.size();
            depth++; // 记录深度
            for (int i = 0; i < size; i++) {
                treenode* node = que.front();
                que.pop();
                if (node->left) que.push(node->left);
                if (node->right) que.push(node->right);
            }
        }
        return depth;
    }
};

#二叉树的最小深度 111. 二叉树的最小深度 - 力扣（LeetCode）

class Solution {
public:
    int getDepth(TreeNode* node) {
        if (node == NULL) return 0;
        int leftDepth = getDepth(node->left);           // 左
        int rightDepth = getDepth(node->right);         // 右
                                                        // 中
        // 当一个左子树为空，右不为空，这时并不是最低点
        if (node->left == NULL && node->right != NULL) { 
            return 1 + rightDepth;
        }   
        // 当一个右子树为空，左不为空，这时并不是最低点
        if (node->left != NULL && node->right == NULL) { 
            return 1 + leftDepth;
        }
        int result = 1 + min(leftDepth, rightDepth);
        return result;
    }

    int minDepth(TreeNode* root) {
        return getDepth(root);
    }
};

前序遍历

class Solution {
private:
    int result;
    void getdepth(TreeNode* node, int depth) {
        if (node->left == NULL && node->right == NULL) {
            result = min(depth, result);  
            return;
        }
        // 中 只不过中没有处理的逻辑
        if (node->left) { // 左
            getdepth(node->left, depth + 1);
        }
        if (node->right) { // 右
            getdepth(node->right, depth + 1);
        }
        return ;
    }

public:
    int minDepth(TreeNode* root) {
        if (root == NULL) return 0;
        result = INT_MAX;
        getdepth(root, 1);
        return result;
    }
};

层次遍历

class Solution {
public:

    int minDepth(TreeNode* root) {
        if (root == NULL) return 0;
        int depth = 0;
        queue<TreeNode*> que;
        que.push(root);
        while(!que.empty()) {
            int size = que.size();
            depth++; // 记录最小深度
            for (int i = 0; i < size; i++) {
                TreeNode* node = que.front();
                que.pop();
                if (node->left) que.push(node->left);
                if (node->right) que.push(node->right);
                if (!node->left && !node->right) { // 当左右孩子都为空的时候，说明是最低点的一层了，退出
                    return depth;
                }
            }
        }
        return depth;
    }
};

#完全二叉树的节点个数 222. 完全二叉树的节点个数 - 力扣（LeetCode）

普通二叉树的递归方法

class Solution {
private:
    int getNodesNum(TreeNode* cur) {
        if (cur == NULL) return 0;
        int leftNum = getNodesNum(cur->left);      // 左
        int rightNum = getNodesNum(cur->right);    // 右
        int treeNum = leftNum + rightNum + 1;      // 中
        return treeNum;
    }
public:
    int countNodes(TreeNode* root) {
        return getNodesNum(root);
    }
};

普通二叉树的迭代方法

class Solution {
public:
    int countNodes(TreeNode* root) {
        queue<TreeNode*> que;
        if (root != NULL) que.push(root);
        int result = 0;
        while (!que.empty()) {
            int size = que.size();
            for (int i = 0; i < size; i++) {
                TreeNode* node = que.front();
                que.pop();
                result++;   // 记录节点数量
                if (node->left) que.push(node->left);
                if (node->right) que.push(node->right);
            }
        }
        return result;
    }
};

完全二叉树

class Solution {
public:
    int countNodes(TreeNode* root) {
        if (root == nullptr) return 0;
        TreeNode* left = root->left;
        TreeNode* right = root->right;
        int leftDepth = 0, rightDepth = 0; // 这里初始为0是有目的的，为了下面求指数方便
        while (left) {  // 求左子树深度
            left = left->left;
            leftDepth++;
        }
        while (right) { // 求右子树深度
            right = right->right;
            rightDepth++;
        }
        if (leftDepth == rightDepth) {
            return (2 << leftDepth) - 1; // 注意(2<<1) 相当于2^2，所以leftDepth初始为0
        }
        return countNodes(root->left) + countNodes(root->right) + 1;
    }
};

由于这三个东西的原理基本一样，在这里我就不一个一个单独写了，这里只分享我在做的过程中的一些感悟或者理解

在一开始做这种题的时候，我从来没考虑过为什么遍历顺序对结果会有差异，或者说不明白为什么不同的遍历顺序会影响到结果，经过这个深度和高度的例子，我明白了，左中右，中左右，左右中，层次遍历这四种方式有其独特的方法，就拿后序遍历，即左右中来说，这种方式跟中序遍历左中右的方式就不太一样，例如当我求深度的时候，左中右就不太行，没有左右中方便，为什么呢？因为深度是指从根节点到当前节点的距离，而左右中这种遍历方式正好能将左右子树遍历完后将结果返回给父节点，无论父节点在之后的遍历过程中充当什么角色，都是左右子树遍历完后的结果，是全面的；而左中右这种中序遍历就“不那么顺利”，因为遍历完左子树后，就返回给父节点了，此时右子树还没有遍历，这种方式是不全面的，所以会导致不同的题需要采用不同的遍历方式进行解答。

今天继续，状态不错，希望继续打牢基础，加油冲冲冲