Lesen des Quellcodes: Yocto-Warteschlange
Lesen des Quellcodes: Yocto-Warteschlange
Einführung
Eine Warteschlange ist eine geordnete Liste von Elementen, wobei Elemente am Ende der Warteschlange eingefügt und am Anfang der Warteschlange entfernt werden. Die Warteschlange funktioniert nach dem First-In-First-Out-Prinzip.
Wenn Sie viele Array#push()- und Array#shift()-Operationen für große Arrays ausführen, sollten Sie dieses Paket anstelle von Arrays verwenden, da Array#shift() eine lineare Zeitkomplexität von O(n) hat, während Queue # dequeue() wird basierend auf einer verknüpften Liste implementiert und hat eine konstante Zeitkomplexität O(1). Bei großen Warteschlangen macht das einen großen Unterschied.
Interpretation des Quellcodes
Dieser Code definiert eine Warteschlangendatenstruktur, die eine Knotenklasse Nodeund eine Warteschlangenklasse enthält Queue.
class Node {
value;
next;
constructor(value) {
this.value = value;
}
}
NodeDie Klasse stellt den Knoten in der Warteschlange dar. Sie verfügt über zwei Eigenschaften, die valueden Wert des Knotens und nextden Zeiger auf den nächsten Knoten darstellen. Der Konstruktor constructorwird verwendet, um den Wert des Knotens zu initialisieren.
export default class Queue {
#head;
#tail;
#size;
constructor() {
this.clear();
}
// ...
}
QueueKlasse ist eine standardmäßig exportierte Klasse, die die Warteschlangendatenstruktur darstellt. Es verfügt über drei private Attribute #head, #tailund #size, die jeweils den Kopfknoten, den Endknoten und die Warteschlangengröße der Warteschlange darstellen. Der Konstruktor constructorwird verwendet, um die Warteschlange zu initialisieren und clear()die Methode zur Initialisierung aufzurufen.
enqueue(value) {
const node = new Node(value);
if (this.#head) {
this.#tail.next = node;
this.#tail = node;
} else {
this.#head = node;
this.#tail = node;
}
this.#size++;
}
enqueue(value)Die Methode wird verwendet, um neue Elemente zur Warteschlange hinzuzufügen. Es nimmt einen Wert als Argument, erstellt einen neuen Knoten und fügt ihn am Ende der Warteschlange hinzu. Wenn die Warteschlange leer ist, wird der neue Knoten sowohl als Kopf- als auch als Endknoten festgelegt. Wenn die Warteschlange nicht leer ist, verbinden Sie den neuen Knoten mit den Eigenschaften des aktuellen Endknotens nextund legen Sie den neuen Knoten als neuen Endknoten fest. Abschließend wird die Warteschlangengröße um eins erhöht.
dequeue() {
const current = this.#head;
if (!current) {
return;
}
this.#head = this.#head.next;
this.#size--;
return current.value;
}
dequeue()Methode, die verwendet wird, um das Kopfelement aus der Warteschlange zu entfernen und seinen Wert zurückzugeben. Es ruft zunächst den aktuellen Hauptknoten ab und kehrt direkt zurück, wenn die Warteschlange leer ist. Andernfalls verweisen Sie den Kopfknoten auf den nächsten Knoten, verringern Sie die Warteschlangengröße um eins und geben Sie schließlich den Wert des entfernten Knotens zurück.
clear() {
this.#head = undefined;
this.#tail = undefined;
this.#size = 0;
}
clear()Die Methode wird verwendet, um die Warteschlange zu leeren, die Kopf- und Endknoten auf festzulegen undefinedund die Warteschlangengröße auf festzulegen 0.
get size() {
return this.#size;
}
sizeDie Eigenschaft ist eine getter, mit der die Größe der Warteschlange ermittelt wird.
* [Symbol.iterator]() {
let current = this.#head;
while (current) {
yield current.value;
current = current.next;
}
}
[Symbol.iterator]Die Methode ist eine Generatorfunktion, die das Warteschlangenobjekt iterierbar macht. Es gibt ein Iteratorobjekt zurück, indem es die Knoten der Warteschlange durchläuft und der Reihe nach den Wert des Knotens zurückgibt. In jeder Iteration wird der Wert des aktuellen Knotens yieldüber das Schlüsselwort zurückgegeben, und der aktuelle Knoten zeigt auf den nächsten Knoten, bis die gesamte Warteschlange durchlaufen ist.
Diese Warteschlangendatenstruktur bietet allgemeine Warteschlangenoperationen wie das Einreihen in die Warteschlange, das Entfernen aus der Warteschlange, das Löschen der Warteschlange und das Abrufen der Warteschlangengröße. Sie kann auch die Elemente in der Warteschlange über Iteratoren durchlaufen.
Schauen wir uns als Nächstes die Typdeklaration an:
export default class Queue<ValueType> implements Iterable<ValueType> {
/**
The size of the queue.
*/
readonly size: number;
constructor();
[Symbol.iterator](): IterableIterator<ValueType>;
/**
Add a value to the queue.
*/
enqueue(value: ValueType): void;
/**
Remove the next value in the queue.
@returns The removed value or `undefined` if the queue is empty.
*/
dequeue(): ValueType | undefined;
/**
Clear the queue.
*/
clear(): void;
}
Diese Typdeklaration stellt eine generische Warteschlangenklasse dar Queue, die die Schnittstelle implementiert Iterableund iterative Operationen ausführen kann:
export default class Queue<ValueType> implements Iterable<ValueType>: Exportieren Sie eine StandardklasseQueue, bei der es sich um eine generische Klasse handelt, dieValueTypeals generischer Parameter verwendet wird undIterabledie Schnittstelle implementiert, was darauf hinweist, dass iterative Vorgänge ausgeführt werden können.readonly size: number: Ein schreibgeschütztes Attribut, das die Größe der Warteschlange angibt.constructor(): Konstruktor, der zum Erstellen einer leeren Warteschlange verwendet wird.[Symbol.iterator](): IterableIterator<ValueType>: Iterator-Methode, gibt einIterableIteratorObjekt zum Iterieren von Elementen in der Warteschlange zurück.enqueue(value: ValueType): void: Enqueue-Methode, empfängt einenValueTypeWerttyp als Parameter und fügt ihn der Warteschlange hinzu.dequeue(): ValueType | undefined: Dequeue-Methode, entfernt das nächste Element in der Warteschlange und gibt seinen Wert zurück. Gibt zurück, wenn die Warteschlange leer istundefined.clear(): void: Leeren Sie die Warteschlange und entfernen Sie alle Elemente in der Warteschlange.
Diese Typdeklaration definiert eine grundlegende Warteschlangenklasse, einschließlich allgemeiner Vorgänge wie Einreihen in die Warteschlange, Entfernen aus der Warteschlange und Löschen der Warteschlange. Außerdem stellt sie ein schreibgeschütztes Größenattribut und eine Iteratormethode bereit, damit die Warteschlange durchlaufen werden kann.
Der vollständige Quellcode lautet wie folgt:
class Node {
value;
next;
constructor(value) {
this.value = value;
}
}
export default class Queue {
#head;
#tail;
#size;
constructor() {
this.clear();
}
enqueue(value) {
const node = new Node(value);
if (this.#head) {
this.#tail.next = node;
this.#tail = node;
} else {
this.#head = node;
this.#tail = node;
}
this.#size++;
}
dequeue() {
const current = this.#head;
if (!current) {
return;
}
this.#head = this.#head.next;
this.#size--;
return current.value;
}
clear() {
this.#head = undefined;
this.#tail = undefined;
this.#size = 0;
}
get size() {
return this.#size;
}
* [Symbol.iterator]() {
let current = this.#head;
while (current) {
yield current.value;
current = current.next;
}
}
}
Lernen und gewinnen
Aus diesem Code können wir Folgendes lernen:
- So verwenden Sie Klassen und Konstruktoren zum Erstellen einer Warteschlangendatenstruktur.
- So verwenden Sie Klassenmethoden, um grundlegende Vorgänge verknüpfter Listenwarteschlangen zu implementieren, z. B. das Einreihen in die Warteschlange, das Entfernen aus der Warteschlange und das Löschen der Warteschlange.
- So implementieren Sie Generatorfunktionen und Iteratoren, um die Iterabilität einer Warteschlange zu implementieren, sodass sie das
for...ofDurchlaufen mithilfe einer Schleife unterstützt.
Durch das Studium dieses Codes können wir die Grundprinzipien und die Verwendung von Warteschlangendatenstrukturen verstehen und üben und erfahren, wie Klassen zum Implementieren einer verknüpften Listenwarteschlange verwendet werden. Dies ist sehr hilfreich für das Verständnis und die Anwendung anderer Datenstrukturen und Algorithmen sowie für die Lösung praktischer Probleme.