算法第五周解题报告

21. Merge Two Sorted Lists

问题描述：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.

解题思路：简单题，设置两个指针再链表上移动，每次将链表顶端的较小的元素取出接到新链表上即可。

代码如下：

class Solution {public:    ListNode* mergeTwoLists(ListNode* l1, ListNode* l2) {        ListNode *res(NULL);        ListNode *cur(NULL);        ListNode* l1Cur(l1), *l2Cur(l2);        res = new ListNode(-1);        cur = res;        while (l1Cur != NULL && l2Cur != NULL){            ListNode *tmp = new ListNode(-1);            tmp -> next = NULL;            tmp -> val = (l1Cur -> val < l2Cur -> val ? l1Cur -> val : l2Cur -> val);            ListNode *s1 = l1Cur;            l1Cur = (l1Cur -> val < l2Cur -> val ? l1Cur -> next : l1Cur);            l2Cur = (s1 -> val < l2Cur -> val ? l2Cur : l2Cur -> next);            cur -> next = tmp;            cur = cur -> next;        }        if(l1Cur != NULL){            cur -> next = l1Cur;        }        if(l2Cur != NULL){            cur -> next = l2Cur;        }        res = res -> next;        return res;    }};

结果如下：

23. Merge k Sorted Lists

题目描述：Merge k sorted linked lists and return it as one sorted list. Analyze and describe its complexity.

解题思路：解题思路同上题，只是一个简单的扩展而已。一个小技巧是当一个链表遍历完了就将它移除向量。

代码如下：

class Solution {public:    ListNode* mergeKLists(vector<ListNode*>& lists) {        for(int i = 0; i < lists.size(); ++i){            if(lists[i] == NULL){                int j = lists.size() - 1;                while(lists[j] == NULL && j > i){                    lists.pop_back();                    --j;                }                if (lists[j] == NULL){                    lists.pop_back();                } else{                    lists[i] = lists[j];                    lists.pop_back();                }            }        }        if(lists.size() == 0) return NULL;                ListNode *res = new ListNode(-1);        ListNode *curP = res;        while (lists.size() != 1){            ListNode *tmp = NULL;            int index = -1;            int min = 0;            for(int i = 0; i < lists.size(); ++i){                if(index == -1 || min > lists[i] -> val){                    min = lists[i] -> val;                    index = i;                }            }            tmp = new ListNode(-1);            tmp -> val = lists[index] -> val;            curP -> next = tmp;            curP = curP -> next;            lists[index] = lists[index] -> next;            if(lists[index] == NULL){                lists[index] = lists[lists.size() - 1];                lists.pop_back();            }        }        curP -> next = lists[0];        return res -> next;    }};

结果如下：

24. Swap Nodes in Pairs

题目描述：

Given a linked list, swap every two adjacent nodes and return its head.

For example,
Given 1->2->3->4, you should return the list as 2->1->4->3.

Your algorithm should use only constant space. You may not modify the values in the list, only nodes itself can be changed.

解题思路：

设置前后两个相邻指针即可，需要注意的是指针是否已经达到了链表尾

代码如下：

class Solution {public:    ListNode* swapPairs(ListNode* head) {        ListNode *pre(NULL), *back(NULL), *left(head), *right(NULL);        if(left != NULL) right = left -> next;        while(left != NULL && right != NULL){            ListNode *preLNext(left -> next), * preRNext(right -> next);            right -> next = left;            left -> next = preRNext;            if(pre != NULL){                pre -> next = right;            } else {                head = right;            }            //move forward            pre = left;            left = left -> next;            if(left != NULL){                right = left -> next;            }        }        return head;    }};

结果如下：

138. Copy List with Random Pointer

题目描述：

A linked list is given such that each node contains an additional random pointer which could point to any node in the list or null.

Return a deep copy of the list.

解题思路：这一题是真正比较需要技巧的题目。

本人使用的技巧是：假设被复制的链表为L1， 生成的链表为L2。

将L1的每个节点的地址记录在数组当中；

将L1每个节点的next指向res中对应的节点，构成一个一一对应关系。

对于res中的每个节点，res -> randomP = L1 -> randomP -> next

最后根据数组将L1复原。

代码如下：

class Solution {public:    RandomListNode *copyRandomList(RandomListNode *head) {        if(head == NULL) return NULL;        vector<RandomListNode*> precord;        RandomListNode *res(NULL), *recordH(head), *recordR;        res = new RandomListNode(-1);        recordR = res;        while(recordH != NULL){            precord.push_back(recordH);            RandomListNode *tmp = new RandomListNode(-1), *tmp1 = recordH;            tmp -> label = recordH -> label;            tmp -> random = recordH -> random;            recordH = recordH -> next;            recordR -> next = tmp;            recordR = recordR -> next;            tmp1 -> next = recordR;        }        recordR = res -> next;        while(recordR != NULL){            if(recordR -> random != NULL)                recordR -> random = recordR -> random -> next;            recordR = recordR -> next;        }        for(int i = 0; i < precord.size() - 1; ++i){            precord[i] -> next = precord[i + 1];        }        precord[precord.size() -1] -> next = NULL;        return res -> next;    }};

结果如下：