代码随想录Day 10 队列和栈的相互模拟

344. 反转字符串 - 力扣（LeetCode）

简单的进行交换即可

func reverseString(s []byte)  {
    for i, j := 0, len(s)-1; i < j; {
        s[i], s[j] = s[j], s[i]
        i++
        j--
    }
}

541. 反转字符串 II - 力扣（LeetCode）

和上一道题差不太多

func reverseStr(s string, k int) string {
    s1 := []byte(s)
    for i := 0; i < len(s1); i = i+k*2 {
        for j, t := i, i+k-1; j < t; j, t = j+1, t-1 {
            if t > len(s1)-1 {
                t = len(s1)-1
            }
            s1[j],s1[t] = s1[t],s1[j]
        }
    }
    return string(s1)
}

LCR 122. 路径加密 - 力扣（LeetCode）

简单替换一下即可

func pathEncryption(path string) string {
    p := []byte(path)
    for i := 0; i < len(p); i++ {
        if p[i] == '.' {
            p[i] = ' '
        }
    }
    return string(p)
}

151. 反转字符串中的单词 - 力扣（LeetCode）

计算好单词数量，预分配空间，再进行填充

func reverseWords(s string) string {
    var strs [][]byte
    var temp []byte
    for i := 0; i < len(s); i++ {
        if s[i] != ' ' {
            temp = append(temp, s[i])
        } else if len(temp) != 0 {
            strs = append(strs, temp)
            temp = make([]byte, 0)
        }
    }
    if len(temp) != 0 {
        strs = append(strs, temp)
    }
    var ans []byte
    for i := len(strs)-1; i >= 0; i-- {
        ans = append(ans, strs[i]...)
        ans = append(ans, ' ')
    }
    ans = ans[:len(ans)-1]
    return string(ans)
}

232. 用栈实现队列 - 力扣（LeetCode）

在push数据的时候，只要数据放进输入栈就好，但在pop的时候，操作就复杂一些，输出栈如果为空，就把进栈数据全部导入进来（注意是全部导入），再从出栈弹出数据，如果输出栈不为空，则直接从出栈弹出数据就可以了。

type MyQueue struct {
    inStack, outStack []int
}

func Constructor() MyQueue {
    return MyQueue{}
}

func (q *MyQueue) Push(x int) {
    q.inStack = append(q.inStack, x)
}

func (q *MyQueue) in2out() {
    for len(q.inStack) > 0 {
        q.outStack = append(q.outStack, q.inStack[len(q.inStack)-1])
        q.inStack = q.inStack[:len(q.inStack)-1]
    }
}

func (q *MyQueue) Pop() int {
    if len(q.outStack) == 0 {
        q.in2out()
    }
    x := q.outStack[len(q.outStack)-1]
    q.outStack = q.outStack[:len(q.outStack)-1]
    return x
}

func (q *MyQueue) Peek() int {
    if len(q.outStack) == 0 {
        q.in2out()
    }
    return q.outStack[len(q.outStack)-1]
}

func (q *MyQueue) Empty() bool {
    return len(q.inStack) == 0 && len(q.outStack) == 0
}

225. 用队列实现栈 - 力扣（LeetCode）

用Go切片实现很简单的还是……

type MyStack struct {
	e []int
}

func Constructor() MyStack {
	return MyStack{}
}

func (s *MyStack) Push(x int) {
	s.e = append(s.e, x) // 入队
}

func (s *MyStack) Pop() (v int) {
	v = s.Top()
	s.e = s.e[:len(s.e)-1]
	return
}

func (s *MyStack) Top() (v int) {
	// 此处是模拟队列弹出元素再插入队尾，直到找到原先队尾的元素返回它，再将其插入队尾
	// 以下代码等价于 return s.e[len(s.e) - 1]
	for i := len(s.e); i > 0; i-- {
		if i == 1 {
			v = s.e[0]
		}
		s.e = append(s.e, s.e[0])
		s.e = s.e[1:]
	}
	return
}

func (s *MyStack) Empty() bool {
	return len(s.e) == 0
}