stack data structure c with illustration
wenn Regressionstests durchgeführt werden sollten
Alles, was Sie über Stack in C ++ wissen müssen.
Der Stapel ist eine grundlegende Datenstruktur, mit der Elemente linear gespeichert werden.
Stapel folgt LIFO (zuletzt rein, zuerst raus) Reihenfolge oder Ansatz, in dem die Operationen ausgeführt werden. Dies bedeutet, dass das Element, das zuletzt zum Stapel hinzugefügt wurde, das erste Element ist, das vom Stapel entfernt wird.
=> Besuchen Sie hier, um die gesamte C ++ - Schulungsserie für alle zu sehen.
Was du lernen wirst:
In C ++ stapeln
Ein Stapel ähnelt einem realen Stapel oder einem Stapel von Dingen, die wir übereinander stapeln.
Unten ist eine bildliche Darstellung von Stack angegeben.
Wie oben gezeigt, ist ein Stapel Platten übereinander gestapelt. Wenn wir ein weiteres Element hinzufügen möchten, fügen wir es oben im Stapel hinzu, wie in der obigen Abbildung (linke Seite) gezeigt. Diese Operation zum Hinzufügen eines Elements zum Stapel wird als „ drücken ”.
Auf der rechten Seite haben wir eine entgegengesetzte Operation gezeigt, d. H. Wir entfernen einen Gegenstand vom Stapel. Dies erfolgt ebenfalls vom selben Ende, d. H. Von der Oberseite des Stapels. Diese Operation heißt „ Pop ”.
Wie in der obigen Abbildung gezeigt, werden Push und Pop vom selben Ende aus ausgeführt. Dadurch folgt der Stapel der LIFO-Reihenfolge. Die Position oder das Ende, von der aus die Gegenstände in den Stapel hineingeschoben oder aus ihm herausgeschoben werden, wird als „ Oberseite des Stapels ”.
Wenn sich keine Elemente im Stapel befinden, wird der obere Rand des Stapels zunächst auf -1 gesetzt. Wenn wir dem Stapel ein Element hinzufügen, wird die Oberseite des Stapels um 1 erhöht, was anzeigt, dass das Element hinzugefügt wurde. Im Gegensatz dazu wird die Oberseite des Stapels um 1 dekrementiert, wenn ein Gegenstand aus dem Stapel herausspringt.
Als nächstes sehen wir einige der grundlegenden Operationen der Stapeldatenstruktur, die wir bei der Implementierung des Stapels benötigen.
Grundoperationen
Im Folgenden sind die grundlegenden Vorgänge aufgeführt, die vom Stapel unterstützt werden.
- drücken - Fügt ein Element hinzu oder schiebt es in den Stapel.
- Pop - Entfernt ein Element oder entfernt es aus dem Stapel.
- Peek - Ruft das oberste Element des Stapels ab, entfernt es jedoch nicht.
- ist voll - Testet, ob der Stapel voll ist.
- ist leer - Testet, ob der Stapel leer ist.
Illustration
Die obige Abbildung zeigt die Abfolge der Operationen, die am Stapel ausgeführt werden. Anfangs ist der Stapel leer. Bei einem leeren Stapel wird der obere Rand des Stapels auf -1 gesetzt.
Als nächstes schieben wir das Element 10 in den Stapel. Wir sehen, dass die Oberseite des Stapels jetzt auf Element 10 zeigt.
Als nächstes führen wir eine weitere Push-Operation mit Element 20 durch, wodurch die Oberseite des Stapels jetzt auf 20 zeigt. Dieser Zustand ist die dritte Zahl.
In der letzten Abbildung führen wir nun eine pop () - Operation aus. Infolge der Pop-Operation wird das Element, das oben auf den Stapel zeigt, aus dem Stapel entfernt. Daher sehen wir in der Figur, dass das Element 20 vom Stapel entfernt wird. Somit zeigt die Oberseite des Stapels jetzt auf 10.
Auf diese Weise können wir den vom Stapel verwendeten LIFO-Ansatz leicht erkennen.
Implementierung
# 1) Verwenden von Arrays
Es folgt die C ++ - Implementierung des Stapels mithilfe von Arrays:
#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< Ausgabe:
Der Stack Push
zwei
4
6
Der Stack Pop:
6
4
zwei
In der Ausgabe können wir sehen, dass die Elemente in einer Reihenfolge in den Stapel geschoben und in umgekehrter Reihenfolge aus dem Stapel herausgeschleudert werden. Dies zeigt den LIFO-Ansatz (Last in, First out) für den Stapel.
Für die obige Array-Implementierung des Stacks können wir schließen, dass dies sehr einfach zu implementieren ist, da keine Zeiger beteiligt sind. Gleichzeitig ist die Größe des Stapels statisch und der Stapel kann nicht dynamisch wachsen oder schrumpfen.
Als nächstes implementieren wir den Stack mithilfe von Arrays in der Programmiersprache 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()); } } } Ausgabe:
Stack Push:
1
3
5
Stack Pop:
5
3
1
Die Implementierungslogik ist dieselbe wie bei der C ++ - Implementierung. Die Ausgabe zeigt die LIFO-Technik zum Ein- und Herausschieben der Elemente zum / vom Stapel.
Wie bereits erwähnt, ist die Stapelimplementierung mit Arrays die einfachste Implementierung, jedoch statischer Natur, da wir den Stapel nicht dynamisch vergrößern oder verkleinern können.
# 2) Verwenden einer verknüpften Liste
Als Nächstes implementieren wir Stapeloperationen mithilfe einer verknüpften Liste in C ++ und Java. Zunächst werden wir die C ++ - Implementierung demonstrieren.
#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:'< Ausgabe:
Stack Push:
100
200
300
Oberes Element ist 300
Stack Pop:
300
200
100
Das oberste Element ist -1
kostenloses Bereinigungstool für Windows 10
Als nächstes präsentieren wir die Java-Implementierung des Stacks anhand einer verknüpften Liste.
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()); } } Ausgabe:
Stack Push:
100
200
300
Oberes Element ist 300
Stack Pop:
300
200
100
Der Stapel ist leer
Das oberste Element ist -2147483648
Wir haben gerade C ++ - und Java-Implementierungen für einen Stapel mit verknüpften Listen gesehen. Wir repräsentieren jeden Stapeleintrag als Knoten der verknüpften Liste. Der wichtigste Vorteil dieser Implementierung ist, dass sie dynamisch ist. Dies bedeutet, dass wir die Stapelgröße gemäß unseren Anforderungen vergrößern oder verkleinern können.
Dies ist anders als bei der Stapelimplementierung mit Arrays, bei denen wir die Größe vorher deklarieren müssen und sie nicht dynamisch ändern können.
Der Nachteil dieser Implementierung ist, dass sie, da wir überall Zeiger verwenden, im Vergleich zur Array-Implementierung etwas zu viel Platz beansprucht.
Anwendungen von Stack
Lassen Sie uns einige der Anwendungen der Stack-Datenstruktur diskutieren. Die Stack-Datenstruktur wird in einer Reihe von Anwendungen in der Softwareprogrammierung hauptsächlich aufgrund ihrer Einfachheit und einfachen Implementierung verwendet.
Im Folgenden werden einige Anwendungen des Stacks kurz beschrieben:
# 1) Infix zu Postfix-Ausdrücken
Jeder allgemeine arithmetische Ausdruck hat die Form operand1 OP-Operand 2 .
Basierend auf der Position des Operators OP haben wir die folgenden Arten von Ausdrücken:
- Infix - Die allgemeine Form des Infix-Ausdrucks lautet „ operand1 OP-Operand 2 ”. Dies ist die Grundform des Ausdrucks, die wir in der Mathematik ständig verwenden.
- Präfix - Wenn ein Operator vor den Operanden steht, handelt es sich um einen Präfixausdruck. Die allgemeine Form des Infix-Ausdrucks lautet „ OP-Operand1 Operand2 ”.
- Postfix - In Postfix-Ausdrücken werden zuerst Operanden geschrieben, gefolgt vom Operator. Es hat die Form 'operand1 operand2 OP'.
Betrachten Sie den Ausdruck „a + b * c '' . Der Compiler scannt den Ausdruck entweder von links nach rechts oder von rechts nach links. Unter Berücksichtigung der Priorität und Assoziativität des Operators wird zuerst der Ausdruck gescannt, um den Ausdruck b * c zu bewerten. Als nächstes muss der Ausdruck erneut gescannt werden, um das Ergebnis von b * c zu a hinzuzufügen.
Wenn die Ausdrücke immer komplexer werden, wird diese Art des immer wieder abtastenden Scannens des Ausdrucks ineffizient.
Um diese Ineffizienz zu überwinden, konvertieren wir den Ausdruck in Postfix oder Präfix, sodass sie mithilfe einer Stapeldatenstruktur leicht ausgewertet werden können.
# 2) Ausdrucksanalyse / Auswertung
Mit Stack können wir auch eine tatsächliche Ausdrucksbewertung durchführen. Dabei wird der Ausdruck von links nach rechts gescannt und Operanden werden auf den Stapel verschoben.
Immer wenn ein Operator angetroffen wird, werden Operanden herausgesprungen und die Operation ausgeführt. Das Ergebnis der Operation wird erneut in den Stapel geschoben. Auf diese Weise wird der Ausdruck mithilfe des Stapels ausgewertet, und das Endergebnis des Ausdrucks ist normalerweise die aktuelle Oberseite des Stapels.
# 3) Baumdurchquerungen
Die Baumdatenstruktur kann durchlaufen werden, um jeden Knoten auf viele Arten und abhängig davon zu besuchen, wann der Stammknoten, den wir haben, besucht wird.
- inOrder Traversal
- Traversal vorbestellen
- Nachbestellung
Um den Baum effizient zu durchlaufen, verwenden wir die Stapeldatenstruktur, um Zwischenknoten auf dem Stapel zu verschieben, sodass wir die Reihenfolge des Durchlaufs beibehalten.
# 4) Sortieralgorithmen
Sortieralgorithmen wie Quicksort können mithilfe der Stapeldatenstrukturen effizienter gestaltet werden.
# 5) Türme von Hanoi
Dies ist ein klassisches Problem mit n Scheiben und drei Türmen, und das Problem besteht darin, die Scheiben von einem Turm zum anderen zu bewegen, wobei der dritte Turm als Zwischenstufe verwendet wird.
Dieses Problem kann mithilfe des Stapels effizient gelöst werden, wenn die zu verschiebenden Discs auf den Stapel geschoben werden, da der Stack im Grunde genommen als Turm fungiert, der zum Bewegen der Discs verwendet wird.
Fazit
Der Stack ist die einfachste Datenstruktur und einfacher als Programm zu implementieren. Es wurde der LIFO-Ansatz (last in, first out) verwendet, dh das zuletzt eingegebene Element wird zuerst entfernt. Dies liegt daran, dass der Stapel nur ein Ende zum Hinzufügen (Drücken) und Entfernen (Pop) von Elementen verwendet.
Die Stapeldatenstruktur hat viele Verwendungszwecke in der Softwareprogrammierung. Das prominenteste unter ihnen sind Ausdrucksbewertungen. Die Auswertung von Ausdrücken umfasst auch das Konvertieren des Ausdrucks von Infix in Postfix oder Präfix. Dazu gehört auch die Auswertung des Ausdrucks, um das Endergebnis zu erhalten.
In diesem Tutorial haben wir die Illustration und Implementierung des Stacks sowie seine verschiedenen Operationen gesehen.
In unserem nächsten Tutorial erfahren Sie mehr über die Struktur der Warteschlangendaten.
=> Besuchen Sie hier für den vollständigen C ++ - Kurs von Experten.
Literatur-Empfehlungen
- Warteschlangendatenstruktur in C ++ mit Illustration
- Datenstruktur für zirkuläre verknüpfte Listen in C ++ mit Abbildung
- Datenstruktur der verknüpften Liste in C ++ mit Abbildung
- Datenstruktur der Prioritätswarteschlange in C ++ mit Abbildung
- Doppelt verknüpfte Listendatenstruktur in C ++ mit Abbildung
- Einführung in Datenstrukturen in C ++
- JMeter-Datenparametrierung mit benutzerdefinierten Variablen
- 10+ beste Datenerfassungstools mit Datenerfassungsstrategien