Home-theater-designers
Tietorakenteet ovat olennainen osa tietotekniikkaa ja ohjelmointia riippumatta käyttämästäsi kielestä. Niiden perusteellinen tuntemus voi auttaa sinua järjestämään, hallitsemaan, tallentamaan ja muokkaamaan tietoja tehokkaasti. Käyttötarkoituksen oikean tietorakenteen tunnistaminen voi parantaa suorituskykyä valtavasti.
JavaScript sisältää kuitenkin oletuksena vain primitiiviset tietorakenteet, kuten taulukot ja objektit. Mutta kun otat käyttöön ECMAScript 6 (ES6) -luokat, voit nyt luoda mukautettuja tietorakenteita, kuten pinoja ja jonoja primitiivisten tietorakenteiden avulla.
kuinka vaihtaa oletustili Googlessa
Pino datarakenne
Pinotietorakenteen avulla voit työntää uusia tietoja olemassa olevien tietojen päälle LIFO (last-in, first-out) -menetelmällä. Tämä lineaarinen tietorakenne on helppo visualisoida yksinkertaisen esimerkin avulla. Harkitse pinoa levyjä, joita pidetään pöydällä. Voit lisätä tai poistaa levyn vain pinon yläosasta.
Näin voit toteuttaa pino -tietorakenteen JavaScript -matriisien ja ES6 luokat :
class Stack {
constructor() {
this.data = [];
this.top = -1;
}
}Tutkitaan ja rakennetaan joitain pinoon suoritettavia toimintoja.
Push -toiminto
Työntötoimintoa käytetään uusien tietojen lisäämiseen pinoon. Sinun on välitettävä tiedot parametrina kutsuttaessa push -menetelmää. Ennen tietojen lisäämistä pinoon lisätään yhden osoittimen yläosoitin ja uudet tiedot lisätään yläasentoon.
push(data) {
this.top++;
this.data[this.top] = data;
return this.data;
}Pop -operaatio
Pop -toiminnolla poistetaan pinon ylin tietoelementti. Tämän toiminnon aikana yläosoitinta pienennetään yhdellä.
pop() {
if (this.top <0) return undefined;
const poppedTop = this.data[this.top];
this.top--;
return poppedTop;
}Kurkistusoperaatio
Kurkistustoimintoa käytetään palauttamaan pinon yläosassa oleva arvo. Ajan monimutkaisuus näiden tietojen hakemiseksi on O (1).
Lisätietoja: Mikä on Big-O-merkintä?
peek() {
return this.top >= 0 ? this.data[this.top] : undefined;
}Linkitetyn luettelon tietorakenne
Linkitetty luettelo on lineaarinen tietorakenne, joka koostuu lukuisista solmuista, jotka on yhdistetty toisiinsa osoittimien avulla. Jokainen luettelon solmu sisältää tiedot ja osoitinmuuttujan, joka osoittaa luettelon seuraavaan solmuun.
Lisätietoja: Johdanto ohjelmoijien osoittimiin
Toisin kuin pino, linkitetyt luettelototeutukset JavaScriptissä edellyttävät kahta luokkaa. Ensimmäinen luokka on Solmu luokka solmun luomiseksi, ja toinen luokka on LinkedList luokka suorittaa kaikki linkitetyn luettelon toiminnot. Pääosoitin osoittaa linkitetyn luettelon ensimmäiseen solmuun ja hännän osoitin linkitetyn luettelon viimeiseen solmuun.
class Node {
constructor(data, next = null) {
this.data = data;
this.next = next;
}
}
class LinkedList {
constructor() {
this.head = null;
this.tail = null;
this.size = 0;
}
}Tässä on joitain ensisijaisia toimintoja, jotka voit suorittaa linkitetyssä luettelossa:
Liitä toiminto
Liiteoperaatiota käytetään uuden solmun lisäämiseen linkitetyn luettelon loppuun. Sinun on välitettävä tiedot parametrina uuden solmun lisäämiseksi. Luo ensin uusi solmuobjekti käyttämällä Uusi avainsana JavaScriptissä.
Jos linkitetty luettelo on tyhjä, sekä pään että hännän osoitin osoittavat uuteen solmuun. Muussa tapauksessa vain hännän osoitin osoittaa uuteen solmuun.
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;
}Lisää toiminto
Voit lisätä uuden solmun tiettyyn hakemistoon käyttämällä lisäystoimintoa. Tässä menetelmässä on kaksi parametria: lisättävät tiedot ja indeksi, johon ne lisätään. Pahimmassa tapauksessa tämän menetelmän aikakompleksisuus on O (N), koska sen on ehkä läpäistävä koko luettelo.
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;
}Poista toiminto
Poistotoiminto kulkee linkitetyn luettelon läpi saadakseen viittauksen poistettavaan solmuun ja poistaa edellisen solmun linkin. Samoin kuin lisäystoimenpiteellä, myös poistotoiminnon aikakompleksisuus on pahimmillaan 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;
}Jonon tietorakenne
Jonotietorakenne on samanlainen kuin joukko ihmisiä, jotka seisovat jonossa. Henkilö, joka tulee ensimmäisenä jonoon, palvelee muita. Vastaavasti tämä lineaarinen tietorakenne noudattaa FIFO (first in, first out) -menetelmää tietojen lisäämiseksi ja poistamiseksi. Tämä tietorakenne voidaan luoda uudelleen JavaScriptissä käyttämällä linkitettyä luetteloa tällä tavalla:
class Queue {
constructor() {
this.front = null;
this.rear = null;
this.size = 0;
}
}Voit lisätä ja poistaa tietoja jonosta JavaScriptissä seuraavasti:
kuinka laittaa Google -kalenteri työpöydälle Windows 10
Enqueue Operation
Enqueue -toiminto lisää uusia tietoja jonoon. Tätä menetelmää kutsuttaessa, jos jonon tietorakenne on tyhjä, sekä etu- että takaosoittimet osoittavat jonoon juuri lisättyyn solmuun. Jos jono ei ole tyhjä, uusi solmu lisätään luettelon loppuun ja takaosoitin osoittaa tähän solmuun.
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 -toiminto
Dequeue -toiminto poistaa jonon ensimmäisen elementin. Dequeue -toiminnon aikana pään osoitin siirretään luettelon toiseen solmuun. Tästä toisesta solmusta tulee nyt jonon pää.
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;
}Seuraava vaihe tietorakenteiden jälkeen
Tietorakenteet voivat olla hankala ymmärtää, varsinkin jos olet uusi ohjelmoija. Mutta kuten mikä tahansa muu taito, käytäntö voi auttaa sinua todella ymmärtämään ja arvostamaan tehokkuutta, jonka se tarjoaa tietojen tallentamiseen ja hallintaan sovelluksissasi.
Algoritmit ovat yhtä hyödyllisiä kuin tietorakenteet ja niistä voi tulla seuraava looginen vaihe ohjelmointimatkalla. Joten miksi et aloita lajittelualgoritmilla, kuten kuplalajittelulla?
Jaa Jaa Tweet Sähköposti Johdanto kuplalajittelualgoritmiinBubble Sort -algoritmi: erinomainen johdanto matriisien lajitteluun.
Lue seuraava Liittyvät aiheet- Ohjelmointi
- JavaScript
- Ohjelmointi
- Koodausoppaat
Nitin on innokas ohjelmistokehittäjä ja tietotekniikan opiskelija, joka kehittää verkkosovelluksia JavaScript -tekniikoilla. Hän työskentelee freelance -verkkokehittäjänä ja tykkää kirjoittaa vapaa -ajallaan Linuxille ja ohjelmoinnille.
Lisää Nitin Ranganathiltatilaa uutiskirjeemme
Liity uutiskirjeeseemme saadaksesi teknisiä vinkkejä, arvosteluja, ilmaisia e -kirjoja ja ainutlaatuisia tarjouksia!
Klikkaa tästä tilataksesi