Hva er stabildatastrukturer i Python?

Datastrukturer er en samling av dataverdier, forholdet mellom dem og funksjonene eller operasjonene som kan brukes på dataene. Nå er det mange datastrukturer tilgjengelig. Men i dag vil vårt fokus være på stabildatastrukturer. Jeg skal diskutere følgende emner:

• Hvorfor datastrukturer?
• Typer datastrukturer
• Hva er Stack Datastruktur?
• Opprette stabeldatastruktur
• Skyv elementene i stakken
• Popelementer fra Stack
• Anvendelser av stabeldatastruktur

Hvorfor datastrukturer?

For å svare på dette må du tenke på et stort nivå. Tenk hvordan Google maps viser deg den beste ruten på bare en brøkdel av sekunder, hvordan den gir deg søkeresultatet i mikrosekunder. Den håndterer ikke bare 100 nettsteder, den handler med mer enn en milliard nettsteder og viser deg fortsatt resultatet så raskt.

Vel, selv om algoritmen som brukes spiller en avgjørende rolle, er datastrukturen eller beholderen som brukes grunnlaget for den algoritmen. I alle applikasjoner er organisering og lagring av data på en måte eller i en struktur som er best egnet for bruk, nøkkelen til effektiv tilgang og behandling av data.

Typer datastrukturer

Det er noen standard datastrukturer som kan brukes til å jobbe effektivt med data. Vi kan til og med tilpasse dem eller bygge helt nye som passer til vår applikasjon.

Hva er Stack Datastruktur?

Tenk på noen virkelige eksempler:

• Forsendelse i last
• Plater på et brett
• Bunt med mynter
• Bunke med skuffer
• Rangering av tog i et jernbanetun

Alle disse eksemplene følger a Last-In-First-Out strategi. Tenk på tallerkener på et brett. Når du ønsker å plukke en tallerken, må du plukke en tallerken fra toppen, mens når platene ble holdt på brettet, må de være i omvendt rekkefølge. Ovenfor eksempler som følger Last-in-First-Out (LIFO) prinsippet er kjent som Stable .

Bortsett fra de komplementære operasjonene, kan jeg si at de viktigste operasjonene som er mulige på stabelen er:

1. Skyv eller sett inn et element på toppen av bunken
2. Popp eller fjern et element fra toppen av bunken

Opprette stabeldatastruktur

class Stack: def __init __ (self, max_size): self .__ max_size = max_size self .__ elements = [None] * self .__ max_size self .__ top = -1

• maks. størrelse er det maksimale antall elementer som forventes i bunken.
• Elementer av stabelen er lagret i pythonlisten.
• Topp indikerer den øverste indeksen til stakken som først ble tatt -1 for å markere tom stabel.

Den opprinnelige statusen til Stack kan sees i figuren hvor max_size = 5

Skyv elementet inn i stakken

Nå, hvis du vil legge inn eller skyve elementet til bunken, må du huske det

• Toppen peker indeksen elementet skal settes inn i.
• Og at ingen elementer vil bli satt inn når bunken er full, dvs. når max_size = topp.

Så hva skal algoritmen være ??

# returnerer maksimal størrelse på stabelen def get_max_size (self): returner selv .__ max_size # returnerer bool-verdi om stacken er full eller ikke, True hvis full og False ellers def is_full (self): return self.get_max_size () - 1 == self .__ top #pushes element øverst på stack def push (self, data): if (self.is_full ()): print ('stack is already full') ellers: self .__ top = self .__ top + int (1 ) self .__ elements [self .__ top] = data #Du kan bruke nedenstående __str __ () til å skrive ut elementene til DS-objektet mens du feilsøker def __str __ (self): msg = [] index = self .__ top while (index> = 0): msg.append ((str) (self .__ elements [index])) index- = 1 msg = ''. Join (msg) msg ​​= 'Stack data (Top to Bottom):' + msg return msg

Nå, når du utfører følgende:

java hva er en forekomst

stack1 = Stack (4)

#Trykk alle nødvendige element (er).

stack1.push (“A”)

stack1.push (“B”)

stack1.push (“C”)

stack1.push (“E”)

skriv ut (stack1.is_full ())

skriv ut (stack1)

Produksjon:

stabelen er allerede full
ekte
Stakkdata (topp til bunn): D C B A

Popelementer fra Stack

Nå som du har satt inn elementene i bunken, vil du pope dem, så du må ta vare på følgende:

• Stakken er ikke tom, dvs. topp! = -1
• Når du sletter dataene, må toppen peke til forrige topp i bunken.

Så, hva blir algoritmen ??

#returns bool-verdi, enten stack er tom eller ikke, True hvis tom og False ellers def er_empty (self): return self .__ top == - 1 #returns popped value def pop (self): if (self.is_empty ()): skriv ut ('ingenting å poppe, allerede tomt') annet: a = selv .__-elementer [selv .__ topp] selv .__ topp = selv .__ topp-1 returnerer et #display alle stabelelementene fra topp til bunn def-display (selv): for jeg i rekkevidde (selv .__ topp, -1, -1): utskrift (selv .__ elementer [i], slutt = '') utskrift ()

Nå, med tanke på tidligere opprettet stabel, kan du prøve å pope elementer

skriv ut (stack1.pop ())

skriv ut (stack1.pop ())

skriv ut (stack1)

skriv ut (stack1.pop ())

skriv ut (stack1.pop ())

skriv ut (stack1.pop ())

hva som er foranderlig og uforanderlig

Produksjon:

D

C

Stakkdata (topp til bunn): B A

B

TIL

konverter dobbelt til heltall i java

ingenting å poppe, allerede tomt

Anvendelser av stabeldatastruktur

• Eksempel 1:

En stabel brukes til å implementere braketttilpasningsalgoritme for aritmetisk uttrykksevaluering og også til implementering av metodeanrop.

Svaret som er 5.

• Eksempel 2:

Utklippstavle i Windows bruker to stabler for å implementere angre-omgjøring (ctrl + z, ctrl + y). Du ville ha jobbet med Windows-ordredigerere som MS-Word, Notepad osv. Her er en tekst skrevet i MS-Word. Observer hvordan teksten endret seg ved å klikke på Ctrl-Z og Ctrl-Y.

Her er en kode som simulerer angre-om-bruk. Gå gjennom koden og observer hvordan stakken brukes i denne implementeringen.

#creating class stack class Stack: def __init __ (self, max_size): self .__ max_size = max_size self .__ elements = [None] * self .__ max_size self .__ top = -1 def is_full (self): if (self .__ top == self .__ max_size-1): returner True return False def is_empty (self): if (self .__ top == - 1): return True Return False def push (self, data): if (self.is_full ()): print ('Stakken er full !!') annet: selv .__ topp + = 1 selv .__ elementer [selv .__ topp] = data def pop (selv): hvis (self.is_empty ()): skriv ut ('Bunken er tom! ! ') annet: data = selv .__-elementer [selv .__ topp] selv .__ topp- = 1 return data def display (self): if (self.is_empty ()): print (' Stacken er tom ') annet: index = self .__ topp mens (index> = 0): print (self .__ elements [index]) index- = 1 def get_max_size (self): return self .__ max_size #You can use the below __str __ () to print the elements of the DS-objekt mens feilsøking def __str __ (selv): msg = [] indeks = selv .__ topp mens (indeks> = 0): msg.append ((str) (selv .__ elementer [indeks])) indeks- = 1 msg = ' '.join (msg) msg ​​=' Stabeldata (topp til bunn): '+ msg return ms g #function to implement remove or backspace operation def remove (): global utklippstavle, angre_stack data = utklippstavle [len (utklippstavle) -1] utklippstavle. fjern (data) undo_stack.push (data) skriv ut ('Fjern:', utklippstavle) #funksjon for å implementere angre operasjon def angre (): globalt utklippstavle, angre_stakk, gjenta_stakk hvis (angre_stack.is_empty ()): skriv ut ('Det er ingen data å angre') annet: data = angre_stack.pop () utklippstavle.append ( data) redo_stack.push (data) print ('Angre:', utklippstavle) #funksjon for å implementere redo operation def redo (): global utklippstavle, angre_stack, redo_stack hvis (redo_stack.is_empty ()): skriv ut ('Det er ingen data å gjøre om ') annet: data = gjør om_stack.pop () hvis (data ikke i utklippstavlen): skriv ut (' Det er ingen data å gjøre om ') redo_stack.push (data) annet: utklippstavle. fjern (data) angre_stack.push ( data) print ('Gjør om:', utklippstavle) utklippstavle = ['A', 'B', 'C', 'D', 'E', 'F'] undo_stack = Stack (len (utklippstavle)) redo_stack = Stack (len (utklippstavle)) fjern () angre () gjør om ()

Produksjon:

Fjern: [‘A’, ‘B’, ‘C’, ‘D’, ‘E ']

Angre: ['A', 'B', 'C', 'D', 'E', 'F']

Gjør om: ['A', 'B', 'C', 'D', 'E']

Med dette kommer vi til en slutt på denne stack-datastrukturen i Python-artikkelen. Hvis du med suksess har forstått og kjørt kodene, er du ikke lenger en nybegynner for Stacks Datastruktur.

Har du spørsmål til oss? Vennligst nevn det i kommentarfeltet i denne artikkelen, og vi vil kontakte deg så snart som mulig.

For å få grundig kunnskap om Python sammen med de forskjellige applikasjonene, kan du registrere deg for live med 24/7 support og levetidstilgang.