代码随想录第15天|二叉树

qq_45699949

已于 2024-06-06 15:28:26 修改

阅读量299

点赞数 9

分类专栏：代码随想录文章标签：算法

于 2024-06-05 21:33:04 首次发布

本文链接：https://blog.csdn.net/qq_45699949/article/details/139446366

版权

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

46 篇文章 0 订阅

订阅专栏

102. 二叉树的层序遍历

在这里插入图片描述

class Solution {
public:
    vector<vector<int>> levelOrder(TreeNode* root) {
        queue<TreeNode*> myqueue;
        int layer = 0;
        if (root) myqueue.push(root);
        vector<vector<int>> result;
        while (!myqueue.empty()) {
            int size = myqueue.size();
            vector<int> tem_layer;
            for (int i = 0; i < size; i++) {
                TreeNode* tem = myqueue.front();
                tem_layer.push_back(tem->val);
                myqueue.pop();
                if (tem->left) myqueue.push(tem->left);
                if (tem->right) myqueue.push(tem->right);
            }
            result.push_back(tem_layer);
        }
        return result;
    }
};

226. 翻转二叉树

在这里插入图片描述

参考

思路: 递归法

明确遍历顺序, 使用后序或前序遍历

//1.后序遍历
class Solution {
public:
    TreeNode* invertTree(TreeNode* root) {			//1. 明确递归函数的参数和返回值
        if (root == nullptr) return root;			//2. 确认终止条件
        TreeNode* left = invertTree(root->left);	//3. 单层递归逻辑
        TreeNode* right = invertTree(root->right);

        root->left  = right;
        root->right = left;
        return root;	//通常这里返回最终结果,在递归的第一层
    }
};

//2.前序遍历
class Solution {
public:
    TreeNode* invertTree(TreeNode* root) {
        if (root == NULL) return root;
        swap(root->left, root->right);  // 中
        invertTree(root->left);         // 左
        invertTree(root->right);        // 右
        return root;
    }
};

思路: 迭代法实现

//前序迭代法
class Solution {
public:
    TreeNode* invertTree(TreeNode* root) {
        stack<TreeNode*> mystack;
        if (root) mystack.push(root);
        while (!mystack.empty()) {
            TreeNode* tem = mystack.top();
            mystack.pop();
            swap(tem->right, tem->left);
            if (tem->right) mystack.push(tem->right);
            if (tem->left) mystack.push(tem->left);
        }
        return root;
    }
};

//统一迭代法(前序)
class Solution {
public:
    TreeNode* invertTree(TreeNode* root) {
        stack<TreeNode*> mystack;
        if(root) mystack.push(root);
        while (!mystack.empty()) {
            TreeNode* tem = mystack.top();
            if (tem != nullptr) {
                mystack.pop();
                if (tem->right) mystack.push(tem->right);
                if (tem->left) mystack.push(tem->left);
                mystack.push(tem);
                mystack.push(nullptr);
                
            } else {
                mystack.pop();
                swap(mystack.top()->left,mystack.top()->right);
                mystack.pop();
            }
        }
        return root;
    }
};

思路: 层序遍历实现

class Solution {
public:
    TreeNode* invertTree(TreeNode* root) {
        queue<TreeNode*> myqueue;
        if (root) myqueue.push(root);
        while (!myqueue.empty()) {
            int size = myqueue.size();
            for (int i = 0; i < size; i++) {
                TreeNode* tem = myqueue.front();
                myqueue.pop();
                if (tem->left) myqueue.push(tem->left);
                if (tem->right) myqueue.push(tem->right);
                swap(tem->left, tem->right);
            }
        }
        return root;
    }
};

101. 对称二叉树

在这里插入图片描述

参考

思路: 递归法

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

class Solution {
    bool judge(TreeNode* left, TreeNode* right) {
        if (left == nullptr && right == nullptr) return true;
        else if (left == nullptr || right == nullptr) return false;
        else if (left->val != right->val) return false;//left->val == right->val return true为错误操作
        //else return false;//错误操作

        bool res1 = judge(left->left, right->right);
        bool res2 = judge(left->right, right->left);
        return res1 && res2;
    }
public:
    bool isSymmetric(TreeNode* root) {
        if (root == nullptr) return true;
        return judge(root->left, root->right);
    }
};