单调栈的应用 Largest Rectangle in Histogram，Max Tree，expression tree, 表达式求值,

单调栈的应用场景：求一侧或两侧比当前元素小（大）的最近的元素。

例题：一个数组，对于每个元素，输出左边第一个比它小的元素

暴力解法：对于每个元素，往前查看，直到遇到比自己小的，O(n^2）

单调栈：维护一个递增栈，满足递增的时候（比栈顶元素大），上一个元素（栈顶元素）就是所求，当新元素不满足递增（比栈顶小），退栈，直到栈顶比当前元素小，输出，然后再把当前元素入栈。每个元素最多入栈一次出栈一次，O(n)

Largest Rectangle in Histogram

枚举每个柱子的高度，计算以这个高度为高的最长的矩形的面积，做法就是以这个高度往两边延伸，碰到比它低的柱子就截止了，所以就是求两边第一个比当前元素小的元素的位置，这样就得到了矩形的长度。

int largestRectangleArea(vector<int> &height) {
	stack<int> s;
	int maxArea = 0;
	height.push_back(0);
	for(int i = 0; i < height.size(); ++i) {		
		while (!s.empty() && height[i] < height[s.top()]){
			int h = height[s.top()]; s.pop();
			int left = s.empty() ? -1 : s.top();
			maxArea = max(maxArea, h * (i - left - 1));
		}
		s.push(i);
	}
	return maxArea;
}

Max Tree

直接的解法是找最大值，得到根，然后两边递归解决，T(n)= n+2T(n/2)  = O(nlgn)

树的问题较优的解法一般考虑自底向上，（类似有序链表构造BST问题），规律是：只要确定一个元素比两边的元素小，则两边小的那个就是当前元素的父结点，在父节点的左边就是左孩子，右边就是右孩子。

TreeNode* maxTree(vector<int> A) {
	stack<TreeNode*> s;
	A.push_back(INT_MAX);
	for (int &x : A) {
		TreeNode *p = nullptr, *q = new TreeNode(x);
		while (!s.empty() && s.top()->val <= x) {
			s.top()->right = p;
			p = s.top(); s.pop();
		}
		q->left = p;
		s.push(q);
	}
	return s.top()->left;
}

 Expression Tree

def build(self, expression):
    op, oprand = [], [None]
    for token in expression + ['#']:
        if token.isdigit(): oprand.append(ExpressionTreeNode(token))
        else:
            while len(op) > 0 and op[-1] != '(' and token != '(' and (token in '+-)#' or op[-1] in '*/'):
                node = ExpressionTreeNode(op.pop())
                node.right = oprand.pop();
                node.left = oprand.pop();
                oprand.append(node);
            if token == ')': op.pop()
            else: op.append(token)
    return oprand[-1]

表达式求值

算法主要参与者：

1）操作符函数映射表

2）操作数栈operand，操作符栈op

3）token stream (可以先用操作符split，也可以实时tokenize)

算法框架：token 流加一个结束符#，依次取token：

1）如果token是操作数，atoi, 入operand栈

2）token是操作符，while token优先级比op栈顶元素低，则取op栈顶操作符做运算，相应的操作数是operand栈的最近的两个数

对于括号，可以看作是一种分界，左括号可以看作是一个新的op栈的栈底， 右括号可以看作是括号内表达式的结束符。

def evaluateExpression(self, expression):
	m = {'+' : lambda a, b : a + b, '-' : lambda a, b : a - b, '*' : lambda a, b : a * b, '/' : lambda a, b : a / b}
	op, oprand = [], [0]
	for token in expression + ['#']:
		if token.isdigit(): oprand.append(int(token))
		else:
			while len(op) > 0 and token != '(' and op[-1] != '(' and  (token in '#)+-' or op[-1] in '*/'):
				b = oprand.pop();
				oprand[-1] = m[op.pop()](oprand[-1], b)
			if token == ')': op.pop()
			else: op.append(token)
	return oprand[-1]

单调栈问题可以总结个模式

1）给输入序列append一个终止元素，一般就是和单调性相反的极值，如果是递减栈，append一个最大值，如果是递增栈，append一个最小值。

2）模板

int monotonousStackProblem(vector<int> &A) {
	stack s;
	A.push(终结元素) // 原序列append一个终结元素
	//other states /variables
	for(int i = 0; i < A.size(); ++i) {		
		while (!s.empty() && A[i]和栈顶元素比较不满足单调性质){
			x = s.top();s.pop();
			做一些计算，update states/variables
		}
		s.push(A[i] or i);
	}
	return result //往往和栈里最后剩下的元素stack.top()有关;
}