Paano Bumuo ng Mga Istraktura ng Data Sa Mga Klase ng JavaScript ES6

Ang mga istruktura ng data ay isang pangunahing aspeto ng computer science at programa, hindi alintana ang wikang ginagamit mo. Ang pagkakaroon ng masusing kaalaman sa mga ito ay makakatulong sa iyong mahusay na ayusin, pamahalaan, maiimbak, at baguhin ang data. Ang pagkilala sa tamang istraktura ng data para sa iyong kaso ng paggamit ay maaaring mapabuti ang pagganap sa pamamagitan ng isang malaking margin.

Gayunpaman, ang JavaScript ay may kasamang primitive na mga istraktura ng data tulad ng mga arrays at object bilang default. Ngunit sa pagpapakilala ng mga klase ng ECMAScript 6 (ES6), maaari ka na ngayong lumikha ng mga pasadyang istraktura ng data tulad ng mga stack at pila sa tulong ng mga primitive na istruktura ng data.

tindahan ng mga gamit na pc na malapit sa akin

Istraktura ng Data ng Stack

Pinapayagan ka ng istraktura ng stack data na itulak ang bagong data sa tuktok ng mayroon nang data sa isang LIFO (huling-in, first-out) na paraan. Ang istraktura ng linear na data na ito ay madaling mailarawan gamit ang isang simpleng halimbawa. Isaalang-alang ang isang stack ng mga plato na itinatago sa isang mesa. Maaari kang magdagdag o mag-alis ng isang plato mula sa tuktok ng stack lamang.

Narito kung paano mo maipapatupad ang istraktura ng stack data gamit ang mga JavaScript array at Mga klase sa ES6 :

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

Tuklasin natin at buuin ang ilan sa mga pagpapatakbo na maaari mong gampanan sa isang stack.

Push Operation

Ginagamit ang operasyon ng push upang ipasok ang bagong data sa stack. Kailangan mong ipasa ang data bilang isang parameter habang tinatawagan ang push method. Bago ipasok ang data, ang tuktok na pointer ng stack ay nadagdagan ng isa, at ang bagong data ay naipasok sa tuktok na posisyon.

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

Pagpapatakbo ng Pop

Ginagamit ang pagpapatakbo ng pop upang alisin ang pinakamataas na elemento ng data ng stack. Habang ginagawa ang operasyong ito, ang nangungunang pointer ay nabawasan ng 1.

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

Sumilip sa Operasyon

Ang operasyon ng pagsilip ay ginagamit upang ibalik ang halaga na naroroon sa tuktok ng stack. Ang pagiging kumplikado ng oras para sa pagkuha ng data na ito ay O (1).

Dagdagan ang nalalaman: Ano ang Big-O Notation?

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

Istraktura ng Data ng naka-link na Listahan

Ang isang naka-link na listahan ay isang linear na istraktura ng data na binubuo ng maraming mga node na konektado sa bawat isa sa tulong ng mga payo. Ang bawat node sa listahan ay naglalaman ng data at isang variable ng pointer na tumuturo sa susunod na node sa listahan.

Dagdagan ang nalalaman: Isang Panimula sa Mga Turo para sa Programmers

Hindi tulad ng isang stack, ang mga pagpapatupad ng listahan ng naka-link sa JavaScript ay nangangailangan ng dalawang klase. Ang unang klase ay ang Node klase para sa paglikha ng isang node, at ang pangalawang klase ay ang LinkedList klase upang maisagawa ang lahat ng mga pagpapatakbo sa naka-link na listahan. Itinuon ng head pointer ang unang node ng naka-link na listahan, at ang tail pointer ay tumuturo sa huling node ng naka-link na listahan.

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

Narito ang ilang pangunahing operasyon na maaari mong gampanan sa isang naka-link na listahan:

Idagdag ang Operasyon

Ginagamit ang operasyon ng append upang magdagdag ng isang bagong node sa dulo ng naka-link na listahan. Kailangan mong ipasa ang data bilang isang parameter para sa pagpasok ng isang bagong node. Una, lumikha ng isang bagong node object gamit ang bago keyword sa JavaScript.

Kung ang listahan ng naka-link ay walang laman, ang parehong ulo at buntot na pointer ay magtuturo sa bagong node. Kung hindi man, ang tail pointer lamang ang magtuturo sa bagong 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;  
}

Ipasok ang Operasyon

Upang magsingit ng isang bagong node sa isang partikular na index, maaari mong gamitin ang pagpapatakbo ng insert. Ang pamamaraang ito ay tumatagal ng dalawang mga parameter: ang data upang ipasok at ang index kung saan ito ay maipapasok. Sa pinakapangit na kaso, ang pamamaraang ito ay may pagiging kumplikado ng oras ng O (N) dahil maaaring dumaan ito sa buong listahan.

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;  
}

Tanggalin ang Operasyon

Ang pagtanggal ng operasyon ay dumadaan sa listahan ng naka-link upang makuha ang sanggunian sa node na tatanggalin at aalisin ang link ng nakaraang node. Katulad ng pagpapatakbo ng insert, ang pagpapatakbo ng tanggalin ay mayroon ding pagkakumplikado ng oras ng O (N) sa pinakamasamang kaso.

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;  
}

Istraktura ng Data ng pila

Ang istraktura ng data ng pila ay katulad ng isang grupo ng mga tao na nakatayo sa isang pila. Ang taong unang pumasok sa pila ay hinahain bago ang iba. Katulad nito, ang linear na istraktura ng data na ito ay sumusunod sa FIFO (una sa, unang labas) na diskarte upang maipasok at alisin ang data. Ang istraktura ng data na ito ay maaaring likhain muli sa JavaScript gamit ang isang naka-link na listahan sa ganitong paraan:

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

Narito kung paano mo mailalagay at alisin ang data mula sa isang pila sa JavaScript:

kung paano makahanap ng isang tao nang libre sa internet

Pagpapatakbo pagpapatakbo

Ang pagpapatakbo ng enqueue ay nagsisingit ng bagong data sa pila. Habang tinatawagan ang pamamaraang ito, kung ang istraktura ng data ng pila ay walang laman, ang parehong mga hintuturo sa harap at likuran ay tumuturo sa bagong ipinasok na node sa pila. Kung ang pila ay hindi walang laman, ang bagong node ay idinagdag sa dulo ng listahan at ang likurang pointer ay tumuturo sa node na ito.

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;  
}

Pagpapatakbo ng Dequeue

Tinatanggal ng operasyon ng dequeue ang unang elemento sa pila. Sa panahon ng operasyon ng dequeue, ang head pointer ay ilipat sa pangalawang node sa listahan. Ang pangalawang node na ito ngayon ay nagiging pinuno ng pila.

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;  
}

Ang Susunod na Hakbang Pagkatapos ng Mga Istraktura ng Data

Ang mga istraktura ng data ay maaaring isang mahirap na konsepto upang maunawaan, lalo na kung bago ka sa pag-program. Ngunit tulad ng anumang iba pang kasanayan, makakatulong ang pagsasanay na tunay mong maunawaan at pahalagahan ang kahusayan na ibinibigay nito para sa pagtatago at pamamahala ng data sa iyong mga application.

Ang mga algorithm ay kasing kapaki-pakinabang ng mga istruktura ng data at maaaring maging susunod na lohikal na hakbang sa iyong paglalakbay sa programa. Kaya, bakit hindi magsimula sa isang pag-uuri ng algorithm tulad ng pag-uuri ng bubble?

Magbahagi Magbahagi Mag-tweet Email Isang Panimula sa Algorithm ng Bubble Sort

Ang algorithm ng Bubble Sort: isang mahusay na pagpapakilala sa pag-uuri ng mga arrays.

Basahin Susunod Mga Kaugnay na Paksa

Programming
JavaScript
Programming
Mga Tutorial sa Coding

Tungkol sa May-akda Nitin Ranganath(31 Mga Artikulo Na-publish)

Ang Nitin ay isang masugid na developer ng software at isang mag-aaral sa computer engineering na bumubuo ng mga aplikasyon sa web gamit ang mga teknolohiya ng JavaScript. Gumagawa siya bilang isang freelance web developer at gustong magsulat para sa Linux at Programming sa kanyang libreng oras.

Higit pa Mula sa Nitin Ranganath

Mag-subscribe sa aming newsletter

Sumali sa aming newsletter para sa mga tip sa tech, pagsusuri, libreng ebook, at eksklusibong deal!

Mag-click dito upang mag-subscribe