栈:先进后出
时间复杂度:入出O(1),查找O(n)
使用场景:10进制转2进制
23 %2 = 1
11 %2 = 1
5 %2 = 1
2 %2 = 0
1 %2 = 1
tack = [1, 1, 1, 0, 1]
res = 1 0 1 1 1
复习下2进制转10进制:
1 0 1 1 1有5位
1 * 2^4 + 0 * 2^3 + 1*2^2 + 1*2^1 + 1*2^0
= 16 + 0 + 4 + 2 + 1
= 23
一:有效括号(20)
给定一个只包括 '(',')','{','}','[',']' 的字符串 s ,判断字符串是否有效。
有效字符串需满足:
左括号必须用相同类型的右括号闭合。
左括号必须以正确的顺序闭合。
示例 1:
输入:s = "()"
输出:true
示例 2:
输入:s = "()[]{}"
输出:true
示例 3:
输入:s = "(]"
输出:false
示例 4:
输入:s = "([)]"
输出:false
示例 5:
输入:s = "{[]}"
输出:true
func isValid(s string) bool {
/**
思路分析:
左右闭合必然是偶数,单数直接返回
从左遍历,如果是左边的括号,就放入栈中,当匹配右边的第一个括号,必然是和栈顶的是一套的,怎么判断是一套那,我们可以直接使用hash实现,利用map
**/
//开始
n:= len(s)
if n%2 == 1 {
return false
}
//利用ascii码,注意这里key一定要是有括号,因为下面判断是从最左边开始,所以存在有括号才是需要和栈顶数据对比,写反了下面逻辑也要修改
var memory = map[byte]byte{
')':'(',
'}':'{',
']':'[',
}
stack := []byte{}
for i:=0; i<n; i++ {
//>0说明存在右括号,这时从栈顶取出做括号
if memory[s[i]] > 0{
if len(stack) == 0 || stack[len(stack)-1] != memory[s[i]] {
return false
}
//取出栈顶的数据
stack = stack[:len(stack) - 1]
} else {
//是做括号放到栈顶
stack = append(stack, s[i])
}
}
//栈没有数据说明匹配完毕
if len(stack) == 0 {
return true
} else {
return false
}
}
二:用栈实现队列(232)
请你仅使用两个栈实现先入先出队列。队列应当支持一般队列支持的所有操作(push、pop、peek、empty):
实现 MyQueue 类:
void push(int x) 将元素 x 推到队列的末尾
int pop() 从队列的开头移除并返回元素
int peek() 返回队列开头的元素
boolean empty() 如果队列为空,返回 true ;否则,返回 false
说明:
你只能使用标准的栈操作 —— 也就是只有 push to top, peek/pop from top, size, 和 is empty 操作是合法的。
你所使用的语言也许不支持栈。你可以使用 list 或者 deque(双端队列)来模拟一个栈,只要是标准的栈操作即可。
进阶:
你能否实现每个操作均摊时间复杂度为 O(1) 的队列?换句话说,执行 n 个操作的总时间复杂度为 O(n) ,即使其中一个操作可能花费较长时间。
示例:
输入:
["MyQueue", "push", "push", "peek", "pop", "empty"]
[[], [1], [2], [], [], []]
输出:
[null, null, null, 1, 1, false]
解释:
MyQueue myQueue = new MyQueue();
myQueue.push(1); // queue is: [1]
myQueue.push(2); // queue is: [1, 2] (leftmost is front of the queue)
myQueue.peek(); // return 1
myQueue.pop(); // return 1, queue is [2]
myQueue.empty(); // return false
type MyQueue struct {
queue1, queue2 []int
}
func Constructor() (this MyQueue) {
return
}
func (this *MyQueue) Push(x int) {
//栈先进后出,队列先进先出
//写入前先把栈的数据放到临时中,然后写入到新的栈,如果检测到临时的栈有数据,就把数据放到当前栈中,比如按照栈输入的是2,3,4,5.栈输出是5,4,3,2.所以再把这个按照顺序保存到另一个栈就是,5,4,3,2输出就变成了2,3,4,5。因为栈是先输出最后一个也就是 queue(len(queue)-1)
//原本234现在2345
this.queue2 = append(this.queue2, x)
//开始保存到queue1,每次插入清空queue1,重新同步queue2
this.queue1 = []int{}
for i:=0; i< len(this.queue2); i++ {
this.queue1 = append(this.queue1, this.queue2[len(this.queue2) - i - 1])
}
}
func (this *MyQueue) Pop() int {
v := this.queue1[len(this.queue1) - 1]
//1
//这里一定要注意。。因为1和2是反转的,所以1移出最后一个,2就应该移出第一个
//1:1234,2:4321
this.queue1 = this.queue1[:len(this.queue1) - 1]
this.queue2 = this.queue2[1:]
return v
}
func (this *MyQueue) Peek() int {
//栈只能从栈顶出数据,但是这个是队列的第一个出的
return this.queue1[len(this.queue1) - 1]
}
func (this *MyQueue) Empty() bool {
return len(this.queue1) == 0
}
/**
* Your MyQueue object will be instantiated and called as such:
* obj := Constructor();
* obj.Push(x);
* param_2 := obj.Pop();
* param_3 := obj.Peek();
* param_4 := obj.Empty();
*/