1.6 LeetCode总结（线性表）_单调栈类

编程总结

每每刷完一道题后，其思想和精妙之处没有地方记录，本篇博客用以记录刷题过程中的遇到的算法和技巧
这类型的题目有一定的套路模板，需要持续刷，熟练掌握模板，详见单调递增栈的伪代码。
本文基础讲解部分，参考如下链接，基础知识需要了解清楚，才会写代码
参考链接1：https://blog.csdn.net/lucky52529/article/details/89155694
参考链接2：https://www.bilibili.com/video/BV1my4y1Z7jj/?spm_id_from=333.788&vd_source=69b69aec9479090b82c45d4b18beb481

单调栈的作用：找其左\右第一个比它大\小的元素, 记录之前遍历过的元素(top)

什么是单调栈？

从名字上就听的出来，单调栈中存放的数据应该是有序的，所以单调栈也分为单调递增栈和单调递减栈

单调递增栈：单调递增栈就是从栈底到栈顶数据是从大到小
单调递减栈：单调递减栈就是从栈底到栈顶数据是从小到大

举例：
现在有一组数10，3，7，4，12。

从左到右依次入栈，则如果栈为空或入栈元素值小于栈顶元素值，则入栈；否则，如果入栈则会破坏栈的单调性，则需要把比入栈元素小的元素全部出栈。单调递减的栈反之。

1）10入栈时，栈为空，直接入栈，栈内元素为10
2）3入栈时， 栈顶元素10比3大，则入栈，栈内元素为10，3
3）7入栈时， 栈顶元素3比7小，则栈顶元素出栈，此时栈顶元素为10，比7大，则7入栈，栈内元素为10，7
4）4入栈时， 栈顶元素7比4大，则入栈，栈内元素为10，7，4
5）12入栈时，栈顶元素4比12小，4出栈，此时栈顶元素为7，仍比12小，栈顶元素7继续出栈，此时栈顶元素为10，仍比12小，10出栈， 此时栈为空，12入栈，栈内元素为12。

单调递增栈的伪代码

int stack[size];
//此处一般需要给数组最后添加结束标志符，具体下面例题会有详细讲解
for (遍历这个数组)
{
	if (栈空 || 栈顶元素大于等于当前比较元素)
	{
		入栈;
	} else
	{
		while (栈不为空 && 栈顶元素小于当前元素)
		{
			栈顶元素出栈;
			更新结果;
		}
		当前数据入栈;
	}
}

739. 每日温度

示例 1:
输入: temperatures = [73, 74, 75, 71, 69, 72, 76, 73]
输出: output = [1, 1, 4, 2, 1, 1, 0, 0]
index = [0, 1, 2, 3, 4, 5, 6, 7]

下面的方法与伪代码提供的框架一致, stack数组是用来记录下标的, temperatures[stack[top]] 为值
这里的 stack 是用来记录遍历过的元素的下标，因为题目是求下一个更高温度出现在几天后，是坐标相减

// 递增栈，栈顶最小，栈底最大
int *dailyTemperatures(int *temperatures, int temperaturesSize, int *returnSize)
{
	int n = temperaturesSize;
	int *res   = (int *)malloc(sizeof(int) * n);
	int *stack = (int *)malloc(sizeof(int) * n); // stack数组记录下标, temperatures[stack[top]]为值
	int top    = -1;
	int index;

	memset(res,   0 , sizeof(int) * n);
	memset(stack, 0,  sizeof(int) * n);
	*returnSize = n;
	for (int i = 0; i < n; i++) {
		// 当前元素小于等于栈顶元素，则入栈
		if ((top == -1) || (temperatures[i] <= temperatures[stack[top]])) {
			stack[++top] = i;
		}
		else {
			// 当前元素大于栈顶元素大，则找到了答案计算其下标
			while (top >= 0 && temperatures[i] > temperatures[stack[top]]) {
				index = stack[top];
				res[index] = i - index; // 结果数组
				top--; // 出栈
			}
			stack[++top] = i; // 这一步很重要，更新当前的栈顶
		}
	}
	for (int i = 0; i < n; i++) {
		printf("stack[%d]=%d, res[%d]=%d\n", i, stack[i], i, res[i]);
	}

	return res;
}

496. 下一个更大元素 I

当前这两个题都是单调栈的递增，手法类似，处理类似

#define NUM_SIZE 10001
void GetNext(int *num, int size, int *res)
{
	int top = -1;
	int *stack = (int *)malloc(sizeof(int) * size);
	memset(stack, 0 ,sizeof(int) * size);

	for (int i = 0; i < size; i++) {
		if ((top == -1) || (num[i] <= stack[top])) {
			stack[++top] = num[i];
		}
		else {
			while ((top >= 0) && (num[i] > stack[top])) { // 如果此时比较元素大于栈顶元素，则栈顶元素出栈.
				res[stack[top]] = num[i];                 // 将找到的元素作为map存下来.
				top--;
			}
			stack[++top] = num[i];
		}
	}
	// 处理此时还未出栈的元素，都是不存在下一个更大元素的，赋值为-1。
	while (top >= 0) {
		res[stack[top]] = -1;
		top--;
	}
	for (int i = 0; i < size; i++) {
		printf("stack[%d] = %d\n", i, stack[i]);
	}
	for (int i = 0; i < size; i++) {
		printf("res[%d] = %d\n", i, res[i]);
	}

	free(stack);
}

int *nextGreaterElement(int *nums1, int nums1Size, int *nums2, int nums2Size, int *returnSize)
{
	int *ret = (int *)malloc(sizeof(int) * nums1Size);
	int *res = (int *)malloc(sizeof(int) * NUM_SIZE);  // hash map
	memset(ret, 0, sizeof(int) * nums1Size);
	memset(res, 0, sizeof(int) * NUM_SIZE);

	// 1. nums2求解右边第一个更大的元素.
	GetNext(nums2, nums2Size, res);

	// 2. nums1作为查询的行为，查找hash_map即可. 
	for (int i = 0; i < nums1Size; i++) {
		ret[i] = res[nums1[i]];
	}
	*returnSize = nums1Size;
	free(res);
	return ret;
}