1. We have moved from vBulletin to XenForo and you are viewing the site in the middle of the move. Though the functional aspect of everything is working fine, we are still working on other changes including the new design on Xenforo.
    Dismiss Notice

C++ to C#

Discussion in 'C#' started by Loosexll, Aug 27, 2012.

  1. Loosexll

    Loosexll New Member

    Joined:
    Aug 27, 2012
    Messages:
    1
    Likes Received:
    0
    Trophy Points:
    0
    I code a algorithm by C++(Breadth first search), and i converted to C#, but it not work, i can found error. Please test it in your VS and fix it.
    C++:
    Code:
    #include <iostream>
    #include <queue>
    
    using namespace std;
    
    const int maxx = 20;
    
    void Read_input_from_user(bool grid[][maxx], int vertices)
    {
        int u, v;
        for(int x = 0; x < vertices; ++x)
        {
            cout << "Enter u : \t"; 
            cin >> u;
            u--;
            cout << "Enter v : \t";
            cin >> v;
            v--;
            grid[u][v] = true;
                    grid[v][u] = true;
            cout << "---------------------\n";
        }
    }
    
    void Breadth_first_search(queue<int> &Q, vector<int> &trace,
                              bool grid[][maxx], int start, int nodes)
    {
        int u;
        vector<int> visited(maxx,0);
        Q.push(start);
        trace[start] = -1;
        visited[start] = 1;
        do{
            u = Q.front();
            Q.pop();
            for(int v = 0; v < nodes; ++v)
            {
                if((grid[u][v] == true) && visited[v] == 0)
                {
                    Q.push(v);
                    trace[v] = u;
                    visited[v] = 1;
                }
            }
        }while(!Q.empty());
    }
    
    void Trace_result(vector<int> &trace, int start, int end, int nodes)
    {
        cout << "From _nodes" << start + 1 << " you can visit :\n";
        for(int v = 0; v < nodes; ++v)
        {
            if(trace[v] != 0)
            {
                cout << " _nodes : " << v + 1 << " , ";
            }
        }
    
        cout << "\n--------------------------------------------\n";
        cout << "The path from " << start + 1 << " to " << end + 1 << '\n';
        
        if(trace[end] == 0){
            cout << "Unavailable.! to go to from " << end + 1 
                 << " to -> " << start + 1 << '\n';
        }
        else{
            while(end != start)
            {
                cout << end + 1 << "<-";
                end = trace[end];
            }
            cout << start + 1 << endl;
        }
        
    }
    
    
    int main()
    {
        //Initialization
        vector<int> trace(maxx, 0);
        queue<int> Q;
        bool grid[maxx][maxx] = {false};
        
        int nodes, vertices;
        cout << "Please input the number of Node : \n";
        cin >> nodes;
        cout << "Please input the number of Vertices : \n";
        cin >> vertices;
    
        //Set value for all vertices.
        Read_input_from_user(grid, vertices); 
    
        //Read the necessary path
        int starting_position, finishing_position;
        cout << "Please Input the Starting Node : \n";
        cin >> starting_position;
        cout << "Please Input the Finishing Node : \n";
        cin >> finishing_position;
        //Decrease to fit with index of C++ start from 0->size-1
        starting_position--;
        finishing_position--;
        //Algorithm starts 
        Breadth_first_search(Q, trace, grid, starting_position, nodes);
        Trace_result(trace, starting_position, finishing_position, nodes);
        system("pause");
        return 0;
    }
    C#:
    Code:
    using System;
    using System.Collections.Generic;
    using System.Linq;
    using System.Text;
    
    namespace ConsoleApplication1
    {
        class Program
        {
            private const int maxx = 20;
    
             static void Read_input_from_user(bool[,] grid, int vertices)
            {
                int u;
                int v;
                for (int x = 0; x < vertices; ++x)
                {
                    Console.Write("Enter u : \t");
                    u = Convert.ToInt32(Console.ReadLine());
                    u--;
                    Console.Write("Enter v : \t");
                    v = Convert.ToInt32(Console.ReadLine());
                    v--;
                    grid[u, v] = true;
                    grid[v, u] = true;
                    Console.Write("---------------------\n");
                }
            }
    
             static void Breadth_first_search( Queue<int> Q,  List<int> trace, bool[,] grid, int start, int nodes)
            {
                int u;
                List<int> visited = new List<int>(maxx);
                Q.Enqueue(start);
                trace[start] = -1;
                visited[start] = 1;
                do
                {
                    u = Q.Peek();
                    Q.Dequeue();
                    for (int v = 0; v < nodes; ++v)
                    {
                        if ((grid[u, v] == true) && visited[v] == 0)
                        {
                            Q.Enqueue(v);
                            trace[v] = u;
                            visited[v] = 1;
                        }
                    }
                } while (Q.Count != 0);
            }
    
             static void Trace_result(  List<int> trace, int start, int end, int nodes)
            {
                Console.Write("From _nodes");
                Console.Write(start + 1);
                Console.Write(" you can visit :\n");
                for (int v = 0; v < nodes; ++v)
                {
                    if (trace[v] != 0)
                    {
                        Console.Write(" _nodes : ");
                        Console.Write(v + 1);
                        Console.Write(" , ");
                    }
                }
    
                Console.Write("\n--------------------------------------------\n");
                Console.Write("The path from ");
                Console.Write(start + 1);
                Console.Write(" to ");
                Console.Write(end + 1);
                Console.Write('\n');
    
                if (trace[end] == 0)
                {
                    Console.Write("Unavailable.! to go to from ");
                    Console.Write(end + 1);
                    Console.Write(" to -> ");
                    Console.Write(start + 1);
                    Console.Write('\n');
                }
                else
                {
                    while (end != start)
                    {
                        Console.Write(end + 1);
                        Console.Write("<-");
                        end = trace[end];
                    }
                    Console.Write(start + 1);
                    Console.Write("\n");
                }
    
            }
             static int Main()
            {
                //Initialization
                List<int> trace = new List<int>(maxx);
                Queue<int> Q = new Queue<int>();
                bool[,] grid = new bool[maxx, maxx];
                
                int nodes;
                int vertices;
                Console.Write("Please input the number of Node : \n");
                //cin >> nodes;
                nodes = Convert.ToInt32(Console.ReadLine());
                Console.Write("Please input the number of Vertices : \n");
                //cin >> vertices;
                vertices = Convert.ToInt32(Console.ReadLine());
                //Set value for all vertices.
                Read_input_from_user(grid, vertices);
                
                //Read the necessary path
                int starting_position;
                int finishing_position;
                Console.Write("Please Input the Starting Node : \n");
                //cin >> starting_position;
                starting_position = Convert.ToInt32(Console.ReadLine());
                Console.Write("Please Input the Finishing Node : \n");
                //cin >> finishing_position;
                finishing_position = Convert.ToInt32(Console.ReadLine());
                //Decrease to fit with index of C++ start from 0->size-1
                starting_position--;
                finishing_position--;
                //Algorithm starts 
                Breadth_first_search( Q,  trace, grid, starting_position, nodes);
                Trace_result( trace, starting_position, finishing_position, nodes);
                Console.ReadLine();
                return 0;
            }
        }
    }
    
    Please help me
     
  2. xpi0t0s

    xpi0t0s Mentor

    Joined:
    Aug 6, 2004
    Messages:
    3,012
    Likes Received:
    203
    Trophy Points:
    0
    Occupation:
    Senior Support Engineer
    Location:
    England
    "it not work" is not a very helpful description of the problem.
    What doesn't it do that you expected, or what does it do that you didn't expect?
    What line of code does it start going wrong?
    Have you tried adding some debug statements to display where it's up to and what the variable values are? This could help you determine what is wrong.

    In fact if you're using Visual Studio, have you tried stepping through it in the debugger? Watching it execute line by line with the ability to watch variable contents is a spectacularly efficient way to find bugs.
     

Share This Page