Oliver's Blog
search
Ctrlk
  • 🤩Welcome!
  • Projects
    • RISC Game
    • Mini Amazon
    • HTTP Caching Proxy
    • Course Enrollment App
    • Fitness Tracker App
    • Voice Shopping Assistant
    • Graphics Town
  • Algo
    • Binary Searchchevron-right
    • Linked Listchevron-right
    • Recursion Basicschevron-right
    • Binary Treechevron-right
    • Sortingchevron-right
    • Two Pointerschevron-right
    • Queue & Stackchevron-right
      • Implement Queue by Interface
      • Implement Stack
      • Implement Queue by Two Stacks
      • Implement Stack by Two Queues
      • Binary Tree Level Order Traversal
      • Valid Parentheses
      • Min Stack
      • Largest Rectangle in Histogram
      • Evaluate Reverse Polish Notation
      • Implement Queue by Linked List II
      • Basic Calculator II
      • Moving Average from Data Stream
      • Reveal Cards In Increasing Order
      • Longest Valid Parentheses
    • Hash Tablechevron-right
    • Heap & Priority Queuechevron-right
    • BFSchevron-right
    • Arraychevron-right
    • Stringchevron-right
    • Mathchevron-right
    • Dynamic Programmingchevron-right
    • LeetCode vs. LintCode Table
  • React Notes
    • Optimizing Performance in React
  • Golang Notes
    • Basicschevron-right
    • Official Tutorial Noteschevron-right
  • Miscellaneous
    • Traveling to China During a Global Pandemic
gitbookPowered by GitBook
block-quoteOn this pagechevron-down
  1. Algochevron-right
  2. Queue & Stack

Valid Parentheses

ID: 20; easy

LogoValid Parentheses - LeetCodeLeetCodechevron-right
LogoLintCode 炼码 - 更高效的学习体验!www.lintcode.comchevron-right

hashtag
Solution 1 (Go)

hashtag
Solution 2 (Java)

PreviousBinary Tree Level Order Traversalchevron-leftNextMin Stackchevron-right

Last updated 4 years ago

  • Solution 1 (Go)
  • Solution 2 (Java)
func isValid(s string) bool {
    stack := make([]rune, 0)
    for _,v := range s {
        if v == '(' || v == '[' || v == '{' {
            stack = append(stack, v)
        } else if (v == ')' && len(stack) > 0 && stack[len(stack)-1] == '(') ||
            (v == ']' && len(stack) > 0 && stack[len(stack)-1] == '[') ||
            (v == '}' && len(stack) > 0 && stack[len(stack)-1] == '{') {
                stack = stack[:len(stack)-1]
        } else {
            return false
        }
    }
    return len(stack) == 0
}
public class Solution {
    /**
     * @param s: A string
     * @return: whether the string is a valid parentheses
     */
    public boolean isValidParentheses(String s) {
        if (s == null || s.length() == 0)
            return true;
        char[] arr = s.toCharArray();
        Deque<Character> stack = new ArrayDeque<>(); 
        for (char c : arr) {
            if (c == '(' || c == '[' || c == '{') {
                stack.push(c);
            } else {
                if (stack.isEmpty())
                    return false;
                if (c == ')' && stack.pop() != '(')
                    return false;
                if (c == ']' && stack.pop() != '[')
                    return false;
                if (c == '}' && stack.pop() != '{')
                    return false;
            }
        }
        return stack.isEmpty();
    }
}