>> JASON HIRSCHHORN: მოგესალმებით ყველას სექცია შვიდი.
ჩვენ კვირაში შვიდი კურსი.
და ეს მომავალი ხუთშაბათი არის ჰელოუინი ასე ვარ
ჩაცმული up მსგავსი გოგრა.
მე ვერ წარმართონ მეტი და დააყენა ჩემი ფეხსაცმელი, ასე რომ რატომ ვარ
უბრალოდ ტარება წინდები.
მე ასევე არ აცვია არაფერს ქვეშ ამ, ასე რომ მე ვერ მიიღოს ეს off, თუ ეს
გადატანის თქვენ.
მე ბოდიშს წინასწარ რომ.
თქვენ არ უნდა წარმოვიდგინოთ რა ხდება.
მე ტარება მოკრივე.
ასე რომ, ეს ყველაფერი კარგი.
>> მაქვს აღარ ამბავი რატომ ვარ ჩაცმული, როგორც გოგრა, მაგრამ მე ვაპირებ
გადარჩენა, რომ მოგვიანებით ამ სექციაში იმიტომ, რომ მე მინდა დავიწყოთ.
ჩვენ ბევრი საინტერესო რამ წავიდეთ ამ კვირაში.
მათი უმეტესობა დაკავშირებულია უშუალოდ ამ კვირის პრობლემა კომპლექტი, misspellings.
ჩვენ ვაპირებთ იყოს აპირებს მეტი უკავშირდება სიები და hash მაგიდები
მთელი განყოფილება.
მე ზუსტად ამ სიაში ყოველ კვირას, სიაში რესურსების თქვენთვის, რათა დაგეხმაროთ
მასალა ამ კურსს.
იმ შემთხვევაში, თუ დაკარგვა თუ ეძებს ზოგიერთი დამატებითი ინფორმაციისთვის, შეამოწმეთ ერთი
ამ რესურსების.
>> ერთხელ, pset6 არის misspellings, ამ კვირის pset.
და ეს ასევე ხელს უწყობს თქვენ, და მე გარწმუნებთ, გამოიყენოს რაიმე სხვა
რესურსები სპეციალურად ამ pset.
კერძოდ, სამი მე ჩამოთვლილი up ეკრანზე -
GDB, რომელიც ჩვენ უკვე იცნობს და გამოყენებით, ხოლო ახლა,
იქნება ძალიან გამოსადეგი ამ კვირაში.
ასე რომ, მე დააყენა, რომ აქ.
მაგრამ როდესაც თქვენ მუშაობის C, თქვენ ყოველთვის უნდა იყოს გამოყენებით GDB to
გამართვის თქვენი პროგრამებს.
ამ კვირაში ასევე Valgrind.
ვინმემ იცის, რა Valgrind აკეთებს?
>> აუდიტორია: ეს ამოწმებს მეხსიერების ტბები?
>> JASON HIRSCHHORN: Valgrind ამოწმებს მეხსიერების გაჟონვის.
ასე რომ, თუ თქვენ malloc რაღაც თქვენს პროგრამა, თქვენ გეკითხებით მეხსიერება.
დასასრულს თქვენი პროგრამა, თქვენ უნდა დაწერა უფასოდ ყველაფერი თქვენ
malloced მისცეს მეხსიერების უკან.
თუ თქვენ არ წერენ უფასო დასასრულს და თქვენი პროგრამა მოდის იმ დასკვნამდე,
ყველაფერი ავტომატურად გათავისუფლდებიან.
და პატარა პროგრამებს, ეს არ არის, რომ დიდი გარიგება.
მაგრამ თუ თქვენ წერა აღარ გაშვებული პროგრამა, რომელიც არ დატოვა,
აუცილებლად, რამდენიმე წუთის ან რამდენიმე წამში, მაშინ მეხსიერების ტბები
შეიძლება გახდეს დიდი გარიგება.
>> ასე pset6, მოლოდინი არის ის, რომ თქვენ უნდა ნულოვანი მეხსიერების გაჟონვის ერთად
თქვენი პროგრამა.
შევამოწმოთ მეხსიერების გაჟონვის, აწარმოებს Valgrind და ეს მოგცემთ ზოგიერთი ლამაზი
გამომავალი გაქირავების იცით თუ არა თუ არა ყველაფერი უფასოდ.
ჩვენ პრაქტიკაში მას შემდეგ დღეს, იმედია.
>> საბოლოოდ, diff ბრძანება.
გამოიყენება რამე მსგავსი, რომ in pset5 ერთად peek ინსტრუმენტი.
დაშვებულია თქვენ შიგნიდან.
თქვენ ასევე გამოიყენება diff, ძალიან, პოსტი პრობლემა კომპლექტი სპეც.
მაგრამ საშუალებას გაძლევთ შედარება ორი ფაილი.
თქვენ ვერ შევადარებთ bitmap ფაილი და ინფორმაცია headers რომელიც პერსონალის გადაწყვეტა და
თქვენი გადაწყვეტა pset5 თუ თქვენ აირჩია გამოიყენოს იგი.
Diff საშუალებას მოგცემთ ამისათვის, ისევე.
შეგიძლიათ შეადაროთ სწორი პასუხი ამ კვირაში პრობლემა მითითებული თქვენი პასუხი
და თუ ეს ხაზები და ვხედავთ სადაც შეცდომები.
>> ასე რომ იმ სამი კარგი ინსტრუმენტი, რომელიც თქვენ უნდა გამოიყენოთ ამ კვირაში, და
აუცილებლად შეამოწმეთ თქვენი პროგრამა ამ სამი ინსტრუმენტები
ადრე გარდამტეხი ის სისტემაში
კვლავ, როგორც მე აღვნიშნე, ყოველ კვირას, თუ თქვენ გაქვთ რაიმე კავშირი ჩემთვის - როგორც
პოზიტიური და კონსტრუქციული -
მოგერიდებათ ხელმძღვანელს ნახვა ბოლოში ამ slide
და შეყვანის მას იქ.
მე ნამდვილად ვაფასებ ნებისმიერი და ყველა კავშირი.
და თუ თქვენ მომეცი კონკრეტული რამ, რომ მე შეუძლია გააუმჯობესოს ან რომ მე ვარ
აკეთებს კარგად, რომ გსურთ ჩემთვის გაგრძელდება, მე რომ გული და
ნამდვილად ცდილობენ მოუსმინოს თქვენი კავშირი.
ვერ დაგპირდებით, მე ვაპირებ ამის გაკეთებას ყველაფერი, თუმცა, როგორც ტარება
გოგრა კოსტუმი, ყოველ კვირას.
>> ამიტომ, ჩვენ ვაპირებთ გაატაროთ ნაყარი განყოფილებიანი, როგორც აღვნიშნე, ვსაუბრობთ
დაკავშირებული სიები და hash მაგიდები, რომელიც იქნება უშუალოდ გამოიყენება
პრობლემა მითითებული ამ კვირაში.
დაკავშირებული სიები ჩვენ წავიდეთ მეტი შედარებით სწრაფად, რადგან ჩვენ გაატარა სამართლიანი ცოტა
დრო დასრულდა ეს განყოფილება.
და ასე მივიღებთ სწორი შევიდა კოდირების პრობლემები დაკავშირებული სიები.
და შემდეგ დასასრულს ჩვენ ვსაუბრობთ hash მაგიდები და როგორ ვრცელდება ამ
კვირის პრობლემა კომპლექტი.
>> ვნახე ეს კოდი ადრე.
ეს არის struct, და ეს განსაზღვრავს რაღაც ახალი ჰქვია კვანძში.
და შიგნით კვანძის არსებობს მთელი რიცხვი აქ და იქ არის მომცეთ
სხვა კვანძის.
ჩვენ ვნახეთ ადრე.
ეს უკვე ახლოვდება რამდენიმე კვირაა.
იგი აერთიანებს მითითებას, რომელიც ჩვენ მუშაობა და structs, რომელიც საშუალებას
us დააკავშიროთ ორი სხვადასხვა ყველაფერი ერთ მონაცემები ტიპის.
>> არსებობს უამრავი ხდება ეკრანზე.
მაგრამ ყველა ეს უნდა იყოს შედარებით იცნობს თქვენ.
პირველი ხაზი, ჩვენ განაცხადოს ახალი კვანძში.
და შემდეგ შიგნით რომ ახალი კვანძის, მე მითითებული მთელი ამ კვანძის ერთი.
ჩვენ ვხედავთ მომდევნო ხაზი მე ვაკეთებ printf ბრძანება, მაგრამ მე grayed out
printf ბრძანება იმის გამო, რომ მართლაც მნიშვნელოვანი ნაწილი არის ამ ხაზის აქ -
new_node.n.
რას dot ნიშნავს?
>> აუდიტორია: გადადით კვანძის და შეაფასოს n ღირებულება მას.
>> JASON HIRSCHHORN: ეს სწორედ.
Dot ნიშნავს შედიხართ n ნაწილი ამ ახალი კვანძში.
ამ შემდეგი ხაზი იმას, თუ რა?
მაიკლ.
>> აუდიტორია: იგი ქმნის სხვა კვანძის რომ იქნება აღვნიშნო, რომ ახალი კვანძში.
>> JASON HIRSCHHORN: ასე რომ, ეს არ შექმნა ახალი კვანძში.
იგი ქმნის რა?
>> აუდიტორია: A მაჩვენებელი.
>> JASON HIRSCHHORN: A მომცეთ კვანძის, როგორც მიერ მითითებულ ამ კვანძის * აქ.
ასე რომ, ეს ქმნის მომცეთ კვანძში.
და რომელიც კვანძის ეს მიუთითებს to მაიკლ?
>> აუდიტორია: New კვანძის?
>> JASON HIRSCHHORN: New კვანძში.
და ეს მიუთითებს არსებობს, რადგან ჩვენ მოცემული ეს მისამართი ახალი კვანძში.
და ახლა ამ ხაზის ჩვენ ვხედავთ ორ სხვადასხვა გზები
გამოხატავს იგივე.
და მინდოდა აღვნიშნო, თუ როგორ შეიძლება ამ ორი რამ არის იგივე.
პირველი ხაზი, ჩვენ dereference მაჩვენებელი.
ასე რომ, ჩვენ წასვლა კვანძში.
სწორედ ამ star ნიშნავს.
ჩვენ ვნახეთ, რომ სანამ პოინტერები.
წასვლა რომ კვანძის.
ეს არის ის, ფრჩხილებში.
და შემდეგ გავლით dot ოპერატორი n ელემენტს რომ კვანძის.
>> ასე რომ აღების სინტაქსი ჩვენ ვნახეთ უფლება აქ და ახლა
გამოყენებით იგი მაჩვენებელი.
რა თქმა უნდა, იგი იღებს სახის დაკავებული თუ თქვენ წერა იმ ფრჩხილებში -
რომ ვარსკვლავი და რომ dot.
იგი იღებს პატარა დაკავებულია.
ასე რომ, ჩვენ გვაქვს გარკვეული სინტაქსური შაქარი.
და ეს ხაზი სწორედ აქ -
ptr_node> n.
რომ აკეთებს იგივე ზუსტი რამ.
ასე რომ, ეს ორი ხაზი კოდი არის ექვივალენტს და ყველაფერს გავაკეთებთ
ზუსტად იგივე რამ.
>> მაგრამ მინდოდა აღვნიშნო იმ წინაშე ჩვენ წავიდეთ რაიმე ისე გესმით
რომ ნამდვილად ეს რამ სწორედ აქ არის მხოლოდ სინტაქსური შაქარი განთავსების dereferencing
მაჩვენებელი და შემდეგ აპირებს n ნაწილი რომ struct.
რაიმე შეკითხვები ამ slide?
OK.
>> ამიტომ, ჩვენ ვაპირებთ გავლა რამდენიმე ოპერაციების, რომ შეგიძლიათ გააკეთოთ
დაკავშირებული სიები.
დაკავშირებული სიაში, გაწვევას, არის მთელი რიგი კვანძების, რომ აღვნიშნო, რომ ერთმანეთს.
და ჩვენ ზოგადად იწყება მომცეთ მოუწოდა ხელმძღვანელი, ზოგადად, რომელიც მიუთითებს
პირველი, რაც სიაში.
ასე რომ, პირველი ხაზი, ჩვენ ჩვენი ორიგინალური L პირველი.
ასე რომ, რაც შეგიძლიათ ვფიქრობ - ეს ტექსტის აქ თქვენ შეგიძლიათ ვფიქრობ, როგორც
მხოლოდ კურსორი ჩვენ ინახება სადღაც, რომ რაოდენობა
პირველი ელემენტს.
და ამ უკავშირდება სიაში ჩვენ გვაქვს ოთხი კვანძების.
თითოეული კვანძის დიდი ყუთი.
დიდი ყუთი შიგნით დიდი ყუთი არის მთელი ნაწილი.
და მაშინ ჩვენ გვაქვს მომცეთ ნაწილი.
>> ამ ყუთები არ შედგენილი მასშტაბი, რადგან, თუ როგორ დიდი არის
მთელი ბაიტებში?
როგორ დიდი არის?
ოთხი.
და რამდენად დიდი მაჩვენებელი?
ოთხი.
ასე რომ, რეალურად, თუ ჩვენ მიაპყროს ამ მასშტაბის ორივე ყუთები
იქნება იგივე ზომა.
ამ შემთხვევაში, ჩვენ გვინდა ჩადეთ რაღაც შევიდა უკავშირდება სიაში.
ასე რომ თქვენ ხედავთ ქვემოთ აქ ჩვენ ჩასმა ხუთ ჩვენ traverse მეშვეობით
დაკავშირებული სიაში, იპოვოს, სადაც ხუთ მიდის, და შემდეგ ჩადეთ იგი.
>> მოდით დაარღვიოს, რომ ქვემოთ და წავიდეთ ცოტა უფრო ნელა.
მე ვაპირებ აღვნიშნო ფორუმში.
ასე რომ, ჩვენ გვაქვს ჩვენი კვანძის ხუთ, რომ ჩვენ შექმნილი mallocs.
რატომ ყველას იცინის?
Just kidding.
OK.
ამიტომ ჩვენ malloced ხუთ.
ჩვენ შევქმენით ამ კვანძის სხვაგან.
ჩვენ მას მზად ვართ წავიდეთ.
ჩვენ ვიწყებთ წინაშე ჩვენს სიაში ორი.
და ჩვენ გვინდა ჩადეთ in დახარისხებული მოდის.
>> ასე რომ, თუ ჩვენ ვხედავთ, ორი და ჩვენ გვინდა, რომ დააყენა ხუთ, რას ვაკეთებთ, როცა ვხედავთ
რაღაც ნაკლებად, ვიდრე ჩვენ?
რა?
გვინდა ჩადეთ five ამ დაკავშირებული სიაში, შენახვა ეს დახარისხებული.
ჩვენ ვხედავთ ნომერი ორი.
მერე რა ვქნათ?
Marcus?
>> აუდიტორია: ზარის მაჩვენებელი მომდევნო კვანძის.
>> JASON HIRSCHHORN: და რატომ ჩვენ წასვლა მომდევნო ერთი?
>> აუდიტორია: იმიტომ, რომ ის შემდეგი კვანძის სიაში.
და ჩვენ მხოლოდ ვიცით, რომ სხვა ადგილას.
>> JASON HIRSCHHORN: და ხუთ დიდია გარდა ორი, კერძოდ.
რადგან ჩვენ გვინდა, რომ შევინარჩუნოთ ის დახარისხებული.
ასე რომ, ხუთ მეტია ორი.
ასე რომ, ჩვენ გადაადგილება, რათა მომდევნო ერთი.
და ახლა ჩვენ მივაღწევთ ოთხ.
და რა ხდება, როდესაც ჩვენ მივაღწევთ ოთხი?
>> ხუთი მეტია ოთხ.
ასე რომ, ჩვენ შენარჩუნებას აპირებს.
და ახლა ჩვენ ექვსი.
და რას ვხედავთ, ექვსი?
დიახ, Carlos?
>> აუდიტორია: ექვსი მეტია ხუთ.
>> JASON HIRSCHHORN ექვსი არის აღემატება ხუთ.
ასე რომ, სადაც ჩვენ გვინდა, ჩადეთ ხუთ.
თუმცა, გახსოვდეთ, რომ თუ ჩვენ მხოლოდ ერთი მაჩვენებელი აქ -
ეს არის ჩვენი დამატებითი მაჩვენებელი, გადიოდა მეშვეობით სიაში.
და ჩვენ მიუთითებს ექვსი.
ჩვენ დავკარგეთ სიმღერა რა მოდის ადრე ექვსი.
ასე რომ, თუ გვინდა ჩადეთ რაღაც შევიდა ამ სიაში შენახვა ეს დახარისხებული, ჩვენ
ალბათ უნდა რამდენი მითითებას?
>> აუდიტორია: ორი.
>> JASON HIRSCHORN: ორი.
ერთ ტრეკზე მიმდინარე ერთი და ტრეკზე
წინა.
ეს არის მხოლოდ საგნით უკავშირდება სიაში.
ეს მხოლოდ მიდის ერთი მიმართულებით.
თუ ჩვენ გვქონდა ორმაგად უკავშირდება სიაში, სადაც ყველაფერი იმაზე მიუთითებს, რომ ის
მას შემდეგ და რამ ადრე, მაშინ ჩვენ არ უნდა გავაკეთოთ, რომ.
მაგრამ ამ შემთხვევაში ჩვენ არ სურს დაკარგოს სიმღერა რა ადრე მოვიდა us შემთხვევაში
ჩვენ უნდა ჩაწეროთ ხუთ სადღაც ცენტრიდან.
ამბობენ, რომ ჩვენ ჩასმა ცხრა.
რა მოხდებოდა, როცა მივიღეთ რვა?
>> აუდიტორია: ნეტავ უნდა მიიღოს, რომ null წერტილი.
იმის მაგივრად null წერტილი ნეტავ დაამატოთ ელემენტს და შემდეგ უნდა
ეს აღვნიშნო, რომ ცხრა.
>> JASON HIRSCHORN: ზუსტად.
ამიტომ ჩვენ კიდევ რვა.
მივაღწევთ სიის ბოლოში იმის გამო, ეს მიუთითებს null.
და ახლა, ნაცვლად, რომელმაც ის აღვნიშნო, რომ null ჩვენ ეს აღვნიშნო, რომ ჩვენი ახალი კვანძში.
და ჩვენ დავსახეთ მაჩვენებელი ჩვენი ახალი კვანძის null.
ვინმეს გაქვთ რაიმე შეკითხვები დაახლოებით ჩასმა?
რა მოხდება, თუ არ აინტერესებს შენახვა სია დალაგებულია?
>> აუდიტორია: Stick იგი დასაწყისში ან ბოლოს.
>> JASON HIRSCHORN: Stick იგი დასაწყისში ან ბოლოს.
რომელი უნდა ვქნათ?
Bobby?
რატომ ბოლოს?
>> აუდიტორია: იმიტომ, რომ დასაწყისში უკვე შევსებული.
>> JASON HIRSCHORN: OK.
დასაწყისში უკვე შევსებული.
ვისაც სურს ამტკიცებენ, წინააღმდეგ Bobby.
Marcus.
>> აუდიტორია: Well თქვენ ალბათ მინდა გამყარებაში მას დასაწყისში, რადგან
წინააღმდეგ შემთხვევაში, თუ დააყენა ეს ბოლოს ნეტავ უნდა
traverse მთელი სია.
>> JASON HIRSCHORN: ზუსტად.
ასე რომ, თუ ჩვენ ფიქრი runtime, runtime ჩასმა დასასრულს
იქნება n, ზომა.
რა არის დიდი O runtime ჩასმა დასაწყისში?
მუდმივი დრო.
ასე რომ, თუ არ აინტერესებს შენახვა რაღაც დახარისხებული, ბევრად უკეთესი, უბრალოდ
ჩადეთ დასაწყისში ამ სიაში.
და რომ შეიძლება გაკეთდეს მუდმივი დრო.
>> OK.
შემდეგი ოპერაცია იპოვოს, რომელიც მეორე - ჩვენ ფორმულირებული ეს ძიება.
მაგრამ ჩვენ ვაპირებთ გადახედეთ დაკავშირებული სიაში ზოგიერთი ობიექტი.
თქვენ ბიჭები არ ჩანს კოდი ძებნის ადრე ლექცია.
მაგრამ ჩვენ ერთგვარი უბრალოდ გააკეთეს ეს ჩადეთ, ან თუნდაც ჩასმა
რაღაც დახარისხებული.
გადავხედავთ, აპირებს კვანძის მიერ კვანძის, სანამ თქვენთვის ნომერი, რომელიც თქვენ
ეძებს.
რა მოხდება, თუ თქვენ მიღწევა ბოლოს სიაში?
ამბობენ, ვეძებ ცხრა და მე მიაღწიონ ბოლომდე სიაში.
რა ვქნათ?
>> აუდიტორია: დაბრუნება ყალბი?
>> JASON HIRSCHORN: დაბრუნება ყალბი.
ჩვენ არ საპოვნელად.
თუ თქვენ მივაღწიოთ ბოლოს სიაში და თქვენ არ იპოვოს ნომერი თქვენ
ეძებს, ის არ არსებობს.
რაიმე შეკითხვები მოვძებნოთ?
თუ ეს იყო დახარისხებული სია, რა განსხვავებული უნდა იყოს ჩვენი ძებნას?
ჰო.
>> აუდიტორია: ეს რომ იპოვოს პირველ ღირებულება რომ ის უფრო მეტია, ვიდრე ერთი
თქვენ ეძებთ შემდეგ დაბრუნების ცრუ.
>> JASON HIRSCHORN: ზუსტად.
ასე რომ, თუ ეს დახარისხებული სია, თუ მივიღებთ რაღაც რომ მეტი რა
ჩვენ ვეძებთ, ჩვენ არ უნდა შეინახოს აპირებს ბოლომდე სიაში.
ჩვენ შეგვიძლია იმ ეტაპზე დაბრუნების ცრუ იმიტომ, რომ ჩვენ არ ვაპირებთ მის საპოვნელად.
კითხვა ახლა, ჩვენ ვისაუბრეთ შენახვა დაკავშირებული სიები დახარისხებული,
შენახვა მათ დაუხარისხებელი.
ეს იქნება რაღაც თქვენ ალბათ აპირებს უნდა ვიფიქროთ
როდესაც კოდირების პრობლემა კომპლექტი ხუთ თუ აირჩიეთ hash table ცალკე
chaining მიდგომა, რომელიც ჩვენ ვსაუბრობთ შემდეგ.
>> მაგრამ ღირს ეს შენარჩუნება სია დახარისხებული და შემდეგ შეძლებთ იქნებ აქვს
სწრაფად ეძებს?
თუ უკეთესი სწრაფად ჩადეთ რაღაც მუდმივი runtime მაგრამ შემდეგ
აღარ ეძებს?
ეს tradeoff უფლება არსებობს, რომ კიდევ გადასაწყვეტია, რა უფრო შესაბამისი
თქვენი კონკრეტული პრობლემა.
და იქ არ არის აუცილებელი ერთი აბსოლუტურად სწორი პასუხი.
მაგრამ ეს, რა თქმა გადაწყვეტილება თქვენ მიიღებთ რათა და ალბათ კარგი დასაცავად
რომ, ვთქვათ, კომენტარი ან ორი, თუ რატომ თქვენ აირჩია ერთი მეტი სხვა.
>> და ბოლოს, წაშლის.
ჩვენ ვნახეთ წაშლის.
ეს მსგავსი ძებნას.
ჩვენ ვეძებთ ელემენტს.
ამბობენ, რომ ჩვენ ვცდილობთ წაშლა ექვსი.
ასე რომ, ჩვენ ვხედავთ, ექვსი უფლება აქ.
საქმე იმაშია, რომ ჩვენ უნდა დავრწმუნდეთ, რომ ჩვენ გავაკეთოთ არის ის, რომ რაც მიუთითებს
ექვსი - როგორც ვხედავთ ნაბიჯი ორი ქვემოთ აქ -
რასაც მიუთითებს ექვსი საჭიროებების გაფართოებული ექვსი ახლა და უნდა შეიცვალოს
რასაც ექვსი მიუთითებს.
ჩვენ არ გვინდა, რომ ოდესმე ობოლი დანარჩენი ჩვენი სია ავიწყდება მითითებული, რომ
წინა მაჩვენებელი.
და შემდეგ, ზოგჯერ, დამოკიდებულია პროგრამა, ისინი მხოლოდ
წაშლა ამ კვანძის მთლიანად.
ზოგჯერ თქვენ გსურთ დაბრუნდეს ღირებულება, რომელიც ამ კვანძში.
ასე რომ, თუ წაშლის სამუშაოები.
ნებისმიერი კითხვები წაშლა?
>> აუდიტორია: ასე რომ, თუ თქვენ აპირებს წაშლა ის, რომ თქვენ უბრალოდ გამოიყენოს თავისუფალი, რადგან
სავარაუდოდ, ეს იყო malloced?
>> JASON HIRSCHORN თუ გსურთ გასათავისუფლებლად რაღაც რომ სწორედ და თქვენ
malloced იგი.
Say გვინდოდა დაბრუნებას ამ ღირებულება.
ჩვენ შეიძლება დაბრუნდეს ექვსი და შემდეგ უფასოდ ამ კვანძის და call უფასო მასზე.
ან ჩვენ მინდა ალბათ call უფასო პირველი და შემდეგ დაბრუნდება ექვსი.
>> OK.
მოდით გადაადგილება, რათა პრაქტიკაში კოდირების.
ჩვენ ვაპირებთ კოდექსის სამი ფუნქციები.
პირველი ჰქვია insert_node.
ასე რომ თქვენ უნდა კოდი, რომელიც მე ელექტრონული ფოსტით თქვენ, და თუ თქვენ თვალს ამ მოგვიანებით
თქვენ შეგიძლიათ თქვათ კოდის linked.c on CS50 ნახვა.
მაგრამ linked.c, არსებობს გარკვეული ჩონჩხი კოდი, რომელიც უკვე
დაიწერა თქვენთვის.
და შემდეგ იქ რამდენიმე ფუნქციები თქვენ უნდა დაწეროთ.
>> პირველი, ჩვენ ვაპირებთ დაწერა insert_node.
და რა insert_node აკეთებს არის ჩანართები რიცხვი.
და თქვენ რაც მთელი რიცხვი შევიდა უკავშირდება სიაში.
კერძოდ, თქვენ უნდა შენარჩუნება სია დალაგებულია
საწყისი პატარა რომ უდიდესი.
ასევე, თქვენ არ მინდა ჩადეთ ნებისმიერი ეგზ.
საბოლოოდ, როგორც ხედავთ insert_node დააბრუნებს bool.
ასე რომ თქვენ უნდა ნება შესახებ ვიცით თუ არა ჩანართით იყო
წარმატებული დაბრუნების ჭეშმარიტი ან ცრუ.
დასასრულს ამ პროგრამის -
და ამ ეტაპზე, თქვენ არ გჭირდებათ ფიქრი ათავისუფლებს არაფერი.
ასე რომ ყველა თქვენ აკეთებთ არის აღების რიცხვი და ჩასმა იგი სიაში.
>> ეს არის ის, რაც მე გეკითხებით ახლა.
ერთხელ, იმ linked.c, რომელიც თქვენ ყველას გვაქვს, არის ჩონჩხი კოდი.
და თქვენ უნდა ნახოთ ბოლოსკენ ნიმუში ფუნქცია დეკლარაცია.
თუმცა, სანამ შესვლის კოდირების ის C, უაღრესად გარწმუნებთ, რომ წავიდეს
მეშვეობით ნაბიჯები ჩვენ პრაქტიკოსი ყოველ კვირას.
ჩვენ უკვე გავიარეთ სურათს ამ.
ასე, რომ თქვენ უნდა ჰქონდეს გარკვეული გაგება თუ როგორ ეს სამუშაოები.
მაგრამ მე გარწმუნებთ, რომ წერენ ზოგიერთი pseudocode ადრე diving შემოსული
და ჩვენ ვაპირებთ წასვლა მეტი pseudocode როგორც ჯგუფი.
და მერე კიდევ თქვენ წერილობითი თქვენი pseudocode, და კიდევ ჩვენ წერილობითი ჩვენი
pseudocode როგორც ჯგუფი, თქვენ შეგიძლიათ წასვლას კოდირების ის C.
>> როგორც ხელმძღვანელები up, insert_node ფუნქცია ალბათ trickiest of
სამ ჩვენ ვაპირებთ დავწეროთ, რადგან მე დამატება ზოგიერთი დამატებითი შეზღუდვების
თქვენი პროგრამირების, კერძოდ, თქვენ არ აპირებს ჩადეთ ნებისმიერი
ეგზემპლარი და რომ სიაში უნდა დარჩეს დახარისხებული.
ასე რომ ეს არის არასამთავრობო ტრივიალური პროგრამა რომ თქვენ უნდა Code.
და რატომ არ მიიღოს ხუთიდან შვიდ ე მხოლოდ მისაღებად მუშაობა
pseudocode და კოდი.
და მაშინ ჩვენ დაიწყება ვაპირებ, როგორც ჯგუფი.
ისევ და ისევ, თუ თქვენ გაქვთ რაიმე შეკითხვები მხოლოდ გაზარდოთ თქვენი მხრივ, და მე მოდის გარშემო.
.
>> ჩვენ ასევე ზოგადად გავაკეთოთ ეს -
ან მე არ მკაფიოდ ამბობენ, რომ თქვენ შეუძლია მუშაობა ადამიანი.
მაგრამ ცხადია, უაღრესად გარწმუნებთ, თუ თქვენ გაქვთ შეკითხვები, ვთხოვო
მეზობელი სხდომაზე შემდეგ თქვენ ან თუნდაც მუშაობა ვინმეს
სხვაგან, თუ გსურთ.
ეს არ უნდა იყოს ინდივიდუალური ჩუმად საქმიანობაში.
>> დავიწყოთ წერა რამდენიმე pseudocode ფორუმში.
ვის შეუძლია მომეცი პირველი ხაზი pseudocode ამ პროგრამის?
ამ ფუნქციას, არამედ - insert_node.
Alden?
>> აუდიტორია: ასე რომ პირველი რაც გავაკეთე იყო შექმნა ახალი მომცეთ კვანძის და მე
ინიციალიზაცია მიუთითებს ურთიერთობა ის, რომ სიაში მიუთითებს.
>> JASON HIRSCHORN: OK.
ასე რომ თქვენ შექმნით ახალ მაჩვენებელი სიას, არა კვანძში.
>> აუდიტორია: Right.
ჰო.
>> JASON HIRSCHORN: OK.
და მერე რა გვინდა გავაკეთოთ?
რა ამის შემდეგ?
რაც შეეხება კვანძის?
ჩვენ არ გვაქვს კვანძში.
ჩვენ უბრალოდ ღირებულება.
თუ გვინდა ჩადეთ კვანძის, რას უნდა გავაკეთოთ სანამ ჩვენ კი
ვიფიქროთ ჩასმა იგი?
>> აუდიტორია: ოჰ, უკაცრავად.
ჩვენ უნდა malloc ფართი კვანძში.
>> JASON HIRSCHORN: Excellent.
მოდით -
OK.
ვერ აღწევს, რომ მაღალი.
OK.
ჩვენ ვაპირებთ დაცემას, შემდეგ კი ჩვენ გამოყენებით ორი სვეტით.
მე ვერ, რომ -
OK.
შექმნა ახალი კვანძში.
თქვენ შეგიძლიათ შექმნათ კიდევ ერთი მაჩვენებელი სიაში ან შეგიძლიათ უბრალოდ გამოიყენოთ სიაში, როგორც ის არსებობს.
თქვენ ნამდვილად არ უნდა გავაკეთოთ, რომ.
>> ასე რომ, ჩვენ შევქმნით ახალ კვანძში.
დიდი.
ეს არის ის, რასაც ჩვენ ვაკეთებთ პირველი.
რა არის შემდეგი?
>> აუდიტორია: Wait.
უნდა შეიქმნას ახალი კვანძის ახლა ან უნდა დაველოდოთ, რათა დავრწმუნდეთ, რომ
არ არსებობს ეგზემპლარი კვანძის სიაში სანამ ჩვენ შექმნა?
>> JASON HIRSCHORN: კარგი კითხვაა.
მოდით გამართავს, რომ მოგვიანებით, რადგან უმრავლესობა დროს ჩვენ უნდა შექმნაში
ახალი კვანძში.
ასე რომ, ჩვენ გავაგრძელებთ რომ აქ.
მაგრამ ეს კარგი კითხვაა.
თუ ჩვენ შევქმნით და ჩვენ დუბლიკატი, რა უნდა
ჩვენ გავაკეთებთ სანამ?
>> აუდიტორია: უფასო იგი.
>> JASON HIRSCHORN: ჰო.
ალბათ გასათავისუფლებლად იგი.
OK.
რას ვაკეთებთ შემდეგ ჩვენ შექმნა ახალი კვანძის?
Annie?
>> აუდიტორია: ჩვენ დააყენა ნომერი კვანძის?
>> JASON HIRSCHORN: ზუსტად.
ჩვენ დააყენა ნომერი - ჩვენ malloc სივრცეში.
მე ვაპირებ რომ დატოვოთ რომ ყველა, როგორც ერთი ხაზი.
მაგრამ თქვენ უფლება.
ჩვენ malloc სივრცეში, და შემდეგ ჩვენ დააყენა ნომერი შემოსული
ჩვენ შეგიძლიათ კიდევ მითითებული მომცეთ ნაწილს null.
ეს არის ზუსტად ის უფლება.
და მერე რა შეიძლება ითქვას ამის შემდეგ?
ჩვენ მიიპყრო ამ სურათს დაფაზე.
მერე რა ვქნათ?
>> აუდიტორია: ჩვენ გავლა სიაში.
>> JASON HIRSCHORN: გავლა სიაში.
OK.
და რას შემოწმება ყოველ კვანძში.
Kurt, რას შემოწმება განთავსების ყოველ კვანძის?
>> აუდიტორია: თუ არა n ღირებულება რომ კვანძის მეტია n ღირებულება
ჩვენი კვანძში.
>> JASON HIRSCHORN: OK.
მე ვაპირებ ამის გაკეთებას -
yeah, OK.
ასე რომ, ეს n -
მე ვაპირებ ვთქვა, თუ ღირებულება არის დიდი გარდა ამ კვანძის, მაშინ რა ვქნათ?
>> აუდიტორია: Well, მაშინ ჩვენ ჩადეთ რამ უფლება, რომ.
>> JASON HIRSCHORN: OK.
ასე რომ, თუ ეს უფრო მეტია, ვიდრე ამ, მაშინ ჩვენ გვინდა ჩადეთ.
მაგრამ ჩვენ გვინდა, ჩადეთ ეს უფლება ადრე იმის გამო, რომ ჩვენ ასევე უნდა იყოს
შენახვა ტრეკზე, მაშინ, რა იყო ადრე.
ასე რომ ჩადეთ ადრე.
ამიტომ, ჩვენ, ალბათ გაშვებული რაღაც ადრე.
ჩვენ ალბათ უნდა შენახვა სიმღერა რა ხდება.
მაგრამ ჩვენ დავუბრუნდეთ არსებობს.
ასე რომ, რა მნიშვნელობა ნაკლებია?
Kurt, რა გავაკეთოთ, თუ მნიშვნელობა ნაკლებია?
>> აუდიტორია: მაშინ თქვენ უბრალოდ შეინახოს აპირებს თუ იგი ბოლო ერთი.
>> JASON HIRSCHORN: მომწონს, რომ.
ასე რომ, გადადით მომდევნო კვანძის.
თუ ეს უკანასკნელი -
ჩვენ, ალბათ, შემოწმების, რომ ამ თვალსაზრისით მდგომარეობა.
მაგრამ ჰო, მომდევნო კვანძის.
და რომ არც ძალიან დაბალია, ასე რომ, ჩვენ გადაადგილება აქ.
მაგრამ თუ -
შეგიძლიათ ყველამ ნახოთ ეს?
თუ ჩვენ ტოლია რას ვაკეთებთ?
თუ ღირებულება ჩვენ ვცდილობთ ჩასასმელად უდრის ამ კვანძის მნიშვნელობა?
ჰო?
>> აუდიტორია: [INAUDIBLE].
>> JASON HIRSCHORN: ჰო.
აქედან გამომდინარე -
Marcus არის სწორი.
ჩვენ შეგვეძლო იქნებ გაკეთდეს რაღაც განსხვავებული.
მაგრამ იმის გათვალისწინებით, რომ ჩვენ შევქმენით, აქ ჩვენ უნდა გასათავისუფლებლად და შემდეგ დაბრუნდნენ.
Oh boy.
ის არის, რომ უკეთესი?
როგორ არის, რომ?
OK.
უფასო და მერე რა ჩვენ დაბრუნდნენ, [INAUDIBLE]?
OK.
ჩვენ აკლია რამე?
ასე რომ, სად ვართ ჩვენ, შენახვა ტრეკზე ადრე კვანძის?
>> აუდიტორია: მე ვფიქრობ, რომ წავიდოდა მას შემდეგ, რაც შექმნის ახალ კვანძში.
>> JASON HIRSCHORN: OK.
ასე რომ, წლის დასაწყისში ჩვენ, ალბათ -
ჰო, ჩვენ შეგვიძლია შევქმნათ მომცეთ new კვანძის, ისევე როგორც წინა კვანძის მაჩვენებელი და
მიმდინარე კვანძის მაჩვენებელი.
მოდით ჩადეთ, რომ აქ.
შექმნა მიმდინარე და წინა მითითებას კვანძების.
მაგრამ როდესაც ჩვენ შეცვალოს იმ მითითებას?
სად გავაკეთოთ, რომ კოდი?
Jeff?
>> აუდიტორია: - ღირებულება პირობებში?
>> JASON HIRSCHORN: რომელი ერთი კერძოდ?
>> აუდიტორია: მე უბრალოდ დაბნეული.
თუ ღირებულება აღემატება ამ კვანძის, არ ნიშნავს ეს იმას, რომ გსურთ წავიდეთ
მომდევნო კვანძის?
>> JASON HIRSCHHORN: ასე რომ, თუ ჩვენი ღირებულება მეტი ღირებულება ამ კვანძში.
>> აუდიტორია: Yeah, მაშინ ნეტავ მინდა წასვლა შემდგომი ქვემოთ ხაზის, არა?
>> JASON HIRSCHHORN: Right.
ამიტომ, ჩვენ არ ჩადეთ აქ.
თუ მნიშვნელობა ნაკლებია ამ კვანძის, მაშინ ჩვენ წასვლა მომდევნო კვანძის - ან მაშინ ჩვენ
ჩადეთ ადრე.
>> აუდიტორია: Wait, რომელიც ამ კვანძის და რაც მნიშვნელობა?
>> JASON HIRSCHHORN: კარგი კითხვაა.
ფასის პოსტი ამ ფუნქციის განმარტება არის ის, რაც ჩვენ მოცემული.
ასე რომ ღირებულება არის ნომერ ჩვენ მოცემული.
ასე რომ, თუ მნიშვნელობა ნაკლებია ამ კვანძის, ჩვენ გვჭირდება დრო, რათა ჩადეთ.
თუ ღირებულება აღემატება ამ კვანძის, ჩვენ წასვლა მომდევნო კვანძის.
და თავში ორიგინალური კითხვა, თუმცა, სადაც -
>> აუდიტორია: თუ ღირებულება არის დიდი ვიდრე ამ კვანძში.
>> JASON HIRSCHHORN: და ა.შ. რას ვაკეთებთ აქ?
ტკბილი.
ეს არის სწორი.
მე უბრალოდ აპირებს დაწერა განახლება პოინტერები.
მაგრამ დიახ, მიმდინარე ერთი თქვენ უნდა განაახლოთ იგი და
აღვნიშნო, რომ მომდევნო ერთი.
არაფერი ჩვენ აკლია?
ამიტომ მე ვაპირებ აკრიფოთ ამ კოდი შევიდა gedit.
ხოლო მე ამის გაკეთება, შეგიძლიათ აქვს რამდენიმე წუთის მუშაობა კოდირების
ამ C.
>> ამიტომ უნდა შეყვანის pseudocode.
სწრაფი შენიშვნა, სანამ ჩვენ უნდა დავიწყოთ.
ჩვენ შეიძლება ვერ შეძლებს მთლიანად დასრულდება ეს ყველა
სამი ფუნქციები.
არ არის სწორი გადაწყვეტილებები მათ რომ მე მქონ out თქვენ ბიჭები
შემდეგ სექციაში, და იგი გამოქვეყნდება CS50.net.
ასე რომ მე არ მოგიწოდებთ თქვენ წასვლა შევხედოთ სექციები.
მე მოგიწოდებთ თქვენ ცდილობენ ამ თქვენს ფლობს, და შემდეგ გამოიყენოს პრაქტიკა
პრობლემები სანახავად პასუხი.
ეს არ ყველა შემუშავებულია მჭიდროდ ეხება და ვიცავთ იმას, რაც
თქვენ უნდა გავაკეთოთ პრობლემა კომპლექტი.
ასე რომ, მე გარწმუნებთ, რომ პრაქტიკაში ეს საკუთარი და შემდეგ გამოიყენოს კოდი
შეამოწმეთ თქვენი პასუხი.
იმიტომ, რომ მე მინდა გადაადგილება hash მაგიდები რაღაც მომენტში მონაკვეთზე.
ასე რომ, ჩვენ შეიძლება არ მიიღოთ მეშვეობით ეს ყველაფერი.
მაგრამ ჩვენ ყველაფერს გავაკეთებთ, რამდენიც ჩვენ შეგვიძლია ახლა.
>> OK.
დავიწყოთ.
ASAM, როგორ უნდა შეიქმნას ახალი კვანძის?
>> აუდიტორია: თქვენ struct *.
>> JASON HIRSCHHORN: ასე რომ, აქვს, რომ აქ.
ოჰ, უკაცრავად.
თქვენ ამბობდნენ struct *.
>> აუდიტორია: და მერე [? სახის?] კვანძის ან გ კვანძში.
>> JASON HIRSCHHORN: OK.
მე ვაპირებ მოვუწოდო მას new_node ასე რომ ჩვენ შეგვიძლია დარჩენა თანმიმდევრული.
>> აუდიტორია: და გსურთ, რომ უხელმძღვანელებს, პირველ კვანძში.
>> JASON HIRSCHHORN: OK.
ასე რომ, ახლა ეს მიუთითებს - ეს არ იქმნება ახალი კვანძის არავის გაუკეთებია.
ეს მხოლოდ მიუთითებს პირველი კვანძის სიაში.
როგორ შევქმნა ახალი კვანძის?
თუ მე უნდა სივრცის შექმნა ახალი კვანძში.
Malloc.
და რამდენად დიდი?
>> აუდიტორია: ზომა struct.
>> JASON HIRSCHHORN: ზომა struct.
და რა struct მოუწოდა?
>> აუდიტორია: Node?
>> JASON HIRSCHHORN: Node.
ასე malloc (sizeof (კვანძის)); გვაძლევს სივრცეში.
და ეს ხაზი -
ერთი რამ არის არასწორი ამ ხაზის.
არის new_node მომცეთ struct?
ეს არის generic სახელი.
რა არის ეს -
კვანძის, ზუსტად.
ის კვანძის *.
და რა ვქნათ შემდეგ ჩვენ malloc რაღაც, Asan?
რა არის პირველი რამ გავაკეთოთ?
რა მოხდება, თუ ის არ მუშაობს?
>> აუდიტორია: Oh, შეამოწმოთ, თუ იგი მიუთითებს კვანძის?
>> JASON HIRSCHHORN: ზუსტად.
ასე რომ, თუ new_node შეადგენს შეადგენს null, რა ვქნათ?
ეს დააბრუნებს bool, ამ ფუნქციას.
ზუსტად.
კარგად გამოიყურება.
არაფერს დაამატოთ იქ?
ჩვენ დაამატოთ რამ დასასრულს.
მაგრამ ეს ჯერჯერობით კარგად გამოიყურება.
შექმნა მიმდინარე და წინა პოინტერები.
მიხეილი, როგორ გავაკეთო ეს?
>> აუდიტორია: თქვენ უნდა გავაკეთოთ კვანძის *.
ნეტავ უნდა გააკეთოთ ერთი არ განთავსების new_node არამედ
კვანძების ჩვენ უკვე გვაქვს.
>> JASON HIRSCHHORN: OK.
ასე რომ, მიმდინარე კვანძის ჩვენ შესახებ.
მე მოვუწოდებ, რომ Curr.
ყველა უფლება.
ჩვენ გადავწყვიტეთ, რომ ჩვენ გვინდა, რომ შევინარჩუნოთ ორი იმიტომ, რომ ჩვენ უნდა ვიცოდეთ
რა სანამ.
რას უნდა ინიციალიზაცია to?
>> აუდიტორია: მათი ღირებულება ჩვენს სიაში.
>> JASON HIRSCHHORN: რა არის პირველი, რაც ჩვენს სიაში?
ან ვიცით, სადაც დასაწყისში ჩვენს სიაში არის?
>> აუდიტორია: არის თუ არა ეს გავიდა შევიდა ფუნქცია?
>> JASON HIRSCHHORN: Right.
იგი გავიდა უფლება აქ.
ასე რომ, თუ ის შევიდა ფუნქცია, დაიწყოს სია, რა უნდა
მითითებული მიმდინარე ტოლია?
>> აუდიტორია: სია.
>> JASON HIRSCHHORN: სია.
ეს არის ზუსტად ის უფლება.
ახლა მას აქვს მისამართი დაწყების ჩვენს სიაში.
რაც შეეხება წინა?
>> აუდიტორია: სია მინუს ერთი?
>> JASON HIRSCHHORN: არსებობს არაფერი სანამ.
რა უნდა გავაკეთოთ, რომ ნიშნავდეს არაფერი?
>> აუდიტორია: Null.
>> JASON HIRSCHHORN: ჰო.
რომ ჟღერს კარგი იდეა.
სრულყოფილი.
დიდი მადლობა.
გავლა სიაში.
კონსტანტინე, რამდენ ხანს მივდივართ გავლა სიაში?
>> აუდიტორია: სანამ მივაღწევთ null.
>> JASON HIRSCHHORN: OK.
ასე რომ, თუ, ხოლო ამისთვის loop.
რას ვაკეთებთ?
>> აუდიტორია: იქნებ for loop?
>> JASON HIRSCHHORN: მოდით for loop.
OK.
>> აუდიტორია: და ჩვენ ვთქვათ -
სანამ მაჩვენებელი არ არის ტოლი null.
>> JASON HIRSCHHORN: ასე რომ, თუ ჩვენ ვიცით, მდგომარეობაში, როგორ შეგვიძლია დავწეროთ loop
საფუძველზე off რომ მდგომარეობა.
როგორი loop უნდა გამოვიყენოთ?
>> აუდიტორია: მიუხედავად იმისა.
>> JASON HIRSCHHORN: ჰო.
რომ ხდის უფრო გრძნობა საფუძველზე off რას განაცხადა.
იმ შემთხვევაში, თუ ჩვენ გვსურს მხოლოდ წასვლას, ჩვენ ეს საკითხი უბრალოდ ვიცი, რომ რამ, ეს იქნებოდა
გრძნობა უნდა გააკეთოს ხოლო loop.
მიუხედავად იმისა, რომ მიმდინარე არ თანაბარი null, თუ მნიშვნელობა ნაკლებია ამ კვანძში.
Akshar, მომეცი ამ ხაზის.
>> აუდიტორია: თუ მიმდინარე> n n ნაკლები ღირებულება.
ან საპირისპირო რომ.
გადართვის რომ bracket.
>> JASON HIRSCHHORN: უკაცრავად.
>> აუდიტორია: შეცვლა bracket.
>> JASON HIRSCHHORN: ასე რომ, თუ ის აღემატება ღირებულება.
იმიტომ, რომ გაუგებარია ერთად კომენტარის ზემოთ, მე ვაპირებ ამის გაკეთებას.
მაგრამ დიახ.
თუ ჩვენი მნიშვნელობა ნაკლებია ამ კვანძის, რა ვქნათ?
Oh.
მე მას უფლება აქ.
ჩადეთ ადრე.
OK.
როგორ გავაკეთოთ ეს?
>> აუდიტორია: ეს ჯერ კიდევ მე?
>> JASON HIRSCHHORN: ჰო.
>> აუდიტორია: თქვენ -
new_node-> მომავალი.
>> JASON HIRSCHHORN: რა არის რომ აპირებს გაუტოლდება?
>> აუდიტორია: იგი აპირებს ტოლია მიმდინარე.
>> JASON HIRSCHHORN: ზუსტად.
და ა.შ. მეორე -
რა გვჭირდება განაახლოთ?
>> აუდიტორია: შეამოწმეთ თუ წარსულში შეადგენს null.
>> JASON HIRSCHHORN თუ prev -
ასე რომ, თუ prev შეადგენს null.
>> აუდიტორია: ეს ნიშნავს, რომ ის აპირებს გახდეს ხელმძღვანელი.
>> JASON HIRSCHHORN: ე.ი. ის გახდა ხელმძღვანელი.
ასეა, მაშინ რა ვქნათ?
>> აუდიტორია: ჩვენ გავაკეთოთ ხელმძღვანელი შეადგენს new_node.
>> JASON HIRSCHHORN: Head შეადგენს new_node.
და რატომ უხელმძღვანელებს აქ, არ ჩამოვთვალოთ?
>> აუდიტორია: იმიტომ, რომ თავი გლობალურ ცვლადი, რომელიც არის დაწყებული ადგილას.
>> JASON HIRSCHHORN: Sweet.
OK.
და -
>> აუდიტორია: მაშინ თქვენ სხვას prev> შემდეგი ტოლია new_node.
და მაშინ იქნება TRUE.
>> JASON HIRSCHHORN: სად ჩვენ დავსახეთ new_node ბოლოს?
>> აუდიტორია: მე -
I მითითებული, რომ სტარტზე.
>> JASON HIRSCHHORN: რა ხაზი?
>> აუდიტორია: მას შემდეგ, თუ განაცხადი შემოწმების, თუ ის ცნობილია.
>> JASON HIRSCHHORN: Right აქ?
>> აუდიტორია: მინდა გავაკეთოთ new_node-> n უდრის ღირებულება.
>> JASON HIRSCHHORN: ხმები კარგი.
ალბათ ეს აზრი - ჩვენ არ უნდა ვიცოდეთ რა სიაში ჩვენ შესახებ
რადგან ჩვენ მხოლოდ საქმე ერთი სია.
ასე რომ, უკეთესი ფუნქცია დეკლარაციის ეს არის უბრალოდ მოშორება ამ
მთლიანად და უბრალოდ ჩადეთ ღირებულება თარგმნეს ხელმძღვანელი.
ჩვენ კი არ უნდა იცოდეს, რა სიაში ჩვენ შემოსული
მაგრამ მე დაიცავს მას ახლა და შემდეგ შეცვალოთ ის საფუძველზე განახლებაზე
სლაიდები და კოდი.
ასე რომ გამოიყურება კარგი ახლა.
თუ ღირებულება - ვის შეუძლია ამის გაკეთება ხაზი?
იმ შემთხვევაში, თუ -
რას ვაკეთებთ აქ, ნოე.
>> აუდიტორია: თუ ღირებულება არის დიდი გარდა Curr> n -
>> JASON HIRSCHHORN: როგორ ჩვენ წასვლა მომდევნო კვანძის?
>> აუდიტორია: Curr> n არის ტოლი new_node.
>> JASON HIRSCHHORN: So n არის რა ნაწილი struct?
რიცხვი.
და new_node არის მომცეთ კვანძში.
ასე რომ, თუ რა ნაწილი Curr უნდა განახლება?
თუ არ n, მაშინ რა არის მეორე ნაწილი?
ნოეს რა არის მეორე ნაწილი.
>> აუდიტორია: Oh, მომავალი.
>> JASON HIRSCHHORN შემდეგი, ზუსტად.
ზუსტად.
შემდეგი არის სწორი ერთი.
და რა გვჭირდება განახლება, ნოეს?
>> აუდიტორია: პოინტერები.
>> JASON HIRSCHHORN: So ჩვენ განახლება მიმდინარე.
>> აუდიტორია: წინა> მომავალი.
>> JASON HIRSCHHORN: ჰო.
OK, ჩვენ პაუზის.
ვინ დაგვეხმარება აქ?
Manu, რა უნდა გავაკეთოთ?
>> აუდიტორია: თქვენ მოხვდით მითითებული მას ტოლი Curr> მომავალი.
მაგრამ, რომ სანამ წინა ხაზი.
>> JASON HIRSCHHORN: OK.
არაფერი?
Akshar.
>> აუდიტორია: მე არ ვფიქრობ, თქვენ ნიშნავდა, რომ შეიცვალოს Curr> მომავალი.
მე ვფიქრობ, თქვენ ნიშნავდა გავაკეთოთ Curr შეადგენს Curr> შემდეგი წასვლა მომდევნო კვანძის.
>> JASON HIRSCHHORN: ასე რომ, ბოდიში, სადაც?
რა ხაზი?
ეს ხაზი?
>> აუდიტორია: Yeah.
რათა Curr შეადგენს Curr> მომავალი.
>> JASON HIRSCHHORN: ასე რომ სწორი იმის გამო, რომ მიმდინარე
მომცეთ კვანძში.
და ჩვენ გვინდა, რომ აღვნიშნო, რომ მომავალ კვანძის რა მისაღებად გაკეთებული
მიუთითა.
Curr თავად აქვს მომავალი.
მაგრამ თუ ჩვენ განახლება curr.next, ჩვენ იქნება განახლება ფაქტობრივი შენიშვნა
თავისთავად, არ არის, სადაც ეს მაჩვენებელი მიუთითებს.
რაც შეეხება ამ მიმართულებით, თუმცა.
Avi?
>> აუდიტორია: წინა> შემდეგი ტოლია Curr.
>> JASON HIRSCHHORN: ასე რომ, კიდევ ერთხელ, თუ prev არის მომცეთ კვანძის, prev-> მომავალი არის
ფაქტობრივი მაჩვენებელი ამ კვანძში.
ასე რომ, ეს იქნება განახლებაზე მაჩვენებელი კვანძის Curr.
ჩვენ არ გვინდა განახლება მაჩვენებელი კვანძში.
ჩვენ გვინდა განაახლოთ წინა.
ასე როგორ უნდა ამის გაკეთება?
>> აუდიტორია: ეს იქნებოდა მხოლოდ prev.
>> JASON HIRSCHHORN: Right.
წინა მომცეთ კვანძში.
ახლა ჩვენ იცვლება მას ახალი მომცეთ კვანძში.
OK მოდი ქვევით.
და ბოლოს, ამ ბოლო მდგომარეობაში.
Jeff, რას ვაკეთებთ აქ?
>> აუდიტორია: თუ ღირებულება არის ტოლი Curr> n.
>> JASON HIRSCHHORN: უკაცრავად.
Oh ჩემი სიკეთე.
რა?
ღირებულება == Curr> n.
რა ვქნათ?
>> აუდიტორია: ნეტავ გასათავისუფლებლად ჩვენი new_node, და მერე ნეტავ დაბრუნების ცრუ.
>> JASON HIRSCHHORN: ეს არის ის, რაც ჩვენ წერილობით ჯერჯერობით.
ვინმეს აქვს რამე დაამატოთ სანამ ჩვენ?
OK.
მოდით ცდილობენ.
კონტროლის მიღწევა ბოლომდე არასამთავრობო ბათილად ფუნქცია.
Avi, რა ხდება?
>> აუდიტორია: თქვენ უნდა დააყენოს დაბრუნება მართალია გარეთ ხოლო loop?
>> JASON HIRSCHHORN: მე არ ვიცი.
გსურთ ჩემთვის?
>> აუდიტორია: არასოდეს იბადება.
პოსტები
>> JASON HIRSCHHORN: Akshar?
>> აუდიტორია: მე ვფიქრობ, თქვენ ნიშნავდა დააყენა დაბრუნების ცრუ დასასრულს
საქართველოს ხოლო loop.
>> JASON HIRSCHHORN: ასე რომ, სადაც გინდა წასვლა?
>> აუდიტორია: Like გარეთ ხოლო loop.
ასე რომ, თუ გასასვლელად ხოლო loop ნიშნავს რომ თქვენ მიაღწია ბოლოს და
არაფერი მოხდა.
>> JASON HIRSCHHORN: OK.
ასე რომ, რას ვაკეთებთ აქ?
>> აუდიტორია: თქვენ დაბრუნების ცრუ იქ.
>> JASON HIRSCHHORN: Oh, ჩვენ ამის გაკეთება ორივეგან?
>> აუდიტორია: Yeah.
>> JASON HIRSCHHORN: OK.
უნდა წავიდეთ?
Oh ჩემი სიკეთე.
მე ბოდიში.
მე ბოდიშს ეკრანზე.
ეს არის სახის freaking გარეთ ჩვენზე.
ასე რომ, აირჩიეთ ვარიანტი.
Zero, თითო კოდი, ტოვებს პროგრამა.
ერთი ჩანართები რაღაც.
მოდით ჩადეთ სამი.
ჩანართით არ იყო წარმატებული.
მე ვაპირებ ამობეჭდოთ.
მე არ მაქვს არაფერი.
OK.
იქნებ ეს იყო მხოლოდ fluke.
ჩადეთ ერთი.
არ არის წარმატებული.
OK.
მოდით აწარმოებს მეშვეობით GDB მართლაც სწრაფად შეამოწმეთ, თუ რა ხდება.
>> დამახსოვრება GDB. / სახელი თქვენი პროგრამა იღებს us შევიდა GDB.
არის, რომ ბევრი გაუმკლავდეს?
Flashing?
ალბათ.
თვალები დახუჭე და რამდენიმე ღრმა breaths თუ თქვენ დაიღალა
ეძებს მას.
მე GDB.
რა არის პირველი რამ გავაკეთო GDB?
ჩვენ მივიღეთ გაერკვნენ რა ხდება აქ.
ვნახოთ.
ჩვენ ექვსი წუთი ფიგურა თუ რა ხდება.
დაარღვიე მთავარი.
და მერე რა გავაკეთო?
Carlos?
აწარმოებს.
OK.
მოდით ავირჩიოთ ვარიანტი.
და რას N გავაკეთოთ?
შემდეგი.
ჰო.
>> აუდიტორია: ჯერ არ თქვენ აღვნიშნო -
არ ამბობთ, რომ ხელმძღვანელი, ეს იყო ინიციალიზაცია to null დასაწყისში.
მაგრამ ვფიქრობდი, თქვენ განაცხადეთ, რომ OK.
>> JASON HIRSCHHORN: წამო - მოდით შევხედოთ in GDB, და მაშინ ჩვენ დავბრუნდებით.
მაგრამ ეს ჟღერს თქვენ უკვე გაქვთ გარკვეული იდეები, თუ რა ხდება.
ასე რომ ჩვენ გვინდა ჩადეთ რამე.
OK.
ჩვენ ჩადეთ.
გთხოვთ შეიყვანოთ int.
ჩვენ ჩადეთ სამი.
და შემდეგ მე ამ ხაზის.
როგორ შემიძლია წასვლა დაიწყება გამართვის ჩანართით ცნობილი ფუნქცია?
Oh ჩემი სიკეთე.
რომ ბევრი.
ის არის, რომ freaking გარეთ ბევრი?
>> აუდიტორია: Oh, ის გარდაიცვალა.
>> JASON HIRSCHHORN: I just გამოყვანილია იგი out.
OK.
>> აუდიტორია: შესაძლოა ის ჩაეგდო მავთული.
>> JASON HIRSCHHORN: Wow.
ასე რომ, დედააზრი -
რა ვთქვა?
>> აუდიტორია: მე ვთქვი, ირონია ტექნიკური სირთულეები ამ კლასში.
>> JASON HIRSCHHORN: ვიცი.
თუ მხოლოდ მე მქონდა კონტროლი, რომ ნაწილი.
[INAUDIBLE]
რომ ჟღერს დიდი.
რატომ არ ბიჭები დაიწყოს ფიქრი რა ვქნათ, რა დავაშავეთ,
და ჩვენ დავბრუნდებით 90 წამში.
>> Avica, მე ვაპირებ გთხოვოთ, თუ როგორ უნდა წავიდეს შიგნით insert_node გამართვის იგი.
ასე რომ, ეს არის, სადაც ჩვენ ბოლო შეჩერდით.
როგორ შემიძლია წასვლა შიგნით insert_node, Avica, შეისწავლოს, თუ რა ხდება?
რა GDB ბრძანება?
Break არ მიიღებს me შიგნით.
ჯერ Marquise იცით?
>> აუდიტორია: What?
>> JASON HIRSCHHORN: რა GDB ბრძანება გამოვიყენო წავიდეთ შიგნით ამ ფუნქციას?
>> აუდიტორია: ნაბიჯი?
>> JASON HIRSCHHORN: Step via S. რომ იღებს me შიგნით.
OK.
New_node mallocing გარკვეული ფართი.
რომ ყველა გამოიყურება მისი აპირებს.
მოდით, შევხედოთ new_node.
მას გარკვეული მეხსიერება მისამართზე.
შევამოწმოთ -
რომ არის სწორი.
ასე რომ, ყველაფერი აქ, როგორც ჩანს, სამუშაო სწორად.
>> აუდიტორია: რა არის განსხვავება შორის P და ჩვენება?
>> JASON HIRSCHHORN: P დგას ბეჭდვითი.
და ა.შ. თქვენ გეკითხებით რა განსხვავება და ეს?
ამ შემთხვევაში, არაფერი.
მაგრამ ზოგადად არსებობს გარკვეული განსხვავებები.
და თქვენ უნდა გამოიყურებოდეს GDB სახელმძღვანელო.
მაგრამ ამ შემთხვევაში, არაფერი.
ჩვენ ტენდენცია გამოიყენოს ბეჭდვითი, თუმცა იმის გამო, ჩვენ არ უნდა გავაკეთოთ ბევრად მეტი, ვიდრე
ბეჭდვა ერთი ღირებულება.
>> OK.
ასე რომ, ჩვენ on line 80 ჩვენი კოდი შექმნის კვანძის * Curr ტოლია სიაში.
მოდით ამობეჭდოთ Curr.
ის ტოლია სიაში.
ტკბილი.
დაველოდოთ.
ეს უდრის რაღაც.
რომ არ ჩანს უფლება.
იქ ჩვენ წავიდეთ.
ეს იმიტომ, რომ ამ GDB, უფლება, თუ ეს ხაზი თქვენ ეს
არ აღსრულებულა.
ასე რომ თქვენ უნდა რეალურად აკრიფოთ შემდეგი შეასრულოს ხაზი
ადრე ხედავს მის შედეგებს.
ასე რომ აქ ვართ.
ჩვენ მხოლოდ შესრულებული ამ ხაზის, წინა ტოლია null.
ასე რომ კიდევ ერთხელ, თუ ჩვენ ბეჭდვა წინა ჩვენ ვერ ვხედავთ არაფერს, უცნაური.
მაგრამ თუ ჩვენ რეალურად შეასრულოს, რომ ხაზი, მაშინ ვნახავთ
, რომ ხაზი მუშაობდა.
>> ამიტომ, ჩვენ უნდა Curr.
ეს არის ორივე კარგი.
უფლება?
ახლა ჩვენ ამ ხაზის უფლება აქ.
მიუხედავად იმისა, რომ Curr არ თანაბარი null.
ისე, რას Curr ტოლია?
ჩვენ უბრალოდ დაინახა იგი შეადგენდა null.
ჩვენ დაბეჭდილი იგი out.
მე ამობეჭდოთ ისევ.
ამიტომ არის, რომ სანამ loop აპირებს შეასრულოს?
>> აუდიტორია: არა
>> JASON HIRSCHHORN: ასე რომ, როდესაც მე აკრეფილი, რომ ხაზი, ხედავთ ჩვენ გადახტა ყველა გზა
ქვემოთ ბოლოში, დაბრუნების ცრუ.
და მაშინ ჩვენ ვაპირებთ დაბრუნებას ყალბი და დავუბრუნდეთ ჩვენი პროგრამა და
საბოლოოდ ამობეჭდოთ, როგორც ვნახეთ, ჩანართით არ იყო წარმატებული.
ასე რომ, ვინმეს გაქვთ რაიმე იდეები, თუ რა ჩვენ უნდა გავაკეთოთ დაფიქსირება ამ?
მე ვაპირებ დაველოდოთ ვხედავ რამდენიმე ხელში ახვიდეთ.
ჩვენ არ შეასრულოს ეს.
გაითვალისწინეთ, ეს იყო პირველი რამ ვაკეთებდით.
მე არ ვაპირებ გავაკეთოთ რამოდენიმე.
მე ვაპირებ ამის გაკეთებას რამდენიმე.
იმის გამო, რომ რამდენიმე ნიშნავს ორი.
მე ლოდინი ორზე მეტი.
>> პირველი ჩანართი, Curr, by default შეადგენს null.
და ამ მარყუჟის მხოლოდ ახორციელებს თუ Curr არ null.
ასე რომ, როგორ შემიძლია გარშემო?
მე ვხედავ სამი ხელში.
მე დაველოდოთ უმეტეს სამი.
Marcus, რას ფიქრობთ?
>> აუდიტორია: ისე, თუ სჭირდება შეასრულოს კიდევ ერთხელ, თქვენ უბრალოდ
შეცვალოთ ეს do-ხოლო loop.
>> JASON HIRSCHHORN: OK.
იქნება, რომ გადაწყვიტოს ჩვენი პრობლემა, თუმცა?
>> აუდიტორია: ამ შემთხვევაში არ არის, რადგან ის ფაქტი, რომ სია ცარიელია.
ასე რომ, მაშინ, ალბათ, მხოლოდ უნდა დაამატოთ განცხადება, რომ იმ შემთხვევაში, თუ loop გამოსვლა
მაშინ თქვენ უნდა იყოს დასასრულს სიაში, სადაც წერტილი თქვენ
შეგიძლიათ უბრალოდ ჩადეთ იგი.
>> JASON HIRSCHHORN: მომწონს, რომ.
ეს აზრი.
იმ შემთხვევაში, თუ loop გასასვლელების -
იმიტომ, რომ თქვენ დაბრუნების ცრუ აქ.
ასე რომ, თუ loop გასასვლელების, მაშინ ჩვენ at ბოლოს სიაში, ან იქნებ
დავიწყოთ სიაში, თუ არსებობს არაფერი ის, რაც არის იგივე, რაც ბოლომდე.
ახლა ჩვენ გვინდა ჩადეთ რაღაც აქ.
მაშ როგორ ამჯამად რომ კოდი გამოიყურება, Marcus?
>> აუდიტორია: თუ თქვენ უკვე კვანძის malloced, შეგიძლიათ უბრალოდ, ვამბობთ
new_node-> მომავალი შეადგენს null რადგან ეს უნდა იყოს დასასრულს.
ან new_node-> მომავალი შეადგენს null.
>> JASON HIRSCHHORN: OK.
უკაცრავად.
New_node-> მომავალი შეადგენს null რადგან ჩვენ დასასრულს.
რომ არ განათავსოთ შემოსული
როგორ უნდა დააყენოს ის სიაში?
უფლება.
ეს მხოლოდ განსაზღვრავს ის ტოლია.
არარის როგორ უნდა რეალურად ამას სიაში?
რა მიუთითებს სიის ბოლოში?
>> აუდიტორია: Head.
>> JASON HIRSCHHORN: უკაცრავად?
>> აუდიტორია: Head მიუთითებს ბოლომდე სიაში.
>> JASON HIRSCHHORN: თუ არსებობს არაფერი სიაში, ხელმძღვანელი მიუთითებს
სიის ბოლოში.
ასე რომ ვიმუშავებთ პირველი ჩანართი.
რაც შეეხება, თუ არსებობს რამდენიმე რამ სიაში?
ვიდრე ჩვენ არ გვინდა, რომ მითითებული უხელმძღვანელებს ტოლია new_node.
რა გვინდა იქ?
ჰო?
ალბათ წინა.
იქნება, რომ მუშაობს?
შეგახსენებთ, რომ წინა მხოლოდ მომცეთ კვანძში.
და წინა ადგილობრივი ცვლადი.
ასე რომ, ეს ხაზი იქნება ადგილობრივი ცვლადი, წინა, ტოლია ან
მიუთითებს ამ ახალი კვანძში.
რომ არ რეალურად დააყენოს ის ჩვენს სიაში, თუმცა.
როგორ უნდა დააყენოს ის ჩვენს სიაში?
Akchar?
>> აუდიტორია: მე ვფიქრობ, თქვენ ამის გაკეთება მიმდინარე> მომავალი.
>> JASON HIRSCHHORN: OK.
Curr> მომავალი.
ასე რომ კიდევ ერთხელ, ერთადერთი მიზეზი ჩვენ ქვემოთ აქ არის, რას მიმდინარე ტოლია?
>> აუდიტორია: უდრის null.
>> JASON HIRSCHHORN: და მერე რა მოხდება, თუ ჩვენ გავაკეთებთ null> შემდეგი?
რას აპირებს მიიღოს?
ჩვენ კიდევ სეგმენტაცია ბრალია.
>> აუდიტორია: Do Curr შეადგენს null.
>> JASON HIRSCHHORN: ეს იგივე როგორც prev, თუმცა, რადგან არსებობს
ადგილობრივი ცვლადი ჩვენ შექმნის ტოლი ახალ კვანძში.
მოდით დავუბრუნდეთ ჩვენს სურათზე ჩასმა რაღაც.
ამბობენ, რომ ჩვენ ჩასმა დასასრულს სიაში, ასე რომ უფლება აქ.
ჩვენ გვაქვს მიმდინარე მაჩვენებელი, მიუთითებს null და previous წერტილი
რომ მიუთითებს 8.
ასე რომ, რას უნდა განახლდეს, Avi?
>> აუდიტორია: წინა> შემდეგი?
>> JASON HIRSCHHORN: წინა> შემდეგი არის რა ჩვენ გვინდა განაახლოთ იმიტომ, რომ
რეალურად ჩადეთ იგი დასასრულს სიაში.
ჩვენ ჯერ კიდევ გვაქვს ერთი bug, თუმცა, რომ ჩვენ ვაპირებთ გადაეყარონ.
რა არის, რომ bug?
ჰო?
>> აუდიტორია: ეს დაბრუნებას აპირებს ცრუ ამ შემთხვევაში?
>> JASON HIRSCHHORN: Oh, არის არის დაბრუნებას აპირებს ყალბი.
მაგრამ არსებობს კიდევ ერთი შეცდომა.
ამიტომ ჩვენ უნდა დააყენოს დაბრუნების ჭეშმარიტი.
>> აუდიტორია: არა წინა მაინც თანაბარი null ზედა სიაში?
>> JASON HIRSCHHORN: So წინა მაინც შეადგენს null თავიდანვე.
ასე როგორ შეიძლება ჩვენ მიიღოს მეტი, რომ?
ჰო?
>> აუდიტორია: ვფიქრობ, თქვენ შეგიძლიათ ეს გააკეთოთ გამშვები ადრე ხოლო loop თუ ის
ცარიელი სია.
>> JASON HIRSCHHORN: OK.
მოდით წავიდეთ აქ.
გავაკეთოთ ქვითარი.
იმ შემთხვევაში, თუ -
>> აუდიტორია: ასე რომ, თუ ხელმძღვანელი უდრის უდრის null.
>> JASON HIRSCHHORN: თუ უფროსი უდრის უდრის null -
რომ ყველაფერს გვეუბნება, თუ ის ცარიელი სია.
>> აუდიტორია: და მაშინ გავაკეთოთ ხელმძღვანელი შეადგენს ახალი.
>> JASON HIRSCHHORN: Head შეადგენს new_node?
და რა არ უნდა გავაკეთოთ?
>> აუდიტორია: და მაშინ იქნება TRUE.
>> JASON HIRSCHHORN: არ არის საკმაოდ.
ჩვენ დაკარგული ერთი ნაბიჯია.
>> აუდიტორია: New_node შემდეგი უნდა აღვნიშნო, რომ null.
>> JASON HIRSCHHORN: ზუსტად, Alden.
და მაშინ ჩვენ შეგვიძლია იქნება TRUE.
OK.
მაგრამ მაინც კარგი იდეა უნდა გავაკეთოთ რამ, დასასრულს სიაში, უფლება?
ყველა უფლება.
ჩვენ ჯერ კიდევ შეიძლება რეალურად მიიღონ ბოლომდე სიაში.
ამიტომ არის ეს კოდი ჯარიმა, თუ ჩვენ იმ სიის ბოლოში და არსებობს
რამ სიაში?
უფლება?
იმის გამო, რომ ჩვენ ჯერ კიდევ გვაქვს Marcus იდეა.
ჩვენ შეიძლება გაითიშება ამ loop რადგან ჩვენ დასასრულს სიაში.
ასე რომ ჩვენ მაინც გვინდა ეს კოდი ქვემოთ აქ?
>> აუდიტორია: დიახ.
>> JASON HIRSCHHORN: ჰო.
და რას უნდა შეიცვალოს ეს?
ასეა.
აკეთებს, რომ ხმის კარგი ყველას აქამდე?
არავის აქვს არც -
Avi, გაქვთ რაიმე დასამატებელი?
>> აუდიტორია: არა
>> JASON HIRSCHHORN: OK.
ასე რომ, ჩვენ გავაკეთეთ რამდენიმე ცვლილებები.
ჩვენ ეს გამშვები სანამ ჩვენ წავიდა განთავსების ცარიელი სია.
ამიტომ ჩვენ ზრუნვა ცარიელი სია.
და აქ ჩვენ იზრუნა ჩასმა რაღაც დასასრულს სიაში.
ასე რომ, როგორც ჩანს, ამ ხოლო loop აყვანა ზრუნვა რამ შორის,
სადღაც სიაში, თუ არსებობს რამ სიაში.
>> OK.
მოდით აწარმოებს ამ პროგრამის ერთხელ.
არ არის წარმატებული.
>> აუდიტორია: თქვენ არ მიიღოს იგი.
>> JASON HIRSCHHORN: Oh, მე არ მიიღოს იგი.
კარგი წერტილი, მაიკლ.
მოდით დაამატოთ მიიღოს უკავშირდება.
Line 87 იქ შეცდომა.
Line 87.
Alden, ეს იყო ონლაინ მომეცით.
რა არის არასწორი?
>> აუდიტორია: ეს უნდა იყოს null.
>> JASON HIRSCHHORN: Excellent.
სწორედ.
ეს უნდა იყოს null.
მოდით კიდევ ერთხელ.
შეადგინოს.
OK.
მოდით ჩადეთ სამი.
ჩანართით წარმატებული იყო.
მოდით ამობეჭდოთ.
ოჰ, თუ მხოლოდ ჩვენ შეგვიძლია შეამოწმოს.
მაგრამ ჩვენ არ კეთდება ბეჭდვა ფუნქცია არავის გაუკეთებია.
მოდით შეიყვანოთ რაღაც.
რა უნდა შევიდეს?
>> აუდიტორია: შვიდი.
>> JASON HIRSCHHORN: Seven?
>> აუდიტორია: დიახ.
>> JASON HIRSCHHORN: ჩვენ გვყავს seg ბრალია.
ამიტომ მივიღეთ, მაგრამ ჩვენ ნათლად ვერ ორი.
ეს არის 5:07.
ასე რომ, ჩვენ შეიძლება გამართვის ამ სამი წუთის განმავლობაში.
მაგრამ მე ვაპირებ რომ დატოვოთ აქ და გადაადგილება, რათა hash მაგიდები.
მაგრამ ერთხელ, პასუხი ეს კოდი მე მქონ ეს თქვენ ცოტა.
ჩვენ ძალიან ახლოს.
უაღრესად გარწმუნებთ, რომ გაერკვნენ რა ხდება აქ და გაასწორონ ის.
ასე რომ მე მქონ თქვენ ამ კოდექსის ისევე პლუს გადაწყვეტა -
ალბათ გამოსავალი მოგვიანებით.
პირველი ეს კოდი.
>> სხვა რამ მინდა გავაკეთოთ სანამ ჩვენ დასრულება ჩვენ არ გაათავისუფლა არაფერი.
ასე რომ, მე მინდა გაჩვენოთ რა Valgrind ჰგავს.
თუ ჩვენ აწარმოებს Valgrind საზღვრები ჩვენი პროგრამა. / უკავშირდება.
ერთხელ, შესაბამისად, ამ slide, ჩვენ უნდა აწარმოებს Valgrind ზოგიერთი ტიპის
ვარიანტი, ამ შემთხვევაში - გაჟონვის შემოწმება = სავსე.
მოდით დავწეროთ Valgrind - გაჟონვის შემოწმება = სავსე.
ასე რომ, ეს აწარმოებს Valgrind ჩვენი პროგრამა.
და ახლა პროგრამის რეალურად გადის.
ამიტომ, ჩვენ ვაპირებთ, რომ აწარმოებს, ისევე, ადრე, დააყენა რაღაც შემოსული
მე ვაპირებ დააყენა სამი.
რომ მუშაობს.
მე არ ვაპირებ ცდილობენ რაღაც სხვაგან, რადგან ჩვენ ვაპირებთ
მიიღეთ seg ცრუ ამ შემთხვევაში.
ასე რომ მე უბრალოდ აპირებს დატოვა.
>> და ახლა ხედავთ ქვემოთ აქ გაჟონვის და ბევრი შემაჯამებელი.
ეს არის კარგი რამ, გსურთ შეამოწმოთ out.
ასე რომ, ბევრი ინფორმაცია - ნათქვამია, გამოყენება ერთი გასასვლელი - რვა bytes ერთი ბლოკი.
რომ ერთი ბლოკი კვანძის ჩვენ malloced.
Michael, თქვენ განაცხადა, კვანძის რვა ნაკბენები, რადგან მას მთელი რიცხვი
და მაჩვენებელი.
ასე რომ ჩვენი კვანძში.
და მერე ამბობს, რომ ჩვენ malloc შვიდჯერ და ჩვენ გაათავისუფლა
რაღაც ექვსჯერ.
მაგრამ ჩვენ არასოდეს მოუწოდა უფასოდ, ასე რომ მე არ მაქვს ვიცი რა ეს ლაპარაკი.
>> მაგრამ საკმარისია ვთქვა, რომ როდესაც თქვენი პროგრამა ეშვება, malloc მიმდინარეობს მოუწოდა
ზოგიერთ სხვა ადგილებში, რომ ჩვენ არ უნდა ფიქრი.
ასე malloc ალბათ მოუწოდა ზოგან.
ჩვენ არ უნდა ფიქრი, სადაც.
მაგრამ ეს მართლაც ჩვენთვის.
ეს პირველი ხაზი არის ჩვენთვის.
დავტოვეთ, რომ ბლოკში.
და თქვენ ხედავთ, რომ აქ in გაჟონვის შემაჯამებელი.
ჯერ კიდევ მიუწვდომელია -
რვა bytes ერთი ბლოკი.
ეს ნიშნავს, რომ მეხსიერება -
ჩვენ გაჟონა, რომ მეხსიერებაში.
ნამდვილად დაკარგა -
რაღაც დაკარგულია.
ზოგადად, თქვენ არ ვხედავ რაიმე არსებობს.
ჯერ კიდევ მიუწვდომელია ზოგადად, სადაც თქვენ ნახავთ რამ, სადაც თქვენ გსურთ
გამოიყურება დაინახოს, თუ რა კოდი უნდა არ გაათავისუფლა, მაგრამ დაავიწყდა უფასოდ.
>> და შემდეგ, თუ ეს არ მოხდა, თუ გავაკეთეთ უფასო ყველაფერი,
ჩვენ შეგვიძლია შევამოწმოთ, რომ.
მოდით უბრალოდ გაუშვით პროგრამა არ აყენებს არაფერი.
დაინახავთ ქვემოთ აქ გამოყენება exit -
ნულოვანი bytes ნულოვანი ბლოკები.
ეს ნიშნავს, რომ ჩვენ არაფერი დარჩა როდესაც ამ პროგრამის დასრულების.
ასე რომ, სანამ გარდამტეხ pset6, აწარმოებს Valgrind და დარწმუნდით, რომ თქვენ არ გაქვთ
ნებისმიერი მეხსიერების გაჟონვის თქვენს პროგრამას.
თუ თქვენ გაქვთ რაიმე შეკითხვებს Valgrind, მოგერიდებათ მივაწვდინოთ.
მაგრამ ეს არის, თუ როგორ გამოიყენოს იგი.
ძალიან მარტივია - თუ თქვენ აქვს გამოყენების exit -
ნებისმიერი bytes ნებისმიერ ბლოკები.
>> ასე რომ, ჩვენ მუშაობდა ჩადეთ კვანძში.
მე მქონდა ორი სხვა ფუნქციები აქ - ბეჭდვა კვანძების და თავისუფალი კვანძების.
ისევ და ისევ, ეს არის ფუნქციები, რომლებიც იქნება კარგი თქვენთვის პრაქტიკაში
იმიტომ, რომ ისინი დაგეხმარებათ არა მხოლოდ ეს ნიმუში წვრთნები, არამედ
პრობლემა შეიქმნა.
ისინი რუკა საკმაოდ მჭიდროდ რამ თქვენ აპირებთ უნდა გავაკეთოთ
პრობლემა კომპლექტი.
მაგრამ მე გვინდა დავრწმუნდეთ ჩვენ შევეხებით ყველაფერს.
და hash მაგიდები ასევე მნიშვნელოვანია რას ვაკეთებთ ნაწილში ამ
week - ან პრობლემა კომპლექტი.
>> ამიტომ, ჩვენ ვაპირებთ, რომ დაასრულოს განყოფილებაში ვსაუბრობთ hash მაგიდები.
თუ თქვენ შეამჩნევთ მე მივიღე პატარა hash მაგიდასთან.
ეს არ არის ის, რაც ჩვენ ვსაუბრობთ შესახებ, თუმცა.
ჩვენ ვსაუბრობთ სხვადასხვა ტიპის hash მაგიდები.
და მისი ძირითადი, hash მაგიდა მეტი არაფერი
array plus ქეშირების ფუნქცია.
ჩვენ ვაპირებთ, რომ გაიგო ცოტა უბრალოდ დარწმუნდით, რომ ყველას ესმის, თუ რა
hash ფუნქცია.
და მე გეუბნებით, რომ ეს არის მეტი არაფერი ორი რამ -
array და ქეშირების ფუნქცია.
და აქ არის ნაბიჯები მეშვეობით რომელიც ამ მუშაობს.
>> იქ ჩვენი მასივი.
იქ ჩვენი ფუნქცია.
კერძოდ, hash ფუნქციები უნდა ამის გაკეთება რამდენიმე რამ ამ.
მე ვაპირებ გაიგო კონკრეტულად ამ პრობლემის შესახებ მითითებული.
ის ალბათ აპირებს მიიღოს სიმებიანი.
და რა არის ის დაბრუნებას აპირებს?
რა მონაცემები ტიპის?
Alden?
თქვენი ქეშირების ფუნქცია დაბრუნებას?
მთელი რიცხვი.
ასე რომ, ეს არის ის, რაც hash მაგიდა შედგება -
მაგიდა სახით array და ქეშირების ფუნქცია.
როგორ მუშაობს?
იგი მუშაობს სამი ნაბიჯი.
ჩვენ ეს გასაღები.
ამ შემთხვევაში, ჩვენ მისთვის string.
ჩვენ მოვუწოდებთ ქეშირების ფუნქცია თითო ნაბიჯი ერთი გასაღები და მივიღებთ ღირებულება.
>> კერძოდ, ჩვენ ვიტყვით, მივიღებთ რიცხვი.
ეს რიცხვი, არსებობს ძალიან კონკრეტული შეზღუდვები რა რომ მთელი რიცხვი უნდა იყოს.
ამ მაგალითში, ჩვენი მასივი არის ზომა სამი.
ასე რომ, რა რაოდენობით შეიძლება რომ მთელი რიცხვი უნდა იყოს.
რა არის სპექტრი მოქმედებს ღირებულებების რომ რიცხვი, დაბრუნების ტიპის ამ
ქეშირების ფუნქცია?
Zero, ერთი და ორი.
წერტილი hash ფუნქცია გაერკვნენ ადგილი მასივი
სადაც ჩვენი გასაღები აპირებს.
არსებობს მხოლოდ სამი შესაძლო ადგილები აქ -
ნულოვანი, ერთი, ან ორი.
ასე რომ, ამ ფუნქციის უკეთ დაბრუნება ნულოვანი, ერთი, ან ორი.
საპატიო indice ამ მასივი.
>> და შემდეგ დამოკიდებულია სადაც ის დააბრუნებს, ხედავთ array ღია
Bracket ღირებულება.
რომ სადაც ჩვენ გასაღები.
ასე რომ, ჩვენ ჩააგდოს გოგრა, ჩვენ გავიდნენ ნულოვანი.
ამავე მასივი bracket 0, ჩვენ გოგრა.
ჩვენ სახიფათოა, კატა, ჩვენ გავიდნენ ერთი.
ჩვენ დააყენა cat ერთი.
ჩვენ დააყენა spider.
ჩვენ გავიდნენ ორი.
ჩვენ spider at მასივი bracket ორი.
ეს იქნება ასე ლამაზი თუ იგი მუშაობდა როგორიცაა, რომ.
მაგრამ, სამწუხაროდ, როგორც ვნახავთ, ეს ცოტა უფრო რთული.
>> სანამ არ მივიღებთ იქ რაიმე შეკითხვები ამ საბაზისო
გაშვება of hash მაგიდასთან?
ეს არის იმიჯი ზუსტად რაც ჩვენ გაამახვილა ფორუმში.
მაგრამ რადგან ჩვენ ამოიღო ფორუმში, I არ ვაპირებ წასვლას მის შემდგომ.
არსებითად გასაღებები, ჯადოსნური black box - ან ამ შემთხვევაში, teal box - ერთი
ქეშირების ფუნქცია აყენებს მათ თაიგულების.
და ამ მაგალითში ჩვენ არ აყენებს სახელი.
ჩვენ აყენებს ასოცირებული ტელეფონი ნომერი სახელწოდების bucket.
მაგრამ თქვენ შეიძლება ძალიან კარგად მხოლოდ ამით სახელი bucket.
>> ეს არის მხოლოდ სურათს რა ჩვენ გაამახვილა ფორუმში.
ჩვენ პოტენციური pitfalls, თუმცა.
და არსებობს ორი კერძოდ სლაიდები, რომ მე მინდა მეტი.
პირველი არის ქეშირების ფუნქცია.
ამიტომ მე ვკითხე კითხვაზე, თუ რა რაც კარგი ქეშირების ფუნქცია?
მე ვაძლევ ორი ​​პასუხი.
პირველი არის ის, რომ დეტერმინისტული.
კონტექსტში hash ფუნქციები, რას ნიშნავს ეს?
დიახ?
>> აუდიტორია: ეს შეგიძლიათ index მუდმივ დრო?
>> JASON HIRSCHHORN: ეს არ არის რას ნიშნავს.
მაგრამ ეს კარგი ამოიცნობთ.
ვინმეს აქვს ამოიცნობთ რა ეს იმას ნიშნავს,?
რომ კარგი ქეშირების ფუნქცია არის დეტერმინისტული?
Annie?
>> აუდიტორია: ეს გასაღები შეიძლება მხოლოდ mapped ერთი ადგილი hash მაგიდასთან.
>> JASON HIRSCHHORN: ეს სწორედ.
ყოველ დროს, თქვენ დააყენა გოგრა, ის ყოველთვის ბრუნდება ნულოვანი.
თუ თქვენ დააყენა გოგრა და თქვენი hash ფუნქცია დააბრუნებს ნულოვანი მაგრამ აქვს
ალბათობა დაბრუნების რაღაც სხვაგან მეტი ნულოვანი -
იქნებ მას შეუძლია დაბრუნდეს ერთ ზოგჯერ ან ორი სხვა - ჯერ
რომ არ არის კარგი ქეშირების ფუნქცია.
თქვენ ზუსტად უფლება.
თქვენი ქეშირების ფუნქცია უნდა დაუბრუნდეს იგივე ზუსტი რიცხვი, ამ შემთხვევაში,
იგივე ზუსტი სიმებიანი.
>> იქნებ ის დააბრუნებს იგივე ზუსტი რიცხვი იმავე ზუსტი string
მიუხედავად კაპიტალიზაცია.
მაგრამ ამ შემთხვევაში მაინც დეტერმინისტული რადგან მრავალი რამ
მოდელი მოვარგოთ იგივე ღირებულება.
ეს ჯარიმა.
რადგან არსებობს მხოლოდ ერთი გამომავალი მოცემული შეყვანის.
>> OK.
მეორე ის არის, რომ ეს ბრუნდება ძალაშია მაჩვენებლები.
ჩვენ მოუტანა, რომ ადრე.
ამ ქეშირების ფუნქცია -
oh boy -
ქეშირების ფუნქცია უნდა დაბრუნებას ძალაშია მაჩვენებლები.
ასე ამბობენ -
მოდით დავუბრუნდეთ ამ მაგალითს.
ჩემი ქეშირების ფუნქცია ითვლის up წერილები სიტყვა.
სწორედ ქეშირების ფუნქცია.
და დააბრუნებს, რომ რიცხვი.
ასე რომ, თუ მე მაქვს სიტყვა, ის დაბრუნებას აპირებს ერთი.
და ის აპირებს დააყენოს უფლება აქ.
რა მოხდება, თუ მე ზუსტად სიტყვა bat?
ის დაბრუნებას აპირებს სამი.
სად bat წავიდეთ?
>> ეს არ ჯდება.
მაგრამ ეს უნდა წავიდეს სადმე.
ეს არის ჩემი hash table შემდეგ, და ყველაფერი უნდა წავიდეს სადმე.
ასე რომ, სადაც უნდა bat წავიდეთ?
ნებისმიერი აზრები?
მიხვდება?
კარგი შთაბეჭდილებები?
>> აუდიტორია: Zero.
>> JASON HIRSCHHORN: რატომ ნულოვანი?
>> აუდიტორია: იმიტომ, რომ სამი modulo სამი ნულოვანი?
>> JASON HIRSCHHORN: სამი modulo სამი არის ნული.
რომ არის დიდი ვხვდები, და ეს სწორია.
ასე რომ, ამ შემთხვევაში ეს უნდა ალბათ წასვლა ნულოვანი.
ასე რომ კარგი გზა, რათა უზრუნველყოს, რომ ეს hash ფუნქცია მხოლოდ ბრუნდება ძალაშია ინდექსების არის
to Modulo მას ზომის მაგიდაზე.
თუ თქვენ Modulo რასაც ამ ბრუნდება მიერ სამი, თქვენ ყოველთვის აპირებს მიიღოს
რაღაც შორის ნულოვანი, ერთი და ორი.
და თუ ეს ყოველთვის ბრუნდება შვიდი, და თქვენ ყოველთვის Modulo სამი, თქვენ
ყოველთვის აპირებს მიიღოს იგივე.
>> ასე რომ, ჯერ კიდევ დეტერმინისტული თუ Modulo.
მაგრამ ეს იმისთვის, რომ თქვენ არასოდეს მიიღოთ რაღაც -
არასწორი ინდუსტრიაში.
საერთოდ, რომ modulo უნდა მოხდეს თქვენს ქეშირების ფუნქცია.
ასე რომ თქვენ არ გჭირდებათ ფიქრი ეს.
თქვენ უბრალოდ შეგიძლიათ უზრუნველყოს, რომ ეს არის სწორი indice.
ნებისმიერი შეკითხვა ამ პოტენციური pitfall?
>> OK.
და იქ ჩვენ წავიდეთ.
შემდეგი პოტენციური pitfall და ეს არის დიდი ერთი.
რა მოხდება, თუ ორ კლავიშს რუკა იგივე მნიშვნელობა?
ასე რომ, არსებობს ორი გზა გაუმკლავდეს ამ.
პირველი ეწოდება წრფივი საცდელი, რომელიც მე
არ ვაპირებ წასვლა მეტი.
მაგრამ თქვენ უნდა იცნობს, თუ როგორ რომელიც მუშაობს და რა, რომ არის.
>> მეორე ვაპირებ წასვლა მეტი იმიტომ, რომ ის არის, რომ ბევრი
ადამიანი სავარაუდოდ დასრულდება მდე გადამწყვეტი გამოყენება მათი პრობლემა კომპლექტი.
რა თქმა უნდა, არ უნდა.
მაგრამ პრობლემა კომპლექტი, ბევრი ადამიანი ტენდენცია აირჩიოს შევქმნათ hash table
ცალკე chaining განხორციელება მათი ლექსიკონი.
ამიტომ, ჩვენ ვაპირებთ წასვლა რას ნიშნავს შევქმნათ hash მაგიდა
ცალკე chaining.
>> ასე რომ, მე დააყენა გოგრა.
ის დააბრუნებს ნულოვანი.
და მე ზუსტად გოგრა აქ.
მერე დასვა -
რა არის კიდევ ერთი ჰელოუინი-themed რამ?
>> აუდიტორია: Candy.
>> JASON HIRSCHHORN: Candy!
სწორედ დიდი ერთი.
მე ზუსტად Candy, და კანფეტი ასევე მაძლევს ნულოვანი.
რა გავაკეთო?
ნებისმიერი იდეები?
იმიტომ, რომ თქვენ ყველა სახის ვიცი რა ცალკე chaining არის.
ასე რომ ნებისმიერი იდეები რა უნდა გავაკეთოთ?
ჰო.
>> აუდიტორია: ჩვენ სიმებიანი რეალურად hash მაგიდასთან.
>> JASON HIRSCHHORN: ასე რომ, ჩვენ ვაპირებთ მიაპყროს კარგი იდეა აქ.
OK.
>> აუდიტორია: Have hashtable [INAUDIBLE]
მაჩვენებელი, რომელიც მიუთითებს დასაწყისში სიაში.
და შემდეგ არ გოგრა იქნება პირველი ღირებულება რომ უკავშირდება სიაში და კამფეტი იქნება
მეორე მნიშვნელობა, რომელიც უკავშირდება სიაში.
>> JASON HIRSCHHORN: OK.
Marcus, რომ იყო გამორჩეული.
მე ვაპირებ დაარღვიოს, რომ ქვემოთ.
მარკუს ამბობს, არ გადაწერა გოგრა.
ეს იქნება ცუდი.
არ დააყენა candy სხვაგან.
ჩვენ ვაპირებთ, რომ ამით მათ, როგორც ნულოვანი.
მაგრამ ჩვენ ვაპირებთ გამკლავება აყენებს მათ ნულოვანი მიერ
შექმნა სია ნულოვანი.
და ჩვენ ვაპირებთ, რომ შევქმნათ სია ყველაფერი, რაც mapped ნულოვანი.
და საუკეთესო გზა გავიგეთ, რომ შევქმნათ სია, რომელიც შეიძლება გაიზარდოს და შემცირება
დინამიურად არ შედის კიდევ ერთი მასივი.
ასე რომ, არა მრავალ განზომილებიანი მასივი.
მაგრამ მხოლოდ შექმნა უკავშირდება სიაში.
>> ასე რომ, რაც მან შესთავაზა -
მე ვაპირებ კიდევ ახალი -
არის შექმნა მასივი პოინტერები, მასივი პოინტერები.
OK.
ნებისმიერი იდეა, ან მინიშნება, თუ რა ტიპის ამ მითითებას უნდა იყოს?
Marcus?
>> აუდიტორია: მითითებას -
>> JASON HIRSCHHORN: იმის გამო, რომ განაცხადა უკავშირდება სიაში, ისე -
>> აუდიტორია: Node მითითებას?
>> JASON HIRSCHHORN: Node პოინტერები.
იმ შემთხვევაში, თუ რამ ჩვენი უკავშირდება სიაში კვანძების შემდეგ ისინი
უნდა იყოს კვანძის პოინტერები.
და რას უდრის თავდაპირველად?
>> აუდიტორია: Null.
>> JASON HIRSCHHORN: Null.
ასე რომ ჩვენი ცარიელია რამ.
Pumpkin ბრუნდება ნულოვანი.
რა ვქნათ?
სიარული ჩემთვის ეს?
სინამდვილეში, Marcus უკვე მომცა.
სხვისი ფეხით ჩემთან მეშვეობით.
რას ვაკეთებთ, როცა ჩვენ -
ეს გამოიყურება ძალიან ჰგავს რაც ჩვენ უბრალოდ აკეთებს.
Avi.
>> აუდიტორია: მე ვაპირებ მიიღოს ამოიცნობთ.
ასე რომ, როდესაც თქვენ candy.
>> JASON HIRSCHHORN: ჰო.
ასევე, მივიღეთ გოგრა.
მოდით მისაღებად ჩვენი პირველი ერთი.
მივიღეთ გოგრა.
>> აუდიტორია: OK.
Pumpkin ბრუნდება ნულოვანი.
ასე, რომ თქვენ ამას, რომ.
ან რეალურად, თქვენ ამას უკავშირდება სიაში.
>> JASON HIRSCHHORN: როგორ გავაკეთოთ ამას უკავშირდება სიაში?
>> აუდიტორია: Oh, ფაქტობრივი სინტაქსი?
>> JASON HIRSCHHORN: Just ფეხით -
ვთქვა მეტი.
რა ვქნათ?
>> აუდიტორია: თქვენ უბრალოდ ჩადეთ მას, როგორც პირველ კვანძში.
>> JASON HIRSCHHORN: OK.
ასე რომ, ჩვენ გვაქვს ჩვენი კვანძის, გოგრა.
და ახლა როგორ უნდა ჩადოთ ეს?
>> აუდიტორია: თქვენ დაავალოს ის მაჩვენებელი.
>> JASON HIRSCHHORN: რომელი მაჩვენებელი?
>> აუდიტორია: The მაჩვენებელი ნულოვანი.
>> JASON HIRSCHHORN: ასე რომ, სადაც აკეთებს ამ ეტაპზე?
>> აუდიტორია: To null ახლა.
>> JASON HIRSCHHORN: ისე, ეს მიუთითებს null.
მაგრამ მე აყენებს გოგრა.
ასე რომ, სადაც უნდა აღვნიშნო?
>> აუდიტორია: იმისათვის, რომ გოგრა.
>> JASON HIRSCHHORN: To გოგრა.
ზუსტად.
ასე რომ, ეს მიუთითებს, რომ გოგრა.
და სად ეს მაჩვენებელი გოგრა წერტილი?
დან
>> აუდიტორია: Null.
>> JASON HIRSCHHORN: To null.
ზუსტად.
ამიტომ ჩვენ უბრალოდ დევს რაღაც შევიდა უკავშირდება სიაში.
ჩვენ უბრალოდ დაწერა ეს კოდი უნდა გავაკეთოთ ეს.
თითქმის ჩვენ თითქმის მივიღე ეს მთლიანად დაბზარულია.
ახლა ჩვენ ჩადეთ candy.
ჩვენი candy ასევე მიდის ნულოვანი.
ასე რომ რას ვაკეთებთ candy?
>> აუდიტორია: ეს დამოკიდებულია თუ არ ჩვენ ვცდილობთ დასალაგებლად ის.
>> JASON HIRSCHHORN: ეს სწორედ.
ეს დამოკიდებულია თუ არა ჩვენ ვცდილობთ, რომ დასალაგებლად ის.
მოდით ვივარაუდოთ, ჩვენ არა ვართ აპირებს დასალაგებლად ის.
>> აუდიტორია: Well შემდეგ, როგორც ჩვენ განვიხილეთ ადრე, ის მარტივი უბრალოდ უნდა დააყენოს ის
უფლება დასაწყისში ასე რომ მომცეთ ნულიდან რაოდენობა candy.
>> JASON HIRSCHHORN: OK.
ჩატარების შესახებ.
ნება მომეცით შექმნა candy უფლება აქ.
ასე რომ, ეს მაჩვენებელი -
>> აუდიტორია: Yeah, ახლა უნდა იქნება მიუთითებს candy.
მაშინ აქვს კურსორი საწყისი candy წერტილი გოგრა.
>> JASON HIRSCHHORN: Like რომ?
და ვთქვათ, ჩვენ მივიღეთ კიდევ ერთი რაც MAP-zero?
>> აუდიტორია: Well, თქვენ უბრალოდ გავაკეთოთ იგივე?
>> JASON HIRSCHHORN: ნუ იგივე.
ასე რომ, ამ შემთხვევაში, თუ ჩვენ არ გვინდა, რომ შევინარჩუნოთ ის დახარისხებული ის
ხმები საკმაოდ მარტივია.
ჩვენ ვიღებთ მაჩვენებელი წელს indice მოცემული ჩვენი ქეშირების ფუნქცია.
ჩვენ იმ ეტაპზე ჩვენი ახალი კვანძში.
და შემდეგ რაც მიუთითებს ადრე -
ამ შემთხვევაში, null, იმ მეორე შემთხვევაში გოგრა -
რომ, რაც მიუთითებს ადრე, ჩვენ დაამატოთ შევიდა უახლოესი
ჩვენი ახალი კვანძში.
ჩვენ ჩასმა რაღაც დასაწყისში.
რეალურად ეს არის ბევრი მარტივი ვიდრე ცდილობს შეინარჩუნოს სია დახარისხებული.
მაგრამ ერთხელ, ძებნას იქნება უფრო რთული აქ.
ჩვენ ყოველთვის უნდა წავიდეს ბოლომდე.
>> OK.
რაიმე შეკითხვები ცალკე chaining?
როგორ, რომ მუშაობს?
გთხოვთ ვთხოვთ ახლა.
მე ნამდვილად მინდა დარწმუნდით ყველა მესმის ეს ადრე ჩვენ უხელმძღვანელებს out.
>> აუდიტორია: რატომ დააყენა გოგრა და კამფეტი შევიდა იმავე
ნაწილი hash table?
>> JASON HIRSCHHORN: კარგი კითხვაა.
რატომ ჩვენ მათ იგივე ნაწილი hash table?
ისე, ამ შემთხვევაში ჩვენი ქეშირების ფუნქცია ანაზღაურება ნულის ორივე მათგანი.
ასე რომ, ისინი უნდა წავიდეთ at indice ნულოვანი იმიტომ, რომ სადაც ჩვენ ვაპირებთ
ვეძებთ მათ, თუ ჩვენ ოდესმე გსურთ ვეძებთ მათ.
ერთხელ, ხაზოვანი საცდელი მიდგომა ჩვენ არ დააყენოს მათ, როგორც ნულოვანი.
მაგრამ ცალკე ჯაჭვი მიდგომა, ჩვენ ვაპირებთ, რომ ამით მათ, როგორც ნულოვანი
და შემდეგ შექმნა ჩამონათვალი off ნულოვანი.
>> და ჩვენ არ გვინდა, რომ გადავაწერო გოგრა უბრალოდ იმის გამო, რომ მაშინ ჩვენ
ვივარაუდოთ, რომ გოგრა იყო არასდროს არ შეიყვანეს.
თუ ჩვენ უბრალოდ შეინახოს ერთი რამ ადგილმდებარეობა რომ იქნებოდა ცუდი.
მაშინ არ იქნება chance of us ოდესმე -
თუ ჩვენ ოდესმე დუბლიკატი, მაშინ ჩვენ უბრალოდ წაშალოს ჩვენი თავდაპირველი ღირებულება.
ასე რომ, რატომ ვაკეთებთ ამ მიდგომას.
ან ამიტომაც ჩვენ ვირჩევთ - მაგრამ ერთხელ, ჩვენ აირჩია ცალკე chaining მიდგომა,
რომელიც არსებობს მრავალი სხვა მიდგომები შეიძლება აირჩიონ.
ამჯამად რომ უპასუხოს შეკითხვას?
>> OK.
Carlos.
ხაზოვანი საცდელი გულისხმობს -
თუ ჩვენ აღმოვაჩინეთ შეჯახება ნულოვანი, ჩვენ გამოიყურება მომდევნო ადგილზე თუ
ეს იყო ღია და ვთქვათ არსებობს.
და მაშინ ჩვენ გამოიყურებოდეს მომავალი და სპორტის ვნახოთ, თუ რომ ღია იყო და მისი იქ.
ასე რომ, ჩვენ ვხედავთ, მომავალი ხელმისაწვდომია ღია ადგილზე და დააყენოს ის არსებობს.
ნებისმიერი სხვა კითხვები?
ჰო, Avi.
>> აუდიტორია: როგორც თვალყური რომ, რას ნიშნავს მეორე ადგილზე?
In hash მაგიდასთან ან უკავშირდება სიაში.
>> JASON HIRSCHHORN: ხაზოვანი პროგრამირება, არ არის დაკავშირებული სიები.
მომდევნო ადგილზე hash მაგიდასთან.
>> აუდიტორია: OK.
ასე რომ hash table იქნება ინიციალიზაცია ზომა -
მოსწონს ნომერი strings რომ თქვენ ჩასმა?
>> JASON HIRSCHHORN თქვენ აკეთებთ გვინდა, რომ იყოს მართლაც დიდი.
დიახ.
აქ არის სურათი, რაც ჩვენ უბრალოდ გაამახვილა ფორუმში.
კიდევ ერთხელ, ჩვენ შეჯახება უფლება აქ.
at 152.
და დაინახავთ, ჩვენ შევქმენით დაკავშირებული სიაში off იგი.
ერთხელ, hash table ცალკე chaining მიდგომა არ არის ერთი თქვენ
უნდა მიიღოს პრობლემები შექმნას ექვსი მაგრამ არის ერთი, რომ ბევრი
სტუდენტები ტენდენცია მიიღოს.
ასე რომ შენიშვნა, ვისაუბროთ მოკლედ სანამ ჩვენ უხელმძღვანელებს out შესახებ პრობლემა ექვსი,
და მაშინ მე გაუზიაროს ამბავი თქვენთან ერთად.
ჩვენ სამი წუთის განმავლობაში.
>> პრობლემა კომპლექტი ექვსი.
თქვენ გაქვთ ოთხი ფუნქციები -
დატვირთვა, შეამოწმეთ, სიდიდესა და განიტვირთოს.
დატვირთვა -
ასევე, ჩვენ უკვე მიმდინარეობს მეტი დატვირთვის ახლა.
ჩვენ გაამახვილა დატვირთვის ფორუმში.
და ჩვენ კი დაიწყო კოდირების ბევრი ჩასმა შევიდა დაკავშირებული სიაში.
ასე დატვირთვის არ არის ბევრად მეტი, ვიდრე რა ჩვენ უბრალოდ აკეთებს.
>> Check არის კიდევ გაქვთ რაღაც დატვირთული.
ეს იგივე პროცესი, როგორც ეს.
იგივე პირველი ორი ნაწილი, სადაც თქვენ გადაყარეთ რაღაც შევიდა ქეშირების ფუნქცია
და კიდევ მისი ღირებულება.
მაგრამ ახლა ჩვენ არ ჩასმა იგი.
ახლა ჩვენ ვეძებთ მას.
მე ნიმუში კოდი დაწერილი მოძიების რაღაც უკავშირდება სიაში.
მე მოგიწოდებთ თქვენ პრაქტიკაში რომ.
მაგრამ ინტუიციურად მოძიებაში რაღაც საკმაოდ მსგავსი ჩასმა რაღაც.
მართლაც, ჩვენ მიიპყრო სურათს მოძიებაში რაღაც დაკავშირებული სიაში, მოძრავი
მეშვეობით სანამ შენ ბოლომდე.
და თუ თქვენ გაქვთ ბოლომდე და ვერ ის, მაშინ ეს არ არის.
ასე რომ, შემოწმება, არსებითად.
>> შემდეგი არის ზომა.
მოდით გამოტოვოთ ზომა.
საბოლოოდ თქვენ არ განიტვირთოს.
განიტვირთოს არის ერთ ერთი ჩვენ არ შედგენილი დაფაზე ან კოდირებულ არავის გაუკეთებია.
მაგრამ მე მოგიწოდებთ თქვენ ცდილობენ კოდირების ის ჩვენს ნიმუში უკავშირდება სია მაგალითად.
მაგრამ განიტვირთოს ინტუიციურად მსგავსი free -
ან ვგულისხმობ მსგავსი შემოწმება.
გარდა ახლა ყოველ დროს, თქვენ ვაპირებთ მეშვეობით, თქვენ არ უბრალოდ შემოწმების
თუ თქვენ გაქვთ თქვენი ღირებულება არსებობს.
მაგრამ თქვენ აღების, რომ კვანძის და ათავისუფლებს მას, არსებითად.
ის, რაც განიტვირთოს მოგთხოვთ გავაკეთოთ.
უფასო ყველაფერი თქვენ malloced.
ასე რომ თქვენ გადის მთელი სია ერთხელ, გადის მთელი hash
მაგიდა ერთხელ.
ამ დროს არ ამოწმებენ რა არის იქ.
უბრალოდ გასათავისუფლებლად, რა არის იქ.
>> და ბოლოს ზომის.
ზომა უნდა განხორციელდეს.
თუ თქვენ არ განახორციელოს ზომა -
მე ვიტყვი, რომ მოსწონს ეს.
თუ თქვენ არ განახორციელოს ზომა ზუსტად ერთი ხაზი კოდი ჩათვლით
დაბრუნების განაცხადი, თქვენ აკეთებს ზომა არასწორად.
ასე რომ დარწმუნდით, ზომა, სრული დიზაინი ქულა, თქვენ აკეთებთ ეს ზუსტად ერთი
ხაზი კოდი, მათ შორის, დაბრუნების განცხადებაში.
>> და არ კრავენ up არის, Akchar.
მოწადინებული თახვის.
მინდოდა მეთქვა დიდი მადლობა ბიჭებს მოდის მონაკვეთზე.
აქვს Happy Halloween.
ეს არის ჩემი კოსტუმი.
მე ტარება ამ ხუთშაბათს თუ მე ვერ ვხედავ თქვენ ოფისში საათის განმავლობაში.
და თუ თქვენ აინტერესებს კიდევ რამდენიმე ფონზე, როგორც ეს კოსტუმი, ვგრძნობ
უფასო შეამოწმეთ 2011 განყოფილებიანი ამბავი, თუ რატომ ვარ
ტარება გოგრა კოსტუმი.
და ეს არის სამწუხარო ამბავი.
ასე რომ დარწმუნდით აქვს ზოგიერთი ქსოვილების სიახლოვეს.
მაგრამ, თუ თქვენ გაქვთ რაიმე კითხვებს მე გამყარებაში გარშემო
გარეთ შემდეგ სექციაში.
წარმატებებს გისურვებთ პრობლემა კომპლექტი ექვსი.
და როგორც ყოველთვის, თუ თქვენ გაქვთ რაიმე შეკითხვები, ნება მომეცით ვიცი.