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;
    }

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