快速掌握面试常考的单调栈基础

Shawxing精讲算法

已于 2024-06-30 21:17:34 修改

阅读量738

点赞数 19

文章标签：面试算法 leetcode

于 2024-06-09 11:04:53 首次发布

本文链接：https://blog.csdn.net/qq_64892278/article/details/139558944

版权

前言

在单调栈基础题中，经常需要类似这种的解题思路：在 $O (n)$ 的时间复杂度内求出数组中各个元素右侧第一个更大的元素及其下标，然后一并得到其他信息。

在进阶题中，主要考察借助单调栈的模拟。

本篇主要围绕基础部分讲解，读者掌握后基本能应对非高级岗位面试中的单调栈部分（如果出现的话）。

原理

在这里插入图片描述

过程模拟结束，所得结果如下。

这样 arr[0] 右侧第一个更大的元素为 arr[4]。根据 0 4 arr[0] arr[4] 能组成很多信息。

对于 arr[1], arr[2] … 以此类推。

arr[4], arr[5] 右侧不存在更大的元素。

代码

C++

class Solution {
public:
    vector<int> monotonicStack(vector<int>& nums) {
        int n = nums.size();
        vector<int> ans(n);
        stack<int> st;
      
      	for (int i = 0; i < n; ++i) {
            while (!st.empty() && nums[i] > nums[st.top()]) {
                int prevI = st.top();
                ans[prevI] = i;
                st.pop();
	              // 还可以针对 prevI, i, nums[prevI], nums[i] 做些其他的处理 
            }
            st.push(i);
        }
        
      return ans;
    }
};

Python

class Solution:
    def monotonicStack(self, nums: List[int]) -> List[int]:
        n = len(nums)
        ans = [0] * n
        st = []

        for i, v in enumerate(nums):
            while st and v > nums[st[-1]]:
                prevI = st.pop()
                ans[prevI] = i
                # 还可以针对 prevI, i, nums[prevI], nums[i] 做些其他的处理 
            st.append(i)
        
        return ans

Java

class Solution {
    public int[] monotonicStack(int[] nums) {
      	int n = nums.length;
        int[] ans = new int[n];
        // java 中的 Stack 会涉及到线程锁，降低性能。而 ArrayList 移除最后一个元素不方便。
	    // 此处采用 ArrayDeque，读者亦可采用 LinkedList。
        Deque<Integer> stack = new ArrayDeque<>();
        
        for (int i = 0; i < n; i++) {
            while (!stack.isEmpty() && nums[i] > nums[stack.peek()]) {
                int prevI = stack.pop();
                ans[prevI] = i;
                // 还可以针对 prevI, i, nums[prevI], nums[i] 做些其他的处理 
            }
            stack.push(i);
        }
        
        return ans;
    }
}

Kotlin

public class Solution{
    fun monotonicStack(nums: IntArray): IntArray {
      	// 如果调用 java 的 Stack 会涉及到线程锁，降低性能，改用 list。
        val list = mutableListOf<Int>()
        val ans = IntArray(nums.size)

        for(i in nums.indices){
            while(list.any() && nums[i] > nums[list.last()]){
                val prevI = list.removeLast()
                ans[prevI] = i
                // 还可以针对 prevI, i, nums[prevI], nums[i] 做些其他的处理 
            }
            list += i
        }

        return ans
    }
}

伪代码

MONOTONIC_STACK(Nums): IntArray
    Ans = [0] * Nums.size
    S = empty stack

    for each i in [0, Nums.size):
        while S is not empty and Nums[i] > Nums[S.peek()]:
            prevI = S.pop()
            Ans[prevI] = i
            // 还可以针对 prevI, i, Nums[prevI], Nums[i] 做些其他的处理 
        S.push(i)

    return Ans