జావాస్క్రిప్ట్ ES6 క్లాస్‌లతో డేటా స్ట్రక్చర్‌లను ఎలా నిర్మించాలి

మీరు ఉపయోగించే భాషతో సంబంధం లేకుండా డేటా స్ట్రక్చర్స్ కంప్యూటర్ సైన్స్ మరియు ప్రోగ్రామింగ్ యొక్క ప్రాథమిక అంశం. వాటి గురించి పూర్తి పరిజ్ఞానం కలిగి ఉండటం వలన డేటాను సమర్ధవంతంగా నిర్వహించడానికి, నిర్వహించడానికి, నిల్వ చేయడానికి మరియు సవరించడానికి మీకు సహాయపడుతుంది. మీ వినియోగ కేసు కోసం సరైన డేటా స్ట్రక్చర్‌ను గుర్తించడం వలన పనితీరును భారీ తేడాతో మెరుగుపరుస్తుంది.

ఏదేమైనా, జావాస్క్రిప్ట్ డిఫాల్ట్‌గా శ్రేణులు మరియు వస్తువులు వంటి ఆదిమ డేటా నిర్మాణాలతో మాత్రమే వస్తుంది. కానీ ECMAScript 6 (ES6) తరగతుల పరిచయంతో, మీరు ఇప్పుడు ప్రాచీన డేటా నిర్మాణాల సహాయంతో స్టాక్స్ మరియు క్యూల వంటి అనుకూల డేటా నిర్మాణాలను సృష్టించవచ్చు.

---

---

ddr4 తర్వాత సంఖ్య అంటే ఏమిటి

స్టాక్ డేటా నిర్మాణం

స్టాక్ డేటా నిర్మాణం 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).

ఇంకా నేర్చుకో: బిగ్- O సంజ్ఞామానం అంటే ఏమిటి?

---

---

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 (ఫస్ట్ ఇన్, ఫస్ట్ అవుట్) విధానాన్ని అనుసరిస్తుంది. ఈ పద్ధతిలో లింక్ చేయబడిన జాబితాను ఉపయోగించి ఈ డేటా నిర్మాణాన్ని జావాస్క్రిప్ట్‌లో పునreసృష్టి చేయవచ్చు:

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 కథనాలు ప్రచురించబడ్డాయి)

నితిన్ ఆసక్తిగల సాఫ్ట్‌వేర్ డెవలపర్ మరియు కంప్యూటర్ ఇంజనీరింగ్ విద్యార్థి జావాస్క్రిప్ట్ టెక్నాలజీలను ఉపయోగించి వెబ్ అప్లికేషన్‌లను అభివృద్ధి చేస్తున్నాడు. అతను ఫ్రీలాన్స్ వెబ్ డెవలపర్‌గా పనిచేస్తాడు మరియు తన ఖాళీ సమయంలో లైనక్స్ మరియు ప్రోగ్రామింగ్ కోసం వ్రాయడానికి ఇష్టపడతాడు.

నితిన్ రంగనాథ్ నుండి మరిన్ని

మా వార్తాలేఖకు సభ్యత్వాన్ని పొందండి

టెక్ చిట్కాలు, సమీక్షలు, ఉచిత ఈబుక్‌లు మరియు ప్రత్యేకమైన డీల్స్ కోసం మా వార్తాలేఖలో చేరండి!

సభ్యత్వం పొందడానికి ఇక్కడ క్లిక్ చేయండి