ორობითი ხეები. გროვა. სორტირება გროვით. ორობითი ხეები. გროვა. სორტირება გროვით.

რეკურსიული განსაზღვრება ხეები რეკურსიული განსაზღვრება ჩანაწერს, რომელიც შეიცავს კონკრეტული საინფორმაციო სტრუქტურის აღწერას, მნიშვნელობას ან მდგომარეობას, ვუწოდოთ კვანძი (node). T ხე წარმოადგენს კვანძების სიმრავლეს, სადაც T შეიძლება იყოს ცარიელი თუ ცარიელი არაა, მაშინ T შეიცავს: განსაკუთრებულ r კვანძს - ხის სათავეს (root, ფესვი, ძირი), ცარიელ ან არაცარიელ ქვეხეებს T1, T2, ...., Tk

ხეთა თვისებები ხე წარმოადგენს წვეროებისა და წიბოების G=(V,E) სიმრავლეს, სადაც G-ს ნებისმიერი ორი წვეროსათვის არსებობს მათი შემაერთებელი ერთადერთი მარტივი გზა; G ბმულია, მაგრამ კარგავს ბმულობას, თუ გამოვაკლებთ ნებისმიერ წიბოს; E=V-1; G არ შეიცავს ციკლებს ანუ აციკლურია; G აციკლურია, მაგრამ ნებისმიერი წიბოს დამატებით მასში ჩნდება ციკლი.

ტერმინოლოგია მშობელი და შვილი (Parent, Child) ყველა კვანძს ხის სათავის გარდა ჰყავს მხოლოდ 1 მშობელი;  ყველა კვანძს ჰყავს 0, 1 ან რამდენიმე შვილი; ფოთოლი (Leaf ) კვანძი შვილების გარეშე; ძმა (დედმამიშვილი, Sibling) ერთი მშობლის შვილები; გზა და მისი სიგრძე (Path, Length) ორ კვანძს შორის არსებული წიბოების მიმდევრობა წარმოადგენს გზას ამ ორ კვანძს შორის, ხოლო წიბოების რაოდენობა - ამ გზის სიგრძეს; კვანძის სიღრმე (Depth) გზის სიგრძე სათავიდან კვანძამდე; კვანძის სიმაღლე (Height) უშორესი გზის სიგრძე კვანძიდან ფოთლამდე ნებისმიერი ფოთლის სიმაღლე 0-ის ტოლია ხის სიმაღლე = სათავის სიმაღლე = ყველაზე “ღრმა” ფოთლის სიღრმე წინაპარი და შთამომავალი (Ancestor and descendant) თუ არსებობს გზა n1-დან n2-მდე სათავის გავლის გარეშე და n1-ის სიღრმე ნაკლებია n2-ის სიღრმეზე, მაშინ n1 არის n2-ის წინაპარი, ხოლო n2 – n1-ის შთამომავალი.

ორობითი ხეები გააჩნია სათავე, სიმაღლის ყველაზე მეტი დონით; ყოველ კვანძს აქვს 0, 1 ან 2 შვილი; კვანძები შვილების გარეშე წარმოადგენენ ფოთლებს; X კვანძის სტრუქტურაში განისაზღვრება მისი მარცხენა შვილი left(x), მარჯვენა შვილი right(x) და მშობელი parent(x). root Parent(x) x leaf leaf left(x) right(x) leaf

ორობითი ხის სიმაღლე ორობითი ხის სიმაღლედ ითვლება წიბოების რაოდენობა სათავიდან წვერომდე არსებულ უგრძელეს გზაში. Height = 4

სრული ორობითი ხე height no. of nodes 1 1 2 2 4 3 8 d 2d სრული ორობითი ხე ეწოდება ხეს, რომელშიც ყველა კვანძს აქვს 0 (ფოთოლი) ან 2 შვილი; ყველა ფოთოლი ერთნაირი სიღრმე აქვს დამოკიდებულება კვანძებსა და ხის სიმაღლეს შორის N კვანძისაგან შედგენილი სრული ორობითი ხის სიმაღლეა O(logN); d სიმაღლის მქონე სრული ორობითი ხე შეიცავს 2d+1-1 კვანძს. height no. of nodes 1 1 2 2 4 3 8 d 2d

გროვა გროვა წარმოადგენს ბალანსირებულ ორობით ხეს, ანუ არასრულად შევსებული შეიძლება იყოს მხოლოდ ყველაზე ქვედა დონე, ამასთან ამ შეუვსებელ დონეზე კვანძები მიჯრით მარცხნივ არიან განლაგებული; ნებისმიერი კვანძისათვის მისი მნიშვნელობა ნაკლებია მშობლის მნიშვნელობაზე (ასეთ გროვებს მაქს-გროვებს უწოდებენ, არსებობს მინ-გროვაც, სადაც ნებისმიერ კვანძში მისი მნიშვნელობა მშობლის მნიშვნელობაზე ნაკლებია). n-2 n-1 n ბალანსირებული ბალანსირებული არაბალანსირებული 1 4 2 5 2 5 4 3 6 1 3 6 მარცხნივ დალაგებული გროვა არ არის გროვა

გროვის თვისებები გროვა ეფექტურად ახორციელებს შემდეგ ოპერაციებს ელემენტის ჩამატება ხდება O(logN) დროში; განსაზღვრავს მაქსიმუმს (ან მინიმუმს) O(1) დროში; ახორციელებს მაქსიმუმის (ან მინიმუმის) წაშლას O(log N) დროში.

გროვის წარმოდგენა მასივით მასივის ნებისმიერი i-ური ელემენტისათვის მარცხენა შვილის ინდექსია 2i მარჯვენა შვილის ინდექსია 2i+1 მშობლის ინდექსია floor(i/2) - (i/2)-ის მთელი ნაწილი. ასეთი წარმოდგენის უარყოფითი მხარე ის არის, რომ წინასწარ უნდა აღვწეროთ მაქსიმალური ზომის მასივი, ხოლო დამუშავებას მასივში უამრავი ცარიელი ადგილი შეიძლება დარჩეს. 53 44 25 15 21 13 18 3 12 5 7 53 44 25 15 21 13 18 3 12 5 7 0 1 2 3 4 5 6 7 8 9 10 11

გროვის მთავარი თვისების აღდგენა 12 12 12 8 3 8 12 8 14 წითელი კვანძი აკმაყოფილებს გროვის მთავარ თვისებას წითელი კვანძი არ აკმაყოფილებს გროვის მთავარ თვისებას 12 14 8 14 8 12 თუ კვანძი არღვევს გროვის მთავარ თვისებას, მაშინ ის უცვლის ადგილს თავისი შვილებიდან უდიდესს.

გროვის აგება თუ ხე შეიცავს მხოლოდ ერთ კვანძს, ის გროვად ითვლება; გროვის ასაგებად ვამატებთ თითო კვანძს შემდეგი წესით: ვუმატებთ კვანძს ყველაზე ქვედა დონეზე უკიდურეს მარცხენა თავისუფალ ადგილას; თუ ქვედა დონე შევსებულია, შევქმნათ ახალი დონე; თუ ახლად დამატებული კვანძი არღვევს გროვის მთავარ თვისებას, მას რეკურსიულად ვუცვლით ადგილს მშობელთან; მაგალითი: ვუმატებთ ახალ კვანძს აქ ვუმატებთ ახალ კვანძს აქ

გროვის აგება 8 10 5 12 1 2 3 4 12 10 5 8 14 12 14 5 8 10 14 12 5 8 10

სათავის წაშლა 19 14 18 22 3 21 11 9 15 25 17 19 14 18 22 3 21 9 15 17 11 გროვის შესანარჩუნებლად წაშლილი წვეროს ნაცვლად იქ მოვათავსოთ გროვის ბოლო ელემენტი და აღვადგინოთ გროვის მთავარი თვისება.

გროვის აღდგენა სათავის წაშლის შემდეგ 19 14 18 21 3 11 9 15 17 22 ფოთლის პოზიციაში მოხვედრამდე, 11 გაუცვლის ადგილს 22-ს, 22-ს და 21-ს.

მასივის გარდაქმნა გროვად გავყოთ მასივი ორ ნაწილად, პირველი ნახევრის თითოეული წევრი განვიხილოთ მარჯვნიდან მარცხნივ და ის რეკურსიულად “ჩავძიროთ” ხის ქვედა დონეებზე შესაბამის ადგილამდე. 21 3 17 11 22 14 9 18 25 15 19 1 2 3 4 5 6 7 8 9 10 11 12 13 21 3 17 11 22 14 9 18 25 15 19 1 2 3 4 5 6 7 8 9 10 11 12 13 21 3 17 11 22 19 9 18 14 25 15 1 2 3 4 5 6 7 8 9 10 11 12 13 21 3 17 11 25 19 9 18 14 22 15 1 2 3 4 5 6 7 8 9 10 11 12 13 21 3 17 18 25 19 9 11 14 22 15 1 2 3 4 5 6 7 8 9 10 11 12 13

1 2 3 4 5 6 7 8 9 10 11 12 13 21 3 19 18 25 17 9 11 14 22 15 21 25 19 18 22 17 9 11 14 3 15 1 2 3 4 5 6 7 8 9 10 11 12 13 1 2 3 4 5 6 7 8 9 10 11 12 13 25 22 19 18 22 17 9 11 14 3 21 15 14 25 22 19 18 22 17 9 11 14 3 21 15 14

ასიმპტოტიკა

გროვით სორტირება ალგორითმი: გროვით სორტირება ყოველთვის O(n log n)-ში მუშაობს ჩქარი სორტირება საშუალოდ O(n log n)-ში მუშაობს, მაგრამ უარეს შემთხვევაში O(n2) დროს ხარჯავს; საზოგადოდ ჩქარი სორტირება სწრაფია გროვით სორტირებაზე, მაგრამ ეს უკანასკნელი უარეს შემთხვევაშიც O(n log n)-ში მუშაობს და უფრო სანდოა კრიტიკული დროის მქონე აპლიკაციებში. ალგორითმი: ავაგოთ გროვა; გროვის სათავეში მყოფ ელემენტს (მაქსიმუმს) გავუცვალოთ ადგილი გროვის ბოლო ელემენტთან და გროვა ერთით შევამციროთ; აღვადგინოთ გროვის ძირიტადი თვისება და გროვის სათავეში მოხვედრილი ელემენტი “ჩავძიროთ” შესაბამის ადგილამდე; გავიმეოროთ წინა ორი მოქმედება ყველა ელემენტისათვის.

25 22 19 18 22 17 9 1 2 3 4 5 6 7 25 22 19 18 22 17 9 22 19 18 9 17 25 1 2 3 4 5 6 7

22 18 19 17 9 25 1 2 3 4 5 6 7 19 18 9 22 22 25 17 1 2 3 4 5 6 7 19 18 9 17 22 22 25

18 17 9 19 22 25 1 2 3 4 5 6 7 17 9 18 19 22 22 25 1 2 3 4 5 6 7 17 9 18 19 22 22 25 1 2 3 4 5 6 7 9 17 18 19 22 22 25

ანალიზი გროვის აგებისათვის საჭიროა (n/2)*O(log n); წინა ორი ოპერაცია n-ჯერ უნდა გავიმეოროთ, ამიტომ ალგორითმის მუშაობის საერთო დრო იქნება n*O(log n), ანუ O(n log n)

void Heapify(int A[],int i,int HeapSize){ int left=2*i, right=2*i+1; int largest; if ((left <= HeapSize) && (A[left] > A[i])) largest = left; else largest = i; if ((right <= HeapSize) && (A[right] > A[largest])) largest = right; if (largest != i) { Swap(&A[i],&A[largest]); Heapify(A,largest,HeapSize); } void HeapSort(int A[], int n){ int i, HeapSize = n; for (i= HeapSize/2; i >= 1; i--) Heapify(A,i,HeapSize); for (i=n; i>=2; i--) { Swap(&A[i],&A[1]); HeapSize--; Heapify(A,1,HeapSize);

დასასრული