УНИВЕРЗИТЕТ ,,ГОЦЕ ДЕЛЧЕВ”- ШТИП

ФАКУЛТЕТ ЗА ИНФОРМАТИКА

Семинарски труд по предметот

Структури на податоци и алгоритми

на тема:

Алгоритми за внатрешно сортирање

Ментор Кандидат:

Д-р Цвета Мартиновска Александар Јаќимовски

10945

Штип, јануари 2012

1

Содржина

Вовед------------------------------------------------------------------------------------------------------3

Сортирање со замена на елементите----------------------------------------------------------4

Сортирање со избор на најмалиот елемент (selection sort)-----------------------------5

Сортирање со замена на соседните елементи (bubble sort)----------------------------7

Едноставно сортирање со вметнување (insertion sort)------------------------------------9

Брзо сортирање (quick sort)-----------------------------------------------------------------------

11

Заклучок (Concluding remarks)-------------------------------------------------------------------15

Користена литература (References)-----------------------------------------------------------16

2

ВОВЕД

Поимот алгоритам во секојдневниот живот означува одреден процес или метод

со свои специфични карактеристики за постигнување одредена цел.Значењето

на овој поим во софтверскиот инженеринг е слично.Имено под поимот

алгоритам таму подразбираме множество на инструкции за решавање на

одреден проблем со конечен број на чекори. Алгоритмите за сортирање може

да бидат внатрешни и надворешни. Алгоритмите за внатрешно сортирање се

користат кога колекцијата на записи е доволно мала за да може целата да се

смести во оперативната меморија. Истите се делат на алгоритми со и без

споредување на вредности. Доколку колекцијата на записи целосно не може да

се смести во оперативната меморија се користат алгоритми за надворешно

сортирање.

Проблемот на сортирање гласи вака. Зададена е листа (a1, a2, . . . ,an) со

должина n. Вредностите на елементите во листата можат да се споредуваат со

знакот ≤. Треба да се пермутираат вредностите на елементите така да после

пермутирањето да биде а1 ≤ а2 ≤ ... ≤ аn.

3

Сортирање со замена на елементите

Поради едноставност, во сите примери ќе претпоставуваме дека нашата листа

се состои од цели броеви, и дека е имплементирана со должина на поле барем

за n. Значи, наместо сортирање на листата (a1, a2, . . . ,an) ќе говориме за

сортирање на полиња a[ ] кои се состојат од елементи а[0], a[1], … , a[n-1] од

тип int. Ваквото поедноставување не претставува ограничување и може да се

земе како општ случај. Поточно, многу од алгоритмите кои ќе ги прикажеме

можат да се преправат така да наместо со полиња работат и со некоја друга

имплементација на листи, на пример со поврзани листи. Исто така, сите

алгоритми наместо со цели броеви можат да се применат и на податоци од

некој друг тип, но под услов да за тие податоци имаме операција која одговара

на ≤. На крај, секој од алгоритмите за растечко сортирање можат на травијален

начин да се претворат во опаѓачко сортирање: доволно е знакот ≤ да се замени

со ≥.

Во ова подпоглавје се работи за наједноставните алгоритми за сортирање кои

се сведуваат на замена на елементите. Поточно, ќе обработиме две

едноставни постапки: сортирање со избор на најмалиот елемент (selection

sort), односно сортирање со замена на соседните елементи (bubble sort). И

двата алгоритми со замена на елементите имаат слична временска сложеност

и поспори се од повеќето кои ќе бидат објаснети во овој труд.

4

Сортирање со избор на најмалиот елемент (selection sort)

Алгоритамот работи на следниот начин. Полето се поминува и се наоѓа

најмалиот елемент. Потоа најмалиот елемент се заменува со почетниот.

Понатаму се обработува остатокот на полето ( без почетниот елемент) и се

повторува истата постапка. За да се сортира целото поле потребни се n-1

поминувања.

Слика 1.1Пример selection sort алгоритмот

Пример за сортирање со избор на најмалиот елемент (selection sort) се

гледа на сликата 1.1. Во секое поминување најмалиот пронајден елемент е

означен.

Алгоритамот за сортирање со избор на најмалиот елемент (selection sort)

во јазикот C++ може да се реализира со следната функција selectionSort( ). Таа

5

функција како аргумент го прима целобројното поле аrr[ ] и неговата должина

lenght. Функцијата го менува полето аrr[ ] така да тоа стане сортирано.

Java

public void selectionSort(int[] arr) {

      int i, j, minIndex, tmp;

      int n = arr.length;

      for (i = 0; i < n - 1; i++) {

            minIndex = i;

           for (j = i + 1; j < n; j++)

           if (arr[j] < arr[minIndex])

           minIndex = j;

            if (minIndex != i) {

                  tmp = arr[i];

               arr[i] = arr[minIndex];

                  arr[minIndex] = tmp;

            }

      }

C++

void selectionSort(int arr[], int n) {

      int i, j, minIndex, tmp;    

      for (i = 0; i < n - 1; i++) {

            minIndex = i;

      for (j = i + 1; j < n; j++)

       if (arr[j] < arr[minIndex])

                        minIndex = j;

            if (minIndex != i) {

                  tmp = arr[i];

            arr[i] = arr[minIndex];

                  arr[minIndex] = tmp;

            }

      }

}

Анализа на временската сложеност со алгоритамот за сортирање со избор на

најмалиот елемент (selection sort) изгледа вака.

- Во првото поминување имаме n-1 споредби, а во секое наредно

поминување бројот на споредувања се намалува за 1. Значи вкупниот

број на споредувања изнесува

(n − 1) + (n − 2) + (n − 3) + · · ·+ 2+1 = n(n − 1)/2.

- Во секое поминување постои уште замена, па имаме уште 3(n − 1)

операции на придружување.

6

- Значи вкупниот број на операции е: n(n − 1)/2+ 3(n − 1) = O(n2).

- Алгоритамот ја извршува истата работа без обзир на почетната состојба

на полето, дури и ако полето уште на почетокот е сортирано.

Сортирање со замена на соседните елементи (bubble sort)

Описот на алгоритамот е ваков. Го поминуваме полето од почетокот до крајот и

ги споредуваме соседните елементи. Ако некој елемент е поголем од следниот

елемент, ги заменуваме тие вредности. Кога на тој начин ќе дојдеме до крајот

на полето, најголемата вредност ќе дојде на последното место. После тоа ја

повторуваме истата постапка во скратено поле (без последниот елемент).

Алгоритамот може да застане штом во некое повторување открие дека нема

парови на елементи кои треба да се заменат.

Пример на сортирање со замена на соседните елементи (bubble sort) се

гледа на сликата 1.2. Во секој чекор двата соседни елемента кои треба да се

заменат се затемнети. Делот кој се разгледува се наоѓа од левата страна на

полната линија. Шестото поминување служи за да се заклучи дека нема повеќе

парови елементи кои треба да се заменат.

Слика 1.2 Пример за bubble sort алгоримот

7

Следната функција bubbleSort( ) го имплементира алгоритамот bubble sort во

јазикот C. Функцијата повторно како аргумент го прима целобројното поле а[ ] и

неговата должина n, и го менува полето a[ ] така да тоа стане сортирано. Се

користи истата помошна функција swap( ) за замена на две целобројни

вредности како и порано.

Java

public void bubbleSort(int[] arr) {

      boolean swapped = true;

      int j = 0;

      int tmp;

      while (swapped) {

            swapped = false;

            j++;

            for (int i = 0; i < arr.length - j; i++) {                                       

                  if (arr[i] > arr[i + 1]) {                          

                        tmp = arr[i];

                        arr[i] = arr[i + 1];

                        arr[i + 1] = tmp;

                        swapped = true;

                  }

            }                

      }

}

C++

void bubbleSort(int arr[], int n) {

      bool swapped = true;

      int j = 0;

      int tmp;

      while (swapped) {

            swapped = false;

            j++;

            for (int i = 0; i < n - j; i++) {

                  if (arr[i] > arr[i + 1]) {

                        tmp = arr[i];

                        arr[i] = arr[i + 1];

                        arr[i + 1] = tmp;

                        swapped = true;

                  }

            }

      }

}

8

Следува анализа на временската комплексност на опишаниот алгоритам за

сортирање со замена на соседните елементи (bubble sort).

- Во првото поминување во најлош случај имаме n – 1 споредби и n – 1

замена на елементи.

- Во второто поминување во најлош случај имаме n – 2 споредби и n – 2

замени на елементи.

- ............

- Во (n − 1)- тото поминување во најлош случај имаме 1 споредба и 1

замена на елементи.

- Значи вкупниот број операции во најлош случај изнесува:

4(n − 1) + 4(n − 2) + · · ·+ 4·1 = 4n(n − 1)/2 = 2n(n − 1).

- Оценетиот број на операција вистински се добива кога елементите во

почетното поле се опаѓачки сортирани.

- Од друга страна, ако почетното сортирање е растечко, ќе се изврши

само едно поминување со n – 1 споредувања и 0 замени.

- За било која друга поставеност на почетното поле бројот на операции е

помеѓу (n − 1) и 2n(n − 1).

- Во секој случај, времето на извршување е O(n2).

Едноставно сортирање со вметнување (insertion sort)

За време на работата на алгоритамот, почетниот дел од полето е веќе

сортиран, а остатокот од полето не е сортиран. Во едно поминување

алгоритамот го зема првиот елемент од несортираниот дел, и го сместува на

“вистинското место” ( во смисла на сортираниот редослед) во сортираниот дел,

при што доаѓа до поместување на некои елементи за едно место. Значи, со

9

едно поминување должината на почетниот сортиран дел се зголемува за 1, а

должината на несортираниот дел се намалува за 1.

Слика 2.3 Пример за Insertion sort

Пример за работа на едноставниот алгоритам за сортирање со вметнување

(insertion sort) е даден на слика 2.1. Местото на вметнување е означено со

прашалник. Имплементација на едноставниот алгоритам за сортирање со

вметнување (insertion sort) во јазикот C++ се сведува на следната функција

insertionSort( ). Функцијата повторно како аргумент го прима целобројното поле

a[ ] кое треба да се сортира и неговата должина n.

Java implementation

void insertionSort(int[] arr) {

      int i, j, newValue;

      for (i = 1; i < arr.length; i++) {

            newValue = arr[i];

            j = i;

            while (j > 0 && arr[j - 1] > newValue) {

                  arr[j] = arr[j - 1];

                  j--;

            }

            arr[j] = newValue; }}}

     

C++ implementation

void insertionSort(int arr[], int length) {

      int i, j, tmp;

      for (i = 1; i < length; i++) {

            j = i;

            while (j > 0 && arr[j - 1] > arr[j]) {

                  tmp = arr[j];

                  arr[j] = arr[j - 1];

10

                  arr[j - 1] = tmp;                   j--; }

Следи анализа на временската сложеност на едноставниот алгоритам за

сортирање со вметнување (insertion sort).

- Во k-тото поминување наназад поминуваме низ сортираниот дел на

полето со должина k. Сортираните елеметни ги поместуваме за едно

место понатаму се додека тие се поголеми од елементот кој сакаме да го

вметнеме на “вистинското место”. Тоа во најлош случај дава k

споредувања и отприлика исто толку придружувања.

- Значи, вкупниот број на операции во најлош случај е околу :

2 · 1 + 2 · 2 + · · ·+ 2(n − 1) = n(n − 1).

- Величината за времето на извршување повторно е O(n2), сепак овој

алгоритам во пракса се покажува побрз од претходно опишаните

алгоритми со замена на елементите.

Брзо сортирање (quick sort)

Овој алгоритам е од типот раздели па владеј (eng divide-and-conquer).

Еден алгоритам е од типот раздели па владеј ако проблемот го решава така

што најпрвин го разделува на помали подпроблеми,а потоа решавајќи ги

подпроблемите и комбинирајќи ги нивните решенија доаѓа до бараното

решение т.е решението на основниот проблем.

Нека a1, ..., an е дадена низа која треба да се сортира.

Методот на брзо сортирање проблемот на сортирањето го решава на следниот

начин:

-еден елемент од низата се прогласува за главна точка-пивот(eng pivot),се

пронаоѓа и поставува на “точната“ позиција на која треба да стои.

-елементите од низата се делат на две поднизи во првиот дел одат елементите

кои се помали од главната точка ,а во вториот дел оние кои се поголеми.

11

-алгоритмот рекурзивно се применува за двете поднизи се додека не се дојде

до интервал со должина еден.

Пример:

Да се сортираат елементите 16,7,9,44,2,18,8,53,1,5,17 со помош на методата за

брзо сортирање.Алгоритмот се изведува со помош на користење на два

индекси иницијално поставени едниот на почеток а другиот на крајот од низата.

Го избираме првиот елемент #1(16) како главна точка и продолжуваме со

пребарување,откриваме дека четвртиот елемент #4(44) е првиот поголем

елемент од 16 и застануваме тука ,сега започнуваме со елементот #11(17) на

крајот од низата и работиме наназад,елементот #10(5) е првиот елемент помал

од 16 и тука вршиме смена со елементот на четвртата позиција #4(44).

Ја добиваме следната ситуација:

Подвлечените елементи се тие два елементи кои си ги заменија местата се

разбира  на индексите каде што застанавме со броењето од почетокот и крајот

на низата.

Продолжуваме,следните два елементи кои треба да си ги заменат местата

затоа што се наоѓаат на погрешни страни од низата се

елементите #6(18) и #9(1)со што добиваме:

Продолжуваме следниот поголем елемент од пивотот е елементот #8(53) но

тука веќе индексите кои ни покажуваат до каде сме стигнале се изедначуваат

со што не се можни повеќе замени па пивотот се поставува на точната позиција

(индекс минус еден)вршејќи замена со елементот кој е на таа позицијасо што

се добива:

12

Сега низата е поделена на две поднизи,а елементот 16 е на “точната“ позиција

и не треба повеќе да се разгледува (оттука името главна точка).Размислувајќи

рекурзивно истата постака може да се примени за двете поднизи со што би се

сортирала целата низа. Повторувајќи ја постапката за левата подниза

добиваме:

Повторувајќи ја постапката за левата подниза околу 8 , се добива:

Левата подниза со главна точка 2 е сортирана(еден елемент).Кога и десната

подниза со главна точка 2 (два елементи) ке се исортира добиваме:

Со повторување на истата процедура ќе се добие следната слика:

13

Алгоритмот за реализација на овој метод се состои од следните чекори:

1. Постави го првиот елемент од низата за главна точка-пивот.

2. Најди ја точната позиција на тој елемент и постави го таму.

3. Распореди ги елементите од низата т.ш. елементите кои се пред

главната точка-пивот се помали,а тие после неа поголеми од неа.

4. Повторувај ги чекорите рекурзивно за левата подниза се додека има

повеќе од еден елемент.

5. Повторувај ги чекорите рекурзивно за десната подниза се додека има

повеќе од еден елемент.

Алгоритмот гарантира дека во секој чекор еден елемент ке дојде на

вистинското место.

14

Заклучок (Concluding remarks)

Во оваа семинарска работа подетално ги разработивме поимите алгоритмите

за внатрешно сортирање како што се: Сортирање со избор на најмалиот

елемент (selection sort), Сортирање со замена на соседните елементи (bubble

sort), Едноставно сортирање со вметнување (insertion sort) и Брзото сортирање

(quick sort). Опишани се начинот на кој работат, времето за кое се извршуваат

и комплексноста што ја содржат. Проучувањето на овие алгоритми е важно за

понатамошниот развој на софтверот.

15

Користена литература (References)

http://cs.org.mk/index.php/natprevari/materijali/82-sortiranje

www.wikipedia.com

www.google.com

16