DAY15: 层序遍历102、翻转二叉树226、对称二叉树101

Leetcode: 102层序遍历

代码随想录

二叉树的层序遍历，在图论上展现为广度优先搜索。

本题中选择队列作为辅助数据结构

迭代法

class Solution {
public:
    vector> levelOrder(TreeNode* root) {
        vector> result;//定义返回的二维数组
        queue que;//定义队列
        if(root != NULL) que.push(root);//先将根节点输入队列
        while(!que.empty()){
            vector vec;//保存每层的结构
            int nodesize = que.size();//计算每层的大小
            while(nodesize--){
                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;
    }
};

递归法

代码为代码随想录提供，供参考学习

class Solution {
public:
    void order(TreeNode* cur, vector>& result, int depth)
    {
        if (cur == nullptr) return;
        if (result.size() == depth) result.push_back(vector());
        result[depth].push_back(cur->val);
        order(cur->left, result, depth + 1);
        order(cur->right, result, depth + 1);
    }
    vector> levelOrder(TreeNode* root) {
        vector> result;
        int depth = 0;
        order(root, result, depth);
        return result;
    }
};

Leetcode: 226翻转二叉树

翻转二叉树，整体上是整个数沿着一条线对称翻转，但是从细节来看，就是左右节点的交换。

代码随想录

递归法

• 确定递归的参数和返回值：只需要传入节点的指针，返回节点的指针
• 递归的终止条件：当当前节点为NULL的时候
• 单层递归的逻辑：先交换左右孩子节点，然后反转左子树和右子树

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) {
        if(root == NULL) return root;
        stack st;
        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) {
        queue que;//定义队列
        if(root != NULL) que.push(root);//先将根节点输入队列
        while(!que.empty()){
            int nodesize = que.size();//计算每层的大小
            while(nodesize--){
                TreeNode* node = que.front();//先取当前节点，弹出队列，并将其左右子节点加入队列
                que.pop();
                swap(node->left, node->right);
                if(node->left) que.push(node->left);
                if(node->right) que.push(node->right);
            }
        }
        return root;
    }
};

Leetcode: 101对称二叉树

递归法

• 确定函数参数和返回值，输入左右节点，输出false或者true的bool判断。
• 确定递归终止条件，节点为空（左右子树NULL的情况），节点不为空（判断数值是否相等）
• 确定单层迭代逻辑：1、比较外侧左左子树的左孩子和右子树的右孩子是否相等。2、比较内侧左子树的右孩子和右子树的左孩子是否相等。3、如果都相等返回true。

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;
    	//迭代逻辑
        bool outside = compare(left->left, right->right);
        bool inside = compare(left->right, right->left);
        bool isSame = outside && inside;                   
        return isSame;

    }
    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;
        queue 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;
    }
};

使用栈

class Solution {
public:
    bool isSymmetric(TreeNode* root) {
        if (root == NULL) return true;
        stack 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) {
                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;
    }
};

小结

对于二叉树的题目，递归的条件非常重要，实际需要手写代码，不然总是看着很简单，写起来就容易出错。