栈的基本使用
例题:有效的括号
给定一个只包括 ‘(’,’)’,’{’,’}’,’[’,’]’ 的字符串,判断字符串是否有效。
有效字符串需满足:
左括号必须用相同类型的右括号闭合。 左括号必须以正确的顺序闭合。 注意空字符串可被认为是有效字符串。
很经典的题目,当初第一次做还是个懵懂的少年,现在头发刷刷的掉。
利用栈可以很轻松的实现,遇到左括号就进栈,右括号就出栈栈顶元素进行匹配。如果匹配错误或者栈为空,则返回false。
当然,如果最后运行结束栈为空,返回true;否则返回false。
class Solution {
public boolean isValid(String s) {
Stack<Character> stack = new Stack<Character>();
for(int i=0;i<s.length();i++){
char cur = s.charAt(i);
if(cur=='(' || cur=='[' || cur=='{'){
stack.push(cur);
}else{
if(stack.empty()) return false;
switch(stack.pop()){
case '(':
if(cur!=')') return false;
break;
case '{':
if(cur!='}') return false;
break;
case '[':
if(cur!=']') return false;
break;
}
}
}
return stack.empty()?true:false;
}
}
1.逆波兰表达式求值
根据逆波兰表示法,求表达式的值。 有效的运算符包括 +, -, *, / 。每个运算对象可以是整数,也可以是另一个逆波兰表达式。
说明: 整数除法只保留整数部分。 给定逆波兰表达式总是有效的。换句话说,表达式总会得出有效数值且不存在除数为 0 的情况。
逆波兰表达式也就是学的“后缀表达式”,具体算法如下所示:
新建一个表达式,如果当前字符为变量或者为数字,则压栈,如果是运算符,则将栈顶两个元素弹出作相应运算,结果再入栈,最后当表达式扫描完后,栈里的就是结果。
class Solution {
public int evalRPN(String[] tokens) {
Stack<String> stack = new Stack<String>();
for(String s:tokens){
if(s.equals("+")){
int a = Integer.parseInt(stack.pop());
int b = Integer.parseInt(stack.pop());
stack.push(String.valueOf(a+b));
}else if(s.equals("-")){
int a = Integer.parseInt(stack.pop());
int b = Integer.parseInt(stack.pop());
stack.push(String.valueOf(b-a));
}else if(s.equals("*")){
int a = Integer.parseInt(stack.pop());
int b = Integer.parseInt(stack.pop());
stack.push(String.valueOf(a*b));
}else if(s.equals("/")){
int a = Integer.parseInt(stack.pop());
int b = Integer.parseInt(stack.pop());
stack.push(String.valueOf(b/a));
}else{
stack.push(s);
}
}
return Integer.parseInt(stack.pop());
}
}
2.简化路径
以 Unix 风格给出一个文件的绝对路径,你需要简化它。或者换句话说,将其转换为规范路径。
在 Unix 风格的文件系统中,一个点(.)表示当前目录本身;此外,两个点 (…)表示将目录切换到上一级(指向父目录);两者都可以是复杂相对路径的组成部分。
请注意,返回的规范路径必须始终以斜杠 / 开头,并且两个目录名之间必须只有一个斜杠 /。最后一个目录名(如果存在)不能以 /结尾。此外,规范路径必须是表示绝对路径的最短字符串。
这个题,乍一看复杂之极,但实际上懂一些文件路径便能轻松解决:
- 第一步,按照
/
来分割字符串; - 对每一个分割后的字符串判断:
- 如果是单词,那么就先入栈一个
/
,再将单词入栈; - 如果是
.
或者,就按兵不动;
- 如果是
..
,就出栈两个元素,如果栈为空,就不动;
- 如果是单词,那么就先入栈一个
- 遍历完数组后,此时栈中的元素,全部出栈,逆向拼接即可。
class Solution {
public String simplifyPath(String path) {
String[] array = path.split("/");
Stack<String> stack = new Stack<String>();
for(String s:array){
if(s.equals("..")){
if(!stack.empty()){
stack.pop();
stack.pop();
}
}else if(s.equals(".") || s.equals("")){
}else{
stack.push("/");
stack.push(s);
}
}
StringBuilder sb = new StringBuilder();
while(!stack.empty()){
sb.insert(0,stack.pop());
}
return sb.length()==0?"/":sb.toString();
}
}
栈和递归的紧密关系
1.二叉树的前序遍历
前序的顺序为[根,左,右]
,所以使用递归,深度优先遍历代码如下:
class Solution {
List<Integer> list = new ArrayList<Integer>();
public List<Integer> preorderTraversal(TreeNode root) {
if(root!=null) preorder(root);
return list;
}
public void preorder(TreeNode root){
list.add(root.val);
if(root.left!=null) preorder(root.left);
if(root.right!=null) preorder(root.right);
}
}
可以不使用递归,而使用一个栈来实现:
- 先将root进栈(不为null)
- 如果栈不为空,就循环:每次对于取出的node,先将自身的值添加到列表中,再将右孩子进栈,最后将左孩子进栈。
class Solution {
public List<Integer> preorderTraversal(TreeNode root) {
List<Integer> list = new ArrayList<Integer>();
Stack<TreeNode> stack = new Stack<TreeNode>();
if(root!=null) stack.push(root);
while(!stack.empty()){
TreeNode t = stack.pop();
list.add(t.val);
if(t.right!=null) stack.push(t.right);
if(t.left!=null) stack.push(t.left);
}
return list;
}
}
2.二叉树的中序遍历
原理都一样,只是代码顺序不同:
class Solution {
List<Integer> list = new ArrayList<Integer>();
public List<Integer> inorderTraversal(TreeNode root) {
if(root!=null) inorder(root);
return list;
}
public void inorder(TreeNode root){
if(root.left!=null) inorder(root.left);
list.add(root.val);
if(root.right!=null) inorder(root.right);
}
}
感觉中序遍历的迭代方法不是很好理解
- 因为先输出左子树,所以先将当前结点
p
进栈,然后一路将所有左子树都进栈; - 出栈一个结点,此时该结点的左子树已经被访问过了,所以输出该结点值;
- 然后
p
指向右结点,开始下一轮循环。
栈S;
p= root;
while(p || S不空){
while(p){
p入S;
p = p的左子树;
}
p = S.top 出栈;
访问p;
p = p的右子树;
}
class Solution {
public List<Integer> inorderTraversal(TreeNode root) {
List<Integer> list = new ArrayList<Integer>();
Stack<TreeNode> stack = new Stack<TreeNode>();
TreeNode p = root;
while(p!=null || !stack.empty()){
while(p!=null){
stack.push(p);
p = p.left;
}
p = stack.pop();
list.add(p.val);
p = p.right;
}
return list;
}
}
3.二叉树的后序遍历
class Solution {
List<Integer> list = new ArrayList<Integer>();
public List<Integer> postorderTraversal(TreeNode root) {
if(root!=null) postorder(root);
return list;
}
public void postorder(TreeNode root){
if(root.left!=null) postorder(root.left);
if(root.right!=null) postorder(root.right);
list.add(root.val);
}
}
明白了中序迭代的思路,后序其实差不多。不过需要注意,要区分开从左结点回来的,和从右结点回来的,所以要打上一个标记。
当两个子树都访问过了,将该结点的标志位置为true。
栈S;
p= root;
T<节点,True/False> : 节点标记;
while(p || S不空){
while(p){
p入S;
p = p的左子树;
}
while(S不空 且 T[S.top] = True){
访问S.top;
S.top出S;
}
if(S不空){
p = S.top 的右子树;
T[S.top] = True;
}
}