力扣739 每日温度 单调栈的理解

给定一个整数数组 temperatures ，表示每天的温度，返回一个数组 answer ，其中 answer[i] 是指对于第 i 天，下一个更高温度出现在几天后。如果气温在这之后都不会升高，请在该位置用 0 来代替。

示例 1:

输入: temperatures = [73,74,75,71,69,72,76,73]
输出: [1,1,4,2,1,1,0,0]
示例 2:

输入: temperatures = [30,40,50,60]
输出: [1,1,1,0]
示例 3:

输入: temperatures = [30,60,90]
输出: [1,1,0]

提示：

1 <= temperatures.length <= 105
30 <= temperatures[i] <= 100

暴力解法（超时了）

/**
 * Note: The returned array must be malloced, assume caller calls free().
 */
int* dailyTemperatures(int* temperatures, int temperaturesSize, int* returnSize) {
  
    int i = 0;
    int j = 0;
    int *out = NULL;

    out = (int *)malloc(temperaturesSize * sizeof(int));

    *returnSize = temperaturesSize;

    for(i=0; i<temperaturesSize; i++)
    {
        for(j=i+1; j<temperaturesSize; j++)
        {
            if(temperatures[j]>temperatures[i])
            {
                out[i] = j-i;
                break;
            }
        }
        if(j==temperaturesSize)
        {
             out[i] = 0;
        }
    }

    return out;
}

单调栈：（理解上有点费解）

1、这个栈记录的是下标。它的意义是记录前面操作完后的状况，此刻的操作要考虑这个状况；

2、确定什么时候入栈，什么时候出栈，以及出栈要做啥；

3、看以下代码屏蔽的部分，细节上很容易出错；

4、明确top始终是指向下一个要存数据的位置，所以栈顶起始是top-1

实例说明：这个栈记录的是之前最大的元素下标。

例如 temperatures = [73,74,75,71,69,72,76,73]  思考一下全部元素都一样：都是75，会怎样

现在记录到75，下标2，入栈；

下一个71，没有75大，下标3，入栈；

下一个69，没有71大，下标4，入栈；

下一个72，

比69大，栈顶的要出栈，表示已经找到了比栈顶要大的数，他们相距=当前处理下标-栈顶下标；

由于69出栈，现在栈顶是71了，仍然比栈顶大，栈顶出栈，

71出栈，栈顶是75了，把72入栈；

流程：

第一步：i=0把第一个元素入栈：stack[top] = i；top++;

第二步：拿当前元素temperatures [i]，i=1，与栈顶元素temperatures [stack[top-1]]比较：

（1）当前元素更大，栈顶出栈（并且栈顶对应的下标，出结果了，因为当前的值栈顶代表的值大）top--，

        继续当前元素与更新后的栈顶代表值比较：

        当前元素更大的话，栈顶出栈（并且栈顶对应的下标，出结果了，因为当前的值栈顶代表的值大）top--，

        直到当前元素比栈顶小，或者栈空了，把当前元素入栈；

（2）当前元素小，当前元素的下标入栈，入栈后top++；考虑下一个下标i++；

（3）相等，当前元素入栈，入栈后top++；考虑下一个下标i++；

第三步：

最后剩下的栈里面的元素（他是数组下标）都是没有找到比它大的元素，依次出栈并且赋值为0；

int* dailyTemperatures(int* temperatures, int temperaturesSize, int* returnSize) {
    
    int *out = NULL;
    int *stack = NULL;
    int top = 0;
    int i = 0;
    int flag = 1;

    out = (int *)malloc(temperaturesSize * sizeof(int));
    stack = (int *)malloc(temperaturesSize * sizeof(int));
    (*returnSize) = temperaturesSize;

    memset(stack,-1,temperaturesSize);
    //memset(out,0,temperaturesSize);//没起作用
   //memset(out,0,sizeof(out));//没起作用 
    memset(out,0,sizeof(int)*temperaturesSize);//有用

    // for(i = 0; i < temperaturesSize; i++){  //有用
    //     out[i] = 0;
    // }

    for(i=0; i<temperaturesSize; i++)
    {
        flag = 1;

        if(i == 0)
        {
            stack[top] = i;
            top++;
        }
        else
        {
            //if(temperatures[i]>temperatures[stack[top-1]])//找到比栈顶大的元素要出栈
            {
               // while((temperatures[i]>temperatures[stack[top-1]]) && (top>0) )//报错堆栈溢出
                while((top>0) &&(temperatures[i]>temperatures[stack[top-1]]) )
                {
                    out[stack[top-1]] = i - stack[top-1];
                    top--;
                }
            }
            if(flag == 1)
            {
                stack[top] = i;
                top++;
            }
        }
    }

    //整体把站内的元素出栈 并得出结果 剩下栈里面是没找到比他们大的
    // while(top>0)
    // {
    //     out[stack[top-1]] = 0;
    //     top--;
    // }


    return out;
}