C# 对List<T>取交集、连集及差集

转：http://www.cnblogs.com/shuibin/archive/2012/04/19/2457867.html

 //Union()这个方法将会Union(并集)两个序列(集合)连接成一个新列表(集合)
 //Intersect ()它将产生两个序列的交集
//Except ()它是从一个集合中删除存在另一个集合中的项.两个序列产生的集合差. 英文意思是：除此之外

1.  取交集 (A和B都有)

List A : { 1 , 2 , 3 , 5 , 9 }

List B : { 4 , 3 , 9 }

var intersectedList = list1.Intersect(list2);

 

結果 : { 3 , 9 }

判断A和B是否有交集

bool isIntersected = list1.Intersect(list2).Count() > 0

2. 取差集 (A有，B沒有)

List A : { 1 , 2 , 3 , 5 , 9 }

List B : { 4 , 3 , 9 }

var expectedList = list1.Except(list2);

結果 : { 1 , 2 , 5 }

判断A和B是否有差集

bool isExpected = list1.Expect(list2).Count() > 0

3.  取连集 (包含A和B)

List A : { 1 , 2 , 3 , 5 , 9 }

List B : { 4 , 3 , 9 }

public static class ListExtensions

{

　　public static List<T> Merge<T>(this List<T> source, List<T> target)

　　{

　　　　List<T> mergedList = new List<T>(source);

　　　　mergedList.AddRange(target.Except(source));

　　　　return mergedList;

　　}

}

var mergedList = list1.Merge(list2);

結果 : { 1 , 2 , 3 , 5 ,9 , 4 }

LinQ已有內建方法Union可取连集：listA.Union(listB).ToList();

==========================================

合并两个数组,并去掉重复元素,然后排序(C#)

 

List<int> numbers1 = new List<int>() { 5, 4, 1, 3, 9, 8, 6, 7, 12, 10 };
List<int> numbers2 = new List<int>() { 15, 14, 11, 13, 19, 18, 16, 17, 12, 10 };
var newQuerty = numbers1.Concat(
from n in numbers2
where !numbers1.Contains(n)
select n
).OrderBy(n=>n);

 

C# 获取两个数组集合的差集，交集

在做一个树形选择节点时，遇到一个问题，属性节点是记录了相关的ID值，第一次呢全部对这些ID进行处理，但是接下来再次选择就要分情况了，原先选择的ID如果不在新选择的集合中那么剔除掉，否则，原先ID不传入函数处理，新ID传入函数处理：

比如原来①选择的ID是：1,2,3,4                下次：1,2,3,4,5，   那么这时候5要处理，1,2,3,4维持原样。

              ②选择ID是：1,3                          下次： 3,4,5           那么这时候4,5 要处理，3 维持原样。1剔除。

              ③选择ID是：1,2,3,4,5                  下次：3,4,5             那么这时候3,4,5都维持原样，1,2剔除。

              ④选择ID是：1,2                           下次：3,4,5             那么这时候3,4,5处理，1,2剔除。

 

简化一下数学模型：

大家发现没其实这就是一个数学的概念，集合的差集，那么我们怎么处理呢？ 假设前次选择的集合为A，后次选择为B

得到要处理的很简单：B-A （B与A的差集）就是要处理的集合元素，为什么呢？根据概念可知哈！

那么得到不做处理的怎么办呢？ 不要处理的必然是B的子集，那么怎么得到呢？

出来啦既是：B-(B-A)    这是为什么呢？ B-A  就是要处理的，而维持原样的就是当然就是:B-(B-A)，

那么剔除的集合呢？ A-(B-(B-A)) 

 

如何用C#表示呢，我这里就不用什么循环之类的了，我用的是NET3.5 那就好办了，用Linq处理：

俺这里特殊点，右键得到的树形集合（lstSource）包含了其他信息，先获取ID集合再说：

 var m_ilAllSelect = lstSource.Select(r => r.ID).AsEnumerable();//新选择的列表

///////下面开始处理了

List<int> m_ilNewSelect = m_ilAllSelect.ToList();//新选择列表
List<int> m_ilExcept = m_ilNewSelect.Except(m_mcuids).ToList(); //两者的不同之处
List<int> m_iExceptAfterAndNew = m_ilNewSelect.Except(m_ilExcept).ToList();//新选择列表与差集比较，则是新选择中的旧的

 

为了简化给大家，这里的A代表旧集合，B代表新集合,这里的集合都是List<int>泛型列表。

那么要处理的就是 B.Except(A), 维持原样的：B( B.Except(A)), 剔除的：A.Except(B( B.Except(A))),

集合合并

首先举例2个集合A,B. 
 
 List<int> listA = new List<int> {1,2,3,5,7,9};
 
 List<int> listB = new List<int> {13,4,17,29,2};
 
 
 
 listA.AddRange(listB );把集合A.B合并
 
 List<int> Result = listA.Union(listB).ToList<int>();          //剔除重复项 
 
 List<int> Result = listA.Concat(listB).ToList<int>();        //保留重复项
 
 listA.BinarySearch("1");//判断集合中是否包含某个值.如果包含则返回0
 
 
 
  在举例两个数组
 

  int[] i=new int[]{1,2};
 
  int[] j=new int[]{2,3};
 
  List<int> r = new List<int>();  
 
  r.AddRange(i);
 
  r.AddRange(j);
 
  int[] c = r.ToArray(); 合并数组
 
  int[] x=i.Union(j).ToArray<int>(); //剔除重复项 
 
  int[] x=i.Concat(j).ToArray<int>(); //保留重复项
 
  int n = Array.BinarySearch(i,3);//判断数组中是否包含某个值.如果包含则返回0

实例

            List<string> a = new List<string>{ "a", "b", "c" };
            List<string> b = new List<string> { "b", "c", "d", "e" };
            List<string> c1 = a.Except(b).ToList();     //a     //A跟B的差异(B的里面不存在的数据)
            List<string> c2 = b.Except(a).ToList();     //d e   //B跟A的差异(A的里面不存在的数据)
            List<string> c3 = a.Except(c1).ToList();    //b c 
            List<string> c4 = a.Except(c2).ToList();    //a b c
            List<string> c5 = b.Except(c1).ToList();    //b c d e
            List<string> c6 = b.Except(c2).ToList();    //b c
            //Union()这个方法将会Union(并集)两个序列(集合)连接成一个新列表(集合)
            //Intersect ()它将产生两个序列的交集
            //Except ()它是从一个集合中删除存在另一个集合中的项.两个序列产生的集合差. 英文意思是：除此之外
            List<string> d1 = a.Union(b).ToList();  //a b c d e //集合ab合并，剔除重复项
            List<string> d2 = a.Concat(b).ToList(); //a b c b c d e//集合ab合并，保留重复项
            int m1 = a.BinarySearch("b");       //判断集合中是否包含某个值.如果包含则返回位置索引
            //判断集合A B是否相等  if (c1.Any()||c2.Any()) { }
            if (c1.Count()!=0||c2.Count()!=0)
            {
                
            }