代码随想录复习 1047. 删除字符串中的所有相邻重复项 150 逆波兰表达式求值 239 滑动窗口最大值

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

代码如下 

func removeDuplicates(s string) string {

            var  stack []byte   //结果栈数组

            for i := 0 ; i < len(s) ; i++ {

                if len(stack) > 0 && stack[len(stack)-1] == s[i] {  //如果当前遍历到的元素与栈顶元素相同，那么就说明两个元素重复，要删除这两个元素。如果不相同，则保留当前遍历的元素

                    stack = stack[:len(stack)-1]

                }else {

                    stack = append(stack,s[i])

                }

            }

            return string(stack)

}

150 逆波兰表达式求值 

func evalRPN(tokens []string) int {

          stack := []int{}    //设置一个空的int数组

          for _,token  := range tokens { 遍历数组

              val , err := strconv.Atoi(token)  //将字符串数组转换为整形

              if err == nil {  //如果转换成功，则将这个整数放入stack数组中

                  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 滑动窗口最大值 

代码如下 

type myqueue struct {

    queue []int 

}

func newqueue() *myqueue {  //初始化

       return &myqueue {

           queue : make([]int,0),

       }

}

func (this *myqueue)front() int {

    return this.queue[0]    //获取队列最开头的元素

}

func (this *myqueue) back() int {

    return this.queue[len(this.queue)-1]  //获取队列最后一个元素

}

func (this *myqueue) empty() bool {  //判断是否为空 

    if len(this.queue) == 0 {    

        return true 

    }else {

        return false 

    }

}

func (this *myqueue) push(val int) {   //push的原则是，如果队列不为空，且队列的最后一个元素比将要push的元素小，那么需要把队列的元素移出。直到队列的最后一个元素比将要push进来的元素大，这样就确保了队列的首个元素一定是最大的元素

    for this.empty() == false && val > this.back() {

        this.queue = this.queue[:len(this.queue)-1]

    }

    this.queue = append(this.queue,val)

}

func (this *myqueue) pop(val int) {

    if this.empty() == false && val == this.front() {  //pop的原则是，如果这个将要pop的值和队列的最开头元素相同，就要把队列里的开头元素一起pop出去，否则不动队列里的元素

        this.queue = this.queue[1:]

    }

}

 

func maxSlidingWindow(nums []int, k int) []int {

           queue := newqueue()   //创建一个队列

           res := make([]int,0) 

           for i := 0 ; i < k ; i++ { //先收集前k个元素

               queue.push(nums[i])

           }

           res = append(res,queue.front()) //计算最大值

           for i := k ; i < len(nums) ; i++ {

               queue.pop(nums[i-k])  //将数组的元素从头pop出去

               queue.push(nums[i])  //从第k+1个元素开始push进来

               res = append(res,queue.front())  //每进行一次pop和push操作，计算一次最大值 

           }

           return res 

}