public string Resolver(string expressaoPos)
{
//Declaração da pilha que guardará o resultado
PilhaHerdaLista <string> pilhaResult = new PilhaHerdaLista <string>();
for (int indice = 0; indice < qtd; indice++)
{
//Se é sinal, resolvemos uma parte da expressao, atualizando a pilha
if (SeEhSinal(vetorPosfixo[indice] + ""))
{
string sinal = vetorPosfixo[indice];
double b = double.Parse(pilhaResult.Desempilhar());
if (sinal != "@")
{
double a = double.Parse(pilhaResult.Desempilhar());
pilhaResult.Empilhar(SubExpressao(a, b, Convert.ToChar(sinal)));
}
else
{
if (sinal == "@")
{
double result = -b;
pilhaResult.Empilhar(result + "");
}
}
}
else
{
//Caso seja um número, apenas a adicionamos na pilhaResult
pilhaResult.Empilhar(vetorPosfixo[indice]);
}
}
return(pilhaResult.Desempilhar());
}
public bool VerificarParenteses(string expressao) //Método bool que verifica se os parenteses de uma sequencia estão ordenados
{
PilhaHerdaLista <string> parenteses = new PilhaHerdaLista <string>(); //instanciação da pilha parenteses, que, como o nome informa, nunca guardará algo que não seja abre ou fecha parenteses
foreach (var a in expressao) //Percorre caractere por caractere da string passada por parâmetro
{
if (a == '(') //Verifica se o caractere atual é um abre parenteses; se não for, lemos o próximo caractere
{
parenteses.Empilhar(a + ""); //Empilhamos o abre parenteses sempre que o achamos
}
else if (a == ')') //Verifica se o caractere atual é um fecha parenteses; se não for, lemos o próximo caractere
{
try
{
parenteses.Desempilhar(); //Caso consiga desempilhar, significa que a pilha não está vazia, logo sabemos que tem um abre parenteses referente ao fecha parenteses lido nessa posiçao da string, portanto está em ordem, e continuamos a percorre-la
}
catch (Exception) //Se tentarmos desempilhar algo de uma pilha vazia, uma exceção é lançada
{
return(false); //Caso não consiga desempilhar um fecha parenteses referente à um abre parenteses, a sequencia não está ordenada, portanto retornamos false
}
}
}
if (!parenteses.EstaVazia()) //Se a pilha parenteses não estiver vazia, então a sequencia fornecida por parametro tem mais fecha parenteses do que abre parenteses, portanto não está ordenada
{
return(false); //Retornamos false se a sequencia não está ordenada
}
return(true); //Retornamos true se a sequencia está ordenada
}
public static bool EstaBalanceada(String entrada) // Método que verifica se a expressão está balanceada
{
// construtor com tamanho default; topo valerá -1
PilhaHerdaLista <char> p = new PilhaHerdaLista <char>();
bool balanceada = true;
int indice = 0;
char simbolo;
char caracterAbertura;
for (indice = 0; balanceada && indice < entrada.Length; indice++)
{
simbolo = entrada[indice];
if (simbolo == '(')
{
p.Empilhar(simbolo); // chamada causa overhead
}
else
if (simbolo == ')')
{
if (p.EstaVazia())
{
balanceada = false; // pois a pilha já esvaziou
}
else
{
caracterAbertura = p.Desempilhar();
if (!Combinam(simbolo, caracterAbertura))
{
balanceada = false;
}
}
}
}
if (!p.EstaVazia())
{
balanceada = false;
}
return(balanceada);
}
public string ParaPosfixa(string expressaoInfixa)
{
string posfixa = "";
int a = 0;
if (expressaoInfixa[0] == '-')
{
posfixa += "s";
}
char letra = 'A';
//Para construimos a sequencia posfixa e popularmos seu vetor(que será usado no método Resolver()), fazemos um loop que percorre cada posição do vetInfixo
for (int indice = a; indice < qtd; indice++)
{
if (SeEhSinal(vetInfixo[indice])) //Caso o valor lido seja sinal, verificamos sua preferencia
{
if (indice != 0 || vetInfixo[indice] == "(")
{
if (vetInfixo[indice] == ")")
{
while (pilha.OTopo() != "(")
{
var aux = pilha.Desempilhar();
posfixa += aux;
vetorPosfixo[a] = aux;
a++;
}
pilha.Desempilhar();
}
else
{
while (!pilha.EstaVazia() && SeTemPreferencia(pilha.OTopo(), vetInfixo[indice]))
{
var aux = pilha.Desempilhar();
if (vetInfixo[indice] != "(")
{
posfixa += aux;
vetorPosfixo[a] = aux;
a++;
}
}
pilha.Empilhar(vetInfixo[indice]);
}
}
}
else
{
if (posfixa != "" && indice == 1)
{
posfixa = letra + "-";
vetorPosfixo[a] = vetInfixo[indice];
vetorPosfixo[++a] = "@";
letra++;
a++;
}
else
{
posfixa += letra;
letra++;
vetorPosfixo[a] = vetInfixo[indice];
a++;
}
}
}
//Caso a pilha de sinais não esteja vazia, temos que esvazia-la na sequencia correta
for (int l = qtd; !pilha.EstaVazia(); l++)
{
var aux = pilha.Desempilhar();
if (aux != "(")
{
posfixa += aux;
vetorPosfixo[a] = aux;
a++;
}
}
qtd = qtd - qtdParenteses; //Diminuimos 2 na variavel qtd porque os dois parenteses lidos não foram adicionados no vetorPosfixo, que será usado no método Resolver(), portanto deve estar com sua qtd atualizada
return(posfixa); //Retornamos a sequencia posfixa encontrada
}
