>> [მუსიკის დაკვრა]
>> Zamyla CHAN: პირველი, რაც თქვენ შესაძლოა ცნობა იმის შესახებ, იპოვოს ის არის, რომ ჩვენ უკვე
არ კოდი დაწერილი ჩვენთვის.
ამ ეწოდება განაწილების კოდი.
ასე რომ, ჩვენ არა მხოლოდ წერილობით საკუთარი კოდექსის ნულიდან უქმნით.
პირიქით, ჩვენ შევსების voids ზოგიერთ წინასწარ არსებული კოდი.
>> Find.c პროგრამა მოთხოვნა ნომრები შევსება haystack, ეძებს
haystack განთავსების შესახებ წარმოდგენილი ნემსი, და ამას დარეკვით სახის და
ძიების, განსაზღვრული ფუნქციების in helpers.c.
ასე find.c წერია უკვე.
თქვენი სამუშაო დაწერა დამხმარე.
>> ასე რომ, რას ვაკეთებთ?
ჩვენ ახორციელებს ორი ფუნქცია.
ძებნა, რომელიც ბრუნდება ნამდვილი თუ ღირებულება გვხვდება haystack, დაბრუნების
ცრუ თუ ღირებულება არის არ haystack.
და მაშინ ჩვენ, ასევე, ახორციელებს ერთგვარი რომელიც ახარისხებს მასივი მოუწოდა ღირებულებებს.
>> მოდით დაძლევის ძებნა.
ძიება ამჟამად ხორციელდება როგორც ხაზოვანი ძებნა, მაგრამ შეგიძლიათ ამის გაკეთება ბევრად
უკეთესად რომ.
ხაზოვანი ძებნა ხორციელდება O of n დრო, რომელიც საკმაოდ ნელა.
თუმცა, შეგიძლიათ მოძებნოთ ნებისმიერი სია გადაეცა იგი.
თქვენი სამუშაო განახორციელოს ორობითი ძებნა, რომელიც აწარმოებს დრო O of log n.
ეს არის საკმაოდ სწრაფი.
>> მაგრამ არსებობს განაპირობებს.
ორობითი ძებნა შესაძლებელია მხოლოდ ძებნა მეშვეობით წინასწარ დახარისხებული სიები.
რატომ არის, რომ?
>> კარგად მოდით შევხედოთ მაგალითს.
მოცემული მასივი ღირებულებები, haystack, ჩვენ ვაპირებთ იყოს ეძებს
განთავსების ნემსი.
და ამ მაგალითად, რიცხვი სამი.
ისე, რომ ბინარული ძებნის მუშაობს ის არის, რომ შევადარებთ შუა ღირებულება
მასივი ნემსი, ჰგავს, თუ როგორ გავხსენით წიგნი შუა
გვერდი კვირაში ნულოვანი.
>> ასე რომ, მას შემდეგ, რაც შედარებით შუა ღირებულება ნემსი, შეგიძლიათ გაუქმება ან
მარცხენა ან მარჯვენა ნახევარში მასივი გამკაცრება თქვენი საზღვრები.
ამ შემთხვევაში, მას შემდეგ, რაც სამი, ჩვენი ნემსი, ნაკლებია, ვიდრე 10, შუა ღირებულება,
მარჯვენა შეკრული შეუძლია შეამციროს.
მაგრამ ცდილობენ, რომ თქვენი საზღვრები მჭიდრო როგორც შესაძლებელი.
იმ შემთხვევაში, თუ შუა ღირებულება არ არის ნემსი, მაშინ თქვენ იცით, რომ თქვენ არ უნდა
მოიცავს იგი თქვენს ძებნა.
ასე რომ, თქვენ უფლება შეკრული შეიძლება გამკაცრდეს ძებნა საზღვრები მხოლოდ პატარა უფრო მეტი,
და ასე შემდეგ და ასე შემდეგ, სანამ თქვენ თქვენი ნემსი.
>> ასე რომ, რას pseudocode გამოიყურებოდეს?
კარგად, ხოლო ჩვენ ჯერ კიდევ გადახედეთ სიაში და კიდევ აქვს ელემენტები
გამოიყურება, ჩვენ შუა სიაში, და შედარების რომ შუა ღირებულება
ჩვენი ნემსი.
იმ შემთხვევაში, თუ ისინი ტოლია, მაშინ ეს ნიშნავს, რომ ჩვენ ვიდეო ნემსი და ჩვენ შეგვიძლია
TRUE.
>> წინააღმდეგ შემთხვევაში, თუ ნემსი ნაკლებია, ვიდრე შუა ღირებულება, მაშინ ეს ნიშნავს, რომ ჩვენ
შეგიძლიათ გაუქმება მარჯვენა ნახევარში, და მხოლოდ ძებნა მარცხენა მხარეს მასივი.
წინააღმდეგ შემთხვევაში, ჩვენ მოძებნოთ მარჯვენა მხარეს მასივი.
და ბოლოს, თუ თქვენ არ გაქვთ მეტი ელემენტები მარცხენა მოძებნოთ მაგრამ თქვენ
არ არის ნაპოვნი თქვენი ნემსი არ არის, მაშინ დაბრუნების ცრუ, რადგან ნემსის
ნამდვილად არ არის haystack.
>> ახლა neat რამ ამ pseudocode ორობითი ძებნა არის ის, რომ ეს შეიძლება იყოს
გაგებული როგორც iterative ან რეკურსიული განხორციელება.
ასე რომ, ეს იქნება რეკურსიული თუ მოუწოდა ძებნის ფუნქცია ფარგლებში ძებნა
ფუნქციონირებს ორივე ნახევარში მასივი.
ჩვენ დაფარავს უკან ცოტა მოგვიანებით რა თქმა უნდა, მაგრამ ვიცით, რომ ეს არის
ვარიანტი თუ გსურთ ცდილობენ.
>> ახლა მოდით შევხედოთ ჯიშია.
დახარისხება იღებს მასივი და რიცხვი n, რომელიც არის ზომა მასივი.
ახლა არსებობს სხვადასხვა სხვადასხვა სახის სახის, და თქვენ შეგიძლიათ შევხედოთ ზოგიერთი
შორტები demos და განმარტებები.
დაბრუნების ტიპის ჩვენი დალაგების ფუნქცია ბათილად.
ასე რომ, ეს ნიშნავს, რომ ჩვენ არ ვაპირებთ დაბრუნების ნებისმიერი array ეხლა ჯიშია.
ჩვენ რეალურად შეიცვლება, ძალიან array, რომელიც შევიდა ჩვენთვის.
>> და ეს შესაძლებელია, რადგან კოლექტორები გაიარა მინიშნება C. ახლა ჩვენ
იხილეთ მეტი მოგვიანებით, მაგრამ არსებითი განსხვავება გავლის
რაღაც რიცხვი და გავლის მასივი, ის არის, რომ როდესაც თქვენ
გაივლის რიცხვი, C უბრალოდ აპირებს ასლი, რომ რიცხვი და გაიაროს
ის ფუნქცია.
ორიგინალური ცვლადი არ შეიცვლება ერთხელ ფუნქციის დასრულდა.
მასივი, მეორეს მხრივ, ეს არ აპირებს მიიღოს ასლი, და თქვენ
რეალურად რედაქტირების ძალიან მასივი თავად.
>> ასე რომ, ერთი ტიპის სახის არის შერჩევა ჯიშია.
შერჩევა სახის სამუშაოების დაწყებული დასაწყისში, და მაშინ iterate
მეტი და იპოვოს პატარა ელემენტს.
და მაშინ სვოპ, რომ პატარა ელემენტს პირველი.
და მაშინ გადავა მეორე ელემენტს , იპოვოს მომავალი პატარა
ელემენტს, შემდეგ სვოპ რომ მეორე ელემენტია მასივი, რადგან
პირველი ელემენტია უკვე დახარისხებული.
და ასე შემდეგ, თქვენ კვლავაც ყველა ელემენტის იდენტიფიცირების პატარა
ღირებულება და შევცვალე ის.
>> მე უდრის 0, პირველივე ელემენტს to n მინუს 1, თქვენ აპირებს შედარება
ყოველ მომდევნო ღირებულება შემდეგ, და იპოვოს ინდექსის მინიმალური ღირებულება.
ერთხელ თქვენთვის მინიმალური ღირებულება ინდექსი, შეგიძლიათ სვოპ რომ ღირებულება მასივი
მინიმალური და array I.
>> სხვა ტიპის სახის რომ თქვენ შეგიძლიათ განხორციელება არის ბუშტი ჯიშია.
ასე რომ, bubble sort iterates მეტი სია შედარებით მიმდებარე ელემენტები და
შევცვალე ელემენტები, არასწორი მიზნით.
და ამ გზით, უდიდესი ელემენტს ნება ბუშტი ბოლომდე.
და სია დალაგებულია ერთხელ აღარ ელემენტები უკვე გაცვალეს.
>> ასე რომ, ეს ორი მაგალითი სახის ალგორითმები, შეგიძლიათ განახორციელოს for
იპოვოს პროგრამა.
მას შემდეგ, რაც დასრულდება დალაგების, და თქვენ კეთდება ძიების, თქვენ დასრულდა.
ჩემი სახელი არის Zamyla, და ეს არის CS50.
>> [მუსიკის დაკვრა]