155. 最小栈
设计一个支持 push，pop，top 操作，并能在常数时间内检索到最小元素的栈。
push(x) -- 将元素 x 推入栈中。
pop() -- 删除栈顶的元素。
top() -- 获取栈顶元素。
getMin() -- 检索栈中的最小元素。
示例:
MinStack minStack = new MinStack();
minStack.push(-2);
minStack.push(0);
minStack.push(-3);
minStack.getMin(); --> 返回 -3.
minStack.pop();
minStack.top(); --> 返回 0.
minStack.getMin(); --> 返回 -2.
思路一：
解法1：用两个栈实现最小栈功能
一个栈s存放数据，另一个栈min存放前栈中最小的数据
class MinStack {
public:
stack<int> s;//数据栈
stack<int> min;//辅助栈
/** initialize your data structure here. */
MinStack() {
}
void push(int x) {
s.push(x);
if(min.empty()||x<=min.top())
{
min.push(x);
}
}
void pop() {
if(s.top()==min.top())
min.pop();
s.pop();
}
int top() {
return s.top();
}
int getMin() {
return min.top();
}
};
解法2：一个栈实现
栈中两个数据位合成一个单元，第一个数据位存放当前数据到末尾的最小值，第二个数据位存放当前数据
class MinStack {
public:
/** initialize your data structure here. */
stack<int> s;
MinStack() {
}
void push(int x) {
if(s.empty())
{
s.push(x);
s.push(x);
}
else
{
int temp=s.top();
s.push(x);
if(x<temp)
{
s.push(x);
}
else
{
s.push(temp);
}
}
}
void pop() {
s.pop();
s.pop();
}
int top() {
int temp=s.top();
s.pop();
int top=s.top();
s.push(temp);
return top;
}
int getMin() {
return s.top();
}
};
作者：chenlele
链接：https://leetcode-cn.com/problems/min-stack/solution/zui-xiao-zhan-by-gpe3dbjds1/
来源：力扣（LeetCode）
著作权归作者所有。商业转载请联系作者获得授权，非商业转载请注明出处。
我的：
class MinStack {
public:
stack<int> s;//数据栈
stack<int> min;//辅助栈
/** initialize your data structure here. */
MinStack() {
}
void push(int x)
{
s.push(x);
if(min.empty()||x <= min.top())
{
min.push(x);
}
}
void pop()
{
if(s.top() == min.top())
{
min.pop();
}
s.pop();
}
int top() {
return s.top();
}
int getMin() {
return min.top();
}
};
/**
* Your MinStack object will be instantiated and called as such:
* MinStack* obj = new MinStack();
* obj->push(x);
* obj->pop();
* int param_3 = obj->top();
* int param_4 = obj->getMin();
*/
94. 二叉树的中序遍历
给定一个二叉树，返回它的中序遍历。
示例:
进阶:递归算法很简单，你可以通过迭代算法完成吗？
思路一：二叉树的中序遍历 - 迭代法
解题思路：
• 前序遍历迭代算法
• 后序遍历迭代算法
o 第一种方法
o 第二种方法
• 中序遍历迭代算法
前序遍历迭代算法：
二叉树的前序遍历
二叉树的遍历，整体上看都是好理解的。
三种遍历的迭代写法中，数前序遍历最容易理解。
递归思路：先树根，然后左子树，然后右子树。每棵子树递归。
在迭代算法中，思路演变成，每到一个节点 A，就应该立即访问它。
因为，每棵子树都先访问其根节点。对节点的左右子树来说，也一定是先访问根。
在 A 的两棵子树中，遍历完左子树后，再遍历右子树。
因此，在访问完根节点后，遍历左子树前，要将右子树压入栈。
思路：
代码：
后序遍历迭代算法：
二叉树的后序遍历
有两种方法。第一种比第二种要容易理解，但多了个结果逆序的过程。
第一种方法：
我们可以用与前序遍历相似的方法完成后序遍历。
后序遍历与前序遍历相对称。
思路： 每到一个节点 A，就应该立即访问它。 然后将左子树压入栈，再次遍历右子树。
遍历完整棵树后，结果序列逆序即可。
思路：
代码：
第二种方法：
按照左子树-根-右子树的方式，将其转换成迭代方式。
思路：每到一个节点 A，因为根要最后访问，将其入栈。然后遍历左子树，遍历右子树，最后返回到 A。
但是出现一个问题，无法区分是从左子树返回，还是从右子树返回。
因此，给 A 节点附加一个标记T。在访问其右子树前，T 置为 True。之后子树返回时，当 T 为 True表示从右子树返回，否则从左子树返回。
当 T 为 false 时，表示 A 的左子树遍历完，还要访问右子树。
同时，当 T 为 True 时，表示 A 的两棵子树都遍历过了，要访问 A 了。并且在 A 访问完后，A 这棵子树都访问完成了。
思路：
代码：
中序遍历迭代算法:
二叉树的中序遍历
思路：每到一个节点 A，因为根的访问在中间，将 A 入栈。然后遍历左子树，接着访问 A，最后遍历右子树。
在访问完 A 后，A 就可以出栈了。因为 A 和其左子树都已经访问完成。
思路：
代码：
作者：jason-2
链接：https://leetcode-cn.com/problems/binary-tree-inorder-traversal/solution/die-dai-fa-by-jason-2/
来源：力扣（LeetCode）
著作权归作者所有。商业转载请联系作者获得授权，非商业转载请注明出处。
我的：
class Solution {
public:
vector<int> inorderTraversal(TreeNode* root)
{
stack<TreeNode*> S;
vector<int> v;
TreeNode* rt = root;
while(rt || S.size()){
while(rt){
S.push(rt);
rt=rt->left;
}
rt=S.top();S.pop();
v.push_back(rt->val);
rt=rt->right;
}
return v;
}
};
