Ang wika ng programa sa Python ay isang wikang bukas-pinagmulan na may iba't ibang mga pagpapatupad na nasa labas ng kahon na ginagawang natatangi at madaling matuto. Kahit na ay hindi sumusuporta sa konsepto ng isang naka-link na listahan, mayroong isang paraan sa paligid nito sa pamamagitan ng isang iba't ibang pagpapatupad upang makakuha ng isang naka-link na listahan. Sa artikulong ito, malalaman natin kung paano tayo makakagawa ng isang naka-link na listahan sa Python. Ang sumusunod ay ang mga paksang sakop sa blog na ito:
- Ano ang Listahan ng Naka-link?
- Pagpapatupad ng isang Listahang Naka-link
- Mga pamamaraan ng listahan ng naka-link
Magsimula na tayo !!
Ano ang Listahan ng Naka-link?
Ang listahan ng link ay isang pagkakasunud-sunod ng mga node na nagkakaroon ng katulad na uri ng data, ang bawat node ay naglalaman ng isang data object at pointer sa susunod na node.
Ang isang naka-link na listahan ay isang linear na istraktura ng data na may koleksyon ng maraming mga node. Kung saan eNag-iimbak ang elemento ng ach ng sarili nitong data at isang pointer sa lokasyon ng susunod na elemento. Ang huling link sa isang naka-link na listahan ay tumuturo sa null, na nagpapahiwatig ng pagtatapos ng kadena. Ang isang elemento sa isang naka-link na listahan ay tinatawag na a node . Ang unang node ay tinawag na ulo .Ang huling node ay tinawagang buntot .
Ang karaniwang library ng sawa ay walang naka-link na listahan. Maaari naming ipatupad ang konsepto ng listahan ng data ng listahan ng link sa pamamagitan ng paggamit ng konsepto ng mga node.
Ngayong nalaman namin ang tungkol sa kung Ano ang Naiugnay. Kaya't magpatuloy tayo sa pagpapatupad ng isang listahan ng Naka-link.
Pagpapatupad ng isang Listahang Naka-link
Para sa paglikha ng isang Naka-link na Listahan, lumilikha kami ng isang node object at lumikha ng isa pang klase upang magamit ang node object na ito.
Code para sa paglikha ng klase ng Node.
Lumilikha ang programa sa itaas ng isang naka-link na listahan na may tatlong elemento ng data.
class Node (object): # Consumeror to initilize class variable variable def __init __ (self, data = Wala, next_node = Wala): self.data = data self.next_node = next_node #get data def get_data (self): return self.data # makakuha ng susunod na halaga def get_next (sarili): ibalik ang self.next_node # itakda ang susunod na data def set_next (sarili, new_next): self.next_node = new_next
Ang pagpapatupad ng listahan ng link ay binubuo ng mga sumusunod na pag-andar sa isang naka-link na listahan
isa Isingit : Ang pamamaraang ito ay magpapasok ng isang bagong node sa isang naka-link na listahan.
2. Sukat : Ibabalik ng pamamaraang ito ang laki ng naka-link na listahan.
3. Maghanap : Ang pamamaraang ito ay magbabalik ng isang node na naglalaman ng data, kung hindi man ay magtataas ng isang error
Apat. Tanggalin : Tatanggalin ng pamamaraang ito ang isang node na naglalaman ng data, kung hindi man ay magtataas ng isang error
Hinahayaan nating tingnan ang listahan ng Mga Paraan ng Naka-link
kung paano wakasan ang isang programang java
Paunang pamamaraan sa isang naka-link na listahan
klase LinkedList (object): def __init __ (sarili, ulo = Wala): self.head = ulo
Ginamit ang paunang pamamaraan para sa pagsisimula ng a klase variable kung ang listahan ay walang mga node itinakda ito sa wala.
Ipasok:
def insert (sarili, data): new_node = Node (data) new_node.set_next (self.head) self.head = new_node
Ang pamamaraan ng insert na ito ay tumatagal ng data, pinasimulan ang isang bagong node na may ibinigay na data, at idinagdag ito sa listahan. Teknikal na maaari mong ipasok ang isang node saanman sa listahan, ngunit ang pinakasimpleng paraan upang gawin ito ay upang ilagay ito sa pinuno ng listahan at ituro ang bagong node sa lumang ulo (uri ng pagtulak sa iba pang mga node sa linya).
Sukat
# Ibinabalik ang kabuuang bilang ng node sa laki ng listahan ng def (sarili): kasalukuyang = self.head count = 0 habang kasalukuyang: count + = 1 kasalukuyang = kasalukuyang.get_next () bilang ng pagbalik
Napakadali ng pamamaraan ng laki, talagang binibilang nito ang mga node hanggang hindi na ito makita, at ibabalik kung gaano karaming mga node ang nahanap nito. Nagsisimula ang pamamaraan sa head node, bumibiyahe pababa sa linya ng mga node hanggang sa maabot ang dulo (ang kasalukuyang magiging Wala kapag umabot ito sa dulo) habang sinusubaybayan kung gaano karaming mga node ang nakita nito.
Maghanap
halimbawa ng mga object ng java
# Ibinabalik ang node sa listahan na mayroong nodeData, naganap ang error kung wala ang node sa paghahanap ng def (sarili, nodeData): kasalukuyang = self.head isPresent = Maling habang kasalukuyang at isPresent ay Mali: kung kasalukuyang.get_data () == nodeData: isPresent = Totoo pa: kasalukuyang = kasalukuyang.get_next () kung ang kasalukuyang wala: taasan ang ValueError ('Wala ang data sa listahan') bumalik kasalukuyangAng paghahanap ay talagang katulad sa laki, ngunit sa halip na daanan ang buong listahan ng mga node ay sinusuri nito ang bawat hintuan upang makita kung ang kasalukuyang node ay may hiniling na data. Kung gayon, ibabalik ang node na humahawak sa data na iyon. Kung ang pamamaraan ay dumaan sa buong listahan ngunit hindi pa rin natagpuan ang data, tataas ito ng isang error sa halaga at aabisuhan sa gumagamit na ang data ay wala sa listahan.
Tanggalin
# Tanggalin ang node mula sa naka-link na listahan ay nagbabalik ng error kung wala ang node sa def delete (sarili, nodeData): kasalukuyang = self.head nakaraang = Wala angPresenta = Mali habang kasalukuyan at isPresent ay Mali: kung kasalukuyang.get_data () == nodeData: isPresent = True else: nakaraang = kasalukuyang kasalukuyan = kasalukuyang.get_next () kung kasalukuyang wala, taasan ang ValueError ('Wala ang data sa listahan') kung nauna ay Wala: self.head = current.get_next () iba pa: nakaraang.set_next ( kasalukuyang.get_next ())Ang pamamaraan ng tanggalin ay binabagtas ang listahan sa parehong paraan ng paghahanap, ngunit bilang karagdagan sa pagsubaybay sa kasalukuyang node, naaalala din ng pamamaraan na tanggalin ang huling node na binisita. Kapag ang pagtanggal sa wakas ay dumating sa node nais nitong tanggalin. Tinatanggal lamang nito ang node mula sa kadena sa pamamagitan ng 'leapfrogging' ito.
Sa pamamagitan nito ay nangangahulugan ako na kapag naabot ng paraan ng tanggalin ang node na nais nitong tanggalin, tinitingnan nito ang huling node na binisita nito (ang 'dating' node) at itinatakda muli ang pointer ng nakaraang node. Sa halip na ituro ang malapit nang matanggal na node.
Ituturo nito ang susunod na node sa linya. Dahil walang mga node na tumuturo sa mahirap na node na tinatanggal, epektibo itong tinanggal mula sa listahan!
Dinadala nito sa amin ang katapusan ng artikulong ito kung saan natutunan namin kung paano kami makakagawa ng isang naka-link na listahan sa sawa na may katulad na pagpapatupad kahit na ang python ay hindi talaga sumusuporta sa konsepto ng isang naka-link na listahan. Inaasahan kong malinaw ka sa lahat ng naibahagi sa iyo sa tutorial na ito.
Kung nahanap mo ang artikulong ito sa 'Naka-link na Lista Sa Python' na may kaugnayan, tingnan ang Ang isang pinagkakatiwalaang kumpanya sa online na pag-aaral na may isang network ng higit sa 250,000 nasiyahan na mga nag-aaral na kumalat sa buong mundo.
Narito kami upang matulungan ka sa bawat hakbang sa iyong paglalakbay at magkaroon ng isang kurikulum na idinisenyo para sa mga mag-aaral at propesyonal na nais na maging . Ang kurso ay dinisenyo upang bigyan ka ng isang panimula sa Python program at sanayin ka para sa parehong core at advanced na mga konsepto ng Python kasama ang iba't ibang katulad
Kung may nahahanap kang anumang mga katanungan, huwag mag-atubiling tanungin ang lahat ng iyong mga katanungan sa seksyon ng mga komento ng 'Naka-link na Lista Sa Python' at ang aming koponan ay nalulugod na sagutin.