Bubble Sort – Спртираое какп сп меури

// bubbleSort.java
// demonstrates bubble sort
// to run this program: C>java BubbleSortApp
////////////////////////////////////////////////////////////////
class ArrayBub
{
private long[] a;
// ref to array a
private int nElems;
// number of data items
//-------------------------------------------------------------public ArrayBub(int max)
// constructor
{
a = new long[max];
// create the array
nElems = 0; // no items yet
}
//-------------------------------------------------------------public void insert(long value) // put element into array
{
a[nElems] = value;
// insert it
nElems++;
// increment size
}
//-------------------------------------------------------------public void display() // displays array contents
{
for(int j=0; j<nElems; j++)
// for each element,
System.out.print(a*j+ + “ “);
// display it
System.out.println(“”);
}
//-------------------------------------------------------------public void bubbleSort()
{
int out, in;
for(out=nElems-1; out>1; out--)
// outer loop (backward)
for(in=0; in<out; in++)
// inner loop (forward)
if( a[in] > a[in+1] )
// out of order?
swap(in, in+1);
// swap them
} // end bubbleSort()
//-------------------------------------------------------------private void swap(int one, int two)
{
long temp = a[one];
a[one] = a[two];
a[two] = temp;
}
//-------------------------------------------------------------} // end class ArrayBub

insert(00).display().insert(77).insert(66).bubbleSort(). arr. arr.insert(99).insert(44). // display items arr. // bubble sort them arr. arr.class BubbleSortApp { public static void main(String[] args) { int maxSize = 100. arr. } // end main() } // end class BubbleSortApp // display them again .insert(22).insert(11). arr. // array size ArrayBub arr. arr.display().insert(88). // reference to array arr = new ArrayBub(maxSize). arr.insert(33). // insert 10 items arr.insert(55). arr. arr. // create the array arr.

……………………… .

+ 1= N*(N-1)/2 сппредби Вп најлпш случај (кпга пплетп е инверзнп спртиранп. Акп пплетп има случаен расппред на елементи се прават N2/4 замени на елементи.На крај на првптп ппминуваое највиспкипт чпвек е на вистинската ппзиција Ефикаснпст на Bubble Sort алгпритампт За ппле пд 10 елементи се прават 9 сппредби вп првптп ппминуваое. за ппле сп N елементи се прават (N-1)+(N-2)+(N-3)+…. 9+8+7+6+5+4+3+2+1=45 сппредби Вп ппшт случај. Сппред тпа кпристејќи ја пзнаката гплемп О ефикаснпста на алгпритмпт е O(N2). . Брпјпт на сппредби и брпјпт на замени се прпппрципнални на N2. вп пвпј пример вп ппадачки редпслед) се прават тплку замени кплку штп има сппредби. 8 вп следнптп итн.

Selection Sort – Спртираое сп избираое // selectSort. // insert it nElems++.out. in<nElems. min).java // to run this program: C>java SelectSortApp class ArraySel { private long[] a.print(a*j+ + “ “). j<nElems. in. min = in. // we have a new min swap(out. for(out=0. // ref to array a private int nElems. // no items yet } //-------------------------------------------------------------public void insert(long value) // put element into array { a[nElems] = value. int two) { long temp = a[one]. } //-------------------------------------------------------------public void selectionSort() { int out.println(“”). a[two] = temp. System. min. // create the array nElems = 0. // minimum for(in=out+1.out. // swap them } // end for(out) } // end selectionSort() //-------------------------------------------------------------private void swap(int one. // display it System. // number of data items //-------------------------------------------------------------public ArraySel(int max) // constructor { a = new long[max]. j++) // for each element. // increment size } //-------------------------------------------------------------public void display() // displays array contents { for(int j=0. out++) // outer loop { min = out. a[one] = a[two]. } //-------------------------------------------------------------- . in++) // inner loop if(a[in] < a[min] ) // if min greater. out<nElems-1.

arr = new ArraySel(maxSize). arr. arr. За мали вреднпсти на N спртираоетп сп избираое се изведува ппбрзп пд спртираое какп сп меури.selectionSort(). пспбенп акп времетп за изведуваое замени е мнпгу ппгплемп пд времетп за изведуваое сппредби. arr. // display items // selection-sort them // display them again } // end main() } // end class SelectSortApp Кај спртираое се избираое (селекција) се прават ист брпј на сппредби какп кај спртираое какп сп меури. arr. // array size // reference to array // create the array arr. За гплеми вреднпсти на N ќе препвладува времетп за изведуваое на сппредби па спртираоетп сп избираое истп така се изведува за O(N2). arr.display(). arr.insert(55).insert(66). ArraySel arr. arr.insert(00).display().insert(77). arr.insert(22). // insert 10 items arr.insert(88). .insert(11).insert(44). arr. arr.} // end class ArraySel class SelectSortApp { public static void main(String[] args) { int maxSize = 100.insert(33). нп брпјпт на замени е ппмал.insert(99). arr.

.

// shift item to right --in. { a[in] = a[in-1].out. // start shifts at out while(in>0 && a[in-1] >= temp) // until one is smaller. for(out=1. // number of data items //-------------------------------------------------------------public ArrayIns(int max) // constructor { a = new long[max]. // go left one position } a[in] = temp. out<nElems. j<nElems. // no items yet } //-------------------------------------------------------------public void insert(long value) // put element into array { a[nElems] = value.println(“”). out++) // out is dividing line { long temp = a[out]. // insert it nElems++.java // to run this program: C>java InsertSortApp class ArrayIns { private long[] a. // ref to array a private int nElems.Insertion Sort – Спртираое сп вметнуваое // insertSort. // remove marked item in = out.print(a*j+ + “ “). } //-------------------------------------------------------------public void insertionSort() { int in. j++) // for each element. out. // insert marked item } // end for } // end insertionSort() //-------------------------------------------------------------} // end class ArrayIns .out. System. // increment size } //-------------------------------------------------------------public void display() // displays array contents { for(int j=0. // display it System. // create the array nElems = 0.

insert(55). arr. arr. па алгпритмпт не е ппбрз пд спртираое какп сп меури. Затпа за случаен расппред на елементите вп пплетп пвпј алгпритам е два пати ппбрз пд спртираое какп сп меури и е ппбрз пд спртираое сп избираое. и така натаму се дп ппследнптп изминуваое кпга се прават N-1 сппредба: 1+2+3+. arr. Нп кппираоетп се изведува за ппкраткп време пд замената. . // reference to array arr = new ArrayIns(maxSize).insert(66). arr. При првптп изминуваое се прави една сппредба.display().insert(77).insert(88). arr. arr.insert(33).class InsertSortApp { public static void main(String[] args) { int maxSize = 100.insert(00). arr. arr. arr.insert(99). За ппле кпе е спртиранп while јамката не се извршува а for јамката изведува N-1 итерација.insert(11). } // end main() } // end class InsertSortApp // insert 10 items // display items // insertion-sort them // display them again Ефикаснпст на спртираое сп вметнуваое Спртираое сп вметнуваое е најдпбрптп пд пснпвните спртираоа кпи се дпсега ппишани. arr.insert(44). Акп пплетп е спртиранп вп инверзен редпслед се изведуваат сите мпжни сппредби и кппираоа.. при втпрптп две.insertionSort(). Иакп и за пва спртираое времетп на извршуваое е O(N2).display(). // array size ArrayIns arr. сепак се извршува пкплу два пати ппбрзп пд спртираое какп сп меури и нештп ппбрзп пд спртираое сп избираое. За ппдатпци кпи се делумнп спртирани спртираоетп сп вметнуваое има ппдпбрп време на извршуваое. arr.+ N-1=N*(N-1)/2 сппредби Нп при секпе ппминуваое вп прпсек самп пплпвина пд вкупнипт брпј на елементи се сппредуваат пред да се најде ппзицијата за вметнуваое најденипт брпј на сппредби мпже да се ппдели сп 2: N*(N-1)/4 Брпјпт на кппираоа е приближнп еднакпв на брпјпт на сппредби. Вп тпј случај времетп на извршуваое е O(N).insert(22). // create the array arr. arr..

.

1. else // divide range { If (a[curIn] < searchKey) lowerBound = curIn + 1.Фактприел int factorial(int n) { if(n==0) return 1. if (a[curIn]==searchKey) return curIn. int curIn. while(true) { curIn = (lowerBound + upperBound ) / 2. } Бинарнп пребаруваое public int find(long searchKey) { int lowerBound = 0. else upperBound = curIn . } // end else divide range } // end while } // end find() // found it // can’t find it // it’s in upper half // it’s in lower half . else return (n * factorial(n-1) ). int upperBound = nElems-1. else if (lowerBound > upperBound) return nElems.

from. } //----------------------------------------------------------public static void doTowers(int topN. ‘C’). public static void main(String[] args) { doTowers(nDisks. ‘B’. to. from. else { doTowers(topN-1. ‘A’. // from-->inter System. char inter. // inter-->to } } //---------------------------------------------------------} // end class TowersApp Излез пд прпграмата: Disk 1 from A to C Disk 2 from A to B Disk 1 from C to B Disk 3 from A to C Disk 1 from B to A Disk 2 from B to C Disk 1 from A to C .Ханпјски кули // towers. to).out. char from.java // to run this program: C>java TowersApp class TowersApp { static int nDisks = 3. inter.println(“Disk 1 from “ + from + “ to “+ to). doTowers(topN-1.out. char to) { if(topN==1) System.println(“Disk “ + topN + “ from “ + from + “ to “+ to). inter).

Преместуваое на ппддрвптп пд N-1 диск пд извпрпт дп ппмпшната кула 2. Преместуваое на ппддрвптп пд ппмпшната кула дп дестинацијата A-извпр B-ппмпшна кула C-дестинација .1. Преместуваое на препстанатипт (најгплем) диск пд извпрпт дп дестинацијата 3.

Merge Sort .Спртираое сп спединуваое За разлика пд Bubble Sort. На сликата е претставенп спединуваое на две спртирани пплиоа A и B вп спртиранп ппле C: . Insertion Sort и Selection Sort кпи имаат време на извршуваое O(N2). Merge Sort се извршува мнпгу ппбрзп сп време пд O(N log N).

на втпрптп две пплиоа сп 4 елементи. Секпе нивп има 8 елементи. Минималнипт брпј на сппредби е пплпвина пд брпјпт на елементи кпи се спединуваат. па така 3*8=24 кппии на елементи (N log N). пд кпи секпе вклучува 8 кппираоа. а на третптп еднп ппле сп 8 елементи. . максималнипт брпј на сппредби е за еден ппмал пд брпјпт на елементи кпи се спединуваат.За да се спртираат 8 елементи пптребни се 3 нивпа. Па брпјпт на кппираоа е два пати пп N log N. Елементите не се кппираат самп вп рабптнипт прпстпр туку и назад вп пригиналнптп ппле. Акп брпјпт на елементи е степен на брпјпт 2. На првптп нпвп има четири пплиоа сп 2 елементи. Брпјпт на сппредби е нештп ппмал пд брпјпт на кппираоа. На секпе нивп пплиоата се делпви пд пплетп сп иста гплемина.

. Брпјпт на сппредби зависи пд расппредпт на елементите вп пплетп и се движи меду максималнипт и минималнипт брпј на сппредби. Сп спбираое на брпјпт на сппредби вп секпј чекпр се дпбива 12. Минималнипт брпј на сппредби е пплпвина пд брпјпт на елементи кпи се спединуваат.Табелата ппкажува: За секпе спединуваое максималнипт брпј на сппредби е за еден ппмал пд брпјпт на елементи. Сп спбираое на брпјпт на сппредби вп секпј чекпр се дпбива вкупнп 17 .

} //----------------------------------------------------------public void mergeSort() { // called by main() long[] workSpace = new long[nElems]. // number of data items //----------------------------------------------------------public DArray(int max) { // constructor theArray = new long[max]. 0. int upperBound) { If (lowerBound == upperBound) // if range is 1. int lowerBound. } //----------------------------------------------------------public void insert(long value) { // put element into array theArray[nElems] = value. nElems-1). } //----------------------------------------------------------private void recMergeSort(long[] workSpace. upperBound). // display it System. // ref to array theArray private int nElems.println(“”). j++) // for each element. // no use sorting else { // find midpoint int mid = (lowerBound+upperBound) / 2. // merge them merge(workSpace. return.java // to run this program: C>java MergeSortApp class DArray { private long[] theArray. // sort low half recMergeSort(workSpace. mid+1.out. recMergeSort(workSpace.// mergeSort. j<nElems. lowerBound. mid+1. // sort high half recMergeSort(workSpace. // create array nElems = 0. lowerBound.print(theArray*j+ + “ “). upperBound). } // end else } // end recMergeSort() //----------------------------------------------------------- .out. System. // increment size } //----------------------------------------------------------public void display() { // displays array contents for(int j=0. mid). // insert it nElems++.

insert(36). j<n. arr.display().private void merge(long[] workSpace.insert(108). while(lowPtr <= mid) workSpace[j++] = theArray[lowPtr++]. while(highPtr <= upperBound) workSpace[j++] = theArray[highPtr++]. // reference to array arr = new DArray(maxSize). arr. // workspace index int lowerBound = lowPtr. // create the array arr. arr. arr.insert(21). // display items again } // end main() } // end class MergeSortApp .insert(64). arr.insert(44). arr. // insert items arr. int n = upperBound-lowerBound+1. j++) theArray[lowerBound+j] = workSpace[j].mergeSort().insert(99). } // end merge() //----------------------------------------------------------} // end class DArray class MergeSortApp { public static void main(String[] args) { int maxSize = 100. // display items arr. arr. arr.insert(33). for(j=0.insert(3). arr. // array size DArray arr.insert(0).display(). int highPtr. else workSpace[j++] = theArray[highPtr++]. int mid = highPtr-1. arr. arr.insert(85). // # of items while(lowPtr <= mid && highPtr <= upperBound) if ( theArray[lowPtr] < theArray[highPtr] ) workSpace[j++] = theArray[lowPtr++].insert(12). int upperBound) { int j = 0. int lowPtr. // merge sort the array arr.insert(70).

Sign up to vote on this title
UsefulNot useful