public void minHeapify(int idx)
{
int smallest, left, right;
smallest = idx;
left = 2 * idx + 1;
right = 2 * idx + 2;
if (left < this.size &&
this.array[left].dist < this.array[smallest].dist)
{
smallest = left;
}
if (right < this.size &&
this.array[right].dist < this.array[smallest].dist)
{
smallest = right;
}
if (smallest != idx)
{
// The nodes to be swapped in min heap
MinHeapNode smallestNode = this.array[smallest];
MinHeapNode idxNode = this.array[idx];
// Swap positions
this.pos[smallestNode.v] = idx;
this.pos[idxNode.v] = smallest;
// Swap nodes
MinHeapNode temp = this.array[smallest];
this.array[smallest] = this.array[idx];
this.array[idx] = temp;
minHeapify(smallest);
}
}
//public static void printArr(Cell[] dist, int n)
//{
// Console.WriteLine("\n\n Vertex \t\t Distance from Source \t\t parent \n");
// for (int i = 0; i < n; ++i)
// Console.WriteLine("\n" + i + " \t\t " + dist[i].distance + " \t\t" + dist[i].Parent);
//}
// The main function that calulates distances of shortest paths from src to all
// vertices. It is a O(ELogV) function
public static Cell[] Dijkstra(Graph graph, int src)
{
int vv = graph.v; // Get the number of vertices in graph
Cell[] dist = new Cell[vv]; // dist values used to pick minimum weight edge in cut
for (int i = 0; i < vv; i++)
{
dist[i] = new Cell();
dist[i].i = src;
dist[i].j = i;
dist[i].Parent = 0;
dist[i].distance = int.MaxValue;
}
// minHeap represents set E
MinHeap minHeap = new MinHeap(vv);
// Initialize min heap with all vertices. dist value of all vertices
for (int v = 0; v < vv; ++v)
{
dist[v].distance = int.MaxValue;
minHeap.array[v] = new MinHeapNode(v, dist[v].distance);
minHeap.pos[v] = v;
}
// Make dist value of src vertex as 0 so that it is extracted first
minHeap.array[src] = new MinHeapNode(src, dist[src].distance);
minHeap.pos[src] = src;
dist[src].distance = 0;
minHeap.decreaseKey(src, dist[src].distance);
// Initially size of min heap is equal to V
minHeap.size = vv;
// In the followin loop, min heap contains all nodes
// whose shortest distance is not yet finalized.
while (!minHeap.isEmpty())
{
// Extract the vertex with minimum distance value
MinHeapNode minHeapNode = minHeap.extractMin();
int u = minHeapNode.v; // Store the extracted vertex number
// Traverse through all adjacent vertices of u (the extracted
// vertex) and update their distance values
AdjListNode pCrawl = graph.array[u].head;
while (pCrawl != null)
{
int v = pCrawl.dest;
// If shortest distance to v is not finalized yet, and distance to v
// through u is less than its previously calculated distance
if (minHeap.isInMinHeap(v) && dist[u].distance != int.MaxValue &&
pCrawl.weight + dist[u].distance < dist[v].distance)
{
dist[v].distance = dist[u].distance + pCrawl.weight;
dist[v].Parent = u;
// update distance value in min heap also
minHeap.decreaseKey(v, dist[v].distance);
}
pCrawl = pCrawl.next;
}
}
// print the calculated shortest distances
//printArr(dist, vv);
return(dist);
}
public void swapMinHeapNodeProblem(MinHeapNode a, MinHeapNode b, out MinHeapNode aa, out MinHeapNode bb)
{
aa = b;
bb = a;
}
