力扣刷题第二十三天--栈与队列

前言

看到困难题，直接开抄。。。有一天我会说出，滑动窗口，不过如此。

内容

一、逆波兰表达式求值

150.逆波兰表达式求值

给你一个字符串数组 tokens ，表示一个根据 逆波兰表示法 表示的算术表达式。

请你计算该表达式。返回一个表示表达式值的整数。

注意：

• 有效的算符为 '+'、'-'、'*' 和 '/' 。
• 每个操作数（运算对象）都可以是一个整数或者另一个表达式。
• 两个整数之间的除法总是 向零截断 。
• 表达式中不含除零运算。
• 输入是一个根据逆波兰表示法表示的算术表达式。
• 答案及所有中间计算结果可以用 32 位 整数表示。

栈

如果遇到操作数，则将操作数入栈；

如果遇到运算符，则将两个操作数出栈，其中先出栈的是右操作数，后出栈的是左操作数，使用运算符对两个操作数进行运算，将运算得到的新操作数入栈。

func evalRPN(tokens []string) int {
    stack:=[]int{}
    for _,token:=range tokens{
        val,err:=strconv.Atoi(token)
        //用于将字符串转换为整数
        if err==nil{//是数字
            stack=append(stack,val)
        }else{//不是数字
            num1,num2:=stack[len(stack)-2],stack[len(stack)-1]
            stack=stack[:len(stack)-2]
            switch token{
                case "+":
                stack=append(stack,num1+num2)
                case "-":
                stack=append(stack,num1-num2)
                case "*":
                stack=append(stack,num1*num2)
                case "/":
                stack=append(stack,num1/num2)
            }
        }
    }
    return stack[0]
}

 二、滑动窗口最大值

239.滑动窗口最大值

给你一个整数数组 nums，有一个大小为 k 的滑动窗口从数组的最左侧移动到数组的最右侧。你只可以看到在滑动窗口内的 k 个数字。滑动窗口每次只向右移动一位。

返回 滑动窗口中的最大值 。

优先队列

看不太懂

var a []int
type hp struct{
    sort.IntSlice//sort.IntSlice是一个实现了sort.Interface接口的类型  并且定义了三个方法：Less, Push 和 Pop。这些方法使得我们可以使用堆（heap）数据结构来操作一个整数切片a
}
func(h hp)Less(i,j int)bool{
    return a[h.IntSlice[i]]>a[h.IntSlice[j]]
}
func(h *hp) Push(v interface{}){
    h.IntSlice=append(h.IntSlice,v.(int))
    //这个方法接收一个接口类型的参数，并把其转换为整数类型后添加到切片h.IntSlice的末尾
}
func (h *hp) Pop() interface{}{
    a:=h.IntSlice;
    v:=a[len(a)-1];
    h.IntSlice=a[:len(a)-1];
    return v
    //这个方法首先复制切片h.IntSlice到另一个切片，然后从原切片中删除最后一个元素，并返回这个元素
}
 
func maxSlidingWindow(nums []int, k int) []int {
    a=nums
    q:=&hp{make([]int,k)}
   for i:=0;i
       q.IntSlice[i]=i
   }
   heap.Init(q)//使用heap.Init函数初始化堆。这是必要的步骤，因为尽管我们之前已经将q.IntSlice初始化为满足堆特性的数组，但我们仍然需要调用heap.Init(q)来确保堆的其他部分也被正确初始化
   n:=len(nums)
   ans:=make([]int,1,n-k+1)//长度为1，容量为n-k+1
   ans[0]=nums[q.IntSlice[0]]
   for i:=k;i
       heap.Push(q,i)
       for q.IntSlice[0]<=i-k{
           heap.Pop(q)
       }
       ans=append(ans,nums[q.IntSlice[0]])
   }
   return ans
}

单调队列 

看懂了，但好像写不出来。。。

// 封装单调队列的方式解题
type  MyQueue struct{
    queue []int
}
func NewMyQueue() *MyQueue{
    return &MyQueue{
        queue:make([]int,0),
    }
}
 
func (m *MyQueue) Front() int{
    return m.queue[0]
}
 
func(m *MyQueue) Back() int{
    return m.queue[len(m.queue)-1]
}
func (m *MyQueue)Empty()bool{
    return len(m.queue)==0
}
func (m *MyQueue)Push(val int){
    for !m.Empty()&&val>m.Back(){
        m.queue=m.queue[:len(m.queue)-1]
    }
    m.queue=append(m.queue,val)
}
func (m *MyQueue) Pop(val int){
    if !m.Empty()&&val==m.Front(){
        m.queue=m.queue[1:]
    }
}
func maxSlidingWindow(nums []int,k int)[]int{
    queue:=NewMyQueue()
    length:=len(nums)
    res:=make([]int,0)
    for i:=0;i// 先将前k个元素放入队列
      queue.Push(nums[i])
    } // 记录前k个元素的最大值
    res=append(res,queue.Front())
// 滑动窗口移除最前面的元素
    for i:=k;i
       queue.Pop(nums[i-k])
       // 滑动窗口添加最后面的元素
       queue.Push(nums[i])
       // 记录最大值
       res=append(res,queue.Front())
    }
    return res
}

最后

rise！