La pile est une liste qui restreint l'insertion et la suppression à effectuer uniquement dans une seule position. Cette position est la fin de la liste, appelée le haut de la pile. Pour les opérations de base de la pile, il y a Push et Pop. Le premier est l'insertion et le second est supprimé.
La pile est également une table FIFO.
Il existe deux types d'implémentations de piles, l'une consiste à utiliser des tableaux et l'autre est d'utiliser des listes liées.
classe publique 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 publique 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; }} Application de pile
Symbole d'équilibre
Compte tenu d'une chaîne de code, nous vérifions si les supports de ce code sont conformes à la syntaxe.
Par exemple: [{()}] C'est légal, mais [{]} () est illégal.
Ce qui suit est le code de test:
classe publique BalanceSymbol {public boolean isBalance (String String) {MyArrayStack <Comacacre> Stack = new MyArrayStack <> (); char [] array = string.tocharArray (); pour (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 peek, char ch) {if ((peek == '{' && ch == '}') || (peek == '[' && ch == ']') || (peek == '(' && ch == ')')) {return true; } return false; } public static void main (String [] args) {BALANCHOLYMOL SYMBOL = new Balancesymbol (); String String = "public static void main (String [] args) {BALANCEYMBOL SYMBOL = new Balancesymbol ();}"; String String2 = "public static void main (String [] args) {BALANCEYMBOL SYMBOL = new Balancesymbol ([);}]"; System.out.println (symbol.isbalance (string)); System.out.println (symbol.isbalance (String2)); }} Expression de suffixe
Par exemple, une entrée suivante calcule le résultat correspondant,
3 + 2 + 3 * 2 =?
Cela produira des résultats différents dans un ordre de calcul différent. Si le résultat du calcul est de 16 de gauche à droite et si le résultat du calcul est 11 selon la priorité mathématique.
Si l'expression de l'infixe ci-dessus est convertie en une expression de suffixe:
3 2 + 3 2 * +
Il serait très simple de calculer la valeur de cette expression à l'aide d'une expression de suffixe, utilisez simplement une pile.
Chaque fois qu'un nombre est rencontré, mettez le numéro sur la pile.
Chaque fois qu'un opérateur est rencontré, deux éléments apparaissent pour calculer en fonction de l'opérateur, puis les mettre sur la pile.
Le seul élément qui apparaît de la pile est le résultat de calcul.
/ ** * Version simplifiée, chaque opérande n'est qu'un, et en supposant que la chaîne est légale * / classe publique PostFixExpression {public static int calcul (String String) {MyArrayStack <string> Stack = new MyArrayStack <> (); char [] arr = string.tocharArray (); pour (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 (calcul ("32 + 32 * +")); }} Convertir une expression de l'infixe en une expression de suffixe
Supposons que seules les expressions +, -, *, /, () sont exécutées. Et l'expression est légale.
a + b * c - (d * e + f) / g L'expression du suffixe converti est la suivante:
abc * + de * f + g / -
Les étapes pour utiliser Stack Infix pour convertir les suffixes sont les suivantes:
import java.util.hashmap; import java.util.map; public class expressionswitch {private static map <caractère, enter> map = new hashmap <caractère, entier> (); statique {map.put ('+', 0); map.put ('-', 1); map.put ('*', 2); map.put ('/', 3); map.put ('(', 4);} private static char [] [] priority = {// opérateur actuel // + - * / (/ * pile + * / {'>', '>', '<', '<', '<'}, / * top- * / {'>', '>', ',', ',' <'}, / * do * * /'> '>'> ',', ', <'}, / * DO * * '>', '<'}, / * Make / * / {'>', '>', '>', '>', '<'}, / * Caractère (* / {'<', '<', '<', '<', '<'},}; public stating strict1 (String String) {StringBuilder Builder = New StringBuilder (); Char [] Arring = String ();); MyArrayStack <Comacother> Stack = new MyArrayStack <>); == ch) {while (true &&! stack.isempty ()) {char tmp = stack.pop (); Stack (ch)) {Builder.append (Stack. } return builder.toString (); } private static boolean isPriorityHigh (char tmp, char ch) {return priority [map.get (tmp)] [map.get (ch)] == '>'; } public static void main (String [] args) {System.out.println (switch1 ("a + b * c- (d * e + f) / g")); }}Grâce à cet article, j'espère que tout le monde a maîtrisé la connaissance de Java Stack. Merci pour votre soutien pour ce site Web!