Explicación detallada de la pila de implementación de Java y el código de ejemplo

La pila es una lista que restringe la inserción y la eliminación para realizar solo en una posición. Esta posición es el final de la lista, llamada la parte superior de la pila. Para las operaciones básicas de la pila, hay push y pop. El primero es inserción y el segundo es eliminado.

La pila también es una mesa FIFO.

Hay dos tipos de implementaciones de pilas, una es usar matrices y el otro es usar listas vinculadas.

 clase 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 isEtimty () {return list.size () == 0; }} clase 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 isEtimty () {return list.size () == 0; }}

Aplicación de pila

Símbolo de equilibrio

Dada una cadena de código, verificamos si los soportes en este código cumplen con la sintaxis.

Por ejemplo: [{()}] Esto es legal, pero [{]} () es ilegal.

El siguiente es el código de prueba:

 Public Class Balancesymbol {Public Boolean Isbalance (String String) {myArRayStack <Artacter> stack = new MyArrayStack <> (); char [] array = string.toCarArray (); for (char ch: array) {if ("{[(" .indexof (ch)> = 0) {stack.push (ch);} else if ("}])". indexOf (ch)> = 0) {if (isMatching (stack.peek (), ch)) {stack.pop (); }}} return stack.isEmpty (); } private boolean ismatching (char leek, char ch) {if ((peek == '{' && ch == '}') || (peek == '[' && ch == ']') || (peek == '(' && ch == ')') {return true; } return false; } public static void main (string [] args) {BalanceSymbol Symbol = New BalanceSymbol (); String String = "public static void main (string [] args) {BalanceSymbol Symbol = New BalanceSymbol ();}"; String String2 = "public static void main (string [] args) {BalanceSymbol Symbol = New BalanceSymbol ([);}]"; System.out.println (Symbol.Sbalance (String)); System.out.println (Symbol.Sbalance (String2)); }}

Expresión de sufijo

Por ejemplo, una siguiente entrada calcula el resultado correspondiente,

3 + 2 + 3 * 2 =?

Esto producirá diferentes resultados en diferentes orden de cálculo. Si el resultado del cálculo es 16 de izquierda a derecha, y si el resultado del cálculo es 11 de acuerdo con la prioridad matemática.

Si la expresión infijo anterior se convierte en una expresión de sufijo:

3 2 + 3 2 * +

Sería muy simple calcular el valor de esta expresión usando una expresión de sufijo, solo use una pila.

Siempre que se encuentre un número, coloque el número en la pila.

Cada vez que se encuentra un operador, aparecen dos elementos para calcular según el operador y luego los colocan en la pila.

El único elemento que aparece en la pila es el resultado del cálculo.

 /*** Versión simplificada, cada operando es solo uno, y suponiendo que la cadena es legal*/public class PostfixExpression {public static int calculate (cadena de cadena) {myArRayStack <String> stack = new MyArRayStack <> (); char [] arr = string.toCarArray (); for (char ch: arr) {if ("0123456789" .indexof (ch)> = 0) {stack.push (ch + ""); } else if ("+-*/". indexOf (ch)> = 0) {int a = integer.parseInt (stack.pop ()); 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) + ""); }} return integer.parseInt (stack.peek ()); } public static void main (string [] args) {system.out.println (calculación ("32+32*+")); }}

Convertir una expresión infijo a una expresión sufijo

Supongamos que solo se ejecutan las expresiones +, -, *, /, (). Y la expresión es legal.

a + b * c - (d * e + f) / g La expresión de sufijo convertida es la siguiente:

ABC * + DE * F + G / -

Los pasos para usar Stack Infix para convertir los sufijos son los siguientes:

1. Al leer el operando, lo genera inmediatamente
2. Si se encuentra el operador y se coloca en la pila, si se encuentra el soporte izquierdo, también se colocará en la pila.
3. Si encuentra un soporte cercano, el elemento de pila comenzará a aparecer hasta que se encuentre el soporte izquierdo correspondiente. El soporte izquierdo solo aparecerá y no saldrá.
4. Si se encuentran otros símbolos, entonces establezca el elemento de la pila desde la pila hasta que sepa encontrar el elemento de menor prioridad.

 import java.util.hashmap; import java.util.map; public class expresionswitch {private static map <caracteres, integer> map = new Hashmap <caracteres, integer> (); static {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/ */{'>', '>', '>', '>', '<'},/ * caracteres ( */{'<', '<', '<', '<', '<'},}; String statats stats stats string (string String (String) {StringBuilder = new StringBuilder (); MyArrayStack <CaptAd> stack = new MyArrayStack <> (); == ch) {while (true &&! stack.isempty ()) {char tmp = stack.pop (); stack.peek (); } return builder.ToString (); } private static boolean ispriorityhigh (char tmp, char ch) {prioridad de retorno [map.get (tmp)] [map.get (ch)] == '>'; } public static void main (string [] args) {system.out.println (switch1 ("a+b*c- (d*e+f)/g")); }}

A través de este artículo, espero que todos hayan dominado el conocimiento de Java Stack. ¡Gracias por su apoyo para este sitio web!