Home-theater-designers
Duomenų struktūros yra pagrindinis informatikos ir programavimo aspektas, nepriklausomai nuo jūsų vartojamos kalbos. Išsamios jų žinios gali padėti efektyviai tvarkyti, tvarkyti, saugoti ir keisti duomenis. Tinkamos duomenų struktūros nustatymas jūsų naudojimo atveju gali labai pagerinti našumą.
Tačiau „JavaScript“ numatyta tik su primityviomis duomenų struktūromis, tokiomis kaip masyvai ir objektai. Tačiau pradėję naudoti „ECMAScript 6“ (ES6) klases, dabar naudodami primityvias duomenų struktūras galite sukurti pasirinktines duomenų struktūras, tokias kaip krūvos ir eilės.
kokios programos turėtų būti paleistos paleidžiant „Windows 7“
Kamino duomenų struktūra
Duomenų krūvos struktūra leidžia perkelti naujus duomenis ant esamų duomenų LIFO (paskutinis įėjimas, pirmas išėjimas) būdu. Šią tiesinę duomenų struktūrą lengva vizualizuoti naudojant paprastą pavyzdį. Apsvarstykite krūvą lėkščių, laikomų ant stalo. Galite pridėti arba pašalinti plokštelę tik iš kamino viršaus.
Štai kaip galite įdiegti krūvos duomenų struktūrą naudodami „JavaScript“ masyvus ir ES6 klasės :
class Stack {
constructor() {
this.data = [];
this.top = -1;
}
}Panagrinėkime ir sukursime kai kurias operacijas, kurias galite atlikti su kaupu.
Paspaudimo operacija
Stumimo operacija naudojama naujiems duomenims įterpti į krūvą. Turite perduoti duomenis kaip parametrą, kai skambinate „push“ metodu. Prieš įterpiant duomenis, viršutinė kamino rodyklė padidinama vienu, o nauji duomenys įterpiami viršutinėje vietoje.
push(data) {
this.top++;
this.data[this.top] = data;
return this.data;
}Pop operacija
Iššokimo operacija naudojama pašalinti viršutinį kamino duomenų elementą. Atliekant šią operaciją, viršutinė rodyklė sumažinama 1.
pop() {
if (this.top <0) return undefined;
const poppedTop = this.data[this.top];
this.top--;
return poppedTop;
}Žvilgsnio operacija
Žvilgsnio operacija naudojama grąžinant kamino viršuje esančią vertę. Šių duomenų gavimo laiko sudėtingumas yra O (1).
Sužinokite daugiau: Kas yra „Big-O“ žymėjimas?
peek() {
return this.top >= 0 ? this.data[this.top] : undefined;
}Susietų sąrašų duomenų struktūra
Susietas sąrašas yra linijinė duomenų struktūra, susidedanti iš daugybės mazgų, sujungtų vienas su kitu rodyklių pagalba. Kiekviename sąrašo mazge yra duomenys ir rodyklės kintamasis, rodantis į kitą sąrašo mazgą.
Sužinokite daugiau: Įvadas į programuotojų nuorodas
Skirtingai nuo krūvos, susietam sąrašo įgyvendinimui „JavaScript“ reikia dviejų klasių. Pirmoji klasė yra Mazgas klasė mazgui sukurti, o antroji klasė yra „LinkedList“ klasę, kad atliktumėte visas susieto sąrašo operacijas. Galvos rodyklė nukreipia į pirmąjį susieto sąrašo mazgą, o uodegos rodyklė - į paskutinį susieto sąrašo mazgą.
class Node {
constructor(data, next = null) {
this.data = data;
this.next = next;
}
}
class LinkedList {
constructor() {
this.head = null;
this.tail = null;
this.size = 0;
}
}Štai keletas pagrindinių operacijų, kurias galite atlikti susietame sąraše:
Pridėti operaciją
Pridėjimo operacija naudojama norint pridėti naują mazgą susieto sąrašo pabaigoje. Turite perduoti duomenis kaip naujo mazgo įterpimo parametrą. Pirmiausia sukurkite naują mazgo objektą naudodami naujas raktinis žodis „JavaScript“.
Jei susietas sąrašas tuščias, tiek galva, tiek uodegos žymeklis nukreipia į naują mazgą. Priešingu atveju tik uodegos rodyklė nurodys naują mazgą.
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;
}Įterpti operaciją
Norėdami įterpti naują mazgą prie tam tikro indekso, galite pasinaudoti įterpimo operacija. Šis metodas apima du parametrus: duomenis, kuriuos reikia įterpti, ir indeksą, prie kurio jie turi būti įterpti. Blogiausiu atveju šio metodo laiko sudėtingumas yra O (N), nes gali tekti pereiti per visą sąrašą.
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;
}Ištrinti operaciją
Ištrynimo operacija pereina per susietą sąrašą, kad gautų nuorodą į mazgą, kuris turi būti ištrintas, ir pašalina ankstesnio mazgo nuorodą. Panašiai kaip ir įterpimo operacija, ištrynimo operacija blogiausiu atveju taip pat turi laiko sudėtingumą 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;
}Eilės duomenų struktūra
Eilės duomenų struktūra panaši į krūvą žmonių, stovinčių eilėje. Žmogus, kuris pirmas įeina į eilę, aptarnaujamas prieš kitus. Panašiai ši linijinė duomenų struktūra atitinka FIFO (pirmojo įėjimo, pirmojo išėjimo) metodą, skirtą įterpti ir pašalinti duomenis. Šią duomenų struktūrą galima atkurti naudojant „JavaScript“ naudojant susietą sąrašą tokiu būdu:
class Queue {
constructor() {
this.front = null;
this.rear = null;
this.size = 0;
}
}Štai kaip galite įterpti ir pašalinti duomenis iš eilės „JavaScript“:
ką daryti su senais kietaisiais diskais
Enqueue operacija
Surinkimo operacija į eilę įterpia naujų duomenų. Skambinant šiuo metodu, jei eilės duomenų struktūra tuščia, tiek priekiniai, tiek galiniai rodyklės rodo į naujai įterptą mazgą eilėje. Jei eilė nėra tuščia, naujas mazgas pridedamas prie sąrašo pabaigos, o galinis žymeklis rodo šį mazgą.
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 operacija
Atlikimo operacija pašalina pirmąjį eilės elementą. Atliekant operaciją, galvos rodyklė perkeliama į antrąjį sąrašo mazgą. Šis antrasis mazgas dabar tampa eilės galva.
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;
}Kitas žingsnis po duomenų struktūrų
Duomenų struktūros gali būti sudėtinga suvokti, ypač jei esate programuotojas. Tačiau kaip ir bet kuris kitas įgūdis, praktika gali padėti jums iš tikrųjų suprasti ir įvertinti duomenų saugojimo ir valdymo efektyvumą programose.
Algoritmai yra tokie pat naudingi kaip ir duomenų struktūros ir gali tapti kitu logišku žingsniu jūsų programavimo kelyje. Taigi, kodėl gi ne pradėti nuo rūšiavimo algoritmo, pvz., Burbuliukų rūšiavimo?
Dalintis Dalintis „Tweet“ Paštu Įvadas į burbulų rūšiavimo algoritmą„Bubble Sort“ algoritmas: puikus įvadas į masyvų rūšiavimą.
Skaityti toliau Susijusios temos- Programavimas
- „JavaScript“
- Programavimas
- Kodavimo pamokos
Nitinas yra aistringas programinės įrangos kūrėjas ir kompiuterių inžinerijos studentas, kuriantis žiniatinklio programas naudojant „JavaScript“ technologijas. Jis dirba kaip laisvai samdomas žiniatinklio kūrėjas ir laisvalaikiu mėgsta rašyti „Linux“ ir programavimui.
Daugiau iš Nitin RanganathPrenumeruokite mūsų naujienlaiškį
Prisijunkite prie mūsų naujienlaiškio, kad gautumėte techninių patarimų, apžvalgų, nemokamų el. Knygų ir išskirtinių pasiūlymų!
Norėdami užsiprenumeruoti, spustelėkite čia