代码随想录第十八天 | 层序遍历 10 ● 226.翻转二叉树 ● 101.对称二叉树 2 (1st)，104.二叉树的最大深度，111.二叉树的最小深度

magnetotell

已于 2024-08-10 22:15:51 修改

阅读量724

点赞数 19

文章标签：深度优先算法

于 2024-05-20 22:27:55 首次发布

本文链接：https://blog.csdn.net/magnetotell/article/details/139066275

版权

10. 二叉树层序遍历

看完想法：需要借用一个辅助数据结构即队列来实现，队列先进先出，符合一层一层遍历的逻辑，而用栈先进后出适合模拟深度优先遍历也就是递归的逻辑。

vector<vector<int>> levelOrder(TreeNode* root) {
        queue<TreeNode*> que;
        if (root != NULL) que.push(root);
        vector<vector<int>> result;   //此处是二维数组
        while (!que.empty()) {
            int size = que.size();
            vector<int> vec; //二维数组不能直接push_back,要新建一个vector数组用来插入二维数组
            // 这里一定要使用固定大小size，不要使用que.size()，因为que.size是不断变化的
            for (int i = 0; i < size; i++) {
                TreeNode* node = que.front();
                que.pop();
                vec.push_back(node->val);
                if (node->left) que.push(node->left);
                if (node->right) que.push(node->right);
            }
            result.push_back(vec);
        }
        return result;

tip:如果是二叉树层序遍历，从顶节点向根节点遍历，只需把result倒序一下即可输出

107.二叉树的层次遍历 II

vector<vector<int>> levelOrderBottom(TreeNode* root) {
        queue<TreeNode*> que;
        if (root != NULL) que.push(root);
        vector<vector<int>> result;
        while (!que.empty()) {
            int size = que.size();
            vector<int> vec;
            for (int i = 0; i < size; i++) {
                TreeNode* node = que.front();
                que.pop();
                vec.push_back(node->val);
                if (node->left) que.push(node->left);
                if (node->right) que.push(node->right);
            }
            result.push_back(vec);
        }
        reverse(result.begin(), result.end()); // 在这里反转一下数组即可
        return result;

199.二叉树的右视图

看完想法：层序遍历的时候，判断是否遍历到单层的最后面的元素

vector<int> rightSideView(TreeNode* root) {
        queue<TreeNode*> que;
        if (root != NULL) que.push(root);
        vector<int> result;   //只需要一维数组
        while (!que.empty()) {
            int size = que.size();
            for (int i = 0; i < size; i++) {
                TreeNode* node = que.front();
                que.pop();
                if(i==(size-1)) result.push_back(node->val);  //size-1一般是操作右孩子了
                if (node->left) que.push(node->left);
                if (node->right) que.push(node->right);
            }

        }

        return result;

637.二叉树的层平均值

看完想法：层序遍历的时候把一层求个总和在取一个均值。

vector<double> averageOfLevels(TreeNode* root) {
        queue<TreeNode*> que;
        if (root != NULL) que.push(root);
        vector<double> result;
        while (!que.empty()) {
            int size = que.size();
            double sum=0;
            for (int i = 0; i < size; i++) {
                TreeNode* node = que.front();
                que.pop();
                sum+=node->val;
                
                if (node->left) que.push(node->left);
                if (node->right) que.push(node->right);
            }
            result.push_back(sum/size);
        }
        return result;
    }

429.N叉树的层序遍历

看完想法：与二叉树差不多，节点变多了而已,注意此处树的类定义不是treenode而是node

vector<vector<int>> levelOrder(Node* root) {
        queue<Node*> que;
        if (root != NULL) que.push(root);
        vector<vector<int>> result;
        while (!que.empty()) {
            int size = que.size();
            vector<int> vec;
            for (int i = 0; i < size; i++) {
                Node* node = que.front();
                que.pop();
                vec.push_back(node->val);
                for (int i = 0; i < node->children.size(); i++) { // 将节点孩子加入队列
                    if (node->children[i]) que.push(node->children[i]);
                }
            }
            result.push_back(vec);
        }
        return result;

515.在每个树行中找最大值

看完想法：层序遍历，取每一层的最大值

vector<int> largestValues(TreeNode* root) {
        queue<TreeNode*> que;
        if (root != NULL) que.push(root);
        vector<int> result;
        while (!que.empty()) {
            int size = que.size();
            int maxValue = INT_MIN; // 取每一层的最大值
            for (int i = 0; i < size; i++) {
                TreeNode* node = que.front();
                que.pop();
                maxValue = node->val > maxValue? node->val:maxValue;
                if (node->left) que.push(node->left);
                if (node->right) que.push(node->right);
            }
            result.push_back(maxValue); // 把最大值放进数组
        }
        return result;

116.填充每个节点的下一个右侧节点指针

看完想法：在单层遍历的时候记录一下本层的头部节点，然后在遍历的时候让前一个节点指向本节点就可以了

queue<Node*> que;
        if (root != NULL) que.push(root);
        while (!que.empty()) {
            int size = que.size();
            // vector<int> vec;
            Node* nodePre;
            Node* node;
            for (int i = 0; i < size; i++) {
                if (i == 0) {
                    nodePre = que.front(); // 取出一层的头结点
                    que.pop();
                    node = nodePre;
                } else {
                    node = que.front();
                    que.pop();
                    nodePre->next = node; // 本层前一个节点next指向本节点
                    nodePre = nodePre->next;  //更新上一个节点的位置
                }
                if (node->left) que.push(node->left);
                if (node->right) que.push(node->right);
            }
            nodePre->next = NULL; // 本层最后一个节点指向NULL，必须要有这个
        }
        return root;

117.填充每个节点的下一个右侧节点指针Ⅱ

Node* connect(Node* root) {
        queue<Node*> st;
        if(root!=NULL) st.push(root);
        while(!st.empty()){
            int size = st.size();  //  必须要有，因为st.size()是可变的
            Node* precur;  //定义前一个节点指针
            Node* cur;     //定义后一个
            for(int i =0; i<size; i++){
                if(i == 0){
                    precur = st.front();
                    st.pop();  //记录最左边的节点
                }
                else{
                    cur = st.front();
                    st.pop();
                    precur->next = cur;
                    precur = precur->next; //更新旧节点
                }
                if(precur->left) st.push(precur->left);
                if(precur->right) st.push(precur->right);
            }
            precur->next = NULL;
        }
        return root;
    }

104.二叉树的最大深度

看完想法：

使用迭代法的话，使用层序遍历是最为合适的，因为最大的深度就是二叉树的层数，和层序遍历的方式极其吻合。在二叉树中，一层一层的来遍历二叉树，记录一下遍历的层数就是二叉树的深度，所以这道题就是一道模板题目

int maxDepth(TreeNode* root) {
        queue<TreeNode*> que;
        if (root != NULL) que.push(root);
        vector<vector<int>> result;
        int depth=0;
        while (!que.empty()) {
            int size = que.size();
            vector<int> vec;
            depth++;
            // 这里一定要使用固定大小size，不要使用que.size()，因为que.size是不断变化的
            for (int i = 0; i < size; i++) {
                
                TreeNode* node = que.front();
                que.pop();
                vec.push_back(node->val);
                if (node->left) que.push(node->left);
                if (node->right) que.push(node->right);
            }
            result.push_back(vec);
        }
        return depth;

111.二叉树的最小深度

看完想法：需要注意的是，只有当左右孩子都为空的时候，才说明遍历的最低点了。如果其中一个孩子为空则不是最低点

int minDepth(TreeNode* root) {
        queue<TreeNode*> que;
        if (root != NULL) que.push(root);
        vector<vector<int>> result;
        int depth=0;
        while (!que.empty()) {
            int size = que.size();
            vector<int> vec;
            depth++;
            // 这里一定要使用固定大小size，不要使用que.size()，因为que.size是不断变化的
            for (int i = 0; i < size; i++) {
                
                TreeNode* node = que.front();
                que.pop();
                vec.push_back(node->val);
                if (node->left) que.push(node->left);
                if (node->right) que.push(node->right);
                if(!node->left && !node->right) return depth;  //当左右节点都为空，此时为最小的深度
            }
            result.push_back(vec);
        }
        return depth;

    }

226.翻转二叉树

看完想法：用前序和后序递归遍历法解决，用递归法要注意

确定递归函数的参数和返回值
确定终止条件
确定单层递归的逻辑

TreeNode* invertTree(TreeNode* root) {
        if(root==NULL) return root;
        
        invertTree(root->left);
        invertTree(root->right);
        swap(root->left, root->right);  //中
        return root;

    }

101. 对称二叉树

看完想法：前面只有3个else if的原因是：第四个左右孩子不为空且相等的情况，是要进行下一轮的递归的，看它的左右孩子是否相等

bool compare(TreeNode* left, TreeNode* right){
        if(left==NULL && right==NULL) return true;
        else if(left==NULL && right!=NULL) return false;
        else if(left!=NULL && right==NULL) return false;
        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;                    // 中间比较注意不用left, right
        return isSame;
        
    }


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


    }

迭代法

看完想法：主要思想是用栈或者队列把外部节点和内部节点成双成对的放进去，然后成双成对的取出并比较。

bool isSymmetric(TreeNode* root) {
        if (root == NULL) return true;
        queue<TreeNode*> que;
        que.push(root->left);   // 将左子树头结点加入队列
        que.push(root->right);  // 将右子树头结点加入队列
        
        while (!que.empty()) {  // 接下来就要判断这两个树是否相互翻转
            TreeNode* leftNode = que.front(); que.pop();
            TreeNode* rightNode = que.front(); que.pop();
            if (!leftNode && !rightNode) {  // 左节点为空、右节点为空，此时说明是对称的
                continue;
            }

            // 左右一个节点不为空，或者都不为空但数值不相同，返回false
            if ((!leftNode || !rightNode || (leftNode->val != rightNode->val))) {
                return false;
            }
            que.push(leftNode->left);   // 加入左节点左孩子
            que.push(rightNode->right); // 加入右节点右孩子
            que.push(leftNode->right);  // 加入左节点右孩子
            que.push(rightNode->left);  // 加入右节点左孩子
        }
        return true;

104. 二叉树的最大深度

首次想法：前序求得是深度，后序求的是高度。根节点的高度就是二叉树的最大深度。因此既可以用前序，也可以用后序遍历。同时这道题也是层序遍历的模板题，但是我不会...

看完想法：前序遍历需要回溯，这里写的是简化版本。实际需要在确定有左右孩子后让depth+1，然后迭代，再depth--回溯撤销节点

//前序遍历
//用全局变量result来存储最大深度
    int result=0;
    void getdepth(TreeNode* root, int depth){
        //用depth来存储当前的深度
        result = result < depth?depth:result; 
        if(root->left==nullptr && root->right==nullptr) return;
        if(root->left) getdepth(root->left, depth+1);
        if(root->right) getdepth(root->right, depth+1);
        return;
    }
    int maxDepth(TreeNode* root) {
        //要考虑根节点为空的情况，否则会报错
        if(root==nullptr) return result;
        getdepth(root, 1);
        return result;
    }

//后序遍历
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);
    }

111. 二叉树的最小深度

magnetotell

关注

19
点赞
踩
5

收藏

觉得还不错? 一键收藏
0
评论
复制链接

分享到 QQ

分享到新浪微博

扫一扫