方法一：利用栈
思路：（1）创建一个栈，在栈里依次加入字符串的括号，如果遇到的是右括号，那么将左括号入栈，如果是右括号，则将出栈一个元素，判断出栈元素，是不是刚好是当前即将入栈的匹配右元素
python版本
class Solution(object):
def isValid(self, s):
"""
:type s: str
:rtype: bool
"""
# The stack to keep track of opening brackets.
stack = []
# Hash map for keeping track of mappings. This keeps the code very clean.
# Also makes adding more types of parenthesis easier
mapping = {")": "(", "}": "{", "]": "["}
# For every bracket in the expression.
for char in s:
# If the character is an closing bracket
if char in mapping:
# Pop the topmost element from the stack, if it is non empty
# Otherwise assign a dummy value of '#' to the top_element variable
top_element = stack.pop() if stack else '#'
# The mapping for the opening bracket in our hash and the top
# element of the stack don't match, return False
if mapping[char] != top_element:
return False
else:
# We have an opening bracket, simply push it onto the stack.
stack.append(char)
# In the end, if the stack is empty, then we have a valid expression.
# The stack won't be empty for cases like ((()
return not stack
Java版本
class Solution {
public boolean isValid(String s) {
int n = s.length();
if (n % 2 == 1) {
return false;
}
Map<Character, Character> pairs = new HashMap<Character, Character>() {{
put(')', '(');
put(']', '[');
put('}', '{');
}};
Deque<Character> stack = new LinkedList<Character>();
for (int i = 0; i < n; i++) {
char ch = s.charAt(i);
if (pairs.containsKey(ch)) {
if (stack.isEmpty() || stack.peek() != pairs.get(ch)) {
return false;
}
stack.pop();
} else {
stack.push(ch);
}
}
return stack.isEmpty();
}
}
如果括号只有()样式，那么判断有效的括号可以用下面的方式
def vaild(input_str):
tmp = []
for i in input_str:
if i == ")" and tmp[-1] == "(":
print(tmp[-1])
tmp.pop()
else:
tmp.append(i)
if tmp == []:
return True
else:
return False
print(vaild("(()())"))
扩展，关于Java的双端队列Deque和LinkedList相关知识
一个是peek和pop的用法
peek() 返回队头元素，但不删除该元素。
pop() 返回队头元素，并删除该元素。
示例代码如下
import java.util.LinkedList;
class LinkedListPopDemo{
public static void main(String[] args) {
// Create a LinkedList of Strings
LinkedList<String> list = new LinkedList<String>();
// Add few Elements
list.add("Jack");
list.add("Robert");
list.add("Chaitanya");
list.add("kate");
// Display LinkList elements
System.out.println("LinkedList before: "+list);
// pop Element from list and display it
System.out.println("Element removed: "+list.pop());
// Display after pop operation
System.out.println("LinkedList after: "+list);
}
}
LinkedList before: [Jack, Robert, Chaitanya, kate]
Element removed: Jack
LinkedList after: [Robert, Chaitanya, kate]
总结一下：
当我们只需要取出栈顶的元素进行处理（或者说我们需要先对栈顶的数据进行处理例如比较）然后根据处理的结果进行决定是否要pop()，这种情况下，我们可以先使用peek()方法，取出栈顶的值。
补充总结一下栈中的其他常用的方法：
empty( )——如果堆栈是空的，则返回true，当堆栈包含元素时，返回false；
一个是add和push的用法区别
Java LinkedList add 是加在list尾部，LinkedList push 施加在list头部，等同于addFirst
示例代码1
import java.util.LinkedList;
class LinkedListExample {
public static void main(String[] args) {
// Create a LinkedList of Strings
LinkedList<String> list = new LinkedList<String>();
// Add few Elements
list.add("Jack");
list.add("Robert");
list.add("Chaitanya");
list.add("kate");
// Display LinkList elements
System.out.println("LinkedList contains: "+list);
// push Element the list
list.push("NEW ELEMENT");
// Display after push operation
System.out.println("LinkedList contains: "+list);
}
运行结果
LinkedList contains: [Jack, Robert, Chaitanya, kate]
LinkedList contains: [NEW ELEMENT, Jack, Robert, Chaitanya, kate]
示例代码2
package collections;
import java.util.Deque;
import java.util.LinkedList;
/**
* @Package collections
* @date 2017-11-28下午5:53:32
*/
public class DequeTest {
/**
* @param args
*/
public static void main(String[] args) {
Deque<String> deque = new LinkedList<String>();
deque.add("d");
deque.add("e");
deque.add("f");
//从队首取出元素，不会删除
System.out.println("队首取出元素:"+deque.peek());
System.out.println("队列为:"+deque);
//从队首加入元素(队列有容量限制时用，无则用addFirst)
deque.offerFirst("c");
System.out.println("队首加入元素后为："+deque);
//从队尾加入元素(队列有容量限制时用，无则用addLast)
deque.offerLast("g");
System.out.println("队尾加入元素后为："+deque);
//队尾加入元素
deque.offer("h");
System.out.println("队尾加入元素后为："+deque);
//获取并移除队列第一个元素,pollFirst()也是，区别在于队列为空时,removeFirst会抛出NoSuchElementException异常，后者返回null
deque.removeFirst();
System.out.println("获取并移除队列第一个元素后为:"+deque);
//获取并移除队列第一个元素,此方法与pollLast 唯一区别在于队列为空时,removeLast会抛出NoSuchElementException异常，后者返回null
deque.removeLast();
System.out.println("获取并移除队列最后一个元素后为:"+deque);
//获取队列第一个元素.此方法与 peekFirst 唯一的不同在于：如果此双端队列为空，它将抛出NoSuchElementException，后者返回null
System.out.println("获取队列第一个元素为:"+deque.getFirst());
System.out.println("获取队列第一个元素后为:"+deque);
//获取队列最后一个元素.此方法与 peekLast 唯一的不同在于：如果此双端队列为空，它将抛出NoSuchElementException，后者返回null
System.out.println("获取队列最后一个元素为:"+deque.getLast());
System.out.println("获取队列第一个元素后为:"+deque);
//循环获取元素并在队列移除元素
while(deque.size()>0){
System.out.println("获取元素为："+ deque.pop()+" 并删除");
}
System.out.println("队列为:"+deque);
}
}
运行结果
队首取出元素:d
队列为:[d, e, f]
队首加入元素后为：[c, d, e, f]
队尾加入元素后为：[c, d, e, f, g]
队尾加入元素后为：[c, d, e, f, g, h]
获取并移除队列第一个元素后为:[d, e, f, g, h]
获取并移除队列最后一个元素后为:[d, e, f, g]
获取队列第一个元素为:d
获取队列第一个元素后为:[d, e, f, g]
获取队列最后一个元素为:g
获取队列第一个元素后为:[d, e, f, g]
获取元素为：d 并删除
获取元素为：e 并删除
获取元素为：f 并删除
获取元素为：g 并删除
队列为:[]
总结
继承关系是：deque => queue => collection=》Iterable
1.使用队列的时候，new LinkedList的时候为什么用deque接收，不用LinkedList呢？
答：deque继承queue接口，因为它有两个实现，LinkedList与ArrayDeque。用deque接收是因为向上转型(子类往父类转，会丢失子类的特殊功能)了。可以试试，用get()方法，LinkedList接收才有。
2.为什么有一个实现还不够，还弄两个呢，它们总有区别吧？
答：ArrayDeque是基于头尾指针来实现的Deque，意味着不能访问除第一个和最后一个元素。想访问得用迭代器，可以正反迭代。
ArrayDeque一般优于链表队列/双端队列，有限数量的垃圾产生（旧数组将被丢弃在扩展），建议使用deque，ArrayDeque优先。
参考链接
https://leetcode-cn.com/problems/valid-parentheses/solution/you-xiao-de-gua-hao-by-leetcode-solution/
https://www.javatpoint.com/java-deque-pop-method
java Queue中 add/offer，element/peek，remove/poll区别
https://blog.csdn.net/u012050154/article/details/60572567
扫一扫
235
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
