// Github: http://bit.ly/GrafoMA-Codigo
// Video: http://bit.ly/video-GrafoMA
// APRESENTAÇÃO DO PROGRAMA: Este programa exibe um menu para o usuário que permite chamar vários métodos para análise de grafos.
// AUTORES:
// - Alex Martins Oliveira
// - Gabriel Rocha de Oliveira
// VERSÃO: 1.0.
// DATA: 01/06/2018
// CÓDIGO DE HONRA: N/A
static void Main(string[] args)
{
int opcao = 0;
bool testeOpcao = true;
Console.WriteLine("\n************************ CRIAR GRAFO ************************");
int qtdVertice = 0;
bool testeQtdVertice = true;
bool testeVertice = true;
Console.Write("\nDigite a quantidade de vértices: ");
testeQtdVertice = int.TryParse(Console.ReadLine(), out qtdVertice);
while (!testeQtdVertice)
{
Console.WriteLine("VALOR INVÁLIDO. Digite a quantidade de vértices: ");
testeQtdVertice = int.TryParse(Console.ReadLine(), out qtdVertice);
}
Grafo Grafo = new Grafo(qtdVertice);
do
{
Console.Clear();
Console.WriteLine("\n************************ MENU DE GRAFOS ************************\n");
Console.WriteLine("[01] Imprimir a ordem do grafo");
Console.WriteLine("[02] Inserir aresta");
Console.WriteLine("[03] Remover aresta");
Console.WriteLine("[04] Imprimir grau de um vértice");
Console.WriteLine("[05] Verificar se o grafo é completo");
Console.WriteLine("[06] Verificar se o grafo é regular");
Console.WriteLine("[07] Imprimir Matriz de Adjacência");
Console.WriteLine("[08] Imprimir Lista de Adjacências");
Console.WriteLine("[09] Imprimir Sequência de Graus");
Console.WriteLine("[10] Imprimir Vértices Adjacentes de um vértice");
Console.WriteLine("[11] Verificar se um vértice é isolado");
Console.WriteLine("[12] Verificar se um vértice é ímpar");
Console.WriteLine("[13] Verificar se um vértice é par");
Console.WriteLine("[14] Verificar se dois vértices são adjacentes");
Console.WriteLine("[15] Imprimir grafo");
Console.WriteLine("[00] Sair\n");
Console.Write("\nDigite a opção desejada: ");
testeOpcao = int.TryParse(Console.ReadLine(), out opcao);
while (opcao < 0 || opcao > 15 || testeOpcao == false)
{
Console.Write("\nOPÇÃO INVÁLIDA. Digite a opção desejada: ");
testeOpcao = int.TryParse(Console.ReadLine(), out opcao);
}
switch (opcao)
{
case (1):
Console.Clear();
Console.WriteLine("\n************************ VERIFICAR ORDEM DO GRAFO ************************");
Console.Write("\nA ordem do grafo é: " + Grafo.Ordem().ToString());
Console.ReadKey(true);
break;
case (2):
Console.Clear();
Console.WriteLine("\n************************ INSERIR ARESTA ************************");
int V1 = 0, V2 = 0;
bool testeAresta = true;
Console.Write("\nDigite o primeiro vértice: ");
testeAresta = int.TryParse(Console.ReadLine(), out V1);
while (!testeAresta || V1 > qtdVertice || V1 <= 0)
{
Console.Write("\nVALOR INVÁLIDO. Digite o primeiro vértice: ");
testeAresta = int.TryParse(Console.ReadLine(), out V1);
}
testeAresta = true;
Console.Write("\nDigite o segundo vértice: ");
testeAresta = int.TryParse(Console.ReadLine(), out V2);
while (!testeAresta || V2 > qtdVertice || V2 <= 0)
{
Console.Write("\nVALOR INVÁLIDO. Digite o segundo vértice: ");
testeAresta = int.TryParse(Console.ReadLine(), out V2);
}
Grafo.InsereAresta(V1, V2);
Console.ReadKey(true);
break;
case (3):
Console.Clear();
Console.WriteLine("\n************************ REMOVER ARESTA ************************");
V1 = 0;
V2 = 0;
testeAresta = true;
Console.Write("\nDigite o primeiro vértice: ");
testeAresta = int.TryParse(Console.ReadLine(), out V1);
while (!testeAresta || V1 > qtdVertice)
{
Console.Write("\nVALOR INVÁLIDO. Digite o primeiro vértice: ");
testeAresta = int.TryParse(Console.ReadLine(), out V1);
}
testeAresta = true;
Console.Write("\nDigite o segundo vértice: ");
testeAresta = int.TryParse(Console.ReadLine(), out V2);
while (!testeAresta || V2 > qtdVertice)
{
Console.Write("\nVALOR INVÁLIDO. Digite o segundo vértice: ");
testeAresta = int.TryParse(Console.ReadLine(), out V2);
}
Grafo.retiraAresta(V1, V2);
Console.ReadKey(true);
break;
case (4):
Console.Clear();
Console.WriteLine("\n************************ IMPRIMIR GRAU DE UM VÉRTICE ************************");
V1 = 0;
testeAresta = true;
Console.Write("\nDigite o vértice: ");
testeAresta = int.TryParse(Console.ReadLine(), out V1);
while (!testeAresta || V1 > qtdVertice)
{
Console.Write("\nVALOR INVÁLIDO. Digite o vértice: ");
testeAresta = int.TryParse(Console.ReadLine(), out V1);
}
Console.Clear();
Console.WriteLine("\n************************ IMPRIMIR GRAU DE UM VÉRTICE ************************");
Console.Write("\nO grau do vértice " + V1.ToString() + " é: " + Grafo.Grau(V1));
Console.ReadKey(true);
break;
case (5):
Console.Clear();
Console.WriteLine("\n************************ VERIFICAR SE O GRAFO É COMPLETO ************************");
if (Grafo.Completo())
{
Console.Write("\nO Grafo é completo. ");
}
else
{
Console.Write("\nO Grafo não é completo. ");
}
Console.ReadKey(true);
break;
case (6):
Console.Clear();
Console.WriteLine("\n************************ VERIFICAR SE O GRAFO É REGULAR ************************");
if (Grafo.Regular())
{
Console.Write("\nO Grafo é regular. ");
}
else
{
Console.Write("\nO Grafo não é regular. ");
}
Console.ReadKey(true);
break;
case (7):
Console.Clear();
Console.WriteLine("\n************************ IMPRIMIR MATRIZ DE ADJACÊNCIA ************************");
Grafo.ShowMA();
Console.ReadKey(true);
break;
case (8):
Console.Clear();
Console.WriteLine("\n************************ IMPRIMIR LISTA DE ADJACÊNCIA ************************");
Grafo.ShowLA();
Console.ReadKey(true);
break;
case (9):
Console.Clear();
Console.WriteLine("\n************************ IMPRIMIR SEQUÊNCIA DE GRAUS ************************");
Grafo.SequenciaGraus();
Console.ReadKey(true);
break;
case (10):
Console.Clear();
Console.WriteLine("\n************************ LISTA VÉRTICES ADJACENTES ************************");
int v = 0;
testeVertice = true;
Console.Write("\nDigite o vértice para listar as adjacências: ");
testeVertice = int.TryParse(Console.ReadLine(), out v);
while (!testeVertice)
{
Console.Write("\nVALOR INVÁLIDO. Digite o vértice para listar as adjacências: ");
testeVertice = int.TryParse(Console.ReadLine(), out v);
}
Grafo.VerticesAdjacentes(v);
Console.ReadKey(true);
break;
case (11):
Console.Clear();
Console.WriteLine("\n************************ VERIFICAR SE UM VÉRTICE É ISOLADO ************************");
v = 0;
testeVertice = true;
Console.Write("\nDigite o vértice para verificar se ele é isolado: ");
testeVertice = int.TryParse(Console.ReadLine(), out v);
while (!testeVertice)
{
Console.Write("\nVALOR INVÁLIDO. Digite o vértice para verificar se ele é isolado: ");
testeVertice = int.TryParse(Console.ReadLine(), out v);
}
if (Grafo.Isolado(v))
{
Console.Write("\nO vértice informado é classificardo como isolado. ");
}
else
{
Console.Write("\nO vértice informado não é isolado. ");
}
Console.ReadKey(true);
break;
case (12):
Console.Clear();
Console.WriteLine("\n************************ VERIFICAR SE UM VÉRTICE É ÍMPAR ************************");
v = 0;
testeVertice = true;
Console.Write("\nDigite o vértice para verificar se ele é ímpar: ");
testeVertice = int.TryParse(Console.ReadLine(), out v);
while (!testeVertice)
{
Console.Write("\nVALOR INVÁLIDO. Digite o vértice para verificar se ele é ímpar: ");
testeVertice = int.TryParse(Console.ReadLine(), out v);
}
if (Grafo.Impar(v))
{
Console.Write("\nO vértice informado é classificardo como ímpar. ");
}
else
{
Console.Write("\nO vértice informado não é ímpar. ");
}
Console.ReadKey(true);
break;
case (13):
Console.Clear();
Console.WriteLine("\n************************ VERIFICAR SE UM VÉRTICE É PAR ************************");
v = 0;
testeVertice = true;
Console.Write("\nDigite o vértice para verificar se ele é par: ");
testeVertice = int.TryParse(Console.ReadLine(), out v);
while (!testeVertice)
{
Console.Write("\nVALOR INVÁLIDO. Digite o vértice para verificar se ele é par: ");
testeVertice = int.TryParse(Console.ReadLine(), out v);
}
if (Grafo.Par(v))
{
Console.Write("\nO vértice informado é classificardo como par. ");
}
else
{
Console.Write("\nO vértice informado não é par. ");
}
Console.ReadKey(true);
break;
case (14):
Console.Clear();
Console.WriteLine("\n************************ VERIFICAR SE DOIS VÉRTICES SÃO ADJACENTES ************************");
V1 = 0;
V2 = 0;
testeAresta = true;
Console.Write("\nDigite o primeiro vértice: ");
testeAresta = int.TryParse(Console.ReadLine(), out V1);
while (!testeAresta || V1 > qtdVertice)
{
Console.Write("\nVALOR INVÁLIDO. Digite o primeiro vértice: ");
testeAresta = int.TryParse(Console.ReadLine(), out V1);
}
testeAresta = true;
Console.Write("\nDigite o segundo vértice: ");
testeAresta = int.TryParse(Console.ReadLine(), out V2);
while (!testeAresta || V2 > qtdVertice)
{
Console.Write("\nVALOR INVÁLIDO. Digite o segundo vértice: ");
testeAresta = int.TryParse(Console.ReadLine(), out V2);
}
if (Grafo.Adjacentes(V1, V2))
{
Console.Write("\nOs vértices informados são adjacentes. ");
}
else
{
Console.Write("\nOs vértices informados não são adjacentes. ");
}
Console.ReadKey(true);
break;
case (15):
Console.Clear();
Console.WriteLine("\n************************ IMPRIMIR GRAFO ************************");
Grafo.ImprimeGrafo();
Console.ReadKey(true);
break;
case (0):
break;
default:
Console.Write("\nOPÇÃO INVÁLIDA!");
break;
}
} while (opcao != 0);
Console.Write("\nPressione qualquer tecla para sair...");
Console.ReadKey(true);
}
static public void MenuMatriz()
{
bool repete = true;
int menu = -1, controleInt = 0, qtdVertice = 0, v1 = 0, v2 = 0;
Console.WriteLine("Informe o número de vértices do grafo:");
qtdVertice = int.Parse(Console.ReadLine());
Grafo g = new Grafo(qtdVertice);
Console.Clear();
repete = true;
while (repete)
{
do
{
try
{
Console.WriteLine("\n______________________________________________________________________________________\n" +
"*** Grafo que utiliza a estrutura de dados Matriz de Adjacência ***\n\n" +
"\nEscolha uma opção no menu abaixo:\n" +
"1- Inserir aresta.\n" +
"2- Remover aresta.\n" +
"3- Imprimir Ordem do Grafo.\n" +
"4- Imprimir MA. \n" +
"5- Imprimir LA.\n" +
"6- Imprimir Sequencia de Graus.\n" +
"7- Imprimir vertices adjacentes.\n" +
"8- Verificar vértice isolado.\n" +
"9- Verificar se vértice é par.\n" +
"10- Verificar se vértice é impar.\n" +
"11- Verificar se dois vértices são adjacentes.\n" +
"12- Verificar se o Grafo é completo.\n" +
"13- Verificar se o Grafo é regular.\n\n" +
"DIGITE -1 PARA ENCERRAR. \n" +
"______________________________________________________________________________________");
menu = int.Parse(Console.ReadLine());
Console.Clear();
repete = false;
}
catch (FormatException)
{
Console.WriteLine("ERRO NO VALOR DIGITADO.");
System.Threading.Thread.Sleep(1000); //Faz o programa esperar 3 segundos para o usuário ver a mensagem e depois continua
Console.Clear();
}
} while (repete);
repete = true;
switch (menu)
{
case 1:
do
{
try
{
Console.WriteLine("Digite o vértice [1]: ");
v1 = int.Parse(Console.ReadLine());
repete = false;
}
catch (FormatException)
{
Console.Clear();
Console.WriteLine("ERRO NO VALOR DIGITADO");
}
} while (repete);
repete = true;
do
{
try
{
Console.WriteLine("Digite o vértice [2]: ");
v2 = int.Parse(Console.ReadLine());
repete = false;
}
catch (FormatException)
{
Console.Clear();
Console.WriteLine("ERRO NO VALOR DIGITADO");
}
} while (repete);
repete = true;
if (g.InserirAresta(v1, v2))
{
Console.WriteLine("\nAresta adicionada com sucesso!\n");
}
else
{
Console.WriteLine("\nAresta NÃO adicionada!\n\n");
}
break;
case 2:
do
{
try
{
Console.WriteLine("Digite o vertice 1: ");
v1 = int.Parse(Console.ReadLine());
repete = false;
}
catch (FormatException)
{
Console.Clear();
Console.WriteLine("ERRO NO VALOR DIGITADO");
}
} while (repete);
repete = true;
do
{
try
{
Console.WriteLine("Digite o vertice 2: ");
v2 = int.Parse(Console.ReadLine());
repete = false;
}
catch (FormatException)
{
Console.Clear();
Console.WriteLine("ERRO NO VALOR DIGITADO");
}
} while (repete);
repete = true;
if (g.RemoverAresta(v1, v2))
{
Console.WriteLine("\nAresta removida com sucesso!\n\n");
}
else
{
Console.WriteLine("\nAresta NÃO removida.\n\n");
}
break;
case 3:
Console.WriteLine("\nA ordem do grafo é: " + g.Ordem() + "\n\n");
break;
case 4:
g.ShowMA();
break;
case 5:
g.ShowLA();
break;
case 6:
g.SequenciaGraus();
break;
case 7:
do
{
try
{
Console.WriteLine("Digite o vértice que deseja verificar seus adjacentes: ");
controleInt = int.Parse(Console.ReadLine());
repete = false;
}
catch (FormatException)
{
Console.WriteLine("ERRO NO VALOR DIGITADO.");
}
} while (repete);
repete = true;
Console.Clear();
g.VerticesAdjacentes(controleInt);
break;
case 8:
do
{
try
{
Console.WriteLine("Digite o vértice que deseja verificar se é Isolado: ");
controleInt = int.Parse(Console.ReadLine());
repete = false;
}
catch (FormatException)
{
Console.WriteLine("ERRO NO VALOR DIGITADO.");
}
} while (repete);
repete = true;
Console.Clear();
try
{
if (g.Isolado(controleInt))
{
Console.WriteLine("\nVértice isolado.\n\n");
}
else
{
Console.WriteLine("\nVértice NÃO isolado.\n\n");
}
}
catch (Exception ex)
{
Console.WriteLine(ex.Message);
}
break;
case 9:
do
{
try
{
Console.WriteLine("Digite o vértice que deseja verificar se é Par: ");
controleInt = int.Parse(Console.ReadLine());
repete = false;
}
catch (FormatException)
{
Console.WriteLine("ERRO NO VALOR DIGITADO.");
}
} while (repete);
repete = true;
Console.Clear();
try
{
if (g.Par(controleInt))
{
Console.WriteLine("\nVértice Par.\n\n");
}
else
{
Console.WriteLine("\nVértice NÃO Par.\n\n");
}
}
catch (Exception ex)
{
Console.WriteLine(ex.Message);
}
break;
case 10:
do
{
try
{
Console.WriteLine("Digite o vértice que deseja verificar se é Impar: ");
controleInt = int.Parse(Console.ReadLine());
repete = false;
}
catch (FormatException)
{
Console.WriteLine("ERRO NO VALOR DIGITADO.");
}
} while (repete);
repete = true;
Console.Clear();
try
{
if (g.Impar(controleInt))
{
Console.WriteLine("\nVértice Impar.\n\n");
}
else
{
Console.WriteLine("\nVértice NÃO Impar.\n\n");
}
}
catch (Exception ex)
{
Console.WriteLine(ex.Message);
}
break;
case 11:
do
{
try
{
Console.WriteLine("Digite o vertice 1: ");
v1 = int.Parse(Console.ReadLine());
repete = false;
}
catch (FormatException)
{
Console.Clear();
Console.WriteLine("ERRO NO VALOR DIGITADO");
}
} while (repete);
repete = true;
do
{
try
{
Console.WriteLine("Digite o vertice 2: ");
v2 = int.Parse(Console.ReadLine());
repete = false;
}
catch (FormatException)
{
Console.Clear();
Console.WriteLine("ERRO NO VALOR DIGITADO");
}
} while (repete);
repete = true;
try
{
if (g.Adjacentes(v1, v2))
{
Console.WriteLine("\nVértices adjacentes.\n");
}
else
{
Console.WriteLine("\nVértices NÃO adjacentes.\n");
}
}
catch (Exception ex)
{
Console.WriteLine(ex.Message);
}
break;
case 12:
try
{
if (g.Completo())
{
Console.WriteLine("\nGRAFO COMPLETO.\n");
}
else
{
Console.WriteLine("\nGRAFO NÃO É COMPLETO.\n");
}
}
catch (Exception ex)
{
Console.WriteLine(ex.Message);
}
break;
case 13:
try
{
if (g.Regular())
{
Console.WriteLine("\nGRAFO É REGULAR.\n");
}
else
{
Console.WriteLine("\nGRAFO NÃO É REGULAR.\n");
}
}
catch (Exception ex)
{
Console.WriteLine(ex.Message);
}
break;
case -1:
repete = false;
break;
}
}
}