Question

Please write the complete code in C.

Write a C function that prints the minimum spanning tree of a graph. At the end,
print the weight of the spanning tree. A suggested report format is shown in the
following example.
Source Vertex To Vertex Weight
A B 2
A C 4
B D 3
D E 1
Total weight of spanning tree: 10
Your main program will read a graph from DataIn file to an adjacency table
before calling the function.

There is a 'skeleton code' given, so can someone just fill it up:

//Q4
//Find out the minimum spanning tree (MST) of a graph which is stored in **AM1
//The MST will be stored in AM2.
//The output format should follow the specification

#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include <ctype.h>

#define INFINITY   0
#define MAXNODE       26

// Pointer to the file you want to read and write.
FILE *fp;

int NumberOfNode = 0;

// Initialize the Adjacency table **AM
// In this function, you should set all elements in the Adjacency table to INFINITY
void InitAM(int **AM)
{
   //*********
   //Add your code here
   //*********
   //*********
}

//Read the Graph from the input file to **AM
//
int ReadGraph(int **AM)
{
   //open file
   fp = fopen ("DataIn.txt", "r");  
  
if (fp == NULL)
   {
       printf("Unable to open file.");
       return 0;
   }
   else
   {
       int i = 0;
       // get the number of nodes of the graph
       fscanf (fp, "%d\n", &NumberOfNode);      
      
       for (;i< NumberOfNode;i++ )
       {
           int NodeOfLine = 0;
           int NumberOfNodesLine = 0;
           int node = 0;
           int weight = INFINITY;

//get the current node
           fscanf (fp, "%d", &NodeOfLine);

           if(NodeOfLine == (i+1))
           {
               int j=0;

               //get the number of nodes connected to the current node
               fscanf (fp, "%d", &NumberOfNodesLine);
          

               for (;j< NumberOfNodesLine;j++ )
               {
                   //get the weight of the link
                   fscanf (fp, "%d", &node);
                   fscanf (fp, "%d", &weight);
                   AM[i][node] = weight;                  
               }

               fscanf (fp, "\n");              

           }
           else
           {
               return 0;
           }
       }
          
   }      
  
   fclose(fp);
   return 1;

}

//find the minimum spanning tree (MST) from **AM1, and store the MSP in **AM2
//
int MPS_tree(int **AM1,int **AM2)
{
   //*********
   //Add your code here
   //*********
   //*********

}

//print out the minimum spanning tree in **AM, as specified in Q4
//
void WriteMPS(int ** AM)
{
   //*********
   //Add your code here
   //*********
   //*********

}

///print out the graph in **AM, for testing
// In this function, all you have to do is to print every element in the Adjacency table **AM
//
void WriteGraph(int ** AM)
{
   //*********
   //Add your code here
   //*********
   //*********
}

int main( )
{
   //create two-dimensional array AM1, AM2
   //
   int ** AM1 = (int **) malloc( sizeof(int *) * MAXNODE );
   int ** AM2 = (int **) malloc( sizeof(int *) * MAXNODE );
   int i;
   for ( i = 0 ; i < MAXNODE ; i ++ )
   {
       AM1[i] = (int *) malloc( sizeof(int) * MAXNODE );
       AM2[i] = (int *) malloc( sizeof(int) * MAXNODE );
   }  

   InitAM(AM1);
   InitAM(AM2);

   if (ReadGraph(AM1) == 0)
   {
       return 1;
   }

   if(MPS_tree(AM1,AM2) == 0)
   {
       printf("There is no minimun spanning tree!");
       return 1;
   }

   WriteMPS( AM2 );

   for ( i = 0 ; i < MAXNODE ; i ++ )
   {
       free( AM1[i] );
       free( AM2[i] );
   }
   free(AM1);
   free(AM2);

   return 0;
}

Answer 1

#include <iostream>
#include <vector>
utilizing namespace sexually transmitted disease;
layout <class T>
class Stack{
private:
vector<T> information;
open:
bool Empty();/checks if stack is vacant
void Push(T thing);/adds thing to stack
T Top();/returns thing at top of stack
void Pop();/expels thing at top of stack
companion ostream& operator<<(ostream&out, const Stack &s);/over-burden yield administrator
};
#include <iostream>
#include <vector>
#include "Stack.h"
utilizing namespace sexually transmitted disease;
layout <class T>
bool Stack<T>::Empty()/checks if stack is vacant
{
return data.empty();
}
layout <class T>
void Stack<T>::Push(T thing)/adds thing to stack
{
data.push_back(item);
}
layout <class T>
T Stack<T>::Top()/returns thing at top of stack
{
if(data.back()>-1)
return data.back();
else
cerr<<"Stack is empty\n";
}
layout <class T>
void Stack<T>::Pop()/expels thing at top of stack
{
data.pop_back();
}
format <class T>
ostream and operator<<(ostream&out, const Stack<T> &s)/over-burden yield administrator
{
while(!s.Empty())
{
out<<s.Top();
s.Pop();
}return out;
}
#include <iostream>
#include <vector>
#include <string>
#include "Stack.h"
#include <fstream>
utilizing namespace sexually transmitted disease;
int principle()
{
ifstream inFile;
ofstream outFile;
inFile.open("palindrome.txt");
outFile.open("outfile.txt");
Stack<string> s;
string holdPalindrome="";
/I know the accompanying isn't generally right however I halted here
while(inFile)
{
holdPalindrome.append(s.Top());
outFile<<holdPalindrome<<endl;
}
inFile.close();
outFile.close();
return 0;
}