A sort implementation comparing with Bubble sort and Selection sort

Ramin Edjlal Armin Edjlal and Tayebeh Moradi

Islamic Azad University of Urmia's branch University of applied science and technology
School Of Computer Engineering School of Information Technology
Urmia,Iran Urmia,Iran
Codesandart@gmail.com Armin.Edjlal@gmail.com
tabeyeh@yahoo.com

Abstract—Today implementation of sort leads to lower and n: = n − 1

easier order time. Our purpose in this article are trying to For each i in 0 to n − 1 inclusive do:
introduce an algorithm with lower cost of Bubble sort and {
nearly same as Selection sort. A way is in orderly inserting of
elements in another array. Sort is an algorithm that arranges
if A[ i ] > A[ i + 1 ] then
all elements of an array ,orderly. This algorithm has sequential Swap ( A[ i ], A[ i + 1 ] )
form. The order of Selection sort complexity is nearly least Swapped: = true
than Bubble sort. }
}
Keywords-component; sort ; inserting ; Algorithm
g(n)= 3n2+4n+2
For c=4 and n>0 its order is:
O (4n2).
I. INTRODUCTION B. Selection Sort
Specific field and new data that there are in given of the The Selection sort order is nearly the Bubble sort but it
programmer, are none sorted. Some times these data need to is least than it. This algorithm is called Selection sort because
be sort with specified order. Like student lists by average, list with maximum index of array, is arranged indexes and is
of employees by personality number and etc. It said that sort inserted maximum index in specific location, body of this
is an algorithm that arranges the element's of an array by algorithm has differences of Bubble sort as below:
specific order. The order time execution of algorithm is void Selection sort (int arr[] , int n)
lower than Bubble and nearly same as Selection sort and is {
nearly O(n2). An implementation of sort refers to sequential register int i , j;
form and insertion array, orderly by an extra sorting array. int max , temp;
for (i = n − 1 ; i >0 ; i −−)
II. RELATED WORKS {
Order time of this sort –Bubble sort-is O(n2). One sort max = 0;
simple algorithm that moves around a list toward front or for (j = 1 ; j <= i ; j++)
back until every test time with its behind index compared if (arr[ max ] < arr[ j])
and swap, if is in incorrect place. This algorithm must {
continue until there is not any swap in a list. This algorithm
max = j;
called Bubble because every index is compared with behind
temp = arr[ i];
index and when it is smaller than the key, it gives its location
to another one and these continues until the smaller index is arr[i] = arr[ max];
gone to downer location of list and others become sorted. arr[max] = temp;
Bubble sort is a rather weak algorithm that for some strange }
reason dominates introductory courses. The Bubble and }
Selection sort so do code are brought below: }

A. Bubble sort: Its complexity function in worst state is:

Void Bubble Sort (A: list of sort able items) g(n)=2n2−2n−1
{ And the Selection sort order is near O( ). But in worst
N: = length (A)
Do state has O(2n2) order.
III. PROPOSED METHOD
Swapped: = false
___________________________________
978-1-61284-840-2/11/$26.00 ©2011 IEEE



Authorized licensed use limited to: Ingrid Nurtanio. Downloaded on October 01,2020 at 02:17:29 UTC from IEEE Xplore. Restrictions apply.
 Sort Implemantation is sequential programming strategy. better than it.Horizontal axis indicates number of indexes
every elements of array insert by conditions into an extra and vertical indicates the time in millisecond.The time
array like Table1. The inizial conditions and call for array are: execution of this method is higher than two other untile 520 ,
after that the time execution is lower than Bubble sort and
int[ ] d = new int [n]; from 2000 the time execution of It, Selection sort is better.
for (int i = 0; i < n; i++) The results are brought in Table2 and Figure1.
d[i] = −1; Experimental results are:
H = 0; TABLE II Results
c = Sort(a, c,d, n);
Kind 10 510 1010 1510 2010 2510
S 0 15.48 65.1 148.13 263.13 416.63
IV. TIME COMPLEXITY,CALCULATION B 0 23.65 88.63 200.63 356.65 549.50
The order of this algorithm has O(n2) .That is computed I 10.33 17.98 67.65 143.15 265.63 441.96
as:
g(n)= 2n2+3n+2
That is function of complexity:
For c=3 and n>0 the order is equal:
O (3n2).
As test illustrates the performance of this algorithm is
better than Bubble sort for great arrays.

V. TIME COMPLEXITY,EXECUTION
The result are brought in Figure1. The lines from top to
down are for Bubble sort , and Improved sort and Selection
sort orderly. The exam indicated that the Bubble sort was in
worst state and the improved sort-our implementation- was
Figure 1 Experimantes

TABLE I Imperoved Sort

VI. CONCLUSION
Code by line Order As a result we find a new sort algorithm with lower cost
int[] sort[] a, int[] c, int[] d, int n) 0
of time by Bubble and nearly same as Selection sort. We
{ 0
while (H < n) n+1 proposed algorithm so do code and calculated the order time
{ 0 and propose a test in order to show experimental results.
int Lastindex = −1; 1 With a computer we consider the options and results
bool FirstIndex = false; 1
concluded that this algorithm has the lower cost of Bubble
for (int i = 0; i < n; i++) n+1
0 and Selection sort complexity.
{
if ((i == d[i]))
0 References:
1
continue;
0 [1] Assignment 4: Sort Lab-Kudos to Julie Zelenski and Eric Roberts for
else
0 the handout-October 15th , 2010
{ 0
if (!FirstIndex) 0
[2] Algorithms Design with c so do code by kiomarth naimipor-Richard
{ Neapolitan
1
Lastindex = i; 1 [3] Algorithms Design by Ellis Haritos
FirstIndex = true; 0 [4] Design and analysis of algorithms with Dr. Behroz –Golizadeh
} 0 [5] Design of Algorithms by Kederman…
if (a[Lastindex] < a[i]) 1
[6] Knuth, D. Sorting by Exchanging. “The Art of Computer
Lastindex = i; 0
Programming, Volume 3: Sorting and Searching, Second Edition.”
} 0
1997. Pp.106-110
} 0
0 [7] Knuth, D. Sorting by Selection. “The Art of Computer Programming,
if ((Lastindex != −1) & (H <= n))
1 volume 3: Sorting and Searching, Second Edition.” 1997. Pp.138-141
{
1 [8] Knuth, D. Sorting by Insertion. “The Art of Computer Programming,
d[Lastindex] = Lastindex;
1 volume 3: Sorting and Searching, Second Edition.” 1998. Pp.80-105
c[n − 1 − H] = a[Lastindex]; 0
H++; [9] http://fa.wikipedia.org/wiki
0
} 0
} 0
return c; }



Authorized licensed use limited to: Ingrid Nurtanio. Downloaded on October 01,2020 at 02:17:29 UTC from IEEE Xplore. Restrictions apply.