/// <summary>
/// Perform a Quick Find on a small text file.
/// </summary>
/// <param name="unionFind">The union find to be tested.</param>
internal static void CommonUnionFindTiny(IUnionFind unionFind)
{
using (In input = new In("Algs4-Data\\TinyUF.txt"))
{
int initialComponentCount = input.ReadInt();
unionFind.IsolateComponents(initialComponentCount);
while (!input.IsEmpty())
{
int siteP = input.ReadInt();
int siteQ = input.ReadInt();
if (unionFind.Connected(siteP, siteQ))
{
continue;
}
unionFind.Union(siteP, siteQ);
}
}
Assert.AreEqual(2, unionFind.Count);
}
public void TestUnion()
{
_sut.Union(4, 3);
Assert.AreEqual(9, _sut.Count());
Assert.IsTrue(_sut.IsConnected(4, 3));
Assert.AreEqual(4, _sut.Find(3));
Assert.AreEqual(4, _sut.Find(4));
_sut.Union(3, 8);
Assert.AreEqual(8, _sut.Count());
Assert.IsTrue(_sut.IsConnected(3, 8));
Assert.AreEqual(4, _sut.Find(3));
Assert.AreEqual(4, _sut.Find(8));
}
/// <summary>
/// Common portion of file input UnionFind tests.
/// </summary>
/// <param name="streamName">The name for the input stream.</param>
/// <param name="unionFind">The union find to be tested.</param>
/// <returns>The Union Find structure.</returns>
public static IUnionFind UnionFindCommon(string streamName, IUnionFind unionFind)
{
if (null == streamName)
{
throw new ArgumentNullException("streamName");
}
if (null == unionFind)
{
throw new ArgumentNullException("unionFind");
}
using (In input = new In(streamName))
{
int initialComponentCount = input.ReadInt();
unionFind.IsolateComponents(initialComponentCount);
while (!input.IsEmpty())
{
int siteP = input.ReadInt();
int siteQ = input.ReadInt();
if (unionFind.Connected(siteP, siteQ))
{
continue;
}
unionFind.Union(siteP, siteQ);
}
return unionFind;
}
}
private void TestFind(IUnionFind uf)
{
Assert.AreEqual(100, uf.Components().Count, "The given UnionFind algorithm must be defined for 100 nodes");
bool result;
/* Initially, I find no path */
result = uf.Find(0, 1);
Assert.AreEqual(result, false);
/* Test directly connected nodes */
uf.Union(0, 1);
result = uf.Find(0, 1);
Assert.AreEqual(result, true);
/* Test indirectly connected nodes */
uf.Union(1, 2);
result = uf.Find(0, 2);
Assert.AreEqual(result, true);
/* Test non-connected nodes */
result = uf.Find(0, 9);
Assert.AreEqual(result, false);
/* Test find in an union of all nodes */
Random random = new Random();
List <int> components = uf.Components();
for (int i = 3; i < components.Count; i++)
{
uf.Union(i - 1, i);
}
components = uf.Components();
for (int i = 0; i < components.Count; i++)
{
int p = random.Next(0, components.Count);
int q = random.Next(0, components.Count);
result = uf.Find(p, q);
Assert.AreEqual(result, true);
}
Assert.AreEqual(CountConnectedComponents(components), 1);
}
private void TestUnion(IUnionFind uf)
{
Assert.AreEqual(100, uf.Components().Count, "The given UnionFind algorithm must be defined for 100 nodes");
List <int> components;
/* Test union of two nodes */
uf.Union(0, 1);
components = uf.Components();
Assert.AreEqual(components[0], components[1]);
Assert.AreEqual(CountConnectedComponents(components), components.Count - 1);
/* Test union of three nodes */
uf.Union(1, 2);
components = uf.Components();
Assert.AreEqual(components[0], components[1]);
Assert.AreEqual(components[1], components[2]);
Assert.AreEqual(CountConnectedComponents(components), components.Count - 2);
/* Test random unions */
Random random = new Random();
List <Tuple <int, int> > connections = new List <Tuple <int, int> >();
for (int i = 0; i < components.Count; i++)
{
int p = random.Next(0, components.Count);
int q = random.Next(0, components.Count);
connections.Add(new Tuple <int, int>(p, q));
uf.Union(p, q);
}
components = uf.Components();
foreach (var con in connections)
{
Assert.AreEqual(components[con.Item1], components[con.Item2]);
}
}
private string GetNotConnectedUnions()
{
List <string> result = new List <string>();
for (int i = 0; i < _unions.GetLength(0); i++)
{
int p = _unions[i, 0];
int q = _unions[i, 1];
if (!_unionFind.Connected(p, q))
{
_unionFind.Union(p, q);
result.Add($"{p} {q}");
}
}
return(string.Join(" : ", result));
}
public void WhenCall_Union_ShouldReturnCorrectComponentAndConnectedResults()
{
// Arrange
var testDataSet = FakeUnionData.Data();
// Act
foreach (var obj in testDataSet)
{
int p = (int)obj[0];
int q = (int)obj[1];
int componentCount = (int)obj[2];
int dot1 = (int)obj[3];
int dot2 = (int)obj[4];
bool res = (bool)obj[5];
unionFind.Union(p, q);
// Assert
Assert.Equal(unionFind.Count(), componentCount);
Assert.Equal(unionFind.Connected(dot1, dot2), res);
}
}
public void TestUnion()
{
sut.Union(0, 1);
Assert.AreEqual(1, sut.Find(0));
Assert.AreEqual(9, sut.Count());
}
public void Union(int source, int destination)
{
_unionFind.Union(source, destination);
}
