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 FilaLista <char> CriarInfixa(ref string infixa) { FilaLista <char> seqInfixa = new FilaLista <char>(); char letra = 'A'; //char que irá de A a Z para "substituir" os números valores = new double[26]; //instanciação do vetor de valores string numero = ""; //string que armazenará um valor lido, caracter por caracter for (int i = 0; i < txtVisor.Text.Length && !erro; i++) //percorre string do txtVisor, indexando-o como um vetor, até acabar as posições { char caracterAtual = (txtVisor.Text)[i]; //pega o caracter atual pelo index do for int num; //variável apenas com fim de ser usada no tryParse if (int.TryParse(caracterAtual.ToString(), out num) || caracterAtual.Equals('.') || caracterAtual.Equals(',')) //se o valor for um número inteiro(como se está analisando apenas um caracter isolado, não se precisa usar double.TryParse) { // ou se for um '.', ou seja, uma vírgula do double, ele faz parte de um número if (caracterAtual.Equals('.')) { caracterAtual = ','; } numero += caracterAtual; //concatena caracter do número em formação } else if (numero != "") //se caracter lido não fizer mais parte de um número e a variável numero não for vazia { valores[letra - 'A'] = double.Parse(numero); //armazena-se valor do número formado, convertendo-o para double infixa += letra + "" + caracterAtual; //concatena-se o número e o caracter lido na string infixa seqInfixa.Enfileirar(letra); //enfileira letra referente a posição do número no vetor de valores seqInfixa.Enfileirar(caracterAtual); //enfileira caracter de operação numero = ""; //esvazia string de número para que comece a formação de um novo caso haja letra++; //vai para a próxima letra } else //se o caracter lido for referente a uma operação mas não houver um número na variável numero (está vazia) { if (caracterAtual.Equals('-') || caracterAtual.Equals('+')) //o caracter pode fazer parte do número, como "-1", mas daí o '+'/'-' tem que { //estar logo no começo da sequência, ou estar precedido de '(' if (seqInfixa.EstaVazia() || seqInfixa.OFim().Equals('(')) { numero += caracterAtual; } else { seqInfixa.Enfileirar(caracterAtual); //enfileira-se caracter atual infixa += caracterAtual; //concatena-se caracter atual em infixa } } else { seqInfixa.Enfileirar(caracterAtual); //enfileira-se caracter atual infixa += caracterAtual; //concatena-se caracter atual em infixa } } if (i + 1 == txtVisor.Text.Length && (numero != "") && !erro) // se o próximo index do vetor for o fim da operação mas o número não estiver vazio { valores[letra - 'A'] = double.Parse(numero); //armazena valor no vetor de valores seqInfixa.Enfileirar(letra); //enfileira letra correspondente a valor infixa += letra + ""; //concatena letra à sequencia infixa numero = ""; //esvazia número letra++; //vai à próxima letra } } lblInfixa.Text = infixa; //exibe sequência infixa formada no lblInfixa return(seqInfixa); }
public void AdicionarCaminho(Caminho novo) { Caminhos.Enfileirar(novo); }