పైథాన్‌లో స్టాక్ డేటా స్ట్రక్చర్స్ ఏమిటి?

డేటా స్ట్రక్చర్స్ అంటే డేటా విలువల సమాహారం, వాటి మధ్య సంబంధాలు మరియు డేటాకు వర్తించే విధులు లేదా కార్యకలాపాలు. ఇప్పుడు చాలా డేటా స్ట్రక్చర్స్ అందుబాటులో ఉన్నాయి. కానీ ఈ రోజు మన దృష్టి స్టాక్ డేటా స్ట్రక్చర్స్‌పై ఉంటుంది. నేను ఈ క్రింది విషయాలను చర్చిస్తాను:

• డేటా స్ట్రక్చర్స్ ఎందుకు?
• డేటా నిర్మాణాల రకాలు
• స్టాక్ డేటా నిర్మాణం అంటే ఏమిటి?
• స్టాక్ డేటా నిర్మాణాన్ని సృష్టిస్తోంది
• ఎలిమెంట్స్‌ను స్టాక్‌లోకి నెట్టండి
• స్టాక్ నుండి పాప్ ఎలిమెంట్స్
• స్టాక్ డేటా నిర్మాణం యొక్క అనువర్తనాలు

డేటా స్ట్రక్చర్స్ ఎందుకు?

దీనికి సమాధానం ఇవ్వడానికి మీరు పెద్ద స్థాయిలో ఆలోచించాలి. మైక్రో సెకన్లలో శోధన ఫలితాన్ని గూగుల్ మ్యాప్స్ మీకు ఎలా చూపిస్తాయో ఆలోచించండి. ఇది 100 వెబ్‌సైట్‌లతో మాత్రమే వ్యవహరించదు, ఇది ఒక బిలియన్ కంటే ఎక్కువ సైట్‌లతో వ్యవహరిస్తుంది మరియు మీరు ఇంత త్వరగా ఫలితాన్ని చూపుతుంది.

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

డేటా నిర్మాణాల రకాలు

డేటాతో సమర్ధవంతంగా పనిచేయడానికి ఉపయోగించే కొన్ని ప్రామాణిక డేటా నిర్మాణాలు ఉన్నాయి. మేము వాటిని అనుకూలీకరించవచ్చు లేదా మా అనువర్తనానికి అనుగుణంగా పూర్తిగా క్రొత్త వాటిని నిర్మించవచ్చు.

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

కొన్ని నిజ జీవిత ఉదాహరణలను పరిశీలించండి:

• సరుకు రవాణా
• ట్రేలో ప్లేట్లు
• నాణేల స్టాక్
• సొరుగుల స్టాక్
• రైల్వే యార్డ్‌లో రైళ్లను నిలిపివేయడం

ఈ ఉదాహరణలన్నీ a లాస్ట్-ఇన్-ఫస్ట్-అవుట్ వ్యూహం. ఒక ట్రేలో ప్లేట్లను పరిగణించండి, మీరు ఒక ప్లేట్ ఎంచుకోవాలనుకున్నప్పుడు మీరు పైనుండి ఒక ప్లేట్ తీయవలసి వస్తుంది, అయితే ప్లేట్లు ట్రేలో ఉంచినప్పుడు అవి రివర్స్ ఆర్డర్‌లో ఉండాలి. అనుసరించే ఉదాహరణలు పైన లాస్ట్-ఇన్-ఫస్ట్-అవుట్ (LIFO) సూత్రం అంటారు స్టాక్ .

పరిపూరకరమైన కార్యకలాపాలు కాకుండా, స్టాక్‌లో సాధ్యమయ్యే ప్రధాన కార్యకలాపాలు:

1. స్టాక్ పైభాగానికి ఒక మూలకాన్ని నొక్కండి లేదా చొప్పించండి
2. స్టాక్ ఎగువ నుండి ఒక మూలకాన్ని పాప్ చేయండి లేదా తొలగించండి

స్టాక్ డేటా నిర్మాణాన్ని సృష్టిస్తోంది

తరగతి స్టాక్: డెఫ్ __ఇనిట్ __ (సెల్ఫ్, మాక్స్_సైజ్): సెల్ఫ్ .__ మాక్స్_సైజ్ = మాక్స్_సైజ్ సెల్ఫ్ .__ ఎలిమెంట్స్ = [ఏదీ లేదు] * సెల్ఫ్ .__ మాక్స్_సైజ్ సెల్ఫ్ .__ టాప్ = -1

• గరిష్ట_ పరిమాణం స్టాక్‌లో ఆశించిన మూలకాల గరిష్ట సంఖ్య.
• స్టాక్ యొక్క అంశాలు పైథాన్ జాబితాలో నిల్వ చేయబడతాయి.
• టాప్ స్టాక్ యొక్క అగ్రశ్రేణి సూచికను సూచిస్తుంది, ఇది ప్రారంభంలో ఖాళీ స్టాక్‌ను గుర్తించడానికి -1 తీసుకుంటుంది.

స్టాక్ యొక్క ప్రారంభ స్థితిని మాక్స్_సైజ్ = 5 ఉన్న చిత్రంలో చూడవచ్చు

ఎలిమెంట్‌ను స్టాక్‌లోకి నెట్టండి

ఇప్పుడు, మీరు మూలకాన్ని ఎంటర్ చేయాలనుకుంటే లేదా స్టాక్‌కు నెట్టాలనుకుంటే, మీరు దానిని గుర్తుంచుకోవాలి

• మూలకం చొప్పించబడే సూచికను పైభాగం చూపుతుంది.
• మరియు స్టాక్ నిండినప్పుడు ఏ మూలకం చేర్చబడదు, అంటే max_size = top ఉన్నప్పుడు.

కాబట్టి అల్గోరిథం ఎలా ఉండాలి ??

# స్టాక్ యొక్క గరిష్ట పరిమాణాన్ని తిరిగి ఇస్తుంది get_max_size (self): స్వీయ తిరిగి .__ max_size # స్టాక్ నిండి ఉందో లేదో బూల్ విలువను తిరిగి ఇస్తుంది, పూర్తి అయితే తప్పు మరియు తప్పు లేకపోతే def is_full (self): return self.get_max_size () - 1 == స్వీయ .__ టాప్ # స్టాక్ డెఫ్ పుష్ (సెల్ఫ్, డేటా) పైభాగంలో మూలకాన్ని పుష్ చేస్తుంది: if (self.is_full ()): ప్రింట్ ('స్టాక్ ఇప్పటికే నిండి ఉంది') వేరే: స్వయం .__ టాప్ = సెల్ఫ్ .__ టాప్ + పూర్ణాంకం (1 ) self .__ మూలకాలు [self .__ top] = data # మీరు డీఫ్ __str __ (self) ను డీబగ్ చేసేటప్పుడు DS ఆబ్జెక్ట్ యొక్క మూలకాలను ముద్రించడానికి దిగువ __str __ () ను ఉపయోగించవచ్చు: msg = [] index = self .__ top అయితే (index> = 0): msg.append ((str) (self .__ element [index])) index- = 1 msg = ''. చేరండి (msg) msg ​​= 'స్టాక్ డేటా (పై నుండి దిగువకు):' + msg return msg

ఇప్పుడు, మీరు ఈ క్రింది వాటిని అమలు చేసినప్పుడు:

stack1 = స్టాక్ (4)

# అవసరమైన అన్ని మూలకాలను (ల) నొక్కండి.

stack1.push (“A”)

stack1.push (“B”)

stack1.push (“C”)

stack1.push (“E”)

ముద్రణ (stack1.is_full ())

ముద్రణ (స్టాక్ 1)

అవుట్పుట్:

స్టాక్ ఇప్పటికే నిండి ఉంది
నిజం
డేటా స్టాక్ (పై నుండి దిగువ వరకు): D C B A.

స్టాక్ నుండి పాప్ ఎలిమెంట్స్

ఇప్పుడు, మీరు మూలకాలను స్టాక్‌లోకి చేర్చినట్లుగా, మీరు వాటిని పాప్ చేయాలనుకుంటున్నారు, కాబట్టి మీరు ఈ క్రింది వాటిని జాగ్రత్తగా చూసుకోవాలి:

• స్టాక్ ఖాళీగా లేదు అంటే టాప్! = -1
• మీరు డేటాను తొలగించినప్పుడు, పైభాగం స్టాక్ యొక్క మునుపటి పైభాగానికి సూచించాలి.

కాబట్టి, అల్గోరిథం ఎలా ఉంటుంది ??

# స్టాక్ ఖాళీగా ఉందో లేదో బూల్ విలువను అందిస్తుంది, ఖాళీగా ఉంటే ట్రూ మరియు తప్పు లేకపోతే డెఫ్ is_empty (నేనే): స్వయంగా తిరిగి .__ top == - 1 # పాప్ చేసిన విలువ డెఫ్ పాప్ (స్వీయ) ను తిరిగి ఇస్తుంది: if (self.is_empty ()): ప్రింట్ ('పాప్ చేయడానికి ఏమీ లేదు, ఇప్పటికే ఖాళీగా ఉంది') వేరే: a = self .__ ఎలిమెంట్స్ [సెల్ఫ్ .__ టాప్] సెల్ఫ్ .__ టాప్ = సెల్ఫ్ .__ టాప్ -1 రిటర్న్ # # అన్ని స్టాక్ ఎలిమెంట్లను పై నుండి క్రిందికి డెఫ్ డిస్ప్లే (సెల్ఫ్) ప్రదర్శించండి: నేను పరిధిలో (స్వీయ .__ టాప్, -1, -1): ప్రింట్ (స్వీయ .__ అంశాలు [i], ముగింపు = '') ముద్రణ ()

ఇప్పుడు, గతంలో సృష్టించిన స్టాక్‌ను పరిశీలిస్తే, అంశాలను పాప్ చేయడానికి ప్రయత్నించండి

ముద్రణ (stack1.pop ())

ముద్రణ (stack1.pop ())

ముద్రణ (స్టాక్ 1)

ముద్రణ (stack1.pop ())

ముద్రణ (stack1.pop ())

ముద్రణ (stack1.pop ())

అవుట్పుట్:

డి

సి

డేటా స్టాక్ (పై నుండి దిగువ వరకు): B A.

బి

TO

పాప్ చేయడానికి ఏమీ లేదు, ఇప్పటికే ఖాళీగా ఉంది

c ++ గోటో లైన్

స్టాక్ డేటా నిర్మాణం యొక్క అనువర్తనాలు

• ఉదాహరణ 1:

అంకగణిత వ్యక్తీకరణ మూల్యాంకనం కోసం బ్రాకెట్ మ్యాచింగ్ అల్గోరిథంను అమలు చేయడానికి మరియు పద్ధతి కాల్స్ అమలులో కూడా ఒక స్టాక్ ఉపయోగించబడుతుంది.

దీనికి సమాధానం 5.

• ఉదాహరణ 2:

విండోస్‌లో క్లిప్‌బోర్డ్ చర్యరద్దు-పునరావృతం (ctrl + z, ctrl + y) ఆపరేషన్లను అమలు చేయడానికి రెండు స్టాక్‌లను ఉపయోగిస్తుంది. మీరు MS-Word, నోట్‌ప్యాడ్ వంటి విండోస్ వర్డ్ ఎడిటర్‌లలో పని చేసేవారు. ఇక్కడ ఒక టెక్స్ట్ MS-Word లో వ్రాయబడింది. Ctrl-Z మరియు Ctrl-Y క్లిక్‌లో టెక్స్ట్ ఎలా మారిందో గమనించండి.

చర్యను అన్డు-పునరావృతం చేసే అనుకరణ కోడ్ ఇక్కడ ఉంది. కోడ్ ద్వారా వెళ్లి ఈ అమలులో స్టాక్ ఎలా ఉపయోగించబడుతుందో గమనించండి.

# క్రియేటింగ్ క్లాస్ స్టాక్ క్లాస్ స్టాక్: డెఫ్ __ఇనిట్ __ (సెల్ఫ్, మాక్స్_సైజ్): సెల్ఫ్ .__ మాక్స్_సైజ్ = మాక్స్_సైజ్ సెల్ఫ్ .__ ఎలిమెంట్స్ = [ఏదీ లేదు] * సెల్ఫ్ .__ మాక్స్_సైజ్ సెల్ఫ్. self .__ max_size-1): రిటర్న్ ట్రూ రిటర్న్ ఫాల్స్ డెఫ్ is_empty (self): if (self .__ top == - 1): రిటర్న్ రిటర్న్ రిటర్న్ ఫాల్స్ డెఫ్ పుష్ (సెల్ఫ్, డేటా): if (self.is_full ()): ప్రింట్ ('స్టాక్ నిండింది !!') else: self .__ top + = 1 self .__ మూలకాలు [self .__ top] = data def pop (self): if (self.is_empty ()): print ('స్టాక్ ఖాళీగా ఉంది! ! ') else: data = self .__ మూలకాలు [self .__ top] self .__ top- = 1 return data def display (self): if (self.is_empty ()): print (' స్టాక్ ఖాళీగా ఉంది ') else: index = స్వీయ .__ టాప్ అయితే (ఇండెక్స్> = 0): ప్రింట్ (సెల్ఫ్ .__ ఎలిమెంట్స్ [ఇండెక్స్]) ఇండెక్స్- = 1 డెఫ్ గెట్_మాక్స్_సైజ్ (సెల్ఫ్): సెల్ఫ్ రిటర్న్ .__ మాక్స్_సైజ్ # మీరు దిగువ __str __ () ను మూలకాల యొక్క మూలకాలను ముద్రించడానికి ఉపయోగించవచ్చు. డీబ్ డీబగ్ చేస్తున్నప్పుడు DS ఆబ్జెక్ట్: __str __ (self): msg = [] index = self .__ top అయితే (index> = 0): msg.append ((str) (self .__ element [index])) index- = 1 msg = ' '. చేరండి (msg) msg ​​=' డేటాను స్టాక్ చేయండి (పై నుండి దిగువకు): '+ msg return ms g # అమలు తొలగించడానికి లేదా బ్యాక్‌స్పేస్ ఆపరేషన్ డెఫ్ తొలగించు (): గ్లోబల్ క్లిప్‌బోర్డ్, అన్డో_స్టాక్ డేటా = క్లిప్‌బోర్డ్ [లెన్ (క్లిప్‌బోర్డ్) -1] క్లిప్‌బోర్డ్.రెమోవ్ (డేటా) undo_stack.push (డేటా) ముద్రణ ('తొలగించు:', క్లిప్‌బోర్డ్) చర్యను అన్డు చేయటానికి # ఫంక్షన్ డెఫ్ అన్డు (): గ్లోబల్ క్లిప్‌బోర్డ్, అన్డు_స్టాక్, రీడో_స్టాక్ ఉంటే (అన్డు_స్టాక్.ఇస్_ఎంప్టీ ()): ప్రింట్ ('అన్డు చేయడానికి డేటా లేదు') వేరే: డేటా = అన్డో_స్టాక్.పాప్ () క్లిప్‌బోర్డ్.అప్పెండ్ ( డేటా) redo_stack.push (డేటా) ముద్రణ ('అన్డు:', క్లిప్‌బోర్డ్) # ఆపరేషన్ పునరావృత ఆపరేషన్ డెఫ్ పునరావృతం (): గ్లోబల్ క్లిప్‌బోర్డ్, అన్డు_స్టాక్, రీడో_స్టాక్ ఉంటే (redo_stack.is_empty ()): ప్రింట్ ('డేటా లేదు పునరావృతం చేయడానికి ') else: data = redo_stack.pop () if (డేటా క్లిప్‌బోర్డ్‌లో లేదు): ప్రింట్ (' పునరావృతం చేయడానికి డేటా లేదు ') redo_stack.push (డేటా) వేరే: clipboard.remove (డేటా) undo_stack.push ( డేటా) ముద్రణ ('పునరావృతం:', క్లిప్‌బోర్డ్) క్లిప్‌బోర్డ్ = ['A', 'B', 'C', 'D', 'E', 'F'] undo_stack = స్టాక్ (లెన్ (క్లిప్‌బోర్డ్)) redo_stack = స్టాక్ (లెన్ (క్లిప్‌బోర్డ్)) తొలగించు () అన్డు () పునరావృతం ()

అవుట్పుట్:

తొలగించు: [‘A’, ‘B’, ‘C’, ‘D’, ‘E’]

అన్డు: [‘ఎ’, ‘బి’, ‘సి’, ‘డి’, ‘ఇ’, ‘ఎఫ్’]

పునరావృతం: [‘A’, ‘B’, ‘C’, ‘D’, ‘E’]

దీనితో, పైథాన్ వ్యాసంలో ఈ స్టాక్ డేటా స్ట్రక్చర్ ముగింపుకు వచ్చాము. మీరు మీరే కోడ్‌లను విజయవంతంగా అర్థం చేసుకుని, అమలు చేస్తే, మీరు ఇకపై స్టాక్స్ డేటా స్ట్రక్చర్‌కు క్రొత్తవారు కాదు.

మాకు ప్రశ్న ఉందా? దయచేసి ఈ వ్యాసం యొక్క వ్యాఖ్యల విభాగంలో దీనిని ప్రస్తావించండి మరియు మేము వీలైనంత త్వరగా మిమ్మల్ని సంప్రదిస్తాము.

పైథాన్‌తో పాటు దాని వివిధ అనువర్తనాలతో లోతైన జ్ఞానం పొందడానికి, మీరు ప్రత్యక్ష ప్రసారం కోసం నమోదు చేసుకోవచ్చు 24/7 మద్దతు మరియు జీవితకాల ప్రాప్యతతో.