GO算法-栈队列转换之互通有无

栈：先进后出

时间复杂度：入出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现在2345this.queue2 = append(this.queue2, x)//开始保存到queue1,每次插入清空queue1,重新同步queue2this.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：4321this.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();*/