【HOT100第六天】环形链表,环形链表 II,合并两个有序链表,两数相加

 141. 环形链表

给你一个链表的头节点 head ，判断链表中是否有环。

如果链表中有某个节点，可以通过连续跟踪 next 指针再次到达，则链表中存在环。 为了表示给定链表中的环，评测系统内部使用整数 pos 来表示链表尾连接到链表中的位置（索引从 0 开始）。注意：pos 不作为参数进行传递 。仅仅是为了标识链表的实际情况。

如果链表中存在环 ，则返回 true 。 否则，返回 false 。

先用最好想到的方法做出来，创建哈希集合把出现过的结点存下来，一边存一边用contains和之前的比较，一旦找到就返回true，没有就返回false。

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode(int x) : val(x), next(NULL) {}
 * };
 */
class Solution {
public:
    bool hasCycle(ListNode *head) {
        unordered_set<ListNode*> st;
        ListNode* p=head;
        while(p!=nullptr){
            if(st.contains(p)) return true;
            st.emplace(p);
            p=p->next;
        }
        return false;
    }
};

提交，好，过了。又被全世界人民打败了，想一想优化算法。

 既然只需要知道是不是环形链表就好了，不要求输出它环开始的结点，那我们不如用快慢指针，只要链表中存在环，那两个速度不同的指针必定有一个时刻会重合，但如果链表没有环的话，快指针会先一步到达最尾端。

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode(int x) : val(x), next(NULL) {}
 * };
 */
class Solution {
public:
    bool hasCycle(ListNode *head) {
        if(!head) return false;
        ListNode *slow=head,*fast=head->next;
        while(fast!=nullptr&&fast->next!=nullptr){
            if(slow==fast) return true;
            slow=slow->next;
            fast=fast->next->next;
        }
        return false;
    }
};

142. 环形链表 II

给定一个链表的头节点  head ，返回链表开始入环的第一个节点。 如果链表无环，则返回 null。

如果链表中有某个节点，可以通过连续跟踪 next 指针再次到达，则链表中存在环。 为了表示给定链表中的环，评测系统内部使用整数 pos 来表示链表尾连接到链表中的位置（索引从 0 开始）。如果 pos 是 -1，则在该链表中没有环。

注意：pos 不作为参数进行传递，仅仅是为了标识链表的实际情况。

不允许修改 链表。

还跟上一题思路一样用哈希集合，找到了就输出那个对应指针即可。

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode(int x) : val(x), next(NULL) {}
 * };
 */
class Solution {
public:
    ListNode *detectCycle(ListNode *head) {
        unordered_set<ListNode*> st;
        while(head!=nullptr){
            if(st.contains(head)) return head;
            st.emplace(head);
            head=head->next;
        }
        return nullptr;
    }
};

如果想考虑空间复杂度仅为o(1)的情况，那难度就很大了。解法有点像奥数题，具体怎么写推荐去看灵神的视频讲解。 

还是使用快慢指针来写，假设慢指针为slow，一次前进一格，快指针为fast，一次前进两格，头指针为head。

假设从起点到环开始的点的距离为a，从环开始的点到快指针和满指针在第一次相遇的点的距离是b，环剩下的距离为c。根据我们已知的信息可以写一些公式：

环的长度k=b+c

慢指针在相遇时走过的路程a+b

快指针在相遇时走过的路程a+b+n*(b+c)

快指针走过的路程是慢指针的2倍。

因此可以写出公式：2(a+b)=a+b+n*(b+c)

化简一下，可以把 a 表示出来：a=(n-1)*(b+c)+c=(n-1)*k+c

也就意味着，a的长度可以表示为未知个环长加上c。想想一下当前的情况，慢指针如果从第一次相遇的点继续走c步，就会正好到达环开始的结点。

那我们就在慢指针第一次相遇之后，开始从头移动head指针，slow和head同时每一次移动一个单位，那么当他们相遇时，相遇的位置一定就是我们要求的环开始的点了。

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode(int x) : val(x), next(NULL) {}
 * };
 */
class Solution {
public:
    ListNode *detectCycle(ListNode *head) {
        ListNode *slow=head,*fast=head;
        bool headBegin=false;
        while(fast!=nullptr&&fast->next!=nullptr){
            fast=fast->next->next;
            slow=slow->next;
            if(fast==slow){
                while(slow!=head){
                    slow=slow->next;
                    head=head->next;  
                }
                return slow;
            }
        }
        return nullptr;
    }
};

21. 哈并两个有序链表

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

就像题目所表述的一样，按照大小把两个链表的头结点相互比较，写一个循环就好了。值得注意的是，循环结束后，有可能会有一个链表为空了，另一个链表还没有读完，所以最后再做一次判断，把没有链接进去的部分加入我们的新链表中。

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode() : val(0), next(nullptr) {}
 *     ListNode(int x) : val(x), next(nullptr) {}
 *     ListNode(int x, ListNode *next) : val(x), next(next) {}
 * };
 */
class Solution {
public:
    ListNode* mergeTwoLists(ListNode* list1, ListNode* list2) {
        ListNode* p=new ListNode;
        ListNode* n=p;
        while(list1!=nullptr&&list2!=nullptr){
            if(list1->val<list2->val){
                n->next=list1;
                list1=list1->next;
            }
            else{
                n->next=list2; 
                list2=list2->next;
            }
            n=n->next; 
        }
        n->next=list1==nullptr?list2:list1;
        return p->next;
    }
};

 2. 两数相加

给你两个 非空 的链表，表示两个非负的整数。它们每位数字都是按照 逆序 的方式存储的，并且每个节点只能存储 一位 数字。

请你将两个数相加，并以相同形式返回一个表示和的链表。

你可以假设除了数字 0 之外，这两个数都不会以 0 开头。

设计一个加法位，用于给当前两个链表的头结点做加法的时候算一下有没有超过10，然后将余数赋值到新节点，将除完的结果赋值进加法位。

因此主要步骤就是

1.新建一个sum值储存当前位的数字相加之和

2.加入加法位plus

3.加入list1的当前节点

4.加入list2的当前节点

5.做sum%10运算放进下一个结点中，做sum/10运算放进加法位plus中。

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode() : val(0), next(nullptr) {}
 *     ListNode(int x) : val(x), next(nullptr) {}
 *     ListNode(int x, ListNode *next) : val(x), next(next) {}
 * };
 */
class Solution {
public:
    ListNode* addTwoNumbers(ListNode* l1, ListNode* l2) {
        int plus=0;
        ListNode* l3=new ListNode(0);
        ListNode* p=l3;
        while(l1!=nullptr||l2!=nullptr||plus){
            int sum=plus;
            if(l1!=nullptr){
                sum+=l1->val;
                l1=l1->next;
            }
            if(l2!=nullptr){
                sum+=l2->val;
                l2=l2->next;
            }
            plus=sum/10;
            p->next=new ListNode(sum%10);
            p=p->next;
        }
        return l3->next;
    }
};