Leecode知识点

创建结构体指针：

　　var list *ListNode = &ListNode(0,head)

　　上面的写法等同于 list :=  &ListNode(0,head)

　　要想创建一个链表，首先要创建一个表头

　　num := new(ListNode)

　　然后将其进行数据赋值以及链接到下一个

　　middle := num  //这里对middle进行修改之后，本身的链表也会被修改，所以要保留头链表的链接

   　for i:=0;i<5;i++{

        　　middle.Next = &ListNode{Data: i}

      　　  middle = middle.Next

    }

我们要对链表进行删除操作时：

　　首先我们要复制它的头节点，然后再对复制之后的进行复制，以便进行操作

　　

　　p:=&ListNode{0,head}

    　current:=p

    　for i:=0;i<length-n;i++{

        　　current = current.Next

   　　 }

    　current.Next = current.Next.Next

在实现栈操作的时候，可以通过[]byte来实现

　　stack := []byte{}

真要实现栈操作的时候

//实现栈

type Stack struct{

    data []interface{}

}

//栈的长度

func (s *Stack) Len() int{

    return len(s.data)

}

//获取栈顶元素

func (s *Stack) Peek() interface{}{

    return s.data[len(s.data)-1]

}

//压入一个数据

func (s *Stack) Push(element interface{}){

    s.data = append(s.data, element)

}

//移除栈顶元素

func (s *Stack) Pop() interface{}{

    if len(s.data) == 0{

        return nil

    }

    res := s.data[len(s.data)-1]

    s.data = s.data[:len(s.data)-1]

    return res

}

 

 

关于最小堆的初始化（依据Leecode修改）

func mergeKLists(lists []*ListNode) *ListNode {
h := hp{}
for _, head := range lists {
if head != nil {
h = append(h, head)
}
}
heap.Init(&h) // 堆化(有了下面的方法函数这个方法才能使用）

dummy := &ListNode{} // 哨兵节点，作为合并后链表头节点的前一个节点
cur := dummy
for len(h) > 0 { // 循环直到堆为空
node := heap.Pop(&h).(*ListNode) // 剩余节点中的最小节点
if node.Next != nil { // 下一个节点不为空
heap.Push(&h, node.Next) // 下一个节点有可能是最小节点，入堆
}
cur.Next = node // 合并到新链表中
cur = cur.Next // 准备合并下一个节点
}
return dummy.Next // 哨兵节点的下一个节点就是新链表的头节点
}

type hp []*ListNode
func (h hp) Len() int { return len(h) }
func (h hp) Less(i, j int) bool { return h[i].Val < h[j].Val } // 最小堆
func (h hp) Swap(i, j int) { h[i], h[j] = h[j], h[i] }
func (h *hp) Push(v any) { *h = append(*h, v.(*ListNode)) }
func (h *hp) Pop() any { a := *h; v := a[len(a)-1]; *h = a[:len(a)-1]; return v }