Leetcode算法训练日记 | day14

已于 2024-04-04 23:12:29 修改
阅读量401 收藏 4
点赞数 9
文章标签： 算法 leetcode
于 2024-04-04 21:40:10 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_74882777/article/details/137382867
版权

一、二叉树的前序遍历

1.题目

Leetcode：第 144 题

给你二叉树的根节点 root ，返回它节点值的 前序 遍历。

示例 1：

输入：root = [1,null,2,3]
输出：[1,2,3]

示例 2：

输入：root = []
输出：[]

示例 3：

输入：root = [1]
输出：[1]

示例 4：

输入：root = [1,2]
输出：[1,2]

示例 5：

输入：root = [1,null,2]
输出：[1,2]

2.解题思路

迭代法和递归法

3.实现代码

#include <iostream>
#include <vector>
#include <stack>
#include <queue>
using namespace std;

// 定义一个结构体TreeNode，用于表示二叉树的节点。
struct TreeNode {
    int val; // 存储节点的值。
    TreeNode* left; // 指向该节点左子树的指针。
    TreeNode* right; // 指向该节点右子树的指针。
    // TreeNode的构造函数，用于创建一个TreeNode实例。
    // 参数x是节点的值，left和right默认为NULL，表示没有左右子节点。
    TreeNode(int x) : val(x), left(NULL), right(NULL) {}
};

//一、二叉树的前序遍历（递归法）
class Solution1 {
public:
    // 定义一个名为traversal的成员函数，用于执行二叉树的递归遍历。
    // 参数cur是当前遍历到的TreeNode指针，参数vec是一个引用，用于存储遍历结果。
    void traversal(TreeNode* cur, vector<int>& vec) {
        if (cur == NULL) { // 如果当前节点为空，则直接返回，不再继续遍历。
            return;
        }

        vec.push_back(cur->val); // 访问当前节点，将其值添加到容器vec中。
        traversal(cur->left, vec); // 递归遍历左子树。
        traversal(cur->right, vec); // 递归遍历右子树。
    }

    // 定义一个名为preorderTraversal的成员函数，用于返回二叉树的前序遍历结果,参数root是二叉树的根节点指针。
    vector<int> preorderTraversal(TreeNode* root) {
        vector<int> result; // 创建一个空容器，用于存储前序遍历的结果。
        traversal(root, result); // 调用traversal函数，传入根节点root和容器result的引用，执行前序遍历。
        return result; // 返回结果。
    }
};

//二、二叉树的前序遍历（迭代法）
class Solution2 {
public:
    // 定义名为preorderTraversal的成员函数，接受一个指向TreeNode的指针作为参数。
    // 函数的目的是返回一个包含二叉树前序遍历结果的容器。
    vector<int> preorderTraversal(TreeNode* root) {
        vector<int> result; // 创建一个空的整数向量result，用于存储前序遍历的结果。
        stack<TreeNode*> st;// 创建一个空的栈st，用于辅助进行前序遍历。
        if (root != NULL) {// 检查传入的二叉树根节点是否为空。
            st.push(root);// 如果根节点不为空，则将其压入栈中。
        }
       
        while (!st.empty()) { // 使用while循环进行遍历，直到栈为空。
            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 {// 如果node为空，说明栈顶元素是NULL，这表示已经处理完一个节点的左右子树
                st.pop();// 弹出栈顶元素（此时是NULL）
                node = st.top();// 获取当前节点。
                st.pop();// 弹出当前节点，并将其值添加到结果中。
                result.push_back(node->val);
            }
        }
        return result;// 返回包含前序遍历结果。
    }
};
    

//测试
// 辅助函数，用于创建一个新的TreeNode
TreeNode* createNode(int value) {
    return new TreeNode(value);
}

// 辅助函数，用于构建二叉树
TreeNode* buildTree(vector<int>& values) {
    if (values.empty()) return NULL;
    TreeNode* root = createNode(values[0]);
    queue<TreeNode*> queueNode;
    queueNode.push(root);
    int i = 1;
    while (!queueNode.empty()) {
        TreeNode* node = queueNode.front();
        queueNode.pop();
        if (i < values.size()) {
            node->left = createNode(values[i++]);
            queueNode.push(node->left);
        }
        if (i < values.size()) {
            node->right = createNode(values[i++]);
            queueNode.push(node->right);
        }
    }
    return root;
}

// 打印容器中的所有元素，用于验证测试结果
void printVector(const vector<int>& vec) {
    for (int value : vec) {
        cout << value << " ";
    }
    cout << endl;
}

// 主函数
int main() {

    vector<int> treeValues = { 1, 2, 3, 4, 5, 6, 7 };// 定义二叉树的层序遍历结果，用于构建二叉树
    TreeNode* root = buildTree(treeValues); // 构建二叉树
    Solution1 s1;// 创建Solution类的实例
    Solution2 s2;
    vector<int> result1 = s1.preorderTraversal(root);// 传入二叉树的根节点
    vector<int> result2 = s2.preorderTraversal(root);
    // 打印中序遍历的结果
    cout << "二叉树的前序遍历(递归法)结果是: ";
    printVector(result1);
    cout << endl;
    cout << "二叉树的前序遍历(迭代法)结果是: ";
    printVector(result2);
    cout << endl;
    return 0;
}

二、二叉树的中序遍历

1.题目

Leetcode：第 94 题

给定一个二叉树的根节点 root ，返回 它的 中序 遍历 。

示例 1：

输入：root = [1,null,2,3]
输出：[1,3,2]

示例 2：

输入：root = []
输出：[]

示例 3：

输入：root = [1]
输出：[1]
2.解题思路

迭代法和递归法

3.实现代码
#include <iostream>
#include <vector>
#include <stack>
#include <queue>
using namespace std;

// 定义一个结构体TreeNode，用于表示二叉树的节点。
struct TreeNode {
    int val; // 存储节点的值。
    TreeNode* left; // 指向该节点左子树的指针。
    TreeNode* right; // 指向该节点右子树的指针。
    // TreeNode的构造函数，用于创建一个TreeNode实例。
    // 参数x是节点的值，left和right默认为NULL，表示没有左右子节点。
    TreeNode(int x) : val(x), left(NULL), right(NULL) {}
};

//一、二叉树的中序遍历（递归法）
class Solution1 {
public:

    // 定义一个名为traversal的成员函数，用于执行二叉树的递归遍历。
    // 参数cur是当前遍历到的TreeNode指针，参数vec是一个引用，用于存储遍历结果。
    void traversal(TreeNode* cur, vector<int>& vec) {
        if (cur == NULL) { // 如果当前节点为空，则直接返回，不再继续遍历。
            return;
        }

        traversal(cur->left, vec);// 递归遍历左子树。
        vec.push_back(cur->val); // 访问当前节点，将其值添加到容器vec中。
        traversal(cur->right, vec);// 递归遍历右子树。
    }

    // 定义一个名为inorderTraversal的成员函数，用于返回二叉树的中序遍历结果，参数root是二叉树的根节点指针。
    vector<int> inorderTraversal(TreeNode* root) {
        vector<int> result; // 创建一个空容器，用于存储中序遍历的结果。
        traversal(root, result); // 调用traversal函数，传入根节点root和容器result的引用，执行中序遍历。
        return result; // 返回结果。
    }
};

//二、二叉树的中序遍历（迭代法）
class Solution2 {
public:

    // inorderTraversal函数用于实现中序遍历
    vector<int> inorderTraversal(TreeNode* root) {
        vector<int> result; // 存储遍历结果的数组
        stack<TreeNode*> st; // 定义一个栈，用于辅助中序遍历

        if (root != NULL) {// 如果根节点不为空，则将其入栈
            st.push(root);
        }
        
        while (!st.empty()) {// 当栈不为空时，循环执行以下操作
            TreeNode* node = st.top();// 获取栈顶元素
            if (node != NULL) { // 如果node不为空
                st.pop(); // 弹出栈顶元素
                if (node->right) {// 如果node有右子节点，先将右子节点入栈
                    st.push(node->right);
                }
                st.push(node); // 将当前节点再次压入栈中，这样做是为了在后续的遍历中能够访问到根节点。
                st.push(NULL); // 压入一个空指针作为中序遍历的分隔符。
                if (node->left) {// 如果node有左子节点，将左子节点入栈
                    st.push(node->left);
                }
            }
            else {// 如果node为空，说明栈顶元素是NULL，这表示已经处理完一个节点的左右子树
                st.pop();// 弹出栈顶元素（此时是NULL）
                node = st.top();// 获取当前节点。
                st.pop();// 弹出当前节点，并将其值添加到结果中。
                result.push_back(node->val);
            }
        }
        return result; // 返回中序遍历的结果
    }
};

//测试
// 辅助函数，用于创建一个新的TreeNode
TreeNode* createNode(int value) {
    return new TreeNode(value);
}

// 辅助函数，用于构建二叉树
TreeNode* buildTree(vector<int>& values) {
    if (values.empty()) return NULL;
    TreeNode* root = createNode(values[0]);
    queue<TreeNode*> queueNode;
    queueNode.push(root);
    int i = 1;
    while (!queueNode.empty()) {
        TreeNode* node = queueNode.front();
        queueNode.pop();
        if (i < values.size()) {
            node->left = createNode(values[i++]);
            queueNode.push(node->left);
        }
        if (i < values.size()) {
            node->right = createNode(values[i++]);
            queueNode.push(node->right);
        }
    }
    return root;
}

// 打印容器中的所有元素，用于验证测试结果
void printVector(const vector<int>& vec) {
    for (int value : vec) {
        cout << value << " ";
    }
    cout << endl;
}

// 主函数
int main() {
    
    vector<int> treeValues = { 1, 2, 3, 4, 5, 6, 7 };// 定义二叉树的层序遍历结果，用于构建二叉树
    TreeNode* root = buildTree(treeValues); // 构建二叉树
    Solution1 s1;// 创建Solution类的实例
    Solution2 s2;
    vector<int> result1 = s1.inorderTraversal(root);// 传入二叉树的根节点
    vector<int> result2 = s2.inorderTraversal(root); 
    cout << "二叉树的中序遍历(递归法)结果是: ";
    printVector(result1);
    cout << endl;
    cout << "二叉树的中序遍历(迭代法)结果是: ";
    printVector(result2);
    cout << endl;
    return 0;
}

三、二叉树的后序遍历

1.题目

Leetcode：第 145 题

给你一棵二叉树的根节点 root ，返回其节点值的 后序遍历 。

示例 1：

输入：root = [1,null,2,3]
输出：[3,2,1]

示例 2：

输入：root = []
输出：[]

示例 3：

输入：root = [1]
输出：[1]
2.解题思路

迭代法和递归法

3.实现代码
#include <iostream>
#include <vector>
#include <stack>
#include <queue>
using namespace std;

// 定义一个结构体TreeNode，用于表示二叉树的节点。
struct TreeNode {
    int val; // 存储节点的值。
    TreeNode* left; // 指向该节点左子树的指针。
    TreeNode* right; // 指向该节点右子树的指针。
    // TreeNode的构造函数，用于创建一个TreeNode实例。
    // 参数x是节点的值，left和right默认为NULL，表示没有左右子节点。
    TreeNode(int x) : val(x), left(NULL), right(NULL) {}
};


//一、二叉树的后序遍历（递归法）
class Solution1 {
public:
 
    // 定义一个名为traversal的成员函数，用于执行二叉树的递归后序遍历。
    // 参数cur是当前遍历到的TreeNode指针，参数vec是一个引用，用于存储遍历结果。
    void traversal(TreeNode* cur, vector<int>& vec) {
        if (cur == NULL) { // 如果当前节点为空，则返回，不执行任何操作。
            return;
        }
      
        traversal(cur->left, vec); // 递归调用traversal函数遍历当前节点的左子树。
        traversal(cur->right, vec); // 递归调用traversal函数遍历当前节点的右子树。
        vec.push_back(cur->val);// 访问当前节点，将其值添加到容器vec中。
    }

    // 定义一个名为postorderTraversal的成员函数，用于返回二叉树的后序遍历结果,参数root是二叉树的根节点指针。
    vector<int> postorderTraversal(TreeNode* root) {
        vector<int> result; // 创建一个空容器，用于存储后序遍历的结果。
        traversal(root, result); // 调用traversal函数，传入根节点root和容器result的引用，执行后序遍历。
        return result; // 返回结果。
    }
};

//二、二叉树的后序遍历（迭代法）
class Solution2 {
public:

    // postorderTraversal函数用于实现后序遍历
    vector<int> postorderTraversal(TreeNode* root){
        vector<int> result; // 存储遍历结果的数组
        stack<TreeNode*> st; // 定义一个栈，用于辅助中序遍历

        if (root != NULL) {// 如果根节点不为空，则将其入栈
            st.push(root);
        }

        while (!st.empty()) {// 当栈不为空时，循环执行以下操作
            TreeNode* node = st.top();// 获取栈顶元素
            if (node != NULL) { // 如果node不为空
                st.pop(); // 弹出栈顶元素
                st.push(node); // 将当前节点再次压入栈中，这样做是为了在后续的遍历中能够访问到根节点。
                st.push(NULL); // 压入一个空指针作为后序遍历的分隔符。
                if (node->right) {// 如果node有右子节点，先将右子节点入栈
                    st.push(node->right);
                }
                if (node->left) {// 如果node有左子节点，将左子节点入栈
                    st.push(node->left);
                }
            }
            else {// 如果node为空，说明栈顶元素是NULL，这表示已经处理完一个节点的左右子树
                st.pop();// 弹出栈顶元素（此时是NULL）
                node = st.top();// 获取当前节点。
                st.pop();// 弹出当前节点，并将其值添加到结果中。
                result.push_back(node->val);
            }
        }
        return result; // 返回后序遍历的结果
    }
};


//测试
// 辅助函数，用于创建一个新的TreeNode
TreeNode* createNode(int value) {
    return new TreeNode(value);
}

// 辅助函数，用于构建二叉树
TreeNode* buildTree(vector<int>& values) {
    if (values.empty()) return NULL;
    TreeNode* root = createNode(values[0]);
    queue<TreeNode*> queueNode;
    queueNode.push(root);
    int i = 1;
    while (!queueNode.empty()) {
        TreeNode* node = queueNode.front();
        queueNode.pop();
        if (i < values.size()) {
            node->left = createNode(values[i++]);
            queueNode.push(node->left);
        }
        if (i < values.size()) {
            node->right = createNode(values[i++]);
            queueNode.push(node->right);
        }
    }
    return root;
}

// 打印容器中的所有元素，用于验证测试结果
void printVector(const vector<int>& vec) {
    for (int value : vec) {
        cout << value << " ";
    }
    cout << endl;
}

// 主函数
int main() {

    vector<int> treeValues = { 1, 2, 3, 4, 5, 6, 7 };// 定义二叉树的层序遍历结果，用于构建二叉树
    TreeNode* root = buildTree(treeValues); // 构建二叉树
    Solution1 s1;// 创建Solution类的实例
    Solution2 s2;
    vector<int> result1 = s1.postorderTraversal(root);// 传入二叉树的根节点
    vector<int> result2 = s2.postorderTraversal(root);
    cout << "二叉树的后序遍历(递归法)结果是: ";
    printVector(result1);
    cout << endl;
    cout << "二叉树的后序遍历(迭代法)结果是: ";
    printVector(result2);
    cout << endl;
    return 0;
}

        ps：以上皆是本人在探索算法世界旅途中的浅薄见解，诚挚地希望得到各位的宝贵意见与悉心指导，若有不足或谬误之处，还请多多指教。 

山川人海
关注
  • 9
    点赞
  • 踩
  • 4
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
arith:LeetCode算法训练
03-10
arith:LeetCode算法训练
leetcode2sumc-LeetCode:Leetcodealgorithms|Leetcode算法题
06-30
leetcode 2 和 c 力扣算法 # 标题 解决方案 困难 680 , 简单的 678 , 中等的 666 , 中等的 663 中等的 662 中等的 661 简单的 660 难的 657 简单的 653 , 简单的 650 中等的 647 中等的 605 , 简单的 599 , 简单的 ...
Leetcode算法训练日记 | day34
m0_74882777的博客
04-23 1267
Leetcode：第 1005 题 给你一个整数数组nums和一个整数k，按以下方法修改该数组：选择某个下标i并将nums[i]替换为-nums[i]。重复这个过程恰好k次。可以多次选择同一个下标i。以这种方式修改数组后，返回数组可能的最大和。 Leetcode：第 134 题 在一条环路上有n个加油站，其中第i个加油站有汽油gas[i]升。 Leetcode：第 135 题 n个孩子站成一排。给你一个整数数组ratings表示每个孩子的评分。
Leetcode算法训练日记 | day31
m0_74882777的博客
04-20 990
Leetcode：第 455 题 假设你是一位很棒的家长，想要给你的孩子们一些小饼干。但是，每个孩子最多只能给一块饼干。 Leetcode：第 376 题 如果连续数字之间的差严格地在正数和负数之间交替，则数字序列称为摆动序列 。第一个差（如果存在的话）可能是正数或负数。仅有一个元素或者含两个不等元素的序列也视作摆动序列。
Leetcode算法训练日记 | day30
m0_74882777的博客
04-19 674
Leetcode：第 332 题 给你一份航线列表tickets，其中tickets[i] = [fromi, toi]表示飞机出发和降落的机场地点。请你对该行程进行重新规划排序。 Leetcode：第 51 题 按照国际象棋的规则，皇后可以攻击与之处在同一行或同一列或同一斜线上的棋子。 n皇后问题研究的是如何将n个皇后放置在n×n的棋盘上，并且使皇后彼此之间不能相互攻击。给你一个整数n，返回所有不同的n皇后问题的解决方案。
Leetcode算法训练日记 | day36
m0_74882777的博客
04-25 660
Leetcode：第 435 题 给定一个区间的集合intervals，其中intervals[i] = [starti, endi]。返回需要移除区间的最小数量，使剩余区间互不重叠。 Leetcode：第 763 题 给你一个字符串s。我们要把这个字符串划分为尽可能多的片段，同一字母最多出现在一个片段中。 Leetcode：第 56 题 以数组intervals表示若干个区间的集合，其中单个区间为intervals[i] = [starti, endi]。
Leetcode算法训练日记 | day29
m0_74882777的博客
04-18 964
Leetcode：第 491 题 给你一个整数数组nums，找出并返回所有该数组中不同的递增子序列，递增子序列中至少有两个元素。你可以按任意顺序返回答案。数组中可能含有重复元素，如出现两个整数相等，也可以视作递增序列的一种特殊情况。 Leetcode：第 46题 给定一个不含重复数字的数组nums，返回其所有可能的全排列。你可以按任意顺序返回答案。 Leetcode：第 47题 给定一个可包含重复数字的序列nums，按任意顺序返回所有不重复的全排列。
Leetcode算法训练日记 | day18
m0_74882777的博客
04-06 766
Leetcode：第 513 题 给定一个二叉树的根节点root，请找出该二叉树的最底层最左边节点的值。假设二叉树中至少有一个节点。 Leetcode：第 112题 给你二叉树的根节点root和一个表示目标和的整数targetSum。判断该树中是否存在根节点到叶子节点的路径，这条路径上所有节点值相加等于目标和targetSum。如果存在，返回true；否则，返回false。叶子节点是指没有子节点的节点。
Leetcode算法训练日记 | day32
m0_74882777的博客
04-20 947
Leetcode：第 53题 给你一个整数数组nums，请你找出一个具有最大和的连续子数组（子数组最少包含一个元素），返回其最大和。子数组是数组中的一个连续部分。 Leetcode：第 122 题 给你一个整数数组prices，其中prices[i]表示某支股票第i天的价格。 在每一天，你可以决定是否购买和/或出售股票。你在任何时候最多只能持有一股股票。你也可以先购买，然后在同一天出售。 返回你能获得的最大利润。
Leetcode算法训练日记 | day10
m0_74882777的博客
03-29 994
请你仅使用两个栈实现先入先出队列。队列应当支持一般队列支持的所有操作（push、pop、peek、empty）。 请你仅使用两个队列实现一个后入先出（LIFO）的栈，并支持普通栈的全部四种操作（push、top、pop 和 empty）。
Leetcode算法训练日记 | day35
m0_74882777的博客
04-24 698
Leetcode：第 860 题 在柠檬水摊上，每一杯柠檬水的售价为5美元。顾客排队购买你的产品，（按账单bills支付的顺序）一次购买一杯。 Leetcode：第 406 题 假设有打乱顺序的一群人站成一个队列，数组people表示队列中一些人的属性（不一定按顺序）。每个people[i] = [hi, ki]表示第i个人的身高为hi，前面正好有ki个身高大于或等于hi的人。 Leetcode：第 452 题 有一些球形气球贴在一堵用 XY 平面表示的墙面上。
LeetCode算法数据结构专训笔记,
03-26
LeetCode算法数据结构专训笔记, 刷完之后对于自生的算法能力有着绝对的提升, 而且好处，题目分类清晰，专项专训, 题目存在套路，不会出现说刷不下去的问题存在
LeetCode 算法
09-07
本资源收集于互联网， 为LeetCode 算法习题和答案，供大家共同学习和进步
leetcode初级算法.zip
10-23
leetcode初级算法代码C++完整版，里面是我认为最适合于新手解题的代码，包含详细的注释，还有个人感悟和总结，适合于想要入门的新手。
【算法】二分算法——x的平方根
2302_79031646的博客
05-17 782
用二分边界算法来求解——x的平方根，从暴力求解到二分的优化细说
【算法】【二叉树，DFS，哈希集合，分类讨论】力扣1110. 删点成林
未来就在脚下。
05-20 494
本题通过DFS遍历二叉树，结合分类讨论的方法，逐步删除指定节点并生成新的森林。该算法有效地处理了节点删除后树结构的调整问题，并通过哈希集合优化删除判断的时间复杂度，最终实现了高效的解决方案。
力扣62 不同路径 Java版本
最新发布
m0_47066863的博客
05-20 185
机器人每次只能向下或者向右移动一步。机器人试图达到网格的右下角（在下图中标记为 “Finish” ）。一个机器人位于一个 m x n 网格的左上角 （起始点在下图中标记为 “Start” ）。从左上角开始，总共有 3 条路径可以到达右下角。题目数据保证答案小于等于 2 * 109。输入：m = 3, n = 7。输入：m = 3, n = 2。输入：m = 7, n = 3。输入：m = 3, n = 3。问总共有多少条不同的路径？
MT2057 门票
l141930402的博客
05-15 759
前缀和+归并排序
如何快速掌握LeetCode算法题
06-13
以下是一些快速掌握LeetCode算法题的建议，供您参考： 1. 学习数据结构和算法基础知识：LeetCode算法题需要掌握一些数据结构和算法基础知识，例如链表、树、堆、排序、查找、动态规划等。可以通过参考经典算法书籍...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值