Day15 二叉树part02 102.二叉树的层序遍历 226.翻转二叉树 101. 对称二叉树

Alexander yaphets

已于 2023-12-26 23:34:09 修改

阅读量458

点赞数 10

分类专栏：代码随想录刷题文章标签：算法数据结构 leetcode c++

于 2023-12-26 19:01:25 首次发布

本文链接：https://blog.csdn.net/Alexanderyaphets/article/details/135229028

版权

代码随想录刷题专栏收录该内容

52 篇文章 0 订阅

订阅专栏

102.二叉树的层序遍历

queue容器方法总结，先进先出原则

入队 — push
出队 — pop
返回队头元素 — front
返回队尾元素 — back
判断队是否为空 — empty
返回队列大小 — size

class Solution {
public:
    vector<vector<int>> levelOrder(TreeNode* root) {
        queue<TreeNode*> que;
        vector<vector<int>> result;
        if(root!=nullptr) que.push(root); //根节点为空，提前退出
        while(!que.empty())
        {
            int size =que.size(); //记录当前层的node数量
            vector<int> vec; //记录每一层的遍历结果，存储到result二维数组
            while(size--) 
            {
                TreeNode* node = que.front(); //巧妙利用queueFIFO规则
                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); //存储到result二维数组
        }
        return result;
    }
};

Bonus——二叉树的层序遍历变体（9道题）

107.二叉树的层次遍历II

class Solution {
public:
    vector<vector<int>> levelOrderBottom(TreeNode* root) {
        vector<vector<int>> result;
        queue<TreeNode*> que;
        if(root!=nullptr) que.push(root);
        while(!que.empty())
        {
            int size = que.size();
            vector<int> vec; //存储一层的遍历
            while(size--)
            {
                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.二叉树的右视图

class Solution {
public:
    vector<int> rightSideView(TreeNode* root) {
        vector<vector<int>> result;
        queue<TreeNode*> que;
        if(root!=nullptr) que.push(root);
        while(!que.empty())
        {
            int size = que.size();
            vector<int> vec;
            while(size--)
            {
                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);
        }
        vector<int> resultVec;  //从层序遍历结果中取每个数组末尾值，放进新数组
        for(auto a:result)
        {
            resultVec.push_back(a.back());
        }
        return resultVec;
    }
};

637.二叉树的层平均值

class Solution {
public:
    vector<double> averageOfLevels(TreeNode* root) {
        vector<double> resultAvg;
        vector<vector<int>> resultNumsArray;
        queue<TreeNode*> que;
        if(root!=nullptr) que.push(root);
        while(!que.empty())
        {
            int size = que.size();
            vector<int> vec;
            while(size--)
            {
                TreeNode* node = que.front();
                que.pop();
                vec.emplace_back(node->val);
                if(node->left) que.push(node->left);
                if(node->right) que.push(node->right);
            }
            resultNumsArray.emplace_back(vec);
        }
        //层序遍历，每个数组求总和后除以数组内元素个数
        for(auto NumsArray:resultNumsArray)
        {
            double sum = 0;
            for(auto Num:NumsArray)
            {
                sum+=Num;
            }
            resultAvg.push_back(sum/NumsArray.size());
        }
        return resultAvg;
    }
};

429.N叉树的层序遍历

class Solution {
public:
    vector<vector<int>> levelOrder(Node* root) {
        vector<vector<int>> result;
        queue<Node*> que;
        if(root!=nullptr) que.push(root);
        while(!que.empty()){
            int size = que.size();
            vector<int> vec;
            while(size--)
            {
                Node* node = que.front();
                que.pop();
                vec.push_back(node->val);
                //遍历子节点，依次入队列
                for(auto childNode: node->children)
                {
                    if(childNode!=nullptr) que.push(childNode);
                }
            }
            result.emplace_back(vec);
        }
        return result;
    }
};

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

class Solution {
public:
    vector<int> largestValues(TreeNode* root) {
        vector<int> result;
        queue<TreeNode*> que;
        if(root!=nullptr) que.push(root);
        while(!que.empty())
        {
            int size = que.size();
            int maxVal = INT_MIN; //每层进行层序遍历，求每层最小值
            while(size--)
            {
                TreeNode* node = que.front();
                maxVal = max(maxVal, node->val);
                que.pop();
                if(node->left) que.push(node->left);
                if(node->right) que.push(node->right);
            }
            result.emplace_back(maxVal);
        }
        return result;
    }
};

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

class Solution {
public:
    Node* connect(Node* root) {
        queue<Node*> que;
        if(root!=NULL) que.push(root);
        while(!que.empty())
        {
            int size = que.size();
            while(size--)
            {
                Node* node = que.front();
                que.pop();
                //神来之笔，连接,size若为0，此时next取默认nullptr值
                if(size>0) node->next = que.front();
                if(node->left) que.push(node->left);
                if(node->right) que.push(node->right);
            }
        }
        return root;
    }
};

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

//层序遍历完美通关，和116一致
class Solution {
public:
    Node* connect(Node* root) {
        queue<Node*> que;
        if(root!=nullptr) que.push(root);
        while(!que.empty())
        {
            int size = que.size();
            while(size--)
            {
                Node* node = que.front();
                que.pop();
                if(size >0) node->next = que.front();
                if(node->left) que.push(node->left);
                if(node->right) que.push(node->right);
            }
        }
        return root;
    }
};

104.二叉树的最大深度

class Solution {
public:
    int maxDepth(TreeNode* root) {
        queue<TreeNode*> que;
        if(root!=nullptr) que.push(root);
        else return 0;
        int ans = 0;
        while(!que.empty())
        {
            int size = que.size();
            while(size--)
            {
                TreeNode* node = que.front();
                que.pop();
                if(node->left) que.push(node->left);
                if(node->right) que.push(node->right);
            }
            ans++;
        }
        return ans;
    }
};

111.二叉树的最小深度

class Solution {
public:
    int minDepth(TreeNode* root) {
        queue<TreeNode*> que;
        if(root!=nullptr) que.push(root);
        else return 0;
        int ans = 0;
        while(!que.empty())
        {
            int size = que.size();
            while(size--)
            {
                TreeNode* node = que.front();
                que.pop();
                //找到子节点返回ans+1
                if(!node->left && !node->right) return ans+1;
                if(node->left) que.push(node->left);
                if(node->right) que.push(node->right);
                
            }
            ans++;
        }
        return ans;
    }
};

226.翻转二叉树

方法一：递归（前序遍历）

class Solution {
public:
    //递归法单独放
    TreeNode* invertTreeRecur(TreeNode* node){
        if(node == nullptr) return node;
        swap(node->left,node->right); //中 我们使用swap()函数交换左右子节点的指针时，实际上是交换它们的地址
        invertTreeRecur(node->left); //左
        invertTreeRecur(node->right); //右
        return node; //返回根节点
    }
    //该方法仅支持前序和后序二叉遍历方法
    TreeNode* invertTree(TreeNode* root) {
        return invertTreeRecur(root); //调用递归方法invertTreeRecur
    }
};

方法二：迭代法（前序遍历）

class Solution {
public:
    TreeNode* invertTree(TreeNode* root) {
        stack<TreeNode*> st;
        if(root!=nullptr) st.push(root);
        while(!st.empty())
        {
            TreeNode* node = st.top();
            st.pop();
            swap(node->left,node->right); //关键一步
            if(node->right) st.push(node->right);
            if(node->left) st.push(node->left);
        }
        return root;
    }
};

方法三：统一迭代法（前序遍历）

class Solution {
public:
    TreeNode* invertTree(TreeNode* root) {
        stack<TreeNode*> st;
        if(root!=nullptr) st.push(root);
        while(!st.empty())
        {
            TreeNode* node = st.top();
            if(node!=nullptr)
            {
                st.pop(); //因为栈性质，我们右左中入栈
                if(node->right) st.push(node->right);
                if(node->left) st.push(node->left);
                st.push(node);
                st.push(nullptr);
            }else
            {
                st.pop();
                node = st.top();
                st.pop();
                swap(node->left,node->right); //关键一步
            }

        }
        return root;
    }
};

方法四：层序遍历（前序遍历）

class Solution {
public:
    TreeNode* invertTree(TreeNode* root) {
        queue<TreeNode*> que;
        if(root!=nullptr) que.push(root);
        while(!que.empty())
        {
            int size = que.size();
            while(size--){
                TreeNode* node = que.front(); //queue没有top()方法
                que.pop();
                swap(node->left,node->right); //关键一步
                if (node->left) que.push(node->left);
                if (node->right) que.push(node->right);
            }
        }
        return root;
    }
};

101. 对称二叉树

方法一：递归（后续遍历）

class Solution {
public:
    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;
        else return compare(left->left, right->right)&&compare(left->right, right->left);
    }
    bool isSymmetric(TreeNode* root) {
        if(root==NULL) return true;
        return compare(root->left,root->right);
    }
};

方法二：用栈迭代

class Solution {
public:
    bool isSymmetric(TreeNode* root) {
        if (root == NULL) return true;
        stack<TreeNode*> st;
        st.push(root->left);
        st.push(root->right);

        while(!st.empty()){
            TreeNode* leftNode = st.top(); st.pop();
            TreeNode* rightNode = st.top(); st.pop();
            if (!leftNode && !rightNode) { //左右Node相同，此时对称,退出当前循环，跳入下个循环
                continue;
            }
            if ((!leftNode || !rightNode || (leftNode->val != rightNode->val))) {
                return false;
            }
            st.push(leftNode->left);
            st.push(rightNode->right);
            st.push(leftNode->right);
            st.push(rightNode->left);
        }
        return true;
    }
};