算法学习Day4-Leecode20，496-【数据结构】【栈】

20. 有效的括号

 

class Solution 
{
    public:
    bool isValid(string s) {
        int n = s.size();
        if(n%2 == 1){
            return false;
        }

        unordered_map<char,char> pairs = {
            {')', '('},
            {']', '['},
            {'}', '{'}
        };

        stack<char> stk;
        for(char ch:s){
            if(pairs.count(ch)){
                if (stk.empty() || stk.top() != pairs[ch]) {
                    return false;
                }
                stk.pop();
            }else{
                stk.push(ch);
            }
            return stk.empty();

    }
    
};

func isValid(s string) bool {
    n := len(s)
    if n % 2 == 1{
        return false
    }

    pairs := map[byte]byte{
        ')': '(',
        ']': '[',
        '}': '{',
    }

    stack := []byte{}

    for i:=0;i<n;i++{
        if pairs[s[i]]>0{
            if len(stack) == 0 || stack[len(stack)-1] != pairs[s[i]] {
                return false
            }
            stack = stack[:len(stack)-1]
        } else {
            stack = append(stack, s[i])
        }
    }
    return len(stack) == 0
}

class Solution {
    public boolean isValid(String s) {
        while(s.contains("()")||s.contains("[]")||s.contains("{}")){
            if(s.contains("()")){
                s=s.replace("()","");
            }
            if(s.contains("{}")){
                s=s.replace("{}","");
            }
            if(s.contains("[]")){
                s=s.replace("[]","");
            }
        }
        return s.length()==0;
    }
}

单调栈：下一个更大元素 I

public int[] nextGreaterElement(int[] nums1, int[] nums2) {
    int[] result = new int[nums1.length];
    Map<Integer, Integer> map = helper(nums2);
    for(int i = 0; i < nums1.length; i++) {
        result[i] = map.get(nums1[i]);
    }

    return result;
}

private Map<Integer,Integer> helper(int[] nums){
    Map<Integer,Integer> map = new HashMap<>();
    Stack<Integer> stack = new Stack<>();
    for(int i = 0; i < nums.length; i++) {
        // 栈不为空且当前元素大于栈顶元素
        // 说明当前元素是栈顶元素的下一个更大元素
        // while循环表示当前元素是栈中所有已存元素的下一个更大元素
        while (!stack.isEmpty() && nums[i] > stack.peek()) {
            map.put(stack.pop(), nums[i]);
        }
        // 将当前考察元素入栈，看后面是否有其下一个更大元素
        stack.push(nums[i]);
    }

    // 栈中剩余的元素是没有下一个更大元素的元素
    while (!stack.isEmpty()) {
        map.put(stack.pop(), -1);
    }
    return map;
}

作者：hardcore-aryabhata
链接：https://leetcode-cn.com/problems/next-greater-element-i/solution/dong-hua-yan-shi-dan-diao-zhan-496xia-yi-ql65/
来源：力扣（LeetCode）
著作权归作者所有。商业转载请联系作者获得授权，非商业转载请注明出处。

public int[] nextGreaterElement(int[] nums1, int[] nums2) {
    int[] result = new int[nums1.length];
    Map<Integer, Integer> map = helper(nums2);
    for(int i = 0; i < nums1.length; i++) {
        result[i] = map.get(nums1[i]);
    }

    return result;
}

private Map<Integer,Integer> helper(int[] nums){
    Map<Integer,Integer> map = new HashMap<>();
    Stack<Integer> stack = new Stack<>();
    for(int i = nums.length - 1; i >= 0; i--) {
        // 如果栈不为空且大于栈顶元素
        // 由于是逆序遍历，所以栈中元素不可能是其之前某个元素的
        // 下一个更大元素，所以将栈中元素清空
        while (!stack.isEmpty() && nums[i] >= stack.peek()) {
            stack.pop();
        }
        // 1.如果栈不为空，且nums[i]小于栈顶元素，由于是逆序遍历
        // 所以栈顶元素是nums[i]的下一个更大元素
        // 2.如果栈为空，说明nums[i]没有下一个更大元素,value=-1
        map.put(nums[i], stack.isEmpty() ? -1 : stack.peek());
        // 存入map，看其是否可能是之前某个元素的下一个更大元素
        stack.push(nums[i]);
    }
    return map;
}

作者：hardcore-aryabhata
链接：https://leetcode-cn.com/problems/next-greater-element-i/solution/dong-hua-yan-shi-dan-diao-zhan-496xia-yi-ql65/
来源：力扣（LeetCode）
著作权归作者所有。商业转载请联系作者获得授权，非商业转载请注明出处。

func nextGreaterElement(nums1 []int, nums2 []int) []int {
	mp := make(map[int]int, len(nums2))
	var stack []int
	for _, num := range nums2 {
		for len(stack) > 0 && num > stack[len(stack)-1] {
			mp[stack[len(stack)-1]] = num
			stack = stack[:len(stack)-1]
		}
		stack = append(stack, num)
	}
	ans := make([]int, 0, len(nums1))
	for _, num := range nums1 {
		if v, ok := mp[num]; !ok {
			ans = append(ans, -1)
		} else {
			ans = append(ans, v)
		}
	}
	return ans
}

作者：aaffo
链接：https://leetcode-cn.com/problems/next-greater-element-i/solution/goyu-yan-dan-diao-zhan-by-aaffo-ze5f/
来源：力扣（LeetCode）
著作权归作者所有。商业转载请联系作者获得授权，非商业转载请注明出处。