LintCode刷题阶段性总结---链表容易篇(翻转链表，删除链表重复元素，合并两个排序链表等)

为啥我觉得链表好难！！果然指针还是难啊，有了思路写出代码来动不动内存崩溃....容易篇我也只有几题会做，其他全部参考网上的...现在稍微总结巩固一下！

在Lintcode上筛选容易，链表就会出来这些题，一共10道。

链表定义为：

/** * Definition of ListNode * class ListNode { * public: *     int val; *     ListNode *next; *     ListNode(int val) { *         this->val = val; *         this->next = NULL; *     } * } */

只要头结点给出，就可以访问链表的任何一个节点。链表建立在自由存储区，因为每个节点都存储着下一个节点的地址，所以链表不需要连续的内存，可以动态建立。删除某个节点，只要给出节点，可以在O(1)时间内完成。

一、两两交换链表中的节点

这题比较简单，一开始我想的很复杂以为指针域也要交换，但是看到挑战里面才要求交换指针域，才想到可以简单的通过交换节点中的值完成。

(1)遍历链表，将值push到一个vector中

(2)将vector元素两两交换

(3)再重新赋给链表的每一个节点

代码如下：

class Solution {public:    /*     * @param head: a ListNode     * @return: a ListNode     */     void swap(int &a,int &b)     {         int temp;         temp=a;         a=b;         b=temp;     }    ListNode * swapPairs(ListNode * head) {        // write your code here       if(head==NULL||head->next==NULL) return head;        ListNode*temp=head;        vector<int>data;        while(temp!=NULL)        {            data.push_back(temp->val);            temp=temp->next;        }        for(int i=0;i<data.size()-1;i=i+2)        {            swap(data[i],data[i+1]);        }        temp=head;        int i=0;        while(temp!=NULL)        {            temp->val=data[i];            i++;            temp=temp->next;                    }        return head;    }};

二、在O(1)时间内删除链表节点

考虑基础情况，如果所删除链表为空，那么返回。如果不为空，则将该节点下一节点的数据和指针都赋值给当前节点。

class Solution {public:    /**     * @param node: a node in the list should be deleted     * @return: nothing     */    void deleteNode(ListNode *node) {        // write your code here        if(node->next==NULL)            return;        ListNode*nodeNEXT=node->next;        node->val=nodeNEXT->val;        node->next=nodeNEXT->next;    }};

三、删除链表中倒数第n个节点/返回链表中倒数第n个节点

这两题相似，只是前者比后者多一个步骤，我就放在一起了。

首先看找到倒数第n个节点。

(1)只需要对链表进行两次遍历，第一次遍历找到链表的长度length，则倒数第n个节点的索引等于length+1-n。

class Solution {public:    /*     * @param head: The first node of linked list.     * @param n: An integer     * @return: Nth to last node of a singly linked list.      */    ListNode * nthToLast(ListNode * head, int n) {        // write your code here        if(head==NULL||n==0) return NULL;        int length=0;        ListNode*temp=head->next;        while(temp!=NULL)        {            length++;            temp=temp->next;        }        int index=length+1-n;        temp=head;        for(int i=0;i<index;i++)        {            temp=temp->next;        }        return temp;    }};

(2)在上面找到倒数第n个节点的基础上，删除之。删除该节点，主要是要找到该节点前面一个节点

class Solution {public:    /**     * @param head: The first node of linked list.     * @param n: An integer.     * @return: The head of linked list.     */    ListNode *removeNthFromEnd(ListNode *head, int n) {        // write your code here        if(head==NULL||n==0) return NULL;                int length=0;        ListNode*temp=head->next;        while(temp!=NULL)        {            length++;            temp=temp->next;        }        int index=length+1-n;        ListNode*temq=head;        temp=head->next;        for(int i=1;i<index;i++)        {            temq=temp;            temp=temp->next;        }        if(temq==head)        {            head=head->next;        }        else        {            temq->next=temp->next;        }        return head;            }};

四、合并两个排序链表

因为是排序链表，所以思路如下：

建立一个新链表，遍历所给的两个链表，当链表不为空时：

如果l1的值小于l2的值，就把l1的挂在新建的链表后面，反之则把l2挂在新建的链表后面。

最后，如果l1已经空了，则把l2挂在新建链表后面，反之则挂l1。

代码如下:

ListNode *mergeTwoLists(ListNode *l1, ListNode *l2) {        // write your code here        ListNode*result=new ListNode(0);        ListNode*temp=result;        while(l1!=NULL&&l2!=NULL)        {            if(l1->val<=l2->val)            {                temp->next=l1;                l1=l1->next;                temp=temp->next;            }            else            {                temp->next=l2;                l2=l2->next;                temp=temp->next;            }        }        if(l1==NULL)            temp->next=l2;        else            temp->next=l1;        return result->next;    }     

五、链表插入排序(个人认为这道题有点难度= =)

样例:Given 1->3->2->0->null, return 0->1->2->3->null

思路是遍历整个链表，然后寻找每个元素的插入点，主要考察的是链表的遍历和插入操作。

 ListNode *insertionSortList(ListNode *head) {        // write your code here        if(!head)              return NULL;          ListNode *result=new ListNode(0);              ListNode *temp=NULL;                    while(head)        {                  temp=result;  //temp指向result的头节点              ListNode *next=head->next;              while(temp->next!=NULL&&temp->next->val<head->val)//寻找插入点             {                  temp=temp->next;             }            head->next=temp->next;                temp->next=head;              head=next;          }          temp=result;          result=result->next;          return result;      }

六、翻转链表

面试常考题，主要考察对于指针的操作。对于头结点之后的每一个节点，都要连接到头结点的前面,需要三个工作指针，当前节点指针，当前节点的前一个指针，当前节点的后一个指针。

ListNode * reverse(ListNode * head) {        // write your code here        if(head==NULL||head->next==NULL) return head;        ListNode*temp=head;//当前节点指针，从头结点开始;        ListNode*pre=NULL;//当前节点的前一个指针        ListNode*post=NULL;//当前节点的后一个指针        while(temp!=NULL)        {            post=temp->next;//将当前节点的下一个节点保存，因为等会要把前节点指向它了            temp->next=pre;//将当前节点指向pre节点            pre=temp;//更新前节点            temp=post;//更新当前节点        }        return pre;    }

七、删除排序链表中的重复元素

对于排序链表，要抓住结构，重复元素肯定是相邻的。所以用两个工作指针，temq指向temp的前一个，如果相同，则删除temp,temp后移且再判断，如果不同，temq和temp同时后移。

 ListNode *deleteDuplicates(ListNode *head) {        // write your code here        if(head==NULL||head->next==NULL) return head;        ListNode*temq=head;        ListNode*temp=head->next;        while(temp!=NULL)        {            if(temq->val!=temp->val)            {                temq=temp;                temp=temp->next;            }            else            {                temq->next=temp->next;                temp=temp->next;            }        }        return head;    }

八、链表划分

这题存在争议，给出的样例如下：

给定链表 1->4->3->2->5->2->null，并且 x=3

返回 1->2->2->4->3->5->null

描述是把比3小的节点全部分到3的左边，而比3大的全部分到3的右边，但是上例显然是没有完成的...我不太懂为什么。

比较简单的思路是建立左右两个链表，再遍历原链表，比x小的放到左链表，比x大的放到右链表，最后把左右链表连起来就ok了。

ListNode * partition(ListNode * head, int x) {        // write your code here          if (head == NULL)           {            return NULL;        }        ListNode*leftList = new ListNode(0);        ListNode*rightList = new ListNode(0);        ListNode*left = leftList;        ListNode*right = rightList;        while (head != NULL)         {            if (head->val < x)             {                left->next = head;                left = head;            }             else             {                right->next = head;                right = head;            }            head = head->next;        }        right->next = NULL;        left->next = rightList->next;        return leftList->next;    }

九、链表求和(这题我感觉也挺难的)

给出两个链表 3->1->5->null 和 5->9->2->null，返回 8->0->8->null

你有两个用链表代表的整数，其中每个节点包含一个数字。数字存储按照在原来整数中相反的顺序，使得第一个数字位于链表的开头。写出一个函数将两个整数相加，用链表形式返回和。


看到这题，我一开始的思路是遍历两个链表，把链表中的数取到vector中，再把vector中的数转换为整数，再相加，最后再生成新的链表。但是写好代码提交后提示MLE(内存限制错误),Lintcode没法调试，就弃疗上网找参考了= =主要考察了有进位，且l1和l2不一样长的情况，以及最后一位可能有进位的情况，再加上最后一步翻转链表(见第六题)

 ListNode *addLists(ListNode *l1, ListNode *l2) {        // write your code here        int carry = 0;        ListNode *head = NULL, *p;        while (l1 && l2)         {            int sum = l1->val + l2->val + carry;//最开始算的是低位，第一次进位为0            int remain = sum % 10;//比方513+295，最低位得到的结果应该是(5+3),因为超过10部分要进位            carry = sum / 10;//保存这一步的进位，带到下一次            p = new ListNode(remain);            p->next = head;            head = p;            l1 = l1->next;            l2 = l2->next;        }        while (l1) //如果l1比l2长，这个循环和下面那个循环只可能进入一个        {            int sum = l1->val + carry;//保留上一循环中carry最后的值            int remain = sum % 10;            carry = sum / 10;            p = new ListNode(remain);            p->next = head;            head = p;            l1 = l1->next;        }        while (l2) //如果l2比l1长        {            int sum = l2->val + carry;            int remain = sum % 10;            carry = sum / 10;            p = new ListNode(remain);            p->next = head;            head = p;            l2 = l2->next;        }        if (carry) //如果加到最后一位还有carry，那么只有这个进位了        {            p = new ListNode(carry);            p->next = head;            head = p;        }        if (head) //如果上面步骤成功，那么需要翻转一下链表        {            head=reverse(head);        }        return head;    }

好了，这次链表容易篇总结到此结束，数组容易篇也刷完了，下次有时间总结。