ஜாவாஸ்கிரிப்ட் இஎஸ் 6 வகுப்புகளுடன் தரவு கட்டமைப்புகளை உருவாக்குவது எப்படி

தரவு கட்டமைப்புகள் கணினி அறிவியல் மற்றும் நிரலாக்கத்தின் அடிப்படை அம்சமாகும், நீங்கள் பயன்படுத்தும் மொழியைப் பொருட்படுத்தாமல். அவற்றைப் பற்றிய முழுமையான அறிவை வைத்திருப்பது தரவை ஒழுங்காக ஒழுங்கமைக்க, நிர்வகிக்க, சேமித்து, மாற்றியமைக்க உதவும். உங்கள் பயன்பாட்டிற்கான சரியான தரவு கட்டமைப்பை அடையாளம் காண்பது செயல்திறனை ஒரு பெரிய வித்தியாசத்தில் மேம்படுத்தலாம்.

இருப்பினும், ஜாவாஸ்கிரிப்ட் இயல்பாக வரிசைகள் மற்றும் பொருள்கள் போன்ற பழமையான தரவு கட்டமைப்புகளுடன் மட்டுமே வருகிறது. ஆனால் ECMAScript 6 (ES6) வகுப்புகளை அறிமுகப்படுத்துவதன் மூலம், நீங்கள் இப்போது பழமையான தரவு கட்டமைப்புகளின் உதவியுடன் அடுக்குகள் மற்றும் வரிசைகள் போன்ற தனிப்பயன் தரவு கட்டமைப்புகளை உருவாக்கலாம்.

---

---

ஐபாட் இசையை கணினியில் நகலெடுப்பது எப்படி

ஸ்டாக் டேட்டா அமைப்பு

ஸ்டாக் தரவு அமைப்பு தற்போதுள்ள தரவின் மேல் புதிய தரவை LIFO (கடைசியாக, முதல்-வெளியே) முறையில் தள்ள அனுமதிக்கிறது. இந்த நேரியல் தரவு கட்டமைப்பை ஒரு எளிய உதாரணத்தைப் பயன்படுத்தி எளிதாகக் காணலாம். மேஜையில் வைக்கப்பட்ட தட்டுகளின் அடுக்கைக் கவனியுங்கள். நீங்கள் அடுக்கின் மேல் இருந்து ஒரு தட்டைச் சேர்க்கலாம் அல்லது அகற்றலாம்.

ஜாவாஸ்கிரிப்ட் வரிசைகளைப் பயன்படுத்தி ஸ்டாக் தரவு கட்டமைப்பை நீங்கள் எவ்வாறு செயல்படுத்தலாம் என்பது இங்கே ES6 வகுப்புகள் :

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

நீங்கள் ஒரு ஸ்டேக்கில் செய்யக்கூடிய சில செயல்பாடுகளை ஆராய்ந்து உருவாக்குவோம்.

புஷ் செயல்பாடு

ஸ்டேக்கில் புதிய தரவைச் செருக புஷ் செயல்பாடு பயன்படுத்தப்படுகிறது. புஷ் முறையை அழைக்கும்போது தரவை ஒரு அளவுருவாக அனுப்ப வேண்டும். தரவைச் செருகுவதற்கு முன், அடுக்கின் மேல் சுட்டிக்காட்டி ஒன்றால் அதிகரிக்கப்படுகிறது, மேலும் புதிய தரவு மேல் நிலையில் செருகப்படும்.

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

பாப் செயல்பாடு

அடுக்கின் மேல் தரவு உறுப்பை அகற்ற பாப் செயல்பாடு பயன்படுத்தப்படுகிறது. இந்த செயல்பாட்டைச் செய்யும்போது, ​​மேல் சுட்டிக்காட்டி 1 ஆல் குறைக்கப்படுகிறது.

---

---

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

பீக் ஆபரேஷன்

ஸ்டேக்கின் மேல் இருக்கும் மதிப்பைத் திரும்பப் பெற பீக் ஆபரேஷன் பயன்படுத்தப்படுகிறது. இந்தத் தரவை மீட்டெடுப்பதற்கான நேர சிக்கலானது O (1).

மேலும் அறிக: பிக்-ஓ குறிப்பு என்றால் என்ன?

---

---

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

இணைக்கப்பட்ட பட்டியல் தரவு அமைப்பு

இணைக்கப்பட்ட பட்டியல் என்பது ஒரு நேரியல் தரவு கட்டமைப்பாகும், இது சுட்டிகளின் உதவியுடன் ஒன்றோடொன்று இணைக்கப்பட்ட பல முனைகளைக் கொண்டுள்ளது. பட்டியலில் உள்ள ஒவ்வொரு முனையிலும் தரவு மற்றும் பட்டியலில் உள்ள அடுத்த முனையை சுட்டிக்காட்டும் ஒரு சுட்டிக்காட்டி மாறி உள்ளது.

மேலும் அறிக: புரோகிராமர்களுக்கான சுட்டிகளுக்கான அறிமுகம்

ஒரு ஸ்டாக் போலல்லாமல், ஜாவாஸ்கிரிப்டில் இணைக்கப்பட்ட பட்டியல் செயல்படுத்தலுக்கு இரண்டு வகுப்புகள் தேவை. முதல் வகுப்பு தி முனை ஒரு முனையை உருவாக்குவதற்கான வர்க்கம், மற்றும் இரண்டாம் வகுப்பு இணைக்கப்பட்ட பட்டியல் இணைக்கப்பட்ட பட்டியலில் அனைத்து செயல்பாடுகளையும் செய்ய வர்க்கம். தலை சுட்டிக்காட்டி இணைக்கப்பட்ட பட்டியலின் முதல் முனையையும், வால் சுட்டிக்காட்டி இணைக்கப்பட்ட பட்டியலின் கடைசி முனையையும் சுட்டிக்காட்டுகிறது.

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

இணைக்கப்பட்ட பட்டியலில் நீங்கள் செய்யக்கூடிய சில முதன்மை செயல்பாடுகள் இங்கே:

செயல்பாட்டைச் சேர்க்கவும்

இணைக்கப்பட்ட பட்டியலின் முடிவில் ஒரு புதிய முனையைச் சேர்க்க, இணைப்புச் செயல்பாடு பயன்படுத்தப்படுகிறது. புதிய முனையைச் செருகுவதற்கான ஒரு அளவுருவாக நீங்கள் தரவை அனுப்ப வேண்டும். முதலில், பயன்படுத்தி ஒரு புதிய முனை பொருளை உருவாக்கவும் புதிய ஜாவாஸ்கிரிப்டில் முக்கிய சொல்.

இணைக்கப்பட்ட பட்டியல் காலியாக இருந்தால், தலை மற்றும் வால் சுட்டிக்காட்டி இரண்டும் புதிய முனையை சுட்டிக்காட்டும். இல்லையெனில், வால் சுட்டிக்காட்டி மட்டுமே புதிய முனையை சுட்டிக்காட்டும்.

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

செயல்பாட்டைச் செருகவும்

ஒரு குறிப்பிட்ட குறியீட்டில் ஒரு புதிய முனையைச் செருக, நீங்கள் செருகும் செயல்பாட்டைப் பயன்படுத்தலாம். இந்த முறை இரண்டு அளவுருக்களை எடுக்கும்: செருக வேண்டிய தரவு மற்றும் செருகப்பட வேண்டிய அட்டவணை. மோசமான நிலையில், இந்த முறை O (N) இன் நேர சிக்கலைக் கொண்டுள்ளது, ஏனெனில் இது முழு பட்டியலையும் கடந்து செல்ல வேண்டியிருக்கும்.

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

செயல்பாட்டை நீக்கு

நீக்கப்படும் முனைக்கான குறிப்பைப் பெற நீக்கப்பட்ட செயல்பாடு இணைக்கப்பட்ட பட்டியலின் வழியாகச் சென்று முந்தைய முனையின் இணைப்பை நீக்குகிறது. செருகும் செயல்பாட்டைப் போலவே, நீக்கும் செயல்பாடும் மோசமான நிலையில் 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;
}

வரிசை தரவு அமைப்பு

வரிசை தரவு அமைப்பு ஒரு வரிசையில் நிற்கும் மக்கள் கூட்டத்தைப் போன்றது. வரிசையில் முதலில் நுழைந்த நபர் மற்றவர்களுக்கு முன் சேவை செய்யப்படுகிறார். இதேபோல், இந்த நேரியல் தரவு அமைப்பு FIFO (முதலில், முதலில்) அணுகுமுறையைப் பின்பற்றி தரவைச் செருகவும் நீக்கவும். இந்த முறையில் இணைக்கப்பட்ட பட்டியலைப் பயன்படுத்தி இந்த தரவு கட்டமைப்பை ஜாவாஸ்கிரிப்டில் மீண்டும் உருவாக்கலாம்:

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

ஜாவாஸ்கிரிப்டில் ஒரு வரிசையில் இருந்து தரவை எவ்வாறு செருகலாம் மற்றும் அகற்றலாம் என்பது இங்கே:

எனது கணினி எனது தொலைபேசியை அடையாளம் காணவில்லை

தொடர்ச்சியான செயல்பாடு

வரிசையில் புதிய தரவு செருகுகிறது. இந்த முறையை அழைக்கும் போது, ​​வரிசை தரவு அமைப்பு காலியாக இருந்தால், முன் மற்றும் பின்புற சுட்டிகள் இரண்டும் வரிசையில் புதிதாக செருகப்பட்ட முனையை சுட்டிக்காட்டுகின்றன. வரிசை காலியாக இல்லை என்றால், பட்டியலின் முடிவில் புதிய முனை சேர்க்கப்படும் மற்றும் பின்புற சுட்டிக்காட்டி இந்த முனைக்கு சுட்டிக்காட்டுகிறது.

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() {
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;
}

தரவு கட்டமைப்புகளுக்குப் பிறகு அடுத்த படி

தரவு கட்டமைப்புகள் புரிந்துகொள்ள ஒரு தந்திரமான கருத்தாக இருக்கலாம், குறிப்பாக நீங்கள் நிரலாக்கத்திற்கு புதியவராக இருந்தால். ஆனால் வேறு எந்த திறமையைப் போலவே, பயிற்சியும் உங்கள் பயன்பாடுகளில் தரவைச் சேமித்து நிர்வகிப்பதற்கு வழங்கும் செயல்திறனை உண்மையாகப் புரிந்துகொள்ளவும் பாராட்டவும் உதவும்.

அல்காரிதம்கள் தரவு கட்டமைப்புகளைப் போலவே பயனுள்ளதாக இருக்கும் மற்றும் உங்கள் நிரலாக்க பயணத்தின் அடுத்த தர்க்கரீதியான படியாக மாறும். எனவே, குமிழி வரிசைப்படுத்துதல் போன்ற வரிசைப்படுத்தும் வழிமுறையுடன் ஏன் தொடங்கக்கூடாது?

பகிர் பகிர் ட்வீட் மின்னஞ்சல் குமிழி வரிசைமுறை வழிமுறையின் அறிமுகம்

குமிழி வரிசைமுறை வழிமுறை: வரிசைகளை வரிசைப்படுத்துவதற்கான சிறந்த அறிமுகம்.

அடுத்து படிக்கவும் தொடர்புடைய தலைப்புகள்

• நிரலாக்க
• ஜாவாஸ்கிரிப்ட்
• நிரலாக்க
• குறியீட்டு பயிற்சிகள்

எழுத்தாளர் பற்றி நிதின் ரங்கநாத்(31 கட்டுரைகள் வெளியிடப்பட்டன)

நிதின் ஒரு தீவிர மென்பொருள் உருவாக்குநர் மற்றும் ஜாவாஸ்கிரிப்ட் தொழில்நுட்பங்களைப் பயன்படுத்தி இணையப் பயன்பாடுகளை உருவாக்கும் கணினி பொறியியல் மாணவர். அவர் ஒரு ஃப்ரீலான்ஸ் வலை டெவலப்பராக வேலை செய்கிறார் மற்றும் அவரது ஓய்வு நேரத்தில் லினக்ஸ் மற்றும் புரோகிராமிங்கிற்காக எழுத விரும்புகிறார்.

நிதின் ரங்கநாத்திடமிருந்து மேலும்

எங்கள் செய்திமடலுக்கு குழுசேரவும்

தொழில்நுட்ப குறிப்புகள், மதிப்புரைகள், இலவச மின் புத்தகங்கள் மற்றும் பிரத்யேக ஒப்பந்தங்களுக்கு எங்கள் செய்திமடலில் சேரவும்!

குழுசேர இங்கே சொடுக்கவும்