Page Comparison

/**
 * Definition for singly-linked list.
 * type ListNode struct {
 *     Val int
 *     Next *ListNode
 * }
 */
func mergeTwoLists(list1 *ListNode, list2 *ListNode) *ListNode {
    dummy := &ListNode{}
    p := dummy
    
    p1 := list1
    p2 := list2
    
    for p1 != nil && p2 != nil {
        if p1.Val < p2.Val {
            p.Next = p1
            p1 = p1.Next
            p = p.Next
        } else {
            p.Next = p2
            p2 = p2.Next
            p = p.Next
        }
    }
    
    if p1 != nil {
        p.Next = p1
    }
    
    if p2 != nil {
        p.Next = p2
    }
    
    return dummy.Next
}

/**
 * Definition for singly-linked list.
 * type ListNode struct {
 *     Val int
 *     Next *ListNode
 * }
 */
func partition(head *ListNode, x int) *ListNode {
    dummy1 := &ListNode{}
    dummy2 := &ListNode{}
    p1 := dummy1
    p2 := dummy2
    
    
    for p := head; p != nil; p = p.Next {
        if p.Val < x {
            p1.Next = p
            p1 = p1.Next
        } else {
            p2.Next = p
            p2 = p2.Next
        }
    }
    
    p1.Next = dummy2.Next
    p2.Next = nil
    
    return dummy1.Next
}

/**
 * Definition for singly-linked list.
 * type ListNode struct {
 *     Val int
 *     Next *ListNode
 * }
 */
func mergeKLists(lists []*ListNode) *ListNode {
    dummy := &ListNode{}
    p := dummy
    
    pq := &NodeHeap{}
    for _, l := range lists {
        if l != nil {
            heap.Push(pq, l)
        }
    }
    
    for pq.Len() != 0 {
        v := heap.Pop(pq).(*ListNode)
        p.Next = v
        p = p.Next
        
        if v.Next != nil {
            heap.Push(pq, v.Next)
        }
    }
    
    return dummy.Next
}

type NodeHeap []*ListNode

func (h NodeHeap) Len() int {
    return len(h)
}
func (h NodeHeap) Swap(i, j int) {
    h[i], h[j] = h[j], h[i]
}
func (h NodeHeap) Less(i, j int) bool {
    return h[i].Val < h[j].Val
}

func (h *NodeHeap) Push(x any) {
    *h = append(*h, x.(*ListNode))
}
func (h *NodeHeap) Pop() any {
    n := len(*h)
    
    v := (*h)[n-1]
    *h = (*h)[:n-1]
    
    return v
}

/**
 * Definition for singly-linked list.
 * type ListNode struct {
 *     Val int
 *     Next *ListNode
 * }
 */
func removeNthFromEnd(head *ListNode, n int) *ListNode {
    dummy := &ListNode{Next: head}
    
    prev := findFromEnd(dummy, n+1)
    prev.Next = prev.Next.Next
    
    return dummy.Next
}

func findFromEnd(head *ListNode, n int) *ListNode {
    p1 := head
    
    p2 := head
    for i := 0; i < n; i++ {
        p2 = p2.Next
    }
    
    for p2 != nil {
        p2 = p2.Next
        p1 = p1.Next
    }
    
    return p1
}

/**
 * Definition for singly-linked list.
 * type ListNode struct {
 *     Val int
 *     Next *ListNode
 * }
 */
func deleteMiddle(head *ListNode) *ListNode {
    slow := head
    fast := head
    
    prev := (*ListNode)(nil)
    for fast != nil && fast.Next != nil {
        prev = slow
        slow = slow.Next
        fast = fast.Next.Next
    }
    
    if prev == nil { // only one node
        return nil
    }
    
    prev.Next = prev.Next.Next
    return head
}

/**
 * Definition for singly-linked list.
 * type ListNode struct {
 *     Val int
 *     Next *ListNode
 * }
 */
func hasCycle(head *ListNode) bool {
    slow := head
    fast := head
    
    for fast != nil && fast.Next != nil {
        slow = slow.Next
        fast = fast.Next.Next
        
        if slow == fast {
            return true
        }
    }
    
    return false
}