public void AddTest()
{
_minHeap = new MinBinaryHeap <int>();
for (int i = 0; i < _intArray.Length; i++)
{
_minHeap.Add(_intArray[i]);
Assert.AreEqual(_minHeap.Count, i + 1);
}
}
public Path CalculatePath(Vector2 startPoint, Vector2 endPoint)
{
PathNode startNode = _grid.GetValue(startPoint);
PathNode endNode = _grid.GetValue(endPoint);
bool isFound = false;
PathNode[] pathNodes = null;
if (endNode.IsObstacle)
{
endNode = TryFindOptimalNeighbour(startNode, endNode);
if (endNode == null)
{
return(new Path(null, false));
}
}
_openSet = new MinBinaryHeap <PathNode>();
_closedSet = new HashSet <PathNode>();
_openSet.Add(startNode);
while (_openSet.HeapSize > 0)
{
PathNode currentNode = _openSet.RemoveFirst();
_closedSet.Add(currentNode);
if (currentNode == endNode)
{
pathNodes = RetracePath(startNode, endNode);
if (pathNodes.Length > 0)
{
isFound = true;
}
break;
}
if (currentNode.Neighbours == null)
{
currentNode.SetNeighbours(GetNeighbours(currentNode));
}
foreach (PathNode neighbour in currentNode.Neighbours)
{
if (_closedSet.Contains(neighbour))
{
continue;
}
CheckNeighbour(currentNode, neighbour, endNode);
}
}
return(new Path(pathNodes, isFound));
}
public MinBinaryHeap <int, int> TestMinHeap()
{
var values = new List <int>()
{
3, 7, 10, 1, 4, 4, 0, 20, 15, 12
};
var minHeap = new MinBinaryHeap <int, int>(values.Count);
values.ForEach(v => minHeap.Add(v, v));
return(minHeap);
}
public void AddFollowedByPopTest()
{
_minHeap = new MinBinaryHeap <int>();
for (int i = 0; i < _intArray.Length; i++)
{
_minHeap.Add(_intArray[i]);
Assert.IsTrue(_minHeap.Count == 1);
Assert.IsTrue(_minHeap.Pop(out int top));
Assert.AreEqual(top, _intArray[i]);
Assert.IsTrue(_minHeap.Count == 0);
}
}
private void CheckNeighbour(PathNode currentNode, PathNode neighbour, PathNode endNode)
{
int newDistanceCost = currentNode.GCost + currentNode.GetDistanceCost(neighbour);
if (newDistanceCost < neighbour.GCost || !_openSet.Contains(neighbour))
{
neighbour.UpdateNode(newDistanceCost, neighbour.GetDistanceCost(endNode), currentNode);
if (!_openSet.Contains(neighbour))
{
_openSet.Add(neighbour);
}
else
{
_openSet.Heapify(neighbour);
}
}
}
public static Graph Build(string[] file)
{
if (file.Length < 1)
throw new ArgumentException("No info in file!");
var count = int.Parse(file[0]);
if (file.Length < count + 1)
throw new ArgumentException("Wrong lines count!");
var points = Enumerable.Range(0, count).Select(i => new Point(i)).ToArray();
var edges = new MinBinaryHeap<Edge>();
for (var i = 1; i < count + 1; i++)
{
var positions =
file[i].Split(new[] {';'}, StringSplitOptions.RemoveEmptyEntries)
.Select(s => s.Split(new[] {','}, StringSplitOptions.RemoveEmptyEntries))
.ToArray();
foreach (var positionInString in positions)
{
var position = int.Parse(positionInString[0]);
var weight = int.Parse(positionInString[1]);
var from = points[i - 1];
var to = points[position];
if (!edges.Any(edge => edge.ContainsPoints(from, to)))
{
edges.Add(new Edge(from, to, weight));
}
}
}
return new Graph(edges, count, points);
}
public static void DoTest ()
{
MinBinaryHeap<long> minHeap = new MinBinaryHeap<long> (Comparer<long>.Default);
minHeap.Add (23);
minHeap.Add (42);
minHeap.Add (4);
minHeap.Add (16);
minHeap.Add (8);
minHeap.Add (15);
minHeap.Add (9);
minHeap.Add (55);
minHeap.Add (0);
minHeap.Add (34);
minHeap.Add (12);
minHeap.Add (2);
minHeap.Add (93);
minHeap.Add (14);
minHeap.Add (27);
var array = minHeap.ToArray ();
Debug.Assert (array.Length == minHeap.Count(), "Wrong size.");
var list = minHeap.ToList ();
Debug.Assert (list.Count == minHeap.Count(), "Wrong size.");
array.HeapSortDescending();
var maxHeap = minHeap.ToMaxHeap ();
Debug.Assert (maxHeap.Peek() == array[0], "Wrong maximum.");
}
public static void DoTest()
{
MinBinaryHeap <long> minHeap = new MinBinaryHeap <long> (Comparer <long> .Default);
minHeap.Add(23);
minHeap.Add(42);
minHeap.Add(4);
minHeap.Add(16);
minHeap.Add(8);
minHeap.Add(15);
minHeap.Add(9);
minHeap.Add(55);
minHeap.Add(0);
minHeap.Add(34);
minHeap.Add(12);
minHeap.Add(2);
minHeap.Add(93);
minHeap.Add(14);
minHeap.Add(27);
var array = minHeap.ToArray();
Debug.Assert(array.Length == minHeap.Count(), "Wrong size.");
var list = minHeap.ToList();
Debug.Assert(list.Count == minHeap.Count(), "Wrong size.");
array.HeapSortDescending();
var maxHeap = minHeap.ToMaxHeap();
Debug.Assert(maxHeap.Peek() == array[0], "Wrong maximum.");
}
