static void add(PriorityHeap lows, PriorityHeap highs, int a) { if (lows.Count() == 0) { lows.Add(a); return; } if (a < lows.Peek()) { lows.Add(a); if (lows.Count() > highs.Count() + 1) { highs.Add(lows.Remove()); } } else { highs.Add(a); if (highs.Count() > lows.Count() + 1) { lows.Add(highs.Remove()); } } }
public static List <Edge> SpanningTree(Graph graph, int startNode) { // idea: // greedy approach, // iteratively grow spanning tree by respective shortest connection // reachable nodes are efficiently stored in a heap PriorityHeap distances = new PriorityHeap(graph.Nodes()); // these are the edges that connect a new node with our already // constructed spanning tree. Edge[] connectingEdge = new Edge[graph.Nodes()]; // store all reachable nodes with their distance. foreach (Edge edge in graph.Edges(startNode)) { int w = edge.Other(startNode); distances.Insert(w, edge.Weight()); connectingEdge[w] = edge; } // for all other nodes store an infinite distance. for (int v = 0; v < graph.Nodes(); v++) { if (v == startNode) { continue; } if (!distances.Contains(v)) { distances.Insert(v, System.Double.PositiveInfinity); } } // these are the already selected edges List <Edge> spanningTree = new List <Edge>(); while (!distances.Empty()) { // get the nearest node that is not yet in the spanning tree. int v = distances.DeleteMin(); // add its connecting edge to the spanning tree. spanningTree.Add(connectingEdge[v]); // consider all edges from v for the next step of the algorithm. foreach (Edge edge in graph.Edges(v)) { int w = edge.Other(v); // If we still need the node at the other end of that // edge and the edge weight is better than our currently // stored edge, store the new edge. if (distances.Contains(w) && edge.Weight() < distances.GetKey(w)) { distances.Change(w, edge.Weight()); connectingEdge[w] = edge; } } } return(spanningTree); }
public PriorityQueue(int initialSize, PriorityHeap <TValue> .LessOrEqual leq) { _leq = leq; _heap = new PriorityHeap <TValue>(initialSize, leq); _keys = new TValue[initialSize]; _size = 0; _max = initialSize; _initialized = false; }
private static IPriorityHeap <byte, string> GivenPriorityHeap() { var heap = new PriorityHeap <byte, string>(); heap.Insert(5, "Red"); heap.Insert(4, "Orange"); heap.Insert(3, "Yellow"); heap.Insert(2, "Green"); heap.Insert(1, "Blue"); return(heap); }
public void Reset(int initialSize, PriorityHeap <TValue> .LessOrEqual leq) { _leq = leq; _heap.Reset(initialSize, leq); if (_keys.Count < initialSize) { _keys.AddRange(new TValue[initialSize - _keys.Count]); } _size = 0; _max = initialSize; _initialized = false; }
static void Main(String[] args) { int n = Convert.ToInt32(Console.ReadLine()); int[] a = new int[n]; PriorityHeap lows = new PriorityHeap(n, true); PriorityHeap highs = new PriorityHeap(n); for (int a_i = 0; a_i < n; a_i++) { a[a_i] = Convert.ToInt32(Console.ReadLine()); add(lows, highs, a[a_i]); Console.WriteLine("{0:f1}", median(lows, highs)); } }
static decimal median(PriorityHeap lows, PriorityHeap highs) { if (lows.Count() == highs.Count()) { return(((decimal)(lows.Peek() + highs.Peek())) / 2); } else if (lows.Count() > highs.Count()) { return(lows.Peek()); } else { return(highs.Peek()); } }
public static List <int> GreedyTour(double[,] D, int v_0) { int V = D.GetLength(0); // erzeuge Tour List <int> tour = new List <int>(V + 1); var heap = new PriorityHeap(V); heap.Insert(v_0, 0); //start tour.Add(v_0); var lastNode = v_0; for (int i = 0; i < V - 1; i++) { int shortestNode = -1; double shortestDistance = Double.PositiveInfinity; for (int j = 0; j < V; j++) { if (lastNode == j || heap.Contains(j)) { continue; } if (shortestDistance > D[lastNode, j]) { shortestNode = j; shortestDistance = D[lastNode, j]; } } lastNode = shortestNode; heap.Insert(shortestNode, shortestDistance); tour.Add(shortestNode); } //end tour.Add(v_0); return(tour); }
public NodePriorityHeap() { this.OpenHeap = new PriorityHeap <NodeRecord>(); }
public NodePriorityHeap() { this.OpenHeap = new PriorityHeap<NodeRecord>(); }
public Agent() { _queuedActions = new PriorityHeap <float, IAction <TContext> >(); _strategies = new List <IStrategy <TContext> >(DEFAULT_STRATEGY_CAPACITY); _locked = false; }
public LocationPriorityHeap() { this.OpenHeap = new PriorityHeap <LocationRecord>(); }