C++刷题笔记(19)——leetcode116、117、226

最新推荐文章于 2024-09-26 09:13:29 发布

STATEABC

最新推荐文章于 2024-09-26 09:13:29 发布

阅读量167

点赞数 1

分类专栏：不知道能不能混口饭的C嘎嘎文章标签： c++ leetcode 数据结构算法

本文链接：https://blog.csdn.net/STATEABC/article/details/124672613

版权

不知道能不能混口饭的C嘎嘎专栏收录该内容

50 篇文章 3 订阅

订阅专栏

题目1：116.填充每个节点的下一个右侧节点指针

在这里插入图片描述

解法：层序遍历

使用层序遍历，在遍历过程中让前一个节点指向后一个节点

class Solution {
public:
    Node* connect(Node* root) {
        queue<Node*> que;
        if (root != NULL) que.push(root);     //如果根节点不为空则将其加入队列
        while (!que.empty()) {                //外层的while循环迭代的是层数
            int size = que.size();            //记录当前队列的大小               
            Node* node;
            for (int i = 0; i < size; i++) {  //遍历当前层
                node = que.front();           //取出当前层的头结点
                que.pop();
                if (i < size - 1) {
                    node->next = que.front(); //前一个节点指向下一个节点
                }
                if (node->left) que.push(node->left);
                if (node->right) que.push(node->right);
            }
        }
        return root;
    }
};

题目2：117.填充每个节点的下一个右侧节点指针Ⅱ

在这里插入图片描述

解法：层序遍历

和116比只是将完美二叉树改成了二二叉树，但是对于层序遍历来说没有区别，代码甚至可以不做任何改动

class Solution {
public:
    Node* connect(Node* root) {
        queue<Node*> que;
        if (root != NULL) que.push(root);     //如果根节点不为空则将其加入队列
        while (!que.empty()) {                //外层的while循环迭代的是层数
            int size = que.size();            //记录当前队列的大小               
            Node* node;
            for (int i = 0; i < size; i++) {  //遍历当前层
                node = que.front();           //取出当前层的头结点
                que.pop();
                if (i < size - 1) {
                    node->next = que.front(); //前一个节点指向下一个节点
                }
                if (node->left) que.push(node->left);
                if (node->right) que.push(node->right);
            }
        }
        return root;
    }
};

题目3：226.翻转二叉树

在这里插入图片描述
把每个节点的左右孩子交换，就可以到达翻转的效果

解法一：递归法

前序遍历
在这里插入图片描述

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*> st;
        if (root != NULL) st.push(root);
        while (!st.empty()) {
            TreeNode* node = st.top();                  //定义指针指向头节点
            if (node != NULL) {
                st.pop();
                if (node->right) st.push(node->right);  // 右
                if (node->left) st.push(node->left);    // 左
                st.push(node);                          // 中
                st.push(NULL);
            }
            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 != NULL) que.push(root);
        while (!que.empty()) {
            int size = que.size();
            for (int i = 0; i < size; i++) {
                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;
    }
};