stack data structure c with illustration
alguns errors de programari apunten a un problema de connectivitat física
Tot el que heu de saber sobre la pila en C ++.
La pila és una estructura de dades fonamental que s’utilitza per emmagatzemar elements de manera lineal.
Segueix la pila LIFO (última entrada, primera sortida) ordre o enfocament en què es realitzen les operacions. Això vol dir que l'element que es va afegir l'últim a la pila serà el primer element que es traurà de la pila.
=> Visiteu aquí per veure tota la sèrie de formació C ++ per a tothom.
Què aprendreu:
Apilar en C ++
Una pila és similar a una pila de la vida real o una pila de coses que apilem una sobre l’altra.
A continuació es mostra una representació pictòrica de Stack.
Com es mostra més amunt, hi ha una pila de plaques apilades unes sobre les altres. Si volem afegir-hi un altre element, l’afegim a la part superior de la pila tal com es mostra a la figura anterior (a l’esquerra). Aquesta operació d'afegir un element a la pila s'anomena ' Premeu '.
A la part dreta, hem mostrat una operació oposada, és a dir, traiem un element de la pila. Això també es fa des del mateix extrem, és a dir, la part superior de la pila. Aquesta operació es diu ' pop '.
Com es mostra a la figura anterior, veiem que el push i el pop es duen a terme des del mateix extrem. Això fa que la pila segueixi l’ordre LIFO. La posició o final des d'on s'introdueixen o surten els elements cap a / des de la pila s'anomena ' Part superior de la pila '.
Inicialment, quan no hi ha elements a la pila, la part superior de la pila s'estableix en -1. Quan afegim un element a la pila, la part superior de la pila s’incrementa 1 indicant que l’element s’ha afegit. A diferència d'això, la part superior de la pila es decrementa en 1 quan un element surt de la pila.
A continuació, veurem algunes de les operacions bàsiques de l'estructura de dades de la pila que necessitarem mentre implementem la pila.
Operacions bàsiques
A continuació es mostren les operacions bàsiques que admet la pila.
- empènyer - Afegeix o empeny un element a la pila.
- pop - Elimina o treu un element de la pila.
- ullada - Obté l’element superior de la pila però no l’elimina.
- està ple - Prova si la pila està plena.
- està buit - Prova si la pila està buida.
Il·lustració
La il·lustració anterior mostra la seqüència d'operacions que es realitzen a la pila. Inicialment, la pila està buida. Per a una pila buida, la part superior de la pila s'estableix en -1.
A continuació, empenyem l'element 10 a la pila. Veiem que la part superior de la pila ara apunta a l’element 10.
A continuació, realitzem una altra operació d'empenta amb l'element 20, com a resultat de la qual la part superior de la pila ara apunta a 20. Aquest estat és la tercera figura.
Ara a la darrera figura, realitzem una operació pop (). Com a resultat de l'operació pop, l'element apuntat a la part superior de la pila s'elimina de la pila. Per tant, a la figura veiem que l'element 20 s'elimina de la pila. Així, la part superior de la pila ara apunta a 10.
D’aquesta manera, podem distingir fàcilment l’enfocament LIFO utilitzat per la pila.
Implementació
# 1) Ús de matrius
A continuació es mostra la implementació de C ++ de la pila mitjançant matrius:
#include using namespace std; #define MAX 1000 //max size for stack class Stack { int top; public: int myStack(MAX); //stack array Stack() { top = -1; } bool push(int x); int pop(); bool isEmpty(); }; //pushes element on to the stack bool Stack::push(int item) { if (top >= (MAX-1)) { cout << 'Stack Overflow!!!'; return false; } else { myStack(++top) = item; cout< Sortida:
L'empenta de la pila
2
4
6
The Stack Pop:
6
4
2
A la sortida, podem veure que els elements s’empenyen a la pila en un ordre i surten de la pila en l’ordre invers. Es mostra l'enfocament LIFO (Last in, First out) per a la pila.
Per a la implementació de la pila de la matriu anterior, podem concloure que és molt fàcil d’implementar ja que no hi ha indicadors implicats. Però, al mateix temps, la mida de la pila és estàtica i la pila no pot créixer ni reduir-se dinàmicament.
A continuació, implementarem la pila mitjançant matrius en llenguatge de programació Java.
class Stack { static final int MAX = 1000; // Maximum Stack size int top; int myStack() = new int(MAX); boolean isEmpty() { return (top = (MAX-1)) { System.out.println('Stack Overflow'); return false; } else { myStack(++top) = item; System.out.println(item); return true; } } int pop() { if (top <0) { System.out.println('Stack Underflow'); return 0; } else { int item = myStack(top--); return item; } } } //Main class code class Main { public static void main(String args()) { Stack stack = new Stack(); System.out.println('Stack Push:'); stack.push(1); stack.push(3); stack.push(5); System.out.println('Stack Pop:'); while(!stack.isEmpty()) { System.out.println(stack.pop()); } } }
Sortida:
Pila empenta:
1
3
5
Stack Pop:
5
3
1
La lògica d’implementació és la mateixa que a la implementació de C ++. La sortida mostra la tècnica LIFO d’empènyer i sortir dels elements cap a / des de la pila.
Com ja s'ha dit, la implementació de pila amb matrius és la implementació més senzilla, però és de naturalesa estàtica, ja que no podem créixer ni reduir la pila dinàmicament.
# 2) Ús d’una llista enllaçada
A continuació, implementem operacions de pila mitjançant una llista enllaçada tant en C ++ com en Java. En primer lloc, demostrarem la implementació de C ++.
#include using namespace std; // class to represent a stack node class StackNode { public: int data; StackNode* next; }; StackNode* newNode(int data) { StackNode* stackNode = new StackNode(); stackNode->data = data; stackNode->next = NULL; return stackNode; } int isEmpty(StackNode *root) { return !root; } void push(StackNode** root, int new_data){ StackNode* stackNode = newNode(new_data); stackNode->next = *root; *root = stackNode; cout<data; free(temp); return popped; } int peek(StackNode* root) { if (isEmpty(root)) return -1; return root->data; } int main() { StackNode* root = NULL; cout<<'Stack Push:'< Sortida:
Pila empenta:
100
200
300
L’element superior és 300
Stack Pop:
300
200
100
L'element superior és -1
A continuació, presentem la implementació Java de la pila mitjançant una llista enllaçada.
class LinkedListStack { StackNode root; static class StackNode { int data; StackNode next; StackNode(int data) { this.data = data; } } public boolean isEmpty() { if (root == null) { return true; } else return false; } public void push(int new_data) { StackNode newNode = new StackNode(new_data); if (root == null) { root = newNode; } else { StackNode temp = root; root = newNode; newNode.next = temp; } System.out.println(new_data); } public int pop() { int popped = Integer.MIN_VALUE; if (root == null) { System.out.println('Stack is Empty'); } else { popped = root.data; root = root.next; } return popped; } public int peek() { if (root == null) { System.out.println('Stack is empty'); return Integer.MIN_VALUE; } else { return root.data; } } } class Main{ public static void main(String() args) { LinkedListStack stack = new LinkedListStack(); System.out.println('Stack Push:'); stack.push(100); stack.push(200); stack.push(300); System.out.println('Top element is ' + stack.peek()); System.out.println('Stack Pop:'); while(!stack.isEmpty()){ System.out.println(stack.pop()); } System.out.println('Top element is ' + stack.peek()); } }
Sortida:
Pila empenta:
100
200
300
L’element superior és 300
Preguntes d'entrevistes de servidor sql per a professionals experimentats
Stack Pop:
300
200
100
La pila està buida
L'element superior és -2147483648
Acabem de veure implementacions C ++ i Java per a una pila mitjançant llistes enllaçades. Representem cada entrada de pila com un node de la llista enllaçada. L’avantatge més important d’aquesta implementació és que és dinàmica. Això significa que podem créixer o reduir la mida de la pila segons el nostre requisit.
Això és diferent al cas de la implementació de pila que utilitza matrius en què hem de declarar la mida prèviament i no podem canviar-la dinàmicament.
El desavantatge d'aquesta implementació és que, com que utilitzem punteres a tot arreu, ocupa una mica massa espai en comparació amb la implementació de matriu.
Aplicacions de Stack
Analitzem algunes de les aplicacions de l'estructura de dades de la pila. L’estructura de dades de la pila s’utilitza en diverses aplicacions de programació de programari, principalment per la seva simplicitat i facilitat d’implementació.
A continuació, descriurem breument algunes de les aplicacions de la pila:
# 1) Infix a Postfix Expressions
Qualsevol expressió aritmètica general és de la forma operand1 OP operand 2 .
En funció de la posició de l’operador OP, tenim els següents tipus d’expressions:
- Infix - La forma general d’expressió d’infixos és “ operand1 OP operand 2 ”. Aquesta és la forma bàsica de l’expressió que sempre fem servir en matemàtiques.
- Prefix - Quan un operador es col·loca abans dels operands, és una expressió de prefix. La forma general d’expressió d’infixos és “ Operand OP operant1 '.
- Postfix - A les expressions postfix, els operands s’escriuen primer seguits de l’operador. Té la forma 'operand1 operand2 OP'.
Penseu en l’expressió “a + b * c ' . El compilador escaneja l'expressió d'esquerra a dreta o de dreta a esquerra. Tenint cura de la precedència i l’associativitat de l’operador, primer explorarà l’expressió per avaluar l’expressió b * c. A continuació, haurà de tornar a escanejar l'expressió per afegir el resultat de b * c a.
A mesura que les expressions es fan cada vegada més complexes, aquest tipus d’enfocament d’escanejar una i altra vegada l’expressió esdevé ineficient.
Per superar aquesta ineficiència, convertim l’expressió en postfix o prefix de manera que es puguin avaluar fàcilment mitjançant una estructura de dades de pila.
# 2) Anàlisi / avaluació d'expressions
Mitjançant la pila, també podem realitzar una avaluació de l’expressió real. En això, l'expressió s'escaneja d'esquerra a dreta i els operands s'enfonsen a la pila.
Sempre que es troba un operador, apareixen operands i es realitza l'operació. El resultat de l'operació es torna a empènyer a la pila. Aquesta forma en què s’avalua l’expressió mitjançant la pila i el resultat final de l’expressió sol ser la part superior actual de la pila.
# 3) Transversals d'arbres
L'estructura de dades de l'arbre es pot recórrer per visitar cada node de moltes maneres i en funció de quan es visiti el node arrel que tenim.
- Recorregut en ordre
- preordenar Traversal
- recorregut postOrdre
Per recórrer eficientment l’arbre, fem ús de l’estructura de dades de la pila per empènyer nodes intermedis a la pila de manera que mantenim l’ordre de recorregut.
# 4) Classificació d'algorismes
L’algoritme d’ordenació com el quicksort es pot fer més eficient mitjançant les estructures de dades de la pila.
# 5) Torres de Hanoi
Aquest és un problema clàssic que implica n nombre de discos i tres torres i el problema consisteix a moure els discos d'una torre a una altra amb la tercera torre utilitzada com a intermedi.
Aquest problema es pot abordar de manera eficient utilitzant la pila mentre empenyem els discs per passar a la pila, ja que la pila actua bàsicament com una torre que s’utilitza per moure els discos.
Conclusió
La pila és l'estructura de dades més senzilla i més fàcil d'implementar com a programa. S'utilitzava l'enfocament LIFO (last in, first out), que significa que l'element introduït últim és el que s'elimina primer. Això es deu al fet que la pila només utilitza un extrem per afegir (push) i eliminar (pop) elements.
L’estructura de dades de la pila té molts usos en la programació de programari. El més destacat són les avaluacions d’expressions. L’avaluació d’expressions també inclou la conversió de l’expressió d’infix a postfix o prefix. També implica avaluar l’expressió per produir el resultat final.
En aquest tutorial, hem vist la il·lustració i implementació de la pila, així com les seves diverses operacions.
Al nostre proper tutorial, coneixerem detalladament l’estructura de dades de la cua.
=> Visiteu aquí el curs complet C ++ d’experts.
Lectura recomanada
- Estructura de dades de la cua en C ++ amb il·lustració
- Estructura de dades de llistes enllaçades circulars en C ++ amb il·lustració
- Estructura de dades de la llista enllaçada en C ++ amb il·lustració
- Estructura de dades de la cua de prioritat en C ++ amb il·lustració
- Estructura de dades de llistes doblement enllaçades en C ++ amb il·lustració
- Introducció a les estructures de dades en C ++
- Parametrizació de dades de JMeter mitjançant variables definides per l'usuari
- 10+ millors eines de recopilació de dades amb estratègies de recopilació de dades