public void TestReverseIntSort()
{
var items = Enumerable.Range(1, 100).ToList().Shuffle();
var priorityQueue = new PriorityQueue<int>(true) { items };
Assert.That(priorityQueue.Peek(), Is.EqualTo(100));
Assert.That(priorityQueue.ToList(), Is.EquivalentTo(Enumerable.Range(1, 100).Reverse().ToList()));
}
public void TestSortWithDuplicateKeys()
{
var items = Enumerable.Range(1, 1000)
.Select(x => x % 10).ToList()
.Shuffle();
var priorityQueue = new PriorityQueue<int>() { items };
Assert.That(priorityQueue.Peek(), Is.EqualTo(0));
Assert.That(priorityQueue.ToList(), Is.EquivalentTo(items.OrderBy(x => x).ToList()));
}
static void Main()
{
// example structure as binary heap
// -4444 parent root at the beginning with children -5 and 1
// -5 with children 5 and 50, 1 with children 4 and 8
// 5 with children 999 and 19
// -4444
// -5 1
// 5 50 4 8
// 999 19
PriorityQueue<int> queue = new PriorityQueue<int>();
queue.Enqueue(5);
queue.Enqueue(19);
queue.Enqueue(-4444);
queue.Enqueue(1);
queue.Enqueue(50);
queue.Enqueue(4);
queue.Enqueue(8);
queue.Enqueue(999);
queue.Enqueue(-5);
Print(queue);
Console.WriteLine(queue.Dequeue());
// all are for testing
// Console.WriteLine();
// Print(queue);
Console.WriteLine(queue.Dequeue());
// Console.WriteLine();
// Print(queue);
Console.WriteLine(queue.Dequeue());
Console.WriteLine("----------------");
// Console.WriteLine();
// Print(queue);
Console.WriteLine("Peek: " + queue.Peek());
Console.WriteLine(queue.Count);
queue.Clear();
Console.WriteLine(queue.Count);
}
public void TestAdd()
{
var items = Enumerable.Range(100, 1000).ToList().Shuffle();
var priorityQueue = new PriorityQueue<int>() { items };
Enumerable.Range(1, 10).ToList().ForEach(priorityQueue.Add);
Enumerable.Range(10000, 10).ToList().ForEach(priorityQueue.Add);
((List<int>)items).AddRange(Enumerable.Range(1, 10));
((List<int>)items).AddRange(Enumerable.Range(10000, 10));
Assert.That(priorityQueue.Peek(), Is.EqualTo(1));
Assert.That(priorityQueue.ToList(), Is.EquivalentTo(items.OrderBy(x => x).ToList()));
}
public ArrayList BranchAndBound(City[] Cities, ArrayList Route, double BSSF)
{
Node startNode = new Node(Cities);
startNode.initStaticMembers();
PriorityQueue pQ = new PriorityQueue(startNode);
ArrayList bbRoute = null;
Stopwatch timer = new Stopwatch();
timer.Start();
//while ((pQ.Size() > 0) && (pQ.Peek() < BSSF) && (timer.Elapsed.TotalMinutes < 10))
while ((pQ.Size() > 0) && (pQ.Peek() < BSSF) && (timer.Elapsed.TotalSeconds < 30))
{
// Keep track of the largest size of the queue
if (pQ.Size() > Node.maxNodesCreated)
{
Node.maxNodesCreated = pQ.Size();
}
startNode = pQ.DeleteMinimum();
//startNode.matrix2Table();
// Check for a solution
if (startNode.includedEdges == Cities.Length)
{
ArrayList tempRoute = new ArrayList();
if (!startNode.exited.Contains(-1))
{
int index = 0;
while (tempRoute.Count < Cities.Length)
{
tempRoute.Add(Cities[startNode.exited[index]]);
index = startNode.exited[index];
}
BSSF = startNode.lowerBound;
bbRoute = tempRoute;
Node.numSolutions++;
}
}
Node incNode = new Node(startNode);
Node excNode = new Node(startNode);
Node maxInclude = null;
Node maxExclude = null;
double maxDiff = -1;
double diff = 0;
int maxRow = 0;
int maxCol = 0;
for (int row = 0; row < startNode.matrixSize; row++)
{
for (int col = 0; col < startNode.matrixSize; col++)
{
if (startNode.rcMatrix[row, col] == 0)
{
Node includeNode = new Node(incNode, true, row, col);
Node excludeNode = new Node(excNode, false, row, col);
diff = excludeNode.lowerBound - includeNode.lowerBound;
Node.numStatesCreated += 2;
if (diff > maxDiff)
{
maxDiff = diff;
maxRow = row;
maxCol = col;
maxInclude = new Node(includeNode);
maxExclude = new Node(excludeNode);
}
}
}
}
if (maxInclude != null && maxInclude.lowerBound < BSSF)
{
pQ.Insert(maxInclude);
}
else
{
Node.pruneCount++;
}
if (maxExclude != null && maxExclude.lowerBound < BSSF)
{
pQ.Insert(maxExclude);
}
else
{
Node.pruneCount++;
}
}
timer.Stop();
Node.timeElapsed = timer.ElapsedMilliseconds;
if (bbRoute == null)
{
return Route;
}
else
{
// Add the rest of the queue to the pruned count
Node.pruneCount += pQ.Size();
return bbRoute;
}
}
public static bool GetShortestPath(GridNode i_start, GridNode i_end, bool isDiagonal, out List<GridNode> o_path, out List<GridNode> o_open)
{
o_path = new List<GridNode>();
o_open = new List<GridNode>();
IDictionary<GridNode, GridNode> path = new Dictionary<GridNode, GridNode>();
IDictionary<GridNode, float> open = new Dictionary<GridNode, float>();
PriorityQueue<float, GridNode> priorityQueue = new PriorityQueue<float, GridNode>(30 * 30, Comparer<float>.Default);
priorityQueue.Add(new KeyValuePair<float, GridNode>(GetDistance(i_start, i_end, isDiagonal), i_start));
open.Add(new KeyValuePair<GridNode, float>(i_start, 0));
bool succeed = false;
while (!priorityQueue.IsEmpty)
{
KeyValuePair<float, GridNode> current = priorityQueue.Peek();
GridNode currentNode = current.Value;
float currentCost;
if (!open.TryGetValue(currentNode, out currentCost))
{
Debug.Assert(false);
}
if (currentNode == i_end)
{
succeed = true;
break;
}
foreach (GridNode neighbour in currentNode.GetNeighbors(isDiagonal))
{
if (neighbour.Passable)
{
float newCost = currentCost + GetCost(currentNode, neighbour, isDiagonal);
float oldCost;
if (!open.TryGetValue(neighbour, out oldCost))
{
path.Add(neighbour, currentNode);
open.Add(neighbour, newCost);
float dist = GetDistance(neighbour, i_end, isDiagonal);
priorityQueue.Add(new KeyValuePair<float, GridNode>(newCost + dist, neighbour));
}
else if (newCost < oldCost)
{
path[neighbour] = currentNode;
open[neighbour] = newCost;
float dist = GetDistance(neighbour, i_end, isDiagonal);
priorityQueue.Remove(new KeyValuePair<float, GridNode>(oldCost + dist, neighbour));
priorityQueue.Add(new KeyValuePair<float, GridNode>(newCost + dist, neighbour));
}
}
}
priorityQueue.Remove(current);
}
if (succeed)
{
GridNode currentNode = i_end;
o_path.Add(currentNode);
while (path.ContainsKey(currentNode))
{
currentNode = path[currentNode];
o_path.Add(currentNode);
}
o_path.Reverse();
}
o_open = open.Keys.ToList();
return succeed;
}
public void Count()
{
var pq = new PriorityQueue<int>();
Assert.AreEqual(0, pq.Count);
pq.Enqueue(123);
Assert.AreEqual(1, pq.Count);
pq.Enqueue(31);
pq.Enqueue(64);
Assert.AreEqual(3, pq.Count);
for (int i = 0; i < 30; i++)
pq.Enqueue(i);
pq.Peek();
pq.Dequeue();
pq.Dequeue();
Assert.AreEqual(31, pq.Count);
pq.Clear();
Assert.AreEqual(0, pq.Count);
}
public void Test()
{
var pq = new PriorityQueue<int>();
var random = new Random();
for (int i = 0; i < 100; i++)
{
var value = random.Next(0, 20);
pq.Enqueue(value);
pq.Validate();
}
var max = int.MaxValue;
for (int i = 0; i < 100; i++)
{
Assert.AreEqual(100 - i, pq.Count);
var peek = pq.Peek();
var value = pq.Dequeue();
Assert.AreEqual(peek, value);
Assert.IsTrue(max >= value);
max = value;
pq.TrimExcess();
}
}