Task02 顺序表和链表

###顺序表和链表
了解顺序表和链表的概念，区别，实现方式，应用，基本操作，
优点，什么时候选用链表，什么时候选用顺序表

实现顺序表。 参照STL 中array， vector，
实现单链表、循环链表、双向链表。 参照STL中list， Forward_list
顺序表：数组实现； 链表：指针
单链表：每个节点只有一个指针，指向下一个节点
循环链表：尾节点指针指向头节点

双链表：每个节点含有两个指针，一个指向前驱，一个指向后继

1. 合并两个有序链表 leetcode 21 Easy
   将两个有序链表合并为一个新的有序链表并返回。新链表是通过拼接给定的两个链表的所有节点组成的。

示例：
输入：1->2->4, 1->3->4
输出：1->1->2->3->4->4

思路：若l1和l2都为空，返回NULL;
若l1和l2有一个为空，返回非空的；
若都不为空，每次从两个链表表头取一个节点比较，将val较小者尾插到新链表中。直到有一个链表为空，再将另一个链表链到新链表后.

/**
 * 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) {
        if(!l1 && !l2)   return NULL;
        if(!l1)  return l2;
        if(!l2)  return l1;

        ListNode * result = new ListNode(-1);
        ListNode *p = result;
        
        while(l1 && l2){
            if(l1->val < l2->val){
                p->val = l1->val;
                l1 = l1->next;
                if(l1 && l2){
                    p->next = new ListNode(-1);
                    p = p->next;
                }

            }else{
                p->val = l2->val;
                l2 = l2->next;
                if(l1 && l2){
                    p->next = new ListNode(-1);
                    p = p->next;
                }
            }
        } 


        if(l1)  p ->next= l1;

        if(l2)  p->next= l2;

        return result;
    }
};

2. 删除链表的倒数第N个节点 Leetcode 19 M
   给定一个链表，删除链表的倒数第 n 个节点，并且返回链表的头结点。
   示例：
   给定一个链表: 1->2->3->4->5, 和 n = 2.
   当删除了倒数第二个节点后，链表变为 1->2->3->5.

思路：两个指针，一个先到第n个，一个在头

ListNode* removeNthFromEnd(ListNode* head, int n) {
ListNode * head1 = new ListNode(-1);
ListNode * p1 = head1;
ListNode * p2 = head1;
head1->next = head;//防止删除头节点

    while(n--)
        p1 = p1->next;
    
    while(p1){
        if(!p1->next )    p2->next = p2->next->next;//删除
        else    p2 = p2->next;
        p1 = p1->next;
    }
    return head1->next;      
}

3. 旋转链表 Leetcode 61 M
给定一个链表，旋转链表，将链表每个节点向右移动 k 个位置，其中 k 是非负数。
示例 1:
输入: 1->2->3->4->5->NULL, k = 2
输出: 4->5->1->2->3->NULL
解释:
向右旋转 1 步: 5->1->2->3->4->NULL
向右旋转 2 步: 4->5->1->2->3->NULL
示例 2:
输入: 0->1->2->NULL, k = 4
输出: 2->0->1->NULL
解释:
向右旋转 1 步: 2->0->1->NULL
向右旋转 2 步: 1->2->0->NULL
向右旋转 3 步: 0->1->2->NULL
向右旋转 4 步: 2->0->1->NULL

思路：直接将后（Len - K%Len）个节点移到头节点前面
出现问题：边界

     ListNode* rotateRight(ListNode* head, int k) {

        if(!head) return head;
        if(k == 0)  return head;

        ListNode *p = head;
        ListNode *head1 = head;
        ListNode *q = NULL;//记录最后一个节点
        int Len = 0;

        while(p){
            Len++;
            q = p;
            p = p->next;
        }

        if(Len ==1 ) return head;

        int n = Len - k%Len;
        if(n == 0 || n ==Len)  return head;

        while(n--){
            p = head1;
            head1 = head1->next;
        }

        q->next = head;
        p->next = NULL;

        return head1;
    }