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

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

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

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

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

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

7. სრული ორობითი ხე 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

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

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

10. გროვის წარმოდგენა მასივით
მასივის ნებისმიერი 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

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

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

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

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

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

16. მასივის გარდაქმნა გროვად
გავყოთ მასივი ორ ნაწილად, პირველი ნახევრის თითოეული წევრი განვიხილოთ მარჯვნიდან მარცხნივ და ის რეკურსიულად “ჩავძიროთ” ხის ქვედა დონეებზე შესაბამის ადგილამდე. 21 3 17 11 22 14 9 18 25 15 19 21 3 17 11 22 14 9 18 25 15 19 21 3 17 11 22 19 9 18 14 25 15 21 3 17 11 25 19 9 18 14 22 15 21 3 17 18 25 19 9 11 14 22 15

17. 21 3 19 18 25 17 9 11 14 22 15 21 25 19 18 22 17 9 11 14 3 15 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

18. ასიმპტოტიკა

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

20. 25 22 19 18 22 17 9 25 22 19 18 22 17 9 22 19 18 9 17 25

21. 22 18 19 17 9 25 19 18 9 22 22 25 17 19 18 9 17 22 22 25

22. 18 17 9 19 22 25 17 9 18 19 22 22 25 17 9 18 19 22 22 25 9 17 18 19 22 22 25

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

24. 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);

25. დასასრული