每日的温度

Posted 2021-02-28 shwzh1990

描述

根据每日 气温列表，请重新生成一个列表，对应位置的输入是你需要再等待多久温度才会升高超过该日的天数。如果之后都不会升高，请在该位置用 0来代替。

例如，给定一个列表 temperatures = [73, 74, 75, 71, 69, 72, 76, 73]，你的输出应该是 [1, 1, 4, 2, 1, 1, 0, 0]。

提示：气温 列表长度的范围是 [1, 30000]。每个气温的值的均为华氏度，都是在[30, 100] 范围内的整数。

来源：力扣（LeetCode）

 

 

这道题不能用暴力方式解决 因为第35个题目会卡住， 大神用的是单调栈的方式

所谓的单调栈指的是  https://www.bilibili.com/video/av66395810/

即

• 单调栈里的元素具有单调性
• 元素加入栈前，会在栈顶端把破坏栈单调性的元素都删除
• 使用单调栈可以找到元素向左遍历第一个比他小的元素，也可以找到元素向左遍历第一个比他大的元素
  • 当单调栈中的元素是单调递增的时候，根据上面我们从数组的角度阐述单调栈的性质的叙述，可以得出：
    • 当a > b 时，则将元素a插入栈顶，新的栈顶则为a
    • 当a < b 时，则将从当前栈顶位置向前查找（边查找，栈顶元素边出栈），停止查找，将元素a插入栈顶（在当前找到的数之后，即此时元素a找到了自己的“位置”）

 

#define OK 0
#define NULL 0

typedef int DataType;
typedef struct node{
    DataType data;
    struct node * next;
}Stack;

//创建栈，此时栈中没有任何元素
Stack* CreateStack()
{
    Stack *stack = (Stack*)malloc(sizeof(Stack));
    if(NULL != stack)
    {
       stack->next = NULL;
       return stack;
    }
    return NULL;
}

//撤销栈
void DestoryStack(Stack* stack)
{
    free(stack);
}
 
int IsEmpty(Stack* stack)
{
    return (stack->next == 0);
}
 
//入栈，成功返回1，失败返回0， 把元素 data 存入 栈 stack 中
int PushStack(Stack* stack, DataType data)
{
    Stack* newst = (Stack*)malloc(sizeof(Stack));
    if(NULL != newst)
    {
        newst->data = data;
        newst->next = stack->next;  //s->next = NULL;
        stack->next = newst;
        return 1;
    }
    return 0;
}
 
/*
    出栈，成功返回1，失败返回0，出栈不取出元素值，只是删除栈顶元素。
    如出栈要实现，取出元素值，并释放空间，可结合取栈顶元素函数做修改，这里不再给出。
 */
 
int PopStack(Stack* stack)
{
    Stack* tmpst;
    if(!IsEmpty(stack))
    {
        tmpst = stack->next;
        stack->next = tmpst->next;
        free(tmpst);
        return 1;
    }
    return 0;
}

int PopStackReturn(Stack* stack, DataType *data)
{
    Stack* tmpst;
    if(!IsEmpty(stack))
    {
        tmpst = stack->next;
        stack->next = tmpst->next;
        *data = tmpst->data;
        free(tmpst);
        return 1;
    }
    return 0;
}
 
//取栈顶元素，仅取出栈顶元素的值，取出之后，该元素，任然存在栈中。成功返回元素值，失败输出提示信息，并返回 -1
DataType GetTopElement(Stack* stack)
{
    if(!IsEmpty(stack))
    {
        return stack->next->data;
    }
    return -1;
}


int* dailyTemperatures(int* T, int TSize, int* returnSize) 
{
    int i;
    int temp;
    int topData;
    int ret;
    int *NewT = malloc(TSize * sizeof(int));
    if (NewT == NULL) 
    {
        printf("malloc fail");
        return NULL;
    }
    memset(NewT, 0, TSize * sizeof(int));

    Stack* stack = CreateStack();
    if (stack == NULL) 
    {
        printf("CreateStack fail");
        return NULL;
    }
    for (i = 0; i < TSize; i++) 
    {
        while (!IsEmpty(stack) && (T[i] > T[GetTopElement(stack)])) 
        {
            temp = GetTopElement(stack);
            NewT[temp] = i - temp;
            PopStack(stack);
        }
        PushStack(stack, i);
    }
    
    DestoryStack(stack);
    *returnSize = TSize;
    return NewT;
}

本题的解题思路在于：

首先把请看

  while (!IsEmpty(stack) && (T[i] > T[GetTopElement(stack)])) 
如果我们的遇到的元素大于栈顶的元素则把栈顶的元素弹出来，最后把新的最大的值放进去，然后每次小于这个元素的值会放进去，那么我们每次只是遍历了一次最大的值而不重复。

 主要的问题是什么时候用单调栈 这个还是由于编程太少的原因造成的。