LeetCode Linked List Components 链表组件

We are given head, the head node of a linked list containing unique integer values.
We are also given the list G, a subset of the values in the linked list.
Return the number of connected components in G, where two values are connected if they appear consecutively in the linked list.
Example 1:

Input: 
head: 0->1->2->3
G = [0, 1, 3]
Output: 2
Explanation: 
0 and 1 are connected, so [0, 1] and [3] are the two connected components.

Example 2:

Input: 
head: 0->1->2->3->4
G = [0, 3, 1, 4]
Output: 2
Explanation: 
0 and 1 are connected, 3 and 4 are connected, so [0, 1] and [3, 4] are the two connected components.

Note:

• If N is the length of the linked list given by head, 1 <= N <= 10000.
• The value of each node in the linked list will be in the range [0, N - 1].
• 1 <= G.length <= 10000.
• G is a subset of all values in the linked list.

这道题让咱们判断链表里面有几个节点是“connected components”，单个的节点在数组中出现算一个“connected components”，相连的几个节点在数组中出现，只算一个“connected components”。
咱们能够用二分法查找当前节点是否在数组中出现，若是当前节点的后继节点一样存在，则将指针后移，若是不存在则res++。这里要加一个flag，判断以前的节点是否存在数组中。

解法一：

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode(int x) : val(x), next(NULL) {}
 * };
 */
class Solution {
public:
    int numComponents(ListNode* head, vector<int>& G) {
        sort(G.begin(),G.end());
        int res=0,flag=0;
        while(head!=NULL){
            while(head&&find(G,head->val)){
                head=head->next;
                flag=1;
            }
            if(flag) res++;
            flag=0;
            if(head&&head->next) head=head->next;
            else return res;
        }
        return res;
    }
    bool find(vector<int>& nums, int target) {
        int left = 0, right = nums.size();
        while (left < right) {
            int mid = left + (right - left) / 2;
            if (nums[mid] == target) return true;
            else if (nums[mid] < target) left = mid + 1;
            else right = mid;
        }
        return false;
    }
};

STL提供了一个unordered_set容器可使用count()直接查找，省去了写二分法，参考代码以下。
解法二

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode(int x) : val(x), next(NULL) {}
 * };
 */
class Solution {
public:
    int numComponents(ListNode* head, vector<int>& G) {
        unordered_set<int> setG (G.begin(), G.end());
        int res = 0;
        while (head != NULL) {
            if (setG.count(head->val) && (head->next == NULL || !setG.count(head->next->val))) res++;
            head = head->next;
        }
        return res;
    }
};