代码随想录算法训练营day11| 20. 有效的括号 1047. 删除字符串中的所有相邻重复项 150. 逆波兰表达式求值

20. 有效的括号

使用一个栈读取左括号，当左括号遇到匹配的右括号时弹出，若最后栈为空，则有效；反之无效

时间复杂度O(n) 空间复杂度O(n)

// 使用一个栈读取左括号，当左括号遇到匹配的右括号时弹出，
// 若最后栈为空，则有效；反之无效
type Stack struct {
	elements []int32
}

func (this *Stack) Size() int {
	return len(this.elements)
}
func (this *Stack) Push(val int32) {
	this.elements = append(this.elements, val)
}
func (this *Stack) Pop() int32 {
	element := this.elements[this.Size()-1]
	this.elements = this.elements[:this.Size()-1]
	return element
}
func (this *Stack) Top() int32 {
	if this.Size() > 0 {
		return this.elements[this.Size()-1]
	}
	return -1
}
func isValid(s string) bool {
	myStack := Stack{}
	for _, v := range s {
		switch v {
		case '(':
			myStack.Push(v)
		case '{':
			myStack.Push(v)
		case '[':
			myStack.Push(v)
		case ')':
			if myStack.Top() == '(' {
				myStack.Pop()
			} else {
				myStack.Push(v)
			}
		case ']':
			if myStack.Top() == '[' {
				myStack.Pop()
			} else {
				myStack.Push(v)
			}
		case '}':
			if myStack.Top() == '{' {
				myStack.Pop()
			} else {
				myStack.Push(v)
			}
		default:
			continue
		}
	}
	return myStack.Size() == 0
}

1047. 删除字符串中的所有相邻重复项

使用栈来判断，用栈来存储字符，当新进入的字符与栈顶字符相同时，弹出栈顶字符；否则加入

时间复杂度O(n)   空间复杂度O(n)

type Stack struct {
	elements []int32
}

func (this *Stack) Size() int {
	return len(this.elements)
}
func (this *Stack) Push(val int32) {
	this.elements = append(this.elements, val)
}
func (this *Stack) Pop() int32 {
	element := this.elements[this.Size()-1]
	this.elements = this.elements[:this.Size()-1]
	return element
}
func (this *Stack) Top() int32 {
	if this.Size() > 0 {
		return this.elements[this.Size()-1]
	}
	return -1
}
func removeDuplicates(s string) string {
	// 用栈来存储字符，当新进入的字符与栈顶字符相同时，弹出栈顶字符；否则加入
	myStack := Stack{}
	for _, value := range s {
		if value == myStack.Top() {
			myStack.Pop()
		}else{
			myStack.Push(value)
		}
	}
	return string(myStack.elements)
}

150. 逆波兰表达式求值

使用栈来计算后缀表达式

时间复杂度O(n)           空间复杂度O(n)

type Stack struct {
	elements []string
}

func (this *Stack) Size() int {
	return len(this.elements)
}
func (this *Stack) Push(val string) {
	this.elements = append(this.elements, val)
}
func (this *Stack) Pop() string {
	element := this.elements[this.Size()-1]
	this.elements = this.elements[:this.Size()-1]
	return element
}
func (this *Stack) Top() string {
	if this.Size() > 0 {
		return this.elements[this.Size()-1]
	}
	return ""
}
func evalRPN(tokens []string) int {
	// 后缀表达式的计算，用栈实现，每遇到一个操作符就弹出两个元素，计算后得到的结果再入栈
	myStack := Stack{}
	for _, token := range tokens {
		switch token {
		case "+":
			right, _ := strconv.Atoi(myStack.Pop())
			left, _ := strconv.Atoi(myStack.Pop())
			myStack.Push(strconv.Itoa(left + right))
		case "-":
			right, _ := strconv.Atoi(myStack.Pop())
			left, _ := strconv.Atoi(myStack.Pop())
			myStack.Push(strconv.Itoa(left - right))
		case "*":
			right, _ := strconv.Atoi(myStack.Pop())
			left, _ := strconv.Atoi(myStack.Pop())
			myStack.Push(strconv.Itoa( left * right))
		case "/":
			right, _ := strconv.Atoi(myStack.Pop())
			left, _ := strconv.Atoi(myStack.Pop())
			myStack.Push(strconv.Itoa( left / right))
		default:
			myStack.Push(token)
		}
	}
	result, _ := strconv.Atoi(myStack.Top())
	return result
}