C# 判断两个集合(List)是否相等

1.两个list如果有重复元素(如List1: a,b,a  List2: b,b,a) 是无法通过包含关系来判断是否相等的.

有两个办法,其一是两个List排序后再按顺序比较.另一个办法就是计算各元素的重复项再进行比较

第一种方案劣势太明显,时间复杂度过大

第二种以空间换时间,只需要遍历无需排序即可.

        /// <summary>
        /// 判断两个集合是否是相等的(所有的元素及数量都相等)
        /// </summary>
        /// <typeparam name="T">集合元素类型</typeparam>
        /// <param name="sourceCollection">源集合列表</param>
        /// <param name="targetCollection">目标集合列表</param>
        /// <returns>两个集合相等则返回True,否则返回False</returns>
        public static bool EqualList<T>(this IList<T> sourceCollection, IList<T> targetCollection) where T : IEquatable<T>
        {
            //空集合直接返回False,即使是两个都是空集合,也返回False
            if (sourceCollection == null || targetCollection == null)
            {
                return false;
            }

            if (object.ReferenceEquals(sourceCollection, targetCollection))
            {
                return true;
            }

            if (sourceCollection.Count != targetCollection.Count)
            {
                return false;
            }

            var sourceCollectionStaticsDict = sourceCollection.StatisticRepetition();
            var targetCollectionStaticsDict = targetCollection.StatisticRepetition();

            return sourceCollectionStaticsDict.EqualDictionary(targetCollectionStaticsDict);
        }

        /// <summary>
        /// 判断两个字典是否是相等的(所有的字典项对应的值都相等)
        /// </summary>
        /// <typeparam name="TKey">字典项类型</typeparam>
        /// <typeparam name="TValue">字典值类型</typeparam>
        /// <param name="sourceDictionary">源字典</param>
        /// <param name="targetDictionary">目标字典</param>
        /// <returns>两个字典相等则返回True,否则返回False</returns>
        public static bool EqualDictionary<TKey, TValue>(this Dictionary<TKey, TValue> sourceDictionary, Dictionary<TKey, TValue> targetDictionary)
            where TKey : IEquatable<TKey>
            where TValue : IEquatable<TValue>
        {
            //空字典直接返回False,即使是两个都是空字典,也返回False
            if (sourceDictionary == null || targetDictionary == null)
            {
                return false;
            }

            if (object.ReferenceEquals(sourceDictionary, targetDictionary))
            {
                return true;
            }

            if (sourceDictionary.Count != targetDictionary.Count)
            {
                return false;
            }

            //比较两个字典的Key与Value
            foreach (var item in sourceDictionary)
            {
                //如果目标字典不包含源字典任意一项,则不相等
                if (!targetDictionary.ContainsKey(item.Key))
                {
                    return false;
                }

                //如果同一个字典项的值不相等,则不相等
                if (!targetDictionary[item.Key].Equals(item.Value))
                {
                    return false;
                }
            }

            return true;
        }

        /// <summary>
        /// 统计集合的重复项,并返回一个字典
        /// </summary>
        /// <typeparam name="T">集合元素类型</typeparam>
        /// <param name="sourceCollection">统计集合列表</param>
        /// <returns>返回一个集合元素及重复数量的字典</returns>
        private static Dictionary<T, int> StatisticRepetition<T>(this IEnumerable<T> sourceCollection) where T : IEquatable<T>
        {
            var collectionStaticsDict = new Dictionary<T, int>();
            foreach (var item in sourceCollection)
            {
                if (collectionStaticsDict.ContainsKey(item))
                {
                    collectionStaticsDict[item]++;
                }
                else
                {
                    collectionStaticsDict.Add(item, 1);
                }
            }

            return collectionStaticsDict;
        }

2

 public class CommonTest
    {
        /// <summary>
        /// 集合相等比较
        /// </summary>
        [Fact]
        public void ListEqual_Tests()
        {
            var sourceList = new List<string>()
            {
                "a",
                "b",
                "a"
            };

            var targetList = new List<string>()
            {
                "b",
                "b",
                "a"
            };

            var resp = sourceList.EqualList(targetList);
            Assert.False(resp );
        }

        /// <summary>
        /// 集合相等比较
        /// </summary>
        [Fact]
        public void ListEqual2_Tests()
        {
            var sourceList = new List<string>()
            {
                "a",
                "b",
            };

            var targetList = new List<string>()
            {
                "b",
                "a"
            };

            var resp = sourceList.EqualList(targetList);
            Assert.True(resp);
        }
    }

原文地址:https://www.cnblogs.com/zhshlimi/p/8418903.html

时间: 2024-10-12 10:08:37

C# 判断两个集合(List)是否相等的相关文章

Java如何判断两个集合的元素是否完全相等

一,实现 1. 最简单粗暴的方法,遍历循环 1 package list.demo; 2 3 import java.io.Serializable; 4 import java.util.*; 5 import java.util.stream.Collectors; 6 7 /** 8 * 判断两个集合是否相等 9 */ 10 public class CheckDiffList implements Serializable { 11 public static void main(Str

java判断两集合是否相同以及求取交集,并集,差集

业务中用时需要判断两集合是否相同,所有提供一个工具方法,使用set集合的特性(元素唯一): private Map<String,Set<Integer>> getCategoryApiId(Set<Integer> oldAuthSet , Set<Integer> newAuthSet){ Map<String,Set<Integer>> categoryApiId = new HashMap(); if (oldAuthSet!

【java】【反射】反射实现判断发生了修改操作,判断两个对象是否发生属性值的变更,判断两个List集合内对象的属性值是否发生变更

java的反射实现: 判断发生了修改操作,判断两个对象是否发生属性值的变更,判断两个List集合内对象的属性值是否发生变更 今日份代码: package com.sxd.streamTest; import java.lang.reflect.Field; import java.util.*; /** * @ClassName Test * @Description 判断发生了修改操作,判断两个对象是否发生属性值的变更,判断两个List集合内对象的属性值是否发生变更 * @Author sxd

计算两个集合的交集数字(java)

循环判断2个数组 将相同的公共元素复制到新数组中即可 1 2 3 import java.util.Arrays; 4 5 public class count_same_number { 6 7 public static int[] join(int[] a,int[] b) 8 { 9 int count=0; 10 int new_target[]=new int[Math.max(a.length, b.length)];//新数组 11 int index=0; 12 for(int

判断两个线段是否相交

我们的问题是这样的:给定一条线段的起点为$A_1$.终点为$A_2$,另一条线段的起点为$B_1$.终点为$B_2$,问线段$A_1A_2$和线段$B_1B_2$是否相交? 我们首先解释一下,两条线段相交的概念是指,存在一个点,这个点同时在两条线段上. 方法一(解方程法): 容易知道,线段$A_1A_2$上的点的集合为$A = A_1 * (1 - r_1) + A_2 * r_1$,其中$r_1 \in [0, 1]$:同理,线段$B_1B_2$上的点的集合为$B = B_1 * (1 - r

9.判断两个单链表是否相交

9.判断两个单链表是否相交 注意这里是判断是否相交.对于判断问题来讲,相对还是比较简单的.注意单链表并非不能有重复元素. 思路1:O(len1*len2) 把第一个链表的指针值逐项存在hashtable中,遍历第2个链表的每一项的指针值,如果能在第一个链表中找到,则必然相交.但是C++的STL模板中的hash不太会用.所以我使用了set集合,不过貌似set集合是使用遍历的方式来查找元素是否在集合中的,所以效率是比较低的,至少在O(len1*len2)级别. bool judgeIntersect

求两个集合的交集和并集C#

我是用hashset<T>来实现的 具体如代码所示 using System; using System.Collections.Generic; using System.Linq; using System.Text; namespace JiaoJi { class Program { static void Main(string[] args) { int [] arrA=new int[8]{1,2,3,4,5,6,7,8}; int [] arrB=new int[5]{4,5,

Hoj1412 求两个集合的和{A} + {B}——java实现最优解的辛酸路

写在前面 寒假闲来无事,突发奇想,想A俩题玩玩,许久没A过题了,想想那手指暴力敲击键盘的感觉就是一阵酸爽啊. 做的前几个题还挺顺溜,大概半个小时一个题吧,A了三四个,谁知道到第五个卡这了. 一个看上去很简单的题楞是卡了我俩小时,不过结果还算不错. 打破了个记录,竟然一不小心成为了这个题的最优解....... 详细描述点击此处参见原题 大致就是: 给你两个集合,要求{A} + {B}. 注:同一个集合中不会有两个相同的元素. 辛酸分析路 (1)用Java自带的工具 因为本身是玩Java的,首先想到

POJ 2159(判断可重集合相等&amp;hash)

POJ 2159 题目归结为判断两个自然数多集(允许有重复元素的集合)a, b是否相等.用快排比较的效率是O(nlgn). 此题中a.b则分别是每个字母个数集. 下面提出一种O(n)的方法供大家参考. 猜想:若 sum(a^i) = sum(b^i),i = 0, 1, 2, 则 a = b. 证明:? 注意 sum(s^0) 是多集s中元素的数目 sum(s^1) 是多集s中元素的和 sum(s^2) 是多集s中元素的平方和 即比较多集的三个统计值即可.以上算法是AC的.但是我还没有一个满意的