labuladong算法day1链表7题

链表的定义
type ListNode struct{
	Val int
	Next *ListNode
}

21. 合并两个有序链表（模板）

将两个升序链表合并为一个新的 升序 链表并返回。新链表是通过拼接给定的两个链表的所有节点组成的。

func mergeTwoLists(l1 *ListNode, l2 *ListNode) *ListNode {
    // 虚拟头结点
    dummy := &ListNode{-1, nil}
    p := dummy
    p1 := l1
    p2 := l2
    
    for p1 != nil && p2 != nil {

        // 比较 p1 和 p2 两个指针
        // 将值较小的的节点接到 p 指针
        if p1.Val > p2.Val {
            p.Next = p2
            p2 = p2.Next
        } else {
            p.Next = p1
            p1 = p1.Next
        }
        // p 指针不断前进
        p = p.Next
    }
    
    if p1 != nil {
        p.Next = p1
    }
    
    if p2 != nil {
        p.Next = p2
    }
    
    return dummy.Next
}

86. 分隔链表

给你一个链表的头节点 head 和一个特定值 x ，请你对链表进行分隔，使得所有 小于 x 的节点都出现在 大于或等于 x 的节点之前。

你应当 保留 两个分区中每个节点的初始相对位置。

1、注意相等时赋值给p1还是p2
2、注意p指向next时，不能直接赋值
func partition(head *ListNode, x int) *ListNode {
    // 存放小于 x 的链表的虚拟头结点
    dummy1 := &ListNode{-1, nil}
    // 存放大于等于 x 的链表的虚拟头结点
    dummy2 := &ListNode{-1, nil}
    // p1, p2 指针负责生成结果链表
    p1, p2 := dummy1, dummy2
    // p 负责遍历原链表，类似合并两个有序链表的逻辑
    // 这里是将一个链表分解成两个链表
    p := head
    for p != nil {
        if p.Val >= x {
            p2.Next = p
            p2 = p2.Next
        } else {
            p1.Next = p
            p1 = p1.Next
        }
        // 不能直接让 p 指针前进，
        // p = p.Next
        // 断开原链表中的每个节点的 Next 指针
        temp := p.Next
        p.Next = nil
        p = temp
    }
    // 连接两个链表
    p1.Next = dummy2.Next

    return dummy1.Next
}

23. 合并K个升序链表

给你一个链表数组，每个链表都已经按升序排列。

请你将所有链表合并到一个升序链表中，返回合并后的链表。

示例 1：

输入：lists = [[1,4,5],[1,3,4],[2,6]]
输出：[1,1,2,3,4,4,5,6]
解释：链表数组如下：
[
1->4->5,
1->3->4,
2->6
]
将它们合并到一个有序链表中得到。
1->1->2->3->4->4->5->6

1.这里我们就要用到 优先级队列（二叉堆） 这种数据结构，把链表节点放入一个最小堆，就可以每次获得 k 个节点中的最小节点
2.先把每个链表头节点加入小根堆
3.找出最小元素，如果最小元素的next不为空，加入小根堆，直到小根堆元素为空结束。
/**
 * Definition for singly-linked list.
 * type ListNode struct {
 *     Val int
 *     Next *ListNode
 * }
 */
func mergeKLists(lists []*ListNode) *ListNode {
    if len(lists) == 0 {
        return nil
    }
    // 虚拟头结点
    dummy := &ListNode{-1, nil}
    p := dummy
    // 优先级队列，最小堆
    pq := make(PriorityQueue, 0)
    heap.Init(&pq)
    // 将 k 个链表的头结点加入最小堆
    for _, head := range lists {
        if head != nil {
            heap.Push(&pq, head)
        }
    }

    for pq.Len() > 0 {
        // 获取最小节点，接到结果链表中
        node := heap.Pop(&pq).(*ListNode)
        p.Next = node
        if node.Next != nil {
            heap.Push(&pq, node.Next)
        }
        // p 指针不断前进
        p = p.Next
    }
    return dummy.Next
}

type PriorityQueue []*ListNode

func (pq PriorityQueue) Len() int {
    return len(pq)
}

func (pq PriorityQueue) Less(i, j int) bool {
    return pq[i].Val < pq[j].Val
}

func (pq PriorityQueue) Swap(i, j int) {
    pq[i], pq[j] = pq[j], pq[i]
}

func (pq *PriorityQueue) Push(x interface{}) {
    node := x.(*ListNode)
    *pq = append(*pq, node)
}

func (pq *PriorityQueue) Pop() interface{} {
    old := *pq
    n := len(old)
    node := old[n-1]
    *pq = old[0 : n-1]
    return node
}

//时间复杂度：O(nlog⁡k)\mathcal{O}(n\log k)O(nlogk)，其中 kkk 为 lists\textit{lists}lists 的长度，nnn 为所有链表的节点数之和。
//空间复杂度：O(k)\mathcal{O}(k)O(k)。堆中至多有 kkk 个元素。

获取单链表倒数第K个节点（模板）

1.快慢指针
2.p1指针先走k步
3.走完k步p2指针再走，终止条件
func findFromEnd(head *ListNode, k int) *ListNode {
    p1 := head
    // p1 先走 k 步
    for i := 0; i < k; i++ {
        p1 = p1.Next
    }
    p2 := head
    // p1 和 p2 同时走 n - k 步
    for p1 != nil {
        p1 = p1.Next
        p2 = p2.Next
    }
    // p2 现在指向第 n - k + 1 个节点，即倒数第 k 个节点
    return p2
}

19. 删除链表的倒数第 N 个结点

1.涉及删除操作需要添加头节点
2.删除倒数第k个节点，需要先找到倒数第k+1个节点
func removeNthFromEnd(head *ListNode, n int) *ListNode {
    // 虚拟头结点
    dummy := &ListNode{-1, head}
    // 删除倒数第 n 个，要先找倒数第 n + 1 个节点
    x := findFromEnd(dummy, n + 1)
    // 删掉倒数第 n 个节点
    x.next = x.next.next
    return dummy.next
}
func findFromEnd(head *ListNode, k int) *ListNode{
    p1 := head 
    for i:=0 ;i<k; i++{
        p1 =p1.Next
    }
    p2 := head
    for p1!= nil{
        p1= p1.Next
        p2 = p2.Next
    }
    return p2
}

876. 链表的中间结点

1.每当慢指针 slow 前进一步，快指针 fast 就前进两步，这样，当 fast 走到链表末尾时，slow 就指向了链表中点。
2.注意for循环的判定条件
3.如果链表长度为偶数，也就是说中点有两个的时候，我们这个解法返回的节点是靠后的那个节点。
func middleNode(head *ListNode) *ListNode {
    // 快慢指针初始化指向 head
    slow, fast := head, head
    // 快指针走到末尾时停止
    for fast != nil && fast.Next != nil {
        // 慢指针走一步，快指针走两步
        slow = slow.Next
        fast = fast.Next.Next
    }
    // 慢指针指向中点
    return slow
}

判断链表是否包含环

1.如果 fast 最终能正常走到链表末尾，说明链表中没有环；如果 fast 走着走着竟然和 slow 相遇了，那肯定是 fast 在链表中转圈了，说明链表中含有环
func hasCycle(head *ListNode) bool {
    // 快慢指针初始化指向 head
    slow, fast := head, head
    // 快指针走到末尾时停止
    for fast != nil && fast.Next != nil {
        // 慢指针走一步，快指针走两步
        slow = slow.Next
        fast = fast.Next.Next
        // 快慢指针相遇，说明含有环
        if slow == fast {
            return true
        }
    }
    // 不包含环
    return false
}

142.环形链表

如果链表中含有环，如何计算这个环的起点？

1.快慢指针，slow走一步，fast走两步，相遇后重置slow = head，slow、fast各走一步直到相遇
2.注意判定条件
func detectCycle(head *ListNode) *ListNode {
    fast, slow := head, head
    for fast != nil && fast.Next != nil {
        fast = fast.Next.Next
        slow = slow.Next
        if fast == slow {
            break

        }
    }
    if fast == nil || fast.Next == nil {
        return nil
    }
    slow = head
    for slow != fast {
        slow = slow.Next
        fast = fast.Next
    }
    return slow
}

160.相交链表

1.因为两个链表起始长度不同，p1走到nil走p2，p2走到nil走p1
2.如果有相同节点就是交点，如果为nil则没有交点
3.for循环判定条件、if判定条件

func getIntersectionNode(headA *ListNode, headB *ListNode) *ListNode {
    // p1 指向 A 链表头结点，p2 指向 B 链表头结点
    p1, p2 := headA, headB
    for p1 != p2 {
        // p1 走一步，如果走到 A 链表末尾，转到 B 链表
        if p1 == nil {
            p1 = headB
        } else {
            p1 = p1.Next
        }
        // p2 走一步，如果走到 B 链表末尾，转到 A 链表
        if p2 == nil {
            p2 = headA
        } else {
            p2 = p2.Next
        }
    }
    return p1
}
//空间复杂度为 O(1)，时间复杂度为 O(N)