刷题笔记16 二叉树 PartIII

最新推荐文章于 2024-07-20 16:46:53 发布

supersource732

最新推荐文章于 2024-07-20 16:46:53 发布

阅读量26

点赞数

文章标签：笔记算法 leetcode

本文链接：https://blog.csdn.net/supersource732/article/details/130309376

版权

二叉树 Part III

104. 二叉树的最大深度111二叉树的最小深度 222

104. 二叉树的最大深度111二叉树的最小深度 222

二叉树的最大深度

104. 二叉树的最大深度

		 int getDepth(TreeNode* node){
      
        if (node == NULL) return 0;
        //后序遍历
        int left_dep = getDepth(node->left);
        int right_dep = getDepth(node->right);
        int dep = max(left_dep,right_dep) + 1;
        return dep;
    }
    int maxDepth(TreeNode* root) {
         //迭代 标准层序遍历 模板题
        int dep = 0;
        queue<TreeNode*> store_que;
        if (root != NULL) store_que.push(root);
        while(!store_que.empty()){
            int size = store_que.size();
            for (int i = 0; i < size; ++i) {
                TreeNode* node = store_que.front();
                store_que.pop();
                if (node->left) store_que.push(node->left);
                if (node->right) store_que.push(node->right);
            }
           dep++;
        }
        return dep;
        //递归
                /**
         * 改写java 递归
         */
        /*if(root == NULL){
            return 0;
        }else{
            int leftDepth=maxDepth(root->left);
            int rightDepth=maxDepth(root->right);
            return max(leftDepth,rightDepth)+1;
        }*/
        //int ans = getDepth(root);
        //return ans;
    }

二叉树的最小深度

111. 二叉树的最小深度
法1：

    int getDepth(TreeNode* node){
        if (node == NULL)return 0;
        int left_depth = getDepth(node->left);
        int right_depth = getDepth(node->right);
        if (node->left != NULL && node->right == NULL){
            return 1 + left_depth;
        }
        if (node->left == NULL && node->right != NULL){
            return 1 + right_depth;
        }
        int dep =1+ min(left_depth,right_depth);
        return dep;
    }
    int minDepth(TreeNode* root) {
        return getDepth(root);
    }

222. 完全二叉树的节点个数

法1：

    int getNodeCount(TreeNode* node){
        // 后序遍历
        if (node ==NULL)return 0;
        int left_node = 0, right_node =0;
        if (node->left)  left_node = getNodeCount(node->left);
        if (node->right)  right_node = getNodeCount(node->right);
        int countNode = left_node + right_node + 1;
        return countNode;
    }
    int countNodes(TreeNode* root) {
        return getNodeCount(root);
        /*    int countNodes(TreeNode* root) {int count = 0;
        //深度优先搜索 
         //迭代 标准层序遍历 模板题
        queue<TreeNode*> store_que;
        if (root != NULL) store_que.push(root);
        while(!store_que.empty()){
            int size = store_que.size();
            for (int i = 0; i < size; ++i) {
                TreeNode* node = store_que.front();
                store_que.pop();
                count++;
                if (node->left) store_que.push(node->left);
                if (node->right) store_que.push(node->right);
            }
        }
        return count;*/
    }