1. სორტირება გადათვლით (Countingsort)

2. რამდენად სწრაფი შეიძლება იყოს სორტირება?
აქამდე განხილულ სორტირების ყველა ალგორითმს შეგვიძლია “შედარების” ალგორითმი ვუწოდოთ – ისინი ელემენტთა თანმიმდევრობას შედარებების საშუალებით ადგენენ. (მაგ. სორტირება ჩასმით, ჩქარი სორტირება, სორტირება გროვით და ა.შ.)
შესრულების საუკეთესო დრო ამ ალგორითმებისათვის იყო O (n lg n).
არის თუ არა ეს დრო საუკეთესო?
დიახ. თუკი ჩვენ გამოვიყენებთ შედარებებს.

3.  A,  I, A(I)=P(I) and Time(A,I)  Tupper(|I|)
ამოცანის დროითი სირთულე მინიმალური დრო, რომელიც სჭირდება ალგორითმს ამოცანის ამოსახსნელად.
ზედა საზღვარი P ამოცანა იხსნება Tupper(n) დროში, თუ მას გამოაქვს სწორი პასუხი მაქსიმუმ ამ დროში.
 A,  I, A(I)=P(I) and Time(A,I)  Tupper(|I|)
მაგ: სორტირებისათვის Tupper(n) = O(n2).

4.  A,  I, A(I)  P(I) or Time(A,I)  Tlower(|I|)
ამოცანის დროითი სირთულე მინიმალური დრო, რომელიც სჭირდება ალგორითმს ამოცანის ამოსახსნელად.
ქვედა საზღვარი P ამოცანის ამოხსნის ქვედა საზღვარს უწოდებენ Tlower(n) დროს, რომელზეც უფრო სწრაფად ამოცანის ამოხსნა შეუძლებელია.
 A,  I, A(I)  P(I) or Time(A,I)  Tlower(|I|)
მაგ: სორტირებისათვის Tlower = sqrt(N)

5. ამოხსნის ხე Sort a1, a2, …, an 1:2 2:3 123 1:3 132 312 213 231 321
ყოველი შიგა კვანძს შეესაბამება i:j, სადაც i, j {1, 2,…, n}.
მარცხენა ქვეხე აჩვენებს შედარებებებს, სადაც ai  aj.
მარჯვენა ქვეხე აჩვენებს შედარებებებს, სადაც if ai  aj.

6. ამოხსნის ხის მაგალითი Sort a1, a2, a3 9, 4, 6  1:2 9  4 2:3
1:3
123
1:3
213
2:3
132
312
231
321
ყოველი შიგა კვანძს შეესაბამება i:j, სადაც i, j {1, 2,…, n}.
მარცხენა ქვეხე აჩვენებს შედარებებებს, სადაც ai  aj.
მარჯვენა ქვეხე აჩვენებს შედარებებებს, სადაც if ai  aj.

7. ამოხსნის ხის მაგალითი Sort a1, a2, a3 9, 4, 6  1:2 2:3 1:3
9  6
123
1:3
213
2:3
132
312
231
321
ყოველი შიგა კვანძს შეესაბამება i:j, სადაც i, j {1, 2,…, n}.
მარცხენა ქვეხე აჩვენებს შედარებებებს, სადაც ai  aj.
მარჯვენა ქვეხე აჩვენებს შედარებებებს, სადაც if ai  aj.

8. ამოხსნის ხის მაგალითი Sort a1, a2, a3 9, 4, 6  1:2 2:3 1:3 123
213
2:3
4  6
132
312
231
321
ყოველი შიგა კვანძს შეესაბამება i:j, სადაც i, j {1, 2,…, n}.
მარცხენა ქვეხე აჩვენებს შედარებებებს, სადაც ai  aj.
მარჯვენა ქვეხე აჩვენებს შედარებებებს, სადაც if ai  aj.

9. ამოხსნის ხის მაგალითი Sort a1, a2, a3 9, 4, 6  4  6  9
1:2
2:3
1:3
123
1:3
213
2:3
132
312
231
321
4  6  9
თითოეული ფოთოლი შეიცავს გადანაცვლებას , ,…, (n), რომელიც დალაგებულია a(1) a(2)    a(n) .

10. ნებისმიერი სორტირება, რომელიც შედარებებს იყენებს, შეიძლება გარდავქმნათ ამოხსნის ხედ
class InsertionSortAlgorithm {
for (int i = 1; i < a.length; i++) {
int j = i;
while ((j > 0) && (a[j-1] > a[i])) {
a[j] = a[j-1];
j--; }
a[j] = B; }}
1:2
2:3
123
1:3
132
312
213
231
321

11. ამოხსნის ხის ქვედა საზღვარი სორტირებისათვის
თეორემა. n ელემენტის დალაგებისათვის აგებული ამოხსნის ხის სიმაღლეა (n lg n) .
დამტკიცება. ამოხსნის ხე შეიცავს  n! ფოთოლს, რადგან სულ შესაძლოა n! გადანაცვლება. h სიმაღლის ორობით ხეს აქვს  2h ფოთოლი. მაშასადამე, n!  2h .
 h  lg(n!)
 lg ((n/e)n) (სტირლინგის ფორმულა)
= n lg n – n lg e
= (n lg n) .

12. შედარების ალგორითმების ქვედა საზღვარი
დასკვნა. სორტირება გროვით და სორტირება შერწყმით ასიმპტოტურად ოპტიმალური შედარების ალგორითმები არიან.

13. სორტირება წრფივ დროში k=max(A)
Counting sort: ალაგებს ელემენტთა შედარების გარეშე
Input: A[1 . . n], სადაც A[ j]{1, 2, …, k} .
Output: C[1 . . n], დალაგებული.
დამატებითი მასივი: B[1 . . k] .
k=max(A)

14. Counting-sort A: 4 1 5 4 3 8 3 3 4 3 B: for (i=0; i<n; i++) {2 3 4 5 6 7 8 9 10 A: 4 1 5 4 3 8 3 3 4 3 1 2 3 4 5 6 7 8 B: 1 1 1 3 2 4 3 2 1 1
for (i=0; i<n; i++) {
B[A[i]]++; }

15. Counting-sort A: 4 1 5 4 3 8 3 3 4 3 B: B: for (i=1; i<k; i++) {2 3 4 5 6 7 8 9 10 A: 4 1 5 4 3 8 3 3 4 3 1 2 3 4 5 6 7 8 B: 3 1 4 1 1 1 2 3 4 5 6 7 8 B: 8 1 1 5 9 9 9 10
for (i=1; i<k; i++) {
B[i]=B[i]+B[i-1]; }

16. Counting-sort A: 4 1 5 4 3 8 3 3 4 3 B: C: 3 for (i=n; i>0; i--) {2 3 4 5 6 7 8 9 10 A: 4 1 5 4 3 8 3 3 4 3 1 2 3 4 5 6 7 8 B: 8 1 1 5 4 9 9 9 10 1 2 3 4 5 6 7 8 9 10 C: 3
for (i=n; i>0; i--) {
C[B[A[i]]]=A[i];
B[A[i]]--; }

17. Counting-sort 1 2 3 4 5 6 7 8 9 10 A: 4 1 5 4 3 8 3 3 4 3 1 2 3 4 5 6 7 8 B: 8 1 1 4 7 9 9 9 10 1 2 3 4 5 6 7 8 9 10 C: 3 4
for (i=n; i>0; i--) {
C[B[A[i]]]=A[i];
B[A[i]]--; }

18. Counting-sort 1 2 3 4 5 6 7 8 9 10 A: 4 1 5 4 3 8 3 3 4 3 1 2 3 4 5 6 7 8 B: 7 1 1 4 3 9 9 9 10 1 2 3 4 5 6 7 8 9 10 C: 3 3 4
for (i=n; i>0; i--) {
C[B[A[i]]]=A[i];
B[A[i]]--; }

19. Counting-sort 1 2 3 4 5 6 7 8 9 10 A: 4 1 5 4 3 8 3 3 4 3 1 2 3 4 5 6 7 8 B: 7 1 1 3 2 9 9 9 10 1 2 3 4 5 6 7 8 9 10 C: 3 3 3 4
for (i=n; i>0; i--) {
C[B[A[i]]]=A[i];
B[A[i]]--; }

20. Counting-sort 1 2 3 4 5 6 7 8 9 10 A: 4 1 5 4 3 8 3 3 4 3 1 2 3 4 5 6 7 8 B: 7 1 1 2 9 9 9 10 9 1 2 3 4 5 6 7 8 9 10 C: 3 3 3 4 8
for (i=n; i>0; i--) {
C[B[A[i]]]=A[i];
B[A[i]]--; }

21. Counting-sort 1 2 3 4 5 6 7 8 9 10 A: 4 1 5 4 3 8 3 3 4 3 1 2 3 4 5 6 7 8 B: 7 1 1 1 2 9 9 9 9 1 2 3 4 5 6 7 8 9 10 C: 3 3 3 3 4 8
for (i=n; i>0; i--) {
C[B[A[i]]]=A[i];
B[A[i]]--; }

22. Counting-sort 1 2 3 4 5 6 7 8 9 10 A: 4 1 5 4 3 8 3 3 4 3 1 2 3 4 5 6 7 8 B: 5 1 1 8 9 9 9 1 2 3 4 5 6 7 8 9 10 C: 1 3 3 3 3 4 4 4 5 8
for (i=n; i>0; i--) {
C[B[A[i]]]=A[i];
B[A[i]]--; }

23. ანალიზი (n) (k) (n) (n + k) for (i=0; i<n; i++) { B[A[i]]++; }
for (i=1; i<k; i++) {
B[i]=B[i]+B[i-1]; }
(k)
for (i=n; i>0; i--) {
C[B[A[i]]]=A[i];
B[A[i]]--; }
(n)
(n + k)

24. სტაბილურობა
Counting sort სტაბილური სორტირებაა: ტოლ ელემენტთა შორის თავდაპირველი განლაგება არ იცვლება A: 4 1 3 B:

25. Radix-sort

26. Radix-sort

27. Radix-sort