115 cs Algorithms and Data Structures-1. Sorting: To arrange the elements into ascending or descending order.

Transcription

1 cs Algorithms and Data Structures- Sorting Chapter-6 Sorting: To arrange the elements into ascending or descending order. sort ( ) : It is a method found in "java.util.arrays" package. it is a static method present in arrays class. it is use to sort any type(int, long, double, char, byte) of elements. Example: public static void sort (datatype[ ] a) Sorts the specified array of any data type (int, long, double, char, byte)into ascending numerical order. There are many type of sorting ) Bubble sort ) Linear/Sequential sort ) Selection sort 4) Insertion sort ) Shell sort 6) Merge sort 7) Quick sort ) Heap sort, etc... BUBBLE SORT: In this sort array is scanned from bottom up and two adjacent elements are interchange, if they are out of order, with respect to each other. First items data[n-] and data[n-] are compared and swapped if they are out of order. Next, data[n-] and data[n-] are compared and swapped if they are out of order. And so on up to data[] and data[0]. In this way smallest element is bubbled up to the top of array. This is only for first pass through array, the array is scanned again comparing adjacent items and interchange them when needed, but the last comparison is done for data[] and data[] because the smallest element is placed already in its proper position 0. Page of

2 The second pass bubbles up the second smallest element of array up to second position, the procedure is continues until the last pass when only one comparison, data[n-] with data[n-], and possibly one interchange are performed. i=0 j=4 j= j= j= i= j=0,4 j= i= j=,4 j= i= j=,4 j= ALGORITHM: bubblesort ( data[] ) for( i=0 ; i<data.length- ; i++ ) for( j=data.lenght- ; i<data.length- ; j-- ) swap elements in position j and j-, if they are out of order; JAVA IMPLEMENTATION public void bubblesort(int data[]) int i,j; for(i=0;j<data.length-;i++) temp = data[i]; for(j= data.length-;j>i;j--) if(data[j-]<data[j]) swap(data,j,j-); The numbers of comparisons are the same in each case (best, worst and average) and equals number of iterations of inner for loop. WORST CASE: Page of

3 When the array is in reverse order. Moves have to be made. BEST CASE: When all elements are in already order requires no swap. AVERAGE CASE: In average case, if elements are randomly order, is 0,one,two or number of swap which is. We can calculate average Which is equal to moves DISADVANTAGE The main disadvantage is that at bubbles the items step by step towards the top of the average. JAVA IMPLEMENTATION class BubbleSort private data int[]; private int noelement; BubbleSort(int size) data = new int,j; noelement = 0; void insertdata(int value) data[noelement] = value; noelement++; void display() int i; noelement++; for(i=0;j<data.length-;i++) System.out.print(data[i]+n[i]+" "); Page of

4 void swap(int e, int e) int temp; temp = data[e]; data[e] = data[e]; data[e] = temp; void swap(int e, int e) int temp; temp = data[e]; data[e] = data[e]; data[e] = temp; void sort() int i,j; for(i=0;j<data.length-;i++) if(data[j-] > data[j]) swap(j-,j); class MainProg public static void main(string [] args) BubbleSort obj = new BubbleSort(); obj.insertdata(); obj.insertdata(0); obj.insertdata(); obj.insertdata(4); obj.insertdata(); obj.sort(); obj.display(); SELECTION SORT: Selection sort is an attempt to localize the exchange of array elements by finding a misplaced element first and putting it in its find place. The element with the lowest value is selected and exchange with the element in the first position. Then for n=data.length the smallest value among the remaining element data[], data[ ] is found and put in second position. This selection and placement by finding in each pass, the lowest value among the elements data[], data[ continue until all elements in their proper position: ] and swapping it with data[ ] are Page 4 of

5 int a[] =,,,, i=0 j=,,,4 i= j=,,,4 i= j=,4 i= j=4 0 4 ALGORITHM: Selectionsort(data[]) for(i=0;i<data.length-;i++) select smallest element array data[ ] data[data.length-] swap it with data[i]; JAVA IMPLEMENTATION: public void Selection(data[]) int i,j,least; for(i=0;i<noelement;i++) for(j=i+,least=i-;j< data.length;j++) if(data[j]<data[least]) least=j; swap(data,least;i); void swap(a[],int e, int e) int tmp; tmp = a[e]; Page of

6 a[e] = a[e]; a[e] = tmp; The outer loop executes ( ) times, and for each between 0 and ( ) the inner loop iterates j times. This number is came for all cases. BEST CASE: When an ordered array is sorted, no array elements are swapped. WORST CASE: When largest element is in the first position and remaining elements are ordered, the swapping method is called as many times as outer loop iterates which is. That times are moved. Example : class SelectionSortExample private data int[]; private int noelement; public Selectionsort(int max) data = new int[max]; noelement = 0; public void Insertvalue(int value) Data[noElement] = value; noelement++; public void display() for(i=0;i<data.length;i++) System.out.print(data[i]+n[i]+" "); public void Selectionsort() int i,j,least,tmp; for(i=0;i<noelement;i++) Page 6 of

7 for(j=i++,least=i;j<noelement;j++) System.out.print(data[i]+n[i]+" "); tmp = data[e]; data[e] = data[e]; data[e] = data[e]; class Insertsort public static void main(string args[]) int maxsize = ; Insersort arr = new Insertsort(maxsize); arr.insertvalue(0); arr.insertvalue(); arr.insertvalue(); arr.insertvalue(); arr.insertvalue(6); arr.display(); arr.sort(); arr.display(); INSERTION SORT: An insertion sort starts by considering the two first elements of the array data which are data[0], and data[]. - If they are out of order, interchange takes place. - Then the third element, data[] is considered and inserted into proper place. - If data[] is less than data[0] and data[], then two elements are shifted by one position; data[0] is placed of position, data[] is placed of position and data[] of position 0. - If data[] is less than data[] and greater then data[0], the only data[] is moved to position and its place is taken by data[]. - If data[] is not less than both predecessors. Then it will be its current position. ALGORITHM: Insertionsort(data[]) for(i=; i<data.length;i++) temp =data[i]; move all elements data[j] greater then temp by one position; place temp in its props position; Page 7 of

8 Example: public static void insertsort(string args[]) int temp,i,j; for(i=;j<data.length;i++) temp = data[i]; for(i=;j>0&&temp<data[j-];i--) data[j] = data[j-]; data[j] = temp; int a[] =,,,, i= j= tmp= 0 4 j=0 i= j= tmp= j= i= j= tmp= i=4 j=4 tmp= j= j= j= j=0 ADVANTAGE: An advantage of insertion sort is that it sorts the array only when it is really necessary. If the array is already in order, no substantial moves are performed. DISADVANTGE: If an item is begin inserted, all elements greater than the one begin inserted have to be moved. The number of redundant moves can slow down execution. BEST CASE: the best case is when the data are already in order only one comparsion is made for each position there are comparsions. And moves.,so WOREST CASE: Page of

9 The worest case is whn the data are in revese order. For each, the item data[ ] lessterm every item data[0] data[ ] and each of them is moved by one position. For each iteration of the outer loop; these are comparisions and total number of comparsions for all iterations of the loop is Approximately one half of the number of compression in worst case. Example: class Insertsort private data int[]; private int noelement; public Insertsort(int max) data = new int[max]; noelement = 0; public void Insertvalue(int value) data[noelement] = value; noelement++; public void display() for(i=0;i<noelement;i++) System.out.print(data[i]+n[i]+" "); System.out.println(" "); public void sort() int i,j; for(i=;i<noelements;i++) int tmp = data[i]; for(j=i;j>0&&tmp<data[j-];j--) data[j] = data[j-]; data[j] = tmp; class Insertsort public static void main(string args[]) Page 9 of

10 MERGE SORT int maxsize = ; Insersort arr = new Insertsort(maxsize); arr.insertvalue(0); arr.insertvalue(); arr.insertvalue(); arr.insertvalue(); arr.insertvalue(6); arr.display(); arr.sort(); arr.display(); The merge sort method follows the technique of divide and conquer. The technique works in the principle where a given set data[0] data[ ] is split into distinct subset and required method is applied. On subset separately. - Step : Divide the sequence of elements into two equal parts. - Step : Recursively sort the elements of the left part. - Step : Recursively sort the elements of the right part. - Step 4: Merge the sorted right parts into single sorted array. We divide the array into two parts based on mid value if low is the index of first element and high is the index of last element, then The left part contains elements from low to mid and right part contains elements from (mid+) to high. ALGORITHM mergsort(data,low,high) if low < high mid = (low + high ) / ; mergesort(data,low,mid); mergesort(data,mid+,high); ALGORITHM mergsort(array,low,high) mid = (low + high ) / ; i = 0; i = low; i = mid+; while both left and right sub array of array contains elements if array[i] < array[i] temp[i++] = array[i++]; Page 0 of

11 else temp[i++] = array[i++]; MERGE SORTING MECHANISM Page of

12 JAVA IMPLEMENTATION class MergeExample private data int[]; private int noelement; MergeExample(int size) data = new int[size]; noelement = 0; void insertdata(int value) data[noelement] = value; noelement++; void display() int i; for(i=0;j<noelement;i++) System.out.print(data[i]+n[i]+" "); public void mergesort() int [] workspace = new int [noelement]; recmergesort(workspace,0,noelement-); public void recmergesort(int [] workspace,int low,int high) if(low == high) return; else int mid = (low+high)/; recmergesort(workspace,low,mid); recmergesort(workspace,mid+,high); private void merge(int [] workspace, int hptr,int high) int j,i; Page of

13 int mid = hptr ; int lowptr = low; while(low <= mid && hptr <= high) if(data[low] == data[hptr]) workspace [j] = data[low]; low++; j++; else workspace[j++] = data[htpr++]; while(low <= mid) workspace[j++] = workspace[low++]; while(htpr <= high) workspace[j++] = workspace[hptr++]; n = high - lowptr + ; for(i=0;i<n;i++) data[i] = workspace[i]; class MergeSort public static void main(string [] args) MergeExample obj = new MergeExample(); obj.insertdata(); obj.insertdata(0); obj.insertdata(); obj.insertdata(4); obj.insertdata(); obj.display(); obj.mergesort(); obj.display(); Page of