从C语言到C++_25(树的十道OJ题)力扣:606+102+107+236+426+105+106+144+94+145

最新推荐文章于 2024-07-25 23:22:43 发布
最新推荐文章于 2024-07-25 23:22:43 发布
阅读量351 收藏 1
点赞数 1
分类专栏： ④从C语言到熟悉C++ 文章标签： c++ c语言 数据结构 力扣 leetcode
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/GRrtx/article/details/131123508
版权

目录

606. 根据二叉树创建字符串 - 力扣（LeetCode）

解析代码：

102. 二叉树的层序遍历 - 力扣（LeetCode）

解析代码：

107. 二叉树的层序遍历 II - 力扣（LeetCode）

解析代码：

236. 二叉树的最近公共祖先 - 力扣（LeetCode）

解析代码：（法一）

解析代码：（法二）

剑指 Offer 36. 二叉搜索树与双向链表 - 力扣（LeetCode）

二叉搜索树与双向链表_牛客题霸_牛客网 (nowcoder.com)

解析代码：（牛客）

解析代码：（力扣）

105. 从前序与中序遍历序列构造二叉树 - 力扣（LeetCode）

解析代码：

106. 从中序与后序遍历序列构造二叉树 - 力扣（LeetCode）

解析代码：

144. 二叉树的前序遍历 - 力扣（LeetCode）

解析代码：

94. 二叉树的中序遍历 - 力扣（LeetCode）

解析代码：

145. 二叉树的后序遍历 - 力扣（LeetCode）

解析代码：

本章完。

以下题目更适合使用C++完成，难度也更大一些，所以放在这里。

文字解析能力有限，难理解的地方可以跟着代码画画图，或者看看官方题解。

606. 根据二叉树创建字符串 - 力扣（LeetCode）

难度简单

给你二叉树的根节点 root ，请你采用前序遍历的方式，将二叉树转化为一个由括号和整数组成的字符串，返回构造出的字符串。

空节点使用一对空括号对 "()" 表示，转化后需要省略所有不影响字符串与原始二叉树之间的一对一映射关系的空括号对。

示例 1：

输入：root = [1,2,3,4]
输出："1(2(4))(3)"
解释：初步转化后得到 "1(2(4)())(3()())" ，但省略所有不必要的空括号对后，字符串应该是"1(2(4))(3)" 。

示例 2：

输入：root = [1,2,3,null,4]
输出："1(2()(4))(3)"
解释：和第一个示例类似，但是无法省略第一个空括号对，否则会破坏输入与输出一一映射的关系。

提示：

  • 树中节点的数目范围是 [1, 10^4]
  • -1000 <= Node.val <= 1000
/**
 * 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:
    string tree2str(TreeNode* root) {

    }
};

解析代码：

class Solution {
public:    // 这里的2有人当成to命名
    string tree2str(TreeNode* root) {
        if(root == nullptr)
        {
            return string(); // 返回匿名对象
        }
        string str;
        str += to_string(root->val);

        if(root->left || root->right)//左不为空或者左为空,右不为空,左需要加括号
        {
            str += '(';
            str += tree2str(root->left);
            str += ')';
        }

        if(root->right)//右不为空,右需要加括号
        {
            str += '(';
            str += tree2str(root->right);
            str += ')';
        }
        return str;
    }
};

这段代码的缺陷就是传值返回，代价有点大，

改进就是写一个子函数去用引用返回，这里就不改了。

102. 二叉树的层序遍历 - 力扣（LeetCode）

难度中等

给你二叉树的根节点 root ，返回其节点值的 层序遍历 。 （即逐层地，从左到右访问所有节点）。

示例 1：

输入：root = [3,9,20,null,null,15,7]
输出：[[3],[9,20],[15,7]]

示例 2：

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

示例 3：

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

提示：

  • 树中节点数目在范围 [0, 2000] 内

  • -1000 <= Node.val <= 1000

/**
 * 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:
    vector<vector<int>> levelOrder(TreeNode* root) {

    }
};

解析代码：

以前用C语言讲的层序遍历：

数据结构与算法⑯(第四章_下)二叉树的层序遍历+判断完全二叉树+一道OJ_GR C的博客-CSDN博客

现在我们有STL就不用自己弄一个队列了，而且可以对比一下选C语言给的代码和选C++给的，

就能体会到C++的方便了，C++写：

class Solution {
public:
    vector<vector<int>> levelOrder(TreeNode* root) {
        queue<TreeNode*> q;
        int levelSize = 0; // 每一层的结点数量，因为要放在不同的vector中
        if(root)
        {
            q.push(root);
            levelSize = 1;
        }

        vector<vector<int>> vv;
        while(!q.empty())
        {
            vector<int> v;
            while(levelSize--) // 控制一层一层出
            {
                TreeNode* front = q.front();
                v.push_back(front->val);

                if(front->left) // 出完一个就入它的左右结点
                {
                    q.push(front->left);
                }
                if(front->right)
                {
                    q.push(front->right);
                }
                q.pop();
            }
            levelSize = q.size(); // 此时下一层的已入完，更新levelSize
            vv.push_back(v);
        }
        return vv;
    }
};

107. 二叉树的层序遍历 II - 力扣（LeetCode）

难度中等

给你二叉树的根节点 root ，返回其节点值 自底向上的层序遍历 。 （即按从叶子节点所在层到根节点所在的层，逐层从左向右遍历）

示例 1：

输入：root = [3,9,20,null,null,15,7]
输出：[[15,7],[9,20],[3]]

示例 2：

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

示例 3：

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

提示：

  • 树中节点数目在范围 [0, 2000] 内

  • -1000 <= Node.val <= 1000

/**
 * 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:
    vector<vector<int>> levelOrderBottom(TreeNode* root) {

    }
};

解析代码：

这题写过上面的，直接复制上面的代码，最后加一句reverse：

class Solution {
public:
    vector<vector<int>> levelOrderBottom(TreeNode* root) {
        queue<TreeNode*> q;
        int levelSize = 0; // 每一层的结点数量，因为要放在不同的vector中
        if(root)
        {
            q.push(root);
            levelSize = 1;
        }

        vector<vector<int>> vv;
        while(!q.empty())
        {
            vector<int> v;
            while(levelSize--) // 控制一层一层出
            {
                TreeNode* front = q.front();
                v.push_back(front->val);

                if(front->left) // 出完一个就入它的左右结点
                {
                    q.push(front->left);
                }
                if(front->right)
                {
                    q.push(front->right);
                }
                q.pop();
            }
            levelSize = q.size(); // 此时下一层的已入完，更新levelSize
            vv.push_back(v);
        }
        reverse(vv.begin(),vv.end());
        return vv;
    }
};

236. 二叉树的最近公共祖先 - 力扣（LeetCode）

难度中等

给定一个二叉树, 找到该树中两个指定节点的最近公共祖先。

百度百科中最近公共祖先的定义为：“对于有根树 T 的两个节点 p、q，最近公共祖先表示为一个节点 x，满足 x 是 p、q 的祖先且 x 的深度尽可能大（一个节点也可以是它自己的祖先）。”

示例 1：

输入：root = [3,5,1,6,2,0,8,null,null,7,4], p = 5, q = 1
输出：3
解释：节点5和节点1的最近公共祖先是节点3 。

示例 2：

输入：root = [3,5,1,6,2,0,8,null,null,7,4], p = 5, q = 4
输出：5
解释：节点5和节点4的最近公共祖先是节点5 。

因为根据定义最近公共祖先节点可以为节点本身。

示例 3：

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

提示：

  • 树中节点数目在范围 [2, 105] 内。
  • -109 <= Node.val <= 109
  • 所有 Node.val 互不相同 。
  • p != q
  • p 和 q 均存在于给定的二叉树中。
/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode(int x) : val(x), left(NULL), right(NULL) {}
 * };
 */
class Solution {
public:
    TreeNode* lowestCommonAncestor(TreeNode* root, TreeNode* p, TreeNode* q) {
        
    }
};

解析代码：（法一）

class Solution {
public:
    bool Find(TreeNode* sub,TreeNode* x)
    {
        if(sub == nullptr)
        {
            return false;
        }
        return sub == x 
        || Find(sub->left,x) 
        || Find(sub->right,x);
    }

    TreeNode* lowestCommonAncestor(TreeNode* root, TreeNode* p, TreeNode* q) {
        if(root == p || root == q) // 只要其中一个是自己自己，自己就是公共祖先
        {
            return root;
        }
        bool pInLeft,pInRight,qInLeft,qInRight;
        pInLeft = Find(root->left,p);
        pInRight = !pInLeft; // 依题意,p不在左边就在右边

        qInLeft = Find(root->left,q);
        qInRight = !qInLeft; // 同上

        if((pInLeft && qInRight) || (qInLeft && pInRight))
        {
            return root; // 如果一个在左边,一个在右边,自己就是祖先
        }
        else if(pInLeft && qInLeft) // 如果两个都在左边,递归去左边
        {
            return lowestCommonAncestor(root->left,p,q);
        }
        else // 只剩两个都在右边的情况
        {
            return lowestCommonAncestor(root->right,p,q);
        }
    }
};

法一的时间复杂度是O（H*N）H是树的高度，N是树的结点数，怎么优化到O(N)?

解析代码：（法二）

我们把要找的结点的所有祖先都用栈存起来，

（按前序找，不确定是不是就入栈，确定不是就pop掉继续找）

然后转化为链表相交问题：

class Solution {
public:
    bool FindPath(TreeNode* root,TreeNode* x,stack<TreeNode*>& path)
    {
        if(root == nullptr)
            return false;

        path.push(root); // 不管是不是，先入栈
        if(root == x)
            return true; // 找到返回true
        if(FindPath(root->left,x,path))
            return true; // 左树找到返回true
        if(FindPath(root->right,x,path))
            return true; // 右树找到返回true
        path.pop(); // 都找不到
        return false;
    }
    
    TreeNode* lowestCommonAncestor(TreeNode* root, TreeNode* p, TreeNode* q) {
        stack<TreeNode*> pPath,qPath;
        FindPath(root,p,pPath);
        FindPath(root,q,qPath);

        while(pPath.size() != qPath.size()) // 类似链表相交
        {
            if(pPath.size() > qPath.size())
            {
                pPath.pop();
            }
            else
            {
                qPath.pop();
            }
        }
        while(pPath.top() != qPath.top())
        {
            pPath.pop();
            qPath.pop();
        }
        return pPath.top(); // 相等，返回其中一个
    }
};

剑指 Offer 36. 二叉搜索树与双向链表 - 力扣（LeetCode）

输入一棵二叉搜索树，将该二叉搜索树转换成一个排序的循环双向链表。要求不能创建任何新的节点，只能调整树中节点指针的指向。

为了让您更好地理解问题，以下面的二叉搜索树为例：

我们希望将这个二叉搜索树转化为双向循环链表。链表中的每个节点都有一个前驱和后继指针。对于双向循环链表，第一个节点的前驱是最后一个节点，最后一个节点的后继是第一个节点。

下图展示了上面的二叉搜索树转化成的链表。“head” 表示指向链表中有最小元素的节点。

特别地，我们希望可以就地完成转换操作。当转化完成以后，树中节点的左指针需要指向前驱，树中节点的右指针需要指向后继。还需要返回链表中的第一个节点的指针。

注意：本题与主站 426 题相同：力扣

注意：此题对比原题有改动。

 （牛客一道差不多的题的链接：）

二叉搜索树与双向链表_牛客题霸_牛客网 (nowcoder.com)

解析代码：（牛客）

/*
struct TreeNode {
	int val;
	struct TreeNode *left;
	struct TreeNode *right;
	TreeNode(int x) :
			val(x), left(NULL), right(NULL) {
	}
};*/
class Solution {
public:
    void InOrderConvert(TreeNode* cur, TreeNode*& prev) // 希望就有一个prev,传引用
	{
		if(cur == nullptr)
		{
			return;
		}
		InOrderConvert(cur->left,prev);
		cur->left = prev; // 走到中序这,知道cur的left和prev的right
		if(prev)
		{
			prev->right = cur;
		}
		prev = cur; // 往后走
		InOrderConvert(cur->right,prev);
	}	

    TreeNode* Convert(TreeNode* pRootOfTree) {
        TreeNode* prev = nullptr;
		InOrderConvert(pRootOfTree,prev);

		TreeNode* head = pRootOfTree;
		while(head && head->left) // 找链表的头结点
		{
			head = head->left;
		}
		return head;
    }
};

解析代码：（力扣）

力扣的就是在牛客的基础上改成双向链表：（要判空了）

/*
// Definition for a Node.
class Node {
public:
    int val;
    Node* left;
    Node* right;

    Node() {}

    Node(int _val) {
        val = _val;
        left = NULL;
        right = NULL;
    }

    Node(int _val, Node* _left, Node* _right) {
        val = _val;
        left = _left;
        right = _right;
    }
};
*/
class Solution {
public:
    void treeToDoublyListInOrder(Node* cur,Node*& prev)
    {
        if(cur == nullptr)
		{
			return;
		}
		treeToDoublyListInOrder(cur->left,prev);
		cur->left = prev; // 走到中序这,知道cur的left和prev的right
		if(prev)
		{
			prev->right = cur;
		}
		prev = cur; // 往后走
		treeToDoublyListInOrder(cur->right,prev);
    }
    Node* treeToDoublyList(Node* root) {
        if(root == nullptr)
        {
            return nullptr;
        }

        Node* prev = nullptr;
        treeToDoublyListInOrder(root,prev);

        Node* head = root;
        while(head && head->left) // 找链表的头结点
        {
            head = head->left;
        }
        Node* tail = root; // 变成双向循环链表
        while(tail && tail->right)
        {
            tail = tail->right;
        }
        head->left = tail;
        tail->right = head;
        return head;
    }
};

105. 从前序与中序遍历序列构造二叉树 - 力扣（LeetCode）

难度中等

给定两个整数数组 preorder 和 inorder ，其中 preorder 是二叉树的先序遍历， inorder 是同一棵树的中序遍历，请构造二叉树并返回其根节点。

示例 1:

输入: preorder = [3,9,20,15,7], inorder = [9,3,15,20,7]
输出: [3,9,20,null,null,15,7]

示例 2:

输入: preorder = [-1], inorder = [-1]
输出: [-1] 

提示:

  • 1 <= preorder.length <= 3000
  • inorder.length == preorder.length
  • -3000 <= preorder[i], inorder[i] <= 3000
  • preorder 和 inorder 均 无重复 元素
  • inorder 均出现在 preorder
  • preorder 保证 为二叉树的前序遍历序列
  • inorder 保证 为二叉树的中序遍历序列
/**
 * 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:
    TreeNode* buildTree(vector<int>& preorder, vector<int>& inorder) {

    }
};

解析代码：

class Solution {
public:
    TreeNode* _buildTree(vector<int>& preorder, vector<int>& inorder, int& prei, int left, int right)
	{
		if (left > right)
		{
			return nullptr;
		}
		TreeNode* root = new TreeNode(preorder[prei++]); // 先构建好根
		int ini = left; // 分割中序
		while (ini <= right)
		{
			if (inorder[ini] == root->val)
			{
				break;
			}
			else
			{
				ini++;
			}
		}
		// [left,ini-1] ini [ini+1,right] 构建好根之后,构建根的左右子树
        root->left = _buildTree(preorder, inorder, prei, left, ini - 1);
		root->right = _buildTree(preorder, inorder, prei, ini + 1, right);
		return root;
	}

    TreeNode* buildTree(vector<int>& preorder, vector<int>& inorder) {
        int i = 0;
		return _buildTree(preorder, inorder, i, 0, inorder.size() - 1);
    }
};

106. 从中序与后序遍历序列构造二叉树 - 力扣（LeetCode）

难度中等

给定两个整数数组 inorder 和 postorder ，其中 inorder 是二叉树的中序遍历， postorder 是同一棵树的后序遍历，请你构造并返回这颗 二叉树 。

示例 1:

输入：inorder = [9,3,15,20,7], postorder = [9,15,7,20,3]
输出：[3,9,20,null,null,15,7]

示例 2:

输入：inorder = [-1], postorder = [-1]
输出：[-1]

提示:

  • 1 <= inorder.length <= 3000
  • postorder.length == inorder.length
  • -3000 <= inorder[i], postorder[i] <= 3000
  • inorder 和 postorder 都由 不同 的值组成
  • postorder 中每一个值都在 inorder 中
  • inorder 保证是树的中序遍历
  • postorder 保证是树的后序遍历
/**
 * 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:
    TreeNode* buildTree(vector<int>& inorder, vector<int>& postorder) {

    }
};

解析代码：

class Solution {
public:
	TreeNode* _buildTree(vector<int>& inorder, vector<int>& postorder, int& prei, int left, int right)
	{
		if (left > right)
		{
			return nullptr;
		}
		TreeNode* root = new TreeNode(postorder[prei--]); // 从后面开始new
		int ini = left; // 分割中序
		while (ini <= right)
		{
			if (inorder[ini] == root->val)
			{
				break;
			}
			else
			{
				ini++;
			}
		}
		// [left,ini-1] ini [ini+1,right] 先构建右再构建左
		root->right = _buildTree(inorder, postorder, prei, ini + 1, right);
        root->left = _buildTree(inorder, postorder, prei, left, ini - 1);
		return root;
	}

	TreeNode* buildTree(vector<int>& inorder, vector<int>& postorder) {
		int i = inorder.size() - 1;
		return _buildTree(inorder, postorder, i, 0, inorder.size() - 1);
	}
};

144. 二叉树的前序遍历 - 力扣（LeetCode）

难度简单

给你二叉树的根节点 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]

提示：

  • 树中节点数目在范围 [0, 100] 内
  • -100 <= Node.val <= 100

进阶：递归算法很简单，你可以通过迭代算法完成吗？

/**
 * 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:
    vector<int> preorderTraversal(TreeNode* root) {

};

解析代码：

这道题用C语言写过递归版本的，当时说了后面会用非递归写，兑现承诺了属于是：

数据结构与算法⑮(第四章_下)二叉树OJ(力扣:144,965,104,110,226,100,101,572)_GR C的博客-CSDN博客

class Solution {
public:
    vector<int> preorderTraversal(TreeNode* root) {
        stack<TreeNode*> st;
        vector<int> v;
        TreeNode* cur = root;
        while(cur || !st.empty()) // 开始访问每一颗树，最后再写退出循环的条件
        {
            while(cur) // 1.左路结点的值直接输出，结点入栈
            {
                v.push_back(cur->val);
                st.push(cur);
                cur = cur->left;
            }

            TreeNode* top = st.top(); // 2.访问左路结点的右子树
            st.pop();
            cur = top->right; // 子问题回到循环访问右子树，非递归的精髓
        }
        return v;
    }
};

94. 二叉树的中序遍历 - 力扣（LeetCode）

难度简单

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

示例 1：

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

示例 2：

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

示例 3：

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

提示：

  • 树中节点数目在范围 [0, 100] 内
  • -100 <= Node.val <= 100

进阶: 递归算法很简单，你可以通过迭代算法完成吗？

/**
 * 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:
    vector<int> inorderTraversal(TreeNode* root) {

    }
};

解析代码：

上面也有其它思路，但我们上面的思路前中后序遍历的思路是互通的，只是输出时机不同：

class Solution {
public:
    vector<int> inorderTraversal(TreeNode* root) {
        stack<TreeNode*> st;
        vector<int> v;
        TreeNode* cur = root;
        while(cur || !st.empty()) // 开始访问每一颗树
        {
            while(cur) // 1.左路结点入栈
            {
                st.push(cur);
                cur = cur->left;
            }
            // 当这个结点从栈出来,表明这个结点的左路结点已经访问了
            TreeNode* top = st.top();
            st.pop();
            v.push_back(top->val); // 2. 输出这个结点
            cur = top->right; // 子问题回到循环访问右子树，非递归的精髓
        }
        return v;
    }
};

145. 二叉树的后序遍历 - 力扣（LeetCode）

难度简单

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

示例 1：

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

示例 2：

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

示例 3：

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

提示：

  • 树中节点的数目在范围 [0, 100] 内
  • -100 <= Node.val <= 100

进阶：递归算法很简单，你可以通过迭代算法完成吗？

/**
 * 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:
    vector<int> postorderTraversal(TreeNode* root) {

    }
};

解析代码：

后序和前面两个有点不一样，当你左路结点访问了，这时如果你的右结点为空，

你可以输出根结点，否则要访问右结点，访问右结点之后，回到根结点，

根结点的右结点还是不为空，所以根结点的右结点访问过了的情况也要输出根结点：

class Solution {
public:
    vector<int> postorderTraversal(TreeNode* root) {
        stack<TreeNode*> st;
        vector<int> v;
        TreeNode* cur = root;
        TreeNode* prev = nullptr;
        while(cur || !st.empty()) // 开始访问每一颗树
        {
            while(cur) // 1.左路结点入栈
            {
                st.push(cur);
                cur = cur->left;
            }
            // 当这个结点从栈出来,表明这个结点的左路结点已经访问了
            TreeNode* top = st.top();
            if(top->right == nullptr || prev == top->right) //如果右为空或者上一个输出的结点是右
            {
                v.push_back(top->val); // 2. 输出这个结点
                prev = top; // 记录上一个输出的结点
                st.pop();
            }
            else
            {
                cur = top->right; // 子问题回到循环访问右子树，非递归的精髓
            }
        }
        return v;
    }
};

本章完。

下一部分：set和map容器

GR鲸鱼
关注
  • 1
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
hustoj A+B问题16种语言及答案
11-08
hustoj A+B问题16种语言及答案
AlgoSolutions：AlgoSolutions-LeetCode +剑指提供+编程之美+ zoj + CrackigCode150
02-02
《算法实践：从LeetCode到Cracking the Coding Interview》 在IT行业中，算法是程序员的基础技能之一，它关乎着程序的效率、性能以及问题解决的能力。本资源集合，"AlgoSolutions"，是一个专门为算法爱好者和从业者...
从C语言到C++_18(stack和queue的常用函数+相关练习)力扣
参考书籍：《C语言程序设计》《数据结构》《C++ Primer》《Effective C++》《STL源码剖析》《现代操作系统》《UNIX环境高级编程》《图解TCP/IP》《图解HTTP》《Linux高性能服务器编程》《剑指Offer》《算法导论》
06-11 2298
从C语言到C++_18(stack和queue的常用函数+相关练习)力扣：155+946(剑指offe31)+150+225+232。
从C语言到C++_24(二叉搜索树)概念+完整代码实现+笔试题
参考书籍：《C语言程序设计》《数据结构》《C++ Primer》《Effective C++》《STL源码剖析》《现代操作系统》《UNIX环境高级编程》《图解TCP/IP》《图解HTTP》《Linux高性能服务器编程》《剑指Offer》《算法导论》
07-06 633
从C语言到C++_24（二叉搜索树）概念+模拟实现（完整代码）+笔试选择题。下一部分：树的OJ题，然后是map和set，再然后是AVL树和红黑树。
从C语言到C++_14(vector的常用函数+相关选择题和OJ题)
参考书籍：《C语言程序设计》《数据结构》《C++ Primer》《Effective C++》《STL源码剖析》《现代操作系统》《UNIX环境高级编程》《图解TCP/IP》《图解HTTP》《Linux高性能服务器编程》《剑指Offer》《算法导论》
05-30 1237
从C语言到C++_14（vector的常用函数+相关选择题和OJ题）LeetCode力扣：136+118+26+137+260+169+17+53。其中用了摩尔投票法和简单的动态规划。
从C语言到C++_31(unordered_set和unordered_map介绍+哈希桶封装)
参考书籍：《C语言程序设计》《数据结构》《C++ Primer》《Effective C++》《STL源码剖析》《现代操作系统》《UNIX环境高级编程》《图解TCP/IP》《图解HTTP》《Linux高性能服务器编程》《剑指Offer》《算法导论》
08-08 638
从C语言到C++_31（unordered_set和unordered_map介绍+哈希桶封装）力扣961+349+217+884+修改哈希表，下一篇：从C语言到C++_32（哈希的应用）位图bitset+布隆过滤器+哈希切割。
C语言oj题答案2017-10-11.rar_C语言_c语言oj题_swust oj第10题_swustoj613答案_西南大学
09-20
《C语言oj题答案2017-10-11》这个压缩包文件主要包含了在西南大学（SWUST）在线判题系统（oj）上完成的C语言编程实验题目解答。C语言作为一门基础且重要的编程语言，是计算机科学教育中的核心课程，尤其对于学习算法...
练习题（含答案）_c++oj答案_c++类oj习题_
09-29
这个压缩包文件"练习题（含答案）_c++oj答案_c++类oj习题_"似乎包含了一系列关于C++类与对象的在线判断题（Online Judge, OJ）解答，这对于学习者来说是一个宝贵的资源，可以帮助他们检验和提升在类和对象方面的理解...
博客园stdc++.h头文件源码
04-26
其他国外的oj，还有台湾的oj都支持，CF，Topcoder也都支持。 当然，其实这是一个偷懒的写法，但是会降低编译速度（为何会降低编译速度，我还不能知道，等到之后学编译原理再来填坑吧）。 笔试平台可以使用，方便，...
C语言 之 理解指针（1）
fallzzzzz的博客
07-20 1238
就是先获取该数组的首元素的地址，从前面我们知道，指针的类型的作用是指针+1 所跳过的字节数，int为整形，大小为4个字节，所以p+1就跳过4个字节，p+2就跳过8个字节，计算机的CPU（中央处理器）在处理数据的时候，需要的数据是在内存中读取的，处理后数据也会放回内存中，如果想对这些空间进行高效的管理，就可以。并且我们知道，数组的元素存放是随着下标增长，内存地址变大的。上面的代码创建了一个整型变量n，因为一个整形的大小是4个字节，所以内存中申请了4个字节，⽤于存放整数10，其中每个字节都有地址。
C++ primer plus 第16章string 类和标准模板库, 关联容器
zhyjhacker的博客
07-25 695
C++ primer plus 第16章string 类和标准模板库, 关联容器。
VS2019编译和使用gtest测试（C++）
m0_65635427的博客
07-24 287
下载下来解压到文件夹，再在文件夹里面新建一个build文件夹，如下：再安装cmake，可以先检查一下是否安装了cmake，打开命令窗口，输入cmake -version：然后双击就对了，我这里已经安装好了，无法提供截图，注意一点就是在让选择是否建立系统环境变量（path）的时候，记得勾上第二个建立系统环境变量！下载好之后，记得检验一下是否安装成功，如果在普通用户下显示没有，建议用管理员身份打开命令窗口，再次尝试。之后命令窗口进入创建的build文件夹路径里面执行cmake ../
【C++修炼之路 第五章】string 类（补充）：string 扩展空间规律 + reserve 的缩容 + resize 的使用
唯有忍受别人不能忍受的，才能享受别人不能享受的
07-23 1147
【详细剖析】string 扩展空间规律 + reserve 的缩容性质与只改变capacity的性质 + resize 的使用 + shink_to_fit 的缩容函数
Windows图形界面(GUI)-MFC-C/C++ - Dialog
最新发布
0xCC说逆向
07-25 1022
流程打开资源视图：在Visual Studio中，右键点击资源文件夹（通常是），选择“添加” -> “资源”。添加对话框资源：在弹出的对话框中选择“Dialog”，然后点击“新建”。设计对话框：在资源编辑器中，你可以拖放控件到对话框上，如按钮、文本框、列表框等。拓展资源ID：每个对话框都有一个唯一的资源ID，用于在代码中引用。对话框编辑器：用于可视化地设计和布局对话框。
【C++初阶】string类
2301_78022459的博客
07-24 891
【C++初阶】string类
学懂C语言（二十一）：深入理解C语言中的函数指针和回调函数
martian665的专栏
07-23 591
学懂C语言：C语言中的函数指针和回调函数详解
C++(week14): C++提高:(一)面向对象设计：设计原则、设计模式
Edward2022的博客
07-25 789
类与类之间的五种关系、面向对象的七种设计原则、23种设计模式
如何在C\#中创建HTML表格
程序员-张师傅
07-24 354
在C#中创建HTML表格通常不是直接由C#语言本身完成的，因为C#是一种面向对象的编程语言，主要用于后端逻辑处理。然而，在Web开发中，你可能会在C#代码（如在ASP.NET MVC、ASP.NET Core MVC或Razor Pages应用程序中）中生成HTML表格的字符串，或者更常见的是，使用Razor视图引擎来动态生成HTML表格。
C语言实用函数集锦：50+代码示例
"大一C语言实用函数整理50+" 这份资料主要针对初学者，提供了C语言编程中常见的函数及其应用，涵盖了基础到进阶的各种功能。以下是一些关键知识点的详细说明： 1. **转义符**：在C语言中，转义字符用于表示特殊的...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

GR鲸鱼

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值