Problem:
I have two arrays that can possibly be different lengths. I need to iterate through both arrays and find similarities, additions, and deletions.
What's the fastest and most efficient way to accomplish this in C#?
Edit: The arrays are pre-sorted and they can contain anywhere between 50-100 items. Also, there aren't any constraints on speed and/or memory usage (however, no one likes a memory hog;)
For example:
String[] Foo_Old = {"test1", "test2", "test3"};
String[] Foo_New = {"test1", "test2", "test4", "test5"};
AND
String[] Bar_Old = {"test1", "test2", "test4"};
String[] Bar_New = {"test1", "test3"};
Differences:
(with respect to the Foo_New array)
[Same] "test1" [Same] "test2" [Removed] "test3" [Added] "test4" [Added] "test5"
(with respect to the Bar_New array)
[Same] "test1" [Removed] "test2" [Removed] "test4" [Added] "test3"
You can use Except and Intersect ...
var Foo_Old = new[] { "test1", "test2", "test3" };
var Foo_New = new[] { "test1", "test2", "test4", "test5" };
var diff = Foo_New.Except( Foo_Old );
var inter = Foo_New.Intersect( Foo_Old );
var rem = Foo_Old.Except(Foo_New);
foreach (var s in diff)
{
Console.WriteLine("Added " + s);
}
foreach (var s in inter)
{
Console.WriteLine("Same " + s);
}
foreach (var s in rem)
{
Console.WriteLine("Removed " + s);
}
I went ahead and hand-coded one and use the example in the accepted answer, and the hand-coded one performs a little better. I handled outputting my strings a little differently. Other factors to consider include whether the Except make a sorted copy of the array (since it cannot assume it's sorted) or whether it makes some kind of hash or a linear search (it's actually restricted to IEnumerable - for very large arrays which are already sorted, this could be a problem). You could change mine to compare IEnumerable (which is more general) instead of IComparable[].
static void ArrayCompare(IComparable[] Old, IComparable[] New)
{
int lpOld = 0;
int lpNew = 0;
int OldLength = Old.Length;
int NewLength = New.Length;
while (lpOld < OldLength || lpNew < NewLength)
{
int compare;
if (lpOld >= OldLength) compare = 1;
else if (lpNew >= NewLength) compare = -1;
else compare = Old[lpOld].CompareTo(New[lpNew]);
if (compare < 0)
{
Debug.WriteLine(string.Format("[Removed] {0}", Old[lpOld].ToString()));
lpOld++;
}
else if (compare > 0)
{
Debug.WriteLine(string.Format("[Added] {0}", New[lpNew].ToString()));
lpNew++;
}
else
{
Debug.WriteLine(string.Format("[Same] {0}", Old[lpOld].ToString()));
lpOld++;
lpNew++;
}
}
}
static void ArrayCompare2(IComparable[] Old, IComparable[] New) {
var diff = New.Except( Old );
var inter = New.Intersect( Old );
var rem = Old.Except(New);
foreach (var s in diff)
{
Debug.WriteLine("Added " + s);
}
foreach (var s in inter)
{
Debug.WriteLine("Same " + s);
}
foreach (var s in rem)
{
Debug.WriteLine("Removed " + s);
}
}
static void Main(string[] args)
{
String[] Foo_Old = {"test1", "test2", "test3"};
String[] Foo_New = {"test1", "test2", "test4", "test5"};
String[] Bar_Old = {"test1", "test2", "test4"};
String[] Bar_New = {"test1", "test3"};
Stopwatch w1 = new Stopwatch();
w1.Start();
for (int lp = 0; lp < 10000; lp++)
{
ArrayCompare(Foo_Old, Foo_New);
ArrayCompare(Bar_Old, Bar_New);
}
w1.Stop();
Stopwatch w2 = new Stopwatch();
w2.Start();
for (int lp = 0; lp < 10000; lp++)
{
ArrayCompare2(Foo_Old, Foo_New);
ArrayCompare2(Bar_Old, Bar_New);
}
w2.Stop();
Debug.WriteLine(w1.Elapsed.ToString());
Debug.WriteLine(w2.Elapsed.ToString());
}
If you love us? You can donate to us via Paypal or buy me a coffee so we can maintain and grow! Thank you!
Donate Us With