Home-theater-designers
Datastrukturer er et grunnleggende aspekt ved datavitenskap og programmering, uavhengig av språket du bruker. Å ha grundig kunnskap om dem kan hjelpe deg med effektivt å organisere, administrere, lagre og endre data. Å identifisere riktig datastruktur for ditt brukstilfelle kan forbedre ytelsen med en stor margin.
Imidlertid kommer JavaScript bare med primitive datastrukturer som matriser og objekter som standard. Men med introduksjonen av ECMAScript 6 (ES6) -klasser, kan du nå lage tilpassede datastrukturer som stabler og køer ved hjelp av primitive datastrukturer.
kan jeg bruke en hdmi -splitter for to skjermer
Stack datastruktur
Stabeldatastrukturen lar deg skyve nye data på toppen av eksisterende data på en LIFO-måte (sist inn, først ut). Denne lineære datastrukturen er lett å visualisere ved hjelp av et enkelt eksempel. Tenk på en bunke tallerkener som ligger på et bord. Du kan bare legge til eller fjerne en plate fra toppen av bunken.
Slik kan du implementere stabeldatastrukturen ved hjelp av JavaScript -arrays og ES6 klasser :
class Stack {
constructor() {
this.data = [];
this.top = -1;
}
}La oss utforske og bygge noen av operasjonene du kan utføre på en bunke.
Push -drift
Push -operasjonen brukes til å sette inn nye data i stabelen. Du må sende dataene som en parameter mens du kaller push -metoden. Før du setter inn dataene, økes den øverste pekeren i stabelen med en, og de nye dataene settes inn i topposisjonen.
push(data) {
this.top++;
this.data[this.top] = data;
return this.data;
}Pop -operasjon
Pop -operasjonen brukes til å fjerne det øverste dataelementet i stabelen. Når du utfører denne operasjonen, reduseres toppunktet med 1.
pop() {
if (this.top <0) return undefined;
const poppedTop = this.data[this.top];
this.top--;
return poppedTop;
}Titt operasjon
Tittoperasjonen brukes til å returnere verdien som er tilstede på toppen av bunken. Tidskompleksiteten for å hente disse dataene er O (1).
Lære mer: Hva er Big-O Notation?
peek() {
return this.top >= 0 ? this.data[this.top] : undefined;
}Datastruktur for lenket liste
En koblet liste er en lineær datastruktur som består av mange noder som er koblet til hverandre ved hjelp av tips. Hver node i listen inneholder dataene og en pekervariabel som peker til den neste noden i listen.
Lær mer: En introduksjon til pekere for programmerere
I motsetning til en stabel krever implementering av koblede lister i JavaScript to klasser. Den første klassen er Node klasse for å lage en node, og den andre klassen er LinkedList klasse for å utføre alle operasjoner på den koblede listen. Hodepekeren peker på den første noden i den koblede listen, og halepekeren peker på den siste noden i den koblede listen.
class Node {
constructor(data, next = null) {
this.data = data;
this.next = next;
}
}
class LinkedList {
constructor() {
this.head = null;
this.tail = null;
this.size = 0;
}
}Her er noen hovedoperasjoner du kan utføre på en koblet liste:
Legg til drift
Vedleggsoperasjonen brukes til å legge til en ny node på slutten av den koblede listen. Du må sende dataene som en parameter for å sette inn en ny node. Opprett først et nytt nodeobjekt ved hjelp av ny søkeord i JavaScript.
Hvis den koblede listen er tom, vil både hodet og halepekeren peke på den nye noden. Ellers vil bare halepekeren peke på den nye noden.
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;
}Sett inn operasjon
For å sette inn en ny node på en bestemt indeks, kan du bruke innsatsoperasjonen. Denne metoden tar to parametere: dataene som skal settes inn og indeksen de skal settes inn ved. I verste fall har denne metoden en tidskompleksitet på O (N), da den kan trenge å krysse gjennom hele listen.
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;
}Slett operasjon
Sletteoperasjonen går gjennom den koblede listen for å få referansen til noden som skal slettes, og fjerner koblingen til den forrige noden. I likhet med innsatsoperasjonen har sletteoperasjonen også en tidskompleksitet på O (N) i verste fall.
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;
}Datastruktur i kø
Kødatastrukturen ligner på en haug med mennesker som står i kø. Personen som kommer inn i køen først blir servert før andre. På samme måte følger denne lineære datastrukturen FIFO (først inn, først ut) tilnærming for å sette inn og fjerne data. Denne datastrukturen kan gjenskapes i JavaScript ved hjelp av en lenket liste på denne måten:
class Queue {
constructor() {
this.front = null;
this.rear = null;
this.size = 0;
}
}Slik kan du sette inn og fjerne data fra en kø i JavaScript:
hvordan være anonym på facebook
Enqueue -drift
Enqueue -operasjonen setter inn nye data i køen. Mens du kaller denne metoden, hvis kødatastrukturen er tom, peker både fremre og bakre peker på den nylig innsatte noden i køen. Hvis køen ikke er tom, legges den nye noden til på slutten av listen, og den bakre pekeren peker til denne noden.
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;
}Tøm drift
Tømningsoperasjonen fjerner det første elementet i køen. Under tømningsoperasjonen flyttes hodepekeren videre til den andre noden i listen. Denne andre noden blir nå leder av køen.
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;
}Neste trinn etter datastrukturer
Datastrukturer kan være et vanskelig konsept å forstå, spesielt hvis du er ny i programmering. Men akkurat som alle andre ferdigheter, kan øvelse hjelpe deg med å virkelig forstå og sette pris på effektiviteten den gir for lagring og håndtering av data i applikasjonene dine.
Algoritmer er like nyttige som datastrukturer og kan bli det neste logiske trinnet i programmeringsreisen. Så hvorfor ikke starte med en sorteringsalgoritme som boblesortering?
Dele Dele kvitring E -post En introduksjon til boblesorteringsalgoritmenBoblesorteringsalgoritmen: en utmerket introduksjon til sorteringsoppstillinger.
Les neste Relaterte temaer- Programmering
- JavaScript
- Programmering
- Opplæringsprogrammer for koding
Nitin er en ivrig programvareutvikler og en dataingeniørstudent som utvikler webapplikasjoner ved hjelp av JavaScript -teknologier. Han jobber som frilans webutvikler og liker å skrive for Linux og programmering på fritiden.
Mer fra Nitin RanganathAbonner på vårt nyhetsbrev
Bli med i vårt nyhetsbrev for tekniske tips, anmeldelser, gratis ebøker og eksklusive tilbud!
Klikk her for å abonnere