Home-theater-designers
Le strutture dati sono un aspetto fondamentale dell'informatica e della programmazione, indipendentemente dal linguaggio utilizzato. Avere una loro conoscenza approfondita può aiutarti a organizzare, gestire, archiviare e modificare i dati in modo efficiente. Identificare la struttura dati corretta per il tuo caso d'uso può migliorare le prestazioni di un enorme margine.
Tuttavia, JavaScript viene fornito solo con strutture di dati primitive come array e oggetti per impostazione predefinita. Ma con l'introduzione delle classi ECMAScript 6 (ES6), ora puoi creare strutture di dati personalizzate come stack e code con l'aiuto di strutture di dati primitive.
cosa significa il numero dopo ddr4?
Stack struttura dati
La struttura dei dati dello stack consente di inserire nuovi dati sopra i dati esistenti in modo LIFO (last-in, first-out). Questa struttura di dati lineare è facile da visualizzare utilizzando un semplice esempio. Considera una pila di piatti tenuti su un tavolo. Puoi aggiungere o rimuovere un piatto solo dalla parte superiore della pila.
Ecco come è possibile implementare la struttura dei dati dello stack utilizzando array JavaScript e Classi ES6 :
class Stack {
constructor() {
this.data = [];
this.top = -1;
}
}Esploriamo e costruiamo alcune delle operazioni che puoi eseguire su uno stack.
Spingere il funzionamento
L'operazione push viene utilizzata per inserire nuovi dati nello stack. Devi passare i dati come parametro mentre chiami il metodo push. Prima di inserire i dati, il puntatore superiore dello stack viene incrementato di uno e i nuovi dati vengono inseriti nella posizione superiore.
push(data) {
this.top++;
this.data[this.top] = data;
return this.data;
}Operazione Pop
L'operazione pop viene utilizzata per rimuovere l'elemento dati più in alto dello stack. Durante l'esecuzione di questa operazione, il puntatore superiore viene ridotto di 1.
pop() {
if (this.top <0) return undefined;
const poppedTop = this.data[this.top];
this.top--;
return poppedTop;
}Operazione di sbirciatina
L'operazione Peek viene utilizzata per restituire il valore presente in cima allo stack. La complessità temporale per il recupero di questi dati è O(1).
Per saperne di più: Che cos'è la notazione Big-O?
peek() {
return this.top >= 0 ? this.data[this.top] : undefined;
}Struttura dei dati dell'elenco collegato
Una lista concatenata è una struttura dati lineare composta da numerosi nodi collegati tra loro con l'ausilio di puntatori. Ciascun nodo nell'elenco contiene i dati e una variabile puntatore che punta al nodo successivo nell'elenco.
Ulteriori informazioni: Introduzione ai puntatori per i programmatori
A differenza di uno stack, le implementazioni di elenchi collegati in JavaScript richiedono due classi. La prima classe è la Nodo classe per la creazione di un nodo e la seconda classe è la Lista collegata classe per eseguire tutte le operazioni sull'elenco collegato. Il puntatore head punta al primo nodo dell'elenco collegato e il puntatore coda punta all'ultimo nodo dell'elenco collegato.
class Node {
constructor(data, next = null) {
this.data = data;
this.next = next;
}
}
class LinkedList {
constructor() {
this.head = null;
this.tail = null;
this.size = 0;
}
}Di seguito sono riportate alcune operazioni principali che è possibile eseguire su un elenco collegato:
Aggiungi operazione
L'operazione di aggiunta viene utilizzata per aggiungere un nuovo nodo alla fine dell'elenco collegato. Devi passare i dati come parametro per l'inserimento di un nuovo nodo. Innanzitutto, crea un nuovo oggetto nodo usando il pulsante nuovo parola chiave in JavaScript.
Se la lista collegata è vuota, sia il puntatore head che tail punteranno al nuovo nodo. Altrimenti, solo il puntatore a coda punterà al nuovo nodo.
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;
}Inserimento operazione
Per inserire un nuovo nodo in corrispondenza di un determinato indice, puoi utilizzare l'operazione di inserimento. Questo metodo richiede due parametri: i dati da inserire e l'indice in cui devono essere inseriti. Nel peggiore dei casi, questo metodo ha una complessità temporale di O(N) poiché potrebbe dover attraversare l'intero elenco.
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;
}Elimina operazione
L'operazione di eliminazione attraversa l'elenco collegato per ottenere il riferimento al nodo che deve essere eliminato e rimuove il collegamento del nodo precedente. Simile all'operazione di inserimento, anche l'operazione di cancellazione ha una complessità temporale di O(N) nel caso peggiore.
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;
}Struttura dei dati della coda
La struttura dei dati della coda è simile a un gruppo di persone in coda. La persona che entra per prima in coda viene servita prima degli altri. Allo stesso modo, questa struttura di dati lineare segue l'approccio FIFO (first in, first out) per inserire e rimuovere i dati. Questa struttura dati può essere ricreata in JavaScript utilizzando un elenco collegato in questo modo:
class Queue {
constructor() {
this.front = null;
this.rear = null;
this.size = 0;
}
}Ecco come puoi inserire e rimuovere dati da una coda in JavaScript:
migliore app di fotoritocco gratuita per iPhone
Operazione di accodamento
L'operazione di accodamento inserisce nuovi dati nella coda. Durante la chiamata a questo metodo, se la struttura dei dati della coda è vuota, entrambi i puntatori anteriore e posteriore puntano al nodo appena inserito nella coda. Se la coda non è vuota, il nuovo nodo viene aggiunto alla fine dell'elenco e il puntatore posteriore punta a questo nodo.
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;
}Operazione di annullamento dell'accodamento
L'operazione di rimozione dalla coda rimuove il primo elemento nella coda. Durante l'operazione di dequeue, il puntatore head viene spostato in avanti al secondo nodo nell'elenco. Questo secondo nodo diventa ora la testa della coda.
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;
}Il prossimo passo dopo le strutture di dati
Le strutture dati possono essere un concetto difficile da comprendere, soprattutto se sei nuovo nella programmazione. Ma proprio come qualsiasi altra abilità, la pratica può aiutarti a comprendere e apprezzare veramente l'efficienza che fornisce per l'archiviazione e la gestione dei dati nelle tue applicazioni.
Gli algoritmi sono utili tanto quanto le strutture dati e potrebbero diventare il prossimo passo logico nel tuo percorso di programmazione. Quindi, perché non iniziare con un algoritmo di ordinamento come il bubble sort?
Condividere Condividere Tweet E-mail Introduzione all'algoritmo di Bubble SortL'algoritmo Bubble Sort: un'eccellente introduzione all'ordinamento degli array.
Leggi Avanti Argomenti correlati- Programmazione
- JavaScript
- Programmazione
- Tutorial sulla programmazione
Nitin è un appassionato sviluppatore di software e uno studente di ingegneria informatica che sviluppa applicazioni web utilizzando le tecnologie JavaScript. Lavora come sviluppatore web freelance e gli piace scrivere per Linux e Programmazione nel suo tempo libero.
Altro da Nitin RanganathIscriviti alla nostra Newsletter
Iscriviti alla nostra newsletter per suggerimenti tecnici, recensioni, ebook gratuiti e offerte esclusive!
Clicca qui per iscriverti