Home-theater-designers
Andmestruktuurid on arvutiteaduse ja programmeerimise põhiaspekt, olenemata kasutatavast keelest. Nende põhjalik tundmine aitab teil andmeid tõhusalt korraldada, hallata, salvestada ja muuta. Kasutusjuhtumi jaoks sobiva andmestruktuuri tuvastamine võib jõudlust tohutult parandada.
Kuid JavaScriptiga kaasnevad vaikimisi ainult primitiivsed andmestruktuurid, näiteks massiivid ja objektid. Kuid ECMAScript 6 (ES6) klasside kasutuselevõtuga saate nüüd primitiivsete andmestruktuuride abil luua kohandatud andmestruktuure, näiteks virnasid ja järjekordi.
Windowsi 10 unerežiimi kiirklahv
Virna andmestruktuur
Virna andmestruktuur võimaldab teil LIFO (viimane sisse, esimene välja) viisil uusi andmeid olemasolevate andmete peale tõsta. Seda lineaarset andmestruktuuri on lihtne visualiseerida lihtsa näite abil. Mõelge lauale hoitud taldrikuvirnale. Plaadi saate lisada või eemaldada ainult virna ülaosast.
Siit saate teada, kuidas virna andmestruktuuri JavaScripti massiive kasutades rakendada ES6 klassid :
class Stack {
constructor() {
this.data = [];
this.top = -1;
}
}Uurime ja ehitame üles mõned toimingud, mida saate virnaga teha.
Tõukeoperatsioon
Tõukamistoimingut kasutatakse virna uute andmete sisestamiseks. Tõukemeetodi helistamisel peate andmed parameetrina edastama. Enne andmete sisestamist suurendatakse virna ülemist kursorit ühe võrra ja uued andmed sisestatakse ülemisse asendisse.
push(data) {
this.top++;
this.data[this.top] = data;
return this.data;
}Popoperatsioon
Pop -toimingut kasutatakse virna ülemise andmeelemendi eemaldamiseks. Selle toimingu tegemisel vähendatakse ülemist kursorit 1 võrra.
pop() {
if (this.top <0) return undefined;
const poppedTop = this.data[this.top];
this.top--;
return poppedTop;
}Peek operatsioon
Peek -toimingut kasutatakse virna ülaosas oleva väärtuse tagastamiseks. Nende andmete hankimise ajaline keerukus on O (1).
Lisateave: Mis on Big-O märge?
peek() {
return this.top >= 0 ? this.data[this.top] : undefined;
}Lingitud loendi andmestruktuur
Lingitud loend on lineaarne andmestruktuur, mis koosneb arvukatest viipade abil üksteisega ühendatud sõlmedest. Loendi iga sõlm sisaldab andmeid ja kursori muutujat, mis osutab loendi järgmisele sõlmele.
Lisateave: Sissejuhatus programmeerijate näpunäidetesse
Erinevalt virnast vajavad lingitud loendite rakendused JavaScriptis kahte klassi. Esimene klass on Sõlm klassi sõlme loomiseks ja teine klass on LinkedList klassi, et teha kõiki lingitud loendis olevaid toiminguid. Peanäit osutab lingitud loendi esimesele sõlmele ja sabaotsija lingitud loendi viimasele sõlmele.
class Node {
constructor(data, next = null) {
this.data = data;
this.next = next;
}
}
class LinkedList {
constructor() {
this.head = null;
this.tail = null;
this.size = 0;
}
}Siin on mõned peamised toimingud, mida saate lingitud loendis teha:
Lisa operatsioon
Lisamistoimingut kasutatakse uue sõlme lisamiseks lingitud loendi lõppu. Uue sõlme sisestamiseks peate andmed edastama parameetrina. Esiteks looge nupuga uus märksõna JavaScriptis.
Kui lingitud loend on tühi, osutavad nii pea kui ka sabaotsija uuele sõlmele. Vastasel juhul osutab uuele sõlmele ainult sabaotsija.
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;
}Sisestage operatsioon
Uue sõlme sisestamiseks teatud indeksisse saate kasutada sisestusoperatsiooni. Sellel meetodil on kaks parameetrit: sisestatavad andmed ja indeks, mille juurde need sisestatakse. Halvimal juhul on selle meetodi ajaline keerukus O (N), kuna see peab võib -olla läbima kogu loendi.
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;
}Kustuta operatsioon
Kustutamistoiming läbib lingitud loendi, et saada viide kustutatavale sõlmele, ja eemaldab eelmise sõlme lingi. Sarnaselt sisestustoimingule on kustutamistoimingul halvimal juhul ka ajaline keerukus O (N).
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;
}Järjekorra andmete struktuur
Järjekorra andmete struktuur sarnaneb hunnikuga järjekorras seisvatele inimestele. Isikut, kes esimesena järjekorda astub, serveeritakse teiste ees. Sarnaselt järgib see lineaarne andmestruktuur andmete sisestamiseks ja eemaldamiseks FIFO (esimene sisse, esimene välja) lähenemisviisi. Seda andmestruktuuri saab JavaScriptis uuesti luua, kasutades lingitud loendit järgmiselt.
class Queue {
constructor() {
this.front = null;
this.rear = null;
this.size = 0;
}
}JavaScripti järjekorda andmete sisestamiseks ja eemaldamiseks toimige järgmiselt.
edastage e -kirjad Outlookist gmaili
Enqueue Operation
Järjekorras sisestamine lisab järjekorda uusi andmeid. Selle meetodi kutsumisel, kui järjekorra andmestruktuur on tühi, osutavad nii esi- kui ka tagumine osuti järjekorda äsja sisestatud sõlmele. Kui järjekord pole tühi, lisatakse uus sõlm loendi lõppu ja tagumine osuti osutab sellele sõlmele.
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;
}Dequeue operatsioon
Dequeue operatsioon eemaldab järjekorra esimese elemendi. Lükkamistoimingu ajal liigutatakse pea kursor loendi teise sõlme. Sellest teisest sõlmest saab nüüd järjekorra juht.
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;
}Järgmine samm pärast andmestruktuure
Andmestruktuurid võivad olla keeruline mõiste, eriti kui olete programmeerimisega alles kursis. Kuid nagu iga teine oskus, võib praktika aidata teil tõeliselt mõista ja hinnata tõhusust, mida see pakub teie rakendustes andmete salvestamiseks ja haldamiseks.
Algoritmid on sama kasulikud kui andmestruktuurid ja neist võib saada teie programmeerimisteekonna järgmine loogiline samm. Niisiis, miks mitte alustada sorteerimisalgoritmiga, nagu mullide sortimine?
Jaga Jaga Piiksuma E -post Sissejuhatus mullide sortimise algoritmiMullide sortimise algoritm: suurepärane sissejuhatus massiivide sortimisse.
Loe edasi Seotud teemad- Programmeerimine
- JavaScript
- Programmeerimine
- Kodeerimise õpetused
Nitin on innukas tarkvaraarendaja ja arvutitehnika tudeng, kes arendab JavaScripti tehnoloogiaid kasutades veebirakendusi. Ta töötab vabakutselise veebiarendajana ning talle meeldib vabal ajal kirjutada Linuxi ja programmeerimise jaoks.
Veel Nitin RanganathiltTelli meie uudiskiri
Liituge meie uudiskirjaga, et saada tehnilisi näpunäiteid, ülevaateid, tasuta e -raamatuid ja eksklusiivseid pakkumisi!
Tellimiseks klõpsake siin