Este site utiliza cookies para análise, conteúdo personalizado e anúncios.

Continuando a navegar neste site, você concorda com esse uso. Saiba mais

Developer Network Entrar Assinaturas do MSDN Obter ferramentas

Downloads Programas Comunidade Documentação

Fazer uma Pergunta Pesquisar threads relacionados Search forum questions

Acesso rápido

Usuário com melhor resposta Grafos e ponteiros em c#

Visual Studio Development > C#
53,707
Pergunta
Pontos
Principal 0.1%
Sou estudante e preciso criar um sistema para inserção de times em uma partida de vôlei. Acontece que só
consigo colocar dentro da struct uma variável char, se coloco string ele dá erro e eu não consegui corrigir.
William John Adam Trindade
Ingressou Oct 2009 código:
Threads de Willia… 0
using System;
4 7 18 Mostrar atividade Entrar
para using System.Collections.Generic;
Votar using System.Linq;
using System.Text;
using System.Runtime.InteropServices;

namespace ConsoleApplication1
{
    class Program
  {

        unsafe struct Vertice

    {

            public fixed char v[3]; //campo que armazenará o dado do vértice

            public Vertice* proxV; //ponteiro para o próximo nodo da lista de vértices
            public Adjacente* proxA; //ponteiro para o primeiro nodo da lista de adjacentes
        };

        unsafe struct Adjacente

    {
            public fixed char a[3]; //campo que armazenará o dado do vértice adjacente                
            public Adjacente* proximo; //ponteiro para o próximo nodo da lista de adjacentes            
        };

        static void Main(string[] args)

    {
            unsafe
      {
                int op = 0;
                string v1, v2,dta,hora;
                string[,] resultados = new string[100,11];//100 linhas 10 colunas

                Vertice* inicio = null; //cria um ponteiro que apontará para o endereço do registro que estiver no
início da lista                

                while (op != 5)
        {
                    op = menu(); //chama função para mostrar menu e solicitar opção do usuário
                    switch (op)
          {
                        case 1: //conectar
                            Console.Clear();
                            Console.Write("Digite o nome do País 1:");
                            v1 = Console.ReadLine();
                            Console.Write("Digite o nome do País 2:");
                            v2 = Console.ReadLine();

                            Console.Write("Digite a data da partida:");

                            dta = Console.ReadLine();
Console Write("Digite a hora da partida:");
                            Console.Write( Digite a hora da partida: );
                            hora = Console.ReadLine();                            

                            Console.Clear();
                            conecta(&inicio, v1, v2,dta,hora,resultados);
                            break;
                        case 2: //desconectar
                            Console.Clear();
                            Console.Write("Digite o nome do País 1:");
                            v1 = Console.ReadLine();
                            Console.Write("Digite o nome do País 2:");
                            v2 = Console.ReadLine();
                            Console.Clear();
                            desconecta(&inicio, v1, v2);
                            break;
                        case 3: //imprimir
                            Console.Clear();
                            imprimir(&inicio,resultados);
                            break;
                        case 4: //mostrar partidas
                            partidas(resultados);
                            break;
          }
        }
      }
    }

        private static int menu()

    {
            int op;
            Console.WriteLine("(1)Cadastrar uma partida \n(2)Excluir uma partida \n(3)Visualizar informações
\n(4)Ver partidas \n(5)Sair \n\nEscolha uma opção:");
            op = Convert.ToInt16(Console.ReadLine());
            return op;
    }

        private static unsafe void imprimir(Vertice** inicio,string[,] resultados)

    {
            Vertice* auxV;
            Adjacente* auxA;
            if (*inicio != null)
      {
                auxV = *inicio;
                while (auxV != null)
        {
                    // string auxV_dado = new string(auxV->v);
                    Console.WriteLine("Vertice - dado:" + *auxV->v);
                    Console.WriteLine("Vertice - endereço:" + (int)auxV);
                    Console.WriteLine("Vertice - proxV:" + (int)auxV->proxV);
                    Console.WriteLine("Vertice - proxA:" + (int)auxV->proxA);
                    Console.WriteLine();
                    auxA = auxV->proxA;
                      
                    while (auxA != null)
          {
                        //string auxA_dado = new string(auxA->a);
                        Console.WriteLine("Adjacente - dado:" + *auxA->a);
                        Console.WriteLine("Adjacente - endereço:" + (int)auxA);
                        Console.WriteLine("Adjacente - proximo:" + (int)auxA->proximo);
                        auxA = auxA->proximo;                       

          }
                    auxV = auxV->proxV;
                    Console.Write("------------------------------------------------\n");                    

        }
                
      }
            else
                Console.WriteLine("Grafo Vazio");
    }

        private static void partidas(String[,] resultados)

{
    {
            Console.Clear();
            string impr1 = "", impr2 = "", impr3 = "";
            int n = -1;
            for (int l = 0; l < 97; l++)
      {
                n = n + 1;
                if (n == 0 && resultados[l,0] != null)
                    Console.WriteLine("\nPaís\tData\tHora\tVenceu\t1º Set\t2º Set\t3º Set\t4º Set\t5º Set\n");
                
                if (n == 2)
                    n = -1;
                
                if (resultados[l, 0] != null || resultados[l, 2] != null)
        {
                    for (int z = 0; z < 10; z++)
          {
                        Console.Write(resultados[l, z] + "\t");                        
          } 
                    Console.WriteLine("");
        }
      }
        
    }

        private static unsafe void desconecta(Vertice** inicio, string v1, string v2)
    {
            Vertice* auxV;
            Adjacente* auxA;
            Adjacente* antA;

            if (*inicio == null) //Se o grafo estiver vazio

                Console.WriteLine("Não existe grafo.");
            else
            { //Se o grafo não estiver vazio
                auxV = *inicio;

                while ((auxV != null) && (new String(auxV->v) != v1))

        {
                    auxV = auxV->proxV;
        }
                if (auxV == null)
                    Console.WriteLine("Não há conexões");
                else
        {
                    auxA = auxV->proxA;
                    antA = auxA;
                    while ((auxA != null) && (new String(auxA->a) != v2))
          {
                        antA = auxA;
                        auxA = auxA->proximo;
          }
                    if (auxA == null)
                        Console.WriteLine("Não há conexões");
                    else
          {
                        if (auxV->proxA == auxA)
            {
                            auxV->proxA = auxA->proximo;
            }
                        else
            {
                            antA->proximo = auxA->proximo; 
            }
          }
        }
      }
    }

        private static unsafe void conecta(Vertice** inicio, string v1, string v2, string dta, string hora, string[,]
resultados)
    {
            Vertice* auxV; //ponteiro auxiliar para percorrer a lista de Vértices
            Vertice* novoV; //ponteiro com endereço do novo vértice a ser incluído na lista de vértices
 ; //p ç
            Vertice* antV = null; //ponteiro para guardar o endereço do vértice anterior(recem visitado) da lista
de vértices
            Adjacente* auxA; //ponteiro auxiliar para percorrer a lista de Adjacentes
            Adjacente* novoA; //ponteiro com endereço do novo vértice a ser incluído na lista de Adjacentes
            Adjacente* antA = null; //ponteiro para guardar endereço do vértice anterior(recentemente visitado)
da lista de Adjacentes
            Adjacente* novoA2;
            string end_Ad1 = null, end_Ad2 = null, nome1 = null, nome2 = null;
            

            if (*inicio == null)
            { //Testa se lista de vértices está vazia
                *inicio = alocaVertice(v1); //cria um registro do tipo vértice e atribui o endereço do registro criado
para inicio
                novoV = alocaVertice(v2); //cria um registro do tipo vértice e atribui o endereço do registro criado
para novoV
                (*inicio)->proxV = novoV; //conecta o novo registro v1 com v2 na lista de vértices
                novoA = alocaAdjacente(v2); //cria um registro do tipo adjacente e atribui o endereço do nodo
criado para novoA
                (*inicio)->proxA = novoA; //conecta o nodo adjacente v2 ao nodo vértice v1
                novoA2 = alocaAdjacente(v1);
                novoV->proxA = novoA2;
                nome1 = new String(novoA->a);
                nome2 = new String(novoA2->a);
                end_Ad1 = Convert.ToString((int)novoA);
                end_Ad2 = Convert.ToString((int)novoA2);
      }

            else
            { //se a lista de vértices não está vazia
                auxV = *inicio; //auxiliar recebe inicio da lista de vértices para pesquisar v1
                //pesquisa na lista de vértices até encontrar o vértice v1

                while (auxV != null && new String(auxV->v) != v1)

                { //enquanto não chegar no final da lista de vértices e não encontrar v1 na lista de vértices
                    antV = auxV; //guarda o endereço do vértice visitado no ponteiro antV
                    auxV = auxV->proxV; //atualiza auxiliar para pesquisar no próximo nodo
        }

                if (auxV == null)
                { //se não encontrou v1 na lista de vértices
                    novoV = alocaVertice(v1); //aloca memória para vértice v1
                    novoA = alocaAdjacente(v2); //aloca memória para adjacente v2
                    antV->proxV = novoV; //conecta o vértice criado ao final da lista de vértices
                    novoV->proxA = novoA; //conecta o vértice adjacente ao vértice v1
                    end_Ad1 = Convert.ToString((int)novoA);
                    nome1 = new String(novoA->a);
        }

                else
                { //se encontrou o vértice v1 na lista de vértices

                    if (auxV->proxA == null)
                    { //verifica se o vértice v1 não possui nenhum adjacente
                        novoA = alocaAdjacente(v2); //aloca memória para adjacente v2
                        auxV->proxA = novoA; //conecta o nodo criado ao vértice v1
                        nome1 = new String(novoA->a);
                        end_Ad1 = Convert.ToString((int)novoA);
          }

                    else
                    { //se o vértice v1 já possui algum adjacente
                        auxA = auxV->proxA; //auxiliar recebe o endereço do primeiro nodo da lista de adjacentes de
v1
                        //verifica se v2 já existe na lista de adjacentes de v1

                        while (auxA != null && new String(auxA->a) != v2)

                        { //enquanto não chegar no final da lista de adjacentes e não encontrar v2
                            antA = auxA; //guarda o endereço do vértice visitado no ponteiro antA
                            auxA = auxA->proximo; //atualiza auxiliar para pesquisar no próximo nodo
            }

                        if (auxA == null)
                        { //se v2 não aparece na lista de adjacentes de v1
                            novoA = alocaAdjacente(v2); //aloca memória para adjacente v2                            
                            antA->proximo = novoA; //Conecta o nodo adjacente v2 no final da lista de adjacentes de
v1
                            nome1 = new String(novoA->a);
                            end_Ad1 = Convert.ToString((int)novoA);
            }

                        else
                            Console.WriteLine("O País " + v2 + " já encontra-se na lista de aversários do País " + v1);

                    } //fim do else(se o vértice V1 já possui algum adjacente)

                    
                } //fim do else(se encontrou o vértice v1 na lista de vértices)
                                
                
                //pesquisa na lista de vértices até encontrar o vértice v2
                auxV = *inicio; //auxiliar recebe inicio para percorrer lista de vértices
                while (auxV != null && new String(auxV->v) != v2)
                { //enquanto não chegar no final da lista de vértices e não encontrar v2
                    antV = auxV; //guarda o endereço do vértice visitado em antV
                    auxV = auxV->proxV; //atualiza auxiliar para pesquisar no próximo nodo
        }

                if (auxV == null)
                { //se não encontrou v2 na lista de vértices
                    novoV = alocaVertice(v2); //aloca memória para vértice v2                       
                    antV->proxV = novoV; //conecta o vértice criado ao final da lista de vértices 
                    novoA = alocaAdjacente(v1);
                    novoV->proxA = novoA;
                    nome2 = new String(novoA->a);
                    end_Ad2 = Convert.ToString((int)novoA);
        }
                else //se v2 foi encontrado na lista de vértices
        {
                    auxA = auxV->proxA; //auxiliar recebe o endereço do primeiro nodo da lista de adjacentes de v2
                    //verifica se v1 já existe na lista de adjacentes de v2

                    while (auxA != null && new String(auxA->a) != v1)

                    { //enquanto não chegar no final da lista de adjacentes e não encontrar v1
                        antA = auxA; //guarda o endereço do vértice visitado no ponteiro antA
                        auxA = auxA->proximo; //atualiza auxiliar para pesquisar no próximo nodo
          }

                    if (auxA == null)
                    { //se v1 não aparece na lista de adjacentes de v2
                        novoA = alocaAdjacente(v1); //aloca memória para adjacente v1                          
                        antA->proximo = novoA; //Conecta o nodo adjacente v1 no final da lista de adjacentes de v2
                        nome2 = new String(novoA->a);
                        end_Ad2 = Convert.ToString((int)novoA);
          }

                    else
                        Console.WriteLine("O País " + v1 + " já encontra-se na lista de adversários do País " + v2);   

        }
            } //fim do else(se lista de vértices não está vazia)
            int pos = -1,cont=0;
            if (resultados[0, 0] == null)
                pos = 0;
            else
      {
                while (pos == -1 && cont < 99)
        {
                    if (resultados[cont, 0] == null && cont >= 1)
                        pos = cont;
                    else
                        cont = cont + 3;
        }
      }
      
            resultados[pos, 0] = Convert.ToString(nome2);
            resultados[pos, 10] = end_Ad2;
            resultados[pos, 1] = dta;
            resultados[pos, 2] = hora;
            resultados[pos, 3] = "0";

            resultados[pos + 1, 0] = Convert.ToString(nome1);//endereço memoria do adjacente

            resultados[pos + 1, 10] = end_Ad1;
            resultados[pos + 1, 1] = dta; //data da partida
            resultados[pos + 1, 2] = hora; //hora da partida
            resultados[pos + 1, 3] = "0"; // sets ganhos pelo time
            
            int pt_set1 = 0, pt_set2 = 0;
            for (int x = 1; x <= 5; x++)
      {
                Console.WriteLine("\n\nDigite os pontos do País '"+v1+"' no Set "+x+":");
                pt_set1 = Convert.ToInt16(Console.ReadLine());
                resultados[pos, 3 + x] = Convert.ToString(pt_set1);//pontos do time 1 no set

                Console.WriteLine("Digite os pontos do País '" + v2 + "' no Set " + x + ":");

                pt_set2 = Convert.ToInt16(Console.ReadLine());

                Console.WriteLine("Digite tempo de jogo do Set "+x+":");

                resultados[pos + 2, 3 + x] = Console.ReadLine();      //tempo de jogo      
                resultados[pos + 2, 1] = "Tempo";//insere titulo da linha
                resultados[pos + 2, 2] = "de";
                resultados[pos + 2, 3] = "Jogo";

                resultados[pos + 1, 3 + x] = Convert.ToString(pt_set2);//pontos do time 2 no set

                if (pt_set1 > pt_set2)
                    resultados[pos, 3] = Convert.ToString(Convert.ToInt16(resultados[pos, 3]) + 1);
                else
                    resultados[pos + 1, 3] = Convert.ToString(Convert.ToInt16(resultados[pos + 1, 3]) + 1);

               // Console.WriteLine("País\tData\tHora\tVenceu\t1º Set\t2º Set\t3º Set\t4º Set\t5º Set\n");

                string impr1 = "", impr2 = "", impr3 = "";
                
                for (int z = 0; z < 10; z++)
        {
                    
                    impr1 = impr1 + resultados[pos, z] +"\t";
                    impr2 = impr2 + resultados[pos+1, z] + "\t";                     
                    impr3 = impr3 + resultados[pos+2, z] + "\t";
        }
                //Console.WriteLine("" + impr1 + impr2 + impr3 + "\n");
                if (Convert.ToInt16(resultados[pos, 3]) == 3 || Convert.ToInt16(resultados[pos + 1, 3]) == 3)
                    x = 5;                
      }
            if(Convert.ToInt16(resultados[pos, 3]) >= 3)
                Console.WriteLine("Time '"+v1 +"' venceu!");
            else
                Console.WriteLine("Time '" + v2 + "' venceu!");
            Console.WriteLine("");

        } //fim do procedimento conecta

        /*função que aloca espaço de memória para um novo registro da lista de adjacentes, armazena o dado
já digitado pelo usuário
        e recebido no parâmetro v2, atribui null ao campo proximo e, finalmente, retorna em "novo" o endereço
        do novo registro para o procedimento conecta */
        private static unsafe Adjacente* alocaAdjacente(string v2)
    {
            Adjacente* novo; //ponteiro para o endereço do novo registro alocado
            novo = (Adjacente*)Marshal.AllocHGlobal(sizeof(Adjacente)); //aloca memória necessária para um
novo registro          

            *novo->a = Char.Parse(v2); //atribui o vértice adjacente para o campo "a" do novo registro na lista de
adjacentes
            novo->proximo = null;
            return novo;
    }

        /*função que aloca espaço de memória para um novo registro da lista de vértices, armazena o dado já
digitado pelo usuário
         e recebido no parâmetro v1, atribui null aos campos proxV e proxA do novo registro e, finalmente,
retorna em "novo" o endereço
        do novo registro para o procedimento conecta */
        private static unsafe Vertice* alocaVertice(string v1)
    {
            Vertice* novo; //ponteiro para o endereço do novo registro alocado
            novo = (Vertice*)Marshal.AllocHGlobal(sizeof(Vertice)); //aloca memória necessária para um novo
registro
            *novo->v = Char.Parse(v1); //atribui o vértice origem para o campo "v" do novo registro
            novo->proxV = null;
            novo->proxA = null;
            return novo;
    }
  }
}

segunda-feira, 3 de outubro de 2016 23:30

Responder | Citação
Cássio Jaques 0 Pontos

Respostas

Voce esta tentando converter um codigo em C++ em C#.

Apesar de ser possivel em C#, o uso de ponteiros nao é recomendado.

Sugiro voce trabalha com Lista generica ao invez de tentar usar ponteiros.
0
Entrar Aqui tem um artigo bem completo de como usar lista genericas encadeadas para gerar graphos em C#
para
Votar
http://www.vcskicks.com/representing-graphs.php

e mais um outro artigo, com um codigo mais limpo:

http://theoryofprogramming.com/adjacency-list-implementation-in-c-sharp/

att

William John Adam Trindade

Analyste-programmeur
----------------------------------------------------------

Sogi Informatique ltée

Sugerido como Resposta Robson William Silva Moderator terça-feira, 4 de outubro de 2016 14:28
Marcado como Resposta Robson William Silva Moderator quarta-feira, 5 de outubro de 2016 12:15

terça-feira, 4 de outubro de 2016 10:52

Responder | Citação William John Adam Trindade Sogi Informatique Ltée 53,707 Pontos

Todas as Respostas
 Voce esta tentando converter um codigo em C++ em C#.

Apesar de ser possivel em C#, o uso de ponteiros nao é recomendado.

Sugiro voce trabalha com Lista generica ao invez de tentar usar ponteiros.
0
Entrar Aqui tem um artigo bem completo de como usar lista genericas encadeadas para gerar graphos em C#
para
Votar
http://www.vcskicks.com/representing-graphs.php

e mais um outro artigo, com um codigo mais limpo:

http://theoryofprogramming.com/adjacency-list-implementation-in-c-sharp/

att

William John Adam Trindade

Analyste-programmeur
----------------------------------------------------------

Sogi Informatique ltée

Sugerido como Resposta Robson William Silva Moderator terça-feira, 4 de outubro de 2016 14:28
Marcado como Resposta Robson William Silva Moderator quarta-feira, 5 de outubro de 2016 12:15

terça-feira, 4 de outubro de 2016 10:52

Responder | Citação William John Adam Trindade Sogi Informatique Ltée 53,707 Pontos

Robson,

Preciso falar com voce. Poderia entrar em contato comigo pelo LinkedIn?

Att
0
Entrar
para William John Adam Trindade
Votar
Analyste-programmeur
----------------------------------------------------------

Sogi Informatique ltée

quarta-feira, 5 de outubro de 2016 14:07

Responder | Citação William John Adam Trindade Sogi Informatique Ltée 53,707 Pontos

Centros do desenvolvedor Recursos de aprendizagem Comunidade Suporte

Microsoft Virtual Academy Fóruns Suporte autônomo
Windows
Channel 9 Blogs

Office MSDN Magazine Codeplex

Open Source
Visual Studio

Microsoft Azure Programas

BizSpark (para iniciantes)
Mais... Microsoft Imagine (for students)

Brasil (Português) Boletim informativo Privacidade & cookies Termos de uso Marcas comerciais © 2019 Microsoft