private void btnIgual_Click(object sender, EventArgs e)
{
//Reinicia as filas e pilhas, para elas não continuarem com o que estavam antes
infixa = new FilaLista <string>();
posfixa = new FilaLista <string>();
pilOps = new PilhaLista <string>();
string inf = txtVisor.Text; //Lê os números do visor
double res = 0;
Converter(inf); //Gera as sequências
lbSequencias.Text = "Infixa: ";
EscreverSequencia(infixa); //Escreve a sequência infixa
lbSequencias.Text += "\nPosfixa: ";
EscreverSequencia(posfixa); //Escreve a sequência posfixa
try
{
res = Calcular(); //Calcula o resultado
txtResultado.Text = res.ToString(); //Exibe-o no visor de resultado
}
catch (DivideByZeroException erro) //Se ocorrer um erro de divisão por zero
{
MessageBox.Show(erro.Message); //Exibe um messageBox avisando o erro
txtResultado.Text = "Erro"; //Não é possível gerar resultado, por isso só exibe "Erro"
}
}
// MÉTODO PARA CALCULAR A EXPRESSÃO PÓSFIXA
private static void CalcularPosfixa(string expPosfixa, ref double result)
{
result = 0; // resultado do cálculo pófixo
int posExpPosFixa = 0; // posição na expressão pósfixa
PilhaLista <double> pilhaValores = new PilhaLista <double>(); // para empilhar os valores
while (posExpPosFixa < expPosfixa.Length)
{
char c = Convert.ToChar(expPosfixa.Substring(posExpPosFixa, 1)); // caracter lido
if (!IsOperador(c)) // não é operador
{
pilhaValores.Empilhar(vetValores[c - 'A']); // empilha o valor double
if (expPosfixa.Length == 1)
{
result = vetValores[c - 'A'];
}
}
else
{
if (c == '√')
{
result = ResolverOperacao(0, pilhaValores.Desempilhar(), c); // "√" é operador unário
}
else
{
result = ResolverOperacao(pilhaValores.Desempilhar(), pilhaValores.Desempilhar(), c); // resolve a operação
}
pilhaValores.Empilhar(result); // // empilha o resultado
}
posExpPosFixa++;
}
}
private void ConverterParaPosfixa(FilaLista <char> seqInfixa, ref string posfixa)
{
char operadorComMaiorPrecedencia;
PilhaLista <char> pilha = new PilhaLista <char>(); //pilha que será usada para empilhar operadores
do
{
char simboloLido = seqInfixa.Retirar(); //simbolo lido é retirado da fila de sequencia infixa
if (!(simboloLido <= 'Z' && simboloLido >= 'A')) //se o simbolo lido não estiver entre A e Z, ou seja, for um operador
{
if (pilha.EstaVazia()) //se a pilha estiver vazia, empilha-se simbolo lido
{
pilha.Empilhar(simboloLido);
}
else //se não estiver vazia
{
while (!pilha.EstaVazia() && DeveDesempilhar(pilha.OTopo(), simboloLido)) //enquanto a pilha não estiver vazia e deve desempilhar, ou seja, o topo da pilha tem precedencia sobre o simbolo lido
{
operadorComMaiorPrecedencia = pilha.Desempilhar(); //armazena-se operador com maior precedencia, tirando-o do topo
if (operadorComMaiorPrecedencia != '(') //caso não seja '(', pois não se coloca parêntesis em sequências posfixas
{
seqPosfixa.Enfileirar(operadorComMaiorPrecedencia); //enfileira-se na seqPosfixa
posfixa += operadorComMaiorPrecedencia; //concatena-se na string de posfixa
}
}
if (simboloLido != ')') // empilha-se o simbolo lido, a menos que ele seja um ')'
{
pilha.Empilhar(simboloLido);
}
else
{
if (!pilha.EstaVazia() && pilha.OTopo() == '(') //se o simbolo lido for ')' e já foi feito o método acima sobre as precedencias, restará um parentesis aberto no topo da pilha, a menos que a sequência não esteja balanceada
{
operadorComMaiorPrecedencia = pilha.Desempilhar();
}
else
{
erro = true;
}
}
}
}
else // se for letra
{
seqPosfixa.Enfileirar(simboloLido); //enfileira-se letra na sequência
posfixa += simboloLido; //concatena-se a letra na string posfixa
}
}while (!seqInfixa.EstaVazia() && !erro); //enquando não estiver vazia e não houver nenhum erro, continua-se a expressão
while (!pilha.EstaVazia() && !erro) // se a fila de sequência ja estiver acabado mas houver operandos na pilha e não tiver dado erro
{
operadorComMaiorPrecedencia = pilha.Desempilhar(); //desempilha-se elemento da pilha
if (operadorComMaiorPrecedencia != '(') //se não for '('
{
seqPosfixa.Enfileirar(operadorComMaiorPrecedencia); //enfileira elemento
posfixa += operadorComMaiorPrecedencia; //concatena à string posfixa
}
}
}
public PilhaLista <Dado> Clone()
{
PilhaLista <Dado> pilhaAux = new PilhaLista <Dado>();
pilhaAux.topo = topo;
pilhaAux.tamanho = tamanho;
return(pilhaAux);
}
public PilhaLista(PilhaLista <Dado> modelo)
{
if (modelo == null)
{
throw new Exception("Modelo ausente");
}
this.topo = (NoLista <Dado>)modelo.topo.Clone();
this.tamanho = modelo.tamanho;
}
public void Inverter()
{
PilhaLista <Dado> aux = new PilhaLista <Dado>();
while (!EstaVazia())
{
aux.Empilhar(Desempilhar());
}
this.topo = aux.topo;
this.tamanho = aux.tamanho;
}
public PilhaLista <Dado> Inverter()
{
PilhaLista <Dado> aux = this;
PilhaLista <Dado> outra = new PilhaLista <Dado>();
while (!aux.EstaVazia())
{
outra.Empilhar(aux.Desempilhar());
}
return(outra);
}
public PilhaLista <Dado> Clone()
{
PilhaLista <Dado> ret = null;
try
{
ret = new PilhaLista <Dado>(this);
}
catch (Exception erro)
{ }
return(ret);
}
private double Calcular()
{
PilhaLista <double> valores = new PilhaLista <double>();
double a = 0, b = 0, ret = 0;
string[] vet = posfixa.ToArray();
foreach (string s in vet)
{
if (!ops.Contains(s))
{
valores.Empilhar(double.Parse(s.Replace('.', ',')));
}
else
{
a = valores.Desempilhar();
b = valores.Desempilhar();
switch (s)
{
case "^":
ret = Math.Pow(b, a);
break;
case "*":
ret = a * b;
break;
case "/":
if (a == 0)
{
throw new DivideByZeroException("Divisão por 0");
}
ret = b / a;
break;
case "+":
ret = a + b;
break;
case "-":
ret = b - a;
break;
default:
break;
}
valores.Empilhar(ret);
}
}
return(valores.Desempilhar());
}
// MÉTODO PARA TRANSFORMAR A EXPRESSÃO INFIXA PARA PÓSFIXA
private static void InfixaParaPosfixa(string expLetras, ref string expPosfixa)
{
PilhaLista <char> pilha = new PilhaLista <char>(); // para empilhar os operadores
expPosfixa = ""; // expressão pósfixa com letras
for (int posExp = 0; posExp < expLetras.Length; posExp++)
{
char c = Convert.ToChar(expLetras.Substring(posExp, 1)); // caracter lido
if (!IsOperador(c)) // se não é operador, ou seja, é letra (valor)
{
expPosfixa += c; // adiciona na expressão
}
else
{
if (pilha.EstaVazia() && c != ')')
{
pilha.Empilhar(c); // empilha o operador
}
else
{
if (c == ')') // se achamos um ")", existem operações prioritárias
{
while (pilha.OTopo() != '(') // enquanto não acharmos o correspondente
{
expPosfixa += pilha.Desempilhar(); // desempilha os operadores priorizados
}
pilha.Desempilhar(); // desempilha o próprio "("
}
else
{
while (Precedencia(pilha.OTopo(), c) && pilha.OTopo() != '(')
{
expPosfixa += pilha.Desempilhar(); // o topo tem precedência, então devem vir primeiro (desempilhando)
if (pilha.EstaVazia())
{
break;
}
}
pilha.Empilhar(c); // empilha o novo caracter lido
}
}
}
}
while (!pilha.EstaVazia()) // acabou a expressão, então se sobrou operadores
{
expPosfixa += pilha.Desempilhar(); // desempilhamos, já que está na ordem certa
}
}
public Object Clone()
{
PilhaLista <Dado> obj = null;
try
{
obj = new PilhaLista <Dado>(this);
}
catch (Exception erro)
{
}
return(obj);
}
public PilhaLista <Dado> Copia()
{
PilhaLista <Dado> s1 = new PilhaLista <Dado>();
PilhaLista <Dado> s2 = new PilhaLista <Dado>();
while (!this.EstaVazia())
{
s1.Empilhar(this.Desempilhar());
}
while (!s1.EstaVazia())
{
var obj = s1.Desempilhar();
this.Empilhar(obj);
s2.Empilhar(obj.Copia());
}
return(s2);
}
private string paraPosfixa(string infixa)
{
string ret = "";
char[] exp = infixa.ToCharArray();
string ops = "()^*/+-";
PilhaLista <char> seq = new PilhaLista <char>();
foreach (char c in exp)
{
if (ops.Contains(c))
{
if (seq.EstaVazia())
{
seq.Empilhar(c);
}
else
{
if (MaiorPrecedencia(seq.OTopo(), c) == seq.OTopo())
{
if (c == ')')
{
while (!seq.EstaVazia() && seq.OTopo() != '(')
{
ret += seq.Desempilhar();
}
}
else
{
ret += seq.Desempilhar();
seq.Empilhar(c);
}
}
else
{
seq.Empilhar(c);
}
}
}
else
{
ret += c;
}
}
return(ret);
}
public PilhaLista <Dado> Clone()
{
PilhaLista <Dado> aux = new PilhaLista <Dado>();
while (!this.EstaVazia())
{
aux.Empilhar(this.Desempilhar());
}
PilhaLista <Dado> copia = new PilhaLista <Dado>();
while (!aux.EstaVazia())
{
Dado d = aux.Desempilhar();
this.Empilhar(d);
copia.Empilhar(d);
}
return(copia);
}
public bool Existe(Dado dado)
{
PilhaLista <Dado> pilhaAux = Clone();
while (!EstaVazia())
{
if (OTopo().CompareTo(dado) == 0)
{
this.topo = pilhaAux.topo;
this.tamanho = pilhaAux.tamanho;
return(true);
}
Desempilhar();
}
this.topo = pilhaAux.topo;
this.tamanho = pilhaAux.tamanho;
return(false);
}
private double CalcularResultado(FilaLista <string> expre)
{
PilhaLista <double> valores = new PilhaLista <double>();
double v1 = 0, v2 = 0, result = 0;
string[] vet = expre.ToArray();
for (int c = 0; c < vet.Length; c++) //for até o fim do vetor
{
if (!IsOp(vet[c])) //se não for operação
{
valores.Empilhar(double.Parse(vet[c].Replace('.', ','))); //empilha e troca ponto por vírgula
}
else
{
v1 = valores.Desempilhar(); //desempilha o 1º valor
v2 = valores.Desempilhar(); //desempilha o 2º valor
switch (vet[c]) //switch do valor caso seja operção
{
case "+": result = v2 + v1; break; //se for + soma
case "-": result = v2 - v1; break; //se for - subtrai
case "*": result = v2 * v1; break; //se for * multiplica
case "/": //se for divisão
if (v1 == 0)
{
throw new DivideByZeroException("Divisão por 0"); //se for 0 joga exceção
}
result = v2 / v1; break; //se não for zero calcula
case "^": result = Math.Pow(v2, v1); break; //se for ^ faz potência
}
valores.Empilhar(result); //empilha o resultado
}
}
return(valores.Desempilhar()); //no fim desempilha o resultado final
}
private double CalcularResultado(FilaLista <string> expre)
{
PilhaLista <double> valores = new PilhaLista <double>();
double v1 = 0, v2 = 0, result = 0;
string[] vet = expre.ToArray();
for (int c = 0; c < vet.Length; c++)
{
if (!IsOp(vet[c]))
{
valores.Empilhar(double.Parse(vet[c].Replace('.', ',')));
}
else
{
v1 = valores.Desempilhar();
v2 = valores.Desempilhar();
switch (vet[c])
{
case "+": result = v2 + v1; break;
case "-": result = v2 - v1; break;
case "*": result = v2 * v1; break;
case "/":
if (v1 == 0)
{
throw new DivideByZeroException("Divisão por 0");
}
result = v2 / v1; break;
case "^": result = Math.Pow(v2, v1); break;
}
valores.Empilhar(result);
}
}
return(valores.Desempilhar());
}
private List <Caminho> SalvarResultados(int idCidadeOrigem, int idCidadeDestino)
{
int onde = idCidadeDestino;
PilhaLista <Movimento> pilhaMovimentos = new PilhaLista <Movimento>();
while (onde != idCidadeOrigem)
{
pilhaMovimentos.Empilhar(MatrizAdjacencia[vertices[percursos[onde].verticePai].Cidade.Id, vertices[onde].Cidade.Id]);
onde = percursos[onde].verticePai;
}
if (pilhaMovimentos.Tamanho > 1)
{
PilhaLista <Movimento> pilhaMovimentosInvertido = new PilhaLista <Movimento>();
for (int i = pilhaMovimentos.Tamanho - 1; !pilhaMovimentos.EstaVazia; i--) // exibe cada movimento do melhor caminho
{
Movimento mov = pilhaMovimentos.Desempilhar();
pilhaMovimentosInvertido.Empilhar(mov);
}
caminhoEncontrado.Add(new Caminho(pilhaMovimentosInvertido));
}
return(caminhoEncontrado);
}
public Caminho(PilhaLista <Movimento> movimentos)
{
this.movimentos = movimentos.Clone();
}
public Caminho()
{
this.movimentos = new PilhaLista <Movimento>();
}
void Processar()
{
lsbBalanceado.Items.Clear();
lsbOriginal.Items.Clear();
bool houveErro = false;
int numeroDoBloco = 0;
var pilha = new PilhaLista <Palavra>();
var arquivo = new StreamReader(dlgAbrir.FileName);
while (!arquivo.EndOfStream && !houveErro)
{
string linha = arquivo.ReadLine();
string linhaDeSaida = "";
int posicaoNaLinha = 0;
while (posicaoNaLinha < linha.Length && !houveErro)
{
string palavraLida = "";
char caracter = linha[posicaoNaLinha];
if (EhLetra(caracter)) // começou palavra, percorremos até terminar a palavra
{
int ondeComecouAPalavra = posicaoNaLinha;
while (posicaoNaLinha < linha.Length && EhLetra(linha[posicaoNaLinha]))
{
posicaoNaLinha++;
}
int quantosCaracteresTemAPalavra = posicaoNaLinha - ondeComecouAPalavra;
palavraLida = linha.Substring(ondeComecouAPalavra, quantosCaracteresTemAPalavra);
string palavraEmMaiusculo = palavraLida.ToUpper();
if (palavraEmMaiusculo.Equals("BEGIN") || // palavra abre bloco de comando?
palavraEmMaiusculo.Equals("CASE") ||
palavraEmMaiusculo.Equals("REPEAT"))
{
numeroDoBloco++;
pilha.Empilhar(new Palavra(palavraLida, numeroDoBloco));
linhaDeSaida += palavraLida + " {" + numeroDoBloco + "} ";
}
else // poderá ser palavra que encerra bloco de comandos
if (palavraEmMaiusculo.Equals("END") || // palavra abre bloco de comando?
palavraEmMaiusculo.Equals("UNTIL"))
{
var palavraDesempilhada = pilha.Desempilhar();
if (palavraEmMaiusculo.Equals("END"))
{
if (palavraDesempilhada.palavra.ToUpper().Equals("BEGIN") || // está correto
palavraDesempilhada.palavra.ToUpper().Equals("CASE")
)
{
linhaDeSaida += palavraLida + " {" + palavraDesempilhada.numero + "} ";
}
else
{
houveErro = true;
linhaDeSaida += "END sem o Begin ou Case correspondente.";
}
}
else
if (palavraEmMaiusculo.Equals("UNTIL"))
{
if (palavraDesempilhada.palavra.ToUpper().Equals("REPEAT")) // está correto
{
linhaDeSaida += palavraLida + " {" + palavraDesempilhada.numero + "} ";
}
else
{
houveErro = true;
linhaDeSaida += "UNTIL sem o Repeat correspondente.";
}
}
}
else
{
linhaDeSaida += palavraLida;
}
}
else
{
linhaDeSaida += caracter.ToString();
posicaoNaLinha++;
}
} // while
lsbOriginal.Items.Add(linha);
lsbBalanceado.Items.Add(linhaDeSaida);
}
if (houveErro)
{
lsbBalanceado.Items.Add("Desbalanceado!");
}
if (!pilha.EstaVazia())
{
lsbBalanceado.Items.Add("Há begin, Case ou Repeat a mais.");
}
arquivo.Close();
}
private void btnIgual_Click(object sender, EventArgs e)
{
FilaLista <string> infixa = new FilaLista <string>();
FilaLista <string> posfixa = new FilaLista <string>();
PilhaLista <string> ops = new PilhaLista <string>(); //declara e instancia as 3 listas
string expressao = txtVisor.Text; //expressão a ser calculada
for (int i = 0; i < expressao.Length; i++) //for até o fim da expressão
{
string elemento = "";
if (!IsOp(expressao[i].ToString())) //se não for uma operção
{
elemento = "";
int inicial = i;
while (inicial + elemento.Length < expressao.Length && (!IsOp(expressao[inicial + elemento.Length].ToString()) || expressao[inicial + elemento.Length] == '.')) //enquanto não acabou a expressão, não for operação ou não for ponto
{
elemento += expressao[inicial + elemento.Length]; //incrementa o elemento com o valor da posição específic da expressão
}
i = inicial + elemento.Length - 1;
posfixa.Enfileirar(elemento); //enfileira na posfixa o elemento
}
else //se for operação
{
elemento = expressao[i] + "";
while (!ops.EstaVazia() && TemPrecedencia(ops.OTopo()[0], elemento[0])) //enquanto não estiver vazia e tiver precedência
{
char op = ops.OTopo()[0];
if (op == '(')
{
break;
}
else //se não for abre parenteses
{
posfixa.Enfileirar(op + ""); //enfileira
ops.Desempilhar(); //desempilha
}
}
if (elemento != ")") //se não for fecha parenteses
{
ops.Empilhar(elemento); //empilha
}
else //se for
{
ops.Desempilhar(); //desempilha
}
}
if (elemento != "(" && elemento != ")") //se não for parenteses
{
infixa.Enfileirar(elemento); //enfileira o elemento
}
}
while (!ops.EstaVazia()) //enquanto não estiver vazia
{
string op = ops.Desempilhar(); //pega o primeiro da pilha
if (op != "(" && op != ")") //se não for parenteses
{
posfixa.Enfileirar(op); //enfileira
}
}
escreverSeq(infixa, posfixa); //escreve na tela as sequências
txtResultado.Text = CalcularResultado(posfixa).ToString(); //calcula e escreve o resultado
}
public Pilhas()
{
caminhosEncontrados = new List <Caminho>();
pilhaAuxiliar = new PilhaLista <Movimento>();
}
private void btnIgual_Click(object sender, EventArgs e)
{
FilaLista <string> infixa = new FilaLista <string>();
FilaLista <string> posfixa = new FilaLista <string>();
PilhaLista <string> ops = new PilhaLista <string>();
string expressao = txtVisor.Text;
for (int i = 0; i < expressao.Length; i++)
{
string elemento = "";
if (!IsOp(expressao[i].ToString()))
{
elemento = "";
int inicial = i;
while (inicial + elemento.Length < expressao.Length && (!IsOp(expressao[inicial + elemento.Length].ToString()) || expressao[inicial + elemento.Length] == '.'))
{
elemento += expressao[inicial + elemento.Length];
}
i = inicial + elemento.Length - 1;
posfixa.Enfileirar(elemento);
}
else
{
elemento = expressao[i] + "";
while (!ops.EstaVazia() && TemPrecedencia(ops.OTopo()[0], elemento[0]))
{
char op = ops.OTopo()[0];
if (op == '(')
{
break;
}
else
{
posfixa.Enfileirar(op + "");
ops.Desempilhar();
}
}
if (elemento != ")")
{
ops.Empilhar(elemento);
}
else
{
ops.Desempilhar();
}
}
if (elemento != "(" && elemento != ")")
{
infixa.Enfileirar(elemento);
}
}
while (!ops.EstaVazia())
{
string op = ops.Desempilhar();
if (op != "(" && op != ")")
{
posfixa.Enfileirar(op);
}
}
escreverSeq(infixa, posfixa);
txtResultado.Text = CalcularResultado(posfixa).ToString();
}
public int CompareTo(PilhaLista <Dado> outra)
{
return(this.CompareTo(outra));
}
// Acha todos os caminhos usando o algoritmo de backtracking de cada labirinto especificado...
public void AcharCaminhos(ref DataGridView dgvLab, ref List <Posicao[]> caminhos, ref int[] qtdPosicoesEmCadaCaminho) //encontra os caminhos
{
Posicao posAtual = new Posicao(1, 1); //nova posição no início do labirinto
Posicao[] vetorPos = new Posicao[labirinto.Matriz.Length];
qtdPosicoesEmCadaCaminho = new int[labirinto.Matriz.Length * 10]; //Garante que não há estouro
caminhos = new List <Posicao[]>();
Posicao proxPosicao = null;
bool temCaminho;
bool achouSaida = false;
int qtdPosicoes = 0, qtdCaminhos = 0;
Pintar(ref dgvLab, posAtual.Linha, posAtual.Coluna);
while (true)
{
while (true) //loop eterno
{
proxPosicao = (Posicao)posAtual.Clone();
temCaminho = TemCaminho(ref posAtual, ref proxPosicao); //verifica se tem caminho
// Sinaliza no labirinto da classe Labirinto e no labirinto visual (dgvLab) para qual lugar prosseguiu
// o cursor depois de usar a Rosa dos Ventos (método TemCaminho()).
if (temCaminho)
{
proxPosicao.OndeParou = -1;
pilha.Empilhar(posAtual);
posAtual = (Posicao)proxPosicao.Clone();
// Verifica-se se o lugar para onde o cursor foi é a saída ou não.
if ((char)dgvLab[posAtual.Coluna, posAtual.Linha].Value != SAIDA)
{
dgvLab[posAtual.Coluna, posAtual.Linha].Value = JA_PASSOU;
this.labirinto.Matriz[posAtual.Linha, posAtual.Coluna] = JA_PASSOU;
Pintar(ref dgvLab, posAtual.Linha, posAtual.Coluna);
}
else
{
Pintar(ref dgvLab, posAtual.Linha, posAtual.Coluna);
if (listaCaminhos.Count == 0)
{
System.Threading.Thread.Sleep(500);
}
achouSaida = true;
break;
}
}
// Volta a posição anterior - pois não há mais lugares para ir da posição atual, a não ser voltar!
else
{
if (pilha.EstaVazia)
{
Pintar(ref dgvLab, 1, 1);
break; //Não há caminhos
}
proxPosicao = (Posicao)pilha.OTopo().Clone();
dgvLab[posAtual.Coluna, posAtual.Linha].Value = VAZIO;
this.labirinto.Matriz[posAtual.Linha, posAtual.Coluna] = VAZIO;
Pintar(ref dgvLab, proxPosicao.Linha, proxPosicao.Coluna);
posAtual = (Posicao)pilha.Desempilhar().Clone();
}
}
// Quando a saída, no labirinto: "S", é achada pelo algoritmo e o caminho feito para chegar até a saída
// é adicionado a ArrayList de strings "listaCaminhos", que será usada posteriormente no método "MostrarCaminhos".
if (achouSaida)
{
string ret = "";
int linhaAtual, colunaAtual;
PilhaLista <Posicao> pilhaClonada = pilha.Copia();
while (!pilhaClonada.EstaVazia)
{
linhaAtual = pilhaClonada.OTopo().Linha;
colunaAtual = pilhaClonada.OTopo().Coluna;
Posicao posicaoAtual = new Posicao(linhaAtual, colunaAtual);
vetorPos[qtdPosicoes] = posicaoAtual;
ret += $"Linha: {linhaAtual}, Coluna: {colunaAtual}|";
pilhaClonada.Desempilhar();
qtdPosicoes++;
}
qtdPosicoesEmCadaCaminho[qtdCaminhos] = qtdPosicoes;
caminhos.Add(vetorPos);
listaCaminhos.Add(ret);
// Reseta-se todas as variáveis usadas para encontrarmos um caminho diferente do já encontrado!
qtdPosicoes = 0;
vetorPos = new Posicao[labirinto.Matriz.Length];
achouSaida = false;
}
else
{
if (listaCaminhos.Count > 0)
{
break; //Encontrou todos os caminhos
}
else
{
listaCaminhos.Add("Não há caminhos");
}
}
if (pilha.EstaVazia)
{
break;
}
posAtual = (Posicao)pilha.Desempilhar().Clone();
qtdCaminhos++;
}
}
static void Main(string[] args)
{
const int maxCidade = 11;
const int cidadeFinal = 3;
const int cidadeInicial = 6;
PilhaLista <Movimento> pilha = new PilhaLista <Movimento>();
List <int> todosAndados = new List <int>();
bool[] passouCidade = { false, false, false, false, false, false, false, false, false, false, false };
int saidaAtual = 0;
while (!(cidadeAtual == cidadeInicial && saidaAtual == maxCidade))
{
if (saidaAtual < maxCidade && cidadeAtual != cidadeFinal)
{
while (saidaAtual < maxCidade)
{
if (passouCidade[saidaAtual] == false && cidades[cidadeAtual, saidaAtual] > -1)
{
break;
}
saidaAtual++;
}
if (saidaAtual != maxCidade)
{
passouCidade[cidadeAtual] = true;
pilha.Empilhar(new Movimento(cidadeAtual, saidaAtual, cidades[cidadeAtual, saidaAtual]));
cidadeAtual = saidaAtual;
saidaAtual = 0;
}
}
else
{
if (cidadeAtual == cidadeFinal)
{
PilhaLista <Movimento> inver = new PilhaLista <Movimento>();
inver.Empilhar(new Movimento(cidadeAtual, saidaAtual, 0));
while (!pilha.EstaVazia())
{
inver.Empilhar(pilha.Desempilhar());
}
int totalAndado = 0;
Write("Caminho encontrado: ");
while (!inver.EstaVazia())
{
Movimento mov = inver.Desempilhar();
totalAndado += mov.Valor;
Write(mov + "; ");
pilha.Empilhar(mov);
}
Write("Total andado: " + totalAndado);
WriteLine();
todosAndados.Add(totalAndado);
pilha.Desempilhar();
}
passouCidade[cidadeAtual] = false;
Movimento m = pilha.Desempilhar();
cidadeAtual = m.Cidade;
saidaAtual = m.Saida + 1;
}
}
int menor = 0;
int maior = 0;
for (int i = 0; i < todosAndados.Count; i++)
{
if (todosAndados[i] < todosAndados[menor])
{
menor = i;
}
if (todosAndados[i] > todosAndados[maior])
{
maior = 1;
}
}
WriteLine("Menor caminho: " + (menor + 1));
WriteLine("Maior caminho: " + (maior + 1));
ReadLine();
}
public Recursao()
{
jaPassou = new bool[QtdCidades];
pilhaMovimento = new PilhaLista <Movimento>();
caminhosEncontrados = new List <Caminho>();
}
private void Calcular()
{
PilhaLista <double> pilhaValores = new PilhaLista <double>(); //pilha que armazena valores da expressão
do
{
char simbolo = seqPosfixa.Retirar(); //retira-se um simbolo da sequência posfixa
if (simbolo >= 'A' && simbolo <= 'Z') //se o símbolo for uma letra
{
double valor = valores[simbolo - 'A']; //recupera valor referente à letra indexando o vetor valores
pilhaValores.Empilhar(valor); //empilha valor recebido
}
else // se for operador
{
double valor = 0;
double operando2 = 0;
double operando1 = 0;
if (pilhaValores.Tamanho() < 2)
{
erro = true; //não há elementos suficientes para desempilhar os operandos, ou seja, o usuário digitou operadores 'sobrando'
txtResultado.Text = "Erro: operadores a mais";
}
else
{
operando2 = pilhaValores.Desempilhar(); //o segundo operando é referente ao topo da pilha, e é desempilhado
operando1 = pilhaValores.Desempilhar(); //desempilha-se primeiro operando
}
switch (simbolo) //switch para realizar diferentes operações dependendo do operador
{
case '*':
valor = operando1 * operando2;
break;
case '/':
if (operando2 == 0) // na divisão, não se pode ter divisor 0
{
txtResultado.Text = "Erro: Divisão por 0";
erro = true;
}
else
{
valor = operando1 / operando2;
}
break;
case '^':
valor = Math.Pow(operando1, operando2);
break;
case '+':
valor = operando1 + operando2;
break;
case '-':
valor = operando1 - operando2;
break;
}
pilhaValores.Empilhar(valor); //empilha-se valor da sub-expressão realizada
}
}while (!seqPosfixa.EstaVazia() && !erro); // continua caso não tenha acabado a sequencia e não tenha havido erro
if (!erro) //se não tiver dado erro
{
double resultado = pilhaValores.Desempilhar(); //como os resultados das sub-expressões vão sendo armazenados na pilha, ao final restará o resultado
txtResultado.Text = resultado.ToString(); //exibe resultado
}
}
public PilhaLista(PilhaLista <Dado> model)
{
this.topo = model.topo;
this.tamanho = model.tamanho;
}
