DOUG LLOYD: ასე რომ, თუ თქვენ ვუყურე ვიდეო დასტის,
ეს არის ალბათ აპირებს გრძნობს , ცოტა deja vu.
ის აპირებს ძალიან მსგავსი კონცეფცია, მხოლოდ უმნიშვნელო ბედის შესახებ მას.
ჩვენ ვაპირებთ, რომ გაიგო, ახლა რიგები.
ასე რომ რიგში, მსგავსი დასტის, სხვა სახის მონაცემები სტრუქტურა
რომ ჩვენ შეგვიძლია გამოვიყენოთ, რომ შევინარჩუნოთ მონაცემთა ორგანიზებულად.
მსგავსი დასტის, ეს შეიძლება განხორციელდეს
მასივი ან უკავშირდება სიაში.
განსხვავებით დასტის, წესები რომ ჩვენ ვიყენებთ, რათა დადგინდეს,
როდესაც რამ მისაღებად დასძინა და ამოღებულ მდგომ ცოტა განსხვავებული.
>> განსხვავებით დასტის, რომელიც არის LIFO სტრუქტურა,
გაგრძელდება, პირველი გარეთ, მდგომ არის FIFO სტრუქტურა, FIFO, პირველი, პირველი გარეთ.
ახლა რიგები, ალბათ, აქვს ანალოგი რიგები.
თუ თქვენ ოდესმე ყოფილა ხაზი გასართობი პარკი ან ბანკი,
არ არის ერთგვარი სამართლიანობის ახორციელებს სტრუქტურა.
პირველი პირი ხაზს ბანკი პირველი პირი
ვინც იღებს საუბარი მთხრობელი.
>> ეს იქნება ერთგვარი რასის ბოლოში თუ ერთადერთი გზა
თქვენ გაქვთ საუბარი მთხრობელი ზე საბანკო იყო ბოლო პირი ხაზი.
ყველას ყოველთვის გვინდა იქნება ბოლო პირი ხაზი,
და პირი, რომელიც იქ იყო პირველი რომელიც ელოდება, ხოლო,
შეიძლება იყოს იქ საათობით, და საათი და საათი
მათ აქვთ შანსი რეალურად გააუქმოს ნებისმიერი ფული ბანკში.
ასე რომ რიგები ერთგვარი სამართლიანობის განხორციელების სტრუქტურა.
მაგრამ ეს არ ნიშნავს იმას, რომ stacks არის ცუდი რამ, ისევე,
რომ რიგები კიდევ ერთი გზა ამის გაკეთება.
ასე რომ კიდევ ერთხელ მდგომ არის პირველი, პირველი გარეთ, წინააღმდეგ მილით, რომელიც გაგრძელდება,
პირველი გარეთ.
მსგავსი დასტის, ჩვენ გვაქვს ორი ოპერაცია
რომ ჩვენ შეუძლია შეასრულოს რიგები.
სახელები enqueue, რომელიც დაამატოთ ახალი ელემენტი ბოლომდე მდგომ,
და dequeue, რომელიც ამოიღონ უძველესი
ელემენტის საწყისი წინაშე მდგომ.
ასე რომ, ჩვენ ვაპირებთ, რომ დაამატოთ ელემენტები გადატანა ბოლოს მდგომ,
და ჩვენ ვაპირებთ, რომ ამოიღონ ელემენტების საწყისი წინაშე მდგომ.
ისევ და ისევ, დასტის, ჩვენ დასძინა ელემენტები ზევით დასტის
და მოხსნის ელემენტები ზემოდან Stack.
ასე რომ, enqueue, ის დასძინა, რომ ბოლოს და ბოლოს, მოხსნის წინ.
ასე რომ, უძველესი რამ არ ყოველთვის შემდეგი რამ
გამოვიდეთ თუ ჩვენ ვცდილობთ და dequeue რაღაც.
>> ასე რომ, კიდევ ერთხელ, რიგები, ჩვენ შეგვიძლია მასივი დაფუძნებული შესრულება
და დაკავშირებული სიაში დაფუძნებული შესრულება.
ჩვენ დავიწყებთ ისევ მასივი დაფუძნებული შესრულება.
სტრუქტურა განმარტება გამოიყურება საკმაოდ მსგავსია.
ჩვენ გვაქვს კიდევ ერთი მასივი არსებობს მონაცემები ტიპის ღირებულება,
ასე რომ, მას შეუძლია გამართავს თვითნებური მონაცემთა ტიპები.
ჩვენ კიდევ ერთხელ აპირებს გამოიყენოს რიცხვებით ამ მაგალითს.
>> და ისევე, როგორც ჩვენი მასივი დაფუძნებული დასტის განხორციელება,
იმიტომ, რომ ჩვენ გამოყენებით მასივი, ჩვენ აუცილებლად
უნდა, რომ შეზღუდვა, რომ C სახის საქართველოს აღმასრულებელთა ჩვენზე, რომელიც ჩვენ
არ აქვს რაიმე დინამიზმის ჩვენი უნარი იზრდება და მცირდება მასივი.
ჩვენ უნდა გადაწყვიტოს დასაწყისში რა არის მაქსიმალური რაოდენობის ნივთები
რომ ჩვენ შეგვიძლია შევიდა ამ მდგომ, და ამ შემთხვევაში,
სიმძლავრე იქნება რამდენიმე ფუნტი განსაზღვრული მუდმივი ჩვენს კოდი.
და ამ შეთანხმების მიზნებიდან ვიდეო, მოცულობა იქნება 10.
>> ჩვენ უნდა შევინარჩუნოთ სიმღერა წინაშე მდგომ
ასე რომ, ჩვენ ვიცით, რაც ელემენტი ჩვენ გვინდა dequeue,
ჩვენ ასევე უნდა შევინარჩუნოთ სიმღერა რაღაც else-- რაოდენობის ელემენტები
რომ ჩვენ გვაქვს ჩვენი რიგიდან.
ჩვენ არ შენახვა ტრეკზე ბოლოს მდგომ, უბრალოდ
ზომა მდგომ.
და მიზეზი, რომ იმედია გახდეს ცოტა ნათელი მომენტი.
მას შემდეგ, რაც ჩვენ უკვე დაასრულეს ამ ტიპის განმარტება,
ჩვენ გვაქვს ახალი მონაცემები ტიპის მოუწოდა მდგომ, რომელიც ჩვენ ახლა
განაცხადოს ცვლადები, რომ მონაცემები ტიპის.
და გარკვეულწილად confusingly, მე გადავწყვიტე დარეკეთ ამ მდგომ q, წერილი
q ნაცვლად მონაცემები ტიპის ქ.
>> ასე რომ, აქ არის ჩვენი რიგიდან.
ეს არის სტრუქტურა.
იგი შეიცავს სამ წევრს ან სამი სფეროებში, მასივი ზომა შესაძლებლობების.
ამ შემთხვევაში, მოცულობა არის 10.
და ამ მასივი გამართვას აპირებენ რიცხვებით.
მწვანე არის თვალწინ ჩვენი მდგომ, შემდეგი ელემენტს უნდა მოიხსნას, და წითელი
იქნება ზომა მდგომ, რამდენი ელემენტები ამჟამად
არსებული მდგომ.
ასე რომ, თუ ჩვენ ვამბობთ, q.front ტოლობის 0, და q.size ზომა ტოლია 0-
ჩვენ აყენებს 0s იმ სფეროებში.
და ამ ეტაპზე, ჩვენ საკმაოდ ბევრი მზად არის დაიწყოს მუშაობა ჩვენი რიგიდან.
>> ასე რომ, პირველი ოპერაციის ჩვენ შეგვიძლია ასრულებს enqueue რაღაც,
დაამატოთ ახალი ელემენტი ბოლოს მდგომ.
ისე, რა უნდა გავაკეთოთ ამის ზოგად შემთხვევაში?
ისე ამ ფუნქციის enqueue საჭიროებების მიიღოს მომცეთ ჩვენი რიგიდან.
ისევ და ისევ, თუ ჩვენ გამოაცხადა ჩვენი მდგომ გლობალურად,
ჩვენ არ უნდა გავაკეთოთ ეს აუცილებლად, მაგრამ ზოგადად, ჩვენ
უნდა მიიღოს მითითებას მონაცემთა სტრუქტურები
როგორც ეს, რადგან, წინააღმდეგ შემთხვევაში, ჩვენ ავლით value-- ჩვენ
გადადის ასლები მდგომ, და ამიტომ ჩვენ, ფაქტობრივად, არ იცვლება
მდგომ, რომ ჩვენ ვაპირებთ, რომ შეიცვალოს.
>> სხვა საქმეა, რომ ეს უნდა გააკეთოთ მიიღოს მონაცემთა ელემენტს შესაბამისი ტიპის.
ერთხელ, ამ შემთხვევაში, ეს იქნება მთელი რიცხვები,
მაგრამ თქვენ შეიძლება თვითნებურად განაცხადოს მონაცემები ტიპის, როგორც ღირებულება
და გამოიყენოს ეს ზოგადად.
რომ ელემენტს ჩვენ გვინდა enqueue, ჩვენ გვსურს, რომ ბოლომდე რიგიდან.
მაშინ ჩვენ რეალურად გვინდა განათავსეთ რომ მონაცემები რიგიდან.
ამ შემთხვევაში, დებს მას სწორი მდებარეობის ჩვენი მასივი,
და მაშინ ჩვენ გვინდა შეიცვალოს ზომა მდგომ, რამდენი ელემენტები ჩვენ
გაკეთებული აქვს.
>> მოდით დავიწყოთ.
აქ არის, კიდევ ერთხელ, რომ ზოგადად ფორმა ფუნქცია დეკლარაცია
რა enqueue შეიძლება გამოიყურებოდეს.
და აქ ჩვენ მივდივართ.
მოდით enqueue ნომერი 28 რიგიდან.
ასე რომ, რასაც ჩვენ ვაპირებთ, რომ გავაკეთოთ?
ისე, წინ ჩვენი მდგომ 0, და ზომა ჩვენი მდგომ
არის 0, და ამიტომ ჩვენ ალბათ სურთ დააყენა ნომერი 28 მასივი ელემენტს ნომერი
0, არა?
ასე რომ, ჩვენ ახლა განთავსებული, რომ არსებობს.
ასე რომ, ახლა რა უნდა შეიცვალოს?
ჩვენ არ გვინდა, რომ შეიცვალოს წინაშე მდგომ,
იმიტომ, რომ ჩვენ გვინდა ვიცოდეთ, რა ელემენტი ჩვენ შეიძლება უნდა dequeue შემდეგ.
ასე რომ, იმ მიზეზით, ჩვენ თვალწინ არსებობს არის ერთგვარი მაჩვენებელია, თუ რა არის
უძველესი რამ მასივი.
ისე უძველესი რამ მასივი in ფაქტია, რომ ერთადერთი რამ მასივი უფლება
ახლა კი არის 28, რომელიც არის განთავსებულია მასივი განთავსების 0.
ასე რომ, ჩვენ არ გვინდა, რომ შეიცვალოს, რომ მწვანე ნომერი,
იმიტომ, რომ ის უძველესი ელემენტს.
პირიქით, ჩვენ გვინდა, რომ შეიცვალოს ზომა.
ასე რომ, ამ შემთხვევაში, ჩვენ ნამატი ზომა 1.
>> ახლა ზოგადად გარკვეული იდეა, სადაც შემდეგი ელემენტს აპირებს წავიდეს მდგომ
რომ დაამატოთ ორი ნომრის ერთად, წინა და ზომა,
და რომ გითხრათ, სადაც შემდეგი ელემენტია რიგიდან აპირებს მისვლას.
ასე რომ, ახლა მოდით enqueue მეორე ნომერი.
მოდით enqueue 33.
ასე რომ, 33 აპირებს წასვლას მასივი განთავსების 0 + 1.
ასე რომ, ამ შემთხვევაში, ის აპირებს წასვლას მასივი ადგილმდებარეობა 1,
და ახლა ზომა ჩვენი მდგომ 2.
>> კიდევ ერთხელ, ჩვენ არ იცვლება წინა ჩვენი მდგომ,
იმის გამო, რომ 28 ჯერ კიდევ უძველესი ელემენტია, და ჩვენ
გსურთ, რომელთა მიზანია, როდესაც ჩვენ საბოლოოდ მისაღებად რომ dequeuing, მოხსნის ელემენტები
ამ რიგში, ჩვენ გვინდა ვიცოდეთ, სადაც უძველესი ელემენტი.
ასე რომ, ჩვენ ყოველთვის უნდა შეინარჩუნოს ზოგიერთი მაჩვენებელი, სადაც არ არის.
ასე რომ, რაც 0 არის იქ.
ეს არის ის, რაც წინ არის იქ.
>> მოდით ამ enqueue ერთი ელემენტი, 19.
დარწმუნებული ვარ, რომ თქვენ ვერ ვხვდები სადაც 19 აპირებს მისვლას.
ის აპირებს წასვლას მასივი ადგილმდებარეობა ნომერი 2.
სწორედ 0 plus 2.
ახლა ზომა ჩვენი მდგომ 3.
ჩვენ გვყავს 3 ელემენტები.
ასე რომ, თუ ჩვენ, და ჩვენ არ ვაპირებთ ახლავე, enqueue სხვა ელემენტს,
ეს იქნებოდა წასვლას მასივი ადგილმდებარეობა ნომერი 3, და ზომა ჩვენი მდგომ
იქნება 4.
ასე რომ, ჩვენ enqueued რამდენიმე ელემენტს ახლა.
ახლა დავიწყოთ ამოიღონ მათ.
მოდით dequeue მათ რიგიდან.
>> ასე რომ, მსგავსი პოპ, რომელიც არის ერთგვარი ანალოგი ამ stacks,
dequeue საჭიროებს მიიღოს მომცეთ მდგომ ერთხელ,
თუ ეს გლობალურად განაცხადა.
ახლა ჩვენ გვინდა შეიცვალოს მდებარეობა წინა რიგიდან.
ეს არის სადაც ეს ერთგვარი მოდის პიესა, რომ წინა ცვლადი,
იმიტომ, რომ ერთხელ ჩვენ ამოიღონ ელემენტს, ჩვენ გვინდა
გადატანა შემდეგი ძველი ელემენტს.
>> ამის შემდეგ ჩვენ გვინდა, რომ შემცირდეს ზომა მდგომ,
და მაშინ ჩვენ გვინდა დაბრუნების ღირებულება რომ ამოღებულ იქნა რიგი.
კიდევ ერთხელ, ჩვენ არ გვინდა, რომ უბრალოდ გაუქმება იგი.
ჩვენ, სავარაუდოდ, მოპოვების ეს მდგომ ჩვენ
dequeuing, რადგან ჩვენ აღელვებს მას.
ასე რომ ჩვენ გვინდა ამ ფუნქციის დაბრუნებას მონაცემთა ელემენტის ტიპი ღირებულება.
ერთხელ, ამ შემთხვევაში, მნიშვნელობა რიცხვი.
>> ახლა მოდით dequeue რაღაც.
მოდით ამოიღონ ელემენტს რიგიდან.
თუ ვიტყვით, int x უდრის & q, ampersand q-- კიდევ ერთხელ, რომ მომცეთ ამ q მონაცემები
სტრუქტურა რა ელემენტს იქნება dequeued?
ამ შემთხვევაში, იმიტომ, რომ ეს არის პირველი წელს, პირველი out მონაცემების სტრუქტურას, FIFO,
პირველი, რაც ჩვენ ამოქმედებული ეს მდგომ 28, და ასე რომ, ამ შემთხვევაში,
ჩვენ ვაპირებთ, რომ მიიღოს 28 out of მდგომ, არა 19, რაც
ჩვენ გავაკეთეთ, თუ ეს იყო Stack.
ჩვენ ვაპირებთ, რომ მიიღოს 28 out of მდგომ.
>> მსგავსი, რაც ჩვენ გავაკეთეთ დასტის, ჩვენ რეალურად არ
ვაპირებ წაშლა 28 რიგიდან თავად,
ჩვენ უბრალოდ აპირებს სახის საქართველოს ვიტყვი, რომ ეს არ არსებობს.
ასე რომ, ის აპირებს იქ მეხსიერება, მაგრამ ჩვენ მხოლოდ
აპირებს სახის იგნორირება მოძრავი სხვა ორი სფეროებში ჩვენი q მონაცემები
სტრუქტურა.
ჩვენ ვაპირებთ, რომ შეიცვალოს წინ.
Q.front ახლა აპირებს იყოს 1, იმიტომ, რომ ახლა
უძველესი ელემენტს ჩვენ გვაქვს ჩვენი რიგში, იმიტომ, რომ ჩვენ უკვე ამოღებულია 28
რომელიც ყოფილი უძველესი ელემენტს.
>> და ახლა, ჩვენ გვინდა, რომ შეიცვალოს ზომა მდგომ
ორი ელემენტები ნაცვლად სამი.
ახლა მახსოვს ადრე ვთქვი, როდესაც ჩვენ გსურთ დაამატოთ ელემენტების რიგში,
ჩვენ ამას მასივი ადგილმდებარეობა რომელიც არის თანხა წინა და ზომა.
ასე რომ, ამ შემთხვევაში, ჩვენ მაინც აყენებს ეს, შემდეგი ელემენტია რიგიდან,
შევიდა მასივი ადგილმდებარეობა 3 და ჩვენ დავინახავთ, რომ მეორე.
>> ასე რომ, ჩვენ ახლა dequeued ჩვენი პირველი ელემენტია რიგიდან.
მოდით ეს კიდევ ერთხელ.
მოდით ამოიღონ სხვა ელემენტის რიგიდან.
იმ შემთხვევაში, თუ მიმდინარე უძველესი ელემენტს მასივი ადგილმდებარეობა 1.
ეს არის ის რაც q.front გვეუბნება.
ეს მწვანე ყუთი გვეუბნება, რომ რომ არის უძველესი ელემენტს.
ასე რომ, x გახდება 33.
ჩვენ უბრალოდ სახის დაგავიწყდეთ 33 არსებობს მასივი,
და ჩვენ ვიტყვით, რომ ახლა, ახალი უძველესი ელემენტია რიგიდან
არის მასივი ადგილმდებარეობა 2, და ზომა მდგომ, რაოდენობის ელემენტები
ჩვენ მდგომ, არის 1.
ახლა მოდით enqueue რაღაც, და მე ერთგვარი მისცა მოშორებით მეორე წინ,
მაგრამ თუ ჩვენ გვინდა, რომ 40 წუთზე მდგომ, სადაც ის 40 აპირებს?
ისე ჩვენ უკვე აყენებს მას ამ q.front პლუს მდგომ ზომა,
და ასე რომ აზრი რეალურად 40 აქ.
ახლა შეამჩნია, რომ რაღაც მომენტში, ჩვენ ვაპირებთ
მისაღებად ბოლომდე ჩვენი მასივი შიგნით რ,
მაგრამ, რომ გაცვეთილ out 28 და 33 ისინი, ფაქტობრივად, ტექნიკურად
ღია სივრცეები, არა?
ასე რომ, ჩვენ შეიძლება eventually-- ეს წესი დასძინა
იმ ორი together-- ჩვენ შეიძლება საბოლოოდ უნდა mod ზომა მოცულობა
ასე რომ ჩვენ შეგვიძლია გადაიტანოთ გარშემო.
>> ასე რომ, თუ მივიღებთ, რომ ელემენტს ნომერი 10, თუ ჩვენ
შეცვალა ელემენტს ნომერი 10, ჩვენ გვინდა რეალურად დააყენა მასივი განთავსების 0.
და თუ ჩვენ ვაპირებთ მასივი location-- მაპატიეთ,
თუ ჩვენ დასძინა, რომ ისინი ერთად, და მივიღეთ ნომერი
11 იქნება, სადაც ჩვენ უნდა დააყენოს ის, რაც არ არსებობს ამ მასივი
ეს იქნებოდა აპირებს ფარგლებს გარეთ.
ჩვენ შეგვიძლია mod 10 და იგი მასივი ადგილმდებარეობა 1.
ასე რომ, თუ როგორ რიგები მუშაობა.
ისინი ყოველთვის აპირებს წავიდეს მარცხენა მარჯვნივ და შესაძლოა გადაიტანოთ გარშემო.
და თქვენ იცით, რომ ისინი სრული თუ ზომა, რომელიც წითელი ყუთი,
ხდება თანაბარი მოცულობა.
ასე რომ, მას შემდეგ, რაც ჩვენ დასძინა 40 დან მდგომ, ასევე რას უნდა გავაკეთოთ?
ისე, უძველესი ელემენტი მდგომ ჯერ კიდევ 19
ასე რომ, ჩვენ არ გვინდა, რომ შეიცვალოს წინაშე მდგომ,
მაგრამ ახლა ჩვენ გვაქვს ორი ელემენტების რიგში,
ასე რომ, ჩვენ გვინდა, რომ გაიზარდოს ჩვენი ზომა 1 დან 2.
>> ეს არის საკმაოდ ბევრი იგი მუშაობის მასივი დაფუძნებული რიგები,
და მსგავსი დასტის, არსებობს ასევე გზა
განახორციელოს რიგი უკავშირდება სიაში.
ახლა, თუ ამ მონაცემების სტრუქტურას ტიპი გამოიყურება ნაცნობი თქვენ, ის არის.
ეს არ არის ცალკე უკავშირდება სიაში, ეს ორმაგად უკავშირდება სიაში.
და ახლა, როგორც განზე, ეს არის რეალურად შესაძლებელია განახორციელოს
მდგომ, როგორც ცალკე უკავშირდება სიაში, მაგრამ მე ვფიქრობ, რომ თვალსაზრისით ვიზუალიზაცია,
ეს, ფაქტობრივად, შესაძლოა, დაეხმაროს ნახატის ეს, როგორც ორმაგად უკავშირდება სიაში.
მაგრამ ეს ნამდვილად შესაძლებელია ამისათვის, როგორც ცალკე უკავშირდება სიაში.
>> მოდით აქვს შევხედოთ რა შეიძლება გამოიყურებოდეს.
თუ გვინდა, რომ enquue-- ასე რომ, ახლა, ისევ ჩვენ
გადართვისას დაკავშირებული სიაში დაფუძნებული მოდელი აქ.
თუ ჩვენ გვინდა enqueue, ჩვენ გვინდა დაამატოთ ახალი ელემენტი, ასევე
რას უნდა გავაკეთოთ?
ისე, პირველ რიგში, იმიტომ, რომ ჩვენ ვამატებთ ბოლომდე
და მოხსნის იწყება, ჩვენ, ალბათ
გვინდა, რომ შევინარჩუნოთ მითითებას ორივე ხელმძღვანელი და კუდი უკავშირდება სიაში?
Tail უკვე მეორე ვადა ბოლოს უკავშირდება სია,
ბოლო ელემენტს უკავშირდება სიაში.
და ეს ალბათ, ისევ და ისევ, ეს ჩვენთვისვე
თუ ისინი გლობალური ცვლადები.
მაგრამ ახლა, თუ ჩვენ გვინდა, რომ დაამატოთ ახალი ელემენტის რას უნდა გავაკეთოთ?
რაც ჩვენ უბრალოდ [? malak?] ან დინამიურად გამოყოფს ჩვენი ახალი კვანძის საკუთარ თავს.
და შემდეგ, ისევე, როგორც, როდესაც ჩვენ დაამატოთ ნებისმიერი ელემენტს ორმაგად უკავშირდება სიაში ჩვენ,
უბრალოდ უნდა დასალაგებლად of-- იმ ბოლო სამი ნაბიჯები აქ
არის მხოლოდ ყველაფერი მოძრავი პოინტერები სწორი გზა
ისე, რომ ელემენტი ემატება ჯაჭვის გარეშე არღვევს ჯაჭვის
ან მიღების გარკვეული შეცდომა ან გარკვეული სახის შემთხვევის
მოხდება, რომლის დროსაც ჩვენ შემთხვევით ობოლი ზოგიერთი ელემენტები ჩვენს რიგიდან.
აი რა შეიძლება გამოიყურებოდეს.
ჩვენ გვინდა, რომ დაამატოთ ელემენტი 10 ბოლოს ამ მდგომ.
ასე რომ, უძველესი ელემენტს აქ წარმოდგენილია ხელმძღვანელი.
ეს არის პირველი, რაც ჩვენ დააყენა ამ უსაფუძვლო მდგომ აქ.
და კუდი, 13, არის ყველაზე ცოტა ხნის წინ დაემატა ელემენტს.
ასე რომ, თუ ჩვენ გვინდა enqueue -10 ამ რიგში, ჩვენ გვინდა, რომ მას შემდეგ, რაც 13.
ასე რომ, ჩვენ ვაპირებთ, რომ დინამიურად გამოყოს ფართი ახალი კვანძის
და შევამოწმოთ null, რათა დავრწმუნდეთ, ჩვენ არ გვაქვს მეხსიერების უკმარისობა.
მაშინ ჩვენ ვაპირებთ განათავსეთ -10 კვანძის,
და ახლა ჩვენ უნდა ვიყოთ ფრთხილად იმაზე, თუ როგორ ორგანიზება პოინტერები
ასე რომ, ჩვენ არ დაარღვიოს ჯაჭვი.
>> ჩვენ შეგვიძლია მითითებული 10 წინა ველი უნდა აღვნიშნო, ძველ კუდი,
მას შემდეგ, რაც '10 იქნება ახალი კუდი რაღაც მომენტში
იმ დროს, ყველა ეს ქსელები უკავშირდება,
არაფერი აპირებს ჩამოვიდეს მას შემდეგ, რაც 10 ახლა.
ასე რომ, 10 მომდევნო მაჩვენებელი იქნება აღვნიშნო, null,
და შემდეგ ამის გაკეთება, მას შემდეგ, რაც ჩვენ დაკავშირებული 10 უკან ჯაჭვის,
ჩვენ შეგვიძლია ავიღოთ ძველი ხელმძღვანელი, ან, საბაბი მე, ძველი კუდი რიგიდან.
ძველი ბოლოს მდგომ, 13, და ეს აღვნიშნო, რომ 10.
და ახლა, ამ ეტაპზე, ჩვენ გვაქვს enqueued ნომერი 10 ამ რიგიდან.
ყველა ჩვენ გვჭირდება გავაკეთოთ ახლა მხოლოდ გადატანა კუდი უნდა აღვნიშნო, 10 ნაცვლად 13.
>> Dequeuing ფაქტიურად ძალიან ჰგავს popping
საწყისი სტეკი, რომელიც ხორციელდება როგორც უკავშირდება სიაში
თუ ვნახე stacks ვიდეო.
ყველა ჩვენ უნდა გავაკეთოთ არის იწყება იწყება, იპოვოს მეორე ელემენტს,
გასათავისუფლებლად პირველ ელემენტს, და მაშინ გადატანა უფროსი
უნდა აღვნიშნო, რომ მეორე ელემენტს.
ალბათ უკეთესი ვიზუალურად ის უბრალოდ უნდა იყოს ზედმეტი ნათელია შესახებ.
ასე რომ, აქ ჩვენი მდგომ ერთხელ.
12 არის უძველესი ელემენტი ჩვენი მდგომ, ხელმძღვანელი.
10 არის უახლესი ელემენტს ჩვენი მდგომ, ჩვენი კუდი.
>> ასე რომ, როდესაც ჩვენ გვინდა რომ dequeue ელემენტს,
ჩვენ გვინდა, რომ ამოიღონ უძველესი ელემენტს.
ასე რომ, რა ვქნათ?
ისე ჩვენ მითითებული გასვლის მაჩვენებელი რომელიც იწყება ხელმძღვანელი,
და ჩვენ გადაადგილება ისე, რომ მიუთითებს მეორე ელემენტს
ამ მდგომ რაღაც განაცხადა, trav უდრის trav ისარი მომავალი, მაგალითად,
გადაინაცვლებს trav არ აღვნიშნო, რომ 15, მას შემდეგ, რაც ჩვენ dequeue 12
ან მას შემდეგ, რაც ჩვენ ამოიღონ 12 იქნება გახდეს მაშინ უძველესი ელემენტს.
>> ახლა ჩვენ ხელთ გვაქვს პირველი ელემენტის მეშვეობით მაჩვენებელი უფროსი
და მეორე ელემენტი მეშვეობით მაჩვენებელი trav.
ჩვენ შეგვიძლია ახლა თავისუფალი ხელმძღვანელი, და მაშინ ჩვენ შეგვიძლია რომ არაფერი ვთქვათ მოდის ადრე 15 უქმნით.
ასე რომ, ჩვენ შეიძლება შეიცვალოს 15 წინა მომცეთ აღვნიშნო, null,
და ჩვენ უბრალოდ გადაადგილება ხელმძღვანელი მეტი.
და იქ წასვლა.
ახლა ჩვენ გვაქვს წარმატებით dequeued 12, და ახლა ჩვენ
გვაქვს კიდევ ერთი რიგი 4 ელემენტებს.
ეს არის საკმაოდ ბევრი ყველა არ არის რიგები,
ორივე მასივი დაფუძნებული და დაკავშირებული სიაში დაფუძნებული.
მე Doug Lloyd.
ეს არის CS 50.