Home-theater-designers
Datu struktūras ir būtisks datorzinātņu un programmēšanas aspekts neatkarīgi no izmantotās valodas. Rūpīgas zināšanas par tām var palīdzēt efektīvi organizēt, pārvaldīt, uzglabāt un modificēt datus. Lietošanas gadījumam atbilstošas datu struktūras noteikšana var ievērojami uzlabot veiktspēju.
Tomēr JavaScript pēc noklusējuma ir tikai ar primitīvām datu struktūrām, piemēram, masīviem un objektiem. Bet, ieviešot ECMAScript 6 (ES6) klases, tagad ar primitīvu datu struktūru palīdzību varat izveidot pielāgotas datu struktūras, piemēram, kaudzes un rindas.
mac os emulators operētājsistēmai Windows 10
Kaudze datu struktūra
Kaudze datu struktūra ļauj jums virzīt jaunus datus virs esošajiem datiem LIFO (pēdējais, pirmais, pirmais) veidā. Šo lineāro datu struktūru ir viegli vizualizēt, izmantojot vienkāršu piemēru. Apsveriet šķīvju kaudzi, kas tiek turēta uz galda. Plāksni var pievienot vai noņemt tikai no kaudzes augšdaļas.
Lūk, kā jūs varat ieviest kaudzes datu struktūru, izmantojot JavaScript masīvus un ES6 klases :
class Stack {
constructor() {
this.data = [];
this.top = -1;
}
}Izpētīsim un izveidosim dažas darbības, kuras varat veikt ar kaudzīti.
Push darbība
Stumšanas operācija tiek izmantota jaunu datu ievietošanai kaudzē. Izsaucot push metodi, jums jānodod dati kā parametrs. Pirms datu ievietošanas kaudzes augšējais rādītājs tiek palielināts par vienu, un jaunie dati tiek ievietoti augšējā pozīcijā.
push(data) {
this.top++;
this.data[this.top] = data;
return this.data;
}Pop operācija
Uznirstošā darbība tiek izmantota, lai noņemtu kaudzes augšējo datu elementu. Veicot šo darbību, augšējais rādītājs tiek samazināts par 1.
pop() {
if (this.top <0) return undefined;
const poppedTop = this.data[this.top];
this.top--;
return poppedTop;
}Lūkošanās operācija
Peek operācija tiek izmantota, lai atgrieztu kaudzes augšpusē esošo vērtību. Šo datu izgūšanas laika sarežģītība ir O (1).
Uzzināt vairāk: Kas ir Big-O apzīmējums?
peek() {
return this.top >= 0 ? this.data[this.top] : undefined;
}Saistīto sarakstu datu struktūra
Saistītais saraksts ir lineāra datu struktūra, kas sastāv no daudziem mezgliem, kas savstarpēji savienoti ar rādītāju palīdzību. Katrs saraksta mezgls satur datus un rādītāja mainīgo, kas norāda uz nākamo mezglu sarakstā.
Uzziniet vairāk: Ievads programmētāju norādījumos
Atšķirībā no kaudzes, saistīto sarakstu ieviešanai JavaScript ir nepieciešamas divas klases. Pirmā klase ir Mezgls klase mezgla izveidei, bet otrā klase ir LinkedList klasi, lai veiktu visas saistītā saraksta darbības. Galvas rādītājs norāda uz saistītā saraksta pirmo mezglu, bet astes rādītājs norāda uz saistītā saraksta pēdējo mezglu.
class Node {
constructor(data, next = null) {
this.data = data;
this.next = next;
}
}
class LinkedList {
constructor() {
this.head = null;
this.tail = null;
this.size = 0;
}
}Šeit ir dažas galvenās darbības, kuras varat veikt saistītajā sarakstā:
Pievienot operāciju
Pievienošanas operācija tiek izmantota, lai saistītā saraksta beigās pievienotu jaunu mezglu. Jums ir jānodod dati kā parametrs jauna mezgla ievietošanai. Pirmkārt, izveidojiet jaunu mezgla objektu, izmantojot jauns atslēgvārds JavaScript.
Ja saistītais saraksts ir tukšs, gan galva, gan astes rādītājs norāda uz jauno mezglu. Pretējā gadījumā tikai astes rādītājs norāda uz jauno mezglu.
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;
}Ievietojiet operāciju
Lai ievietotu jaunu mezglu noteiktā indeksā, varat izmantot ievietošanas darbību. Šai metodei ir divi parametri: ievadāmie dati un indekss, kurā tie jāievieto. Sliktākajā gadījumā šīs metodes laika sarežģītība ir O (N), jo tai var nākties šķērsot visu sarakstu.
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;
}Dzēst operāciju
Dzēšanas darbība šķērso saistīto sarakstu, lai iegūtu atsauci uz dzēšamo mezglu, un noņem iepriekšējā mezgla saiti. Līdzīgi kā ievietošanas operācijai, arī dzēšanas operācijas laika sarežģītība sliktākajā gadījumā ir 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;
}Rindas datu struktūra
Rindas datu struktūra ir līdzīga bariņam cilvēku, kas stāv rindā. Persona, kas vispirms ieiet rindā, tiek apkalpota citu priekšā. Līdzīgi šī lineārā datu struktūra seko FIFO (pirmais iekšā, pirmais ārā) pieejai, lai ievietotu un noņemtu datus. Šo datu struktūru var atjaunot JavaScript, izmantojot saistītu sarakstu šādā veidā:
class Queue {
constructor() {
this.front = null;
this.rear = null;
this.size = 0;
}
}Lūk, kā jūs varat ievietot un noņemt datus no JavaScript rindas:
ir gredzens saderīgs ar google home
Enqueue darbība
Sarakstīšanas operācija rindā ievieto jaunus datus. Izsaucot šo metodi, ja rindas datu struktūra ir tukša, gan priekšējie, gan aizmugurējie rādītāji norāda uz rindā tikko ievietoto mezglu. Ja rinda nav tukša, jaunais mezgls tiek pievienots saraksta beigām un aizmugurējais rādītājs norāda uz šo mezglu.
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 operācija
Atlikšanas darbība noņem pirmo rindas elementu. Dequeue darbības laikā galvas rādītājs tiek pārvietots uz priekšu uz otro mezglu sarakstā. Šis otrais mezgls tagad kļūst par rindas galvu.
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;
}Nākamais solis pēc datu struktūrām
Datu struktūras var būt sarežģīta izpratne, it īpaši, ja esat programmēšanas iesācējs. Bet tāpat kā jebkura cita prasme, prakse var palīdzēt jums patiesi izprast un novērtēt efektivitāti, ko tā nodrošina datu glabāšanai un pārvaldīšanai jūsu lietojumprogrammās.
Algoritmi ir tikpat noderīgi kā datu struktūras un var kļūt par nākamo loģisko soli jūsu programmēšanas ceļā. Tātad, kāpēc nesākt ar šķirošanas algoritmu, piemēram, burbuļu kārtošanu?
Kopīgot Kopīgot Čivināt E -pasts Ievads burbuļu kārtošanas algoritmāBurbuļu kārtošanas algoritms: lielisks ievads masīvu šķirošanā.
Lasīt Tālāk Saistītās tēmas- Programmēšana
- JavaScript
- Programmēšana
- Kodēšanas apmācības
Nitins ir dedzīgs programmatūras izstrādātājs un datortehnikas students, kurš izstrādā tīmekļa lietojumprogrammas, izmantojot JavaScript tehnoloģijas. Viņš strādā kā ārštata tīmekļa izstrādātājs, un brīvajā laikā viņam patīk rakstīt Linux un programmēšanai.
Vairāk no Nitin RanganathAbonējiet mūsu biļetenu
Pievienojieties mūsu informatīvajam izdevumam, lai iegūtu tehniskus padomus, pārskatus, bezmaksas e -grāmatas un ekskluzīvus piedāvājumus!
Noklikšķiniet šeit, lai abonētu