算法题：
题目来源：力扣（LeetCode）
简单题：
编写一个程序，找到两个单链表相交的起始节点。
示例 1：
输入：intersectVal = 8, listA = [4,1,8,4,5], listB = [5,0,1,8,4,5], skipA = 2, skipB = 3
输出：Reference of the node with value = 8
输入解释：相交节点的值为 8 （注意，如果两个链表相交则不能为 0）。从各自的表头开始算起，链表 A 为 [4,1,8,4,5]，链表 B 为 [5,0,1,8,4,5]。在 A 中，相交节点前有 2 个节点；在 B 中，相交节点前有 3 个节点。

示例 2：
输入：intersectVal = 2, listA = [0,9,1,2,4], listB = [3,2,4], skipA = 3, skipB = 1
输出：Reference of the node with value = 2
输入解释：相交节点的值为 2 （注意，如果两个链表相交则不能为 0）。从各自的表头开始算起，链表 A 为 [0,9,1,2,4]，链表 B 为 [3,2,4]。在 A 中，相交节点前有 3 个节点；在 B 中，相交节点前有 1 个节点。

示例 3：
输入：intersectVal = 0, listA = [2,6,4], listB = [1,5], skipA = 3, skipB = 2
输出：null
输入解释：从各自的表头开始算起，链表 A 为 [2,6,4]，链表 B 为 [1,5]。由于这两个链表不相交，所以 intersectVal 必须为 0，而 skipA 和 skipB 可以是任意值。
解释：这两个链表不相交，因此返回 null。

注意：
如果两个链表没有交点，返回 null.
在返回结果后，两个链表仍须保持原有的结构。
可假定整个链表结构中没有循环。
程序尽量满足 O(n) 时间复杂度，且仅用 O(1) 内存。

题解思路：
这道题需要用到set集合，把链表A的每个节点地址都放进去，然后在找链表B的每个节点地址是否在集合中，如果找到，第一个就是交点。

class Solution {
public:
    ListNode *getIntersectionNode(ListNode *headA, ListNode *headB) {
        std::set<ListNode*> node_set;
        while(headA){
            node_set.insert(headA);
            headA=headA->next;
        }
        while(headB)
        {
            if(node_set.find(headB)!=node_set.end())
            {
                return headB;
            }
            headB=headB->next;
        }
        return NULL;
    }
};

大佬题解思路：（来源力扣用户：SEU.FidGet
）
由于A链表的长度为a.len,B链表为b.len,两个指针（pa,pb）分别从A链表头和B链表头往尾部走，若pa走到b最后为NULL时，跳到B链表头，若pb走到最后为NULL时，跳到A链表头。当pa==pb时即为交点（a.len+b.len=b.len+a.len）。太强了！！！

public class Solution {
    public ListNode getIntersectionNode(ListNode headA, ListNode headB) {
        /**
        定义两个指针, 第一轮让两个到达末尾的节点指向另一个链表的头部, 最后如果相遇则为交点(在第一轮移动中恰好抹除了长度差)
        两个指针等于移动了相同的距离, 有交点就返回, 无交点就是各走了两条指针的长度
        **/
        if(headA == null || headB == null) return null;
        ListNode pA = headA, pB = headB;
        // 在这里第一轮体现在pA和pB第一次到达尾部会移向另一链表的表头, 而第二轮体现在如果pA或pB相交就返回交点, 不相交最后就是null==null
        while(pA != pB) {
            pA = pA == null ? headB : pA.next;
            pB = pB == null ? headA : pB.next;
        }
        return pA;
    }
}

算法题：
题目来源：力扣（LeetCode）
给定一个链表，判断链表中是否有环。
如果链表中有某个节点，可以通过连续跟踪 next 指针再次到达，则链表中存在环。 为了表示给定链表中的环，我们使用整数 pos 来表示链表尾连接到链表中的位置（索引从 0 开始）。 如果 pos 是 -1，则在该链表中没有环。注意：pos 不作为参数进行传递，仅仅是为了标识链表的实际情况。
如果链表中存在环，则返回 true 。 否则，返回 false 。
进阶：
你能用 O(1)（即，常量）内存解决此问题吗？
示例 1：

输入：head = [3,2,0,-4], pos = 1
输出：true
解释：链表中有一个环，其尾部连接到第二个节点。

示例 2：

输入：head = [1,2], pos = 0
输出：true
解释：链表中有一个环，其尾部连接到第一个节点。

示例 3：

输入：head = [1], pos = -1
输出：false
解释：链表中没有环。

提示：
链表中节点的数目范围是 [0, 104]
-105 <= Node.val <= 105
pos 为 -1 或者链表中的一个 有效索引 。

解题思路
由于刚学算法刷题，数据结构上课也不扎实，c++也不怎么会，能想到办法对于我自己来说已经很不错了，进阶的我确实不会。先说说我简单的思路，就是把链表的节点地址依次放进set集合中，判断head->next在不在集合中，如果在就是环路，如果不在就不是。

class Solution {
public:
    bool hasCycle(ListNode *head) {
        std::set<ListNode*> node_set;
        if(head==NULL){return false;}
        if(head->next!=NULL){
            while(head){
                node_set.insert(head);
                if(node_set.find(head->next)!=node_set.end()){
                   return true;
                }
                head=head->next;
            }
        }
        return false;
    }
};

大佬思路（carlsun-2）利用快慢指针！！！真的猛！我是废物。

class Solution {
public:
    bool hasCycle(ListNode *head) {
        ListNode* fast = head;
        ListNode* slow = head;
        while(fast != NULL && fast->next != NULL) {
            slow = slow->next;
            fast = fast->next->next;
            // 快慢指针相遇，说明有环
            if (slow == fast) return true;
        }
        return false;
    }
};

今日前端罢工，由于html跟着视频大致复习了一遍，现在在看书本，看完了再学css。