// 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++;
}
}
/**
* Método recursivo que retorna todos os caminhos entre as cidades que possuem o Id equivalentes aos parâmetros.
* Cada passo do caminho em questão é armazenado na pilhaDeMovimentos de movimentos "pilhaMovimento".
* Por fim, se chegou ao destino, a pilhaDeMovimentos é armazenada na variável "caminhosEncontrados", representando um dos caminhos possíveis
* O método acaba quando todos os caminhos possíveis são percorridos.
*/
public List <Caminho> BuscarCaminhos(int idCidadeOrigem, int idCidadeDestino)
{
for (int i = 0; i < QtdCidades; i++)
{
if ((MatrizAdjacencia[idCidadeOrigem, i] != null) && (!jaPassou[i]))
{
pilhaMovimento.Empilhar(new Movimento(idCidadeOrigem, i));
jaPassou[i] = true;
if (i == idCidadeDestino) // se chegou ao destino
{
Caminho novoCaminho = new Caminho();
novoCaminho.Movimentos = pilhaMovimento.Clone();
caminhosEncontrados.Add(novoCaminho);
pilhaMovimento.Desempilhar(); // busca novos caminhos
jaPassou[i] = false;
}
else
{
BuscarCaminhos(i, idCidadeDestino); // backtracking
}
}
}
if (!pilhaMovimento.EstaVazia)
{
pilhaMovimento.Desempilhar();
jaPassou[idCidadeOrigem] = false;
}
return(caminhosEncontrados);
}
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
}
}
}
private void Converter(string inf)
{
string elemento = "";
string op = "";
for (int i = 0; i < inf.Length; i++) //Passa por todos os itens da sequencia infixa
{
elemento = "";
if (!ops.Contains(inf[i])) //Se o item lido não for um operador
{
elemento = "";
int inicial = i; //index do início do numero
while (inicial + elemento.Length < inf.Length && (!ops.Contains(inf[inicial + elemento.Length].ToString()) || inf[inicial + elemento.Length] == '.')) //Enquanto o elemento ainda for um número
{
elemento += inf[inicial + elemento.Length]; //O número é incrementado
}
i = inicial + elemento.Length - 1; //o for continua a partir de onde a leitura parou
posfixa.Enfileirar(elemento); //O número é adicionado na fila posfixa
}
else //Se o item lido for um operador
{
elemento = inf[i].ToString(); //O elemento recebe o item lido
while (!pilOps.EstaVazia() && Precedencia(pilOps.OTopo()) >= Precedencia(elemento[0].ToString())) //Enquanto o primeiro operador da pilha tiver precedência sobre os outros
{
op = pilOps.OTopo(); //Identifica o operador a ser tratado
if (op == "(")
{
break;
}
posfixa.Enfileirar(op.ToString()); //O operador é adicionado na sequencia posfixa
pilOps.Desempilhar(); //E removido da pilha
}
if (elemento == ")") //Se o operador for o fecha parênteses
{
pilOps.Desempilhar(); //Desempilha o ultimo operador
}
else //Se não
{
pilOps.Empilhar(elemento); //Empilha o operador normalmente
}
}
if (elemento != "(" && elemento != ")") //Verifica se o item não é ( nem ), pois esses não entram na sequência
{
infixa.Enfileirar(elemento); //Adiciona o item na infixa
}
}
while (!pilOps.EstaVazia()) //Até a pilha ficar vazia
{
op = pilOps.Desempilhar(); //Desempilha o operador
if (op != "(" && op != ")") //Verifica se o item não é ( nem ), pois esses não entram na sequência
{
posfixa.Enfileirar(op); //Enfilera o operador na posfixa
}
}
}
//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;
// //}
// for (int i=0; i<infixa.Length; i++)
// {
// char c = infixa[i];
// if (ops.Contains(c))
// {
// if (seq.EstaVazia())
// {
// seq.Empilhar(c);
// }
// else
// {
// if (MaiorPrecedencia(seq.OTopo(), c) == seq.OTopo())
// {
// if (c == '+' || c == '-')
// {
// ret += seq.Desempilhar();
// i--;
// }
// else
// {
// ret += seq.Desempilhar();
// i--;
// }
// }
// else
// {
// if (c == '+' || c == '-')
// {
// ret += seq.Desempilhar();
// seq.Empilhar(c);
// }
// else
// {
// seq.Empilhar(c);
// }
// }
// }
// }
// else
// {
// ret += c;
// }
// }
// return ret;
//}
//public string ParaPosfixa(string inf)
//{
// string ret = "";
// char[] exp = inf.ToCharArray();
// string ops = "()^*/+-";
// PilhaLista<string> pilOps = new PilhaLista<string>();
// for (int i = 0; i < inf.Length; i++)
// {
// string elemento = "";
// if (!ops.Contains(inf[i].ToString()))
// {
// elemento = "";
// int inicial = i;
// while (inicial + elemento.Length < inf.Length && (!ops.Contains(inf[inicial + elemento.Length].ToString()) || inf[inicial + elemento.Length] == '.'))
// elemento += inf[inicial + elemento.Length];
// i = inicial + elemento.Length - 1;
// //posfixa.Enfileirar(elemento);
// }
// else
// {
// if (inf[i] == '+' && (i == 0 || inf[i - 1] == '('))
// elemento = "#";
// else
// if (inf[i] == '-' && (i == 0 || inf[i - 1] == '('))
// elemento = "@";
// else
// elemento = inf[i] + "";
// while (!pilOps.EstaVazia() && Precedencia(pilOps.OTopo()[0] )> Precedencia (elemento[0]))
// {
// string op = pilOps.Desempilhar();
// /*if (op != "(" && op != ")")
// posfixa.Enfileirar(op);*/
// }
// if (elemento != ")")
// pilOps.Empilhar(elemento);
// }
// if (elemento != "(" && elemento != ")")
// ret += elemento;
// //infixa.Enfileirar(elemento);
// }
// //TratarPilhaOperadores();
// while (!pilOps.EstaVazia())
// {
// string o = pilOps.Desempilhar();
// ret += o;
// }
// //sequenciaInfixa = EscreverSequencia(infixa);
// //sequenciaPosfixa = EscreverSequencia(posfixa);
// //resultado = CalcularResultado();
// //return resultado;
// return ret;
//}
private void Converter(string inf)
{
for (int i = 0; i < inf.Length; i++)
{
string elemento = "";
if (ops.Contains(inf[i]))
{
elemento = "";
int inicial = i;
while (inicial + elemento.Length < inf.Length && (!ops.Contains(inf[inicial + elemento.Length].ToString()) || inf[inicial + elemento.Length] == '.'))
{
elemento += inf[inicial + elemento.Length];
}
i = inicial + elemento.Length - 1;
posfixa.Enfileirar(elemento);
}
else
{
elemento = inf[i].ToString();
while (!pilOps.EstaVazia() && Precedencia(pilOps.OTopo()) > Precedencia(elemento[0].ToString()))
{
char op = pilOps.OTopo()[0];
if (op == '(')
{
break;
}
posfixa.Enfileirar(op.ToString());
pilOps.Desempilhar();
}
if (elemento != ")")
{
pilOps.Empilhar(elemento);
}
else
{
pilOps.Desempilhar();
}
}
if (elemento != "(" && elemento != ")")
{
infixa.Enfileirar(elemento);
}
}
while (!pilOps.EstaVazia())
{
string op = pilOps.Desempilhar();
if (op != "(" && op != ")")
{
posfixa.Enfileirar(op);
}
}
}
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
}
}
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);
}
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
}
public PilhaLista <Dado> Inverter()
{
PilhaLista <Dado> aux = this;
PilhaLista <Dado> outra = new PilhaLista <Dado>();
while (!aux.EstaVazia())
{
outra.Empilhar(aux.Desempilhar());
}
return(outra);
}
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());
}
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);
}
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);
}
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);
}
// 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++;
}
}
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
}
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();
}
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 List <Caminho> BuscarCaminhos(int idCidadeOrigem, int idCidadeDestino)
{
int idCidadeAtual, idSaidaAtual;
bool achouCaminho = false, naoTemSaida = false;
bool[] jaPassou = new bool[QtdCidades];
for (int indice = 0; indice < QtdCidades; indice++)
{
jaPassou[indice] = false;
}
idCidadeAtual = idCidadeOrigem;
idSaidaAtual = 0;
while (!naoTemSaida)
{
naoTemSaida = (idCidadeAtual == idCidadeOrigem && idSaidaAtual == QtdCidades && pilhaAuxiliar.EstaVazia);
if (!naoTemSaida)
{
while ((idSaidaAtual < QtdCidades) && !achouCaminho)
{
if (MatrizAdjacencia[idCidadeAtual, idSaidaAtual] == null)
{
idSaidaAtual++;
}
else if (jaPassou[idSaidaAtual])
{
idSaidaAtual++;
}
else if (idSaidaAtual == idCidadeDestino)
{
Movimento movimento = new Movimento(idCidadeAtual, idSaidaAtual);
pilhaAuxiliar.Empilhar(movimento);
achouCaminho = true;
}
else
{
Movimento movimento = new Movimento(idCidadeAtual, idSaidaAtual);
pilhaAuxiliar.Empilhar(movimento);
jaPassou[idCidadeAtual] = true;
idCidadeAtual = idSaidaAtual;
idSaidaAtual = 0;
}
}
}
if (!achouCaminho)
{
if (!pilhaAuxiliar.EstaVazia)
{
jaPassou[idCidadeAtual] = false;
Movimento ultimoMovimento = pilhaAuxiliar.Desempilhar();
idSaidaAtual = ultimoMovimento.IdCidadeDestino;
idCidadeAtual = ultimoMovimento.IdCidadeOrigem;
idSaidaAtual++;
}
}
if (achouCaminho)
{
Caminho novoCaminho = new Caminho();
novoCaminho.Movimentos = pilhaAuxiliar.Clone();
caminhosEncontrados.Add(novoCaminho);
achouCaminho = false;
pilhaAuxiliar.Desempilhar();
for (int i = 0; i < QtdCidades; i++)
{
jaPassou[i] = false;
}
idSaidaAtual++;
}
}
return(caminhosEncontrados);
}
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 List <List <CaminhoEntreCidades> > Calcular(int origem, int destino)
{
PilhaLista <CaminhoEntreCidades> pilha = new PilhaLista <CaminhoEntreCidades>(); //Serivirá para fazer o Backtracking
List <List <CaminhoEntreCidades> > ret = new List <List <CaminhoEntreCidades> >(); //Armazenará todos os caminhos que encontramos
bool[] passouCidade = new bool[qtdCidades]; //Armazenaremos por quais cidades passamos
int cidadeAtual = origem;
int saidaAtual = 0; //Indica qual cidade tentaremos seguir
while (!(cidadeAtual == origem && saidaAtual == qtdCidades)) //Enquanto não tentamos todas as possibilidades da cidade inicial
{
if (saidaAtual < qtdCidades && cidadeAtual != destino) //Apenas continuaremos andando caso ainda hajam cidades a tentar e a
//cidade que estamos não é o destino
{
for (; saidaAtual < qtdCidades; saidaAtual++) //Tentaremos nos mover para todas as cidades
{
if (passouCidade[saidaAtual] == false && cidades[saidaAtual, cidadeAtual] != null)
{
break; //Caso não passamos pela cidade sendo testada e caso exista uma conecção entre as cidades,
}
}
//podemos sair do for
if (saidaAtual != qtdCidades) //Verificaremos se já tentamos todas as cidades, ou seja, se achamos algum caminho possível
{
//Se achamos algum caminho
passouCidade[cidadeAtual] = true; //Marcaremos que passados pela determinada cidade
pilha.Empilhar(cidades[saidaAtual, cidadeAtual]); //Guardaremos o movimento que fizemos
cidadeAtual = saidaAtual; //Avançaremos a cidade
saidaAtual = 0; //Prepararemos a variável para o próximo ciclo
}
}
else
{
if (cidadeAtual == destino) //Caso achamos o destino
{
/*
* Iremos guardar o caminho feito até então, para isso, devemos esvaziar a pilha.
* Porém, existe a chance de ainda precisarmos usar a pilha nesse método, ou seja,
* a pilha deve continuar igual após lermos seus dados.
* Por conta disso, devemos colocar os dados da pilha atual numa auxiliar (1), vamos trabalhar
* com os dados (2) quando os repassarmos para a pilha atual (3).
* Por fim, forçaremos um backtracking, fazendo com que o algoritmo tente descobrir um novo caminho
*/
PilhaLista <CaminhoEntreCidades> inver = new PilhaLista <CaminhoEntreCidades>();
List <CaminhoEntreCidades> nova = new List <CaminhoEntreCidades>();
while (!pilha.EstaVazia()) //(1)
{
inver.Empilhar(pilha.Desempilhar());
}
while (!inver.EstaVazia()) //(3)
{
CaminhoEntreCidades cid = inver.Desempilhar();
pilha.Empilhar(cid);
nova.Add(cid); //(2)
}
ret.Add(nova); //Guardaremos o caminho descoberto
}
//Fazendo Backtracking
passouCidade[cidadeAtual] = false; //Desmarcaremos que passamos pela cidade
CaminhoEntreCidades c = pilha.Desempilhar(); //Recuperaremos o último movimento que fizemos
cidadeAtual = c.Origem; //Voltaremos a cidade
saidaAtual = c.Destino + 1; //Evitaremos a possibilidade de acessarmos o mesmo caminho anterior
}
}
return(ret);
}
