# Bubble and Straight Insertion Sort in Python

Thu 18 January 2007 by Thejaswi Puthraya

## Bubble and Straight Insertion Sort in Python

Recently I got my hand on the book Introduction to the Design and Analysis of Algorithms (http://worldcat.org/oclc/2463560) by S.E.Goodman and S.T.Hedetniemi published by the Mc-Graw Hill Company. The book is out of print now and I found it in a library. The book had never been lent and I was the lucky first person to borrow it (20 years after it had been bought). This highlights the negligience of libraries and reading habits in Hyderabad (India). Half way through the book (after having read the various sorting algorithms) I decided to give my programming skills in Python a test. I first started out writing the bubble sort program. This was probably the easiest sorting algorithm to code. Then I wrote the straight insertion sort, a better performer than the bubble sort. Though the quick sort algorithm is the most efficient algorithm, I haven't been able to code it (as of now). I am presently working on it and the program might be out soon.

### Bubble Sort

```for i in xrange(len(a)):
for j in xrange(i+1,len(a)):
if a[i]>a[j]:
tmp = a[i]
a[i] = a[j]
a[j] = tmp
```

Here "a" is the list of integers to be sorted. I used the random module to generate the random data for the list.The funda of the bubble sort is to compare a particular element with all the other elements in the list. Whenever it finds a number lower than it, it swaps places with the number and the comparison goes on. Since every element (say for a N-length array) must be compared with N-1 elements and this comparison goes on for all the N elements, this algorithm is usually not preferred. It is taught in colleges and schools because it is the easiest to realise.

### Straight Insertion Sort

```for j in xrange(1,len(a)):
k=a[j]
l=j-1
while k <>=0:
a[l+1]=a[l]
l=l-1
a[l+1]=k
```

We move along a fixed direction of the unsorted list and try to locate the correct location of the number ie until all the sorted numbers with smaller values come before it and all those with larger values come after it:

```Unsorted List --> 27 412 71 81 59 13
Iteration 0: Unsorted 412 71 81 59 13    Sorted 27
Iteration 1: Unsorted 71 81 59 13        Sorted 27 412
Iteration 2: Unsorted 81 59 13           Sorted 27 71 412
Iteration 3: Unsorted 59 13              Sorted 27 71 81
Iteration 4: Unsorted 13                 Sorted 27 59 71 81 412
Iteration 5: Unsorted                    Sorted 13 27 59 71 81 412
```

Then I wrote the main program ie generation of random data, sorting and verifying which is better of the two algorithms.

### Generation of Random Data

```import random
a = []
matdim = input('Enter the number of elements for the array: ')
for i in xrange(matdim):
a.append(random.randint(1,10000))
```

Next we check which sorting program is the best (amongst the two)

Results of Bubble Sort and Straight Insertion Sort:

```Number of Elements          10          50           100            200               500            1000         5000
Bubble Sort                 0.0548      0.951        4.0509         13.540            127.595        379.938      8212.631
Straight Insertion Sort     0.0381      0.725        2.723          10.940            111.083        303.351      6697.399
All times in milliseconds
```

The data has been rounded off to the third place of decimal. Note: The data has been obtained using Python 2.4.4 on an AMD Athlon XP Machine 2.4GHz running Fedora Core 6 with kernel 2.6.18-1.2798.fc6. The mileage may vary for tests on other machines.

Checking: The execution profile of the sorting program has been checked using the time module. There is a better way of determining the execution profile using the timeit module. I decided not to use it since I just wanted an approximate time of execution. The primary objective was to show that Straight Insertion Sort is better than Bubble Sort.

Last Note: As we can see from the table Straight Insertion Sort is faster compared to Bubble Sort. Quick Sort is a lot faster than either of the two sorts but it is comparitively more complex to code. I am presently breaking my head over how to code the Quick Sort Algorithm in Python (without using stacks). Hopefully should be out with it in a couple of weeks.