LeetCode Merge Two Sorted Lists

class Solution {
public:
    ListNode *mergeTwoLists(ListNode *l1, ListNode *l2) {
        ListNode* p = l1;
        ListNode* q = l2;
        ListNode* head = NULL;
        ListNode* tail = NULL;
        ListNode* node = NULL;
        
        while (p != NULL && q != NULL) {
            if (p->val <= q->val) {
                node = p;
                p = p->next;
            } else {
                node = q;
                q = q->next;
            }
            add_node(head, tail, node);        
        }
        while (p != NULL) {
            add_node(head, tail, p);
            p = p->next;
        }
        while (q != NULL) {
            add_node(head, tail, q);
            q = q->next;
        }
        return head;
    }

    void add_node(ListNode* &head, ListNode* &tail, ListNode* node) {
        if (head == NULL) {
            head = node;
            tail = node;
        } else {
            tail->next = node;
            tail = node;
        }
    }
};

水一发

第二轮：

Merge two sorted linked lists and return it as a new list. The new list should be made by splicing together the nodes of the first two lists.

最后可以直接黏贴剩余链表，不用一个一个在转移了

/**
 * Definition for singly-linked list.
 * public class ListNode {
 *     int val;
 *     ListNode next;
 *     ListNode(int x) {
 *         val = x;
 *         next = null;
 *     }
 * }
 */
public class Solution {
    public ListNode mergeTwoLists(ListNode l1, ListNode l2) {
        if (l1 == null || l2 == null) {
            return l1 == null ? l2 : l1;
        }
        ListNode head = null;
        ListNode prev = null;
        ListNode h1 = l1;
        ListNode h2 = l2;
        while (h1 != null && h2 != null) {
            ListNode append = null;
            if (h1.val <= h2.val) {
                append = h1;
                h1 = h1.next;
            } else {
                append = h2;
                h2 = h2.next;
            }
            append.next = null;
            if (head == null) {
                head = append;
                prev = append;
            } else {
                prev.next = append;
                prev = append;
            }
        }
        ListNode last = null;
        if (h1 != null) {
            last = h1;
        }
        if (h2 != null) {
            last = h2;
        }
        if (prev != null) {
            prev.next = last;
        }
        return head;
    }
}

 看了一下参考，加入一个空链表头的话可以省去许多对空值的判断处理：

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode(int x) : val(x), next(NULL) {}
 * };
 */
class Solution {
public:
    ListNode *mergeTwoLists(ListNode *l1, ListNode *l2) {
        ListNode holder(0);
        ListNode* prev = &holder;
        while (l1 != NULL && l2 != NULL) {
            if (l1->val <= l2->val) {
                prev->next = l1;
                l1 = l1->next;
            } else {
                prev->next = l2;
                l2 = l2->next;
            }
            prev = prev->next;
        }
        if (l1 != NULL) {
            prev->next = l1;
        }
        if (l2 != NULL) {
            prev->next = l2;
        }
        return holder.next;
    }
};