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; }