[Powered by Google Translate] [ნაწილი 6: Less კომფორტული]
[Nate Hardison] [ჰარვარდის უნივერსიტეტის]
[ეს არის CS50.] [CS50.TV]
ყველა უფლება. კეთილი იყოს ნაწილი 6.
ამ კვირაში, ჩვენ ვაპირებთ ვისაუბრებთ მონაცემები სტრუქტურების ნაწილში,
პირველ რიგში იმიტომ, რომ ამ კვირის პრობლემა წაუკიდეს spellr
აკეთებს მთელი bunch სხვადასხვა მონაცემები სტრუქტურა exploration.
არსებობს რამოდენიმე განსხვავებული გზა შეგიძლიათ წავიდეთ ერთად პრობლემის კომპლექტი,
და მეტი მონაცემები სტრუქტურების იცით, უფრო მაგარი რამ რისი გაკეთებაც შეგიძლიათ.
>> მოდით დავიწყოთ. პირველი ჩვენ ვაპირებთ ვისაუბროთ stacks,
დასტის და მდგომ მონაცემები სტრუქტურები, რომ ჩვენ ვაპირებთ ვისაუბროთ.
Stacks და რიგები მართლაც გამოსადეგი, როდესაც ჩვენ ვიწყებთ საუბარს გრაფიკების,
რაც ჩვენ არ ვაპირებთ ამის გაკეთებას დიდი ახლავე.
მაგრამ ისინი ნამდვილად კარგი უნდა გვესმოდეს ერთი დიდი ფუნდამენტური მონაცემები სტრუქტურების CS.
აღწერილობა პრობლემა კომპლექტი სპეციფიკაცია,
თუ თქვენ დახევის ის საუბრობს stacks როგორც akin to
pile of სასადილო უჯრები რომ გაქვთ cafeteria at სასადილო დარბაზები
აქ, როდესაც სასადილო პერსონალის მოდის და აყენებს სასადილო ქაღალდის შემდეგ ისინი გაწმენდილი მათ,
ისინი დააწყობს ერთი ყველაზე სხვა.
და მაშინ, როდესაც ბავშვები მოდის მიიღოს საკვები,
ისინი დახევის off ქაღალდის, პირველი დაბრუნება ერთი, მაშინ ერთი ქვემოთ, მაშინ ერთი ქვემოთ რომ.
ასე რომ, ფაქტობრივად, პირველი უჯრა, რომ სასადილო პერსონალის ჩასახშობად არის ბოლო ერთი რომ იღებს წაიყვანეს.
ბოლო ერთი რომ სასადილო პერსონალის ჩაიცვი არის პირველი რომ იღებს წაიყვანეს სადილად.
პრობლემის კომპლექტი ს Spec, რომელიც შეგიძლიათ ჩამოტვირთოთ თუ არ უკვე,
ვსაუბრობთ მოდელირებას დასტის მონაცემები სტრუქტურა გამოყენებით ამ სახის struct.
>> რა გვაქვს აქ, ეს მსგავსია იმისა, რაც იყო წარმოდგენილი ლექცია,
გარდა ლექცია ჩვენ წარმოდგენილი ამ ints ნაცვლად char * s.
ეს იქნება დასტის რომ მაღაზიებში რა?
დანიელ? რას შენახვა ამ დასტის?
[დანიელ] სიმები? >> ჩვენ შენახვის სტრიქონები ამ დასტის, ზუსტად.
ყველა უნდა გქონდეს, რათა შეიქმნას დასტის არის მასივი
კონკრეტული მოცულობა, რომელიც ამ შემთხვევაში,
სიმძლავრის იქნება ყველა caps რადგან მუდმივი.
ხოლო შემდეგ დამატებით მასივი, ყველა ჩვენ გვჭირდება მწკრივზე არის აქტუალური ზომა მასივი.
ერთი რამ აღვნიშნო აქ რომ სახის cool
ის არის, რომ ჩვენ შექმნის stacked მონაცემები სტრუქტურის თავზე სხვა მონაცემები სტრუქტურა, მასივი.
არსებობს სხვადასხვა გზა განახორციელოს stacks.
ჩვენ არ გავაკეთეთ საკმაოდ არის, მაგრამ იმედია შემდეგ აკეთებს დაკავშირებული სიაში პრობლემები,
თქვენ ნახავთ, თუ როგორ შეგიძლიათ ადვილად განახორციელონ დასტის თავზე უკავშირდება სიაშია.
მაგრამ ახლა, ჩვენ ჯოხი მასივები.
ასე რომ კიდევ ერთხელ, ყველა ჩვენ გვჭირდება მასივი და ჩვენ უბრალოდ უნდა აკონტროლოთ ზომა მასივი.
[სემ] უკაცრავად, რატომ არის ის, რომ თქვენ განაცხადა დასტის არის თავზე სტრიქონები?
ჩემთვის თითქოს strings შიგნით Stack.
[Hardison] Yeah. ჩვენ ქმნის, ჩვენ აღების ჩვენი მასივი მონაცემები სტრუქტურა -
რომ დიდი კითხვა. ასე რომ კითხვაზე ამიტომ, მათთვის, ვისაც თვალს ამ შემოსული,
რატომ ვართ, რომ დასტის არის თავზე სიმები,
რადგან აქ გამოიყურება სიმები არიან შიგნით დასტის?
რომელიც მთლიანად შემთხვევაში.
რა გულისხმობდა იყო, რომ ჩვენ მივიღეთ მასივი მონაცემები სტრუქტურა.
გვაქვს მასივი char * s, ამ მასივი სიმები,
და ჩვენ ვაპირებთ დავამატოთ, რომ შესაქმნელად stacked მონაცემები სტრუქტურა.
>> ამიტომ დასტის ოდნავ უფრო რთული, ვიდრე მასივი.
ჩვენ შეგვიძლია გამოვიყენოთ მასივი აშენება Stack.
ასე რომ, სადაც ჩვენ ვამბობთ, რომ დასტის აგებულია ზევით მასივი.
ანალოგიურად, როგორიც მე ვთქვი ადრე, ჩვენ შეგვიძლია ავაშენოთ დასტის თავზე უკავშირდება სიაში.
ნაცვლად გამოყენებით მასივი გავმართოთ ელემენტები,
ჩვენ შეგვიძლია გამოვიყენოთ დაკავშირებული სიაში გავმართოთ ელემენტები და ავაშენოთ დასტის გარშემო რომ.
მოდით გავლა რამდენიმე მაგალითები, ეძებს რაღაც კოდი,
რომ ნახოთ თუ რა სინამდვილეში ხდება აქ.
მარცხნივ, მე ჩაუყარეს რა, რომ დასტის struct გამოიყურება ასე ხსოვნის
თუ სიმძლავრის იყო # განსაზღვრული იქნება ოთხი.
გვაქვს ჩვენი ოთხი ელემენტს char * მასივი.
გვაქვს სტრიქონები [0], სტრიქონები [1], სტრიქონები [2], სტრიქონები [3],
და შემდეგ რომ ბოლო სივრცეში ჩვენი ზომა რიცხვი.
ამჯამად ამ აზრი? Okay.
ეს არის, რა მოხდება, თუ რა გავაკეთო, მარჯვენა,
რაც იქნება ჩემი კოდი, არის უბრალოდ განაცხადოს struct, stacked struct მოუწოდა s.
ეს არის ის, რაც ჩვენ კიდევ. იგი აყალიბებს ამ კვალის მეხსიერებაში.
პირველი კითხვა აქ რა შინაარსის ამ დასტის struct?
ახლავე ისინი არაფერს, მაგრამ ისინი სრულიად არაფერი.
ისინი ამ სახის ნაგვის. ჩვენ არ გვაქვს იდეა რა მათ.
როდესაც ვაცხადებთ დასტის s, ჩვენ უბრალოდ სროლა, რომ ქვევით ზევით მეხსიერება.
ეს სახის მოსწონს გამოცხადების int მე და არა ინიციალიზაციისას იგი.
თქვენ არ ვიცი რა არის. შეგიძლიათ წაიკითხოთ რა იქ,
მაგრამ ეს არ უნდა იყოს სუპერ გამოსადეგი.
ერთი რამ გსურთ ყოველთვის გვახსოვს გააკეთოთ ინიციალიზაცია რასაც საჭიროებს ინიციალიზაცია.
ამ შემთხვევაში, ჩვენ ვაპირებთ ინიციალიზაცია ზომა უნდა იყოს ნულის
რადგან ისინი აპირებენ აღმოჩნდა ჩვენთვის ძალიან მნიშვნელოვანია.
ჩვენ შეგვეძლო წავიდეთ წინ და ინიციალიზაცია ყველა პოინტერები, ყველა char * s,
უნდა იყოს გარკვეული გასაგები ღირებულება, რომელიც სავარაუდოდ null.
მაგრამ ეს არ არის ბოლომდე აუცილებელია, რომ ჩვენ გაგვაჩნია.
>> ახლა, ორი ძირითადი ოპერაციების stacks არიან?
ვინმეს გახსოვთ ლექცია, თუ რას აკეთებთ ერთად stacks? დიახ?
[Stella] უბიძგებს და popping? >> ზუსტად.
ზრდის და popping არიან ორი ძირითადი ოპერაციების stacks.
და რა ბიძგი გავაკეთო? >> იგი აყენებს რაღაც გადატანა დაბრუნება
საქართველოს დასტის, და შემდეგ popping იღებს ეს off.
[Hardison] ზუსტად. ამიტომ უბიძგებს უბიძგებს რაღაც თავზე Stack.
ეს მოსწონს სასადილო პერსონალის აყენებს სასადილო უჯრა down on მთვლელი.
და popping ხდება სასადილო უჯრა გამორთვა Stack.
მოდით გავლა რამდენიმე მაგალითები რა ხდება
როდესაც ჩვენ დააყენებს რამ შევიდა Stack.
თუ ჩვენ დააყენებს string 'მიესალმები' გადატანა ჩვენი დასტის,
ეს არის ის, რაც ჩვენი სქემა გამოიყურება ასე არის.
ვნახოთ, რა მოხდება?
ჩვენ მივიღებთ შევიდა პირველი ელემენტს ჩვენი სიმები მასივი
და ჩვენ upped ჩვენი ზომა რაოდენობა უნდა იყოს 1.
ასე რომ, თუ დავაკვირდებით განსხვავება ორ სლაიდები, აქ იყო 0, აქ ადრე ბიძგი.
აქ არის შემდეგ ბიძგი.
სანამ ბიძგი, შემდეგ ბიძგი.
და ახლა ჩვენ გვაქვს ერთი ელემენტია ჩვენი Stack.
ეს სტრიქონი "Hello", და ამით ყველაფერი მთავრდება.
სხვა დანარჩენი მასივი, ჩვენი სიმები მასივი, კვლავ ნაგვის.
ჩვენ არ ინიციალიზდება იგი.
ვთქვათ ჩვენ დააყენებს სხვა სიმებიანი გადატანა ჩვენი Stack.
ჩვენ ვაპირებთ დააყენებს "სამყარო" ამ დროს.
ასე რომ თქვენ შეგიძლიათ ნახოთ "world" აქ გადის თავზე "Hello",
და ზომა რაოდენობა ღებულობენ მდე 2.
ახლა ჩვენ შეგვიძლია დააყენებს "CS50", და რომ გექნებათ წავიდეთ თავზე კვლავ.
თუ ჩვენ დავბრუნდებით, თქვენ ხედავთ, როგორ ჩვენ უბიძგებს რამ თავზე Stack.
და ჩვენ მივიღებთ თემა.
როდესაც ჩვენ popped რაღაც გამორთვა დასტის, რა მოხდა?
ვინმეს ვხედავთ განსხვავება? ეს საკმაოდ დახვეწილი.
[სტუდენტური] ზომა. >> Yeah, ზომა შეიცვალა.
>> რა იქნებოდა თქვენ არ შეიცვლება?
[სტუდენტური] სიმები, ძალიან. >> მარჯვენა. სიმები ძალიან.
თურმე, როდესაც თქვენ ამის გაკეთება ამ გზით,
რადგან ჩვენ არ გადაწერა ელემენტები შეიტანა ჩვენი დასტის,
ჩვენ მართლაც არ გაქვთ არაფერს, ჩვენ უბრალოდ გამოიყენოთ ზომა
შენარჩუნება ტრეკზე ხმების რამ ჩვენს მასივი
ასე რომ, როცა პოპ ისევ, ისევ ჩვენ უბრალოდ decrement ჩვენი ზომა ქვემოთ 1.
იქ არ არის საჭიროება იმისა, რომ რეალურად წავიდეს და გადავაწერო არაფერი.
სახის ხმაურიანი.
თურმე ჩვენ, როგორც წესი, უბრალოდ დატოვონ რამ მარტო იმიტომ რომ ნაკლები ჩვენთვის მუშაობა უნდა გააკეთოს.
თუ ჩვენ არ უნდა დაბრუნდეს და გადავაწერო რამე, მაშინ რატომ აკეთებენ ამას?
ასე რომ, როდესაც ჩვენ პოპ ორჯერ გამორთვა დასტის, ყველა რომ არ არის decrement ზომა რამდენჯერმე.
ისევ და ისევ, ეს მხოლოდ იმიტომ, რომ ჩვენ არ გადაწერა რამ შევიდა ჩვენი Stack.
დიახ? წავიდეთ წინ.
[სტუდენტი გაუგებარია] >> და მერე რა მოხდება, როცა დააყენებს რაიმეს?
როდესაც თქვენ დააჭირეთ რაღაც ერთხელ, სადაც იგი წავიდეთ?
სად ეს წასვლა, ბასილ? >> Into სტრიქონები [1]? >> მარჯვენა.
რატომ არ მას წასვლას სტრიქონები [3]?
[ბასილ] იმიტომ, რომ დაავიწყდა, რომ იქ არაფერი სტრიქონები [1] და [2]?
[Hardison] ზუსტად. ჩვენი დასტის, არსებითად, "დაავიწყდა", რომ ის ჩატარების შესახებ, რომ არაფერი
in strings [1] ან სტრიქონები [2], ასე რომ, როდესაც ჩვენ დააყენებს "woot",
უბრალოდ აყენებს რომ შევიდა ელემენტს საათზე სტრიქონები [1].
არსებობს რაიმე კითხვები, თუ როგორ ამ სამუშაოების დროს საბაზისო დონეზე?
[სემ] ასე რომ, ეს არ არის დინამიური არანაირად, თვალსაზრისით თანხა
ან თვალსაზრისით ზომა დასტის?
[Hardison] ზუსტად. ეს არის - პუნქტიანი იყო, რომ ეს არ იყო დინამიურად growning Stack.
ეს არის დასტის, რომ შეიძლება გამართავს, უმეტეს, ოთხი char * s, უმეტეს ოთხი რამ.
თუ ჩვენ ცდილობენ და დააყენებს მეხუთე რამ, როგორ ფიქრობთ რა უნდა მოხდეს?
[სტუდენტები, გაუგებარია]
[Hardison] ზუსტად. არსებობს მთელი რიგი საკითხები, რამაც შეიძლება მოხდეს.
ეს შეიძლება seg ბრალია, იმის მიხედვით, თუ რა ვიყავით -
როგორ ზუსტად ჩვენ განხორციელების back-end.
ეს შეიძლება გადავაწერო. ეს შეიძლება ჰქონდეს, რომ ბუფერული overflow რომ ჩვენ ვისაუბრეთ კლასში.
რა იქნება ყველაზე ნათელი რაც შეიძლება შეცვლილ იქნას ინსტალერის
თუ ჩვენ შევეცადეთ დააყენებს ზედმეტი რამ ჩვენს დასტის?
ასე, რომ თქვენ აღნიშნული ბუფერული overflow.
რა შეიძლება იყოს, რაც დაიჭერს წერილობითი მეტი ან stomped შესახებ
თუ ჩვენ overflowed შემთხვევით ცდილობს დააყენებს ზედმეტი რამ?
[დანიელ, გაუგებარია] >> შესაძლებელი.
მაგრამ თავდაპირველად, თუ რა შეიძლება მოხდეს? რა მოხდება, თუ ჩვენ შევეცადეთ დააყენებს მეოთხე რამ?
ეს შეიძლება გადავაწერო ზომა, მინიმუმ ამ მეხსიერების დიაგრამაზე, რომ ჩვენ მივიღეთ.
>> პრობლემის კომპლექტი სპეციფიკაცია, რაც ჩვენ უნდა განხორციელების დღეს,
რას ვაკეთებთ ჩვენ უნდა დააბრუნებს false.
ჩვენი ბიძგი მეთოდით დაბრუნებას აპირებს ლოგიკური ღირებულება,
და რომ ლოგიკური ღირებულება იქნება ნამდვილი თუ ბიძგი გამოსდის
და ცრუ თუ ჩვენ ვერ დააყენებს არაფერი რადგან დასტის სავსეა.
მოდით გავლა ცოტა რომ კოდი ახლავე.
აი ჩვენი ბიძგი ფუნქცია.
ჩვენი ბიძგი ფუნქცია დასტის აპირებს მიიღოს სიმებიანი მოათავსოთ Stack.
იგი აპირებს TRUE თუ სიმებიანი წარმატებით აიძულა
on Stack და ცრუ სხვაგვარად.
რაიმე შემოთავაზება, თუ რა შეიძლება იყოს კარგი პირველი, რაც უნდა გავაკეთოთ აქ?
[სემ] თუ ზომა ტოლია სიმძლავრის შემდეგ დაბრუნდნენ ყალბი?
[Hardison] Bingo. Nice სამუშაოს.
თუ ზომა არის მოცულობა, ჩვენ ვაპირებთ დაბრუნებას ყალბი.
ჩვენ ვერ დააყენა არაფერი მეტი ჩვენი Stack.
წინააღმდეგ შემთხვევაში, ჩვენ გვინდა დააყენა რაღაც ზევით Stack.
რა არის "ყველაზე დასტის," თავდაპირველად?
[დანიელ] ზომა 0? >> ზომა 0.
რა არის ზევით დასტის შემდეგ არსებობს ერთი რამ დასტის? Missy, იცით?
[Missy] ერთი. >> ზომა არის ერთი, ზუსტად. თქვენ გაქვთ შეავსოთ ზომა,
და ყოველ ჯერზე თქვენ აყენებს ახალ ელემენტს საათზე ინდექსი ზომის მასივი.
ჩვენ შეგვიძლია ამის გაკეთება, რომ სახის ერთი ლაინერი, თუ ეს აზრი.
ამიტომ, ჩვენ მივიღეთ ჩვენი სიმები მასივი, ჩვენ ვაპირებთ, რათა შეამოწმონ ის ზომა ინდექსი,
და ჩვენ უბრალოდ აპირებს შესანახად ჩვენი char * იქ.
შეამჩნევთ, თუ როგორ არ სიმებიანი კოპირება ხდება აქ,
არ დინამიური გამოყოფის მეხსიერება?
და შემდეგ მისის იზრდებიან, რაც ჩვენ ახლა უნდა გავაკეთოთ,
რადგან ჩვენ შენახული სიმებიანი შესაბამის ადგილს მასივი,
და მან განაცხადა, რომ მოგვიწია ნამატი ზომა ერთი ასე რომ ჩვენ მზად ვართ მომდევნო ბიძგი.
ასე რომ ჩვენ შეგვიძლია გავაკეთოთ, რომ s.size + +.
ამ ეტაპზე, ჩვენ მივიღებთ ჩვენს მასივი. რა არის ბოლო რამ უნდა გავაკეთოთ?
[სტუდენტური] დაბრუნდა TRUE. >> დაბრუნდა TRUE.
ასე რომ საკმაოდ მარტივია, საკმაოდ მარტივია კოდი. არ არის ძალიან ბევრი.
ერთხელ თქვენ გახვეული თქვენი უფროსი გარშემო როგორ დასტის მუშაობს,
ეს არის საკმაოდ მარტივი განხორციელება.
>> ახლა, მომდევნო ნაწილი ეს popping სიმებიანი გამორთვა Stack.
მე ვაპირებ მოგცემთ ბიჭებს გარკვეული დრო მუშაობა ამ ცოტა.
თითქმის არსებითად საპირისპირო რასაც ჩვენ გავაკეთეთ აქ ფრეა.
რა მე ვაკეთებ ფაქტობრივად - Oops.
მე გაიჭედოთ up ელექტრო მეტი აქ და ელექტრო მოწყობილობების,
მე გამოყვანილია up პრობლემა მითითებული 5 სპეციფიკაცია.
თუ ჩვენ მიუახლოვდით აქ, ვხედავთ ვარ საათზე cdn.cs50.net/2012/fall/psets/pset5.pdf.
თქვენ ბიჭები გადმოწერილი ეს კოდი რომ აქ, section6.zip?
ყველა უფლება. თუ არ გაკეთდა, ამას ახლავე, მართლაც სწრაფად.
მე გავაკეთებთ ჩემი ტერმინალის ფანჯარაში.
მე რეალურად ეს აქ. Yeah.
დიახ, სემ? >> მაქვს შეკითხვა რატომ ამბობენ s.string 's ფრჩხილებში of size = ქ?
რა არის ქ? ის არის, რომ განსაზღვრული სადღაც ადრე, ან - Oh, წელს char * ქ?
[Hardison] დიახ, ზუსტად. ეს იყო არგუმენტი. >> Oh, okay. უკაცრავად.
[Hardison] ჩვენ სასურველი სიმებიანი დააყენებს სისტემაში
სხვა საკითხს, რომელიც შესაძლოა ამუშავება, რომ ჩვენ არ ნამდვილად ვილაპარაკოთ აქ იყო
ავიღეთ თავისთავად, რომ ჩვენ გვქონდა ამ ცვლადში s
რომ იყო ფარგლებს და ხელმისაწვდომი ჩვენთვის.
ჩვენ მივიღეთ თავისთავად, რომ იყო ამ დასტის struct.
ასე ეძებს უკან ამ ბიძგი კოდი,
თქვენ ხედავთ, რომ ვაკეთებთ პერსონალის ამ სტრიქონს რომ გაბმულ გადავიდა
მაგრამ შემდეგ უეცრად, ჩვენ წვდომის s.size, როგორიცაა, სად და მოდის?
კოდექსში, რომ ჩვენ ვაპირებთ შევხედოთ განყოფილებაში არქივი
და მაშინ პერსონალი რომ თქვენ უნდა აკეთებდა თქვენი პრობლემა ადგენს,
ჩვენ გამოვიტანეთ ჩვენი დასტის struct გლობალური ცვლადი
ასე, რომ ჩვენ შეგვიძლია ხელი მიუწვდება ეს ყველა ჩვენი განსხვავებული ფუნქციები
გარეშე ხელით მსგავ გარშემო და მსგავ მიერ მინიშნება,
ყველაფერი რომ მსგავსი საქმიანობები მას.
ჩვენ უბრალოდ პატაშური ცოტა, თუ გნებავთ, რათა რამ გავალამაზოთ.
და ეს რაღაც ვაკეთებთ აქ იმიტომ რომ გასართობად, უფრო ადვილია.
ხშირად დაინახავთ ადამიანებს ამის გაკეთება, თუ მათ აქვთ ერთი დიდი მონაცემები სტრუქტურა
რომ მიმდინარეობს ოპერაცია ფარგლებში მათი პროგრამა.
>> მოდით დავუბრუნდეთ მეტი ელექტრო მოწყობილობების.
ხომ ყველას წარმატებით კიდევ section6.zip?
ყველას unzip ის გამოყენებით unzip section6.zip?
თუ წასვლას ნაწილი 6 დირექტორია -
aah, მთელი ადგილი -
და თქვენ ჩასვათ რა აქ, თქვენ ხედავთ, რომ თქვენ მოხვდით სამი სხვადასხვა. გ files.
თქვენ მოხვდით მდგომ, sll, რომელიც საგნით დაკავშირებული სიაში და დასტის.
თუ თქვენ გახსენით stack.c,
თქვენ ხედავთ, რომ ჩვენ მივიღეთ ეს struct განსაზღვრული ჩვენთვის,
ზუსტი struct, რომ ჩვენ უბრალოდ ვისაუბრეთ იმ სლაიდები.
გვაქვს ჩვენი გლობალური ცვლადი ამისთვის დასტის,
გვაქვს ჩვენი ბიძგი ფუნქცია,
და მაშინ ჩვენ მივიღეთ ჩვენი pop ფუნქცია.
მე დააყენა კოდი დააყენებს back up on the slide აქ,
მაგრამ რა მინდა შენ უნდა გააკეთოთ, მაქსიმალურად თქვენი უნარი,
წასვლა და განხორციელება pop ფუნქცია.
ერთხელ თქვენ განხორციელდა, შეგიძლიათ კომპილაციის ამ გააკეთოს დასტის,
და შემდეგ აწარმოებს resultant დასტის შესრულებადი,
და რომელიც მიიღებს ყველა ამ გამოცდას კოდი ქვემოთ აქ რომ მთავარ.
და ძირითადი ზრუნავს რეალურად მიღების ბიძგი და საესტრადო მოუწოდებს
და დარწმუნებულიყო, რომ ყველაფერი გადის ყველა უფლება.
იგი ასევე ველში დასტის ზომა უფლება აქ
ასე რომ თქვენ არ უნდა ფიქრი, რომ ინიციალიზაციისას.
თქვენ შეიძლება ვივარაუდოთ, რომ ის სათანადოდ ინიციალიზაცია
იმ დროისთვის, რომ თქვენ შედიხართ ის pop ფუნქცია.
ამჯამად რომ აზრი?
ასე რომ აქ ჩვენ მივდივართ. აქ ბიძგი კოდი.
მე მივცემ თქვენ ბიჭები 5 ან 10 წუთი.
და თუ თქვენ გაქვთ რაიმე კითხვები შუალედურ ხოლო თქვენ კოდირება,
გთხოვთ ვთხოვთ მათ ხმამაღალი.
ასე რომ, თუ თქვენ მიიღებთ sticking წერტილი, ჰკითხეთ.
ნება მომეცით ვიცი, მოდით ყველას სხვაგან ვიცი.
მუშაობა თქვენი მეზობელი ძალიან.
[დანიელ] ჩვენ უბრალოდ განხორციელების pop წუთას? >> Just Pop.
თუმცა შეგიძლიათ კოპირება განხორციელების ბიძგი თუ გსურთ
ისე, რომ ტესტირება იმუშავებს.
რადგან ძნელია შესამოწმებლად რამ მისაღებად შევიდა -
ან, ძნელი გამოცდა popping ნივთების გატანას დასტის თუ არ არის არაფერი დასტის დავიწყოთ.
>> რა არის pop უნდა დაბრუნების? ელემენტს საწყისი ზევით Stack.
ის უნდა მიიღოს ელემენტს გამორთვა ზევით დასტის
და შემდეგ decrement ზომა დასტის,
და ახლა თქვენ დაკარგავთ ელემენტს ზედა.
და მაშინ დაბრუნდებიან ელემენტს ზედა.
[სტუდენტი გაუგებარია]
[Hardison] მერე რა მოხდება, თუ თქვენ ამას? [სტუდენტი გაუგებარია]
რა მთავრდება ხდება არის თქვენ ალბათ წვდომის ან
ელემენტს, რომელიც არ ინიციალიზდება ჯერჯერობით, ასე რომ თქვენი გაანგარიშება
სადაც ბოლო ელემენტს არის გამორთულია.
ასე რომ აქ, თუ თქვენ შეამჩნევთ, რომ ბიძგი, ჩვენ წვდომის სიმები საათზე s.size ელემენტს
იმიტომ რომ ახალი ინდექსი.
ეს ახალი ზევით Stack.
ხოლო pop, s.size იქნება შემდეგი სივრცეში,
სივრცე რომ თავზე ყველა ელემენტების თქვენი დასტის.
ასე რომ ყველაზე საუკეთესო ელემენტს არ არის s.size,
არამედ, ის ქვეშ იგი.
>> სხვა რამ უნდა გავაკეთოთ, როდესაც თქვენ - ში pop,
არის თუ თქვენ ჩვენგან უნდა decrement ზომა.
თუ გახსოვთ თავში ჩვენი პატარა დიაგრამაზე სწორედ აქ,
მართლაც, ერთადერთი, რაც ჩვენ ვნახეთ მაშინ, როცა ჩვენ მოუწოდა პოპ
იყო, რომ ეს ზომა დაეცა, პირველი და 2, შემდეგ 1.
მაშინ, როდესაც ჩვენ მივიღებთ ახალ ელემენტს შესახებ, რომ ის გაგრძელდება დათქმულ ადგილზე.
[ბასილ] თუ s.size არის 2, მაშინ არ ეს წასვლა ელემენტს 2,
და მაშინ ნეტავ გსურთ პოპ რომ ელემენტს off?
ასე რომ, თუ წავედით - >> მოდით შევხედოთ ამ ერთხელ.
თუ ეს ჩვენი დასტის ამ ეტაპზე
და მოვუწოდებთ pop,
სადაც ინდექსი არის ყველაზე საუკეთესო ელემენტს?
[ბასილ] # 2, მაგრამ აპირებს პოპ 3. >> მარჯვენა.
ასე რომ, სადაც ჩვენი ზომა არის 3, მაგრამ ჩვენ გვინდა, რომ პოპ ელემენტს საათზე ინდექსი 2.
ეს რომ ტიპიური სახის off ერთი, რომ თქვენ გაქვთ ერთად ნულოვანი ინდექსირებას მასივი.
ასე რომ თქვენ გსურთ პოპ მესამე ელემენტს, მაგრამ მესამე ელემენტს არ არის ინდექსი 3.
და მიზეზი ჩვენ არ უნდა გავაკეთოთ, რომ მინუს 1 როდესაც ჩვენ უბიძგებს
იმიტომ ახლავე, თქვენ შეამჩნევთ რომ ყველაზე საუკეთესო ელემენტს,
თუ ჩვენ დააყენებს რაღაც გადატანა დასტის ამ ეტაპზე,
ჩვენ გვინდა დააყენებს მას ინდექსი 3.
და ეს ასე მოხდება, რომ ზომა და მაჩვენებლების გამოდიან, როდესაც თქვენ დააჭერთ.
>> ვინ მიიღო სამუშაო დასტის განხორციელება?
თქვენ მოხვდით სამუშაო დასტის ერთ. გაქვთ pop სამუშაო ჯერ არ გაქვთ?
[დანიელ] დიახ. ვფიქრობ ასე.
>> პროგრამის გაშვებას და არ seg faulting, ეს დაბეჭდვისას?
იგი ამობეჭდოთ "წარმატება" როდესაც თქვენ გაუშვით?
Yeah. ჩადება დააწყობს, გაუშვით, თუ იგი ბეჭდავს out "წარმატება" და არ მიდის ბუმი
მაშინ ყველა კარგია.
ყველა უფლება. მოდით წავიდეთ მეტი ელექტრო მართლაც სწრაფად,
და ჩვენ გავლა ამ.
თუ დავაკვირდებით, რა ხდება აქ pop,
დანიელ, რა იყო პირველი, რაც თქვენ გააკეთეთ?
[დანიელ] თუ s.size მეტია 0.
[Hardison] Okay. და რატომ ასე?
[დანიელ], რათა დავრწმუნდეთ, რომ იყო რაღაც შიგნით Stack.
[Hardison] მარჯვენა. გსურთ შეამოწმოთ დავრწმუნდეთ, რომ s.size მეტია 0;
სხვაგვარად, თუ რა გსურთ არ მოხდეს?
[დანიელ] დაბრუნება null? >> დაბრუნება null, ზუსტად.
ასე რომ, თუ s.size მეტია 0. მაშინ რას აპირებს?
რას ვაკეთებთ თუ დასტის არ არის ცარიელი?
[Stella] თქვენ decrement ზომა? >> თქვენ decrement ზომა, okay.
ასე რომ როგორ ფიქრობთ ასე? >> S.size--.
[Hardison] დიდი. და მერე რა ვქნათ?
[Stella] და მერე განაცხადა დაბრუნების s.string [s.size].
[Hardison] დიდი.
წინააღმდეგ შემთხვევაში თქვენ დაბრუნებას null. დიახ, სემ?
[სემ] რატომ არ უნდა იყოს s.size + 1?
[Hardison] Plus 1? >> Yeah. >> Got It.
[სემ] მეგონა იმიტომ, რომ თქვენ იღებენ 1 out,
მაშინ თქვენ უნდა დაბრუნების არ ერთი, რომ მათ სთხოვეს.
[Hardison] და ეს მხოლოდ რა ჩვენ ვსაუბრობთ ამ მთელი საკითხი 0 მაჩვენებლების.
ასე რომ, თუ ჩვენ zoom უკან მეტი აქ.
თუ დავაკვირდებით ამ ბიჭს უფლება აქ, თქვენ ხედავთ, რომ როდესაც ჩვენ pop,
ჩვენ popping ელემენტს საათზე ინდექსი 2.
>> ამიტომ, ჩვენ შემცირდება ჩვენი ზომა პირველი, მაშინ ჩვენი ზომა შეესაბამება ჩვენი ინდექსი.
თუ ჩვენ არ decrement ზომა პირველი, მაშინ ჩვენ უნდა გავაკეთოთ ზომა -1 და შემდეგ decrement.
დიდი. ყველა კარგი?
ნებისმიერი კითხვები ამ?
არსებობს მთელი რიგი სხვადასხვა გზები, რათა დაეწერა ამ ისევე.
ფაქტობრივად, ჩვენ შეგვიძლია გავაკეთოთ რაღაც კი - შეგვიძლია გავაკეთოთ ერთი ლაინერი.
ჩვენ შეგვიძლია გავაკეთოთ ერთი ხაზის დაბრუნების.
ასე რომ ჩვენ შეგვიძლია რეალურად decrement სანამ დაბრუნებას აკეთებს, რომ.
ასე აყენებს - ადრე s.size.
ხდის ხაზი მართლაც მკვრივი.
სად სხვაობა - s. ზომა და s.size--
ის არის, რომ ამ postfix - ისინი ეძახით postfix რადგან - უძღოდა s.size--
იმას ნიშნავს, რომ s.size ფასდება მიზნით მოძიებაში ინდექსი
როგორც ეს არის გაკეთებული, როდესაც ამ ხაზს ხორციელდება,
და მაშინ ეს - ხდება შემდეგ ხაზი იღებს დასაჯეს.
შემდეგ ელემენტს საათზე ინდექსი s.size არის შემოწმდა.
და ეს არ არის ის, რაც ჩვენ გვინდა, იმიტომ, რომ ჩვენ გვინდა decrement მოხდეს პირველი.
Othewise, ჩვენ ვაპირებთ იყოს წვდომის მასივი, ეფექტურად, ფარგლებს გარეთ.
ჩვენ ვაპირებთ იყოს წვდომის ელემენტს ზემოთ ერთი, რომ ჩვენ ნამდვილად გინდათ შესვლა.
Yeah, სემ? >> ეს სწრაფად ან გამოიყენოს ნაკლები RAM, რათა ერთ ხაზზე თუ არა?
[Hardison] პატიოსნად, ნამდვილად არის დამოკიდებული.
[სემ, გაუგებარია] >> Yeah, ეს დამოკიდებულია. ამის გაკეთება შეგიძლიათ შემდგენელი tricks
მიიღოს შემდგენელი იმის აღიარება, რომ, როგორც წესი, მე წარმოვიდგენდი.
>> ამიტომ, ჩვენ ახსენეთ ცოტა ამ შემდგენელი ოპტიმიზაციის პერსონალის
რომ თქვენ შეგიძლიათ გავაკეთოთ შედგენა,
და ეს სახის რამ, შემდგენელი შესაძლოა გაერკვნენ,
მოსწონს oh, hey, იქნებ შემიძლია ამ ყველა ერთ ოპერაციას,
როგორც ეწინააღმდეგებოდა დატვირთვისა ზომა ცვლადი in საწყისი RAM,
decrementing ის, შენახვა უკან out, და შემდეგ ჩატვირთვის მას უკან ისევ
დავამუშავოთ დანარჩენი ამ ოპერაციის.
მაგრამ, როგორც წესი, არა, ეს არ არის ერთგვარი რამ
რომ ხდება, რომ თქვენი პროგრამა მნიშვნელოვნად უფრო სწრაფად.
აღარ შეკითხვებს stacks?
>> ასე რომ უბიძგებს და popping. თუ ბიჭებს შევეცდები out Hacker გამოცემა,
რაც ჩვენ გავაკეთეთ წელს Hacker გამოცემა ფაქტობრივად წასული
და ამ დასტის იზრდება დინამიურად ვითარდება.
გამოწვევა არსებობს, პირველ რიგში, აქ წელს ბიძგი ფუნქცია,
გაერკვნენ, თუ როგორ უნდა მიიღოს, რომ მასივი იზრდება
როგორც თქვენ გაქვთ უბიძგებს უფრო და უფრო ელემენტების შესახებ, რომ დასტის.
ეს რეალურად არ არის ძალიან ბევრი დამატებითი კოდი.
უბრალოდ ზარი - თქვენ უნდა გვახსოვდეს, მიიღოს ზარები malloc იქ სწორად,
და შემდეგ გაერკვნენ, როდესაც თქვენ ვაპირებ მოვუწოდო realloc.
სწორედ გართობა გამოწვევა თუ თქვენ დაინტერესებული.
>> მაგრამ ამ დროისათვის, მოდით გადაადგილება, და ვისაუბროთ იმაზე რიგები.
Scroll მეშვეობით აქ.
რიგში არის მჭიდრო ძმა of Stack.
ასე რომ, დასტის, რამ იყო უკანასკნელი
იყო პირველი რამ მაშინ იქნება მიღებული.
გვაქვს ამ ბოლო წელს, პირველი მათგანი, ან LIFO, შეკვეთით.
ხოლო მდგომ, როგორც ნეტავ მოველით, როდესაც თქვენ რიგში მდგომ,
პირველი პირი კიდევ გამოდიან, პირველი რაც შეღწევას მდგომ,
არის პირველი რამ რომ იღებს მოძიებულია რიგიდან.
რიგები ასევე ხშირად გამოიყენება, როდესაც ჩვენ საქმე გრაფიკების,
როგორც ჩვენ ვისაუბრეთ მოკლედ ერთად stacks,
და რიგები ასევე მოსახერხებელი ამისთვის bunch სხვა რამ.
ერთი რამ, რომ მოდის up ხშირად ცდილობს შეინარჩუნოს, მაგალითად,
დახარისხებული სიის ელემენტების.
და ამისათვის ერთად მასივი. თქვენ შეგიძლიათ შენარჩუნება დახარისხებული ჩამონათვალი რამ მასივი,
მაგრამ აქ რომ იღებს სახიფათო არის მაშინ ყოველთვის უნდა მოვძებნოთ
შესაბამის ადგილზე ჩასასმელად შემდეგი რამ.
ასე რომ, თუ თქვენ გაქვთ მასივი ნომრები, 1 მეშვეობით 10,
და შემდეგ გსურთ გაფართოებას, რომ ყველა ციფრები 1 მეშვეობით 100,
და თქვენ მისაღებად ამ ნომრები შემთხვევითი წესრიგისა და ცდილობს შეინარჩუნოს ყველაფერი
დალაგებულია როგორც თქვენ გავლა, თქვენ დასრულდება მდე მქონე ბევრი გადავიდა.
გარკვეული სახის რიგები და გარკვეული სახის ძირითადი მონაცემები სტრუქტურების,
შეგიძლიათ პრაქტიკულად შეინახოს იგი საკმაოდ მარტივია.
თქვენ არ უნდა დაამატოთ რაიმე და შემდეგ რეორგანიზაციის მთელი რამ ყოველ ჯერზე.
არც თქვენ უნდა გავაკეთოთ ბევრი გადავიდა შიდა ელემენტების გარშემო.
შევხედოთ მდგომ, ხედავთ, რომ - ასევე queue.c განყოფილებაში კოდი -
struct რომ ჩვენ მოცემული მართლაც მსგავსი struct რომ მივეცით თქვენ დასტის.
>> თუმცა ერთი გამონაკლისი ამ, და რომ ერთი გამონაკლისი
არის ის, რომ ჩვენ გვაქვს ეს დამატებითი რიცხვი მოუწოდა ხელმძღვანელი,
და უფროსი აქ არის შესანახად სიმღერა უფროსის მდგომ,
ან პირველი ელემენტია რიგიდან.
With დასტის, ჩვენ შეგვეძლო ტრეკზე ელემენტს, რომ ჩვენ ვიყავით დაახლოებით ვიღებ,
ან ზევით დასტის გამოყენებით უბრალოდ ზომა,
ხოლო ერთად მდგომ, ჩვენ მქონე გამკლავება საპირისპირო შაბათ.
ჩვენ ვცდილობთ, რომ Tack რამ წლის მიწურულს, მაგრამ შემდეგ დაბრუნდნენ ნივთები ფრონტზე.
იმდენად ეფექტურად, უფროსთან, ჩვენ გვაქვს მაჩვენებელი დასაწყისში მდგომ,
და ზომა გვაძლევს ინდექსი ბოლოს მდგომ
ასე, რომ ჩვენ შეგვიძლია მივიღოთ ნივთები ხელმძღვანელი და დაამატოთ რამ შესახებ, რომ კუდი.
ვინაიდან ერთად დასტის, ჩვენ მხოლოდ ოდესმე საქმე ზევით Stack.
ჩვენ არასდროს ჰქონია წვდომისათვის ბოლოში დასტის.
ჩვენ მხოლოდ რამ დაბრუნება და აიღო რამ გამორთვა დაბრუნება
ამიტომ ჩვენ არ გვჭირდება, რომ ზედმეტი სფეროში შიგნით ჩვენი struct.
ამჯამად რომ ზოგადად აზრი?
ყველა უფლება. დიახ, Charlotte? [Charlotte, გაუგებარია]
[Hardison] სწორედ დიდი კითხვა, და რომ იყო ერთი, რომ მოვიდა ლექციების.
იქნებ გავლით რამდენიმე მაგალითი იქნება საილუსტრაციოდ, თუ რატომ
ჩვენ არ გვინდა, რომ გამოიყენოთ სტრიქონები [0] უფროსად რიგიდან.
>> ასე რომ წარმოიდგინეთ, რომ ჩვენ გვაქვს ჩვენი მდგომ, ჩვენ ვაპირებთ ეძახით რიგიდან.
თავდაპირველად, როცა ჩვენ უბრალოდ instantiated ის,
როდესაც ჩვენ უბრალოდ გამოაცხადა, ჩვენ არ ინიციალიზდება არაფერი.
ეს ყველაფერი ნაგავი. ასე რომ, რა თქმა უნდა ჩვენ გვინდა დავრწმუნდეთ, რომ ჩვენ ინიციალიზაცია
ორივე ზომა და ხელმძღვანელი სფეროები იქნება 0, რაღაც გონივრული.
ჩვენ შეგვიძლია აგრეთვე წავიდეთ წინ და null out ელემენტები ჩვენს რიგიდან.
და იმისთვის, რომ ეს სქემა მორგებული, რომ ახლა ჩვენი მდგომ შეიძლება მხოლოდ გამართავს სამი ელემენტები;
ხოლო ჩვენი დასტის შეიძლება გამართავს ოთხი, ჩვენი მდგომ შეიძლება მხოლოდ გამართავს სამი.
და ეს მხოლოდ იმისათვის, რომ დიაგრამაზე მორგებული.
პირველი, რაც ხდება აქ არის ჩვენ enqueue სტრიქონი "hi".
და მხოლოდ ისე, როგორც ერთად დასტის, არაფერი საშინლად სხვადასხვა აქ,
ჩვენ გადაყარეთ string ზე სტრიქონები [0] და ნამატი ჩვენი ზომა მიერ 1.
ჩვენ enqueue "bye", იგი იღებს ჩაიცვი.
ასე რომ, ეს ჰგავს დასტის ამისთვის დიდი ნაწილი.
ჩვენ დავიწყეთ off აქ, ახალ ელემენტს, ახალი ელემენტი, ზომა ინახავს იზრდებოდა.
რა ხდება ამ ეტაპზე, როცა ჩვენ გვინდა dequeue რაღაც?
როდესაც ჩვენ გვინდა dequeue, რომელიც ელემენტს, რომ ჩვენ გვინდა dequeue?
[ბასილ] სტრიქონები [0]. >> Zero. სწორედ, ბასილ.
ჩვენ გვინდა, რომ თავი დაეღწია პირველი სიმებიანი, ამ ერთი, "hi".
რა იყო სხვა საქმეა, რომ შეიცვალა?
გაითვალისწინეთ, როდესაც ჩვენ popped რაღაც გამორთვა დასტის, ჩვენ უბრალოდ შეიცვალა ზომა,
მაგრამ აქ, გვაქვს რამდენიმე რამ, რომ ცვლილება.
არა მარტო ზომა ცვლილება, მაგრამ ხელმძღვანელი ცვლილებები.
ეს ბრუნდება Charlotte მოსაზრებით ადრე:
რატომ გვყავს ამ ხელმძღვანელი ისევე?
ამჯამად ეს აზრი არის, Charlotte? >> სახის.
[Hardison] სახის? მერე რა მოხდა, როცა ჩვენ dequeued?
რა ხელმძღვანელი გავაკეთოთ, რომ ახლა არის საინტერესო?
[Charlotte] Oh, რადგან ეს შეიცვალა - okay. მე ვხედავ.
რადგან ხელმძღვანელი - სადაც უფროსი არის მიუთითებს ცვლილებების თვალსაზრისით საიდან.
ეს აღარ ყოველთვის ნულოვანი ინდექსი ერთი. >> ჰო, ზუსტად.
რა მოხდა, თუ dequeueing მაღალი ელემენტს
გაკეთდა და არ გვქონდა ამ სფეროში ხელმძღვანელი
რადგან ჩვენ ყოველთვის მოუწოდებდა ეს კონტექსტი at 0 ინდექსი ხელმძღვანელი ჩვენი მდგომ,
მაშინ ჩვენ ავღნიშნო უნდა გადაეტანა დანარჩენი მდგომ ქვემოთ.
მე მინდა უნდა გადაიტანოს "bye" საწყისი საწყისი სტრიქონები [1] რათა სტრიქონები [0].
და სიმებიანი [2] ქვემოთ სტრიქონები [1].
და ჩვენ გვინდა უნდა გავაკეთოთ ეს მთელი სიაში ელემენტები,
მთელი რიგი ელემენტები.
ხოლო როდესაც ვაკეთებთ ამ მასივი, რომ იღებს მართლაც ძვირი.
ასე რომ აქ, ეს არ დიდი გარიგება. ჩვენ მხოლოდ სამი ელემენტები ჩვენს მასივი.
მაგრამ თუ ჩვენ გვქონდა რიგი ათასი ელემენტები ან მილიონი ელემენტები,
და მერე უეცრად, ჩვენ ვიწყებთ მიღების bunch of dequeue მოუწოდებს ყველა მარყუჟის,
რამ ნამდვილად აპირებს შენელდება როგორც ეს ინაცვლებს ყველაფერი ქვევით მუდმივად.
თქვენ იცით, გადაეტანა მიერ 1, ცვლა მიერ 1, ცვლა მიერ 1, ცვლა მიერ 1.
სამაგიეროდ, ჩვენ ვიყენებთ ამ ხელმძღვანელი, ჩვენ მას "კურსორი" მიუხედავად იმისა, რომ ეს ნამდვილად არ მომცეთ
წელს მკაცრი გაგებით, ეს არ მომცეთ ტიპის.
ეს არ int * ან char * ან რამე მაგდაგვარს.
მაგრამ მიუთითებს ან მითითებით ხელმძღვანელი ჩვენი რიგიდან. ჰო?
>> [სტუდენტური] როგორ ამჯამად dequeue ვიცი უბრალოდ პოპ off რაც სათავეში?
[Hardison] როგორ ამჯამად dequeue ვიცი როგორ პოპ off რასაც არის სათავეში? >> მარჯვენა, yeah.
>> რასაც ის ეძებს მხოლოდ რასაც ხელმძღვანელი სფეროში არის მითითებული.
ამიტომ ამ პირველ შემთხვევაში, თუ გადავხედავთ უფლება აქ,
ჩვენი ხელმძღვანელი არის 0, ინდექსი 0. >> მარჯვენა.
[Hardison] ასე რომ უბრალოდ ამბობს okay, ისევე, ელემენტს საათზე ინდექსი 0, სტრიქონი "hi",
არის ელემენტს სათავეში ჩვენი რიგიდან.
ამიტომ, ჩვენ ვაპირებთ, რომ dequeue guy.
და რომ იქნება ელემენტს რომ იღებს დაბრუნდა Caller.
დიახ, Saad? >> ამიტომ ხელმძღვანელი ძირითადად ადგენს - სადაც თქვენ აპირებთ მაჩვენებლით იგი?
სწორედ დაწყების ეს? >> Yeah. >> Okay.
[Hardison] სწორედ ხდება ახალი სტარტის ჩვენი მასივი.
ასე რომ, როდესაც თქვენ dequeue რაღაც, ყველა თქვენ უნდა გააკეთოთ შედიხართ ელემენტს საათზე ინდექსი q.head,
და რომ იქნება ელემენტს რომ გსურთ dequeue.
თქვენ ასევე უნდა decrement ზომა.
ჩვენ ვხედავთ ცოტა აქ რამ კიდევ ცოტა სახიფათო ამ.
ჩვენ dequeue, და ახლა, თუ ჩვენ enqueue ერთხელ,
სად ჩვენ enqueue?
სად მომდევნო ელემენტს წავიდეს ჩვენი მდგომ?
Say გვინდა enqueue სტრიქონი "CS".
, სადაც ინდექსი იქნება ეს წასვლა? [სტუდენტთა] სტრიქონები [2]. >> ორი.
რატომ 2 და არა 0?
[ბასილ] რადგან ახლა უფროსი არის 1, ასე რომ ჰგავს დაწყების სიაში?
[Hardison] მარჯვენა. და რა ნიშნავს სიის ბოლოში?
რა იყო ჩვენ იყენებს აღინიშნოს ბოლოს ჩვენი მდგომ?
უფროსი არის უფროსი ჩვენი მდგომ, დასაწყისში ჩვენი რიგიდან.
რა არის ბოლოს ჩვენი მდგომ? [სტუდენტთა] ზომა. >> ზომა, ზუსტად.
ასე რომ ჩვენი ახალი ელემენტები წავიდეს საათზე ზომა, და ელემენტები რომ ჩვენ გამეხადა მოდის გამორთვას ხელმძღვანელი.
როდესაც ჩვენ enqueue შემდეგი ელემენტის, ჩვენ აყენებს მას დროს ზომა.
[სტუდენტური] სანამ დააყენა, რომ თუმცა, ზომა იყო 1, არა?
[Hardison] მარჯვენა. ასე რომ არ საკმაოდ საათზე ზომა. ზომა +, არ +1, მაგრამ + ხელმძღვანელი.
იმიტომ, რომ ჩვენ გადაინაცვლა ყველაფერი ხელმძღვანელის მიერ თანხა.
ასე რომ აქ, ახლა გვაქვს რიგი ზომა 1 რომ იწყება ინდექსი 1.
კუდი არის ინდექსი 2. დიახ?
>> [სტუდენტური] რა ხდება, როდესაც თქვენ dequeue სტრიქონები [0], და სტრიქონები 'slots ხსოვნის
უბრალოდ დაიცალა, ძირითადად, ან უბრალოდ დავიწყებული?
[Hardison] Yeah. ამ თვალსაზრისით, ჩვენ უბრალოდ ივიწყებს მათ.
თუ ჩვენ შენახვის ასლები მათ -
ბევრი მონაცემები სტრუქტურების ხშირად შესანახად საკუთარი ასლები ელემენტები
ისე, რომ პირი მართვის მონაცემები სტრუქტურა ამჯამად არ ინერვიულოთ
შესახებ, სადაც ყველა იმ მითითებას ვაპირებთ.
მონაცემები სტრუქტურა ფლობს შესახებ, რომ ყველაფერი, ფლობს შესახებ, რომ ყველა ეგზემპლარი,
რომ დავრწმუნდეთ, რომ ყველაფერი კვლავ სათანადოდ.
თუმცა, ამ შემთხვევაში, ეს მონაცემები სტრუქტურების უბრალოდ, სიმარტივის,
არ მიღების ასლები არაფერი რომ ჩვენ შენახვის მათ.
[სტუდენტური] ასე არის ეს უწყვეტი მასივი -? >> დიახ.
თუ ჩვენ ვიხსენებთ რა განმარტება იყო ამ სტრუქტურის, ის არის.
უბრალოდ სტანდარტული მასივი თქვენნაირი ვხედავთ,
მასივი char * s.
Does რომ -? >> ჰო, მე უბრალოდ მაინტერესებს
თუ თქვენ საბოლოოდ ამოიწურა მეხსიერება, გარკვეულწილად,
თუ თქვენ გაქვთ ყველა ამ ცარიელი ლაქების თქვენს მასივი?
[Hardison] ჰო, კარგი წერტილი.
>> თუ დავაკვირდებით, რა მოხდა ახლა, ამ ეტაპზე,
ჩვენ შეივსო ჩვენი მდგომ, გამოიყურება.
მაგრამ ჩვენ ნამდვილად არ შეივსო ჩვენი მდგომ
იმიტომ რომ ჩვენ გვაქვს მდგომ რომ ზომა 2, მაგრამ ეს იწყება ინდექსი 1,
რადგან ისინი, სადაც ჩვენი უფროსი კურსორი არის.
თქვენნაირი ამბობდნენ, რომ ელემენტს საათზე სტრიქონები [0], საღამოს ინდექსი 0, არ არის ნამდვილად არსებობს.
ეს არ არის ჩვენი მდგომ უქმნით.
ჩვენ უბრალოდ არ გადაიტვირთოთ წავიდეთ და გადაწერა, როდესაც ჩვენ dequeued იგი.
ასე რომ მიუხედავად იმისა, რომ ჰგავს ჩვენ ამოიწურა მეხსიერება, ჩვენ ნამდვილად არ.
რომ ადგილზე ხელმისაწვდომია ჩვენთვის გამოიყენოს.
შესაბამისი ქცევა, თუ ჩვენ უნდა შევეცადოთ და პირველი dequeue რაღაც
როგორც "bye", რომელიც პოპ bye off.
ახლა ჩვენი მდგომ იწყება ინდექსი 2 და არის ზომა 1.
და ახლა თუ ჩვენ ვცდილობთ და enqueue რაიმეს, ვთქვათ 50,
50 უნდა წავიდეს ამ ადგილზე დროს ინდექსი 0
იმიტომ რომ ჯერ კიდევ არის შესაძლებელი ჩვენთვის. დიახ, Saad?
[Saad] არა, რომ მოხდეს ავტომატურად?
[Hardison] ეს არ მოხდება საკმაოდ ავტომატურად. ამისათვის მათემატიკის
რათა ის იმუშავებს, მაგრამ არსებითად, რაც ჩვენ გავაკეთეთ არის ჩვენ უბრალოდ გახვეული გარშემო.
[Saad] და ეს okay, თუ ეს ხვრელი შუა იგი?
[Hardison] ეს თუ შეიძლება გავაკეთოთ მათემატიკის შეიმუშაოს სათანადოდ.
>> და აღმოჩნდება, რომ სინამდვილეში არ არის, რომ ძნელია საერთო mod ოპერატორს.
ასე რომ, ისევე, როგორც ჩვენ შემოიერთა Caesar და შიფრის პერსონალის,
გამოყენებით mod, ჩვენ შეუძლია მიიღოს რამ გადაიტანოთ გარშემო და შეინახოს აპირებს
გარშემო და ირგვლივ და გარშემო ჩვენს მდგომ,
შენახვა, რომ ხელმძღვანელი მაჩვენებელი გადაადგილდებოდნენ.
გაითვალისწინეთ, რომ ზომის ყოველთვის პატივისცემის რაოდენობის ელემენტები რეალურად ფარგლებში რიგი.
და ეს მხოლოდ უფროსის მაჩვენებელი, ინახავს Cycling მეშვეობით.
თუ დავაკვირდებით, თუ რა მოხდა აქ, თუ ჩვენ დავუბრუნდებით დასაწყისში,
და უბრალოდ უყურეთ რა მოსდის ხელმძღვანელი
როდესაც ჩვენ enqueue რაღაც, არაფერი მოხდა ხელმძღვანელი.
როდესაც ჩვენ enqueued რაღაც, არაფერი მოხდა ხელმძღვანელი.
მალე ჩვენ dequeued რაღაც, უფროსი მიდის up ერთი.
ჩვენ enqueued რაღაც, არაფერი მოხდება, უფროსი.
როდესაც ჩვენ dequeue რაღაც, უეცრად ხელმძღვანელი იღებს incremented.
როდესაც ჩვენ enqueue რაღაც, არაფერი მოხდება, უფროსი.
>> რა მოხდება, ამ ეტაპზე, თუ ჩვენ dequeue რაიმეს?
ნებისმიერი აზრები? რა მოხდება რომ ხელმძღვანელი?
რა უნდა მოხდეს, რათა უფროსმა
თუ ჩვენ უნდა dequeue რაღაც?
ხელმძღვანელი ახლავე არის ინდექსი 2,
რაც იმას ნიშნავს, რომ ხელმძღვანელი მდგომ არის სტრიქონები [2].
[სტუდენტური], რომელიც დააბრუნებს 0? >> იგი უნდა დაუბრუნდეს 0. უნდა გადაიტანოთ უკან გარშემო, ზუსტად.
ჯერჯერობით, ყოველ ჯერზე ჩვენ მოუწოდა dequeue, ჩვენ დასძინა ერთი ხელმძღვანელი,
დაამატოთ ერთი ხელმძღვანელი, დაამატოთ ერთი ხელმძღვანელი, დაამატოთ ერთი ხელმძღვანელი.
როგორც კი რომ ხელმძღვანელი კურსორი იღებს ბოლო ინდექსი ჩვენს მასივი,
მაშინ ჩვენ უნდა გადაიტანოთ უკან გარშემო დასაწყისში, დავუბრუნდეთ 0.
[Charlotte] რა განსაზღვრავს რანგში რიგში დასტის?
[Hardison] ამ შემთხვევაში ჩვენ უბრალოდ იყენებს # განსაზღვრული მუდმივი. >> Okay.
[Hardison] თავად. გ ფაილის, შეგიძლიათ გადასვლა და Muck მასთან ცოტა
და იყოს იგი, როგორც დიდი თუ როგორც პატარა, როგორც გსურთ.
[Charlotte] ასე რომ, როდესაც თქვენ რაც მას მდგომ, როგორ გავხადოთ კომპიუტერის ვიცი
რამდენად დიდი გსურთ დასტის იქნება?
[Hardison] სწორედ დიდი კითხვაზე.
არსებობს რამდენიმე გზა არსებობს. ერთი არის ის, რომ მხოლოდ განსაზღვროს ის წინა
და ამბობენ, რომ ეს იქნება მდგომ რომ აქვს 4 ელემენტები ან 50 ელემენტები ან 10,000.
სხვა გზა არის რა ჰაკერი გამოცემა FOLKS ვაკეთებთ
და შექმნას ფუნქციები თქვენი მდგომ იზრდება დინამიურად როგორც რამ მისაღებად დასძინა სისტემაში
>> [Charlotte] ასე წავიდეთ ერთად პირველი ვარიანტი, რა სინტაქსი იყენებთ
ვუთხრა პროგრამის რა არის ზომა მდგომ?
[Hardison] Ah. მოდით გავიდნენ ამ.
მე ჯერ კიდევ stack.c აქ, ამიტომ მე უბრალოდ აპირებს გადახვევა მდე დაბრუნება აქ.
აბა ნახეთ ეს უფლება აქ? ეს არის # განსაზღვრავს ტევადობა 10.
და ეს არის თითქმის ზუსტად იგივე სინტაქსი, რომ ჩვენ გვაქვს ამისთვის რიგიდან.
გარდა რიგში, ჩვენ მივიღეთ, რომ ზედმეტი struct სფეროში აქ.
[Charlotte] Oh, ვიფიქრე მოცულობა ნიშნავდა ტევადობა სიმებიანი.
[Hardison] Ah. >> რომ მაქსიმალური სიგრძე სიტყვა. >> Got It.
Yeah. სიმძლავრე აქ - რომ დიდი წერტილი.
და ეს არის ის, რომ სახიფათო
რადგან ის, რაც ჩვენ განაცხადა აქ არის მასივი char * s.
მასივი პოინტერები.
ეს არის მასივი სიმბოლო.
ეს არის ალბათ, რასაც თქვენ ვხედავთ, როდესაც თქვენ უკვე გამოცხადების თქვენი ბუფერი ამისთვის ფაილის I / O,
როდესაც თქვენ უკვე შექმნა სიმები ხელით on Stack.
თუმცა, რა გვაქვს აქ არის მასივი char * s.
ამიტომ მასივი პოინტერები.
სინამდვილეში, თუკი ჩვენ უკან zoom out და შევხედავთ რა ხდება აქ
in პრეზენტაცია, ხედავთ, რომ ფაქტობრივი ელემენტები, ხასიათი მონაცემები
არ ინახება ფარგლებში მასივი თავისთავად.
რა ინახება შიგნით ჩვენი მასივი აქ მითითებას ხასიათი მონაცემები.
Okay. ასე რომ, ჩვენ ვხედავთ, თუ როგორ ზომა მდგომ უბრალოდ ისევე დასტის,
ზომა ყოველთვის პატივს სცემს რაოდენობის ელემენტები ამჟამად რიგიდან.
შემდეგ 2 enqueues, ზომა არის 2.
შემდეგ dequeue ზომა არის 1.
შემდეგ კიდევ ერთი enqueue ზომა არის უკან მდე 2.
ასე ზომა ნამდვილად პატივს სცემს რაოდენობის ელემენტების რიგში,
და შემდეგ ხელმძღვანელი მხოლოდ ინახავს Cycling.
იგი მიემართება 0-1-2, 0-1-2, 0-1-2.
და ყოველ ჯერზე ჩვენ მოვუწოდებთ dequeue, უფროსი კურსორი იღებს incremented მომდევნო ინდექსი.
და თუ ხელმძღვანელი დაახლოებით წასვლა მეტი, ის მარყუჟების უკან გარშემო 0.
ასე რომ, ჩვენ შეგვიძლია დავწეროთ dequeue ფუნქცია.
და ჩვენ მიემგზავრება enqueue ფუნქცია თქვენ ბიჭები განახორციელოს ნაცვლად.
>> როდესაც ჩვენ dequeue ელემენტს ჩვენი მდგომ,
რა იყო პირველი, რაც გააკეთა დენიელ როდესაც ჩვენ დავიწყეთ წერა pop ფუნქცია stacks?
ნება მომეცით მოვისმინოთ ვინმეს არ გამოუთქვამს არავის გაუკეთებია.
ვნახოთ, Saad, გახსოვთ რას დანიელ გააკეთეს როგორც პირველი, რაც მაშინ, როდესაც მან დაწერა Pop?
[Saad] იყო, ეს იყო - >> მან ტესტირება რაღაც.
[Saad] თუ ზომა მეტია 0. >> ზუსტად.
და რა იყო, რომ ტესტირება?
[Saad] ამის ტესტირების თუ არსებობს რაიმე შიგნით მასივი.
[Hardison] Yeah. სწორედ. ასე, რომ თქვენ ვერ პოპ არაფერი გარეთ დასტის თუ ცარიელი.
ანალოგიურად, ვერ dequeue არაფერს მდგომ თუ ცარიელი.
რა არის პირველი რამ უნდა გავაკეთოთ ჩვენი dequeue ფუნქცია აქ, როგორ ფიქრობთ?
[Saad] თუ ზომა მეტია 0? >> Yeah.
ამ შემთხვევაში, მე რეალურად მხოლოდ გამოცდილი, რომ ნახოთ თუ ის არის 0.
თუ ეს 0, შეგვიძლია დაბრუნების null.
მაგრამ ზუსტად იგივე ლოგიკით.
და მოდით გავაგრძელოთ ამ.
თუ ზომა არ არის 0, სად არის ელემენტს, რომ ჩვენ გვინდა dequeue?
[Saad] სათავეში? >> ზუსტად.
ჩვენ შეგვიძლია მხოლოდ გაიყვანოს პირველი ელემენტია ჩვენი მდგომ
შესვლით ელემენტს სათავეში.
არაფერი გიჟები.
ამის შემდეგ, რა უნდა გავაკეთოთ? რა უნდა მოხდეს?
რა იყო სხვა რამ, რომ ჩვენ ვისაუბრეთ იმ dequeue?
ორი რამ უნდა მოხდეს, რადგან ჩვენი მდგომ შეიცვალა.
[დანიელ] შემცირება ზომა. >> ჩვენ უნდა შეამციროს ზომა, და გაზრდის ხელმძღვანელი? სწორედ.
გაზრდის ხელმძღვანელი, ჩვენ შეგვიძლია არა მხოლოდ ბრმად გაზრდა ხელმძღვანელი, მახსოვს.
ჩვენ არ შეგვიძლია უბრალოდ queue.head + +.
ჩვენ უნდა შეიცავდეს აგრეთვე ამ mod მიერ მოცულობა.
რატომ ჩვენ თავდაცვის სამინისტროს მიერ მოცულობა, Stella?
[Stella] იმიტომ, რომ მან უნდა გადაიტანოთ გარშემო. >> ზუსტად.
ჩვენ mod მიერ მოცულობა, რადგან ის უნდა გადაიტანოთ უკან გარშემო 0.
ასე რომ ახლა, ამ ეტაპზე, ჩვენ შეგვიძლია გავაკეთოთ ის, რაც დანიელ განაცხადა.
ჩვენ შეგვიძლია decrement ზომა.
და მაშინ ჩვენ შეგვიძლია უბრალოდ დააბრუნოს ელემენტს რომ იყო ზედა რიგში.
როგორც ჩანს სახის gnarly თავდაპირველად. ალბათ კითხვა. უკაცრავად?
>> [სემ] რატომ არის პირველი ზედა რიგში? სად, რომ წავიდეთ?
[Hardison] მოდის მეოთხე ხაზის ბოლოში.
შემდეგ ჩვენ ვამოწმებთ დავრწმუნდეთ, რომ ჩვენი მდგომ არ არის ცარიელი,
ჩვენ გაიყვანოს char * პირველი, ჩვენ გაიყვანოს ელემენტს რომ ზის ხელმძღვანელი ინდექსი
ჩვენი მასივი, ჩვენი სიმები მასივი, >> და მოწოდება, რომ პირველი?
[Hardison] და ჩვენ მას პირველი. Yeah.
უბრალოდ თვალყური რომ, როგორ ფიქრობთ, რატომ გვქონდა ამის გაკეთება?
[სემ] ყოველი პირველი უბრალოდ დაბრუნების q.strings [q.head]? >> Yeah.
>> გამო ვაკეთებთ ამ ცვლილებები q.head ერთად თავდაცვის სამინისტროს ფუნქცია,
და არ არსებობს გზა ამის, რომ ვადაში დაბრუნების ხაზი ასევე.
[Hardison] ზუსტად. თქვენ ადგილზე. სემ სრულიად ადგილზე.
მიზეზი გვქონდა გაიყვანოს პირველი ელემენტია ჩვენი მდგომ და ჩაწეროთ იგი შევიდა ცვლადი
არის იმიტომ, რომ ეს ხაზი, სადაც ჩვენ უბრალოდ q.head,
არსებობს თავდაცვის სამინისტროს ოპერატორი არ არის რაღაც, რაც ჩვენ შეგვიძლია გავაკეთოთ
და არ ხდება გავლენას ხელმძღვანელი გარეშე - ერთ ხაზზე.
ამიტომ, ჩვენ რეალურად უნდა გაიყვანოს პირველ ელემენტს, მაშინ შეცვალოს ხელმძღვანელი,
შეცვალოს ზომა, ხოლო შემდეგ დაბრუნდნენ ელემენტს რომ ჩვენ გაყვანილია.
და ეს არის ის, რომ ჩვენ დავინახავთ ამუშავება მოგვიანებით
უკავშირდება სიები, როგორც ჩვენ თამაშობენ გარშემო მათთან.
ხშირად, როდესაც თქვენ გამონთავისუფლების ან არსებითად დაკავშირებულია სიები
თქვენ უნდა გვახსოვდეს შემდეგი ელემენტის, შემდეგი მაჩვენებელი საქართველოს უკავშირდება სია
ადრე განკარგვის მიმდინარე ერთი.
რადგან, წინააღმდეგ შემთხვევაში თქვენ გადაყარეთ ინფორმაციით, რა დარჩა სიაში.
ახლა კი, თუ წასვლა თქვენი მოწყობილობის, თქვენ გახსენით queue.c--x ამ.
ასე რომ, თუ მე გახსენით queue.c, ნება მომეცით მიუახლოვდით აქ,
თქვენ ნახავთ, რომ თქვენ გაქვთ მსგავსი ორიენტირებული ფაილი.
მსგავსი ორიენტირებული ფაილი რა გვქონდა ადრე stack.c.
გვაქვს ჩვენი struct ამისთვის მდგომ განსაზღვრული, ისევე როგორც დავინახეთ on სლაიდები.
>> ჩვენ გვაქვს ჩვენი enqueue ფუნქცია რომელიც თქვენთვის უნდა გააკეთოს.
და ჩვენ გვაქვს dequeue ფუნქცია აქ.
Dequeue ფუნქცია ფაილი unimplemented,
მაგრამ მე ამას უკან მდე PowerPoint ასე რომ თქვენ შეგიძლიათ აკრიფოთ ის, თუ გსურთ.
ასე რომ, მომავალი 5 წუთის ან ისე, თქვენ ბიჭები მუშაობა enqueue
რომელიც თითქმის მხოლოდ საპირისპირო dequeue.
თქვენ არ შეცვალოს ხელმძღვანელი როცა თქვენ enqueueing, მაგრამ რას უნდა შეცვალოს?
ზომა. ასე რომ, როდესაც თქვენ enqueue, უფროსი რჩება ხელშეუხებელი, ზომა იღებს შეიცვალა.
მაგრამ ეს იმას იღებენ ცოტა - თქვენ უნდა ითამაშოს გარშემო რომ mod
გაერკვნენ, თუ რა ინდექსი ახალ ელემენტს უნდა ჩასმული დროს.
ამიტომ მე მივცემ თქვენ ბიჭები ცოტა, დაუსვან dequeue back up on the slide,
და როგორც თქვენ ბიჭებს აქვთ კითხვები, shout მათ, რათა შევძლოთ
ყველა საუბარი მათ ჯგუფს.
ასევე, ერთად ზომა თქვენ don't - როდესაც თქვენ შეცვალოს ზომა, თქვენ ყოველთვის შეგიძლიათ უბრალოდ -
გაქვთ mod ზომა ოდესმე? [დანიელ] მდებარ >> თქვენ არ mod ზომა, სწორი.
რადგან ზომა ყოველთვის, თუ you're - ვთქვათ, თქვენ მმართველი რამ სათანადოდ,
ზომა ყოველთვის იყოს 0 და 3.
სად უნდა mod როდესაც თქვენ აკეთებთ enqueue?
[სტუდენტური] მხოლოდ ხელმძღვანელი. >> მხოლოდ ხელმძღვანელი, ზუსტად.
რატომ უნდა mod ყველა იმ enqueue?
როდესაც არის სიტუაცია, რომელიც ნეტავ უნდა mod?
[სტუდენტური] თუ თქვენ გაქვთ პერსონალის at ფართები, მოსწონს ის ფართების 1 და 2
და მაშინ საჭიროა დაამატოთ რაღაც at 0.
[Hardison] ჰო, ზუსტად. ასე რომ, თუ თქვენი უფროსი მაჩვენებელი არის ძალიან დასასრულს,
ან თუ თქვენი ზომა Plus თქვენი უფროსი მეტია, უფრო სწორად, აპირებს გადაიტანოთ გარშემო მდგომ.
>> ასე რომ ამ სიტუაციაში, რომ გვაქვს აქ on the slide ახლავე,
თუ მინდა enqueue რაღაც ახლავე,
ჩვენ გვინდა enqueue რაღაც ეტაპზე ინდექსი 0.
ასე რომ, თუ გადავხედავთ, სადაც 50 მიდის, და მოვუწოდებ enqueue 50,
იგი მიდის down იქ ბოლოში. იგი მიდის ინდექსი 0.
იგი ცვლის "hi", რაც უკვე dequeued.
[დანიელ] ხომ არ იზრუნოს რომ dequeue უკვე?
რატომ არაფერს ერთად მეთაურის enqueue?
[Hardison] Oh, ამიტომ თქვენ არ შეცვლის ხელმძღვანელი, უკაცრავად.
მაგრამ თქვენ უნდა გამოიყენოთ თავდაცვის სამინისტროს ოპერატორი როცა თქვენ წვდომის
ელემენტს რომ გსურთ enqueue როცა თქვენ წვდომის
შემდეგი ელემენტს თქვენს რიგიდან.
[ბასილ] მე არ გავაკეთოთ, და მე მივიღე "წარმატება" იქ.
[დანიელ] ოჰ, მე მესმის, თუ რას ამბობდა.
[Hardison] ასე, რომ თქვენ didn't - უბრალოდ გააკეთეს საათზე q.size?
[ბასილ] Yeah. უბრალოდ შეიცვალა მხარეს, მე არაფერი უფროსთან.
[Hardison] თქვენ არ რეალურად უნდა აღადგინოთ ხელმძღვანელი უნდა იყოს არაფერი,
მაგრამ როდესაც თქვენ ინდექსი შევიდა სიმები მასივი,
თქვენ ნამდვილად უნდა წავიდეთ წინ და გამოვთვალოთ სადაც შემდეგი ელემენტი,
რადგან withe დასტის, შემდეგი ელემენტს თქვენს დასტის იყო ყოველთვის
ზე ინდექსი შესაბამისი ზომა.
თუ ჩვენ ვიხსენებთ up ჩვენს დასტის ბიძგი ფუნქცია,
ჩვენ შეგვიძლია ყოველთვის plunk ჩვენს ახალ ელემენტს უფლება ინდექსი ზომა.
ვინაიდან ერთად მდგომ, ჩვენ არ შეგვიძლია გავაკეთოთ, რომ
რადგან თუ ჩვენ ამ სიტუაციაში,
თუ ჩვენ enqueued 50 ჩვენი ახალი სიმებიანი წავიდოდა უფლება სტრიქონები [1]
რომელიც ჩვენ არ გვინდა, რომ გავაკეთოთ.
ჩვენ გვინდა, რომ გვქონდეს ახალი სიმებიანი წასვლა საათზე ინდექსი 0.
>> ვინმეს აქვს - კი? [სტუდენტური] მე მაქვს შეკითხვა, მაგრამ ნამდვილად არ უკავშირდება.
რას ნიშნავს, როცა ვინმე მხოლოდ მოუწოდებს რაღაც pred მაჩვენებელი?
რა არის, რომ სახელი მოკლე ამისთვის? მე ვიცი, უბრალოდ სახელი.
[Hardison] Pred მაჩვენებელი? ვნახოთ. რა კონტექსტში?
[სტუდენტური] სწორედ ჩანართით. შემიძლია გთხოვოთ მოგვიანებით თუ გინდათ
იმიტომ რომ ნამდვილად არ უკავშირდება, მაგრამ მე უბრალოდ -
[Hardison] მდებარ დავითის ჩასმა კოდი ლექცია?
ჩვენ შეგვიძლია დახევის რომ და საუბრობენ, რომ.
ჩვენ ვსაუბრობთ, რომ მომდევნო, კიდევ მივიღებთ, რათა დაკავშირებული სიები.
>> მოდით ნამდვილად სწრაფად შევხედოთ რა enqueue ფუნქცია ჰგავს.
რა იყო პირველი რაც ადამიანმა სცადა გავაკეთოთ თქვენი enqueue ხაზი? ამ რიგში?
მსგავსია იმისა, რაც თქვენ გააკეთა დასტის უბიძგებს.
რა გავაკეთოთ, Stella?
[Stella, გაუგებარია]
[Hardison] ზუსტად. თუ (q.size == სიმძლავრის) -
მე უნდა დააყენოს ჩემი braces სწორი ადგილი - დაბრუნებას ყალბი.
მიუახლოვდით ცოტა. Okay.
არის რა შემდეგი რამ, რომ ჩვენ უნდა გაეკეთებინათ?
ისევე ერთად დასტის, და ჩასმული at უფლება ადგილი.
და მერე რა იყო სწორი ადგილი ჩასასმელად რომ?
With დასტის ეს იყო ინდექსი ზომა, ამ ეს არ საკმაოდ რომ.
[დანიელ] მაქვს q.head-ან - >> q.strings? >> Yeah.
q.strings [q.head + q.size mod ტევადობა]?
[Hardison] ჩვენ ალბათ სურთ დააყენა ფრჩხილებში გარშემო
ასე, რომ ჩვენ ვიღებთ შესაბამისი პრეცენდენტის და ასე რომ cleart ყველას.
და დაადგინა, რომ თანაბარი? >> To ქ? >> To ქ. დიდი.
და ახლა რა ბოლო რამ, რომ ჩვენ უნდა გავაკეთოთ?
უბრალოდ ისე, როგორც წელს Stack. >> ნამატი ზომა? >> ნამატი ზომა.
Boom. და მაშინ, რადგან შემქმნელის კოდი დაბრუნებული ცრუ იყოს,
ჩვენ გვინდა, რომ შეიცვალოს ეს ჭეშმარიტი თუ ყველა გადის და ყველაფერი კარგად.
ყველა უფლება. სწორედ უამრავი ინფორმაცია მონაკვეთზე.
ჩვენ არ ვართ საკმაოდ დასრულდა. ჩვენ გვინდა, რომ გაიგო ნამდვილად სწრაფად შესახებ საგნით დაკავშირებული სიები.
მე დააყენა ამ მდე ასე შეგვიძლია დავუბრუნდეთ მოგვიანებით.
მაგრამ მოდით დავუბრუნდეთ ჩვენი პრეზენტაცია მხოლოდ რამდენიმე სლაიდები.
ამიტომ enqueue არის TODO, ახლა ჩვენ გავაკეთეთ.
>> ახლა მოდით შევხედოთ საგნით დაკავშირებული სიები.
ჩვენ ვისაუბრეთ ამ ცოტა მეტი ლექცია.
რამდენი თქვენგანი ბიჭები დაინახა დემო სადაც ჩვენ გვქონდა ხალხი
უხერხულად მიუთითებს ერთმანეთს და ჩატარება ნომრები? >> ვიყავი რომ.
>> რა ბიჭები ვფიქრობ? ამით, იმედია demystify ამ ცოტა?
With სია, აღმოჩნდება, რომ აქ საქმე გვაქვს ამ ტიპის რომ ჩვენ ვაპირებთ მოვუწოდებთ კვანძში.
ვინაიდან ერთად მდგომ და დასტის გვქონდა structs რომ ჩვენ გვინდა მოვუწოდებთ რიგში დასტის,
ჩვენ გვქონდა ამ ახალი რიგში დასტის ტიპის,
აქ სიაში მართლაც მხოლოდ შედგება bunch of კვანძების.
ანალოგიურად, რომ სტრიქონები მხოლოდ bunch of chars ყველა გაფორმებულია up შემდეგი ერთმანეთს.
უკავშირდება სიაში მხოლოდ კვანძის და სხვა კვანძის და სხვა კვანძის და სხვა კვანძის.
და ვიდრე Smashing ყველა კვანძების ერთად და შენახვის მათ contiguously
ყველა უფლება მომდევნო ერთმანეთს მეხსიერება,
მქონე ამ შემდეგი მაჩვენებელი საშუალებას გვაძლევს შესანახად კვანძების სადაც არ უნდა, შემთხვევითი.
და შემდეგ სახის მავთული მათ ყველა ერთად აღვნიშნო ერთი შემდეგი.
>> და რა იყო დიდი უპირატესობა, რომ ეს ყავდა მასივი?
Over შენახვის ყველაფერი contiguously მხოლოდ დავრჩებოდით შემდეგი ერთმანეთს?
თქვენ გახსოვთ? ჰო? >> დინამიური მეხსიერების გამოყოფის?
>> დინამიური მეხსიერების გამოყოფის რა გრძნობა?
[სტუდენტური] In რომ თქვენ შეგიძლიათ შეინახოთ რაც უფრო დიდი და თქვენ არ უნდა გადავიდეთ თქვენი მთელი მასივი?
[Hardison] ზუსტად. ამრიგად მასივი, როდესაც გსურთ დააყენოს ახალი ელემენტს შუაგულში შეიჭრა იგი,
თქვენ უნდა გადაიტანოს ყველაფერი, რათა სივრცეში.
და როგორც ჩვენ ვისაუბრეთ ერთად მდგომ,
ამიტომ შენარჩუნება, რომ ხელმძღვანელი მაჩვენებელი,
ისე, რომ ჩვენ არ ვართ მუდმივად გადავიდა რამ.
გამო რომ იღებს ძვირი თუ თქვენ მოხვდით დიდი მასივი
და თქვენ მუდმივად აკეთებთ ამ შემთხვევითი insertions.
ვინაიდან ერთად სიაში, ყველა თქვენ უნდა გააკეთოთ გადაყარეთ ის ახალ კვანძში,
შეცვალოს პოინტერები, და თქვენ კეთდება.
რა sucks ამის შესახებ?
გარდა იმისა, რომ ეს არ არის ისეთი ადვილი მუშაობა როგორც მასივი? ჰო?
[დანიელ] ისე, ვფიქრობ, გაცილებით უფრო რთული, რათა შეამოწმონ კონკრეტული ელემენტს უკავშირდება სიაში?
[Hardison] თქვენ არ შეგიძლიათ უბრალოდ გადადით თვითნებური ელემენტს შუა თქვენი უკავშირდება სიაში.
როგორ უნდა გავაკეთოთ ნაცვლად? >> თქვენ უნდა გადადგას მთელი რამ.
[Hardison] Yeah. თქვენ უნდა გაიაროს ერთ დროს, ერთ დროს.
ეს უზარმაზარი - ის ტკივილი.
რა არის სხვა - არსებობს კიდევ ერთი ვარდნის ამ.
[ბასილ] თქვენ არ შეგიძლიათ წავიდეთ წინ და უკან? თქვენ უნდა წავიდეს ერთი მიმართულებით?
[Hardison] Yeah. ასე როგორ უნდა გადაწყვიტოს, რომ, ზოგჯერ?
[ბასილ] ორმაგად-უკავშირდება სიები? >> ზუსტად. არსებობს ორმაგად-უკავშირდება სიები.
ასევე არსებობს - უკაცრავად?
>> [სემ] არის, რომ იგივე როგორც გამოყენებით pred, რაც -
მე უბრალოდ გაიხსენა, რომელიც არ არის, რომ რა pred რამ არის?
არ არის, რომ შორის ორმაგად და საგნით?
[Hardison] მოდით წავიკითხოთ რას იგი აკეთებს.
ასე რომ აქ ჩვენ მივდივართ. აი სიაში კოდი.
აქ predptr, აქ. ეს რას ვსაუბრობთ?
ასე რომ, ეს იყო - ის გამონთავისუფლების სიაში და ის ცდილობს შესანახად მომცეთ იგი.
ეს არ არის ორმაგად, საგნით უკავშირდება-სიებში.
ჩვენ შეგვიძლია გაიგო მეტი ამ მოგვიანებით რადგან ეს არის ლაპარაკი გამონთავისუფლების სია
და მინდა ნახოთ ზოგიერთი სხვა პერსონალის პირველი.
მაგრამ ეს მხოლოდ - ის დამახსოვრების ღირებულება ptr
[სტუდენტური] ოჰ, ეს preceeding მაჩვენებელი? >> Yeah.
ასე, რომ ჩვენ შეგვიძლია მაშინ ნამატი ptr თავად სანამ ჩვენ მაშინ უფასო რა predptr არის.
რადგანაც ჩვენ არ შეგვიძლია უფასო ptr და შემდეგ მოვუწოდებთ ptr = ptr შემდეგი, არა?
ეს იქნება ცუდი.
ასე რომ ვნახოთ, თავში ამ ბიჭს.
>> სხვა ცუდი რამ შესახებ სიები არის, რომ მაშინ როდესაც ერთად მასივი
ჩვენ უბრალოდ უნდა ყველა ელემენტები თავად stacked შემდეგი ერთმანეთს,
აქ ჩვენ ასევე გააცნო ამ მაჩვენებელმა.
ასე რომ იქ დამატებითი ბლოკი მეხსიერება, რომ ჩვენ მქონე გამოიყენოს
ყველა ელემენტს რომ ჩვენ შენახვის ჩვენს სიაში.
მივიღებთ მოქნილობა, მაგრამ საქმე ზე ღირებულება.
მას გააჩნია ამ დროის ღირებულება,
და მას გააჩნია ამ მეხსიერების ღირებულება ძალიან.
ახლა იმ გაგებით, რომ ჩვენ ახლა უნდა გაიაროს ყველა ელემენტს მასივი
იპოვონ ერთი ინდექსი 10 ან რომ იქნებოდა ინდექსი 10 მასივი.
>> უბრალოდ მართლაც სწრაფად, როდესაც ჩვენ დიაგრამაზე აღნიშნული სიები,
ჩვეულებრივ ჩვენ გაიმართება ხელმძღვანელს სიაში ან პირველი მაჩვენებელი სიის
და აღინიშნოს, რომ ეს არის ნამდვილი მაჩვენებელი.
უბრალოდ 4 ბაიტი. ეს არ არის ფაქტობრივი კვანძის თავად.
ასე რომ თქვენ ხედავთ, რომ არ გააჩნია int ღირებულების იგი, არ შემდეგი მაჩვენებელი იყო.
ეს სიტყვასიტყვით მხოლოდ კურსორი.
იგი აპირებს აღვნიშნო, რომ ის, რაც არის ფაქტობრივი კვანძის struct.
[სემ] მაჩვენებელი მოუწოდა კვანძის? >> ეს არის - არ. ეს არის მაჩვენებელი რაიმე ტიპის კვანძში.
ეს მომცეთ კვანძის struct. >> Oh, okay.
დიაგრამა მარცხენა, კოდი მარჯვენა.
ჩვენ შეგვიძლია ვაყენებთ მას null, რომელიც კარგი საშუალებაა დაიწყოს.
როდესაც თქვენ დიაგრამაზე მასში თქვენ ან წერენ, როგორც null ან თქვენ დააყენა ხაზის მეშვეობით ეს იგრძნობა.
>> ერთი იოლი გზა მუშაობა სიები
და ჩვენ ვთხოვთ თქვენ ჩვენგან ორივე prepend და დამატება დაინახოს სხვაობა,
მაგრამ prepending ნამდვილად ადვილია.
როდესაც თქვენ prepend, ეს არის სადაც თქვენ - როდესაც თქვენ prepend (7),
თქვენ წადით და შექმნას კვანძის struct
და თქვენ პირველი აღვნიშნო მას, რადგან ახლა, რადგან ჩვენ prepended ის,
ეს იქნება დასაწყისში სიაში.
თუ ჩვენ prepend (3), რომელიც ქმნის მეორე კვანძის, მაგრამ ახლა 3 მოდის ადრე 7.
ასე რომ ჩვენ არსებითად ზრდის რამ გადატანა ჩვენს სიაში.
ახლა, თქვენ ხედავთ, რომ prepend, ზოგჯერ ადამიანებს ეძახით დააყენებს,
იმიტომ, რომ თქვენ უბიძგებს ახალი ელემენტს გადატანა თქვენს სიაში.
ასევე ადვილად წაშლა დროს თვალწინ სიაში.
ამიტომ ხალხი ხშირად მოვუწოდებთ, რომ ჰოლივუდი.
და ამ გზით, შეგიძლიათ emulate დასტის გამოყენებით უკავშირდება სიაში.
Whoops. უკაცრავად, ახლა ჩვენ მისაღებად შევიდა დამატება. ასე რომ აქ ჩვენ prepended (7), ახლა ჩვენ prepend (3).
თუ ჩვენ prepended რაღაც გადატანა ამ სიაში, თუ ჩვენ prepended (4),
მაშინ ჩვენ ავღნიშნო აქვს 4 და შემდეგ 3 და შემდეგ 7.
ასე რომ, ჩვენ შეიძლება პოპ და ამოიღონ 4, წაშალოს 3, ამოიღონ 7.
ხშირად უფრო ინტუიციური გზა ვიფიქროთ ეს ერთად დამატება.
ამიტომ მე diagrammed რა ეს გამოიყურება ასე ერთად დამატება აქ.
აქ, დაერთოს (7) არ გამოიყურება ნებისმიერი სხვადასხვა
რადგან არსებობს მხოლოდ ერთი ელემენტია სიაში.
და appending (3) აყენებს მას დასასრულს.
იქნებ თქვენ ხედავთ ახლავე შეასრულა ერთად დამატება
ის არის, რომ რადგან ჩვენ მხოლოდ ვიცით, სადაც დასაწყისში სია,
to დამატება, რათა სია გაქვთ ფეხით ყველა გზას სია
მისაღებად ბოლომდე, შეჩერება, შემდეგ ავაშენოთ თქვენი კვანძის და plunk ყველაფერი ქვევით.
მავთულის ყველა პერსონალის up.
ამრიგად prepend, როგორც ჩვენ მხოლოდ ამოღებული მეშვეობით ნამდვილად სწრაფად,
როდესაც თქვენ prepend რომ სიაში, ეს საკმაოდ მარტივია.
>> თქვენი ახალი კვანძის, ჩავრთოთ ზოგიერთი დინამიური მეხსიერების გამოყოფის.
ასე რომ აქ ჩვენ მიღების კვანძის struct გამოყენებით malloc.
ამიტომ malloc ჩვენ გამოყენებით იმიტომ, რომ ყველაფერს გათვალისწინებულია მეხსიერების ჩვენთვის მოგვიანებით
იმიტომ, რომ ჩვენ არ გვინდა ამ - ჩვენ გვინდა ამ მეხსიერების არსებობს დიდი ხანია.
ჩვენ ლინკი მომცეთ სივრცეში მეხსიერებაში, რომ ჩვენ უბრალოდ გამოყოფილი.
ჩვენ ვიყენებთ ზომის კვანძი, ჩვენ არ მთლიანობაში სფეროებში.
ჩვენ არ ხელით გენერირება ბაიტების რაოდენობას,
ნაცვლად ჩვენ ვიყენებთ sizeof ისე, რომ ჩვენ ვიცით, ჩვენ ვიღებთ შესაბამისი ბაიტების რაოდენობას.
ჩვენ დარწმუნდით შესამოწმებლად, რომ ჩვენი malloc ზარის შედგა.
ეს არის რაღაც თქვენ უნდა კულტურას.
თანამედროვე მანქანები, ითმენს მეხსიერების არ არის რაღაც, რომ ადვილი
თუ არ ხარ გამოყოფის ტონა პერსონალის და მიღების დიდი სია,
მაგრამ თუ თქვენ მშენებლობის პერსონალის ამისთვის, ვთქვათ, როგორიცაა iPhone ან Android,
თქვენ ჩვენგან შეზღუდული მეხსიერება რესურსების, განსაკუთრებით თუ თქვენ აკეთებთ რაღაც ინტენსიურად მიმდინარეობს.
ასე რომ კარგი შეღწევას პრაქტიკაში.
>> გაითვალისწინეთ, რომ მე გამოიყენება რამდენიმე განსხვავებული ფუნქციები აქ
რომ თქვენ ვხედავთ, რომლებიც სახის ახალი.
ამიტომ fprintf არის ისევე printf
გარდა თავისი პირველი არგუმენტი არის ნაკადი, რომლის გსურთ ბეჭდვა.
ამ შემთხვევაში, ჩვენ გვინდა ბეჭდვა სტანდარტული შეცდომა სიმებიანი
რომელიც განსხვავდება სტანდარტული outstream.
ნაგულისხმევია ის გვიჩვენებს up იმავე ადგილას.
იგი ასევე ბეჭდავს out to ტერმინალი, მაგრამ შეგიძლიათ -
გამოყენებით იმ ბრძანებები თქვენ შეიტყო, გადამისამართება ტექნიკას
თქვენ შეიტყო წელს Tommy-ის ვიდეო პრობლემის კომპლექტი 4, შეგიძლიათ პირდაპირ ეს
სხვადასხვა ადგილებში; შემდეგ გასვლა, უფლება აქ, გასასვლელების თქვენი პროგრამა.
ეს არსებითად მოსწონს დაბრუნების ძირითად,
გარდა ჩვენ ვიყენებთ გასასვლელში რადგან აქ სარგებელი არაფერი.
ჩვენ არ ვართ მთავარ, ისე დაბრუნების არ გაითიშება პროგრამა, როგორიც ჩვენ გვინდა.
ასე რომ ჩვენ ვიყენებთ გასასვლელში ფუნქცია და მისთვის შეცდომის კოდი.
მაშინ აქ ჩვენ დავსახეთ ახალი კვანძის ღირებულების სფეროში, მისი მე სფეროში უნდა იყოს ტოლი i, და შემდეგ ჩვენ WIRE it up.
ჩვენ დავსახეთ ახალი კვანძის მომდევნო მომცეთ აღვნიშნო, რომ პირველი,
და მაშინ პირველად ახლა აღვნიშნავთ, რომ ახალი კვანძში.
ეს პირველი ხაზი კოდი, ჩვენ რეალურად აშენებენ ახალ კვანძში.
არა ბოლო ორი ხაზი ამ ფუნქციის მაგრამ პირველი მიიჩნიეს.
თქვენ შეგიძლიათ რეალურად გაიყვანოს შევიდა ფუნქციის შევიდა დამხმარე ფუნქცია.
რომ ხშირად რა გავაკეთო არის, მე გაიყვანოს მას out შევიდა ფუნქცია,
მოვუწოდებ მას რაღაც Build კვანძში,
და რომ ინახავს prepend ფუნქცია საკმაოდ მცირე, უბრალოდ 3 ხაზების შემდეგ.
მე ზარი ჩემი build კვანძის ფუნქციას, და მერე მავთული ყველაფერი up.
>> საბოლოო რამ მინდა გაჩვენოთ,
და მე მოგცემთ გავაკეთოთ დამატება და ყველა რომ საკუთარ,
არის როგორ iterate მეტი სიაში.
არსებობს რამოდენიმე განსხვავებული გზა iterate მეტი სიაში.
ამ შემთხვევაში, ჩვენ ვაპირებთ, რათა იპოვოს სიგრძეზე სიაში.
ამიტომ, ჩვენ დავიწყებთ სიგრძე = 0.
ეს არის ძალიან ჰგავს წერილობით strlen ამისთვის სიმებიანი.
ეს არის ის, რაც მე მინდა გაჩვენოთ, ეს loop უფლება აქ.
როგორც ჩანს kinda ხმაურიანი, ეს არ არის ჩვეულებრივი int i = 0, I <რასაც მე + +.
ამის ნაცვლად ის ინიციალიზაციისას ჩვენი ცვლადი N უნდა იყოს დასაწყისში სიაში.
და შემდეგ, ხოლო ჩვენი iterator ცვლადი არ არის null, ჩვენ შევინარჩუნოთ აპირებს.
ეს იმიტომ, რომელსაც კონვენცია, ბოლომდე ჩვენს სიაში იქნება null.
და შემდეგ წუთობრივი, ვიდრე აკეთებს + +,
უკავშირდება სია ეკვივალენტს + + არის N = N-> მომავალი.
>> მე მოგცემთ შეავსოთ ხარვეზები აქ იმიტომ ვართ გარეთ დრო.
მაგრამ შენარჩუნება ამის გათვალისწინებით, როგორც თქვენ მუშაობთ თქვენს spellr psets.
უკავშირებს სიები, თუ თქვენ განხორციელების hash მაგიდა,
აუცილებლად მოდის ძალიან მოსახერხებელი.
და მას შემდეგ ამ idiom ამისთვის looping მეტი რამ გახდის ცხოვრებაში ბევრი ადვილია, იმედია.
ნებისმიერი კითხვები, სწრაფად?
[სემ] Will თქვენ გააგზავნით out დასრულდა sll და sc?
[Hardison] Yeah. მე გაგზავნის out დასრულდა სლაიდები და დასრულებული sll დასტის და queue.cs.
[CS50.TV]