数组或链表的交集

两个数组的交集

题目： 给定两个数组，编写一个函数来计算它们的交集。说明： 输出结果中的每个元素一定是唯一的。我们可以不考虑输出结果的顺序。

示例1：

• 输入：
  nums1 = [1,2,2,1], nums2 = [2,2]
• 输出: [2]

示例 2:

• 输入:
  nums1 = [4,9,5], nums2 = [9,4,9,8,4]
• 输出: [9,4]

解题思路：交集即两集合共有的元素的集合。所以首先要保证集合的唯一性，所以选择std::map容器导入元素，进行去重。然后随意遍历其中一个集合中的元素，每个元素与另一个集合中查找这个元素：

1. 如果存在，即为交集元素，插入需要返回的vector中。
2. 如果不存在，即找到了map的end()位置，表示存在在A集合中的B集合中不包含的元素，那这个元素不会处理，即不放入返回的集合。

class Solution {
public:
    vector<int> intersection(vector<int>& nums1, vector<int>& nums2) {
        vector<int> ret;
        
        set<int> s1;
        for(auto e:nums1){
           s1.insert(e);
        }
        
        set<int> s2;
        for(auto e:nums2){
           s2.insert(e);
        }
        
        for(auto e:s1){
            if(s2.find(e) != s2.end())	//s1和s2都共有此元素
                ret.push_back(e);
        }
        return ret;
    }
};

---

两个数组的交集II

数组：给定两个数组，编写一个函数来计算它们的交集。输出结果中每个元素出现的次数，应与元素在两个数组中出现的次数一致。我们可以不考虑输出结果的顺序。

示例 1:

• 输入: nums1 = [1,2,2,1], nums2 = [2,2]
• 输出: [2,2]

示例 2:

• 输入: nums1 = [4,9,5], nums2 = [9,4,9,8,4]
• 输出: [4,9]

class Solution {
public:
    vector<int> intersect(vector<int>& nums1, vector<int>& nums2) {
        unordered_map<int,int> dict;
        vector<int> ret;
        
        for(auto e : nums1){
            dict[e]++;
        }
        
        for(auto e : nums2){
            if(dict.count(e)){
                ret.push_back(e);
                dict[e]--;
                if(dict[e] == 0)    
                    dict.erase(e);
            }
        }
        return ret;
    }
};

两个排序数组的交集

问题描述： 求两个已排序数组的交集，要求时间复杂度为O(m + n)

解题思路： 求两个数组的交集 ，使用两个指针分别指向数组A和数组B，指向数字较小的指针向前移动，若遇到两个数组具有相同的数字，则进行保存，直到其中任何一个数组遍历完。

int mixed(int arr1[],int n1,int arr2[],int n2,int* mix )
{
	int i = 0;
	int j = 0;
	int k = 0;
	//mix = new int[n1];
	while (i < n1 && j < n2)
	{
		if(arr1[i] == arr2[j])
		{
			mix[k++] = arr1[i];
			//k++;
			i++;
			j++;
		}
		else if (arr1[i]>arr2[j])
			j++;
		else if (arr1[i]<arr2[j])
			i++;
	}
	return k;

多个集合的交集见区间合并

题目： 给定多个数组，编写一个函数来计算它们的交集。**说明：**输出结果中的每个元素一定是唯一的。我们可以不考虑输出结果的顺序。

解题思路：交集即两集合共有的元素的集合。所以首先要保证集合的唯一性，所以选择std::set容器导入元素，进行去重。然后随意遍历其中一个集合中的元素，每个元素与另一个集合中查找这个元素,递归的每次执行两个集合的合并。

vector<int> solution(vector<vector<int>> input){
    vector<int> res;
    if (input.size()==0){
        return res;
    }
    if(input.size()==1)
        return input[0]; 
    mergeMultiSet(input,1);
    return input[0];  
}
void mergeMultiSet(vector<vector<int>>&input,int size){
    if (size>=input.size()) return;
    input[0]=mergeTwoSet(input[0],input[size]);
    mergeMultiSet(input,size+1);
}
vector<int> mergeTwoSet(vector<int>inputone,vector<int>inputtwo){
    set<int> setone;
    for(auto i:inputone)
        setone.insert(i);
    int length=inputtwo.size();
    vector<int> res;
    for(int i=0;i<length;i++){
        if (setone.find(inputtwo[i])!=setone.end())
            res.push_back(inputtwo[i]);
    }
    return res;
}

两个链表的交集

题目： 已知两个非降序链表序列S1与S2，设计函数构造出S1与S2的交集新链表S3

typedef int  Status;
typedef int  ElemType;//假设线性表中的元素均为整型
typedef struct LNode
{
    ElemType data;
    struct LNode *next;
} LNode,*LinkList;

void AddList(LinkList &A,LinkList &B,LinkList &C)
{
    LNode *pa,*pb,*pc;
    pa=A->next;
    pb=B->next;
    pc=C;
    while(pa&&pb)
    {
        if((pa->data)==(pb->data))
        {
            pc->next=pa;
            pa=pa->next;
            pb=pb->next;
            pc=pc->next;
        }
        else if((pa->data)<(pb->data))
        {
            pa=pa->next;
        }
        else
            pb=pb->next;
    }
}