周记——单调栈

栈的基本概念

1.栈是一种后进先出（LIFO）的数据结构。
2.对于栈来说，表尾端称为栈顶（top），表头端称为栈低（bottom）。
3.所有元素只能从栈顶进入，进入栈的操作称为入栈（压栈）。
4.同时所有元素只能从栈顶弹出，弹出栈的操作称为出栈（弹栈）。
5.因为只能对栈顶元素进行操作，因此不支持对栈内元素进行随机访问，即我们不能在任意位置访问栈内元素，只能从栈顶访问。
 

单调栈的定义

单调栈是一种特殊的栈，单调栈要求栈中的元素是单调递增的或者单调递减的。

单调栈具有单调性，我们可以先让栈底的值为0或者为负数，只判断要进栈的数是否大于栈顶的数，大于就入栈，否则把栈顶出栈直到栈空或者要进栈的数大于栈顶。

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

适用问题：单调栈分为单调递增栈和单调递减栈，通过使用单调栈我们可以访问到下一个比他大（小）的元素（或者说可以）。也就是说在队列或数组中，我们需要通过比较前后元素的大小关系来解决问题时我们通常使用单调栈。

1.返回数组当前下标以后比当前下标元素大（小）的所有元素。
2.返回数组当前下标元素前后第一个比其大（小）的元素及其下标。 

(给定一个序列求序列中的每个元素的离它右(左)边最近且比这个数大(小)的数。)
3.寻找数组中的极大值（极小值）及其所在下标。                                                                            

例题：链表中下一个更大结点

给定一个长度为 n 的链表 head。对于列表中的每个节点，查找下一个 更大节点 的值。也就是说，对于每个节点，找到它旁边的第一个节点的值，这个节点的值 严格大于 它的值。

返回一个整数数组 answer ，其中 answer[i] 是第 i 个节点( 从1开始 )的下一个更大的节点的值。如果第 i 个节点没有下一个更大的节点，设置 answer[i] = 0 。

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     struct ListNode *next;
 * };
 */


/**
 * Note: The returned array must be malloced, assume caller calls free().
 */



int* nextLargerNodes(struct ListNode* head, int* returnSize){
   
   struct ListNode*p = head;
   int l = 1,i = 0;
   while(p -> next){
       p = p -> next;
       l++;
   }

   int *res = (int *)malloc(sizeof(int)*l);

    while(head){
    p = head;
     while(p && p -> val <= head -> val){
         p = p -> next;
     }
     res[i] = p ? p -> val : 0;
     i++;
     head = head -> next;
    }
    *returnSize = l;
    return res;


}

 注：这个代码是暴力解法，先遍历链表求出表长后分配内存，然后用两个while循环算出每个结点的answer值，耗时很长。

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     struct ListNode *next;
 * };
 */


/**
 * Note: The returned array must be malloced, assume caller calls free().
 */
int* nextLargerNodes(struct ListNode* head, int* returnSize){
    int len=0;
    *returnSize=0;
    struct ListNode* p=head;
    while(p)//获取链表长度
    {
       p=p->next;
        len++;
    }
    if(len==0)
        return NULL;
    int stk[len];
    int temp[len];//临时数组，存放链表值
    int top=-1;
    int* res=(int*)calloc(sizeof(int),len);
    while(head)
    {
        temp[(*returnSize)++]=head->val;
        head=head->next;
    }
    for(int i=0;i<len;i++)
    {
        while(top!=-1&&temp[stk[top]]<temp[i])
        {                                    
            res[stk[top]]=temp[i];
            top--;
        }
        stk[++top]=i;
    }
    res[len-1]=0;
    return res;
}

 

单调栈的伪代码

for (遍历这个数组)
{
	if (栈空 || 栈顶元素大于等于当前比较元素)
	{
		入栈;
	}
	else
	{
		while (栈不为空 && 栈顶元素小于当前元素)
		{
			栈顶元素出栈;
			更新结果;
		}
		当前数据入栈;
	}
}