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