public void WorkPriorityQueue()
{
//throw new NotImplementedException();
PriorityQueue<int> testQueue = new PriorityQueue<int>();
testQueue.Enqueue(1, 0);
testQueue.Enqueue(2, 0);
testQueue.Enqueue(3, 0);
testQueue.Enqueue(4, 0);
testQueue.Enqueue(5, 0);
testQueue.Enqueue(1, 2);
testQueue.Enqueue(2, 2);
testQueue.Enqueue(3, 3);
testQueue.Enqueue(4, 3);
testQueue.Enqueue(5, 5);
Console.WriteLine();
Console.WriteLine("First test {0}", testQueue.First()); // 1
Console.WriteLine("Last test {0}", testQueue.Last()); // 5
Console.WriteLine("First test {0} с приоритетом {1}", testQueue.First(2), 2); //1
Console.WriteLine("Last test {0} с приоритетом {1}", testQueue.Last(3), 3); // 4
int p1 = 0;
Console.WriteLine("число элементов с приоритетом {0} = {1}", p1, testQueue.GetCount(p1)); //5
p1 = 2;
Console.WriteLine("число элементов с приоритетом {0} = {1}", p1, testQueue.GetCount(p1)); //2
p1 = 5;
Console.WriteLine("число элементов с приоритетом {0} = {1}", p1, testQueue.GetCount(p1)); //1
Console.ReadKey();
}
public static Path<Node> FindPath(
Node start,
Node destination,
Func<Node, Node, double> distance,
Func<Node, double> estimate)
{
var closed = new HashSet<Vector2>();
var queue = new PriorityQueue<double, Path<Node>>();
queue.Enqueue(0, new Path<Node>(start));
while (!queue.IsEmpty)
{
var path = queue.Dequeue();
if (closed.Contains(path.LastStep.Point))
{
continue;
}
if (path.LastStep.Point.Equals(destination.Point))
return path;
closed.Add(path.LastStep.Point);
foreach (Node n in path.LastStep.Neightbours)
{
double d = distance(path.LastStep, n);
var newPath = path.AddStep(n, d);
queue.Enqueue(newPath.TotalCost + estimate(n), newPath);
}
}
return null;
}
public PathFinder(Grid graph, Cell start, Cell goal)
{
// Priority Queue which contains cells that are candidates for examining, lowest priority to the node with the lowest f value
var frontier = new PriorityQueue<Cell>();
frontier.Enqueue(start, 0);
cameFrom[start] = start;
costSoFar[start] = 0;
while (frontier.Count > 0)
{
var current = frontier.Dequeue();
// Exit the search if goal have discovered
if (current.Equals(goal)) { break; }
// discovers the neighbours
foreach (var next in graph.Neighbors(current))
{
int newCost = costSoFar[current] + graph.Cost(current, next);
if (!costSoFar.ContainsKey(next) || newCost < costSoFar[next])
{
costSoFar[next] = newCost;
// f = g + h
int priority = newCost + Heuristic(next, goal);
frontier.Enqueue(next, priority);
cameFrom[next] = current;
}
}
}
}
public static void Main()
{
// 1.
var priorityQueue = new PriorityQueue<int>();
priorityQueue.Enqueue(2);
priorityQueue.Enqueue(7);
priorityQueue.Enqueue(17);
priorityQueue.Enqueue(19);
priorityQueue.Enqueue(26);
priorityQueue.Enqueue(29);
priorityQueue.Dequeue();
priorityQueue.Enqueue(3);
priorityQueue.Enqueue(1);
priorityQueue.Dequeue();
priorityQueue.Enqueue(25);
priorityQueue.Enqueue(36);
priorityQueue.Dequeue();
Console.WriteLine();
// 2.
PrintFirst20Products();
Console.WriteLine();
// 3.
CountWords();
}
public static void DijkstraAlgorithm(Dictionary<Node, List<Connection>> graph, Node source)
{
PriorityQueue<Node> queue = new PriorityQueue<Node>();
foreach (var node in graph)
{
node.Key.DijkstraDistance = long.MaxValue;
}
source.DijkstraDistance = 0;
queue.Enqueue(source);
while (queue.Count != 0)
{
Node currentNode = queue.Dequeue();
if (currentNode.DijkstraDistance == long.MaxValue)
{
break;
}
foreach (var connection in graph[currentNode])
{
var potDistance = currentNode.DijkstraDistance + connection.Distance;
if (potDistance < connection.ToNode.DijkstraDistance)
{
connection.ToNode.DijkstraDistance = potDistance;
queue.Enqueue(connection.ToNode);
}
}
}
}
public static void DijkstraAlgorithm(Dictionary<Node, List<Connection>> graph, Node source)
{
var queue = new PriorityQueue<Node>();
foreach (var node in graph)
{
node.Key.DijkstraDistance = double.PositiveInfinity;
}
source.DijkstraDistance = 0.0d;
queue.Enqueue(source);
while (queue.Count != 0)
{
var currentNode = queue.Dequeue();
if (double.IsPositiveInfinity(currentNode.DijkstraDistance))
{
break;
}
foreach (var neighbor in graph[currentNode])
{
var potDistance = currentNode.DijkstraDistance + neighbor.Distance;
if (potDistance < neighbor.Node.DijkstraDistance)
{
neighbor.Node.DijkstraDistance = potDistance;
queue.Enqueue(neighbor.Node);
}
}
}
}
public void TestBasicFunctionality()
{
var q = new PriorityQueue<int>();
Assert.AreEqual(0, q.Count);
Assert.AreEqual(0, q.Capacity);
Assert.Throws<InvalidOperationException>(() => q.Peek());
Assert.Throws<InvalidOperationException>(() => q.Dequeue());
q.Enqueue(5);
q.Enqueue(2);
q.Enqueue(4);
Assert.AreEqual(3, q.Count);
Assert.IsTrue(q.Capacity >= 3);
Assert.IsTrue(q.Contains(2));
Assert.IsFalse(q.Contains(3));
Assert.AreEqual(3, q.ToArray().Length);
CollectionAssert.AreEqual(q.ToArray(), q);
Assert.AreEqual(2, q.Peek());
Assert.AreEqual(2, q.Dequeue());
Assert.AreEqual(4, q.Dequeue());
Assert.AreEqual(5, q.Dequeue());
}
public static void FindMinimalPaths(Dictionary<Node, List<Street>> graph, Node source)
{
PriorityQueue<Node> queue = new PriorityQueue<Node>();
foreach (var node in graph)
{
if (source.ID != node.Key.ID)
{
node.Key.DijkstraDistance = ulong.MaxValue;
}
}
source.DijkstraDistance = 0;
queue.Enqueue(source);
while (queue.Count != 0)
{
Node currentNode = queue.Dequeue();
foreach (var neighbour in graph[currentNode])
{
ulong potDistance = currentNode.DijkstraDistance + neighbour.Distance;
if (potDistance < neighbour.Node.DijkstraDistance)
{
neighbour.Node.DijkstraDistance = potDistance;
// adds only modified elements in the queue
// thus reordering the queue after each iteration is avoided
queue.Enqueue(neighbour.Node);
}
}
}
}
public void PriorityQueue()
{
PriorityQueue<int> pq = new PriorityQueue<int>(LinqExt.TakeMore);
pq.Enqueue(1, 1);
pq.Enqueue(9, 9);
pq.Enqueue(2, 2);
pq.Enqueue(5, 5);
Assert.IsTrue(pq.First() == 9, "Wrong Priority");
Assert.IsTrue(pq.Dequeue() == 9, "Wrong Priority");
Assert.IsTrue(pq.Dequeue() == 5, "Wrong Priority");
pq.ChangePriority(1, 29);
Assert.IsTrue(pq.First() == 1, "Wrong Priority, 1 should be first priority now with priority 29");
pq.Enqueue(3, 2); //add item with same priority
pq.Enqueue(4, 2); //add item with same priority
Assert.IsTrue(pq.Last() == 4, "Wrong Priority, 4 should be last");
pq.Enqueue(30, 30); // mix case
Assert.IsTrue(pq.First() == 30, "Wrong Priority, 30 should be first priority");
pq.Enqueue(31, 30); // mix case
Assert.IsTrue(pq.First() == 30, "Wrong Priority, 30 should still be first priority");
pq.Enqueue(5, 2); //add item with same priority
pq.Enqueue(6, 2); //add item with same priority
Assert.IsTrue(pq.Last() == 6, "Wrong Priority, 6 should be last");
}
private static void Dijkstra(Graph<int> graph, Node<int> source)
{
var queue = new PriorityQueue<Node<int>>();
foreach (var node in graph.NodesCollection.Keys)
{
node.DijkstraDistance = double.PositiveInfinity;
}
source.DijkstraDistance = 0.0d;
queue.Enqueue(source);
while (queue.Count != 0)
{
var currentNode = queue.Dequeue();
if (double.IsPositiveInfinity(currentNode.DijkstraDistance))
{
break;
}
foreach (var neighbor in currentNode.Collection)
{
var potDistance = currentNode.DijkstraDistance + neighbor.Distance;
if (potDistance < neighbor.Target.DijkstraDistance)
{
neighbor.Target.DijkstraDistance = potDistance;
queue.Enqueue(neighbor.Target);
}
}
}
}
public static void Main()
{
//Heap test
//Heap<int> testHeap = new Heap<int>();
//testHeap.Push(3);
//testHeap.Push(4);
//testHeap.Push(5);
//testHeap.Push(1);
//testHeap.Push(6);
//while (testHeap.Count > 0)
//{
// testHeap.Pop();
// testHeap.Print();
//}
//Queue test
PriorityQueue<int> queue = new PriorityQueue<int>();
queue.Enqueue(3);
queue.Enqueue(4);
queue.Enqueue(5);
queue.Enqueue(1);
queue.Enqueue(6);
queue.Print();
while (queue.Count > 0)
{
queue.Dequeue();
queue.Print();
}
}
// Dijkstra's shortest paths algorithm, implemented
// with priority queue. Running time: O(M * log M)
// Learn more at: https://en.wikipedia.org/wiki/Dijkstra%27s_algorithm#Using_a_priority_queue
public static void DijkstraAlgorithm(
Dictionary<Node, List<Edge>> graph,
Node sourceNode)
{
var queue = new PriorityQueue<Node>();
foreach (var node in graph)
{
node.Key.Distance = double.PositiveInfinity;
}
sourceNode.Distance = 0.0d;
queue.Enqueue(sourceNode);
while (queue.Count != 0)
{
var currentNode = queue.Dequeue();
if (double.IsPositiveInfinity(currentNode.Distance))
{
// All nodes processed --> algorithm finished
break;
}
foreach (var childEdge in graph[currentNode])
{
var newDistance = currentNode.Distance + childEdge.Distance;
if (newDistance < childEdge.Node.Distance)
{
childEdge.Node.Distance = newDistance;
childEdge.Node.PreviousNode = currentNode;
queue.Enqueue(childEdge.Node);
}
}
}
}
static void Main(string[] args)
{
var queue = new PriorityQueue<int>();
queue.Enqueue(5);
queue.Enqueue(8);
queue.Enqueue(3);
queue.Enqueue(4);
queue.Enqueue(11);
foreach (var i in queue)
{
Console.WriteLine(i);
}
Console.WriteLine("*******Removed value:{0}",queue.Dequeue());
foreach (var i in queue)
{
Console.WriteLine(i);
}
Console.WriteLine("*******Removed value:{0}", queue.Dequeue());
foreach (var i in queue)
{
Console.WriteLine(i);
}
}
public static void DijkstraAlgorithm(Dictionary<Node, List<Connection>> graph, Node source)
{
PriorityQueue<Node> queue = new PriorityQueue<Node>();
foreach (var item in graph)
{
item.Key.DijkstraDistance = long.MaxValue;
}
queue.Enqueue(source);
source.DijkstraDistance = 0;
while (queue.Count != 0)
{
var currentNode = queue.Dequeue();
foreach (var connection in graph[currentNode])
{
var dist = connection.Distance + currentNode.DijkstraDistance;
if (dist < connection.ToNode.DijkstraDistance)
{
connection.ToNode.DijkstraDistance = dist;
queue.Enqueue(connection.ToNode);
}
}
}
}
static void Main(string[] args)
{
//var queue = new PriorityQueue<int>();
//queue.Enqueue(99);
//queue.Enqueue(2);
//queue.Enqueue(10);
//queue.Enqueue(25);
//queue.Enqueue(11);
//queue.Enqueue(3);
//queue.Enqueue(7);
//queue.Enqueue(22);
//queue.Enqueue(5);
//queue.Enqueue(1);
//queue.Enqueue(45);
//queue.Enqueue(31);
var queue = new PriorityQueue<Student>();
queue.Enqueue(new Student() { Name = "Ivan", Age = 27 });
queue.Enqueue(new Student() { Name = "Pesho", Age = 21 });
queue.Enqueue(new Student() { Name = "Dragan", Age = 24 });
queue.Enqueue(new Student() { Name = "Gosho", Age = 18 });
queue.Enqueue(new Student() { Name = "Todor", Age = 25 });
while (queue.Count > 0)
{
Console.WriteLine(queue.Dequeue().ToString());
}
}
public static void Main(string[] args)
{
PriorityQueue<Student> payQueue = new PriorityQueue<Student>();
for (int i = 0; i < 5; i++)
{
payQueue.Enqueue(new Student("Student" + i, 12, true));
}
for (int i = 5; i < 10; i++)
{
payQueue.Enqueue(new Student("Student" + i, 12, false));
}
for (int i = 0; i < 5; i++)
{
payQueue.Enqueue(new Student("StudentVer2" + i, 12, true));
}
int payQueueLength = payQueue.Count;
for (int i = 0; i < payQueueLength; i++)
{
Console.WriteLine(payQueue.Dequeue().ToString());
}
}
public void EnqDeq()
{
var pq = new PriorityQueue<string>();
pq.Enqueue(1, "world");
pq.Enqueue(2, "hello");
Assert.AreEqual("hello", pq.Dequeue());
Assert.AreEqual("world", pq.Dequeue());
}
public static List<int> DijkstraAlgorithm(Dictionary<Node,Dictionary<Node,int>> graph, Dictionary<int,Node> nodes, int sourceNode, int destinationNode)
{
int[] previous = new int[graph.Count];
bool[] visited = new bool[graph.Count];
PriorityQueue<Node> priorityQueue = new PriorityQueue<Node>();
var startNode = nodes[sourceNode];
startNode.DistanceFromStart = 0;
for (int i = 0; i < previous.Length; i++)
{
previous[i] = -1;
}
priorityQueue.Enqueue(startNode);
while (priorityQueue.Count > 0)
{
var currentNode = priorityQueue.ExtractMin();
if (currentNode.Index == destinationNode)
{
break;
}
foreach (var edge in graph[currentNode])
{
if (!visited[edge.Key.Index])
{
priorityQueue.Enqueue(edge.Key);
visited[edge.Key.Index] = true;
}
var distance = currentNode.DistanceFromStart + edge.Value;
if (distance < edge.Key.DistanceFromStart)
{
edge.Key.DistanceFromStart = distance;
previous[edge.Key.Index] = currentNode.Index;
priorityQueue.DecreaseKey(edge.Key);
}
}
}
if (previous[destinationNode] == -1)
{
return null;
}
List<int> path = new List<int>();
int current = destinationNode;
while (current != -1)
{
path.Add(current);
current = previous[current];
}
path.Reverse();
return path;
}
public void Enqueue_with_different_priorities_in_reverse_order()
{
var queue = new List<PriorityQueue<string>.Element>();
var sut = new PriorityQueue<string>(queue);
sut.Enqueue("c", 1);
sut.Enqueue("b", 5);
sut.Enqueue("a", 10);
Assert.That(queue, Is.EqualTo(new[] { new PriorityQueue<string>.Element("a", 10), new PriorityQueue<string>.Element("b", 5), new PriorityQueue<string>.Element("c", 1) }));
}
public void TestCount()
{
PriorityQueue<int, string> q = new PriorityQueue<int, string>();
q.Enqueue(0, "a");
q.Enqueue(-1, "b");
q.Enqueue(1, "c");
Assert.AreEqual(3, q.Count);
}
public void TestOrder()
{
PriorityQueue<int, string> q = new PriorityQueue<int, string>();
q.Enqueue(0, "a");
q.Enqueue(-1, "b");
q.Enqueue(1, "c");
Assert.AreEqual("b", q.Dequeue());
Assert.AreEqual("a", q.Dequeue());
Assert.AreEqual("c", q.Dequeue());
q.Enqueue(0, "a");
q.Enqueue(0, "b");
q.Enqueue(0, "c");
q.Enqueue(1, "c");
q.Enqueue(1, "d");
q.Enqueue(1, "e");
Assert.AreEqual("a", q.Dequeue());
Assert.AreEqual("b", q.Dequeue());
Assert.AreEqual("c", q.Dequeue());
Assert.AreEqual("c", q.Dequeue());
Assert.AreEqual("d", q.Dequeue());
Assert.AreEqual("e", q.Dequeue());
}
public void PriorityQueueClearEmptiesTheQueue()
{
var q = new PriorityQueue<int>();
q.Enqueue(AnyInt);
q.Enqueue(AnyInt);
q.Clear();
Assert.Equal(0, q.Count);
Assert.Throws<InvalidOperationException>(() => q.Peek());
}
public void BasicTest()
{
var pq = new PriorityQueue<int>();
pq.Enqueue(5);
pq.Enqueue(3);
pq.Enqueue(10);
pq.Enqueue(1);
Assert.AreEqual(1, pq.Dequeue());
Assert.AreEqual(3, pq.Dequeue());
Assert.AreEqual(5, pq.Dequeue());
Assert.AreEqual(10, pq.Dequeue());
}
public void TestConstructWithComparer()
{
var q = new PriorityQueue<int>(Comparer<int>.Create((a, b) => -a.CompareTo(b)));
q.Enqueue(5);
q.Enqueue(2);
q.Enqueue(4);
Assert.AreEqual(5, q.Dequeue());
Assert.AreEqual(4, q.Dequeue());
Assert.AreEqual(2, q.Dequeue());
}
public void New_highest_prio_is_added_at_head()
{
var sut = new PriorityQueue<string>();
sut.Enqueue("0");
sut.Enqueue(1, "1");
sut.Enqueue(2, "2");
Assert.AreEqual("2", sut.Dequeue());
Assert.AreEqual("1", sut.Dequeue());
Assert.AreEqual("0", sut.Dequeue());
}
public void CustomComparer()
{
var pq = new PriorityQueue<int>(
(lhs, rhs) => (10 - lhs).CompareTo(10 - rhs)
);
pq.Enqueue(5);
pq.Enqueue(3);
pq.Enqueue(10);
pq.Enqueue(1);
Assert.AreEqual(10, pq.Dequeue());
Assert.AreEqual(5, pq.Dequeue());
Assert.AreEqual(3, pq.Dequeue());
Assert.AreEqual(1, pq.Dequeue());
}
public void TestConstructWithCapacity()
{
var q = new PriorityQueue<int>(10);
Assert.AreEqual(0, q.Count);
Assert.AreEqual(10, q.Capacity);
q.Enqueue(5);
q.Enqueue(4);
q.TrimExcess();
Assert.AreEqual(2, q.Count);
Assert.AreEqual(2, q.Capacity);
}
public void WorkPriorityQueue()
{
var intPriorityQueue = new PriorityQueue<int>();
var stringPriorityQueue = new PriorityQueue<string>();
var userPriorityQueue = new PriorityQueue<User>();
try
{
intPriorityQueue.Enqueue(5, 1);
intPriorityQueue.Enqueue(40, 1);
Console.WriteLine("Number of elements of 1st order in queue = {0}", intPriorityQueue.GetCount(1));
Console.WriteLine("First element of 1st priority = {0}", intPriorityQueue.First());
Console.WriteLine("Last element of 1st priority = {0}", intPriorityQueue.Last());
intPriorityQueue.Dequeue();
intPriorityQueue.Enqueue(671, 2);
intPriorityQueue.Enqueue(30, 4);
intPriorityQueue.Enqueue(8932, 4);
Console.WriteLine("First element of 4th priority = {0}", intPriorityQueue.First(4));
Console.WriteLine("Last element of 4th priority = {0}", intPriorityQueue.Last(4));
Console.WriteLine("Queue length = {0}", intPriorityQueue.Count);
stringPriorityQueue.Enqueue("", 7);
stringPriorityQueue.Enqueue("40", 7);
//Console.WriteLine("Number of elements of 1st order in queue = {0}", stringPriorityQueue.GetCount(1));
Console.WriteLine("First element of 1st priority = {0}", stringPriorityQueue.First());
Console.WriteLine("Last element of 1st priority = {0}", stringPriorityQueue.Last());
stringPriorityQueue.Dequeue();
stringPriorityQueue.Enqueue("thirteen", 4);
stringPriorityQueue.Enqueue("god", 4);
Console.WriteLine("First element of 4th priority = {0}", stringPriorityQueue.First(4));
Console.WriteLine("Last element of 4th priority = {0}", stringPriorityQueue.Last(4));
Console.WriteLine("Queue length = {0}", stringPriorityQueue.Count);
userPriorityQueue.Enqueue(new User("Bardara", "Morgrad", new DateTime(1992, 12, 5)), 1);
userPriorityQueue.Enqueue(new User("Viki", "Crachkovic", new DateTime(1982, 2, 5)), 2);
Console.WriteLine("Number of elements of 1st order in queue = {0}", userPriorityQueue.GetCount(1));
Console.WriteLine("First element of 1st priority = {0}", userPriorityQueue.First().FullName);
Console.WriteLine("Last element of 1st priority = {0}", userPriorityQueue.Last().FullName);
userPriorityQueue.Dequeue();
userPriorityQueue.Enqueue(new User("Somalien", "Fred", new DateTime(1976, 12, 5)), 2);
//Console.WriteLine("First element of 4th priority = {0}", userPriorityQueue.First(4).FullName);
//Console.WriteLine("Last element of 4th priority = {0}", userPriorityQueue.Last(4).FullName);
Console.WriteLine("Queue length = {0}", userPriorityQueue.Count);
}
catch (Exception e)
{
Console.WriteLine("Exception occured - {0}", e.Message);
}
Console.ReadKey();
}
public void TestPriorityDequeue()
{
PriorityQueue<int, int> q = new PriorityQueue<int, int>();
q.Enqueue(1, 1);
q.Enqueue(1, 2);
q.Enqueue(1, 3);
q.Enqueue(1, 4);
q.Enqueue(10, 11);
q.Enqueue(10, 12);
q.Enqueue(10, 13);
q.Enqueue(10, 14);
Assert.AreEqual(8, q.Count);
Assert.AreEqual(4, q.GetPriorityCount(1));
Assert.AreEqual(1, q.Dequeue(1));
Assert.AreEqual(2, q.Dequeue(1));
Assert.AreEqual(3, q.Dequeue(1));
Assert.AreEqual(4, q.Dequeue(1));
Assert.AreEqual(0, q.GetPriorityCount(1));
Assert.AreEqual(4, q.Count);
Assert.AreEqual(4, q.GetPriorityCount(10));
Assert.AreEqual(11, q.Dequeue(10));
Assert.AreEqual(12, q.Dequeue(10));
Assert.AreEqual(13, q.Dequeue(10));
Assert.AreEqual(14, q.Dequeue(10));
Assert.AreEqual(0, q.GetPriorityCount(10));
}
static void Main(string[] args)
{
PriorityQueue<string> testQueue = new PriorityQueue<string>();
testQueue.Enqueue(1, "One");
testQueue.Enqueue(-1, "NegativeOne");
testQueue.Enqueue(1, "BiggerNumber");
while (testQueue.Count > 0)
{
Console.WriteLine(testQueue.Dequeue().ToString());
}
}
