【算法系列】单调栈

首先来一个例题739. 每日温度 - 力扣（LeetCode）

题意理解：给定了一个数组，找到每个元素右边出现的第一个比它大的元素的下标，两者下标相减记录下来，如果该元素右边没有比它大的元素，则记为0

解法1：暴力解法

首先很自然的会想到暴力解法，找每一个元素的右边第一个比它大的元素，第一层for循环遍历数组，固定需要找到哪一个元素的右边第一个更大数，第二层for循环根据第一层固定的元素向后遍历数组，找到该元素的右边第一个更大数。

class Solution {
public:
    vector<int> dailyTemperatures(vector<int>& temperatures) {
        vector<int> ret(temperatures.size());
        for(int i = 0; i < temperatures.size(); i++)
        {
            int j = i + 1;
            for(; j < temperatures.size(); j++)
            {
                if(temperatures[j] > temperatures[i])
                {
                    ret[i] = j - i;
                    break;
                }
            }
            if(j == temperatures.size()) ret[i] = 0;
        }

        return ret;
    }
};

超时警告！！！

 解法1的时间复杂度是多少？3 2 1...... 是O(N^2)！

如何优化呢？？？先再观察一下，看看有没有什么特别的地方没有发现......

如上图，我们专注于71和69两个数字，如果采用解法1,我们会发现，相同的遍历我们重复走了两次，有必要吗？？我们想一想71大于69，在找到71右边比它大的第一个元素时，我们是不是就已经找到了69的右边第一更大元素，可能与71同时找到，也可能比它先找到，就是不可能比它后找到。这就说明其实没有必要把71和69分开两次找，它们俩可以一起并行找。

我们来假想一下，首先我们先遇到了71这个数，往后遍历找71右边第一个更大元素时遇到69，71看69比自己小，71心想既然比我小，那指不定比我还要先找到，或者说咱俩要找的是同一个，那要不就一起往右边找，后来找到了一个比69大的数，那好69完成任务，拿到结果就走了，这时71说我看看这数比我大不(隐含着循环比较)，比我大我也完成任务可以走了，比我小我就还得往右找......

你看这69明明是后来的，却先完成任务先走一步了，而71先来的却还没69溜得快，这啥数据结构啊，这就是栈啊！！

正式进入解法2：单调栈

首先我们需要明确，在一个元素X往右寻找第一个比自己更大的数时，可能遇到的数有以下三种情况：

1. 遇到的元素比X大，那太幸运了，完成任务收工！
2. 遇到的元素和X一样大，那这位兄台和我要找的是同一个元素啊，X说目标一样不如结伴同行
3. 遇到的元素比X小，那X心想这位小兄弟要么和我要找的是同一个，要么就比我先一步完成任务，也是可以同行一段路的

通过以上的铺垫，模拟大法启动！！！将尚未完成任务的元素入栈：

上图的模拟并没有模拟到最后，但是足够理解了，栈里面放的都是未完成任务的元素，并且你会发现，栈从左到右一直是单调递增的(严格来讲应该是非递减，因为可能有相同元素) ，那这就是单调栈喏。整个数组遍历完后，依然在栈里的元素，就永远都不可能完成任务啦，只能计0了。(遍历完数组后栈可能不为空哦)

 代码实现：

class Solution {
public:
    vector<int> dailyTemperatures(vector<int>& temperatures) {
        vector<int> ret(temperatures.size());
        stack<int> st;
        // 遍历数组
        for(int i = 0; i < temperatures.size(); i++)
        {
            // 如果栈为空 就直接入栈 注意：入栈的是下标哦 为了好计算天数
            if(st.empty()) st.push(i);
            else
            {
                // 如果比栈顶元素小或者等于栈顶元素 就入栈 一起同行吧
                if(temperatures[i] <= temperatures[st.top()]) st.push(i);
                else
                {
                    // 出现目标元素 完成任务出栈 并看看之前入栈的元素有没有也一起完成任务出栈的
                    while(!st.empty() && temperatures[i] > temperatures[st.top()])
                    {
                        ret[st.top()] = i - st.top();
                        st.pop();
                    }
                    st.push(i);
                }
            }
        }
        // 看看哪些元素完不成任务(没有右边第一个更大元素)
        while(!st.empty())
        {
            ret[st.top()] = 0;
            st.pop();
        }
        return ret;
    }
};

解法二单调栈的时间复杂度？？？ 3 2 1.....是O(N)！！！ 

举一反三

1. 找某个元素左边第一个比它大的元素（从右至左）
2. 找某个元素右边第一个比它小的元素（从左至右）
3. 找某个元素左边第一个比它小的元素 （从右至左） 

附上代码：

class Solution
{
public:
	// 找左边第一个更大的数
	static vector<int> dailyTemperatures(vector<int>& temperatures)
	{
		vector<int> ret(temperatures.size());
		stack<int> st;
		for (int i = temperatures.size() - 1; i >= 0; i--)
		{
			if (st.empty()) st.push(i);
			else
			{
				if (temperatures[i] <= temperatures[st.top()]) st.push(i);
				else
				{
					while (!st.empty() && temperatures[i] > temperatures[st.top()])
					{
						ret[st.top()] = i; // 记录左边第一个更大数的下标
						st.pop();
					}
					st.push(i);
				}
			}
		}
		while (!st.empty())
		{
			ret[st.top()] = -1;
			st.pop();
		}

		return ret;
	}
};

class Solution
{
public:
	// 找右边第一个更小的数
	static vector<int> dailyTemperatures(vector<int>& temperatures)
	{
		vector<int> ret(temperatures.size());
		stack<int> st;
		for (int i = 0; i < temperatures.size(); i++)
		{
			if (st.empty()) st.push(i);
			else
			{
				if (temperatures[i] >= temperatures[st.top()]) st.push(i);
				else
				{
					while (!st.empty() && temperatures[i] < temperatures[st.top()])
					{
						ret[st.top()] = i; // 记录右边第一个更小数的下标
						st.pop();
					}
					st.push(i);
				}
			}
		}
		while (!st.empty())
		{
			ret[st.top()] = -1;
			st.pop();
		}

		return ret;
	}
};

class Solution
{
public:
	// 找左边第一个更小的数
	static vector<int> dailyTemperatures(vector<int>& temperatures)
	{
		vector<int> ret(temperatures.size());
		stack<int> st;
		for (int i = temperatures.size() - 1; i >= 0; i--)
		{
			if (st.empty()) st.push(i);
			else
			{
				if (temperatures[i] >= temperatures[st.top()]) st.push(i);
				else
				{
					while (!st.empty() && temperatures[i] < temperatures[st.top()])
					{
						ret[st.top()] = i; // 记录左边第一个更小数的下标
						st.pop();
					}
					st.push(i);
				}
			}
		}
		while (!st.empty())
		{
			ret[st.top()] = -1;
			st.pop();
		}

		return ret;
	}
};

以上三个案列，读者朋友们可以自己动手试一试 ：）

其余题目

496. 下一个更大元素 I - 力扣（LeetCode）

503. 下一个更大元素 II - 力扣（LeetCode）

 总结

单调栈适合用于找某一组元素中，每个元素的右边/左边第一个更大/更小的元素。