Report on Sorting

8/6/2019 Report on Sorting

1/19

A PROJECT REPORT

ON

IMPLEMENTATION OF SORTINGTECHNIQUES IN PROLOG

SUBMITTED BY:

VIRAL RANA CE-86 &TUSHAR RATANPARA CE-87D2 BATCH

GUIDED BY:Mr. Dinesh Chatani

DHARMSINH DESAI UNIVERSITYNADIAD-387001


2/19

DHARMSINH DESAIUNIVERSITY

NADIAD

This is to certify that the Project Work carried out inthe subject of Artificial Intelligence and on the topic of IMPLEMENTATION OF SORTING TECHNIQUESis confide work of Mr. Viral Rana (CE-86) and Mr.Tushar Ratanpara(CE-87) of B.E. semester VII th in thebranch of Computer Engineering during the academicyear 2009-2010.

To the best of my knowledge and belief, the matterpresented by them is original in nature and have notbeen copied.

Staff in Charge Head of the DepartmentDate : Date :


3/19

ACKNOWLEDGEMENT

I would like to thank and acknowledge the members of

individuals who have worked on this project.

I would also like to express my heartfelt gratitude towardsMr. Dinesh Chhatani who have helped me to overcome thetechnical issues and provided me all the facilities withoutwhose help the successful completion of this project wouldnot have been possible.

Last but not least, I would like to thank all my friends whohelped and boosted me for the completion of the project.

PROJECT TEAM

Viral RanaTushar Ratanpara


4/19

Index

1. Problem Definition 5.

2. Explanation & Overview 5.

3. Program Logic 6.3.1 Algorithms3.2 Examples

4. Coding 13.

5. Sample Input/Output 17.

6. References 19 .

Program definition :


5/19

To implement sorting techniques BUBBLESORT ,INSERTIONSORT , MERGESORT and QUICKSORT inProlog.

Explanation & Overview :

Bubble Sort is that it is easy to understand andprogram. The basic idea underlying the bubble sort is to passthrough the array sequentially several times. Each pass

consists of comparing each element in the array with itssuccessor (x[i] with x[i+1]) and interchanging the two elementsif they are not in proper order. Here , N-1 passes are sufficientto sort an array of size N.

Insertion Sort, in this method there is an array link of pointers, one for each of the original array elements.Initially link[i]=i+1 for 0


6/19

2.Each of the elements in position j+1 through n-1 isgreater than or equal to a.If the foregoing process is repeated with subarraysx[0] throughx[j-1] and x[j+1] through x[n-1] and any subarrays created bythe process in successive iterations, the final result is a sortedarray.

Merge Sort, merging is the process of combining twoor more sorted files into a third sorted file. Divide the arrayinto n subarrays of size 1 and merge adjacent pairs of arrays.We then have approximately n/2 arrays of size 2. Repeat thisprocess until there is only one array remaining of size n.

Program logic :

Algorithm BUBBLESORT(A,N)This algorithm sorts an array A with N elements whereN=length(A).1.Take Boolean variable Flag and initialize to True.

2.Repeat step 3 to 5 until flag is True.3.Flag=False.4.Repeat step 5 for i=0 to N-1.5.If A[i] is greater then A[i+1] then

Flag=True,Swap A[i] & A[i+1].

6.Return.

Illustrating with an example, assume that the initial array be[3][5][4][9][2]


7/19

Elements in blue indicate comparisons.Elements in red indicate swaps.The green dash indicates return to position 0.[3][5][4][9][2] -- original-

[3][5] [4][9][2] -- compare 3 to 5[3] [5][4] [9][2] -- compare 5 to 4[3] [4][5] [9][2] -- swap 4 and 5[3][4] [5][9] [2] -- compare 5 to 9[3][4][5] [9][2] -- compare 9 to 2

[3][4][5] [2][9] -- swap 2 and 9-[3][4] [5][2][9] -- compare 3 to 4[3] [4][5] [2][9] -- compare 4 to 5[3][4] [5][2] [9] -- compare 5 to 2[3][4] [2][5] [9] -- swap 2 and 5[3][4][2] [5][9] -- compare 5 to 9-[3][4] [2][5][9] -- compare 3 to 4[3] [4][2] [5][9] -- compare 4 to 2[3] [2][4] [5][9] -- swap 2 and 4[3][2] [4][5] [9] -- compare 4 to 5[3][2][4] [5][9] -- compare 5 to 9-[3][2] [4][5][9] -- compare 3 to 2[2][3] [4][5][9] -- swap 2 and 3[2] [3][4] [5][9] -- compare 3 to 4

[2][3] [4][5] [9] -- compare 4 to 5[2][3][4] [5][9] -- compare 5 to 9

-[2][3] [4][5][9] -- compare 2 to 3[2] [3][4] [5][9] -- compare 3 to 4


8/19

[2][3] [4][5] [9] -- compare 4 to 5[2][3][4] [5][9] -- compare 5 to 9[2][3][4][5][9] -- no changes (swaps) were made in the last run,so we are done!

The time complexity of BUBBLESORT is O(n) in best caseand in worst case it is O(n^2).

Algorithm INSERTIONSORT(A,N)This algorithm sorts an array A with N elements.

1. A[0] can be taken to be as a sorted element.2. Repeat steps 3 to 5 for k = 2,3,..,N:3. Set TEMP = A[K] and PTR = K-1.4. Repeat while TEMP < A[PTR]:

(a.) Set A[PTR+1] = A[PTR]. [Moves elementforward.]

(b.) Set PTR := PTR 1.[End of loop.]

5. Set A[PTR+1] = TEMP. [Inserts element in proper place.][End of step 2 loop.]

6. Return

Here, there is an inner loop which is controlled by thevariable PTR, and there is an outer loop which uses K as anindex.

Illustrating with an example, assume that the initial arraybe77,33,44,11,88,22,66,55


9/19

Here, the first element is 77.The first element can be taken as sorted since it is a singleelement( as per the algorithm )

Pass A[0] A[1] A[2] A[3] A[4] A[5] A[6] A[7]K=1 77 33 44 11 88 22 66 55K=2 77 33 44 11 88 22 66 55K=3 33 77 44 11 88 22 66 55K=4 33 44 77 11 88 22 66 55K=5 11 33 44 77 88 22 66 55K=6 11 33 44 77 88 22 66 55

K=7 11 22 33 44 77 88 66 55K=8 11 22 33 44 66 77 88 55Sorted: 11 22 33 44 55 66 77 88

Algorithm QUICKSORT(S)

1: Do step 2 until S becomes empty.2: If |S| = 1 then return S else choose a S.3: Split the sequence S into three subsequences S1,S2 and S3such thatelements of S1 < a,elements of S2 = a andelements of S3 > a.4: Return (QUICKSORT(S1) U S2 U (S3)).

Quicksort is also known as Partition Exchanged Sort. This isclear from the following explanation.

Illustrating with an example, let the initial array be given as


10/19

25 57 48 37 12 92 86 33

and the first element is placed in its proper position, theresulting array is

12 25 57 48 37 92 86 33

At this point, 25 is in the proper position in the array (x[1]),each element below that position (12) is less than or equal to25, and each element above that position (57,48,37,92,86 and33) is greater than or equal to 25. Since 25 is in its finalposition the original problem has been decomposed into the

problem of sorting the two subarrays.

(12) and (57 48 37 92 86 33)

Nothing need be done to sort the first of these subarrays; a fileof one element is already sorted. To sort the second subarraythe process is repeated and the subarray is further subdivided.The entire array may now be viewed as

12 25 (57 48 37 92 86 33)

where parentheses enclose the subarrays that are yet to besorted. Repeating the process on the subarray x[2] throughx[7] yields

12 25 (48 37 33) 57 (92 86)

and further repetitions yield

12 25 (33 37) 48 57 (92 86)

12 25 (33) 37 48 57 (92 86)


11/19

12 25 33 37 48 57 (92 86)

12 25 33 37 48 57 (86) 92

12 25 33 37 48 57 86 92Note that the final array is sorted.

The time complexity of QUICKSORT is O(n log 2 n) in bestcase and in worst case it is O(n^2).

Algorithm MERGESORT(A)1.Take Length L=Length(A).2.If L


12/19

Illustrating with an example, assume that the initial arraybe38,27,43,3,9,82,10.

The time complexity of MERGESORT is (n log n) in bestas well as worst case.


13/19

Coding

BUBBLESORT :

domainslist=integer*

predicatesbubblesort1(list,integer,list)bubblesort(list,list)

clausesbubblesort1(L1,1,L1):-!.

bubblesort1(L1,C,L2):-C>0,bubblesort(L1,X),CC=C-1,bubblesort1(X,CC,L2).

bubblesort([A],[A]):-!.

bubblesort([H1|[H2|L1]],[H1|L]):-H1


14/19


15/19

QUICKSORT :

domainsint = integerlist = int*

predicatesquicksort(list,list)split(int,list,list,list)combine(list,list,list)

clausesquicksort([],[]).

quicksort([X|Tail], Sorted) :-split(X, Tail, Small, Big),quicksort(Small, SortedSmall),quicksort(Big, SortedBig),combine(SortedSmall, [X|SortedBig], Sorted).

split(X, [], [], []).

split(X, [Y|Tail], [Y|Small], Big) :-X > Y, !,split(X, Tail, Small, Big).

split(X, [Y|Tail], Small, [Y|Big]) :-split(X, Tail, Small, Big).

combine([], L, L).

combine([X|L1], L2, [X|L3]) :- combine(L1, L2, L3).


16/19

MERGESORT:

domainslist=integer*

predicatesmergesort(list,list)divide(list,list,list)my_merge(list,list,list)

clausesmergesort([], []).

mergesort([A], [A]).mergesort([A, B | Rest], S) :-

divide([A, B | Rest], L1, L2),mergesort(L1, S1),mergesort(L2, S2),my_merge(S1, S2, S).

divide([], [], []).divide([A], [A], []).

divide([A, B | R], [A | Ra], [B | Rb]) :-

divide(R, Ra, Rb).

my_merge(A, [], A).my_merge([], B, B).

my_merge([A | Ra], [B | Rb], [A | M]) :-

A B,my_merge([A | Ra], Rb, M).


17/19

SAMPLE INPUT - OUTPUT:

For BubbleSort:

For Insertionsort:


18/19

For Quicksort:

For MergeSort:


19/19

References :

1. Introduction To Turbo Prolog

by Carl Townsend

2. Data Structuresby Yedidyah Langsam,

Moshe J. AugensteinAaron M. Tenenbaum

Report on Sorting

Documents

Transcript of Report on Sorting