两数相加与反转链表

题目1 两数链表相加

给你两个 非空 的链表，表示两个非负的整数。它们每位数字都是按照 逆序 的方式存储的，并且每个节点只能存储 一位 数字。

请你将两个数相加，并以相同形式返回一个表示和的链表。

你可以假设除了数字 0 之外，这两个数都不会以 0 开头。

代码1

/**
 * Definition for singly-linked list.
 * type ListNode struct {
 *     Val int
 *     Next *ListNode
 * }
 */
func addTwoNumbers(l1 *ListNode, l2 *ListNode) *ListNode {
    tmp, num := 0, 0
    res := &ListNode{
        Val: 0,
        Next: nil,
    }
    midNode := res
    num = l1.Val + l2.Val + tmp
    tmp = num/10
    num = num%10
    res.Val = num
    l1=l1.Next
    l2=l2.Next
    for ;l1!=nil || l2!=nil; {
        if l1!= nil && l2 != nil {
            num = l1.Val + l2.Val + tmp
        } else if l1 != nil {
            num = l1.Val + tmp
        } else {
            num = l2.Val + tmp
        }
        tmp = num/10
        num = num%10
        
        tmpNode := &ListNode{
            Val: 0,
            Next: nil,
        }
        midNode.Next = tmpNode
        midNode = midNode.Next
        midNode.Val = num
        if l1 != nil {
            l1=l1.Next
        }
        if l2 != nil {
            l2=l2.Next
        }
        
    }
    if tmp != 0 {
         tmpNode := &ListNode{
            Val: 0,
            Next: nil,
        }
        midNode.Next = tmpNode
        midNode = midNode.Next
        midNode.Val = tmp
    }
    return res
}

题目2 反转单向链表

定义一个函数，输入一个链表的头节点，反转该链表并输出反转后链表的头节点。

代码2

/**
 * Definition for singly-linked list.
 * type ListNode struct {
 *     Val int
 *     Next *ListNode
 * }
 */
func reverseList(head *ListNode) *ListNode {
    if head == nil {
        return head
    }
    pre := &ListNode{}
    pre = nil
    pCu := head
    pN := head.Next
    for ;pCu.Next != nil; {
        pCu.Next = pre
        pre = pCu
        pCu = pN
        pN = pN.Next
    }
    pCu.Next = pre
    return pCu
}

补充代码：
func reverseList(head *ListNode) *ListNode {
    if head == nil {
        return head
    }
    var pre *ListNode
    for head != nil {
        head.Next, head, pre = pre, head.Next, head             
    }
    return pre
}