A pilha é uma lista que restringe a inserção e a exclusão a serem executadas apenas em uma posição. Esta posição é o final da lista, chamada de topo da pilha. Para as operações básicas da pilha, há push e pop. O primeiro é a inserção e o último é excluído.
A pilha também é uma tabela FIFO.
Existem dois tipos de implementações de pilhas, um é usar matrizes e o outro é usar listas vinculadas.
classe pública MyArrayStack <E> {Private ArrayList <E> list = new ArrayList <> (); public void push (e e) {list.add (e); } public e pop () {return list.remove (list.size () - 1); } public e peek () {return list.get (list.size () - 1); } public boolean isEmpty () {return list.size () == 0; }} classe pública myLinkStack <E> {LinkedList <E> list = new LinkedList <> (); public void push (e e) {list.addlast (e); } public e pop () {return list.RemoveLast (); } public e peek () {return list.getLast (); } public boolean isEmpty () {return list.size () == 0; }} Aplicação de pilha
Símbolo do equilíbrio
Dada uma sequência de código, verificamos se os colchetes neste código estão em conformidade com a sintaxe.
Por exemplo: [{()}] Isso é legal, mas [{]} () é ilegal.
A seguir, o código de teste:
classe pública Balancesymbol {public boolean IsBalance (string string) {MyArrayStack <Acilá> Stack = new MyArrayStack <> (); char [] array = string.toCharArray (); para (char ch: array) {if ("{[(" .IndexOf (ch)> = 0) {staack.push (ch);} else if ("}])". }}} return Stack.isempty (); } private boolean ismatching (char peek, char ch) {if ((peek == '{' && ch == '}') || (peek == '[' && ch == '])) || (peek == (' && ch ==))) {return true; } retornar false; } public static void main (string [] args) {balancesymbol símbolo = new Balancesymbol (); String string = "public static void main (string [] args) {balancesymbol símbolo = new Balancesymbol ();}"; String string2 = "public static void main (string [] args) {balancesymbol símbolo = new balancesymbol ([);}]"; System.out.println (symol.isbalance (string)); System.out.println (symbol.isbalance (string2)); }} Expressão do sufixo
Por exemplo, uma entrada seguinte calcula o resultado correspondente,
3 + 2 + 3 * 2 =?
Isso produzirá resultados diferentes em diferentes ordem de cálculo. Se o resultado do cálculo for 16 da esquerda para a direita, e se o resultado do cálculo for 11 de acordo com a prioridade matemática.
Se a expressão de infixo acima for convertida em uma expressão de sufixo:
3 2 + 3 2 * +
Seria muito simples calcular o valor dessa expressão usando uma expressão de sufixo, basta usar uma pilha.
Sempre que um número é encontrado, coloque o número na pilha.
Sempre que um operador é encontrado, dois elementos aparecem para calcular de acordo com o operador e depois os colocam na pilha.
O único elemento que aparece na pilha é o resultado do cálculo.
/*** Versão simplificada, cada operando é apenas um e, assumindo que a string é legal*/public class PostfixExpression {public static int calcular (string string) {MyArrayStack <String> pilha = new MyArrayStack <> (); char [] arr = string.toCharArray (); for (char ch: arr) {if ("0123456789" .IndexOf (ch)> = 0) {staack.push (ch + ""); } else if ("+-*/". int b = Integer.parseint (Stack.pop ()); if (CH == ' +') {Stack.push ((a + b) + ""); } else if (CH == ' -') {Stack.push ((a - b) + ""); } else if (CH == ' *') {Stack.push ((a * b) + ""); } else if (CH == ' /') {Stack.push ((a / b) + ""); }} retornar integer.parseint (pilha.peek ()); } public static void main (string [] args) {System.out.println (calcular ("32+32*+")); }} Converter uma expressão de infix em uma expressão de sufixo
Suponha que apenas as expressões +, -, *, /, () sejam executadas. E a expressão é legal.
a + b * c - (d * e + f) / g A expressão de sufixo convertida é a seguinte:
abc * + de * f + g / -
As etapas para usar o Infix Stack para converter sufixos são as seguintes:
importar java.util.hashmap; importar java.util.map; public class Expressionswitch {private estático mapa <caractere, número inteiro> map = new Hashmap <caractere, inteiro> (); estático {map.put ('+', 0); map.put ('-', 1); map.put ('*', 2); map.put ('/', 3); map.put('(', 4); } private static char[][] priority = { // Current operator// + - * / ( /* Stack+ */{ '>', '>', '<', '<', '<'}, /* Top- */{ '>', '>', '<', '<', '<'}, /* Do* */{ '>', '>', '>', '>', '<'},/ * Make/ */{'>' ',' '', '>' '', '' ',' <'},/ * caractere ( */{' <',' <',' <',' <',' <'},}; public strath1 (string) (string) (strings); MyArrayStack <Aclá> Stack = new MyArrayStack <> (); == CH) {while (true &&! Stack.isempty ()) {char tmp = Stack.pop (); pilha.peek (); } return builder.toString (); } private estático booleano ispriorityHigh (char tmp, char ch) {retorna prioridade [map.get (tmp)] [map.get (ch)] == '>'; } public static void main (string [] args) {System.out.println (switch1 ("a+b*c- (d*e+f)/g")); }}Através deste artigo, espero que todos tenham dominado o conhecimento da pilha Java. Obrigado pelo seu apoio a este site!