>> დინამიკები 1: Hey ყველას!
მივესალმებით თავში მონაკვეთზე.
ასე მიხარია, რომ ბევრი თქვენგანი, როგორც აქ, და ყველას, ვინც თვალს ონლაინ რეჟიმში.
ასე რომ, როგორც ყოველთვის მივესალმებით უკან.
იმედი მაქვს, რომ ყველა ჰქონდა ლამაზი კვირას, სავსე დასვენება, რელაქსაცია.
ეს იყო ლამაზი გუშინ.
ასე რომ, იმედი მაქვს, თქვენ სარგებლობდა გარეთ.
>> ასე რომ, პირველი რამდენიმე განცხადებები.
შეფასების.
ასე რომ, ყველაზე მეტად თქვენ უნდა მიღებული ელ me თქვენი Scratch Pset,
ისევე როგორც შეფასების pset 1.
ასე რომ, მხოლოდ რამდენიმე რამ.
რა თქმა უნდა გამოიყენოს check50 in style50.
ეს კი იმას ნიშნავდა, რომ იყოს რესურსები ბიჭები,
დარწმუნდით, რომ თქვენ მიღების იმდენი რაოდენობა, როგორც თქვენ შეგიძლიათ
გარეშე უხეშად კარგავს მათ.
ასე რომ, რამ, როგორიცაა სტილი ძალიან მნიშვნელოვანია.
ჩვენ ვაპირებთ, რომ მიიღოს off მას.
ზოგიერთი შეიძლება უკვე შენიშნა, რომ თქვენი pset.
და check50 მხოლოდ ნამდვილად მარტივი გზა დარწმუნდით
რომ ჩვენ რეალურად დაბრუნების რა უნდა დაუბრუნდეს მომხმარებელს,
და ყველაფერი მუშაობს გამართულად.
>> მეორე შენიშვნა, დარწმუნდით, რომ თქვენი ატვირთვა რამ სწორი საქაღალდეში.
რაც ჩემს ცხოვრებაში მხოლოდ ცოტა უფრო რთული,
თუ თქვენ ატვირთეთ pset 2 შევიდა pset 1 იმიტომ, რომ როცა ჩამოტვირთოთ რამ,
ისინი არ ჩამოტვირთვა სწორად.
და მე ვიცი, რომ ეს პატარა wonky სისტემა, შეეგუება,
მაგრამ მხოლოდ სუპერ ფრთხილად, თუ მხოლოდ ჩემთვის,
ასე რომ, როდესაც თქვენ მიღების წერილებს, at მოსწონს 2 საათზე და მე შეფასების.
თუ არ გამოიწვიოს მე უნდა გამოიყურებოდეს ყველა გარშემო თქვენი pset.
ზემოთ.
>> მე ვიცი, რომ ადრე, მაგრამ სრულიად მიიღო წაიყვანეს მცველი
ესსე, რომ იმის გამო ამ პარასკევს, რომ ჩემი პროფესორები, ისევე, როგორც, oh yeah.
გახსოვდეთ, თქვენ უნდა ესეს გამო პარასკევს.
ასე რომ, მე ვიცი, არავის არ მოსწონს უნდა ვიფიქროთ იმაზე, შუალედური
მაგრამ თქვენი პირველი ვიქტორინა არის 15 ოქტომბერს, რომელიც ოქტომბერში იწყება ამ კვირაში.
ასე რომ, ეს შეიძლება იყოს უფრო ადრე, ვიდრე მოსალოდნელი არ არის.
ასე რომ თქვენ არ დააგდეს off ფხიზლად მინდა აღვნიშნო, რომ მომავალ კვირას სექცია, რომელიც oh,
თქვენი ვიქტორინა მომავალ კვირას, ვფიქრობდი, მე მინდა გადმოგცეთ ცოტა მეტი
of ხელმძღვანელები ახლა.
>> ასე რომ, თქვენი პრობლემა კომპლექტი, ნომერი სამი.
როგორ ხალხი წაიკითხავს სპეც გარეთ ცნობისმოყვარეობა?
OK.
ჩვენ მივიღეთ რამდენიმე.
სახის ქვემოთ ბოლო კვირას, მაგრამ ეს OK.
მე ვიცი, რომ ეს იყო ლამაზი out.
ასე დაარღვიე Out.
აუცილებლად შემდეგ თქვენ გაკეთდეს დღეს წავიკითხე თქვენი სპეც მინიმუმ
ცდილობენ, როგორიცაა ჩამოტვირთვის განაწილების კოდი და გაშვებული
როგორც საწყის საქმე იმაშია, რომ ისინი გთხოვოთ.
იმიტომ, რომ ჩვენ გამოყენებით განაწილების კოდი და ბიბლიოთეკა
რომ ჩვენ მხოლოდ using-- --It მხოლოდ მეორედ, ჩვენ გავაკეთეთ ამ Pset,
გიჟები რამ შეიძლება მოხდეს თქვენი მოწყობილობების,
და თქვენ სურს იპოვოს, რომ ახლა წინააღმდეგ შემდეგ.
>> იმიტომ, რომ თუ ის ხუთშაბათს ღამით ან ეს ღამით და რატომღაც
თქვენი მოწყობილობის უბრალოდ არ გსურთ აწარმოებს ბიბლიოთეკა
ან განაწილების კოდი, რომელიც საშუალება
თქვენ კი არ დაიწყოს აკეთებს კოდირებას.
იმიტომ, რომ არ შეგიძლიათ შეამოწმოთ თუ ეს მუშაობს.
თქვენი არ ამოვიღებთ შეძლებს ვნახოთ, თუ იგი ადგენს.
გსურთ იზრუნოს იმ დასაწყისში კვირას, როდესაც თქვენ მაინც მომაწოდეთ
ან რომელიმე სხვა TFs, და ჩვენ შეგვიძლია მივიღოთ იმ დაფიქსირდა.
იმის გამო, რომ ეს ის საკითხებია, რომ ვაპირებთ შეჩერება
მიღების რაიმე რეალური პროგრესი.
ეს იმას არ ნიშნავს, ერთი bug, რომელიც შეგიძლიათ უბრალოდ სახის გამოტოვოთ.
თუ თქვენ მქონე საკითხებზე თქვენი ელექტრო ან განაწილების კოდი,
თქვენ ნამდვილად გვინდა, რომ მიღებული ზრუნვა ადრე თუ გვიან.
ისე კი, თუ თქვენ არ ამოვიღებთ რეალურად დაიწყოს კოდირების, უფასო განაწილების
კოდი, წაიკითხა სპეც, დარწმუნდით ყველაფერი მუშაობს იქ.
OK?
თუ შეგიძლიათ უბრალოდ რომ, მე გპირდებით, თქვენი ცხოვრება უფრო ადვილი იქნება.
და ასე რომ თქვენ ალბათ აპირებს ამის გაკეთება ახლა არა?
OK.
ასე რომ, ნებისმიერ კითხვებზე?
ნებისმიერი ლოგისტიკური რამ?
ყველას კარგი?
OK.
>> პასუხისმგებლობის შეზღუდვის განაცხადი იმ თქვენ ოთახში და ონლაინ.
მე ვაპირებ ცდილობს გადართოთ შორის PowerPoint ელექტრო
რადგან ჩვენ ვაპირებთ, იყოს აკეთებს კოდირებას
დღეს პოპულარული მოთხოვნა ანონიმური წინადადება გამოკითხვა გააძევეს გასულ კვირას.
ასე რომ, ჩვენ უნდა აკეთებს კოდირებას.
ასე რომ, თუ თქვენ ბიჭები ასევე მინდა ცეცხლი თქვენი ნივთები,
და თქვენ არ უნდა მიიღო ელ მე, ერთად ნიმუში ფაილი.
გთხოვთ მოგერიდებათ გაგვაჩნია.
>> ასე რომ, ჩვენ ვაპირებთ ვისაუბროთ GDB, რომელიც debugger.
ის აპირებს დაგეხმაროთ სახის გაერკვნენ, სადაც
ვაპირებთ არასწორი თქვენს კოდი.
ეს უბრალოდ გზა თქვენ უნდა გადადგას თქვენი კოდი, როგორც ეს ხდება,
და შეძლებს ამობეჭდოთ ცვლადები ან რა ხდება რეალურად
ქვეშ Hood ლექსები თქვენი პროგრამა მხოლოდ გაშვებული, ეს როგორც ნასხლეტმა,
და თქვენ, როგორიცაა, არ ვიცი რა მოხდა აქ.
მე არ ვიცი, რა ხაზის ეს ვერ შეძლეს.
მე არ ვიცი, სადაც ეს მოხდა.
ასე რომ, GDB აპირებს დაგეხმარებათ, რომ.
გარდა ამისა, თუ თქვენ გადაწყვიტეთ გაგრძელდება დიახ, და მიიღოს 61,
ეს მართლაც, მართლაც იყოს თქვენი საუკეთესო მეგობარი, მიზეზი მე შემიძლია გითხრათ,
იმიტომ, რომ მე ვაპირებ მეშვეობით, რომ კლასი.
>> ჩვენ ვაპირებთ შევხედოთ ორობითი ძებნა, რომელიც თუ ბიჭები გახსოვთ
დიდი სატელეფონო წიგნი მაგალითად სპექტაკლი კლასის.
ჩვენ უნდა განხორციელების, რომ, და გავლით, რომ ცოტა მეტი,
და მაშინ ჩვენ ვაპირებთ ოთხ სხვადასხვა სახის, რომლებიც Bubble,
შერჩევის, Insertion და შერწყმა.
ზემოთ.
ასე რომ, GDB, როგორც აღვნიშნე, არის debugger.
და ეს არის ერთგვარი დიდი რამ, big ფუნქცია ან ბრძანებები
რომ გამოიყენოთ ფარგლებში GDB, და მე ფეხით თქვენ მეშვეობით დემო იგი მეორე.
>> ასე რომ, ეს არ არის მხოლოდ დარჩება აბსტრაქტული.
ვეცდები და მას, როგორც ბეტონის შესაძლებელია თქვენთვის ბიჭები.
ასე რომ, შესვენება.
ეს კიდე იყოს break როგორიცაა, ზოგიერთი ნომერი, რომელიც
წარმოადგენს ხაზი თქვენს პროგრამაში, ან შეგიძლიათ დაასახელოთ ფუნქცია.
ასე რომ, თუ თქვენ აცხადებენ, რომ შესვენება მთავარ, ის შეწყვეტს მთავარი,
და მოდით გავლა, რომ ფუნქცია.
>> გარდა ამისა, თუ თქვენ გაქვთ რაიმე გარე ფუნქციონირებს, როგორც Swap ან Cube,
ჩვენ შევხედეთ გასულ კვირას.
თუ ამბობენ, რომ შესვენება ერთი იმ, როდესაც თქვენი პროგრამის ჰიტები, რომ
ეს თქვენ დაველოდოთ თქვენ ვუთხრა მას, რა უნდა გააკეთოს.
სანამ უბრალოდ შეასრულოს, ასე რომ თქვენ შეიძლება რეალურად დაიხევს შიგნით ფუნქცია
და ვნახოთ რა ხდება.
ასე რომ, შემდეგი, უბრალოდ ნახტომი მეტი შემდეგი ხაზი, მიდის ფუნქციები.
ნაბიჯი.
ეს არის ყველა ცოტა აბსტრაქტული.
ასე რომ, მე მხოლოდ აპირებს მათ, მაგრამ დაინახავთ მათ გამოყენება მეორე.
>> ნაბიჯი შევიდა ფუნქცია.
ასე რომ, როგორც მე ამბობდა, ისევე, როგორც Swap, რომ ის
საშუალებას მოგცემთ რეალურად თითქოს თქვენ როგორც ფიზიკურად სტეპინგზე შიგნით,
თქვენ შეგიძლიათ სასადილო ცვლადები, ბეჭდვა გაირკვეს, თუ რა ისინი, რა ხდება.
სია იქნება ფაქტიურად მხოლოდ ბეჭდვა out მიმდებარე კოდი.
ასე რომ, თუ როგორი დაგავიწყდეთ სადაც თქვენ ხართ თქვენს პროგრამაში,
ან თქვენ გაინტერესებთ რა ხდება გარშემო,
ეს უბრალოდ ამობეჭდოთ სეგმენტი მოსწონს ხუთი ან ექვსი ხაზები გარშემო.
ასე რომ, შეგიძლიათ ორიენტირებული შესახებ, სადაც ხართ.
>> ბეჭდვა ზოგიერთი ცვლადი.
ასე რომ, თუ თქვენ გაქვთ გასაღები, როგორიცაა კეისარი, რომ ჩვენ შევხედოთ.
შეიძლება ითქვას, Print ძირითადი ნებისმიერ წერტილში.
ის გეტყვით, თუ რა ღირებულება არის ასე რომ, შესაძლოა, სადღაც გზაზე,
თქვენ overwrote თქვენი გასაღები.
თქვენ შეგიძლიათ რეალურად გითხრათ, რომ იმის გამო, თქვენ შეგიძლიათ რეალურად ვაკვირდებით, რომ ღირებულება.
>> ადგილობრივებს, ისევე ანაბეჭდები თქვენი ადგილობრივი ცვლადები.
ასე რომ, ნებისმიერ დროს თქვენ ფარგლებში მარყუჟის, და თქვენ უბრალოდ გვინდა, რომ მოსწონს, oh.
რა არის ჩემი მე?
რა არის ეს ძირითადი ღირებულება რომ მე ვრთავ აქ?
რა არის გაგზავნა ამ ეტაპზე?
ეს იქნება მხოლოდ ბეჭდვა იმ, ასე რომ თქვენ
არ უნდა ინდივიდუალურად ამბობენ, Print I. შეტყობინების ამობეჭდვა.
Print Key.
და მაშინ არიან.
რა რომ არ არის, როგორც თქვენ დაიხევს მეშვეობით პროგრამა,
ეს უბრალოდ, დარწმუნდით, რომ ეს აჩვენებს გარკვეული ცვლადი
ყველა წერტილი.
ასე რომ თქვენ also-- --it არის სახის კომბინაცია, სადაც
თქვენ არ გაქვთ შენარჩუნება აპირებს, როგორიცაა, OH.
ბეჭდვა ძირითადი ან ბეჭდვის I. უბრალოდ ავტომატურად გააკეთებს იგი თქვენთვის.
>> ასე, რომ, ჩვენ ვაპირებთ ნახეთ, თუ როგორ მიდის.
მე ვაპირებ ცდილობენ და შეცვლა მეტი ჩემს ელექტრო მოწყობილობების.
თუ მე შემიძლია ამის გაკეთება.
ყველა.
ჩვენ უბრალოდ აპირებს სარკისებური იგი.
იქ არაფერი გიჟები ჩემი ლეპტოპი მაინც.
OK.
ეს უნდა იყოს ეს ერთი.
ეს იმდენად პატარა.
მოდით ვნახოთ, თუ ჩვენ შეგვიძლია ამის გაკეთება.
>> OK.
Alice აშკარად ცდილობს აქ ცოტა,
მაგრამ ჩვენ ეს momento.
OK.
ჩვენ უბრალოდ აპირებს გაზარდოს ეს.
OK.
შეიძლება ყველას სახის, რომ?
იქნებ ცოტა?
მე ვიცი, რომ ცოტა პატარა.
თქვენ ვერ საკმაოდ გაერკვნენ როგორ უნდა ამ დიდი.
თუ ვინმე იცის.
ვინმეს ვიცი როგორ, რათა ის უფრო დიდი?
OK.
ჩვენ ვაპირებთ, რომ გააფართოვოს მას.
არ აქვს მნიშვნელობა, მაინც, რადგან ეს მხოლოდ ეს კოდი, რომ თქვენ ბიჭები უნდა
აქვს.
>> რაც მთავარია, ტერმინალის აქ.
და ჩვენ გვაქვს რატომ არის ასე პატარა?
პარამეტრები.
Oh.
True Ike.
როგორ არის ეს?
გარეთ არსებობს.
ის არის, რომ ყველასთვის უკეთესი?
OK ,.
ზემოთ.
>> თქვენ იცით, როდესაც თქვენ CS კლასი ტექნიკური სირთულეების
სახის ნაწილი the-- ასე რომ, მოდით გარკვევა ამ.
OK.
ასე რომ, აქ განყოფილებიანი, რომელიც ჩვენ გვქონდა აქ.
Caesar არის შესრულებადი ფაილი.
ამიტომ მე მივიღე იგი.
ასე რომ, ერთი რამ უნდა გააცნობიეროს ერთად GDB არის რომ ეს მუშაობს მხოლოდ შესრულებადი ფაილი.
ასე რომ, თქვენ ვერ აწარმოებს DOTSY.
თქვენ უნდა რეალურად დარწმუნებული ვარ, რომ თქვენი კოდი ადგენს,
და ის, რომ რეალურად აწარმოებს.
>> ასე რომ, დარწმუნებული ვარ, რომ თუ ის არ შედგენა, მას შედგენა,
ასე რომ თქვენ შეგიძლიათ სახის აწარმოებს მეშვეობით.
ასე რომ, დავიწყოთ GDB, ყველა თქვენ, Gloria ტიპის GDB, და მერე მხოლოდ
ფაილი, რომელიც გსურთ.
მე ყოველთვის შეცდომას დავუშვებთ Caesar.
მაგრამ თქვენ უნდა დავრწმუნდეთ, მას შემდეგ, რაც ის შემსრულებელი,
ti ს dot ფლეშ ასე რომ ნიშნავს, რომ თქვენ აპირებს
აწარმოებს CSI თქვენ აპირებს შეასრულოს ეს ფაილი ვერც debugger.
OK.
ამიტომ, თქვენ, თქვენ მიიღოს ამ სახის გაუგებრობა.
ეს მხოლოდ ყველა რამ debugger.
თქვენ ნამდვილად არ უნდა ფიქრი ახლა.
და როგორც ხედავთ, ჩვენ გვაქვს ამ ღია parens, მშპ, მჭიდრო parens,
და მხოლოდ სახის ჰგავს ჩვენი ბრძანების ხაზი, არა?
>> ასე რომ, რაც ჩვენ გვინდა გავაკეთოთ --So, პირველ რიგში,
ჩვენ გვინდა აირჩიეთ ადგილი დაარღვიოს იგი.
ასე რომ, არსებობს ერთი bug ამ Caesar პროგრამა
რომ მე გააცნობს, რომელიც ჩვენ ვაპირებთ გავარკვიოთ.
ეს რა არ არის ეს ხდება შეყვანის Barfoo ყველა caps, და რატომღაც
ეს არ ცვლის ა ტოვებს არაფერი არ არის ყველაფერი სწორია,
მაგრამ მეორე წერილი უცვლელი რჩება.
ასე რომ, ჩვენ ვაპირებთ შევეცადოთ და გაერკვნენ, თუ რატომ არის.
ასე რომ, პირველი, რაც თქვენ, როგორც წესი, მინდა ამის გაკეთება, როდესაც თქვენ დაიწყოს GDB
გაერკვნენ, სადაც შესვენება იგი.
>> ასე რომ კეისრის არის საკმაოდ მოკლე პროგრამა.
ჩვენ მხოლოდ ერთი ფუნქცია, არა?
რა იყო ჩვენი ფუნქცია Caesar?
არსებობს მხოლოდ ერთი ფუნქცია, მთავარი არა?
მთავარი არის ფუნქცია ყველა თქვენი პროგრამებს.
თუ თქვენ არ აქვს მთავარი, ალბათ, იყოს პატარა აწუხებს ახლა,
მაგრამ იმედი მაქვს, რომ ყველა ჰქონდა Main არსებობს.
ასე რომ, რა შეგვიძლია გავაკეთოთ არის შეგვიძლია უბრალოდ შესვენება მთავარ, ისევე, რომ.
ასე, იგი ამბობს, OK.
ჩვენ დავსახეთ ჩვენი breakpoint არ არსებობს.
>> ასე რომ, ახლა ის უნდა გვახსოვდეს არის Caesar იღებს ერთი ბრძანება ხაზი არგუმენტი მარჯვენა
და ჩვენ ეს არ გავაკეთეთ, რომ არსად არ არის.
ასე რომ, თუ რას აკეთებთ, როდესაც თქვენ ნამდვილად წასვლა აწარმოებს
პროგრამა, რაიმე პროგრამა, რომელიც თქვენ გაშვებული GDB, რომელიც საჭიროებს command line
არგუმენტები, თქვენ აპირებს input როდესაც თქვენ დავიწყოთ გაშვებული.
ასე რომ, ამ შემთხვევაში, ჩვენ გავაკეთებთ აწარმოებს გასაღები სამ.
და ეს რეალურად დაიწყოს.
>> ასე რომ, თუ ხედავთ, ჩვენ გვაქვს თუ RC არ არის ტოლი 2.
ასე რომ, თუ თქვენ ბიჭები ყველამ უნდა რომ ფაილი, რომელიც გააძევეს up
თქვენ ნახავთ, რომ ასეთი პირველი ხაზი ჩვენი მთავარი ფუნქცია, არა?
ის შემოწმების თუ ჩვენ სწორი რაოდენობის არგუმენტები.
ასე რომ, თუ თქვენ გაინტერესებთ თუ RC არის სწორი,
თქვენ შეგიძლიათ გააკეთოთ რაიმე, ისევე, როგორც Print RC.
RC არის ორი, რომელიც რასაც ჩვენ ველოდით, არა?
>> ასე რომ, ჩვენ შეგვიძლია წავიდეთ შემდეგი და გაგრძელდება.
ასე რომ, ჩვენ გვაქვს გარკვეული გასაღები არსებობს.
და ჩვენ შეგვიძლია ამობეჭდოთ ჩვენი მთავარი იმისათვის, რომ ეს სწორი.
საინტერესოა.
არ არის საკმაოდ, რასაც ველოდით.
ასე რომ, ერთი რამ უნდა გააცნობიეროს ერთად GDB ასევე,
რომ ეს არ არის, სანამ თქვენ ნამდვილად მოხვდა შემდეგი, რომ ხაზი, რომ თქვენ უბრალოდ დაინახა
რეალურად შესრულებული.
ასე რომ, ამ შემთხვევაში ძირითადი არ იქნა დანიშნული არ არის.
ასე რომ, ძირითადი ზოგიერთი ნაგვის ღირებულება რომ ხედავთ ბოლოში არსებობს.
უარყოფითი $ 120-- --It ერთ მილიარდ და რაღაც უცნაური რამ უფლება?
ეს არ არის მთავარი, რომ ჩვენ გვგონია.
მაგრამ თუ ჩვენ მოხვდა შემდეგი, და მაშინ ჩვენ ცდილობენ და ბეჭდვა გასაღები, ეს სამი.
>> ყველას ვხედავ, რომ?
ასე რომ, თუ თქვენ გაქვთ რაიმე რომ თქვენ, ისევე, დაველოდოთ.
ეს არის სრულიად არასწორი, და მე არ ვიცი,
როგორ ეს მოხდებოდა, რადგან ყველა მინდა უნდა გავაკეთოთ არის მიანიჭოს ნომერი, ცვლადი,
ცდილობენ დარტყმის შემდეგ, ცდილობენ ბეჭდვა კიდევ ერთხელ, და თუ მუშაობს.
იმის გამო, რომ ეს მხოლოდ აპირებს შეასრულოს და რეალურად მივანიჭოთ რაღაც მას შემდეგ, რაც
მოხვდა შემდეგი.
აზრი, რომ ყველასთვის?
Uh huh?
>> დინამიკები 2: როცა შემთხვევითი ციფრები რას ნიშნავს?
>> დინამიკები 1: ეს მხოლოდ შემთხვევითი.
უბრალოდ ნაგვის.
ეს არის მხოლოდ ის, რომ თქვენი კომპიუტერული შემთხვევით მინიჭებას.
ზემოთ.
ასე რომ, ახლა ჩვენ შეგვიძლია გადაადგილება მეშვეობით, და ა.შ. ახლა გვაქვს ამ მარტივი ტექსტის GetString.
ასე რომ, ნება მომეცით წარმოგიდგინოთ რა მოხდება მაშინ, როდესაც ჩვენ მოხვდა შემდეგი აქ.
ჩვენი GDB სახის ქრება, არა?
ეს იმიტომ, რომ GetString ახლა შესრულებაში, არა?
ასე რომ, როდესაც დავინახეთ, ჩვეულებრივი ტექსტური შეადგენს GetString, ღია parens და parens,
და ჩვენ მოხვდა შემდეგი, რომ აქვს რეალურად შესრულებული არ არის.
ასე რომ, ეს ელოდება ჩვენს შეყვანის რაღაც.
>> ასე რომ, ჩვენ ვაპირებთ input ჩვენი საკვები, რომელიც არის რასაც ის ვერ როგორც გითხარით
და რომ მხოლოდ აცხადებს, რომ ეს დასრულდა შესრულებაში, რომ დახურული
bracket იმას ნიშნავს, რომ არსებული გარეთ რომ მარყუჟი.
ასე რომ, ჩვენ შეგვიძლია მოხვდა შემდეგი, და ახლა, როგორც მე ვარ დარწმუნებული ვარ, თქვენ ყველა იცნობს კეისარ,
ეს არის, რა არის ეს ხაზი აპირებს.
ეს int მე შეადგენს 0, N შეადგენს Strlen, ძირითადი ტექსტი, და მაშინ
მე ნაკლებია n, მე, ასევე, სასურველია.
რა არის ეს loop აპირებს?
გახსენით თქვენი გაგზავნა.
ზემოთ.
ასე რომ, მოდით დავიწყოთ აკეთებს, რომ.
>> ასე რომ, უნდა ამ მდგომარეობაში ემთხვევა, ჩვენი პირველი?
თუ ეს B, ეს ჩვეულებრივი ტექსტური I. ჩვენ შეგიძლიათ მიიღოთ ინფორმაცია ჩვენი ადგილობრივები.
ასე რომ, მე ნულოვანი, და თუ ექვსი, რომელიც ჩვენ ველით, და ჩვენი გასაღები არის სამი.
ყველა, რომ აზრი, არა?
ეს ციფრები არ არის ყველა ზუსტად ის, რაც უნდა იყოს.
ასე რომ, hum?
დინამიკები 3: მე მაქვს შემთხვევითი ნომრები აფეთქდა.
დინამიკები 1: ისე, ჩვენ შეგვიძლია შეამოწმოთ --we სტატისტიკა იმის შესახებ, რომ მეორე.
მაგრამ თქვენ უნდა მიღების ეს.
ასე რომ, თუ გვაქვს დედაქალაქში B ჩვენი პირველი,
ეს მდგომარეობა უნდა დაიჭიროთ იგი, არა?
ასე რომ, თუ ჩვენ მოხვდა შემდეგი, ჩვენ ვხედავთ რომ ეს თუ რეალურად ახორციელებს.
იმიტომ, რომ თუ თქვენ შემდეგ ერთად თქვენი კოდი,
ეს ხაზი აქ, სადაც ჩვეულებრივი ტექსტური I შეიცვალა ამ არითმეტიკული,
მხოლოდ აღასრულებს თუ თუ მდგომარეობა სწორია არა?
>> GDB მხოლოდ აპირებს აჩვენებს, თუ რამ, რაც რეალურად შესრულებაში.
ასე რომ, თუ, თუ მდგომარეობა არ შეხვდა, ეს უბრალოდ აპირებს გამოტოვოთ მომდევნო ხაზი.
OK?
ასე რომ, ჩვენ გვაქვს.
ამ bracket იმას ნიშნავს, რომ დახურული გარეთ რომ მარყუჟი ახლა.
ასე რომ, ის აპირებს დაიწყოს თავიდან.
ისევე, რომ.
ასე, რომ ჩვენ შეგვიძლია მივიღოთ ინფორმაცია ჩვენი ადგილობრივები აქ,
და ჩვენ ვხედავთ, რომ ჩვენი პირველი წერილი შეიცვალა, არა?
ეს არის E, როგორც ეს უნდა იყოს.
ასე რომ, ჩვენ შეგვიძლია გავაგრძელოთ.
>> და ჩვენ უნდა შეამოწმოს.
და ეს შემოწმება უნდა იმუშაოს, არა?
ეს ა უნდა შეიცვალოს სამი ასო წინ.
მაგრამ თუ თქვენ შეამჩნევთ, რომ ჩვენ კიდევ რაიმე განსხვავებული.
ასე რომ, ამ შემთხვევაში აქ, ის დაიჭირეს ეს, და ამიტომ ეს ხაზი შესრულებული,
რომელიც შეცვლილია ჩვენი B. მაგრამ, ამ შემთხვევაში აქ,
ჩვენ გვაქვს, რომ ეს მხოლოდ გამოტოვებენ,, და წავიდა [? L SIFF. ?]
ასე რომ რაღაც ხდება იქ.
რა, რომ გეუბნებოდით არის, რომ, ჩვენ ვიცით, რომ ეს უნდა დაჭერა აქ,
მაგრამ ეს არ არის.
შეიძლება ვინმეს რა ჩვენი პრობლემა ის არის, რომ ხაზი?
ეს ძალიან წუთი რამ.
და თქვენ შეიძლება ასევე შევხედოთ თქვენი კოდი.
ის ასევე ხაზი დაგვავიწყდეს, რა ხაზის ეს in იქ, მაგრამ ის, რომ [INAUDIBLE].
დიახ?
>> დინამიკები 4: ეს უფრო დიდი, ვიდრე გვერდზე თუ წაიკითხა წიგნი.
დინამიკები 1: ზუსტად.
ასე რომ, debugger ვერ გეტყვით, თქვენ, მაგრამ debugger
შეიძლება თქვენ ქვემოთ ხაზი თუ იცით, რომ არ ფუნქციონირებს.
და ზოგჯერ, როდესაც განსაკუთრებით შემდეგ სემესტრში, როდესაც
თქვენ საქმე ასი, ასი რამდენიმე ხაზი კოდი, და თქვენ
არ ვიცი, სადაც ეს ვერ, ეს არის დიდი გზა ამის გაკეთება.
ასე რომ, ჩვენ ვნახეთ ჩვენი შეცდომა.
თქვენ შეგიძლიათ გაასწორონ ის თქვენს ფაილი, და მაშინ შეიძლება გაუშვით ერთხელ,
და ყველაფერი მუშაობს მშვენივრად.
და ყველაზე დიდი რამ არის ეს შეიძლება როგორც ჩანს, როგორიცაა, OK.
ჰო.
ზემოთ.
იცოდა, რა თქვენ ვეძებთ.
ასე რომ, თქვენ იცოდა, რა უნდა გააკეთოს.
>> GDB შეიძლება იყოს სუპერ სასარგებლოა, რადგან თქვენ შეგიძლიათ ამობეჭდოთ ეს ყველაფერი, რომ თქვენ
არა.
ის ბევრად უფრო სასარგებლოა, ვიდრე printf.
რამდენი გამოყენება როგორიცაა printf განცხადებები
გაერკვნენ, სადაც bug იყო, არა?
ასე, რომ ეს, თქვენ არ უნდა შევინარჩუნოთ ბრუნდება,
და მინდა კომენტირებისას Printf, ან კომენტირებისას out,
და გაერკვნენ, თუ რა თქვენ უნდა ბეჭდვა.
ეს რეალურად მხოლოდ გაძლევთ საშუალებას ნაბიჯი მეშვეობით, ამობეჭდოთ რამ
როგორც თქვენ გადის, ასე რომ, თქვენ შეგიძლიათ დაცვა, თუ როგორ შეიცვლება რეალურ დროში,
როგორც თქვენი პროგრამა მიმდინარეობს.
>> და ეს არ მიიღოს ცოტა ცოტა შეგუება.
მე მაღალ რეკომენდაციას მხოლოდ სახის ყოფნის პატარა იმედგაცრუებული მას
ახლა.
თუ თქვენ ხარჯავთ საათი მეტი მომავალ კვირას სწავლის როგორ გამოვიყენოთ GDB,
დაზოგავთ თავს ამდენი დრო მოგვიანებით.
და სიტყვასიტყვით. ჩვენ ვეუბნებით ეს ადამიანი ყოველ წელს,
და მახსოვს, როდესაც მე მივიღე კლასი, მე მინდა, მე კარგად იქნება.
პოსტები
Pset 6 მოვიდა და მე როგორიცაა, მე კარგად ისწავლოს
თუ როგორ გამოიყენოთ GDB, რადგან მე არ ვიცით, რა ხდება აქ.
>> ასე რომ, თუ თქვენ მიიღოს დრო, ასე რომ გამოიყენოს ეს პატარა პროგრამები
რომ თქვენ იქნება მუშაობა, როგორც სამუშაო
მეშვეობით რაღაც მსგავსი Visionare, მოსწონს ეს.
ან თუ გსურთ დამატებითი პრაქტიკა, დარწმუნებული ვარ, მე ვერ ამუშავება buggy პროგრამები,
თქვენ გამართვის თუ გსურთ.
>> მაგრამ თუ მხოლოდ გარკვეული დრო, რათა გამოიყენება, უბრალოდ ითამაშოს გარშემო,
ეს ნამდვილად ემსახურება თქვენ კარგად.
და ეს მართლაც ერთ-ერთი იმ რამ, რომ თქვენ უბრალოდ
უნდა შევეცადოთ, და მიიღოთ თქვენი ხელები ბინძური ერთად, სანამ მართლაც მესმის.
მე ნამდვილად მხოლოდ მიხვდა, რომ ეს კიდევ ერთხელ მე მქონდა გამართვის რამ მას,
და ეს ბევრად გავალამაზოთ აქვს იდეა როგორ გამართვის ადრე თუ გვიან.
OK.
ზემოთ.
მე ვიცი, რომ სახის მოსწონს ავარიის კურსი GDB,
და მე აუცილებლად დაეწყო მუშაობა ეს გამოიყურება დიდი დროს.
ზემოთ.
>> ასე რომ, თუ ჩვენ დავუბრუნდებით ჩვენი PowerPoint.
არის თუ არა ეს იმუშავებს?
Awh.
დიახ.
OK.
ასე რომ, თუ თქვენ ოდესმე უნდა ნებისმიერი იმ ისევ, სიაში.
ასე ორობითი ძებნა, რომელიც ყველას ახსოვს დიდი სპექტაკლი დავით
ჩამოხევა სატელეფონო წიგნი ნახევარი.
მე ნამდვილად არ მიიღოს სატელეფონო წიგნი აღარ,
იმიტომ, რომ როგორც სად მიიღოს სატელეფონო წიგნი ამ დღეებში?
მე ნამდვილად არ ვიცი.
ორობითი ძებნა.
ვინმეს გახსოვთ როგორ ორობითი ძებნა ნამუშევრები?
ვინმეს საერთოდ?
ჰო?
დინამიკები 5: თქვენ იცით, როდესაც გადავხედავთ, რომელიც ნახევარი
ეს იქნება, აქედან გამომდინარე, და მოშორება მეორე ნახევარში.
>> დინამიკები 1 ზუსტად.
ასე რომ, ორობითი ძებნა, ეს ერთგვარი a-- --we მინდა მოვუწოდო მას გათიშე და დაიპყროთ.
ასე რომ, რას გავაკეთებთ არის თქვენ გამოიყურება შუა,
და დაინახავთ, თუ ეს შეესაბამება ის, რაც თქვენ ეძებთ.
და თუ ეს არ მოხდა, მაშინ ცდილობენ გაერკვნენ, იგი აპირებს, რომ დარჩეს,
ნახევარი ან მარჯვენა ნახევარში.
ასე რომ, ეს შეიძლება იყოს, თუ თქვენ ვეძებთ რაღაც რომ alphabetized,
ხედავთ, რა.
არ Allison მოდის ადრე M?
დიახ.
ასე რომ, ჩვენ ვაპირებთ შეხედეთ პირველ ნახევარში.
>> ან შეიძლება იყოს, როგორიცაა ნომრები.
არაფერი, რომ თქვენ შეგიძლიათ შედარებისთვის, ეს შეიძლება იყოს დახარისხებული.
თქვენ შეგიძლიათ გამოიყენოთ ორობითი ძებნა.
ასე რომ, ვინმეს გახსოვთ ამ გრაფაში ან ეს რა არის?
ეს ასიმპტოტური სირთულე.
ასე რომ, ამ გრაფაში მხოლოდ აღწერს, თუ როგორ ხანგრძლივი
იღებს თქვენ გადაჭრას პრობლემა, როგორც თქვენ რაოდენობის გაზრდა რამ
რომ თქვენ იყენებთ.
>> ასე რომ, ჩვენ გვაქვს N, რომელიც არის წრფივი.
თუ N გამო ორი, რომელიც ოდნავ უკეთესი, ჯერ კიდევ იზრდება სუპერ სწრაფი.
და მაშინ შესვლა, რომელიც რა მიგვაჩნია ორობითი ძებნა.
თუ ჩვენ შეამჩნია, რადგან თქვენი პრობლემა იღებს გაცილებით და ბევრად უფრო,
დრო სჭირდება, რომ თქვენ შეძლებთ ეს ნამდვილად არ გაიზრდება ბევრად.
ეს იგივეა, შედარებით აქ დასაწყისში.
თქვენ, როგორც, OK.
არაფერი აქ ნამდვილად არ მნიშვნელობა რომელი ერთი ვიყენებთ,
მაგრამ თქვენ გავიდნენ მილიონი, მილიარდი.
თქვენ ცდილობს იპოვოს some-- --you're ცდილობს იპოვოს ნემსის haystack.
>> მე ვფიქრობ, რომ გსურთ ამ პრობლემას.
გსურთ ამ სირთულისა, არ ხაზოვანი რადგან ყველა თქვენ
იცით თქვენი gonna უნდა ეძებს მეშვეობით თითოეულ ინდივიდუალური ნემსი, რაც თივა,
ცდილობს გამოიყურებოდეს თქვენი ნემსი.
და ეს არ არის ძალიან fun, ჩემი აზრით.
მე მიყვარს სწრაფად.
მომწონს ეფექტური.
და როგორც შრომისმოყვარე სტუდენტები თქვენ ბიჭები, თქვენ იცით, მუშაობა მსოფლიოს სასურველი სტუმარი გახდებით,
არ რთული ტიპის რამ, თუ როგორ შეიძლება შეადგინოს ამ ალგორითმები.
>> ასე რომ, ჩვენ ვაპირებთ ფეხით მეშვეობით მხოლოდ სწრაფი მაგალითად.
ვფიქრობ, თქვენ ბიჭები უნდა ჰქონდეს ხელის ორობითი ძებნა,
მაგრამ თუ ვინმე არის პატარა საეჭვო, გვინდა გააძლიეროს იგი,
ჩვენ ვაპირებთ, რომ უბრალოდ მეშვეობით მაგალითად აქ.
ასე რომ, ჩვენ ვეძებთ, თუ მასივი შეიცავს შვიდი.
>> ასე რომ, პირველი, რასაც ვაკეთებთ არის შევხედოთ შუა, არა?
და თქვენ აპირებს უნდა კოდირების ორობითი ძებნა მხოლოდ მეორე.
ასე რომ, ეს იქნება fun.
ასე გადავხედავთ შუა პატარა მასივები 3.
ამჯამად 3 გაუტოლდება 7?
არა.
ეს ექვსი.
ასე რომ, ნაკლები ან მეტი შვიდი?
ნაკლებია.
დიახ.
ლამაზი სამუშაო ბიჭები.
ვგრძნობ, როგორიც მე უნდა უნდა candy იმიტომ, რომ მე
მინდა იმისათვის, რომ ის შევიდა ეზოები.
ეს არის ის, რაც მე ვაპირებ მომავალ კვირას.
ეს დაიცავს თქვენ ბიჭები მკვეთრი.
>> ასე რომ, ჩვენ გადაყარეთ, რომ პირველ ნახევარში, არა?
ეს იყო ნაკლები.
ჩვენ ვიცით, რომ ყველაფერი რომ მარცხენა მხარეს
იქნება ნაკლები, რაც ჩვენ რეალურად ეძებს.
ასე, რომ არ არის საჭირო ყურადღება მიაქციოს მას.
უბრალოდ დაივიწყოს იგი.
ასე რომ, ახლა ჩვენ შევხედოთ ჩვენი მარჯვენა მხარეს, და ჩვენ შევხედოთ შუა იქ,
და ახლა ეს ცხრა.
ასე რომ, 9 is-- --Everyone?
მეტია, რაც ჩვენ ეძებს, არა?
ასე რომ, ჩვენ ვაპირებთ, იმისათვის, მოშორებით ყველაფერს უფლება.
როგორიცაა, რომ.
ახლა, ყველა დაგვრჩა ერთი.
ასე რომ, ჩვენ შეამოწმოს, არის ეს ერთი, რა ჩვენ ვეძებთ? ეს არის.
ჩვენ აღმოვაჩინეთ, რაც გვინდოდა.
ასე რომ, ჩვენ გავაკეთეთ.
Bilinear ძებნა.
>> და თუ თქვენ შეამჩნევთ, რომ ჩვენ შვიდი საშუალებებით არსებობს.
ეს მხოლოდ ჩვენთან, როგორც სამჯერ, მაგრამ თუ თქვენ აკეთებთ, როგორიცაა მილიარდი,
თქვენ ბიჭები ვიცი რამდენი ნაბიჯები ეს იქნებოდა მიიღებს თუ ჩვენ მას ოთხი მილიარდი რამ?
ნებისმიერი მიხვდება?
32.
32 ნაბიჯები, რათა იპოვოს რაღაც ოთხი მილიარდი
ელემენტს მასივი გამო უფლებამოსილების ორი.
ასე რომ, ორი არის 32, არის ოთხი მილიარდი.
>> ასე რომ, საკმაოდ გიჟები, როგორ თქვენ ჯერ კიდევ , საკმაოდ მცირე რაოდენობის ნაბიჯები
, რაღაც ოთხი მილიარდი ელემენტებს.
ასე რომ შენიშვნა, ჩვენ აპირებს კოდექსს
ასე რომ თქვენ ბიჭები შეიძლება რეალურად სახის ვხედავთ, როგორ მუშაობს.
ყველა უფლება, ასე რომ თქვენ ბიჭები შეიძლება კოდი.
მე ვაპირებ მოგცემთ ბიჭებს გაიგო ცოტა.
გაეცნონ თქვენს გარშემო, რომელიც რა ვინმე სურდა ბოლო მონაკვეთზე.
>> ასე გაეცნონ თქვენს გარშემო.
განხილვა ცოტა.
და ყველა მე მინდა თქვენგან ბიჭები ახლა მხოლოდ
ვცდილობთ შევქმნათ მონახაზი pseudocode.
OK?
Whoa.
ყველა მინდა თქვენ ბიჭები არის თქვენ უბრალოდ აპირებს შეავსოთ ეს მაშინ, როცა საქმე.
ასე შევქმენი ეს ზედა და ქვედა საზღვრები, რომელიც
წარმოადგენს დასაწყისში და ბოლოს ჩვენი მასივი.
და თქვენ რეალურად ციკლი და გაერკვნენ
რას ვაკეთებთ ჩვენ ამ ხოლო loop.
>> ასე რომ, თუ თქვენ შეგიძლიათ გაერკვნენ out-- მაქვს მინიშნება იქ რა შემთხვევები
რომ ჩვენ გვაქვს აქ?
ასე რომ, თუ გვინდა, რომ გაერკვნენ შემთხვევაში, ჩვენ Pseudocode იმ
და მაშინ ჩვენ რეალურად კოდი მათგანი.
და ეს იქნება, მე ვფიქრობ, იმედია ეს
იყოს ცოტა უფრო ადვილია, ვიდრე თქვენ წარმოგიდგენიათ.
იმიტომ, რომ ეს არ არის, რომ ბევრი კოდი, რეალურად, რომელიც არის მართლაც მაგარი.
>> მმ-hm?
>> სტუდენტი: [INAUDIBLE]?
ინსტრუქტორი: დიახ.
იქ იყო რაღაც მოძიების შუა.
>> სტუდენტი: ასე რომ ჩვენ შეგვიძლია გამოვიყენოთ რომ.
OK.
>> ინსტრუქტორი: Perfect.
ასე რომ, პირველი, რაც ჩვენ უნდა გავაკეთოთ.
ასე რომ, შუა.
დიდი.
ასე რომ თქვენ გაქვთ იდეა, თუ როგორ შეიძლება რეალურად შუა კოდით?
>> სტუდენტი: Yeah.
n 2-ზე?
ინსტრუქტორი: So n 2-ზე.
ასე რომ ერთი რამ უნდა გვახსოვდეს, რომ თქვენი ზედა და ქვედა საზღვრები იცვლება.
ჩვენ მუდმივად მშენებლობის ნაწილი მასივი ჩვენ ვეძებთ.
ასე რომ, ო 2-ზე იმუშავებს მხოლოდ პირველი, რასაც ვაკეთებთ.
ასე რომ, ზედა და ქვედა გათვალისწინებით, როგორ შეიძლება მივიღებთ, რომ შუა ელემენტს?
იმიტომ, რომ ჩვენ გვინდა, რომ საშუალო შორის ზედა და ქვედა, არა?
მმ-hm?
>> სტუდენტი: [INAUDIBLE].
>> ინსტრუქტორი: ასე რომ, ჩვენ გვაქვს გარკვეული შეტევა.
და ეს იქნება ზედა პლუს ქვედა 2-ზე.
გასაოცარია.
იქ ჩვენ წავიდეთ.
ერთი ხაზი ქვემოთ.
თქვენ ბიჭები არიან თქვენი გზა.
ასე რომ, ახლა რომ ჩვენ გვაქვს ჩვენი შუა, რა უნდა გავაკეთოთ?
უბრალოდ კულტურას.
თქვენ არ გაქვთ კოდი იგი.
დიახ.
სტუდენტი: [INAUDIBLE]?
ინსტრუქტორი: ასე რომ, პლუს იმიტომ, რომ თქვენ მოძიებაში საშუალო ორ
მათ.
ასე რომ, თუ თქვენ ფიქრობთ, რომ ასეთი მზარდი in მხრიდან,
ვიფიქროთ, რომ, როგორც თქვენ მიახლოება შუა გსურთ, რომ.
ასე რომ, თუ ორივე მხარეს შუა, და ჩვენ გვაქვს, როგორიცაა 5 და 7.
როდესაც თქვენ დაამატოთ ისინი ერთად თქვენ მიიღეთ 12, დაყოფის მიერ 2, 6.
>> ზოგჯერ ძნელია ახსნა, თუ რატომ, რომ მუშაობს,
მაგრამ თუ თქვენ მუშაობთ მეშვეობით მაგალითად, ზოგჯერ
ეს თქვენ დაგეხმაროთ გაერკვნენ, თუ ეს უნდა იყოს პლუს ან მინუს.
დიახ.
>> სტუდენტი: [INAUDIBLE] ზუსტად შუა
თუ მათ არ ჰქონდათ საქმე, სადაც არსებობს ბევრი პატარა ნომრები
და, როგორც ერთი დიდი რაოდენობით?
>> ინსტრუქტორი: ასე რომ ყველა თქვენ უნდა შუა მასივი.
ასე რომ, თუ მქონდა bunch of პატარა ნომრები და მაშინ მართლაც დიდი რაოდენობით
ბოლოს, რომ არ აქვს მნიშვნელობა.
ყველა თემა არის ის, რომ ისინი დახარისხებული, უბრალოდ
მინდა შევხედოთ შუა მასივი, რადგან თქვენ ჯერ
ოპონენტის თქვენი პრობლემა ნახევარი.
ზემოთ.
ასე რომ, ახლა, რომ ჩვენ გვაქვს შუა, რა გავაკეთოთ შემდეგი?
>> სტუდენტი: შედარება.
ინსტრუქტორი: შედარება.
ასე რომ შედარების შუა value_wanted.
ზემოთ.
ასე რომ, ხედავთ, აქ გვაქვს ეს არც ჩვენ გვინდა აქ.
გვახსოვდეს, რომ ეს არის მასივი.
ასე შუა ეხება ინდექსი.
ასე რომ ჩვენ გვინდა ღირებულებებზე ცენტრიდან.
არ უნდა დაგვავიწყდეს, რომ, თუ გსურთ შედარება, ორმაგი შეადგენს.
თქვენ ამის გაკეთება ერთი უდრის თქვენ უბრალოდ აპირებს reassign ის,
და მაშინ, რა თქმა უნდა, ეს იქნება არც გინდათ.
ასე რომ არ გაგვაჩნია.
>> ამიტომ, ჩვენ ვაპირებთ, რომ თუ ღირებულებები შუა
უდრის არც ჩვენ გვინდა.
ნუ დაგავიწყდებათ თქვენი braces.
Dropbox უნდა წავიდეს.
ასე რომ, რა ვქნათ ამ შემთხვევაში?
თუ ეს არის ის, რაც ჩვენ გვინდა, რომ დაბრუნდეს?
ჩვენ ვცდილობთ, რომ ამბობენ.
>> STUDENT ბეჭდვა off.
>> ინსტრუქტორი: ჩვენ, არ მინდა, რომ ბეჭდვა off.
ასე რომ, ეს bool აქ, ამიტომ ჩვენ მინდა დაბრუნდეს ჭეშმარიტი ან ცრუ.
ჩვენ ვამბობთ, რომ ეს რიცხვი [? RRA? ?] ასე რომ, თუ ეს,
ჩვენ უბრალოდ დააბრუნოს ეს ასეა.
თუ შემიძლია სიტყვიერად ჭეშმარიტი.
>> სტუდენტი: რატომ არ დაბრუნების ნულოვანი?
ინსტრუქტორი: ასე რომ თქვენ შეიძლება დაბრუნების ნულოვანი თუ უნდოდა.
მაგრამ ამ შემთხვევაში, რადგან ჩვენი ფუნქცია დააბრუნებს bool,
ჩვენ უნდა დაბრუნდეს ჭეშმარიტი ან ცრუ.
სტუდენტი: როდესაც თქვენ განაცხადა, რომ ლოგიკური გამოხატვის,
შეგიძლიათ ვაყენებთ მას ტოლი ყალბი?
ასე, თუ მე მინდა ვთქვა, თუ ეს მდგომარეობა არ შეხვდა, როგორიც არის ზედა ტოლია ყალბი.
იქნება ეს მესმის, თუ თქვენ მხოლოდ დააყენა ცრუ მეორე მხარეს?
ინსტრუქტორი: ჰო.
ასე რომ, რეალურად, თუ თქვენ ოდესმე აკეთებს რაღაც
როგორიც არის ზედა ან ქვედა, რომ ბრუნდება ნამდვილი ან ყალბი
და ეს რეალურად ცუდი სტილი ვთქვათ შეადგენს შეადგენს ჭეშმარიტი ან ტოლობის
უდრის ყალბი.
თქვენ გინდათ გამოიყენოთ, რომ შედეგი როგორც თავად, როგორც თქვენი ქვითარი.
არ არის რაც მინდოდა.
ეს არის ის, რაც მე მინდოდა.
ასე რომ, იმ შემთხვევაში, თუ თქვენ გეკითხებით მსგავს გადარჩენა ეს გ.
>> ასე რომ, თუ ჩვენ გვაქვს int ძირითადი (void) და რაღაც მსგავსი.
და თქვენ თუ არის ზედა ზოგიერთი შეყვანის და თქვენ
ითხოვს, თუ შეგიძლიათ გააკეთოთ მსგავსი რამ?
არა?
სტუდენტი: მე ვცდილობდი ამის გაკეთება [INAUDIBLE].
იმიტომ, რომ თუ it's--
ინსტრუქტორი: Right.
ასე რომ თქვენ გსურთ, რომ ეს იქნება ყალბი, არა?
სტუდენტი: Yeah.
ინსტრუქტორი: ასე რომ, ამ შემთხვევაში თქვენ მინდა, რომ შეასრულოს, თუ ეს ასე არ არის.
ასე cool რამ თქვენ არ არის ეს.
ასე მახსოვს, ძახილის წერტილი უარყოფს რამ?
იგი აცხადებს, რომ [INAUDIBLE] ნიშნავს არა.
ასე რომ, თუ დავაკვირდებით მხოლოდ ეს ნაწილი აქ, ნეტავ
ამბობენ, რომ აფასებს ყალბი, როგორც თქვენ გსურთ იგი.
არ მცდარი მართალია რომელიც ეს ნიშნავს, რომ შეასრულოს.
ამჯამად რომ აზრი?
სტუდენტი: Yeah.
ინსტრუქტორი: გასაოცარია.
OK.
ასე რომ ჩვენ შეგვიძლია უბრალოდ დააბრუნოს მართალია, ამ შემთხვევაში.
ახლა ჩვენ გვაქვს ორი სხვა შემთხვევაში ამ შემთხვევაში.
რა არის ორი სხვა შემთხვევებში?
მოდით უბრალოდ ეს გზა.
მოდით დავიწყოთ სხვა თუ ღირებულებების შუა
ნაკლებია, ვიდრე ღირებულება გვინდა.
ასე რომ, ჩვენი ღირებულების საშუალო ნაკლებია მეტი ღირებულება, რომელიც ჩვენ ვეძებთ.
>> ასე რომ, რაც შეკრული თქვენ ვფიქრობ, რომ ჩვენ გვინდა, რომ განაახლოს?
ზედა ან ქვედა?
ზედა?
ასე რომ, რაც მხარეს მასივი ჩვენ ვაპირებთ ეძებს?
>> სტუდენტი: დაბალია.
>> ინსტრუქტორი: ჩვენ მივდივართ უნდა ეძებს მარცხენა.
ასე რომ სხვაგან თუ ცოტა არც ნაკლები.
ასე რომ თქვენი საშუალო ღირებულება აქ ნაკლებია, ვიდრე ის, რაც ჩვენ გვინდა.
ასე რომ ჩვენ გვინდა, რომ მიიღოს მარჯვენა მხარეს ჩვენი მასივი.
ამიტომ, ჩვენ ვაპირებთ, რომ განაახლოს ჩვენი ქვედა შეკრული.
ასე რომ, ჩვენ reassign ჩვენი დაბალია.
და რას ფიქრობთ ქვედა უნდა იყოს?
სტუდენტი: საშუალო ღირებულება?
ინსტრუქტორი: So შუა ღირებულება
სტუდენტი: Plus 1.
ინსტრუქტორი: --plus 1.
შეიძლება ვინმე მითხრათ რატომ ჩვენ გვაქვს Plus 1?
>> სტუდენტი: [? არ ღირებულება?] უფრო თანაბარი მას.
>> ინსტრუქტორი: Right.
იმიტომ, რომ ჩვენ უკვე ვიცით, რომ ჩვენი საშუალო ღირებულება არ არის ტოლი
და ჩვენ გვინდა, რომ გამორიცხავს ყველა შემდგომი ძიება.
თუ თქვენ დაგავიწყდებათ, რომ + 1 ეს მომწონს loop განუსაზღვრელი ვადით.
და თქვენ უბრალოდ უნდა დაიჭირეს უსასრულო ციკლი და შემდეგ თქვენ segfault
და რამ წავიდეთ ცუდი.
ამიტომ ყოველთვის დარწმუნდით, რომ თქვენ არ მათ შორის არც ის, რომ თქვენ მხოლოდ
შევხედე.
ასე რომ, ჩვენ იზრუნოს, რომ პლუს 1.
>> ახლა ჩვენ გვაქვს ჩვენი ბოლო მდგომარეობა რომელიც მე ყოველთვის უსაფრთხოების გულისთვის
თქვენ შეგიძლიათ შეამოწმოთ აქ სხვაგან, თუ ღირებულება შუა მეტი ღირებულების
ჩვენ გვინდა.
ეს იმას ნიშნავს, რომ ჩვენ გვინდა, მარცხენა ნახევარში.
ასე რომელი მივდივართ განახლება?
ზედა.
და რა არის ეს აპირებს თანაბარი?
შუა მინუს 1, რადგან, რა თქმა უნდა, ჩვენ გვინდა,
იმისათვის, რომ ჩვენ არა ვართ ეძებს, რომ ახლო ღირებულება ერთხელ.
და შემდეგ ჩვენ გვაქვს ეს.
ეს არის ის.
რომ ყველა ორობითი ძებნის.
ეს არ არის ცუდი, არა?
ეს იგივეა, 10 ხაზი კოდი და თეთრი სივრცე.
ასე რომ, ძალიან ძლიერი, ძალიან სასარგებლო, თქვენ მისი გამოყენება ერთ-ერთ შემდეგ psets.
იქნებ არ ერთი, მაგრამ მოგვიანებით.
ასე რომ ვისწავლოთ იგი.
მიყვარს.
ეს მკურნალობა თქვენ კარგად.
ასე რომ ვინმეს აქვს რაიმე შეკითხვა ორობითი ძებნა?
დიახ.
>> სტუდენტი: აქვს მნიშვნელობა თუ არა თქვენი n კი ან უცნაური?
>> ინსტრუქტორი: No.
იმიტომ, რომ ჩვენ მიიღო ის შუა, როგორც int, ეს მხოლოდ შეკვეცავს იგი.
ასე რომ, ეს დარჩება რიცხვი და ეს საბოლოოდ დასალაგებლად მეშვეობით ყველაფერს.
ასე რომ თქვენ არ უნდა ფიქრი, რომ.
ყველას კარგი?
გასაოცარია.
ზემოთ.
ასე რომ, თქვენ ბიჭები ამ.
Slideshow.
ასე რომ, როგორც ჩვენ ვსაუბრობთ, მე ვიცი, დავით აღნიშნული სირთულის runtimes.
>> ასე რომ, საუკეთესო შემთხვევაში, ის მხოლოდ ერთი, რაც ჩვენ მოვუწოდებთ მუდმივი დრო.
შეუძლია ვინმეს მითხრათ რატომ შეიძლება იყოს?
რა ტიპის სცენარი, რომელიც იწვევს?
მმ-hm.
>> სტუდენტი: [INAUDIBLE] first--
ინსტრუქტორი: So შუა მყოფი პირველი ელემენტი, რომელიც ჩვენ მოვიდა, არა?
ასე რომ, ან მასივი, ერთი ან რასაც ჩვენ ვეძებთ მხოლოდ
ხდება, რომ smack dab შუა.
ასე რომ ჩვენი საუკეთესო შემთხვევაში.
თქვენ შეღწევას რეალური პრობლემები, ალბათ, არ აპირებს მიაღწიოს [INAUDIBLE], რომ ხშირად.
რაც შეეხება ჩვენს ყველაზე ცუდ შემთხვევაში?
ჩვენი უარეს შემთხვევაში არის log n.
და რომ უნდა გააკეთოს, რომ მთელი უფლებამოსილების ორი რამ, რომ მე ისაუბრა.
>> ასე რომ, უარეს შემთხვევაში ეს იმას ნიშნავს, რომ ჩვენ უნდა მომეჭრა მასივი ქვემოთ
სანამ ის იყო ელემენტს ერთი.
ასე რომ, ჩვენ უნდა მომეჭრა, ის ქვემოთ ნახევარი როგორც არაერთხელ, როგორც ჩვენ ეს შესაძლებელი იქნებოდა.
სწორედ ამიტომ ეს log n, რადგან უბრალოდ შეინახოს გამყოფი ორი.
ასე ვარაუდები, რამ უნდა იცოდეთ, თუ თქვენ ოდესმე
აპირებთ გამოიყენოთ ორობითი ძებნა.
თქვენი ელემენტები უნდა იყოს გადანაწილებული.
ისინი უნდა იყოს დახარისხებული, რადგან ეს არის ერთადერთი გზა, თქვენ
შეუძლია თუ თქვენ შეუძლია იმისათვის, რომ ნახევარს.
>> თუ თქვენ არ ჰქონდა ამ სახელებს ჩანთა ნომრები და თქვენ ამბობდა,
OK, მე ვაპირებ შეამოწმოს საშუალო ნომერი და ნომერი ვეძებ
ნაკლებია, მე უბრალოდ აპირებს თვითნებურად ჩააგდე ერთი ნახევარი.
თქვენ არ იცით, თუ თქვენი ციფრები, რომ მეორე ნახევარში.
თქვენი სია უნდა იყოს დახარისხებული.
ასევე, ეს შეიძლება იყოს მიდის წინ ცოტა,
მაგრამ თქვენ უნდა წვდომის.
თქვენ უნდა შეეძლოს მხოლოდ წასვლა რომ შუა ელემენტს.
თუ თქვენ გაქვთ გავლის მეშვეობით რაღაც
ან სჭირდება ზედმეტი ნაბიჯები მისაღებად, რომ შუა ელემენტს,
ის არ შეხვიდეთ n აღარაა, რადგან თქვენ დასძინა მეტი მუშაობა შევიდა.
და ეს იქნება პატარა უფრო გრძნობა ორი კვირის განმავლობაში,
მაგრამ მე უბრალოდ სახის სურდა შესავალი, მოგაწვდით ბიჭები იდეა რა
მოვა.
მაგრამ ეს ორი მნიშვნელოვანი ვარაუდები
რომ თქვენ უნდა ორობითი სიაში.
დარწმუნდით, რომ იგი ინახება.
ეს არის ის, დიდი ერთი თქვენ ბიჭები ახლა.
და რომ ჩვენ შეგვიძლია წავიდეთ დანარჩენი ჩვენი ჯიშები.
ისე ოთხი sorts-- bubble, ჩანართი, შერჩევა, და შერწყმა.
ისინი ყველა სახის cool.
თუ ბიჭები გადაწყვეტენ მიიღონ CS 124, თქვენ გაეცნობიან ყველა სახის სახის.
და თუ თქვენ xkcd fan, არსებობს მართლაც მაგარი კომიკური შესახებ
როგორც მართლაც არაეფექტური სახის, რომელიც მე უაღრესად გირჩევთ აპირებს შევხედოთ.
ერთ-ერთი მათგანი, როგორიცაა პანიკა ჯიშია, ჰგავს, მე არ, დაბრუნების შემთხვევითი მასივი.
გამორთვის სისტემა.
დატოვოს.
ასე geeky იუმორის ყოველთვის კარგი.
>> ასე რომ ვინმეს გახსოვთ სახის მოსწონს მხოლოდ ზოგადი წარმოდგენა
როგორ bubble sort მუშაობს.
გახსოვთ?
>> სტუდენტი: Yeah.
>> ინსტრუქტორი: წავალ.
>> სტუდენტი: ასე რომ, თქვენ გადის და თუ ის მეტია, მაშინ სვოპ ორი.
>> ინსტრუქტორი: Mm-hm.
ზუსტად.
ასე რომ თქვენ უბრალოდ iterate მეშვეობით.
თქვენ შეამოწმოთ ორი ნომერი.
თუ ადრე უფრო დიდია, ვიდრე ერთი შემდეგ,
თქვენ მხოლოდ სვოპ მათ ისე, რომ ამ გზით ყველა უმაღლესი ნომრები
bubble up დასასრულს სიაში და ყველა ქვედა ნომრები bubble ქვემოთ.
>> ცხადყო მან, რომ თქვენ ბიჭები მაგარი ხმა ეფექტი დახარისხება ვიდეო?
ეს არის სახის cool.
ასე რომ, როგორც რობერტ აღნიშნა, ალგორითმი რომ თქვენ უბრალოდ ნაბიჯ მეშვეობით სიაში,
შევცვალე მიმდებარე ფასეულობების თუ ისინი არ, რათა.
და მაშინ უბრალოდ შეინახოს იმეორებს სანამ თქვენ არ მიიღოს ნებისმიერი სვოპების.
ასე არ არის ცუდი, არა?
ასე რომ, ჩვენ უბრალოდ უნდა სწრაფი მაგალითად აქ.
ასე რომ, ეს იქნება დასალაგებლად მათ აღმავალი შეკვეთა.
ამიტომ, როდესაც ჩვენ გაიაროს პირველი დროს, ჩვენ გადავხედავთ რვა
და ექვსი აშკარად არ ამ მიზნით, ჩვენ სვოპ მათ.
>> ასე რომ შევხედოთ ერთი.
რვა და ოთხი არ მიზნით.
სვოპ მათ.
და მაშინ რვა და ორი, სვოპ მათ.
იქ ჩვენ წავიდეთ.
ასე შემდეგ თქვენი პირველი უღელტეხილზე, თქვენ იცით, რომ თქვენი დიდი რაოდენობის
იქნება ყველა გზა ზედა, რადგან ეს მხოლოდ
იქნება მუდმივად უფრო დიდი, ვიდრე ყველაფერი
და ეს მხოლოდ აპირებს ბუშტი ყველა გზა ბოლომდე არსებობს.
ამჯამად რომ აზრი, რომ ყველასთვის?
ზემოთ.
>> ასე რომ, ჩვენ შევხედოთ ჩვენი მეორე უღელტეხილზე.
ექვსი და ოთხი, შეცვლა.
ექვსი და ორი, შეცვლა.
და ახლა ჩვენ გვაქვს რამდენიმე რამ მიზნით.
ასე რომ, ყოველ უღელტეხილზე, რომ ჩვენ რათა ჩვენი მთელი სია,
ჩვენ ვიცით, რომ როგორც, რომ ბევრი ნომრები ბოლოს უკვე დახარისხებული.
ასე რომ ჩვენ მესამე უღელტეხილზე, რომელიც არის ერთ ერთი swap.
და მერე ჩვენი მეოთხე გაივლის, ჩვენ გვაქვს ნულოვანი slots.
ასე რომ, ჩვენ ვიცით, რომ ჩვენი მასივი დახარისხებული.
>> და ეს არის დიდი რამ bubble sort.
ჩვენ ვიცით, რომ როდესაც ჩვენ ნულოვანი გაცვლებს, რომ
ნიშნავს, რომ ყველაფერი არის სრული წესრიგი.
ეს ერთგვარი, თუ როგორ შევამოწმოთ.
ასე რომ, ჩვენ ვაპირებთ კოდექსის bubble სახის, რომელიც ასევე არ არის, რომ ცუდი.
არც ერთი ეს არის, რომ ცუდი.
მე ვიცი, შეიძლება, როგორც ჩანს, ცოტა საშინელი.
მე ვიცი, როდესაც მე კლასი, მაშინაც კი, როცა
ასწავლის კლასი პირველად შარშან,
მე, როგორც, როგორ გავაკეთო ეს?
ეს აზრი თეორიულად, მაგრამ როგორ უნდა რეალურად ამის გაკეთება?
რის გამოც მე ასევე მინდა სიარული მეშვეობით კოდი თქვენ ბიჭები აქ.
ასე რომ pseudocode შენ ამ დროს.
ასე რომ მხოლოდ შენარჩუნება ამის გათვალისწინებით, როგორც ჩვენ შესახებ გადასვლას დასრულდა.
ასე, რომ ჩვენ გვაქვს counter, რომ ინახავს ტრეკზე ჩვენი გაცვლებს,
იმიტომ, რომ ჩვენ უნდა დავრწმუნდეთ, რომ ჩვენ შემოწმების რომ.
და ჩვენ iterate მთელ მასივი როგორც ჩვენ გავაკეთეთ ეს მაგალითი.
თუ ელემენტს სანამ არ აღემატება ელემენტის შემდეგ, სადაც ჩვენ ვართ,
ჩვენ სვოპ მათ და ჩვენ გავზარდოთ ჩვენი counter, რადგან, როგორც კი swap,
ჩვენ გვინდა, რომ ჩვენი counter ვიცი, რომ.
რაიმე შეკითხვები არსებობს?
რაღაც ჩანს სასაცილო აქ.
სტუდენტი: თქვენ თუ მითითებული counter ნულოვანი ყოველ დროს, თქვენ გავლა loop?
არ გააგრძელებ უკან ნულის ყველა დროის?
ინსტრუქტორი: არ არის აუცილებელი.
რა მოხდება, რომ ჩვენ გაიაროს აქ.
ასე რომ, მაშინ, როდესაც, გახსოვთ, ეს შეასრულოს ერთხელ უეჭველად.
ასე რომ, ის აპირებს მითითებული counter ნულის ტოლია,
შემდეგ ის აპირებს iterate მეშვეობით.
როგორც ის iterates მეშვეობით, იგი განაახლებს counter.
როგორც ის განახლება counter, როდესაც ეს კეთდება, როცა ის მიაღწია ბოლოს მასივი,
თუ ჩვენს სიაში არ იქნა დახარისხებული, counter უკვე განახლდა.
>> ასე რომ, შემდეგ ამოწმებს მდგომარეობა და ამბობს, OK, არის counter ნულზე მეტი.
თუ ეს არ არის, ამას კიდევ ერთხელ.
გსურთ აღადგინოთ ასე რომ, როდესაც თქვენ გავლა, counter ნულის ტოლია.
თუ თქვენ გავლა დახარისხებული მასივი, არაფერი შეიცვლება,
ეს არ მოხდება, და თქვენ დაბრუნდეს დახარისხებული სია.
ამჯამად რომ აზრი?
სტუდენტი: ეს შეიძლება ცოტა.
ინსტრუქტორი: OK.
თუ არსებობს რაიმე სხვა საკითხი, რომ მოდის up.
დიახ.
>> სტუდენტი: რას ფუნქცია იქნება შევცვალე ელემენტები?
>> ინსტრუქტორი: ასე რომ ჩვენ შეგვიძლია რეალურად დაწეროს რომ თუ ჩვენ ვაპირებთ, რომ ახლა.
ზემოთ.
ასე რომ შენიშვნა, Alison აპირებს გადართვის უკან მოწყობილობების.
ეს იქნება fun.
და ჩვენ გვაქვს ჩვენი ლამაზი bubble sort რამ აქ.
ასე რომ, მე უკვე გააკეთა cycling მეშვეობით მასივი.
ჩვენ გვაქვს ჩვენი სვოპების რომ არის ნულის ტოლია.
ასე რომ, ჩვენ გვინდა, რომ სვოპ მიმდებარე ელემენტები, თუ ისინი მწყობრიდან.
ასე რომ, პირველი, რაც უნდა არ არის iterate ჩვენი მასივი.
>> ასე რომ, როგორ ფიქრობთ, ჩვენ შეგვიძლია iterate ჩვენი მასივი?
ჩვენ გვაქვს და უდრის 0.
ჩვენ გვინდა i ნაკლები უნდა იყოს ვიდრე ო მინუს 1 მინუს k.
და მე აგიხსნით, რომ მეორე.
ასე რომ, ეს არის ოპტიმიზაცია აქ, სადაც, მახსოვს, როგორ მას შემდეგ, რაც ყოველ უღელტეხილზე
მეშვეობით მასივი ჩვენ ვიცი, რომ რაც არ უნდა on--
>> ასე რომ, შემდეგ ერთ უღელტეხილზე ჩვენ ვიცი, რომ ეს არის დახარისხებული.
შემდეგ ორი შეჭრა ჩვენ ვიცით, რომ ეს ყველაფერი დალაგებულია.
მას შემდეგ, რაც სამი შეჭრა ჩვენ ვიცი, რომ ეს დახარისხებული.
ასე რომ გზა მე iterating მასივი აქ,
არის ის რაც დარწმუნებული ვარ, მხოლოდ იქ მეშვეობით, რაც ვიცით, არის დაუხარისხებელი.
OK?
ეს მხოლოდ ოპტიმიზაცია.
თქვენ შეგიძლიათ დაწეროთ ის გულუბრყვილოდ მხოლოდ iterating მეშვეობით ყველაფერი,
ეს მხოლოდ დასჭირდეს.
ამ ოთხი loop ეს უბრალოდ ლამაზი ოპტიმიზაცია
რადგან ჩვენ ვიცით, რომ ყოველი სრული iteration მეშვეობით მასივი აქ,
როგორც ყოველ სრულ loop აქ, ჩვენ ვიცით, კიდევ ერთი ამ ელემენტების
იქნება დახარისხებული ბოლოს.
>> ასე რომ, ჩვენ არ უნდა ფიქრი იმ.
ამჯამად რომ აზრი, რომ ყველასთვის?
რომ მაგარი პატარა ხრიკი?
ასე რომ, ამ შემთხვევაში, თუ ჩვენ iterating მეშვეობით,
ჩვენ ვიცით, რომ ჩვენ გვინდა შევამოწმოთ თუ array და n plus 1 მიზნით.
OK.
ასე რომ აქ pseudocode.
ჩვენ გვინდა, რომ შეამოწმოთ, თუ მასივი n და n plus 1 მიზნით.
ასე რომ, რა შეიძლება ჩვენ უნდა იქ?
ეს იქნება გარკვეული პირობით.
ეს იქნება, თუ.
>> სტუდენტი: თუ მასივი n არის ნაკლებია, ვიდრე მასივი n plus 1.
ინსტრუქტორი: Mm-hm.
ასევე, ნაკლები ან მეტი.
სტუდენტი: მეტი.
მაშინ ჩვენ გვინდა სვოპ მათ.
ზუსტად.
ასე რომ, ახლა ჩვენ შეღწევას რა არის მექანიზმი შევცვალე მათ?
ასე რომ, ჩვენ გაიარა მოკლედ, გაცნობის swap ფუნქცია გასულ კვირას.
ვინმეს გახსოვთ, როგორ მუშაობს იგი?
ასე რომ, ჩვენ არ შეგვიძლია მხოლოდ reassign მათ, არა?
იმის გამო, რომ ერთ-ერთი მათგანი დაკარგა.
თუ ჩვენ თქმით ტოლია B და მაშინ B უდრის, ყველა უცებ ორივე მათგანი
არის ტოლი B.
>> ამიტომ, რაც ჩვენ უნდა გავაკეთოთ არის ჩვენ დროებითი ცვლადი რომ
გამართვას აპირებს ერთი ჩვენი, ხოლო ჩვენ პროცესი შევცვალე.
რა გვაქვს, რომ ჩვენ გვექნება გარკვეული int დროებითი ტოლი შეიძლება დაავალოს ეს
რომელი ერთი გსურთ, უბრალოდ დარწმუნდით შენარჩუნება სიმღერა it--
ასე რომ, ამ შემთხვევაში, მე ვაპირებ მივანიჭოთ მას მასივი n plus 1.
ისე, რომ აპირებს გამართოს, რასაც არც ამ მეორე ბლოკი
ჩვენ ვუყურებთ.
>> და მაშინ ჩვენ შეგვიძლია გავაკეთოთ არის შეგვიძლია წავიდეთ წინ და REASSIGN მასივი n + 1
იმიტომ, რომ ჩვენ ვიცით, აქვს, რომ არც ინახება.
ეს არის ასევე ერთი დიდი რამ მე არ ვიცი, თუ თქვენ
ჰქონდა საკითხები, სადაც, თუ თქვენ ჩართოთ ორ ხაზი კოდი მოულოდნელად რამ მუშაობდა.
იმისათვის, ძალიან მნიშვნელოვანია CS.
ასე რომ დარწმუნდით დიაგრამა რამ თუ არის შესაძლებელი
, თუ რა ხდება რეალურად.
ასე რომ, ახლა ჩვენ ვაპირებთ reassign მასივი n + 1
იმიტომ, რომ ჩვენ ვიცით, აქვს, რომ არც ინახება.
>> და ჩვენ შეგვიძლია მივანიჭოთ, რომ მასივი n ან ამ შემთხვევაში მასივი მე.
ძალიან ბევრი ცვლადები.
OK.
ახლა ჩვენ გადაიყვანა მასივი მე პლუს 1 უდრის რა არის მასივი მე.
და ახლა ჩვენ შეგვიძლია წავიდეთ უკან და მივანიჭოთ მასივი მე რა?
ვინმე?
>> STUDENT: 10.
>> ინსტრუქტორი: 10.
ზუსტად.
და ერთი რამ.
თუ ჩვენ გაცვალეს ახლა, რა უნდა გავაკეთოთ?
რა არის ერთი რამ, რომ აპირებს გვითხრათ
თუ ჩვენ ოდესმე შეწყვიტოს ეს პროგრამა?
რა გვეუბნება, რომ ჩვენ აქვს დახარისხებული სია?
თუ ჩვენ არ ასრულებს რაიმე გაცვლებს, არა?
თუ სვოპების ტოლია ნულოვანი ბოლოს ეს.
ასე რომ, როდესაც თქვენ შეასრულოს swap, როგორც ჩვენ მხოლოდ აქ, ჩვენ გვინდა განაახლოთ გაცვლებს.
და მე ვიცი, რომ იყო კითხვა, ადრე შეგიძლიათ
გამოყენება ნულოვანი ან ერთი ნაცვლად ჭეშმარიტი ან ცრუ.
და ეს რა ეს იმას აქ.
ასე რომ, ეს ნათქვამია, თუ არ იცვლება.
ასე რომ, თუ სვოპების არის ნულოვანი, რომელიც is-- ყოველთვის მიიღეთ ჩემი სიმართლე და ჩემი falses აირია.
ჩვენ გვინდა, ჩვენს შეაფასოთ რომ ჭეშმარიტი და ეს არ არის.
ასე რომ, თუ ეს ნულოვანი, მაშინ ეს სიცრუეა.
თუ თქვენ უარყოფს მას [? bang?] სიმართლე ხდება.
ასეა, მაშინ ეს ხაზი ახორციელებს.
>> სიმართლე და ყალბი და zeros და პირობა ჭკუიდან.
მხოლოდ იმ შემთხვევაში, თუ ნელა სიარული მეშვეობით ეს აზრი.
მაგრამ ის, რაც ამ პატარა ცოტა კოდი აქ აკეთებს.
ასე რომ, ეს ამოწმებს გავაკეთეთ რაიმე იცვლება.
ასე რომ, თუ ეს არაფერი, გარდა ნულოვანი, ის იქნება ყალბი
და მთელი რამ არის აპირებს შეასრულოს ერთხელ.
მაგარი?
>> სტუდენტი: რას შესვენების გაკეთება?
>> ინსტრუქტორი: Break მხოლოდ არღვევს თქვენ გარეთ loop.
ასე რომ, ამ შემთხვევაში, ეს იქნებოდა უბრალოდ მინდა დასრულდება პროგრამა
და თქვენ უბრალოდ თქვენი დახარისხებული სია.
სტუდენტი: Amazing.
ინსტრუქტორი: მე ბოდიში?
სტუდენტი: იმის გამო, რომ ადრე ჩვენ გამოიყენება წერილობითი 1 ზე დაწერილი zero
წარმოადგინოს, რომ თუ რომელიც იმუშავებს თუ არა.
>> ინსტრუქტორი: ჰო.
ასე რომ თქვენ შეგიძლიათ დაბრუნების ნულოვანი ან 1.
ამ შემთხვევაში, იმიტომ, რომ ჩვენ რეალურად არ აკეთებს არაფერი ფუნქცია,
ჩვენ უბრალოდ გვინდა, რომ შესვენება.
ჩვენ ნამდვილად არ აინტერესებს ეს.
სამუხრუჭე ასევე კარგია, თუ ის გამოიყენება არღვევს
ოთხი მარყუჟების და პირობები, რომ თქვენ არ გსურთ, რომ შევინარჩუნოთ შესრულებაში.
ეს მხოლოდ იღებს თქვენ აქედან.
ეს ცოტა ნიუანსი რამ.
ვგრძნობ, როგორიცაა არსებობს ბევრი ხელის ქნევა,
როგორც თქვენ გაეცნობიან მალე.
>> მაგრამ თქვენ გაეცნობიან მალე.
მე გპირდებით.
OK.
ასე რომ ყველას bubble sort?
ძალიან ცუდი.
Iterate მეშვეობით, swap რამ გამოყენებით temp ცვლადი, და ჩვენ ყველა იქ?
ზემოთ.
გასაოცარია.
OK.
უკან PowerPoint.
რაიმე შეკითხვები, ზოგადად, შესახებ ეს აქამდე?
ზემოთ.
მმ-hm.
>> სტუდენტი: [INAUDIBLE] int ძირითადი წესი.
მიგაჩნიათ თუ არა აქვს, რომ ამ საკითხთან დაკავშირებით?
>> ინსტრუქტორი: ასე რომ, ჩვენ უბრალოდ ეძებს მხოლოდ ფაქტობრივი დახარისხება ალგორითმი.
თუ თქვენ არ ჰქონდა ის ფარგლებში უფრო დიდი პროგრამა,
თქვენ ექნება int ძირითადი სადღაც.
დამოკიდებულია სადაც თქვენ გამოყენება ამ ალგორითმი,
ის განსაზღვრავს, რა არის დაბრუნება იგი.
მაგრამ ჩვენს შემთხვევაში, ჩვენ მკაცრად ეძებს თუ როგორ აკეთებს ამას, ფაქტობრივად,
iterate მეშვეობით მასივი.
ამიტომ, ჩვენ არ აღელვებს ეს.
>> ასე რომ, ჩვენ ვსაუბრობთ საუკეთესო შემთხვევაში და უარეს შემთხვევაში სცენარი ორობითი ძებნა.
ასე რომ, ეს ასევე მნიშვნელოვანია, რომ გავაკეთოთ რომ თითოეული ჩვენი ჯიშები.
ასე ფიქრობთ რა არის ყველაზე ცუდი საქმე runtime of bubble sort?
ბიჭები გახსოვთ?
>> სტუდენტი: N -1.
ინსტრუქტორი: N -1.
ისე, რომ ნიშნავს, რომ არსებობს ო მინუს 1 შედარებები.
ასე რომ ერთი რამ გვესმოდეს, რომ პირველ iteration,
ჩვენ გაიაროს, შევადარებთ ამ two-- ასე რომ 1.
ამ ორი, სამი, ოთხი.
ასე ერთი iteration ჩვენ უკვე გვაქვს ოთხი შედარებები.
როდესაც მე ვსაუბრობ დრო და n.
N წარმოადგენს რაოდენობა შედარება როგორც ფუნქცია რამდენი ელემენტები
ჩვენ გვაქვს.
OK?
>> ასე რომ, ჩვენ გაიაროს, ჩვენ გვაქვს ოთხი.
მომავალი დრო თქვენ იცით, რომ ჩვენ არ უნდა იზრუნოს ეს.
ჩვენ შევადარებთ ამ ორ, ამ ორი, ამ ორი,
და თუ ჩვენ არ გვაქვს, რომ ოპტიმიზაცია ოთხი ციკლი, რომელიც მე დავწერე,
თქვენ იქნება შედარებით აქ მაინც.
ასე, რომ თქვენ უნდა აწარმოებს მეშვეობით მასივი
და n შედარება n ჯერ, რადგან ყოველ ჯერზე ჩვენ
აწარმოებს მეშვეობით ჩვენ ერთგვარი ერთი რამ.
>> და ყოველ ჯერზე ჩვენ აწარმოებს მეშვეობით მასივი, ჩვენ n შედარება.
ასე რომ, ჩვენი runtime ეს არის ფაქტობრივად, n კვადრატში, რომელიც
გაცილებით უარესი ჩვენი შეხვიდეთ ბოლომდე, იმიტომ, რომ
ნიშნავს, თუ ჩვენ მას ოთხი მილიარდი ელემენტები, ის
აპირებს us ოთხი მილიარდი კვადრატში ნაცვლად 32.
ასე არ არის საუკეთესო runtime, მაგრამ გარკვეული რამ,
თქვენ იცით, თუ თქვენ ფარგლებში გარკვეული სპექტრი ელემენტები
bubble sort შეიძლება იყოს ჯარიმა გამოიყენოს.
>> OK.
ახლა რა არის საუკეთესო შემთხვევაში runtime?
სტუდენტი: Zero?
ან 1?
>> ინსტრუქტორი: So 1 გვინდა იყოს ერთი შედარებით.
უფლება.
>> სტუდენტი: N მინუს 1?
>> ინსტრუქტორი: ასე რომ, yeah.
ასე რომ, ო მინუს 1.
როდესაც თქვენ გაქვთ ისეთი ცნება, როგორიცაა n მინუს 1, ჩვენ, როგორც წესი, მხოლოდ ჩამოშალოს იგი off
და ჩვენ უბრალოდ, ვამბობთ n, რადგან თქვენ უნდა შედარების თითოეული these-- თითოეული წყვილი.
ასე რომ, ეს იქნება n მინუს 1, რომელიც ჩვენ ჩვენ უბრალოდ ამბობენ, დაახლოებით, n.
როდესაც თქვენ საქმე runtime, ყველაფერი უახლოვდება.
რადგან მაჩვენებლებით არის სწორი, თქვენ საკმაოდ კარგი.
>> ეს არის ის, თუ როგორ გაუმკლავდეთ მას.
ასე რომ, საუკეთესო შემთხვევაში არის n, რომელიც ნიშნავს, რომ სიაში უკვე დახარისხებული,
და ყველა ვაკეთებთ არის პერსპექტივაში მეშვეობით და შეამოწმოს, რომ ეს დახარისხებული.
ზემოთ.
ყველა უფლება.
ასე რომ, როგორც ხედავთ, ჩვენ უბრალოდ კიდევ რამდენიმე გრაფიკების.
ისე N კვადრატში.
სახალისო.
გაცილებით უარესი, ვიდრე n როგორც ვხედავთ, და ბევრად, ბევრად უარესი, ვიდრე ჟურნალი 2n.
და მაშინ ასევე მოხვდნენ ჟურნალი ჟურნალი.
და შენ 124, თქვენ შეღწევას როგორც ჟურნალი ვარსკვლავი, რომელიც მოსწონს გიჟები.
ასე რომ, თუ თქვენ დაინტერესებული, lookup შესვლა ვარსკვლავი.
ეს ერთგვარი გართობა.
ასე რომ, ჩვენ ამ დიდი სქემა.
უბრალოდ ხელმძღვანელები, ამ შესანიშნავი გრაფიკი აქვს
თქვენი შუალედური იმიტომ, რომ ჩვენ ხანგრძლივი გკითხოთ ეს არ შეიძლება.
ასე რომ მხოლოდ ხელმძღვანელები, აქვს ამ თქვენს შუალედური თქვენი ლამაზი cheat sheet
არსებობს.
ასე რომ, ჩვენ უბრალოდ შევხედე bubble sort.
უარეს შემთხვევაში, N კვადრატში, საუკეთესო შემთხვევაში, n.
და ჩვენ ვაპირებთ შევხედოთ სხვა.
>> და როგორც ხედავთ, მხოლოდ ერთი, რომ მართლაც აკეთებს კარგად
არის შერწყმა დალაგების, მივიღებთ, თუ რატომ.
ამიტომ, ჩვენ ვაპირებთ წასვლა მომდევნო ერთი აქ შერჩევა ერთგვარი.
ვინმეს გახსოვთ, როგორ შერჩევის დალაგების მუშაობდა?
წავიდეთ ეს.
>> სტუდენტი: ძირითადად გადის წესრიგი და შექმნას ახალი სია.
და ისევე, როგორც თქვენ აყენებს ელემენტები , დააყენა მათ უფლება ადგილი
ახალი სია.
>> ინსტრუქტორი: ასე რომ ხმები უფრო მოსწონს Insertion ჯიშია.
მაგრამ თქვენ ნამდვილად ახლოს.
ისინი ძალიან ჰგავს.
კი მე მათ აირია ხანდახან.
ადრე ამ განყოფილებაში მე იყო, დაველოდოთ.
OK.
ასე რომ, რა გსურთ გავაკეთოთ არის შერჩევის დალაგების,
გზა შეგიძლიათ ვფიქრობ, ამის შესახებ და გზა
მე დარწმუნებული ვარ, ვცდილობ არ მიიღოს მათ აირია, არის ის გადის
და ის ირჩევს პატარა ნომერი და
აყენებს, რომ დასაწყისში თქვენს სიაში.
ეს სვოპების ის, რომ პირველ ადგილზე.
მათ ფაქტობრივად, მაგალითად ჩემთვის.
გასაოცარია.
ასე რომ მხოლოდ გზა ვფიქრობ it-- შერჩევა დალაგების, აირჩიეთ პატარა ღირებულება.
და ჩვენ ვაპირებთ აწარმოებს მეშვეობით მაგალითად
რომ ვფიქრობ, ხელს შეუწყობს, რადგან მე ვფიქრობ, რომ ვიზუალური ყოველთვის დაეხმარება.
ასე რომ, ჩვენ დავიწყოთ რაღაც რომ სრულიად დაუხარისხებელი.
Red იქნება დაუხარისხებელი, მწვანე იქნება დახარისხებული.
ეს ყველა აზრი მეორე.
>> ასე რომ, ჩვენ გაიაროს და ჩვენ iterate თავიდან ბოლომდე.
და ვამბობთ, OK, 2 ჩვენი პატარა ნომერი.
ამიტომ, ჩვენ ვაპირებთ მიიღოს 2 და ჩვენ ვაპირებთ გადატანა წინ ჩვენი მასივი
იმიტომ, რომ მცირე რაოდენობის გვაქვს.
ასე რომ, ეს, თუ რას აკეთებს აქ.
უბრალოდ აპირებს სვოპ ორი.
ახლა ჩვენ დახარისხებული ნაწილი და არასორტირებული ნაწილი.
და რა უნდა გვახსოვდეს, შერჩევის დალაგების
არის ჩვენ მხოლოდ შერჩევის საწყისი არასორტირებული ნაწილი.
>> დახარისხებული ნაწილი უბრალოდ დაანებოს.
მმ-hm?
>> სტუდენტი: როგორ ვიცით, რა არის პატარა გარეშე შედარება
ყველა სხვა ღირებულების მასივი.
ინსტრუქტორი: ეს არ შევადარებ.
მოგვწონს გამოტოვებენ იგი.
ეს არის მხოლოდ და მხოლოდ ზოგადი საერთო.
ჰო.
როდესაც ჩვენ წერენ კოდი ვარ დარწმუნებული ვარ, თქვენ უფრო კმაყოფილი.
მაგრამ თქვენ შესანახად ეს პირველი ელემენტს, როგორც პატარა.
თქვენ შედარება და თქვენ იტყვით, ეს არის პატარა?
დიახ.
შეინახოს იგი.
აქ არის პატარა?
არა?
>> ეს არის თქვენი პატარა, reassign ეს თქვენი ღირებულება.
და თქვენ ბევრად უფრო ბედნიერი როდესაც ჩვენ გაიაროს კოდი.
ასე რომ, ჩვენ გაიაროს, ჩვენ სვოპ ის, ასე რომ, დავაკვირდებით ამ არასორტირებული ნაწილი.
ამიტომ, ჩვენ ვაპირებთ აირჩიოთ სამი.
ჩვენ ვაპირებთ, რომ ეს ზე ბოლოს ჩვენი დახარისხებული ნაწილი.
და ჩვენ უბრალოდ აპირებს შეინარჩუნოს რომ აკეთებს, რომ, და აკეთებს, რომ.
ასე რომ, ეს ჩვენი სახის pseudocode აქ.
ჩვენ კოდექსში ეს აქ მეორე.
მაგრამ რაღაც ფეხით შედეგად მაღალ დონეზე.
თქვენ აპირებს წავიდეს i = 0 to n მინუს 2.
ეს არის კიდევ ერთი ოპტიმიზაცია.
არ ინერვიულოთ ძალიან ბევრი ამის შესახებ.
ასე რომ, ამბობდნენ.
როგორც იაკობ ამბობდა, როგორ უნდა ტრეკზე რა ჩვენი მინიმალური არის?
როგორ ვიცით?
ჩვენ უნდა შეადაროთ ყველაფერი ჩვენს სიაში.
>> ასე მინიმალური ტოლია i.
უბრალოდ ვამბობ, რომ ამ შემთხვევაში ინდექსის ჩვენი მინიმალური ღირებულება.
ასე შემდეგ ის აპირებს iterate მეშვეობით და მიდის j ტოლია i პლუს 1.
ასე რომ, ჩვენ უკვე ვიცით, რომ ეს არის ჩვენი პირველი ელემენტს.
ჩვენ არ უნდა შევადაროთ ის, რომ თავად.
ასე რომ, ჩვენ ვიწყებთ შედარებით მას შემდეგი ერთ-ერთი რის გამოც ის i პლუს 1 ო
მინუს 1, რომელიც არის ბოლოს მასივი არსებობს.
ჩვენ ვუთხარით, თუ მასივი კ ნაკლებია, ვიდრე მასივი წთ,
მაშინ ჩვენ reassign სადაც ჩვენი მინიმალური მაჩვენებლების.
>> და თუ min არ არის ტოლი i, როგორც იქ, სადაც ვიყავით აქ.
ისე მომწონს, როდესაც ჩვენ პირველად ეს ერთი.
ამ შემთხვევაში, ეს იქნებოდა იწყება ნულოვანი, ეს რომ დასრულდება მდე მიმდინარეობს ორი.
ასე min რომ არ თანაბარი i ბოლომდე.
რომელიც საშუალებას გვაძლევს ვიცით, რომ ჩვენ უნდა სვოპ მათ.
ვგრძნობ, როგორიცაა კონკრეტული მაგალითი დაეხმარება ბევრად უფრო, ვიდრე ეს.
ასე რომ, მე კოდექსს up თქვენ ბიჭები ახლა და მე ვფიქრობ, რომ უკეთესი იქნება.
>> სახის ტენდენცია მუშაობა, რომ გზა, რომელიც ეს ხშირად უკეთესი მხოლოდ ვხედავთ.
ამიტომ, რაც ჩვენ გვსურს რომ არის ჩვენ გვინდა პირველი პატარა
ელემენტი თავისი პოზიცია მასივში.
ზუსტად ის, რაც იაკობ ამბობდა.
თქვენ უნდა შეინახოთ, რომ როგორმე.
ასე რომ, ჩვენ ვაპირებთ დავიწყოთ აქ iterating მეტი მასივი.
ჩვენ ვაპირებთ, რომ ვთქვა, რომ ეს ჩვენი პირველი უბრალოდ უნდა დაიწყოს.
ასე რომ, ჩვენ ვაპირებთ აქვს int პატარა ტოლია მასივი i.
>> ასე რომ ერთი რამ შეამჩნია, ყველა დროის ამ მარყუჟის გაუშვებს,
ჩვენ ვიწყებთ ერთი ნაბიჯით შემდგომი ერთად.
როდესაც ჩვენ ვიწყებთ ჩვენ შევხედოთ ეს.
შემდეგი დროს ჩვენ iterate მეშვეობით, ჩვენ ვიწყებთ ამ ერთი
და იმის, რომ ჩვენი პატარა ღირებულება.
ასე რომ, ეს ძალიან ჰგავს bubble sort სადაც ჩვენ ვიცით, რომ მას შემდეგ, რაც ერთ უღელტეხილზე,
ეს ბოლო ელემენტს დახარისხებული.
შერჩევა ერთგვარი, ეს პირიქით.
>> ყველა უღელტეხილზე, ჩვენ ვიცით, რომ პირველი დალაგებულია.
მეორე უღელტეხილზე, მეორე იქნება დახარისხებული.
და როგორც თქვენ ნახეთ, რომ slide მაგალითები, ჩვენი დახარისხებული ნაწილი მხოლოდ იზრდება.
ასე მიიღწევა ჩვენი პატარა ერთი მასივების i, ყველა ის აკეთებს
არის მშენებლობის რა ჩვენ შევხედავთ ისე,
რაოდენობის შემცირების შედარება მოგვცემს.
ამჯამად რომ აზრი ყველას?
გჭირდებათ მე აწარმოებს მეშვეობით, რომ ისევ ნელი ან სხვადასხვა სიტყვა?
მოხარული ვარ, რომ.
OK.
>> ასე რომ, ჩვენ შენახვის არც ამ ეტაპზე,
მაგრამ ჩვენ ასევე გვინდა შესანახად ინდექსი.
ამიტომ, ჩვენ ვაპირებთ შესანახად პოზიცია პატარა
ერთი, რომელიც მხოლოდ იქნება i.
ასე რომ, ახლა Jacob კმაყოფილია.
ჩვენ გვყავს რამ ინახება.
და ახლა ჩვენ უნდა გაეცნონ არასორტირებული ნაწილი მასივი.
ასე რომ ამ შემთხვევაში ეს იქნება ჩვენი არასორტირებული.
ეს არის მე.
OK.
>> ამიტომ, რაც ჩვენ ვაპირებთ, რომ გავაკეთოთ იქნება ციკლი.
როდესაც თქვენ უნდა iterate მეშვეობით მასივი,
თქვენი აზრით, შეიძლება წავიდეს ამისთვის loop.
ასე რომ ზოგიერთი int k შეადგენს რას ვფიქრობთ
k აპირებს თანაბარი უნდა დაიწყოს?
ეს არის ის, რაც ჩვენ მითითებული, როგორც ჩვენი პატარა ღირებულება და ჩვენ გვინდა, რომ შეადაროთ იგი.
რა გვინდა შეადაროთ იგი?
ეს იქნება ეს ერთი, არა?
ასე რომ ჩვენ გვინდა k ინიციალიზაცია რომ მე პლუს 1 დასაწყებად.
>> და ჩვენ გვინდა k ამ შემთხვევაში ჩვენ უკვე ზომა ინახება აქ,
ასე რომ, ჩვენ უბრალოდ გამოიყენოთ ზომა.
ზომა მყოფი ზომა მასივი.
და ჩვენ უბრალოდ გვინდა განახლება k თითო დროს.
ზემოთ.
ასე რომ, ახლა ჩვენ გვჭირდება, ყველაზე პატარა ელემენტი აქ.
ასე რომ, თუ ჩვენ iterate მეშვეობით, ჩვენ მინდა ვთქვა, რომ, თუ მასივი k
ნაკლებია, ვიდრე ჩვენი პატარა ღირებულება ეს არის, სადაც ჩვენ, ფაქტობრივად,
შენახვა ტრეკზე რა პატარა აქ
მაშინ ჩვენ გვინდა reassign რა არის ჩვენი პატარა ღირებულება.
>> ეს ნიშნავს, რომ, მე, ჩვენ iterating მეშვეობით აქ.
როგორიც არ უნდა იყოს არც აქ არის არა ჩვენი პატარა რამ.
ჩვენ არ გვინდა ეს.
ჩვენ გვინდა, რომ reassign ის.
ასე რომ, თუ ჩვენ reassigning ეს, რა როგორ ფიქრობთ, შეიძლება იყოს ეს კოდი აქ?
ჩვენ გვინდა, რომ reassign პატარა და პოზიცია.
რა არის ყველაზე პატარა ახლა?
სტუდენტი: Array k.
ინსტრუქტორი: Array k.
და რა პოზიცია არის?
რა არის ინდექსები ჩვენი პატარა მნიშვნელობა?
უბრალოდ k.
ამიტომ მასივი K, K, ისინი შეესაბამება.
ამიტომ გვინდოდა reassign რომ.
მას შემდეგ, რაც ჩვენ ვნახეთ ჩვენი პატარა, ასე დასასრულს ამ for loop
აქ ჩვენ ვიპოვეთ ის, რასაც ჩვენი პატარა არც, ამიტომ ჩვენ მხოლოდ სვოპ ის.
ამ შემთხვევაში, როგორც ამბობენ, ჩვენი პატარა არც აქ.
ეს არის ჩვენი პატარა ღირებულება.
>> ჩვენ უბრალოდ გვინდა, რომ სვოპ ის, რაც არის რა, რომ swap ფუნქციის ბოლოში
გააკეთა, რომელსაც ჩვენ უბრალოდ დაწერა up ერთად რამდენიმე წუთის წინ.
ასე რომ უნდა გამოიყურებოდეს ნაცნობი.
და მაშინ უბრალოდ iterate მეშვეობით, სანამ ის აღწევს ყველა გზა
და ბოლოს, რაც იმას ნიშნავს, რომ თქვენ ნულოვანი ელემენტები, რომლებიც დაუხარისხებელი
და ყველაფერი უკვე დახარისხებული.
აზრი?
უფრო კონკრეტულად?
კოდი დახმარება?
>> სტუდენტი: For ზომა, თქვენ არასდროს ნამდვილად განსაზღვრავს მის შეცვლას ან,
რამდენად შეესაბამება ეს იცით?
>> ინსტრუქტორი: ასე რომ, ერთი რამ შეამჩნია აქ არის int ზომა.
ასე რომ, ჩვენ ვამბობთ, რომ ამ დალაგება სახის ფუნქცია ამ შემთხვევაში ეს
შერჩევის დალაგების, ის გავიდა ერთად ფუნქცია.
ასე რომ, თუ არ გავიდა in, თქვენ რაღაც
ისევე, როგორც სიგრძეზე მასივი ან თქვენ iterate მეშვეობით
იპოვოს სიგრძეზე.
არამედ იმიტომ, რომ ის გავიდა in, ჩვენ უბრალოდ გამოიყენოს იგი.
უბრალოდ ვივარაუდოთ, რომ მომხმარებლის მისცა თქვენ სწორი ზომა, რომელიც
რეალურად წარმოადგენს ზომა თქვენი მასივი.
მაგარი?
>> თუ თქვენ ბიჭები გაქვთ რაიმე პრობლემები ამ ან სურს მეტი პრაქტიკა კოდირების სახის
საკუთარ, თქვენ უნდა წასვლა study.cs50.
ეს ინსტრუმენტი.
მათ აქვთ შემოწმება რომ თქვენ შეგიძლიათ რეალურად დაწეროს.
მათ ამის pseudocode.
მათ აქვთ მეტი ვიდეო და სლაიდები მათ შორის, აქ გამოყენებული.
ასე რომ, თუ თქვენ ჯერ კიდევ შეგრძნება ცოტა საეჭვო, ცდილობენ რომ.
როგორც ყოველთვის, მოვა გაიგო ჩემთვის, ძალიან.
კითხვა?
>> სტუდენტი: თქვენ ამბობთ, ზომა წინასწარ განსაზღვრული?
ინსტრუქტორი: დიახ.
ზომა ადრე განისაზღვრა აქ ფუნქცია დეკლარაცია.
ასე რომ თქვენ ვივარაუდოთ, რომ ის უკვე გავიდა მომხმარებლის მიერ, და სიმარტივის გულისთვის,
ჩვენ ვაპირებთ, რომ ვივარაუდოთ, რომ მომხმარებლის მოგვცა სწორი ზომა.
ზემოთ.
ისე, რომ შერჩევა ერთგვარი.
ბიჭები, მე ვიცი, ჩვენ სწავლის ბევრი გააკეთა.
ეს მკვრივი მონაცემები მონაკვეთზე.
ასე რომ, ჩვენ ვაპირებთ წასვლა Insertion ჯიშია.
>> OK.
ასე რომ სანამ ჩვენ უნდა გავაკეთოთ ჩვენი runtime ანალიზი აქ.
ასე რომ, საუკეთესო შემთხვევაში, მინიჭებული, რაც მე გაჩვენეთ
მაგიდასთან მე უკვე სახის მისცა ის დაშორებით.
მაგრამ საუკეთესო შემთხვევაში runtime, რას ფიქრობთ?
ყველაფერი დალაგებულია.
N კვადრატში.
ვინმეს აქვს ახსნა რატომ ფიქრობთ?
>> სტუდენტი: თქვენ შედარებით through--
ინსტრუქტორი: Right.
თქვენ შედარებით მეშვეობით.
ყოველ iteration, მიუხედავად იმისა, ჩვენ decrementing ეს ერთი,
თქვენ ჯერ კიდევ ეძებს მეშვეობით იმისათვის, რომ იპოვოს ყველაზე პატარა ერთი.
ისე კი, თუ თქვენი მცირე ღირებულების აქ არის დასაწყისში,
თქვენ ჯერ კიდევ შედარებით წინააღმდეგ ყველაფერი
დარწმუნდით, რომ იგი არის ყველაზე პატარა რამ.
ასე რომ თქვენ დასრულდება მდე გადის დაახლოებით n კვადრატში ჯერ.
ყველა უფლება.
და, რაც ყველაზე ცუდ შემთხვევაში?
ასევე n კვადრატში, რადგან თქვენ უნდა აკეთებს, რომ იგივე პროცედურა.
ასე რომ, ამ შემთხვევაში, შერჩევა დალაგების აქვს რაღაც
ჩვენ ასევე მოვუწოდებთ ელოდებიან runtime.
ასე რომ, სხვა, ჩვენ უბრალოდ ვიცით, ზედა და ქვედა საზღვრები.
დამოკიდებული, თუ რამდენად გიჟები ჩვენი სია არის ან როგორ დაუხარისხებელი ის არის,
ისინი განსხვავდება შორის n ან N კვადრატში.
ჩვენ არ ვიცით.
>> არამედ იმიტომ, რომ შერჩევის დალაგების აქვს იგივე ყველაზე ცუდი და საუკეთესო შემთხვევაში, რომ გვეუბნება, რომ
არ აქვს მნიშვნელობა, თუ რა ტიპის შეყვანის ჩვენ აქვს, თუ არა ის მთლიანად
დახარისხებული ან მთლიანად გადახედოს დახარისხებული, ეს
აპირებს იმავე დროის.
ასე რომ, ამ შემთხვევაში, თუ გვახსოვდეს ჩვენი მაგიდა,
ეს რეალურად ჰქონდა მნიშვნელობა, რომ ეს ორი სახის არ აქვს,
რომელიც სავარაუდოდ runtime.
ჩვენ ვიცით, რომ, როდესაც ჩვენ აწარმოებს შერჩევის დალაგების,
გარანტირებული აწარმოებს n კვადრატში დრო.
არ არის ცვალებადობა არსებობს.
ეს მხოლოდ მოსალოდნელია.
და, კიდევ ერთხელ, თუ გსურთ ისწავლოს მეტი, მიიღოს CS 124 გაზაფხულზე.
ყველა უფლება.
ჩვენ ვნახეთ ამ ერთი.
ზემოთ.
ამიტომ Insertion დალაგების.
და მე ალბათ აპირებს მოვნახოთ მეშვეობით.
მე არ მაქვს, რომ თქვენ ბიჭები კოდი იგი.
ჩვენ მხოლოდ ფეხით მეშვეობით.
ამიტომ Insertion დალაგების სახის მსგავსი შერჩევის დალაგების
რომ ჩვენ გვაქვს როგორც ქალაქის დაუხარისხებელი და დახარისხებული ნაწილი მასივი.
>> მაგრამ რა არის სხვადასხვა არის, რომ როგორც ჩვენ გაიაროს ერთი,
ჩვენ უბრალოდ უნდა ნომერზე არის შემდეგი ჩვენი არასორტირებული,
და სწორად დასალაგებლად ეს ჩვენს დახარისხებული მასივი.
ეს კიდე უფრო გრძნობა მაგალითი.
ასე რომ, ყველაფერი იწყება, როგორც ქალაქის დაუხარისხებელი, უბრალოდ მინდა შერჩევა ერთგვარი.
და ჩვენ ვაპირებთ დასალაგებლად ეს აღმავალი შეკვეთა, როგორც ჩვენ.
ასე რომ, ჩვენი პირველი პასს ჩვენ ვიღებთ პირველი ღირებულება,
და ვამბობთ, OK, თქვენ ახლა სიაში თავს.
>> იმიტომ, რომ თქვენ სიაში საკუთარ თავს, თქვენ გადანაწილებული.
გილოცავთ, რომ პირველ ელემენტს ამ მასივი.
თქვენ უკვე დახარისხებული ყველა საკუთარი.
ახლა ჩვენ დახარისხებული და დაუხარისხებელი მასივი.
ასე რომ, ახლა ჩვენ მიიღოს პირველი.
რა ხდება შორის აქ და აქ არის ის, რომ ვთქვათ,
OK, ჩვენ ვაპირებთ შევხედოთ პირველი ღირებულება ჩვენი დაუხარისხებელი მასივი
და ჩვენ ვაპირებთ input ის თავის სწორი ადგილი დახარისხებული მასივი.
>> რასაც ჩვენ ვაკეთებთ არის ჩვენ ვიღებთ 5 და ჩვენ ვამბობთ, OK, 5 მეტია 3,
ასე რომ, ჩვენ უბრალოდ ჩადეთ ეს უფლება მარჯვნივ რომ.
ჩვენ კარგი.
ასე რომ მაშინ ჩვენ წავიდეთ ჩვენი მომდევნო ერთი.
და ჩვენ 2.
ჩვენ ვამბობთ, OK, 2 ნაკლებია, 3-ზე, ასე რომ ჩვენ ვიცით, რომ ეს
უნდა იყოს წინა ჩვენს სიაში არის.
რასაც ჩვენ ვაკეთებთ არის ჩვენ დააყენებს 3 და 5 ქვემოთ და ჩვენ გადაადგილება 2 შევიდა, რომ პირველი სლოტი.
ასე რომ ჩვენ უბრალოდ ჩასმა იგი სწორი ადგილი უნდა იყოს.
>> მაშინ ჩვენ ჩვენს შემდეგი ერთი, და ვამბობთ 6.
OK, 6 მეტია, ვიდრე ყველაფერი ჩვენი დახარისხებული მასივი,
ასე რომ ჩვენ უბრალოდ მონიშნო იგი ბოლომდე.
და მაშინ ჩვენ შევხედოთ 4.
4 არანაკლებ 6, ეს ნაკლებად 5-ზე, მაგრამ ეს უფრო მეტია, ვიდრე 3.
ასე რომ, ჩვენ უბრალოდ ჩადეთ ის მარჯვენა შუა შორის 3 და 5.
ასე, რომ, რომ ცოტა ცოტა უფრო კონკრეტული,
აქ არის ერთგვარი იდეა რა მოხდა.
ამიტომ თითოეული არასორტირებული ელემენტს, ჩვენ განსაზღვრავს, სადაც დახარისხებული ნაწილი
ეს არის.
>> ასე შენახვა გათვალისწინებით დახარისხებული და დაუხარისხებელი,
ჩვენ უნდა traverse მეშვეობით და ფიგურა სად ჯდება დახარისხებული მასივი.
და ჩვენ ჩადეთ იგი გადავიდა ელემენტები მარჯვნივ მას.
და შემდეგ ჩვენ უბრალოდ შეინახოს iterating მეშვეობით, სანამ ჩვენ
სრულიად დახარისხებული სია სადაც დაუხარისხებელი არის ნულოვანი
და დახარისხებული იკავებს მთლიანად ჩვენს სიაში.
ასე რომ, კიდევ ერთხელ, იმისათვის, რომ კიდევ უფრო კონკრეტული, ჩვენ pseudocode.
>> ასე ძირითადად მე 0-ის ტოლი ო მინუს 1,
ეს მხოლოდ ხანგრძლივობა ჩვენი მასივი.
ჩვენ გვაქვს გარკვეული ელემენტი, რომელიც უდრის პირველ მასივი ან პირველი მაჩვენებლები.
ჩვენ დავსახეთ j ტოლი რომ.
ასე რომ, ხოლო j მეტია, ვიდრე ნულოვანი და მასივი, კ -1
მეტია ელემენტი, ასე რომ ყველა რომ აკეთებს
მიღების დარწმუნებული ვარ, რომ თქვენი j ნამდვილად წარმოადგენს
არასორტირებული ნაწილი მასივი.
>> ასე რომ, როდესაც ჯერ კიდევ არსებობს რამ დასალაგებლად და j მინუს ერთი არის ის, რაც
ელემენტს მისი?
J არ იყო განსაზღვრული აქ.
ეს ერთგვარი შემაშფოთებელი.
OK.
მაინც.
ასე კ მინუს 1, თქვენ შემოწმების ელემენტს, ვიდრე ის.
თქვენ ვამბობთ, არის ელემენტი ადრე იქ, სადაც მე am-- მოდით
რეალურად მიაპყროს ამ out.
ასე ვთქვათ, ეს არის როგორიცაა ჩვენი მეორე უღელტეხილზე.
ასე რომ მე იქნება ტოლი 1, რაც აქ არის.
>> ასე რომ იქნება ტოლი 1.
ეს იქნება 2, 4, 5, 6, 7.
ყველა უფლება.
ასე რომ, ჩვენი ელემენტს ამ შემთხვევაში აპირებს იყოს 4.
და ჩვენ გვაქვს j, რომ ის, იქნება ტოლი 1.
Oh, j არის decrementing.
ეს არის ის, რაც არის.
ასე j ტოლია i, ასე რომ, რა არის ეს არის ის, რომ, როგორც ჩვენ წინსვლა,
ჩვენ უბრალოდ მიღების დარწმუნებული ვარ, რომ ჩვენ არ დასრულებულა
ინდექსირებას ამ გზით, როდესაც ჩვენ ვცდილობთ, ჩადეთ რამ ჩვენს დახარისხებული სია.
>> ასე რომ, როდესაც j ტოლია 1 ამ შემთხვევაში და array j მინუს one-- ასე მასივი j მინუს 1
2 ამ შემთხვევაში, თუ ეს მეტი ელემენტია,
მაშინ ყველა ამ აკეთებს გადასვლის რამ down.
ასე რომ, ამ შემთხვევაში, array j მინუს ერთი იქნება array ნულოვანი, რომელიც არის 2.
2 არ აღემატება 4, ასე რომ ეს არ შეასრულოს.
ასე ცვლა არ გადავა ქვემოთ.
რა ეს იმას აქ მხოლოდ მოძრავი დახარისხებული მასივი ქვემოთ.
ამ შემთხვევაში, ფაქტობრივად, ჩვენ ვერ გააკეთებდა მოდით ეს 3.
ასე რომ, თუ ჩვენ ფეხით მეშვეობით ამ მაგალითად, ჩვენ ახლა აქ.
ეს დახარისხებული.
ეს არის დაუხარისხებელი.
მაგარი?
ამიტომ უდრის 2, ჩვენი ელემენტს უდრის 3.
და ჩვენი j = 2.
ასე რომ, ჩვენ გადავხედავთ და ჩვენ იტყვით, არის array j მინუს ერთი
მეტი ელემენტია ჩვენ ვეძებთ?
და პასუხი არის დიახ, არა?
4 მეტია 3 კ არის 2, ასე რომ ეს კოდი ახორციელებს.
>> ასე რომ, ახლა, რას ვაკეთებთ მასივი 2, ასე რომ სწორედ აქ, ჩვენ სვოპ მათ.
ასე რომ, ჩვენ, უბრალოდ, ვამბობთ, OK, მასივი at 2 ახლა იქნება 3.
კ აპირებს თანაბარი j მინუს 1, რომელიც არის 1.
რომ საშინელებაა, მაგრამ თქვენ ბიჭები იდეა.
J არის ტოლი 1.
და რიგი j უბრალოდ იქნება თანაბარი ჩვენი ელემენტს, რომელიც 4.
მე წაშლილია რაღაც მე არ უნდა აქვს ან miswrote რაღაც,
მაგრამ თქვენ ბიჭები იდეა.
>> ეს გადაადგილება n.
და მაშინ, თუ ეს იყო, რომ ის loop ისევ და რომ ვთქვა, OK, კ 1 ახლა.
და რიგი j მინუს 1 არის 2.
2 ნაკლებია, ვიდრე ჩვენი ელემენტს?
არა?
ეს ნიშნავს, რომ ჩვენ ჩასმული ამ ელემენტის
სწორი ადგილზე ჩვენს დახარისხებული მასივი.
მაშინ ჩვენ შეგვიძლია ეს და ვთქვათ, OK, ჩვენს დახარისხებული მასივი აქ.
და ეს იქნება ამ რაოდენობის 6 და როგორიცაა, OK, 6 ნაკლებად, ვიდრე ეს რიცხვი?
არა?
ზემოთ.
ჩვენ ჯარიმა.
>> ამას კიდევ ერთხელ.
ჩვენ ვამბობთ, 7.
7-ზე ნაკლები ბოლოს ჩვენი დახარისხებული მასივი?
პოსტები
ასე რომ, ჩვენ ჯარიმა.
ასე რომ, ეს იქნება დახარისხებული.
ძირითადად ყველა ამ აკეთებს ის ამბობდა მიიღოს
პირველი ელემენტი თქვენი დაუხარისხებელი მასივი,
გაერკვნენ, სადაც ის მიდის თქვენი დახარისხებული მასივი.
და ეს მხოლოდ ზრუნავს გაცვლებს უნდა გავაკეთოთ, რომ.
თქვენ ძირითადად უბრალოდ შევცვალე სანამ ეს უფლება ადგილზე.
ვიზუალური იმიჯი, რომ თქვენ მოძრავი ყველაფერი, აკეთებს, რომ.
>> ასე რომ, ეს ნახევარი bubble sort მაგვარი.
შეამოწმეთ შესწავლა 50.
უაღრესად რეკომენდაციას ცდილობს კოდექსის ეს საკუთარი.
თუ თქვენ გაქვთ რაიმე საკითხები და გსურთ ნახეთ ნიმუში კოდი Insertion დალაგების,
გთხოვთ ნება მომეცით ვიცი.
მე ყოველთვის გარშემო.
ასე უარეს შემთხვევაში runtime და საუკეთესო შემთხვევაში runtime.
როგორც თქვენ ბიჭი დაინახა, მაგიდასთან მე უკვე აჩვენა, თუ, ის, როგორც n კვადრატში და N.
>> ასე რომ, ასეთი აპირებს off რაც ჩვენ ვისაუბრეთ შესახებ ჩვენი წინა ჯიშები, ყველაზე ცუდი
საქმე runtime, რომ თუ ის მთლიანად არასორტირებული,
ჩვენ უნდა შეადაროთ ყველა ამ N ჯერ.
ჩვენ ამას ვაკეთებთ, მთელი ბევრი შედარება იმიტომ, რომ თუ ის საპირისპირო მიზნით,
ჩვენ ვაპირებთ, რომ იტყვით, ამ იგივე, ეს არის კარგი,
და ეს ერთი უნდა იყოს შედარებით წინააღმდეგ პირველი გადავიდა უკან.
და რადგან ჩვენ მიმართ კუდი ბოლომდე, ჩვენ უნდა
შედარების, შედარების და შედარება წინააღმდეგ ყველაფერი.
>> ასე რომ, ეს დამთავრდა დაახლოებით n კვადრატში.
თუ ეს სწორია, მაშინ თქვენ იტყვით, 2, თქვენ კარგი.
3, თქვენ შედარებით 2.
თქვენ კარგად.
4 ადარებთ კუდი.
თქვენ კარგად.
6 შედარება კუდი, თქვენ ჯარიმა.
ასე რომ ყველა ადგილზე, თუ ეს უკვე დალაგებულია, თქვენ მიღების ერთი შედარებით.
ისე უბრალოდ n.
და რადგან ჩვენ გვაქვს საუკეთესო შემთხვევაში runtime N და უარეს შემთხვევაში runtime ო
კვადრატში, ჩვენ არ გვაქვს ელოდებიან runtime.
>> ეს უბრალოდ დამოკიდებულია ქაოსი ჩვენს სიაში.
და ისევ, სხვა დიაგრამა და სხვა მაგიდასთან.
ასე განსხვავებები სახის.
მე უბრალოდ აპირებს ნიავი მეშვეობით, I გრძნობს, როგორც ჩვენ ვისაუბრეთ ვრცლად
შესახებ, თუ როგორ ყველა სახის of იცვლება და გაეზიარებინათ.
ასე რომ შერწყმა დალაგების არის ბოლო მე შეგაწყენთ ბიჭები.
ჩვენ გვაქვს საკმაოდ ფერადი სურათი.
ასე რომ შერწყმა დალაგების არის რეკურსიული ალგორითმი.
ასე რომ თქვენ ბიჭები ვიცი, რა რეკურსიული ფუნქცია?
>> არავის მინდა ვთქვა?
გსურთ ცდილობენ?
ასე რომ რეკურსიული ფუნქცია მხოლოდ ფუნქცია, რომელიც მოუწოდებს თავად.
ასე რომ, თუ ბიჭები არიან იცნობს ერთად Fibonacci თანმიმდევრობა,
რომ ითვლება რეკურსიული რადგანაც თქვენ მიიღოს წინა ორი
და დაამატოთ ისინი ერთად მიიღოს თქვენი მომავალი ერთი.
ასე რეკურსიული, მე ყოველთვის ვფიქრობ, უკან როგორც მოსწონს spiral
ასე რომ თქვენ, როგორც სპირალის ქვემოთ შევიდა.
მაგრამ ეს მხოლოდ ფუნქცია რომელიც მოუწოდებს თავად.
>> და, ფაქტობრივად, მართლაც სწრაფად I შეგიძლიათ ნახოთ თუ რა, რომ ჰგავს.
ასე რეკურსიული აქ, თუ დავაკვირდებით, ეს არის რეკურსიული გზა ჯამი მასივი.
ამიტომ ყველა, რომ ჩვენ ვაკეთებთ არის ჩვენ გვაქვს თანხა ფუნქცია
თანხა, რომელიც იღებს და ზომის მასივი.
და თუ თქვენ შეამჩნევთ, ზომა decrements თითო დროს.
და ყველა ის არ არის, თუ x უდრის ნულოვანი ასე რომ, თუ ზომა მასივი
უდრის ნულოვანი ბრუნდება ნულოვანი.
>> წინააღმდეგ შემთხვევაში, ეს თანხები ამ ბოლო ელემენტს მასივი,
და შემდეგ იღებს თანხა დანარჩენი მასივი.
ასე რომ, ეს მხოლოდ არღვევს მას ქვემოთ პატარა და მცირე პრობლემები.
მოკლედ, უკან, ფუნქცია, რომელიც მოუწოდებს თავად.
თუ ეს ყველაფერი თქვენ გაქვთ ამ, ის, რაც რეკურსიული ფუნქცია.
თუ თქვენ მიიღოს 51, თქვენ ძალიან, ძალიან კომფორტულად უკან.
ეს მართლაც მაგარი.
ეს გააკეთა გრძნობა, როგორიცაა 3 AM ერთი ღამით გარეთ.
და მე, რატომ მე არ გამოიყენოს ეს?
>> ასე რომ შერწყმა დალაგების, ძირითადად, რასაც ის აპირებს არის ის
აპირებს დაარღვიოს მისი დანგრევა და შესვენება ქვემოთ, სანამ ის უბრალოდ ერთი ელემენტებს.
ერთი ელემენტები ადვილად დასალაგებლად.
ჩვენ ამას ვხედავთ.
თუ თქვენ გაქვთ ერთი ელემენტი, ის უკვე განიხილება დახარისხებული.
ასე ცვლადი n ელემენტებს, თუ n ნაკლებია, ვიდრე 2,
უბრალოდ დაბრუნებას, რადგან ეს ნიშნავს, რომ ის ან 0 ან 1, რაც ჩვენ ვნახეთ.
იმ ითვლება დახარისხებული ელემენტები.
>> სხვაგვარად დაარღვიოს ის ნახევარი.
სორტირება პირველ ნახევარში, დასალაგებლად მეორე ნახევარი და შემდეგ შერწყმა მათ ერთად.
ამიტომ ე.წ. შერწყმა ჯიშია.
ამიტომ აქ ჩვენ დასალაგებლად ამ.
ამიტომ, ჩვენ შევინარჩუნოთ, რომელსაც მათ სანამ მასივი ზომა არის 1.
ასე რომ, როდესაც ის 1, უბრალოდ, დაბრუნდნენ რადგან ეს არის დახარისხებული მასივი,
და ეს არის დახარისხებული მასივი, და ეს დახარისხებული მასივი, ჩვენ ყველა დახარისხებული.
ასე რომ, მაშინ, თუ რას ვაკეთებთ ჩვენ დაიწყოს შერწყმის მათი ერთად.
>> ასე რომ გზა შეგიძლიათ ვიფიქროთ შერწყმა
უბრალოდ ამოიღონ პატარა ნომერი, თითოეული ქვე კოლექტორები
და უბრალოდ დამატება რომ ეს გაჩნდა მასივი.
ასე რომ, თუ გადავხედავთ აქ, როდესაც ჩვენ ამ კომპლექტი ჩვენ გვაქვს 4, 6, და 1.
როდესაც ჩვენ გვინდა შერწყმა ამ, ჩვენ შევხედოთ პირველი ორი
და ვამბობთ, OK, 1 არის პატარა, ის მიდის წინ.
4 და 6, არაფერი შედარება მას, უბრალოდ მონიშნო იგი ბოლომდე.
>> როდესაც ჩვენ დააკავშიროთ ამ ორი, ჩვენ უბრალოდ მიიღოს პატარა ერთი ამ ორი,
ასე რომ 1.
და ახლა ჩვენ ვიღებთ პატარა ამ ორი, ასე რომ 2.
პატარა ამ ორი, 3.
პატარა ამ ორი, 4, 5, 6.
ასე რომ თქვენ მხოლოდ უბიძგებენ off ეს.
და რადგან ისინი დახარისხებული ადრე,
მხოლოდ ერთი შედარებით ყოველ ჯერზე არსებობს.
ასე რომ, მეტი კოდი აქ, უბრალოდ წარმომადგენლობა.
ასე რომ თქვენ დაიწყოს შუა და თქვენ სახის მარცხენა და მარჯვენა
და მაშინ მხოლოდ შერწყმა ამ.
>> და ჩვენ არ გვაქვს კოდი შერწყმა უფლება აქ.
მაგრამ, კიდევ ერთხელ, თუ რა შესწავლა 50, ეს იქნება იქ.
წინააღმდეგ შემთხვევაში, მოვიდა გაიგო ჩემთვის თუ თქვენ ჯერ კიდევ დაბნეული.
ისე მაგარი ისაა, რომ საუკეთესო შემთხვევაში, უარეს შემთხვევაში, და მოსალოდნელი runtime
ყველანი შესვლა N, რომელიც გაცილებით უკეთესია, ვიდრე ჩვენ
ჩანს, რომ ჩვენი დანარჩენი სახის.
ჩვენ ვნახეთ n კვადრატში და რაც ჩვენ რეალურად
კიდევ აქ არის N შესვლა N, რაც საკმაოდ დიდი.
>> შეხედეთ, თუ რამდენად უკეთესი რომ არის.
ასეთი ლამაზი მრუდი.
ასე ბევრად უფრო ეფექტური.
თუ თქვენ ოდესმე შეუძლია, გამოიყენოს შერწყმა ჯიშია.
ეს დაზოგავს თქვენს დროს.
შემდეგ კვლავ, როგორც ვთქვით, თუ თქვენ ქვემოთ ამ ქვედა რეგიონში,
ეს არ გააკეთოს, რომ დიდი სხვაობა.
თქვენ მდე ათასობით და ათასობით საშუალებებით,
თქვენ აუცილებლად მინდა უფრო ეფექტური ალგორითმი.
და, კიდევ ერთხელ, ჩვენი ლამაზი მაგიდა ყველა სახის რომ თქვენ ბიჭები შეიტყო დღეს.
>> მე ვიცი, რომ ეს იყო მკვრივი ყოველდღე.
ეს არ არის აუცილებლად აპირებს დაგეხმაროთ თქვენი pset.
მაგრამ მე მინდა, რომ პასუხისმგებლობის რომ სექციაში არ არის მხოლოდ psets.
ყველა ეს მასალა არის სამართლიანი თამაში თქვენი შუალედური.
ასევე, თუ თქვენ ამის გაკეთება გაგრძელდება CS, ეს მართლაც მნიშვნელოვანი საფუძვლები
, რომ თქვენ უნდა იცოდეთ.
ასე რომ ზოგიერთი დღე იქნება უფრო pset დახმარება,
მაგრამ რამდენიმე კვირის იქნება ბევრად უფრო რეალური შინაარსი
რომ არ ჩანს super სასარგებლო ახლა,
მაგრამ გპირდებით თუ გაგრძელდება on იქნება ძალიან, ძალიან სასარგებლო.
>> ასე რომ ის მონაკვეთზე.
ქვემოთ მავთულები.
მე ეს ერთი წუთით.
მაგრამ თქვენ გადასვლა.
და მე donuts ან Candy.
არის ვინმე ალერგიული არაფერი, სხვათა შორის?
კვერცხი და რძე.
ასე donuts არიან არა?
OK.
ყველა უფლება.
შოკოლადი არ?
Starburst.
Starbursts კარგი.
OK.
ჩვენ ვაპირებთ აქვს Starburst მომავალ კვირას შემდეგ.
რომ ის, რაც მე კიდევ.
თქვენ ბიჭები გაქვთ დიდი კვირას.
წავიკითხე თქვენი სპეც.
>> ნება მომეცით თუ თქვენ გაქვთ რაიმე შეკითხვები.
Pset ორი კლასის უნდა იყოს იმისათვის, რომ თქვენ ხუთშაბათს.
თუ თქვენ გაქვთ რაიმე შეკითხვები როგორ მე ფასდება რაღაც
ან რატომ მე ფასდება რაღაც გზა მე საერთოდ, გთხოვთ მომაწოდეთ, მოვა გაიგო ჩემთვის.
მე ცოტა გიჟები ეს კვირას, მაგრამ მე გპირდებით,
მე მაინც პასუხს 24 საათის განმავლობაში.
ამიტომ აქვს დიდი კვირას, ყველას.
წარმატებებს გისურვებთ თქვენს pset.