Com es construeixen estructures de dades amb classes JavaScript ES6

Com es construeixen estructures de dades amb classes JavaScript ES6

Les estructures de dades són un aspecte fonamental de la informàtica i la programació, independentment del llenguatge que utilitzeu. Tenir-ne un coneixement exhaustiu us pot ajudar a organitzar, gestionar, emmagatzemar i modificar les dades de manera eficient. Identificar l’estructura de dades adequada per al vostre cas d’ús pot millorar el rendiment amb un marge enorme.



Tot i això, JavaScript només inclou estructures de dades primitives com ara matrius i objectes per defecte. Però amb la introducció de les classes ECMAScript 6 (ES6), ara podeu crear estructures de dades personalitzades, com ara piles i cues, amb l’ajut d’estructures de dades primitives.



com transferir d'iPod a iTunes

Estructura de dades de la pila

L’estructura de dades de la pila us permet introduir dades noves sobre les dades existents de manera LIFO (darrera entrada, primera sortida). Aquesta estructura de dades lineal és fàcil de visualitzar mitjançant un exemple senzill. Penseu en una pila de plats guardats sobre una taula. Només podeu afegir o treure una placa de la part superior de la pila.





A continuació s'explica com podeu implementar l'estructura de dades de la pila mitjançant matrius de JavaScript i Classes ES6 :

class Stack {
constructor() {
this.data = [];
this.top = -1;
}
}

Explorem i construïm algunes de les operacions que podeu realitzar en una pila.



Operació Push

L'operació push s'utilitza per inserir dades noves a la pila. Heu de passar les dades com a paràmetre mentre crideu al mètode push. Abans d’inserir les dades, el punter superior de la pila s’incrementa en un i les noves dades s’insereixen a la posició superior.

push(data) {
this.top++;
this.data[this.top] = data;
return this.data;
}

Operació Pop

L'operació pop s'utilitza per eliminar l'element de dades més alt de la pila. En realitzar aquesta operació, el punter superior es redueix en 1.

pop() {
if (this.top <0) return undefined;
const poppedTop = this.data[this.top];
this.top--;
return poppedTop;
}

Operació Peek

L’operació d’observació s’utilitza per retornar el valor present a la part superior de la pila. La complexitat temporal per recuperar aquestes dades és O (1).

Aprèn més: Què és la notació Big-O?

peek() {
return this.top >= 0 ? this.data[this.top] : undefined;
}

Estructura de dades de la llista enllaçada

Una llista enllaçada és una estructura de dades lineal que consisteix en nombrosos nodes connectats entre si amb l'ajut de punteres. Cada node de la llista conté les dades i una variable de punter que apunta al següent node de la llista.

Més informació: Introducció als indicadors per a programadors

A diferència d’una pila, les implementacions de llistes enllaçades a JavaScript requereixen dues classes. La primera classe és la Node per crear un node, i la segona classe és Llista enllaçada classe per realitzar totes les operacions de la llista enllaçada. El punter cap dirigeix ​​el primer node de la llista enllaçada i el punter de cua apunta al darrer node de la llista enllaçada.

class Node {
constructor(data, next = null) {
this.data = data;
this.next = next;
}
}
class LinkedList {
constructor() {
this.head = null;
this.tail = null;
this.size = 0;
}
}

A continuació, es detallen algunes operacions principals que podeu realitzar en una llista enllaçada:

Afegeix l'operació

L'operació d'afegir s'utilitza per afegir un nou node al final de la llista enllaçada. Heu de passar les dades com a paràmetre per inserir un nou node. En primer lloc, creeu un nou objecte de node amb el fitxer nou paraula clau en JavaScript.

Si la llista enllaçada està buida, tant el punter de capçal com el de cua apuntaran al nou node. En cas contrari, només el punter de la cua apuntarà cap al nou node.

append(data) {
const newNode = new Node(data);
if (!this.head) {
this.head = newNode;
this.tail = newNode;
} else {
this.tail.next = newNode;
this.tail = newNode;
}
this.size++;
return this;
}

Operació d'inserció

Per inserir un nou node en un índex concret, podeu fer servir l'operació d'inserció. Aquest mètode té dos paràmetres: les dades a inserir i l'índex on s'ha d'inserir. En el pitjor dels casos, aquest mètode té una complexitat temporal d'O (N), ja que pot haver de recórrer tota la llista.

insert(data, index) {
if (index this.size) return undefined;
if (index === 0) {
this.head = new Node(data, this.head);
!this.tail ? (this.tail = this.head) : null;
this.size++;
return this;
}
if (index === this.size) return this.append(data);
let count = 0;
let beforeNode = this.head;
while (count !== index) {
beforeNode = beforeNode.next;
count++;
}
const newNode = new Node(data);
let afterNode = beforeNode.next;
newNode.next = afterNode;
beforeNode.next = newNode;
this.size++;
return this;
}

Suprimeix l'operació

L'operació de supressió travessa la llista enllaçada per obtenir la referència al node que s'ha de suprimir i elimina l'enllaç del node anterior. De manera similar a l'operació d'inserció, l'operació d'eliminació també té una complexitat temporal d'O (N) en el pitjor dels casos.

deleteNode(index) {
if (index === 0) {
const removedHead = this.head;
this.head = this.head.next;
this.size--;
this.size === 0 ? (this.tail = null) : null;
return removedHead;
}
if (index === this.size - 1) {
if (!this.head) return undefined;
let currentNode = this.head;
let newTail = currentNode;
while (currentNode.next) {
newTail = currentNode;
currentNode = currentNode.next;
}
this.tail = newTail;
this.tail.next = null;
this.size--;
this.size === 0 ? ([this.head, this.tail] = [null, null]) : null;
return currentNode;
}
if (index this.size - 1) return undefined;
let count = 0;
let beforeNode = this.head;
while (count !== index - 1) {
beforeNode = beforeNode.next;
count++;
}
const removedNode = beforeNode.next;
let afterNode = removedNode.next;
beforeNode.next = afterNode;
removedNode.next = null;
this.size--;
return removedNode;
}

Estructura de dades de la cua

L’estructura de dades de la cua és similar a un munt de persones que estan a la cua. La persona que entra a la cua primer se serveix abans que la resta. De la mateixa manera, aquesta estructura de dades lineal segueix l'enfocament FIFO (primer entrada, primer sortida) per inserir i eliminar dades. Aquesta estructura de dades es pot recrear en JavaScript mitjançant una llista enllaçada d'aquesta manera:

class Queue {
constructor() {
this.front = null;
this.rear = null;
this.size = 0;
}
}

A continuació s’explica com podeu inserir i eliminar dades d’una cua a JavaScript:

com comprovar què és la meva placa base

Operació de cola

L'operació de cola insereix noves dades a la cua. Mentre es crida a aquest mètode, si l’estructura de dades de la cua està buida, tant els punteres frontal com el posterior apunten al node acabat d’inserir a la cua. Si la cua no està buida, el nou node s'afegeix al final de la llista i el punter posterior assenyala aquest node.

enqueue(data) {
const newNode = new Node(data);
if (!this.front) {
this.front = newNode;
this.rear = newNode;
} else {
this.rear.next = newNode;
this.rear = newNode;
}
this.size++;
return this;
}

Operació de cola

L'operació dequeue elimina el primer element de la cua. Durant l'operació dequeueue, el punter principal es mou cap al segon node de la llista. Aquest segon node esdevé ara el cap de la cua.

dequeue() {
if (!this.front) return undefined;
if (this.front === this.rear) this.rear = null;
const dequeuedNode = this.front;
this.front = this.front.next;
this.size--;
return dequeuedNode;
}

El següent pas després de les estructures de dades

Les estructures de dades poden ser un concepte complicat d’entendre, sobretot si no coneixeu la programació. Però, com qualsevol altra habilitat, la pràctica us pot ajudar a comprendre i apreciar realment l’eficiència que proporciona per emmagatzemar i gestionar dades a les vostres aplicacions.

Els algoritmes són tan útils com les estructures de dades i poden convertir-se en el següent pas lògic del vostre viatge de programació. Per tant, per què no començar amb un algorisme d’ordenació com ara el tipus de bombolla?

Compartir Compartir Tweet Correu electrònic Una introducció a l'algorisme de classificació de bombolles

L’algorisme Bubble Sort: una excel·lent introducció a l’ordenació de matrius.

Llegiu a continuació
Temes relacionats
  • Programació
  • JavaScript
  • Programació
  • Tutorials de codificació
Sobre l'autor Nitin Ranganath(31 articles publicats)

Nitin és un àvid desenvolupador de programari i estudiant d’enginyeria informàtica que desenvolupa aplicacions web mitjançant tecnologies JavaScript. Treballa com a desenvolupador web independent i li agrada escriure per a Linux i Programació en el seu temps lliure.

Més de Nitin Ranganath

Subscriu-te al nostre butlletí

Uniu-vos al nostre butlletí per obtenir consells tècnics, ressenyes, llibres electrònics gratuïts i ofertes exclusives.

Feu clic aquí per subscriure-us