8.22 树简单&中等 100 Same Tree 102 102 Binary Tree Level Order Traversal

emmm_Yeah

于 2024-08-22 16:12:30 发布

阅读量147

点赞数 4

分类专栏：算法学习文章标签：数据结构

本文链接：https://blog.csdn.net/emmm_Yeah/article/details/141429243

版权

算法学习专栏收录该内容

52 篇文章 0 订阅

订阅专栏

100 Same Tree

在这里插入图片描述

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode() : val(0), left(nullptr), right(nullptr) {}
 *     TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
 *     TreeNode(int x, TreeNode *left, TreeNode *right) : val(x), left(left), right(right) {}
 * };
 */
class Solution {
public:
    bool isSameTree(TreeNode* p, TreeNode* q) {
        //判断逻辑 和值都要相同
        stack<TreeNode*> stk1 , stk2;
        stk1.push(p);
        stk2.push(q);
        //先while循环，除了while循环的都为true 类似于过滤器
        while(!stk1.empty() || !stk2.empty()){
            TreeNode* node1 = stk1.top();stk1.pop();
            TreeNode* node2 = stk2.top();stk2.pop();

            //如果两个结点都为null 继续检查
            if(!node1 && !node2) continue;

            if(!node1 || !node2 || node1->val != node2->val) return false;

            // 将右子树压栈
            stk1.push(node1->right);
            stk2.push(node2->right);
            
            // 将左子树压栈
            stk1.push(node1->left);
            stk2.push(node2->left);
        }
        return stk1.empty() && stk2.empty();
    }
};

C++代码学习: 经典二叉树的非递归先序遍历

在经典的先序遍历中，我们通常使用一个栈来维护节点的访问顺序。流程是：

访问当前节点并处理它。
将右子节点压入栈（因为要先处理左子节点）。
将左子节点压入栈（因为左子节点优先于右子节点）。

void preOrder(TreeNode* root) {
    if (!root) return;
    stack<TreeNode*> stk;
    stk.push(root);
    while (!stk.empty()) {
        TreeNode* node = stk.top();
        stk.pop();
        // 访问节点
        cout << node->val << " ";
        // 先压入右子节点再压入左子节点
        if (node->right) stk.push(node->right);
        if (node->left) stk.push(node->left);
    }
}

~~果然纸质代码和机考不能混为一谈！！~~

102 Binary Tree Level Order Traversal【数据结构 is __】

在这里插入图片描述

class Solution {
public:
    vector<vector<int>> levelOrder(TreeNode* root) {
        // 层次遍历使用队列
        vector<vector<int>> valCollection;
        if (!root) return valCollection;

        queue<TreeNode*> nodeQueue;
        nodeQueue.push(root);

        while (!nodeQueue.empty()) {
            int levelSize = nodeQueue.size();  // 当前层的节点数
            vector<int> currentLevel;

            for (int i = 0; i < levelSize; ++i) {
                TreeNode* node = nodeQueue.front();
                nodeQueue.pop();
                currentLevel.push_back(node->val);

                // 将下一层的节点加入队列
                if (node->left) nodeQueue.push(node->left);
                if (node->right) nodeQueue.push(node->right);
            }

            valCollection.push_back(currentLevel);
        }

        return valCollection;
    }
};