Eine Datenstruktur oder abstrakte Datentyp (ADT) ist ein Modell, das durch eine Sammlung von Operationen definiert wird, die an sich selbst durchgeführt werden k?nnen und durch die Einschr?nkungen auf die Auswirkungen dieser Operationen begrenzt werden. Es schafft eine Wand zwischen dem, was den zugrunde liegenden Daten angetan werden kann und wie sie getan werden soll. Die meisten von uns sind mit Stapeln und Warteschlangen im normalen Alltag vertraut, aber was haben Supermarktwarteschlangen und Verkaufsautomaten mit Datenstrukturen zu tun? Lassen Sie uns herausfinden. In diesem Artikel stelle ich Ihnen zwei grundlegende abstrakte Datentypen vor - Stack und Warteschlange -, die ihren Ursprung in der t?glichen Verwendung haben.

Key Takeaways

• abstrakte Datentypen (ADTs) sind Modelle, die durch eine Reihe von Operationen definiert werden, die darauf ausgeführt werden k?nnen. Stapel und Warteschlangen sind grundlegende ADTs mit Ursprung im t?glichen Gebrauch. In der Informatik ist ein Stapel eine sequentielle Sammlung, in der das letzte platzierte Objekt das erste entfernt ist (LIFO), w?hrend eine Warteschlange mit First-in-Basis (FIFO) arbeitet.
• Ein Stapel kann mit Arrays implementiert werden, da er bereits Push- und Popoperationen bietet. Die grundlegenden Operationen, die einen Stapel definieren, umfassen Init (erstellen Sie den Stapel), drücken (ein Element nach oben), Pop (das zuletzt hinzugefügte Element entfernen), oben (schauen Sie sich den Element oben, ohne ihn zu entfernen) und isEmpty (Rückgabe ob der Stapel keine Elemente mehr enth?lt.
• Die SPL -Erweiterung in PHP liefert einen Satz von Standarddatenstrukturen, einschlie?lich der Splstack -Klasse. Die als doppelt verknüpfte Liste implementierte Splstack-Klasse bietet die F?higkeit, einen durchlaufbaren Stack zu implementieren. Die als Splstack implementierte Leseliste kann den Stapel nach vorne (oben nach unten) und rückw?rts (Bottom-up) durchqueren.
• Eine Warteschlange, ein weiterer abstrakter Datentyp, arbeitet als erstes, erstes Out-Basis (FIFO). Die grundlegenden Operationen, die eine Warteschlange definieren, umfassen Init (erstellen Sie die Warteschlange), Enqueue (ein Element zum Ende hinzufügen), dequeue (entfernen Sie ein Element von vorne) und Isempty (zurück, ob die Warteschlange mehr mehr Elemente enth?lt). Die Splqueue-Klasse in PHP, die auch mit einer doppelt verknüpften Liste implementiert ist, erm?glicht die Implementierung einer Warteschlange.

stapelt

Im allgemeinen Gebrauch ist ein Stapel ein Haufen Objekte, die normalerweise in Schichten angeordnet sind - zum Beispiel ein Stapel Bücher auf Ihrem Schreibtisch oder ein Stapel Tabletts in der Schulcafeteria. In Informatik -Sprachh?usern ist ein Stapel eine sequentielle Sammlung mit einer bestimmten Eigenschaft, in der das letzte Objekt, das auf dem Stapel platziert ist, das erste Objekt entfernt ist. Diese Eigenschaft wird allgemein als als zuerst in der ersten oder lifeo bezeichnet. Sü?igkeiten-, Chip- und Zigarettenautomaten arbeiten nach demselben Prinzip; Der letzte im Rack geladene Artikel wird zuerst abgegeben. In abstrakter Begriffen ist ein Stapel eine lineare Liste von Elementen, bei denen alle Erg?nzungen zu (ein ?Push“) und L?schungen von (einem ?Pop“) die Liste auf ein Ende beschr?nkt sind - definiert als ?Top“ (des Stapel ). Die grundlegenden Operationen, die einen Stapel definieren, sind:

• init - Erstellen Sie den Stapel.
• drücken - fügen Sie einen Gegenstand an die Oberseite des Stapels hinzu.
• pop - Entfernen Sie das letzte Element, das oben am Stapel hinzugefügt wurde.
• oben - Sehen Sie sich den Artikel oben im Stapel an, ohne ihn zu entfernen.
• isempty - Rückgabe, ob der Stapel keine weiteren Elemente enth?lt.

Ein Stapel kann auch implementiert werden, um eine maximale Kapazit?t zu haben. Wenn der Stapel voll ist und nicht genügend Slots enth?lt, um neue Einheiten zu akzeptieren, wird es als überlauf - daher der Ausdruck ?Stapelüberlauf“ bezeichnet. Ebenso tritt ein Pop -Operation auf einen leeren Stapel ein, dann tritt ein ?Stapelunterlauf“ auf. Da wir wissen, dass unser Stapel durch die LIFO -Eigenschaft und eine Reihe von Grundvorg?ngen definiert wird, insbesondere Push and Pop, k?nnen wir einen Stapel mit Arrays problemlos implementieren, da Arrays bereits Push- und Pop -Operationen bereitstellen. So sieht unser einfacher Stack aus:

<span><span><?php
</span></span><span><span>class ReadingList
</span></span><span><span>{
</span></span><span>    <span>protected $stack;
</span></span><span>    <span>protected $limit;
</span></span><span>    
</span><span>    <span>public function __construct($limit = 10) {
</span></span><span>        <span>// initialize the stack
</span></span><span>        <span>$this->stack = array();
</span></span><span>        <span>// stack can only contain this many items
</span></span><span>        <span>$this->limit = $limit;
</span></span><span>    <span>}
</span></span><span>
</span><span>    <span>public function push($item) {
</span></span><span>        <span>// trap for stack overflow
</span></span><span>        <span>if (count($this->stack) < $this->limit) {
</span></span><span>            <span>// prepend item to the start of the array
</span></span><span>            <span>array_unshift($this->stack, $item);
</span></span><span>        <span>} else {
</span></span><span>            <span>throw new RunTimeException('Stack is full!'); 
</span></span><span>        <span>}
</span></span><span>    <span>}
</span></span><span>
</span><span>    <span>public function pop() {
</span></span><span>        <span>if ($this->isEmpty()) {
</span></span><span>            <span>// trap for stack underflow
</span></span><span>	      <span>throw new RunTimeException('Stack is empty!');
</span></span><span>	  <span>} else {
</span></span><span>            <span>// pop item from the start of the array
</span></span><span>            <span>return array_shift($this->stack);
</span></span><span>        <span>}
</span></span><span>    <span>}
</span></span><span>
</span><span>    <span>public function top() {
</span></span><span>        <span>return current($this->stack);
</span></span><span>    <span>}
</span></span><span>
</span><span>    <span>public function isEmpty() {
</span></span><span>        <span>return empty($this->stack);
</span></span><span>    <span>}
</span></span><span><span>}</span></span>

In diesem Beispiel habe ich Array_unshift () und Array_Shift () anstelle von array_push () und array_pop () verwendet, damit das erste Element des Stapels immer das obere ist. Sie k?nnen Array_push () und array_pop () verwenden, um die semantische Konsistenz aufrechtzuerhalten. In diesem Fall wird das nte Element des Stapels zum Oberteil. Es macht keinen Unterschied, da der gesamte Zweck eines abstrakten Datentyps darin besteht, die Manipulation der Daten aus seiner tats?chlichen Implementierung abstrahieren. Fügen wir dem Stapel einige Artikel hinzu:

<span><span><?php
</span></span><span><span>$myBooks = new ReadingList();
</span></span><span>
</span><span><span>$myBooks->push('A Dream of Spring');
</span></span><span><span>$myBooks->push('The Winds of Winter');
</span></span><span><span>$myBooks->push('A Dance with Dragons');
</span></span><span><span>$myBooks->push('A Feast for Crows');
</span></span><span><span>$myBooks->push('A Storm of Swords'); 
</span></span><span><span>$myBooks->push('A Clash of Kings');
</span></span><span><span>$myBooks->push('A Game of Thrones');</span></span>

Um einige Gegenst?nde aus dem Stapel zu entfernen:

<span><span><?php
</span></span><span><span>echo $myBooks->pop(); // outputs 'A Game of Thrones'
</span></span><span><span>echo $myBooks->pop(); // outputs 'A Clash of Kings'
</span></span><span><span>echo $myBooks->pop(); // outputs 'A Storm of Swords'</span></span>

Mal sehen, was oben auf dem Stapel steht:

<span><span><?php
</span></span><span><span>echo $myBooks->top(); // outputs 'A Feast for Crows'</span></span>

Was ist, wenn wir es entfernen?

<span><span><?php
</span></span><span><span>echo $myBooks->pop(); // outputs 'A Feast for Crows'</span></span>

Und wenn wir einen neuen Artikel hinzufügen?

<span><span><?php
</span></span><span><span>$myBooks->push('The Armageddon Rag');
</span></span><span><span>echo $myBooks->pop(); // outputs 'The Armageddon Rag'</span></span>

Sie k?nnen sehen, dass der Stack in erster Ausgabe funktioniert. Was auch immer zum Stapel zuletzt hinzugefügt wird, ist der erste, der entfernt wird. Wenn Sie weiterhin Pop -Artikel bis zum leeren Stapel popieren, erhalten Sie eine Ausnahme von Stapel -Unterlauflaufzeiten.

PHP Fatal error:  Uncaught exception 'RuntimeException' with message 'Stack is empty!' in /home/ignatius/Data Structures/code/array_stack.php:33
Stack trace:
#0 /home/ignatius/Data Structures/code/example.php(31): ReadingList->pop()
#1 /home/ignatius/Data Structures/code/array_stack.php(54): include('/home/ignatius/...')
#2 {main}
  thrown in /home/ignatius/Data Structures/code/array_stack.php on line 33

Oh, hallo ... PHP hat freundlicherweise eine Stapelverfolgung zur Verfügung gestellt, die den Programmausführungsstapel vor und bis zur Ausnahme zeigt!

Der Splstack

Die SPL -Erweiterung bietet eine Reihe von Standarddatenstrukturen, einschlie?lich der Splstack -Klasse (PHP5> = 5.3.0). Wir k?nnen dasselbe Objekt implementieren, wenn auch viel schlauer, wenn wir einen Splast wie folgt verwenden:

<span><span><?php
</span></span><span><span>class ReadingList extends SplStack
</span></span><span><span>{
</span></span><span><span>}</span></span>

Die Splstack -Klasse implementiert einige weitere Methoden als wir ursprünglich definiert haben. Dies liegt daran, dass Splstack als doppelt verknüpfte Liste implementiert wird, die die F?higkeit zur Implementierung eines durchlaufbaren Stacks bietet. Eine verknüpfte Liste, ein weiterer abstrakter Datentyp selbst, ist eine lineare Sammlung von Objekten (Knoten), die zur Darstellung einer bestimmten Sequenz verwendet wird, wobei jeder Knoten in der Sammlung einen Zeiger auf den n?chsten Knoten in der Sammlung beibeh?lt. In seiner einfachsten Form sieht eine verknüpfte Liste ?hnlich aus:

In einer doppelt verknüpften Liste hat jeder Knoten zwei Zeiger, die jeweils auf die n?chsten und vorherigen Knoten in der Sammlung hinweisen. Diese Art von Datenstruktur erm?glicht das Durchlaufen in beide Richtungen.

Mit einem Kreuz (x) gekennzeichnete Knoten bezeichnen einen Null- oder Sentinel -Knoten - das das Ende des Traversalweges (d. H. Der Pfadanschluss) bezeichnet. Da die Leseliste als Splstack implementiert ist, k?nnen wir den Stapel nach vorne (Top-Down) und rückw?rts (Bottom-up) durchqueren. Der Standard -Traversal -Modus für Splstack ist LIFO:

<span><span><?php
</span></span><span><span>class ReadingList
</span></span><span><span>{
</span></span><span>    <span>protected $stack;
</span></span><span>    <span>protected $limit;
</span></span><span>    
</span><span>    <span>public function __construct($limit = 10) {
</span></span><span>        <span>// initialize the stack
</span></span><span>        <span>$this->stack = array();
</span></span><span>        <span>// stack can only contain this many items
</span></span><span>        <span>$this->limit = $limit;
</span></span><span>    <span>}
</span></span><span>
</span><span>    <span>public function push($item) {
</span></span><span>        <span>// trap for stack overflow
</span></span><span>        <span>if (count($this->stack) < $this->limit) {
</span></span><span>            <span>// prepend item to the start of the array
</span></span><span>            <span>array_unshift($this->stack, $item);
</span></span><span>        <span>} else {
</span></span><span>            <span>throw new RunTimeException('Stack is full!'); 
</span></span><span>        <span>}
</span></span><span>    <span>}
</span></span><span>
</span><span>    <span>public function pop() {
</span></span><span>        <span>if ($this->isEmpty()) {
</span></span><span>            <span>// trap for stack underflow
</span></span><span>	      <span>throw new RunTimeException('Stack is empty!');
</span></span><span>	  <span>} else {
</span></span><span>            <span>// pop item from the start of the array
</span></span><span>            <span>return array_shift($this->stack);
</span></span><span>        <span>}
</span></span><span>    <span>}
</span></span><span>
</span><span>    <span>public function top() {
</span></span><span>        <span>return current($this->stack);
</span></span><span>    <span>}
</span></span><span>
</span><span>    <span>public function isEmpty() {
</span></span><span>        <span>return empty($this->stack);
</span></span><span>    <span>}
</span></span><span><span>}</span></span>

Um den Stapel in umgekehrter Reihenfolge zu durchqueren, setzen wir einfach den Iteratormodus auf FIFO (zuerst in, zuerst heraus):

<span><span><?php
</span></span><span><span>$myBooks = new ReadingList();
</span></span><span>
</span><span><span>$myBooks->push('A Dream of Spring');
</span></span><span><span>$myBooks->push('The Winds of Winter');
</span></span><span><span>$myBooks->push('A Dance with Dragons');
</span></span><span><span>$myBooks->push('A Feast for Crows');
</span></span><span><span>$myBooks->push('A Storm of Swords'); 
</span></span><span><span>$myBooks->push('A Clash of Kings');
</span></span><span><span>$myBooks->push('A Game of Thrones');</span></span>

Warteschlangen

Wenn Sie jemals an der Supermarktkasse in einer Reihe waren, wissen Sie, dass die erste Person in der Schlange zuerst serviert wird. In der Computerterminologie ist eine Warteschlange ein weiterer abstrakter Datentyp, der zuerst in der ersten Ausgabe von oder FIFO arbeitet. Das Bestand wird auch fifo verwaltet, insbesondere wenn solche Gegenst?nde verderblich sind. Die grundlegenden Operationen, die eine Warteschlange definieren, sind:

init - Erstellen Sie die Warteschlange.
Enqueue - Fügen Sie ein Element zum "Ende" (Schwanz) der Warteschlange hinzu.
dequeue - Entfernen Sie ein Element von der ?Vorderseite“ (Kopf) der Warteschlange.
isempty - Rückgabe, ob die Warteschlange keine weiteren Elemente enth?lt.

Da Splqueue auch mit einer doppelt verknüpften Liste implementiert wird, werden in diesem Zusammenhang die semantische Bedeutung von Top und POP umgekehrt. Definieren wir unsere Leselistklasse als Warteschlange neu:

<span><span><?php
</span></span><span><span>class ReadingList
</span></span><span><span>{
</span></span><span>    <span>protected $stack;
</span></span><span>    <span>protected $limit;
</span></span><span>    
</span><span>    <span>public function __construct($limit = 10) {
</span></span><span>        <span>// initialize the stack
</span></span><span>        <span>$this->stack = array();
</span></span><span>        <span>// stack can only contain this many items
</span></span><span>        <span>$this->limit = $limit;
</span></span><span>    <span>}
</span></span><span>
</span><span>    <span>public function push($item) {
</span></span><span>        <span>// trap for stack overflow
</span></span><span>        <span>if (count($this->stack) < $this->limit) {
</span></span><span>            <span>// prepend item to the start of the array
</span></span><span>            <span>array_unshift($this->stack, $item);
</span></span><span>        <span>} else {
</span></span><span>            <span>throw new RunTimeException('Stack is full!'); 
</span></span><span>        <span>}
</span></span><span>    <span>}
</span></span><span>
</span><span>    <span>public function pop() {
</span></span><span>        <span>if ($this->isEmpty()) {
</span></span><span>            <span>// trap for stack underflow
</span></span><span>	      <span>throw new RunTimeException('Stack is empty!');
</span></span><span>	  <span>} else {
</span></span><span>            <span>// pop item from the start of the array
</span></span><span>            <span>return array_shift($this->stack);
</span></span><span>        <span>}
</span></span><span>    <span>}
</span></span><span>
</span><span>    <span>public function top() {
</span></span><span>        <span>return current($this->stack);
</span></span><span>    <span>}
</span></span><span>
</span><span>    <span>public function isEmpty() {
</span></span><span>        <span>return empty($this->stack);
</span></span><span>    <span>}
</span></span><span><span>}</span></span>

SpldoublyLinkedList Implementiert auch die ArrayAccess -Schnittstelle, sodass Sie als Array -Elemente auch Elemente sowohl zu Splqueue als auch zu Splstack hinzufügen k?nnen:

<span><span><?php
</span></span><span><span>$myBooks = new ReadingList();
</span></span><span>
</span><span><span>$myBooks->push('A Dream of Spring');
</span></span><span><span>$myBooks->push('The Winds of Winter');
</span></span><span><span>$myBooks->push('A Dance with Dragons');
</span></span><span><span>$myBooks->push('A Feast for Crows');
</span></span><span><span>$myBooks->push('A Storm of Swords'); 
</span></span><span><span>$myBooks->push('A Clash of Kings');
</span></span><span><span>$myBooks->push('A Game of Thrones');</span></span>

Gegenst?nde von der Vorderseite der Warteschlange zu entfernen:

<span><span><?php
</span></span><span><span>echo $myBooks->pop(); // outputs 'A Game of Thrones'
</span></span><span><span>echo $myBooks->pop(); // outputs 'A Clash of Kings'
</span></span><span><span>echo $myBooks->pop(); // outputs 'A Storm of Swords'</span></span>

enqueue () ist ein Alias ??für Push (), aber beachten Sie, dass dequeue () kein Alias ??für Pop () ist; pop () hat eine andere Bedeutung und Funktion im Kontext einer Warteschlange. Wenn wir hier Pop () verwendet h?tten, würde es das Element am Ende (Schwanz) der Warteschlange entfernen, die gegen die FIFO -Regel verst??t. In ?hnlicher Weise müssen wir BOWS () anstelle von Top () verwenden, um zu sehen, was vorne (Kopf) der Warteschlange steht:

<span><span><?php
</span></span><span><span>echo $myBooks->top(); // outputs 'A Feast for Crows'</span></span>

Zusammenfassung

In diesem Artikel haben Sie gesehen, wie die abstrakten Datentypen von Stack und Warteschlangen bei der Programmierung verwendet werden. Diese Datenstrukturen sind abstrakt, da sie durch die Operationen definiert werden, die an sich selbst durchgeführt werden k?nnen, wodurch eine Wand zwischen der Implementierung und den zugrunde liegenden Daten erstellt wird. Diese Strukturen werden auch durch die Auswirkung solcher Vorg?nge eingeschr?nkt: Sie k?nnen Elemente nur vom oberen Rand des Stapels hinzufügen oder entfernen und nur Elemente von der Vorderseite der Warteschlange entfernen oder Gegenst?nde in die hintere Warteschlange hinzufügen. Bild von Alexandre Dulaunoy über Flickr

h?ufig gestellte Fragen (FAQs) zu PHP -Datenstrukturen

Was sind die verschiedenen Arten von Datenstrukturen in PHP?

PHP unterstützt verschiedene Arten von Datenstrukturen, einschlie?lich Arrays, Objekten und Ressourcen. Arrays sind die h?ufigsten und vielseitigsten Datenstrukturen in PHP. Sie k?nnen alle Arten von Daten enthalten, einschlie?lich anderer Arrays, und k?nnen indiziert oder assoziativ werden. Objekte in PHP sind Instanzen von Klassen, die Eigenschaften und Methoden haben k?nnen. Ressourcen sind spezielle Variablen, die Verweise auf externe Ressourcen enthalten, z. B. Datenbankverbindungen.

Wie kann ich einen Stapel in PHP implementieren? Zuletzt, zum ersten Mal) Prinzip. In PHP k?nnen Sie die Splstack -Klasse verwenden, um einen Stapel zu implementieren. Sie k?nnen Elemente mit der PUSP () -Methode auf den Stapel schieben und mit der POP () -Methode Pop -Elemente vom Stapel aus dem Stapel. Arrays und Objekte in PHP sind beide Arten von Datenstrukturen, haben jedoch einige wichtige Unterschiede. Arrays sind einfache Wertelisten, w?hrend Objekte Instanzen von Klassen sind und Eigenschaften und Methoden haben k?nnen. Arrays k?nnen indiziert oder assoziativ werden, w?hrend Objekte immer String -Tasten verwenden. Arrays sind vielseitiger und einfacher zu bedienen, w?hrend Objekte mehr Struktur und Kapselung liefern.

Wie kann ich Datenstrukturen verwenden, um die Leistung meines PHP -Code zu verbessern? Wenn Sie beispielsweise eine gro?e Anzahl von Elementen speichern und h?ufig nach bestimmten Elementen suchen müssen, kann die Verwendung einer Hash -Tabelle oder eines Satzes viel schneller sein als die Verwendung eines Arrays. Wenn Sie an beiden Enden h?ufig Elemente hinzufügen und entfernen müssen, kann die Verwendung eines Deque effizienter sein als die Verwendung eines Arrays. In PHP ist eine Datenstruktur, die eine doppelt verknüpfte Liste implementiert. Sie k?nnen in konstanter Zeit an beiden Enden der Liste auf Elemente an beiden Enden der Liste hinzufügen, entfernen und zugreifen. Es bietet auch Methoden zum Iterieren der Elemente in der Liste und zum Sortieren der Elemente.

Wie kann ich eine Warteschlange in PHP implementieren. Das FIFO -Prinzip (zuerst in, zuerst). In PHP k?nnen Sie die Splqueue -Klasse verwenden, um eine Warteschlange zu implementieren. Sie k?nnen Elemente mit der Enqueue () -Methode auf die Warteschlange und Dequeue -Elemente aus der Warteschlange mit der Methode dequeue (). ??> Ein Stapel und eine Warteschlange sind beide Arten von Datenstrukturen, haben jedoch einen wesentlichen Unterschied in der Hinzufügung und Entfernung von Elementen. Ein Stapel folgt dem LIFO -Prinzip (zuletzt, zuerst), was bedeutet, dass das letzte hinzugefügte Element das erste ist, das entfernt wird. Andererseits folgt eine Warteschlange dem FIFO -Prinzip (zuerst in, zuerst), was bedeutet, dass das erste hinzugefügte Element das erste ist, das entfernt wird.

Die Splheap -Klasse in PHP ist eine Datenstruktur, die einen Haufen implementiert. Ein Haufen ist eine Art bin?rer Baum, bei dem jeder übergeordnete Knoten weniger oder gleich seinen untergeordneten Knoten ist. Sie k?nnen mit der Klassenklasse einen Minimer oder einen Max-heap erstellen und Elemente im Haufen hinzufügen, entfernen und zugreifen. >

Die Verwendung von Datenstrukturen in PHP kann mehrere Vorteile bieten. Sie k?nnen Ihnen helfen, Ihre Daten effizienter und logischer zu organisieren, wodurch Ihr Code das Verst?ndnis und die Wartung erleichtert wird. Sie k?nnen auch die Leistung Ihres Codes verbessern, insbesondere im Umgang mit gro?en Datenmengen oder komplexen Vorg?ngen. der Datenstruktur, bei der jeder Knoten zu den beiden zwei Kindern verfügt, die als linkes Kind und das rechte Kind bezeichnet werden. In PHP k?nnen Sie einen bin?ren Baum mit einer Klasse mit Eigenschaften für den Wert des Knotens und der linken und rechten Kinder implementieren. Sie k?nnen dann Methoden verwenden, um Knoten im Baum hinzuzufügen, zu entfernen und zu suchen.

Das obige ist der detaillierte Inhalt vonPHP Master | Datenstrukturen für PHP -Entwickler: Stapel und Warteschlangen. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!