// GitHub: http://bit.ly/GrafoLA
// Vídeo: http://bit.ly/video-GrafoLA
// 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: 06/05/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 vértice");
Console.WriteLine("[03] Remover vértice");
Console.WriteLine("[04] Inserir aresta");
Console.WriteLine("[05] Remover aresta");
Console.WriteLine("[06] Imprimir grau de um vértice");
Console.WriteLine("[07] Verificar se o grafo é completo");
Console.WriteLine("[08] Verificar se o grafo é regular");
Console.WriteLine("[09] Imprimir Lista de Adjacências");
Console.WriteLine("[10] Imprimir Sequência de Graus");
Console.WriteLine("[11] Imprimir Vértices Adjacentes de um vértice");
Console.WriteLine("[12] Verificar se um vértice é isolado");
Console.WriteLine("[13] Verificar se um vértice é ímpar");
Console.WriteLine("[14] Verificar se um vértice é par");
Console.WriteLine("[15] Verificar se dois vértices são adjacentes");
Console.WriteLine("[16] 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 > 16 || 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 VÉRTICE ************************");
Grafo.InserirVertice();
Console.ReadKey(true);
break;
case (3):
Console.Clear();
Console.WriteLine("\n************************ REMOVER VÉRTICE ************************");
int vertice;
testeVertice = true;
Console.Write("\nDigite o número do vértice que deseja retirar: ");
testeVertice = int.TryParse(Console.ReadLine(), out vertice);
while (!testeVertice)
{
Console.Write("\nVALOR INVÁLIDO. Digite o número do vértice que deseja retirar: ");
testeVertice = int.TryParse(Console.ReadLine(), out vertice);
}
Grafo.RemoverVertice(vertice);
Console.ReadKey(true);
break;
case (4):
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)
{
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.InsereAresta(V1, V2);
Console.ReadKey(true);
break;
case (5):
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 (6):
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 (7):
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 (8):
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 (9):
Console.Clear();
Console.WriteLine("\n************************ IMPRIMIR LISTA DE ADJACÊNCIA ************************");
Grafo.ShowLA();
Console.ReadKey(true);
break;
case (10):
Console.Clear();
Console.WriteLine("\n************************ IMPRIMIR SEQUÊNCIA DE GRAUS ************************");
Grafo.SequenciaGraus();
Console.ReadKey(true);
break;
case (11):
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 (12):
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 (13):
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 (14):
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 (15):
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 (16):
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 MenuLista()
{
bool repete = true;
int menu = -1, controleInt = 0, v1 = 0, v2 = 0;
Grafo g = new Grafo();
Console.Clear();
repete = true;
while (repete)
{
do
{
try
{
Console.WriteLine("\n______________________________________________________________________________________\n" +
"*** Grafo que utiliza a estrutura de dados Lista de Adjacência ***\n\n" +
"\nEscolha uma opção no menu abaixo:\n" +
"1- Inserir vertice\n" +
"2- Remover Vértice\n" +
"3- Inserir aresta.\n" +
"4- Remover aresta.\n" +
"5- Imprimir Ordem do Grafo.\n" +
"6- Imprimir LA.\n" +
"7- Imprimir Sequencia de Graus.\n" +
"8- Imprimir vertices adjacentes.\n" +
"9- Verificar vértice isolado.\n" +
"10- Verificar se vértice é par.\n" +
"11- Verificar se vértice é impar.\n" +
"12- Verificar se dois vértices são adjacentes.\n" +
"13- Verificar se o Grafo é completo.\n" +
"14- 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 vertice: ");
v1 = int.Parse(Console.ReadLine());
repete = false;
}
catch (FormatException)
{
Console.Clear();
Console.WriteLine("ERRO NO VALOR DIGITADO");
}
} while (repete);
if (g.inserirVertice(v1))
{
Console.WriteLine("\nVértice adicionado com sucesso!\n\n");
}
else
{
Console.WriteLine("\nVértice NÃO adicionado.\n\n");
}
repete = true;
break;
case 2:
do
{
try
{
Console.WriteLine("Digite o vértice: ");
v1 = int.Parse(Console.ReadLine());
repete = false;
}
catch (FormatException)
{
Console.Clear();
Console.WriteLine("ERRO NO VALOR DIGITADO");
}
} while (repete);
if (g.RemoveVertice(v1))
{
Console.WriteLine("\nVértice removido com sucesso!\n\n");
}
else
{
Console.WriteLine("\nVertice NÃO removido.\n\n");
}
repete = true;
break;
case 3:
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 4:
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 5:
Console.WriteLine("\nA ordem do grafo é: " + g.Ordem() + "\n\n");
break;
case 6:
g.ShowLA();
break;
case 7:
g.SequenciaGraus();
break;
case 8:
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 9:
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 10:
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 11:
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 12:
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 13:
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 14:
try
{
if (g.Regular())
{
Console.WriteLine("\nGRAFO REGULAR.\n");
}
else
{
Console.WriteLine("\nGRAFO NÃO É REGULA.\n");
}
}
catch (Exception ex)
{
Console.WriteLine(ex.Message);
}
break;
case -1:
repete = false;
break;
}
}
}