【LeetCode】链表数据整理

两数相加

func sum(l1, l2 *ListNode) *ListNode {
    if li == nil && l2 == nil {
        return nil
    }
    dummy := new(ListNode)
    curr, value := dummy, 0
    for l1 != nil || l2!= nil || value > 0 {
        curr.Next = new(ListNode)
        curr = curr.Next
        if l1 != nil {
            value += l1.Value
            l1 = l1.Next
        }
        
        if l2 != nil {
            value += l2.Value
            l2 = l2.Next
        }
        
        curr.Value = value % 10
        value = value/10
    }
    return dummy.Next
}

倒转链表

// Solution1
func ret(head *ListNode) *ListNode {
    if head == nil {
        return head
    }
    
    var prev *ListNode = nil
    curr := prev 
    for curr != nil {
         tmp := curr.Next
        curr.Next = prev
        prev = curr
        curr = tmp
    }
    
    return prev
}

---

// Solution2
func ret(head *ListNode) *ListNode {
    if head == nil || head.Next == nil {
        return head
    }
    
    re := ret(head.Next)
    head.Next.Next = head
    head.Next = nil
    return re
}

 

 

合并排序链表

func mergeTwoLists(l1 *ListNode, l2 *ListNode) *ListNode {
    head := new(ListNode)
    res := head
    for l1 != nil && l2 != nil {
        if l1.Val > l2.Val {
            head.Next = l2
            l2 = l2.Next
        } else {
            head.Next = l1
            l1 = l1.Next
        }
        head = head.Next
    }
    
	if l1 == nil {
		head.Next = l2
	} else {
		head.Next = l1
	}
    
    
    return res.Next
}

快慢指针

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

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

        fast = fast.Next.Next
        slow = slow.Next
    }

    return true
}