1.给你单链表的头节点 head ，请你反转链表，并返回反转后的链表。
示例1:
输入：head = [1,2,3,4,5]
输出：[5,4,3,2,1]

package main

import “fmt”

type ListNode struct {
Val int
Next *ListNode
}

func main() {
l1 := &ListNode{Val: 1}
l2 := &ListNode{Val: 2}
l3 := &ListNode{Val: 3}
l4 := &ListNode{Val: 4}
l5 := &ListNode{Val: 5}
l1.Next = l2
l2.Next = l3
l3.Next = l4
l4.Next = l5
newlist := reverseList(l1)
for newlist != nil {
fmt.Print(newlist.Val)
if newlist.Next != nil {
fmt.Print(“,”)
}
newlist = newlist.Next
}
fmt.Println()
}

func reverseList(head *ListNode) *ListNode {
if head == nil || head.Next == nil {
return head
}
var prev *ListNode
cur := head
for cur != nil {
cur.Next, prev, cur = prev, cur, cur.Next
}
return prev
}

2.给你一个整数数组 nums 和一个整数 k 。你需要找到 nums 中长度为 k 的 子序列 ，且这个子序列的 和最大 。
请你返回 任意 一个长度为 k 的整数子序列。
子序列 定义为从一个数组里删除一些元素后，不改变剩下元素的顺序得到的数组。
示例1:
输入：nums = [2,1,3,3], k = 2
输出：[3,3]
示例2:
输入：nums = [-1,-2,3,4], k = 3
输出：[-1,3,4]
示例3:
输入：nums = [3,4,3,3], k = 2
输出：[3,4]
package main

import (
“fmt”
“sort”
“strconv”
“strings”
)

func main() {
//nums := []int{2, 1, 3, 3}
//k := 2
nums := []int{-1, -2, 3, 4}
k := 3
newSlice := SearchMaxSlice(nums, k)
fmt.Println(newSlice)
}

func SearchMaxSlice(nums []int, k int) []int {
n := len(nums)
temp := make([]int, n)
copy(temp, nums)
sort.Slice(temp, func(i, j int) bool {
return temp[i] > temp[j]
})
newtemp := temp[:k]
newslice := []int{}
newslicestr := fmt.Sprint(newtemp)
for _, v := range nums {
if len(newslice) == k {
break
}
if strings.Contains(newslicestr, strconv.Itoa(v)) {
newslice = append(newslice, v)
}
}
return newslice
}

3.给你一个整数数组 nums 和一个整数 k ，请你统计并返回 该数组中和为 k 的子数组的个数 。
子数组是数组中元素的连续非空序列。
示例1:
输入：nums = [1,1,1], k = 2
输出：2
示例2:
输入：nums = [1,2,3], k = 3
输出：2

func main() {
//slic := []int{1, 1, 1}
slic := []int{1, 2, 3}
k := 3
fmt.Println(calSliceCount(slic, k))
}

func calSliceCount(nums []int, k int) int {
count := 0
for i := 0; i < len(nums); i++ {
sum := 0
for j := i; j < len(nums); j++ {
sum += nums[j]
if sum == k {
count++
}
}
}
return count
}