算法训练day15|层序遍历|226. 翻转二叉树|101. 对称二叉树

障目叶亦能知秋

已于 2023-03-16 11:22:06 修改

阅读量157

点赞数

分类专栏：算法训练文章标签：数据结构算法 leetcode c++ Powered by 金山文档

于 2023-03-15 23:47:50 首次发布

本文链接：https://blog.csdn.net/weixin_45628782/article/details/129557661

版权

算法训练专栏收录该内容

14 篇文章 0 订阅

订阅专栏

一、层序遍历

暂时只学层序遍历的迭代法，后面的几个题目都建立在层序遍历的模板上写。

层序遍历要每一层分开装到二维数组中。

class Solution {
public:
    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;
            // 这里一定要使用固定大小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;
    }
};

429. N 叉树的层序遍历

class Solution {
public:
    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;
            // 这里一定要使用固定大小size，不要使用que.size()，因为que.size是不断变化的
            for (int i = 0; i < size; i++) {
                Node* node = que.front();
                que.pop();
                vec.push_back(node->val);
                for(int j=0; j<node->children.size(); j++){
                    que.push(node->children[j]);
                }
            }
            result.push_back(vec);
        }
        return result;
    }
};

199. 二叉树的右视图

class Solution {
public:
    vector<int> rightSideView(TreeNode* root) {
        queue<TreeNode*> que;
        if(root == nullptr){
            return {};
        }
        que.push(root);
        vector<int> result;
        while(que.empty() != true){//队列非空时
            int size = que.size();
                TreeNode* cur = que.front();
                for (int i = 0; i < size; i++) {
                TreeNode* node = que.front();
                que.pop();
                if(i == size-1) result.push_back(node->val);
                if (node->left) que.push(node->left);
                if (node->right) que.push(node->right);
            }
                
        }
        return result;
    }
};

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

class Solution {
public:
    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 tmp = que.front()->val;
            // 这里一定要使用固定大小size，不要使用que.size()，因为que.size是不断变化的
            for (int i = 0; i < size; i++) {
                TreeNode* node = que.front();
                que.pop();
                tmp = tmp > node->val ? tmp : node->val;
                if (node->left) que.push(node->left);
                if (node->right) que.push(node->right);
            }
            result.push_back(tmp);
        }
        return result;
    }
};

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

这题过得莫名其妙的，马后炮的想，只有两种情况要加next，一是同一父节点下的左右节点，二是相邻父节点的右节点和左节点，这一切的前提，都是题目给了这是一个完美二叉树。

class Solution {
public:
    Node* connect(Node* root) {
        queue<Node*> que;
        if (root != NULL) {
            que.push(root);
        }
        while (!que.empty()) {
            int size = que.size();
            Node* front = que.front();
            // 这里一定要使用固定大小size，不要使用que.size()，因为que.size是不断变化的
            for (int i = 0; i < size; i++) {
                Node* node = que.front();
                que.pop();
                if(node->right && node->next && node->next->left) node->right->next = node->next->left;
                if( node->left && node->right) node->left->next = node->right;
                if (node->left) que.push(node->left);
                if (node->right) que.push(node->right);
            }
        }
        return root;
    }
};

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

这个代码可以解决上一题，其实层序遍历的时候，能遍历到每一层的所有节点，只需要用一个指针记录pre即可

class Solution {
public:
    Node* connect(Node* root) {
        queue<Node*> que;
        if (root != NULL) {
            que.push(root);
        }
        while (!que.empty()) {
            int size = que.size();
            Node* node;
            Node*pre= NULL;
            // 这里一定要使用固定大小size，不要使用que.size()，因为que.size是不断变化的
            for (int i = 0; i < size; i++) { //同一层记录pre指针，当pre非空时，pre->next指向当前节点即可
                node = que.front();
                que.pop();
                if(pre) pre->next=node;
                pre = node;
                if (node->left) que.push(node->left);
                if (node->right) que.push(node->right);
            }
        }
        return root;
    }
};

104. 二叉树的最大深度

class Solution {
public:
    int maxDepth(TreeNode* root) {
        int i=0;
        queue<TreeNode*> que;
        if (root != NULL) que.push(root);
        while (!que.empty()) {
            int size = que.size();
            // 这里一定要使用固定大小size，不要使用que.size()，因为que.size是不断变化的
            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);
            }
            i++;
        }
        return i;
    }
};

111. 二叉树的最小深度

class Solution {
public:
    int minDepth(TreeNode* root) {
        queue<TreeNode*> que;
        if (root != NULL) que.push(root);
        int cnt = 0;
        while (!que.empty()) {
            int size = que.size();
            TreeNode* node;
            cnt++;
            // 这里一定要使用固定大小size，不要使用que.size()，因为que.size是不断变化的
            for (int i = 0; i < size; i++) {
                node = que.front();
                que.pop();
                if(!node->left && !node->right) break;
                if (node->left) que.push(node->left);
                if (node->right) que.push(node->right);
            }
            if(!node->left && !node->right) break;
        }
        return cnt;
    }
};

二、226. 翻转二叉树

其实就是遍历所有节点，翻转左右子树。前序中序后序层序遍历都是可以的，但是中序遍历的递归算法不可以。

层序遍历（迭代）

class Solution {
public:
    TreeNode* invertTree(TreeNode* root) {
        if(!root){
            return nullptr;
        }//其实是多余的
        queue<TreeNode*> que;
        if (root != NULL) que.push(root);
        while (!que.empty()) {
            int size = que.size();
            TreeNode* node;
            // 这里一定要使用固定大小size，不要使用que.size()，因为que.size是不断变化的
            for (int i = 0; i < size; i++) {
                node = que.front();
                que.pop();
                swap(node->right,node->left);
                if (node->left) que.push(node->left);
                if (node->right) que.push(node->right);
            }  
        }
        return root;
    }
    };

先序遍历（递归）

后序直接把swap放后面就行。

class Solution {
public:
    void preOrder(TreeNode *cur){
        if(!cur){
            return;
        }
        swap(cur->left,cur->right);//先序
        preOrder(cur->left);
        preOrder(cur->right);
        //swap(cur->left,cur->right);//后序
    }
    TreeNode* invertTree(TreeNode* root) {
        preOrder(root);
        return root;
    }
};

三、101. 对称二叉树

这题要想到是判断左右两棵子树相同即可得出对称

class Solution {
public:
    bool compare(TreeNode* left,TreeNode* right){
        if(!left && !right){
            return true;
        }
        if((!left && right) || (left && !right)){
            return false;
        }
        if(left->val != right->val){
            return false;
        }
        bool outside = compare(left->left,right->right);//外侧
        bool inside = compare(left->right,right->left); //内侧
        bool result = outside && inside;
        return result;
    }
    bool isSymmetric(TreeNode* root) {
        return compare(root->left,root->right);
    }
};

四、总结

对于递归的使用还是非常不娴熟，要多多练习。

（4小时）

障目叶亦能知秋

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
算法训练day15|层序遍历|226. 翻转二叉树|101. 对称二叉树

这题过得莫名其妙的，马后炮的想，只有两种情况要加next，一是同一父节点下的左右节点，二是相邻父节点的右节点和左节点，这一切的前提，都是题目给了这是一个完美二叉树。这个代码可以解决上一题，其实层序遍历的时候，能遍历到每一层的所有节点，只需要用一个指针记录pre即可。其实就是遍历所有节点，翻转左右子树。前序中序后序层序遍历都是可以的，但是中序遍历的递归算法不可以。暂时只学层序遍历的迭代法，后面的几个题目都建立在层序遍历的模板上写。层序遍历要每一层分开装到二维数组中。这题看完题解了，明天再来写一遍。
复制链接

扫一扫