DOUG LLOYD: ყველა უფლება, ასე რომ, ამ ეტაპზე თქვენ
ალბათ საკმაოდ ნაცნობი კოლექტორები და დაკავშირებული სიები
რომელიც არის ორი ძირითადი მონაცემთა სტრუქტურები ჩვენ
ისაუბრა შენახვა კომპლექტი მონაცემები მსგავსი ტიპის მონაცემები ორგანიზებული.
>> ახლა ჩვენ ვაპირებთ, რომ გაიგო შესახებ რამდენიმე ვარიაციები
კოლექტორები და დაკავშირებული სიები.
ამ ვიდეო ჩვენ ვაპირებთ ვისაუბროთ stacks.
კერძოდ, ჩვენ ვაპირებთ, რომ გაიგო შესახებ მონაცემები სტრუქტურა მოუწოდა Stack.
გავიხსენოთ წინა დისკუსიები პოინტერები და მეხსიერება,
რომ სტეკი არის ასევე სახელი სეგმენტი მეხსიერება
სადაც statically განაცხადა memory-- მეხსიერება, რომ თქვენ
სახელი, ცვლადები, რომ თქვენ დაარქვით, და cetera და ფუნქცია ფარგლებში, რომელიც ჩვენ ასევე
დარეკეთ დასტის ფარგლებში არსებობს.
ასე რომ, ეს დასტის მონაცემები სტრუქტურა არ დასტის სეგმენტი მეხსიერება.
OK.
>> მაგრამ რა არის დასტის?
ასე რომ, ეს არის საკმაოდ ბევრი მხოლოდ სპეციალური სახის სტრუქტურა
რომელიც მოიცავს ინფორმაციას ორგანიზებულად.
აქ არის ორი ძალიან საერთო განხორციელების გზები
stacks გამოყენებით ორი მონაცემთა სტრუქტურები რომ ჩვენ უკვე იცნობს,
კოლექტორები და დაკავშირებული სიები.
რა ხდის დასტის სპეციალური არის გზა, რომელიც ჩვენ ბოლო ინფორმაცია
შევიდა დასტის, და გზა ჩვენ ამოიღონ ინფორმაციას Stack.
კერძოდ stacks წესი არის მხოლოდ ყველაზე
ცოტა ხნის წინ დაემატა ელემენტს შეიძლება ამოღებულ იქნეს.
>> ასე რომ, ვფიქრობ, რომ თითქოს ეს Stack.
ჩვენ პილინგი ინფორმაცია თავზე თავად,
და მხოლოდ ის, რაც ზედა წყობის შეიძლება ამოღებულ იქნეს.
ჩვენ ვერ ამოიღონ რამ ქვეშ იმიტომ, რომ ყველაფერი გავაკეთეთ
დაიშალოს და დაეცემა დასრულდა.
ასე რომ, ჩვენ ნამდვილად ვაშენებთ დასტის, რომ ჩვენ მაშინ უნდა ამოიღონ ნაჭერი.
ამის გამო ჩვენ ხშირად უწოდებენ დასტის, როგორც LIFO სტრუქტურა,
გაგრძელდება, პირველი გარეთ.
LIFO, გაგრძელდება, პირველი გარეთ.
>> ასე რომ, იმიტომ, რომ ეს შეზღუდვა როგორ შეიძლება დაემატოს
და ამოღებულ დასტის, იქ ნამდვილად მხოლოდ ორი რამ შეგვიძლია დასტის.
ჩვენ შეგვიძლია დააყენებს, რომელიც არის ტერმინი ჩვენ ვიყენებთ დასძინა
ახალი ელემენტი ზედა დასტის, ან თუ დასტის არ არსებობს
და ჩვენ შექმნა ნულიდან, შექმნა დასტის, პირველ რიგში,
იქნება უბიძგებს.
და მაშინ პოპ, რომელიც არის ერთგვარი CS ტერმინი ჩვენ ვიყენებთ ამოიღონ ყველაზე ცოტა ხნის წინ
დამატებითი ელემენტი ზემოდან Stack.
>> ამიტომ, ჩვენ ვაპირებთ შევხედოთ როგორც შესრულება, როგორც მასივი დაფუძნებული
და უკავშირდება სიაში დაფუძნებული.
და ჩვენ ვაპირებთ იწყება მასივი საფუძველზე.
ასე რომ, აქ არის ის ძირითადი იდეა რა მასივი დაფუძნებული დასტის მონაცემები სტრუქტურა
რომ გამოიყურებოდეს.
ჩვენ გვყავს აკრეფილი განმარტება აქ.
შიგნით, რომ ჩვენ გვაქვს ორი წევრი ან სფეროებში სტრუქტურა.
ჩვენ გვყავს მასივი.
ისევ და ისევ მე გამოყენებით თვითნებური მონაცემები ტიპის მნიშვნელობა.
>> ასე რომ, ეს შეიძლება იყოს ნებისმიერი მონაცემები ტიპის, int char და სხვა მონაცემები
ჩაწერეთ თქვენ ადრე შექმნილი.
ასე რომ, ჩვენ გვაქვს მასივი ზომა მოცულობა.
მოცულობა მიმდინარეობს ფუნტი განსაზღვრული მუდმივი, ალბათ სხვაგან ჩვენი ფაილი.
ასე რომ შეამჩნია უკვე ამ კონკრეტული განხორციელების ჩვენ bounding
საკუთარ თავს, როგორც იყო, როგორც წესი, იმ შემთხვევაში, მასივები,
რაც ჩვენ არ შეგვიძლია დინამიურად შეცვლის, იქ, სადაც არის გარკვეული რაოდენობის
ელემენტების მაქსიმალური, რომ ჩვენ შეგვიძლია ჩვენი Stack.
ამ შემთხვევაში ეს არის სიმძლავრის ელემენტებით.
>> ჩვენ ასევე ტრეკზე ზევით Stack.
რა ელემენტს არის ყველაზე ცოტა ხნის წინ დაემატა დასტის?
ასე რომ, ჩვენ შენარჩუნება სიმღერა, რომელიც ცვლადში დაბრუნება.
და ეს ყველაფერი ხდება დაასრულა ერთად ახალი მონაცემები ტიპის მოუწოდა Stack.
და კიდევ ჩვენ ის ეს ახალი მონაცემები ტიპის
ჩვენ შეგვიძლია მკურნალობა, როგორიცაა ნებისმიერი სხვა ტიპის მონაცემის.
შეიძლება ითქვას, დასტის s, ისევე, როგორც ჩვენ შეგვიძლია ამის გაკეთება int x, ან char y.
და როდესაც ჩვენ ვამბობთ, დააწყობს s, ასევე, თუ რა ხდება
არის მივიღებთ კომპლექტი მეხსიერების გათვალისწინებულია ჩვენთვის.
>> ამ შემთხვევაში სიმძლავრე მე როგორც ჩანს, გადაწყვიტა
10 იმიტომ, რომ მე მივიღე ერთი ცვლადი ტიპის დასტის
რომელიც შეიცავს ორ სფეროებში გავიხსენოთ.
მასივი, ამ შემთხვევაში აპირებს უნდა იყოს მასივი რიცხვებით
როგორც არის საქმე ყველაზე მეტად ჩემი მაგალითები.
და კიდევ მთელი ცვლადი შეუძლია შენახვა დაბრუნება,
ყველაზე ცოტა ხნის წინ დაემატა ელემენტი Stack.
ასე რომ, ერთი დასტის, რაც ჩვენ მხოლოდ განსაზღვრული ასე გამოიყურება.
ეს ყუთი, რომელიც შეიცავს მასივი 10 რა
იქნება მთელი რიცხვები ამ შემთხვევაში და კიდევ ერთი რიცხვი ცვლადი იქ მწვანე
მიუთითოს ზევით Stack.
>> იმისათვის, რომ ყველაზე დასტის ჩვენ უბრალოდ, ვამბობთ s.top.
სწორედ ასე შედიხართ სფეროში სტრუქტურა გაწვევას.
s.top უდრის 0 ეფექტურად აკეთებს ეს ჩვენი Stack.
ასე რომ კიდევ ერთხელ, ჩვენ გვაქვს ორი ოპერაციების რომ ჩვენ შეუძლია შეასრულოს ახლა.
ჩვენ შეგვიძლია დააყენებს და ჩვენ შეგვიძლია პოპ.
დავიწყოთ ბიძგი.
ისევ და ისევ, უბიძგებს დასძინა ახალი ელემენტი ზევით Stack.
>> ასე რომ, რას უნდა გავაკეთოთ ამ მასივი დაფუძნებული განხორციელება?
ისე, ზოგადად, ბიძგი ფუნქცია აპირებს
უნდა მიიღოს მომცეთ Stack.
ახლა მეორე და ვიფიქროთ ამაზე.
რატომ ჩვენ გვინდა, რომ მიიღოს მომცეთ დასტის?
გავიხსენოთ წინა ვიდეო ცვლადი ფარგლებს და მითითებები,
რა მოხდება, თუ ჩვენ უბრალოდ გააგზავნა დასტის, ეს საკმაოდ როგორც პარამეტრი?
რა რეალურად გადაეცემა იქ?
დამახსოვრება ჩვენ შექმნის ასლი როდესაც ჩვენ გაიაროს ეს ფუნქცია
თუ არ ვიყენებთ მითითებას.
ასე რომ, ეს ფუნქცია დააყენებს საჭიროებების მიიღოს მომცეთ დასტის
ასე, რომ ჩვენ რეალურად შეცვლის დასტის ჩვენ ვაპირებთ, რომ შეიცვალოს.
>> სხვა რამ დააყენებს ალბათ სურს მიიღოს არის მონაცემთა ელემენტს ტიპის მნიშვნელობა.
ამ შემთხვევაში, კიდევ ერთხელ, მთელი რიცხვი, რომელიც ჩვენ ვაპირებთ, რომ დაამატოთ ზევით Stack.
ამიტომ, ჩვენ მივიღეთ ჩვენი ორი პარამეტრი.
ჩვენ რას აპირებს ახლა შიგნით ბიძგი?
ისე, უბრალოდ, ჩვენ უბრალოდ აპირებს დაამატოთ რომ ელემენტს ზევით დასტის
და შემდეგ შეცვალოს, სადაც ზევით დასტის არის, რომ ეს dot დაბრუნება მნიშვნელობა.
ასე რომ, ეს არის ის, რაც ფუნქცია დეკლარაციის ბიძგი
შეიძლება გამოიყურებოდეს წელს მასივი დაფუძნებული განხორციელება.
>> ისევ და ისევ, ეს არ არის რთული და სწრაფად წესი რომ თქვენ ვერ შეცვლის ეს და
ის განსხვავდება სხვადასხვა გზები.
ალბათ s ცხადდება გლობალურად.
ასე რომ, თქვენ კი არ უნდა უნდა გაიაროს ეს არის როგორც პარამეტრი.
ეს არის კიდევ ერთხელ მხოლოდ საერთო საქმე ბიძგი.
არსებობს სხვადასხვა განხორციელების გზები ეს.
მაგრამ ამ შემთხვევაში ჩვენი ბიძგი აპირებს
ორი არგუმენტები, მომცეთ დასტის და მონაცემთა ელემენტს ტიპის მნიშვნელობა, რიცხვი
ამ შემთხვევაში.
>> ასე რომ, ჩვენ განაცხადა s, ჩვენ განაცხადა s.top უდრის 0.
ახლა მოდით დააყენებს ნომერი 28 გადატანა დასტის.
ისე, რას ნიშნავს ეს?
კარგად გაკეთებული ზევით დასტის არის 0.
ასე რომ, რა არის ის, ძირითადად მოხდება
ჩვენ ვაპირებთ, რომ გამყარებაში ნომერი 28 ლარი მასივი განთავსების 0.
საკმაოდ მარტივია, უფლება, რომ იყო ყველაზე და ახლა ჩვენ კარგი წასვლა.
და მაშინ ჩვენ უნდა შეიცვალოს, რაც ზედა დასტის იქნება.
ასე რომ, მომავალი დრო ჩვენ დააყენებს ელემენტს,
ჩვენ ვაპირებთ, რომ ჩაწეროთ იგი მასივი ადგილმდებარეობა, ალბათ, არ არის 0.
ჩვენ არ გვინდა, რომ გადავაწერო რაც ჩვენ უბრალოდ დააყენა იქ.
ასე რომ, ჩვენ უბრალოდ გადაადგილება დაბრუნება 1.
ეს, ალბათ აზრი.
>> ახლა, თუ ჩვენ გვინდა, რომ კიდევ ერთი ელემენტი გადატანა დასტის, ვთქვათ, ჩვენ გვინდა დააყენებს 33,
კარგად ახლა ჩვენ უბრალოდ აპირებს 33 და დააყენა იგი მასივი ადგილმდებარეობა ნომერი
1 და შემდეგ შეცვალოს ჩვენი ქვეყნის დასტის იყოს მასივი ადგილმდებარეობა ნომერი ორი.
ასე რომ, თუ სხვა დროს, ჩვენ გვინდა დააყენებს ელემენტს გადატანა დასტის,
ეს იქნება დააყენა მასივი ადგილმდებარეობა 2.
და მოდით გავაკეთოთ, რომ კიდევ ერთხელ.
ჩვენ დააყენებს 19 გამორთვა stacks.
ჩვენ დააყენა 19 მასივი ადგილმდებარეობა 2 და შეცვალოს თავზე ჩვენი დასტის
იყოს მასივი ადგილმდებარეობა 3 ასე რომ, თუ მომავალი დრო ჩვენ
უნდა მიიღოს ბიძგი ჩვენ კარგი წასვლა.
>> OK, ასე რომ უბიძგებს მოკლედ.
რაც შეეხება popping?
ასე რომ, popping არის ერთგვარი კოლეგა უბიძგებს.
ეს არის, თუ როგორ ამოიღონ მონაცემების Stack.
და საერთოდ, პოპ საჭიროებების უნდა გავაკეთოთ შემდეგ.
ეს უნდა მიიღოს მომცეთ დასტის, კვლავ ზოგად შემთხვევაში.
ზოგიერთ სხვა შემთხვევაში თქვენ შეიძლება არ გამოცხადდა დასტის გლობალურად,
ამ შემთხვევაში თქვენ არ უნდა გაიაროს ეს იმიტომ, რომ მას უკვე აქვს ხელმისაწვდომობის ეს
როგორც გლობალური ცვლადი.
მაგრამ მაშინ რა გავაკეთოთ ჩვენ უნდა გავაკეთოთ?
ისე ჩვენ დამატება ზედა დასტის ბიძგი,
ასე რომ, ჩვენ ალბათ აპირებს მინდა უნდა decrement ზევით დასტის
პოპ, არა?
და რა თქმა უნდა ჩვენ ასევე ვაპირებთ მინდა
დაბრუნებას ღირებულება, რომელიც ჩვენ ამოიღონ.
თუ ჩვენ დასძინა ელემენტების, ჩვენ გვინდა მისაღებად ელემენტები გარეთ მოგვიანებით,
ჩვენ, ალბათ, რეალურად გსურთ შეინახოთ ამიტომ ჩვენ
არ ვშლით მათ დასტის და შემდეგ გააკეთოს არაფერი მათთან.
საერთოდ, თუ ჩვენ უბიძგებს და popping აქ
ჩვენ გვინდა შესანახად ეს ინფორმაცია შინაარსიანი გზა
და ასე რომ არ მიიღოს აქვს უბრალოდ გაუქმება იგი.
ასე რომ, ეს ფუნქცია უნდა ალბათ დაბრუნდება მნიშვნელობა ჩვენთვის.
>> ასე რომ, ეს არის ის, რაც დეკლარაციის პოპ შეიძლება გამოიყურებოდეს იქ ზედა მარცხენა.
ეს ფუნქცია დააბრუნებს მონაცემები ტიპის მნიშვნელობა.
ისევ ჩვენ უკვე გამოყენებით რიცხვებით მასშტაბით.
და ეს ადასტურებს მომცეთ დასტის, როგორც მისი ერთადერთი არგუმენტი ან ერთადერთი პარამეტრი.
ასე რომ, რა pop აპირებს?
მოდით ვთქვათ რომ ჩვენ გვინდა, რომ ახლა პოპ ელემენტს off s.
ასე მახსოვს, მე ვთქვი, რომ stacks არის ბოლო წელს, პირველი გარეთ, LIFO მონაცემების სტრუქტურები.
რომელ ელემენტს აპირებს ამოღებულ დასტის?
ხომ იცი, 19?
იმის გამო, რომ თქვენ მინდა იყოს უფლება.
19 იყო ბოლო ელემენტი ჩვენ დაემატა დასტის, როდესაც ჩვენ უბიძგებს ელემენტები,
და ამიტომ აპირებს პირველი ელემენტი, რომელიც იღებს ამოიღეს.
ეს თითქოს ჩვენ ვთქვით, 28-ე და შემდეგ ჩვენ დააყენა 33 წლის თავზე,
და ჩვენ 19 თავზე რომ.
მხოლოდ ელემენტს შეუძლია off 19.
>> ახლა დიაგრამაზე აქ რასაც მე ვაკეთებ არის ერთგვარი ამოღებულია 19 მასივი.
ეს არ არის ის ის, რასაც ჩვენ ვაპირებთ, რომ გავაკეთოთ.
ჩვენ უბრალოდ სახის საქართველოს ვიტყვი, რომ ეს არ არსებობს.
ეს ჯერ კიდევ არსებობს რომ მეხსიერებაში,
მაგრამ ჩვენ უბრალოდ აპირებს იგნორირება შეცვლის ჩვენი ქვეყნის დასტის
მიმდინარეობს 3: 2.
ასე რომ, თუ ჩვენ ახლა დააყენებს კიდევ ერთი ელემენტი გადატანა დასტის,
ეს იქნებოდა მეტი დაწერა 19.
>> მაგრამ მოდით არ გავლა უბედურება წაშლის 19 Stack.
ჩვენ შეგვიძლია მხოლოდ ვიტყვი, რომ ეს არ არსებობს.
მიზნებისათვის დასტის ის წავიდა, თუ შევცვალოთ დაბრუნება უნდა იყოს 2 ნაცვლად 3.
ყველა უფლება, ასე რომ საკმაოდ ბევრი იყო.
ეს არის ის, რომ ჩვენ უნდა გავაკეთოთ პოპ ელემენტს off.
მოდით ეს კიდევ ერთხელ.
ასე რომ, მე ხაზგასმით მას წითელი აქ მიუთითებს, ჩვენ მიღების კიდევ ერთი ზარი.
ჩვენ ვაპირებთ, რომ გავაკეთოთ იგივე.
>> ასე რომ, რა მოხდება?
ასევე, ჩვენ ვაპირებთ შესანახად 33 x და ჩვენ ვაპირებთ
შეცვალოს ზევით დასტის 1.
ასე რომ, თუ ჩვენ ახლა დააყენებს ელემენტის დასტის, რომელიც ჩვენ
ვაპირებთ გავაკეთოთ, ახლა, რა მოხდება
არის ჩვენ ვაპირებთ გადაწერის მასივი ადგილმდებარეობა ნომერი 1.
ასე რომ, 33 რომ იყო ერთგვარი დატოვა უკან, რომ ჩვენ უბრალოდ პრეტენზია
არ უქმნით, ჩვენ უბრალოდ აპირებს რომ clobber და 40 არ ნაცვლად.
და მაშინ, რა თქმა უნდა, მას შემდეგ, რაც ჩვენ მივიღეთ ბიძგი,
ჩვენ ვაპირებთ, რომ ნამატი ზევით დასტის 1 დან 2
ასე რომ, თუ ჩვენ ახლა რჩეულებში კიდევ ერთი ელემენტი, იგი ყველაფერს
წასვლას მასივი ადგილმდებარეობა ნომერი ორი.
>> ახლა უკავშირდება სიები, სხვა გზა განახორციელოს stacks.
და თუ ეს განმარტება იმ ეკრანზე აქ გამოიყურება ნაცნობი,
ეს იმიტომ, რომ იგი გამოიყურება თითქმის ზუსტად იგივე, ფაქტობრივად,
მას საკმაოდ ბევრი არის ზუსტად ისევე, როგორც ცალკე უკავშირდება სიაში,
თუ გახსოვთ, ჩვენი განხილვის საგნით უკავშირდება სიები კიდევ ერთი ვიდეო.
ერთადერთი შეზღუდვა აქ ჩვენთვის, როგორც პროგრამისტები,
ჩვენ საშუალება არ მისცეს ჩადეთ ან წაშლა შემთხვევით
საწყისი ცალკე უკავშირდება სიაში რომელიც ჩვენ შეგვიძლია ადრე გააკეთოს.
ჩვენ შეგვიძლია მხოლოდ ახლა ჩადეთ და წაშლა წინა და ზედა უკავშირდება
სიაში.
ეს მართლაც მხოლოდ განსხვავება, თუმცა.
ეს არის სხვაგვარად საგნით უკავშირდება სიაში.
ეს მხოლოდ შეზღუდვა შეცვლის საკუთარ თავს
როგორც პროგრამისტები, რომ იცვლება მას Stack.
>> წესით აქ არის ყოველთვის იქონიოს მომცეთ ხელმძღვანელი უკავშირდება სიაში.
ეს, რა თქმა უნდა, ზოგადად, მნიშვნელოვანი წესი პირველი.
იყიდება ცალკე უკავშირდება სიაში მაინც თქვენ მხოლოდ უნდა მომცეთ ხელმძღვანელი
იმისათვის, რომ აქვს ჯაჭვის შეეძლოს ეხება
ყველა სხვა ელემენტს უკავშირდება სიაში.
მაგრამ ეს განსაკუთრებით მნიშვნელოვანი დასტის.
ასე რომ, ზოგადად, თქვენ აპირებს რეალურად სურს
ეს მაჩვენებელი იყოს გლობალური ცვლადი.
ეს, ალბათ, აპირებს უფრო ადვილია, რომ გზა.
ასე რომ, რა ანალოგები ბიძგი და საესტრადო?
უფლება.
ასე რომ უბიძგებს კიდევ ერთხელ დასძინა, ახალი ელემენტი Stack.
უკავშირდება სიაში რომ ნიშნავს, რომ ჩვენ ვაპირებთ აქვს
რათა შეიქმნას ახალი კვანძის, რომ ჩვენ ვაპირებ, რომ დაამატოთ უკავშირდება სიაში,
და შემდეგ ფრთხილად ნაბიჯები რომ ჩვენ გახმოვანებული ადრე
ამ საგნით დაკავშირებული სიები რომ დაამატოთ ეს ჯაჭვის გარეშე არღვევს ჯაჭვის
და დაკარგვის ან orphaning ნებისმიერი ელემენტები დაკავშირებულია სიაში.
და ეს, ძირითადად, რა, რომ პატარა Blob ტექსტის არ უყრის.
და მოდით შევხედოთ მას, როგორც სქემა.
>> ასე რომ, აქ ჩვენს უკავშირდება სიაში.
ეს ერთდროულად შეიცავს ოთხი ელემენტები.
და უფრო კარგად აქ არის ჩვენი დასტის შემცველი ოთხი ელემენტები.
და მოდით ვთქვათ, ჩვენ ახლა მინდა დააყენებს ახალი საქონლის გადატანა ამ დასტის.
ჩვენ გვინდა დააყენებს ახალი ნივთი, რომლის მონაცემები ღირებულება 12.
ისე, რასაც ჩვენ ვაპირებთ, რომ გავაკეთოთ?
ისე პირველი ჩვენ ვაპირებთ malloc სივრცეში, დინამიურად
გამოყოს ფართი ახალი კვანძის.
და რა თქმა უნდა, მაშინვე ჩვენ ზარი malloc ჩვენ ყოველთვის
დარწმუნდით, რომ შემოწმება null, იმიტომ, რომ თუ ჩვენ მივიღეთ null უკან
იყო გარკვეული პრობლემა.
ჩვენ არ გვინდა, რომ, რომ dereference null მაჩვენებელი ან თქვენ განიცდიან seg ბრალია.
ეს არ არის კარგი.
ასე რომ, ჩვენ malloced კვანძი.
ჩვენ ვივარაუდოთ, რომ ჩვენ გვქონდა წარმატება აქ.
ჩვენ ვაპირებთ, რომ 12 წუთზე მონაცემები სფეროში, რომ კვანძის.
ახლა თქვენ გავიხსენოთ, რომელიც ჩვენი პოინტერები მოძრაობს შემდეგი ამიტომ ჩვენ არ დაარღვიოს ჯაჭვი?
ჩვენ გვაქვს რამდენიმე ვარიანტი, მაგრამ აქ მხოლოდ ერთი, რომ იქნება უსაფრთხო
არის მითითებული საინფორმაციო მომდევნო მომცეთ წერტილი ძველი ხელმძღვანელი სია
ან რა მალე ძველი ხელმძღვანელს სიაში.
და ახლა, რომ ყველა ჩვენი ელემენტები მიჯაჭვული ერთად,
ჩვენ შეგვიძლია მხოლოდ გადაადგილება სიიდან აღვნიშნო, ერთი და იგივე ადგილზე რომ ახალი აკეთებს.
და ჩვენ ახლა ეფექტურად მივიღებთ ახალი ელემენტი გადატანა წინაშე დასტის.
>> პოპ ჩვენ უბრალოდ გვინდა წაშლა, რომ პირველ ელემენტს.
ასე რომ, ძირითადად, რა ჩვენ უნდა გავაკეთოთ აქ,
ასევე ჩვენ უნდა მოვძებნოთ მეორე ელემენტს.
საბოლოოდ, რომ გახდება ახალი უხელმძღვანელებს მას შემდეგ, რაც ჩვენ წაშლა პირველი.
ასე რომ, ჩვენ უბრალოდ უნდა დაიწყოს დასაწყისში, გადაადგილება ერთი ნაბიჯია.
მას შემდეგ, რაც ჩვენ მივიღეთ სამფლობელო ერთი თავდამსხმელმა სადაც ჩვენ გაკეთებული
არიან ჩვენ შეგვიძლია წაშლა პირველი უსაფრთხოდ და მაშინ ჩვენ შეგვიძლია მხოლოდ გადაადგილება ხელმძღვანელი
უნდა აღვნიშნო, რომ რა იყო მეორე ვადით და მაშინ ახლა
პირველი მას შემდეგ, რაც კვანძის წაიშალა.
>> ასე რომ კიდევ ერთხელ, იმის სახეს მას, როგორც სქემა ჩვენ
მინდა ახლა პოპ ელემენტის off ამ დასტის.
ასე რომ, რა ვქნათ?
ისე ჩვენ პირველი შექმნას აპირებს ახალი მაჩვენებელი, აპირებს
უნდა აღვნიშნო, რომ ერთსა და იმავე ადგილზე, როგორც ხელმძღვანელი.
ჩვენ ვაპირებთ, რომ გადატანა ერთი პოზიცია წინ განაცხადა, trav ტოლობის
Trav შემდეგი მაგალითად, რომელიც რომ წინასწარ trav მაჩვენებელი ერთ-ერთი
პოზიცია ნაბიჯია.
ახლა, რომ ჩვენ მივიღეთ გამართავს პირველ ელემენტს
მეშვეობით მაჩვენებელი მოუწოდა სიაში, და მეორე ელემენტს მეშვეობით მაჩვენებელი მოუწოდა
trav, ჩვენ შეგვიძლია უსაფრთხოდ წაშლა პირველი ელემენტი დასტის
დაკარგვის გარეშე დანარჩენი ჯაჭვის იმიტომ, რომ ჩვენ
აქვს გზა ეხება მეორე ელემენტს
ველით გზით მაჩვენებელი მოუწოდა trav.
>> ასე რომ, ახლა ჩვენ შეგვიძლია გასათავისუფლებლად რომ კვანძის.
ჩვენ შეგვიძლია გასათავისუფლებლად სიაში.
და მაშინ ყველა ჩვენ უნდა გავაკეთოთ ახლა არის გადაადგილება სია წერტილი ერთი და იგივე ადგილზე
რომ trav აკეთებს და ჩვენ ერთგვარი უკან სადაც ჩვენ დავიწყეთ, სანამ ჩვენ მივიღებთ 12
წლის პირველ რიგში, მარჯვნივ.
სწორედ ეს არის, სადაც ჩვენ ვიყავით.
ჩვენ გვქონდა ამ ოთხი ელემენტის დასტის.
ჩვენ დასძინა მეხუთე.
ჩვენ მივიღებთ მეხუთე ელემენტს, და მაშინ ჩვენ
გამოჩნდა, რომ ცოტა ხნის წინ, დამატებითი ელემენტი უკან off.
>> ეს მართლაც საკმაოდ ბევრი ყველა იქ არის stacks.
შეგიძლიათ განახორციელოს მათ, როგორც მასივები.
შეგიძლიათ განახორციელოს მათ, როგორც დაკავშირებული სიები.
არსებობს, რა თქმა უნდა, სხვა განხორციელების გზები მათ ასევე.
ძირითადად იმ მიზეზით, ჩვენ ვიყენებთ stacks შეინარჩუნოს მონაცემების იმგვარად
რომ ყველაზე ცოტა ხნის წინ დაემატა ელემენტი არის პირველი, რაც ჩვენ
აპირებს მინდა დავუბრუნდეთ.
მე Doug Lloyd, ეს არის CS50.