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()); } }