leetcode 24. Swap Nodes in Pairs \ 21. Merge Two Sorted Lists

24. swap nodes in pairs

这个算法就是把前后节点交换为知，记住每个节点存储在内存中某个地方，指向每个节点的地址是一样，不一样的是每个节点的下一个节点的地址，改变这个即可。

法一：

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode(int x) : val(x), next(NULL) {}
 * };
 */
class Solution {
public:
    ListNode* swapPairs(ListNode* head) {
        ListNode *node_walker = head;
        ListNode *node_next = NULL;
        ListNode *node_cur = NULL;
        ListNode *node_pre= NULL;
        ListNode *node_next2 = NULL;

        while(node_walker && node_walker->next)
        {
            node_next = node_walker->next;
            node_next2 = node_next->next;
            node_cur = node_walker;


            if(node_walker == head)
            {
                head = node_next;
                head->next = node_cur;
                node_cur->next = node_next2;
            }
            else
            {
                node_pre->next = node_next;
                node_walker->next = node_next2;
                node_next->next = node_walker;
            }

            node_pre = node_walker;
            node_walker = node_next2;
        }

        return head;
    }
};

法二：
上面的算法可以写得更加简洁，那就是：
这里有一个巧妙的用法就是它索引指向指针的指针，然后修改这个指针的话就会使得值的赋值过程减少一个阻碍。

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode(int x) : val(x), next(NULL) {}
 * };
 */
class Solution {
public:
    ListNode* swapPairs(ListNode* head) {

        ListNode **head_new = &head, *node_cur = NULL, *node_next = NULL;

        while ((node_cur = *head_new) && (node_next = node_cur->next)) {
            node_cur->next = node_next->next;
            node_next->next = node_cur;
            *head_new = node_next;
            head_new = &(node_cur->next);
        }

        return head;
    }
};

21. Merge Two Sorted Lists

法一：

/**
 * 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 *head = NULL;
        ListNode *tmp = NULL;

        while(l1 != NULL && l2 != NULL)
        {
            if(l1->val <= l2->val)
            {
                if(!head)
                {
                    head = l1;
                    tmp = head;
                }    
                else
                {
                    tmp->next = l1;
                    tmp = l1;
                }    
                l1 = l1->next;
            }
            else
            {
                if(!head)
                {
                    head = l2;
                    tmp = head;
                }    
                else
                {
                    tmp->next = l2;
                    tmp = l2;
                }    
                l2 = l2->next;
            }
            if(!l1)
            {
                tmp->next = l2;
                break;
            }
            if(!l2)
            {
                tmp->next = l1;
                break;
            }
        }

        head = (head == NULL)?((l1 == NULL)?l2:l1):head;

        return head;
    }
};

法二：
精简版：

class Solution {
public:
    ListNode *mergeTwoLists(ListNode *l1, ListNode *l2) {
        ListNode dummy(INT_MIN);
        ListNode *tail = &dummy;

        while (l1 && l2) {
            if (l1->val < l2->val) {
                tail->next = l1;
                l1 = l1->next;
            } else {
                tail->next = l2;
                l2 = l2->next;
            }
            tail = tail->next;
        }

        tail->next = l1 ? l1 : l2;
        return dummy.next;
    }
};