Algorithms & Data Structure I - Lecture 5

Algorithm & Data Structure I – AAU – Instructor: Albohtori Mohammed
Algorithm & Data Structure I
Simple Sorting Algorithms

Selection, Bubble and Insertion
Albohtori Mohammed Salih
Alzaiem Alazhari University

Department of Electrical Engineering (Computer Engineering)
5th Lecture, March 4, 2020
1
Overview
 The Sorting Problem
 Bubble Sort
 Example of Bubble sort
 Pseudo Code for Bubble sort
 Bubble sort Implementation
 Analysis of Bubble sort
 Selection Sort
 Example of Selection sort
 Pseudo Code for Selection sort
 Selection sort Implementation
 Insertion Sort
 Example of Insertion sort
 Insertion sort Implementation
 Analysis of Insertion sort
 Summary
2
The Sorting Problem

 Sorting refers to arranging data in a particular format.
Sorting algorithm specifies the way to arrange data in a
particular order. Most common orders are in numerical or
alphabetical order.
 Sorting is also used to represent data in more readable
formats. Following are some of the examples of sorting in
real-life scenarios:
 Telephone Directory: The telephone directory stores
the telephone numbers of people sorted by their names,
so that the names can be searched easily.
 Dictionary: The dictionary stores words in an
alphabetical order so that searching of any word
becomes easy.
3
The Sorting Problem

 The objective of the sorting problem: to
rearrange a given sequence of items.
 It is one of the fundamental problems in computer
science, can be solved in many ways:
 There are many sorting algorithms
 Some are faster/slower than others
 Some use more/less memory than others
 Some work better with specific kinds of data
 Some can utilize multiple computers / processors, ...
4
The Sorting Problem

There are many sorting algorithms:
 Bubble sort: swap adjacent pairs that are out of order.
 Selection sort: look for the smallest element, move to front.
 Insertion sort: build an increasingly large sorted front portion.
 Shell sort: This algorithm is a simple extension of Insertion sort.
 Heap sort: place the values into a sorted tree structure.
 Merge sort: recursively divide the array in half and sort it.
 Quick sort: recursively partition array based on a middle value.
5
In-place Sorting and Not-in-place Sorting

 Sorting algorithms may require some extra space for
comparison and temporary storage of few data
elements. These algorithms do not require any extra
space and sorting is said to happen in-place, or for
example, within the array itself. This is called in-place
sorting. Bubble sort is an example of in-place sorting.
 However, in some sorting algorithms, the program
requires space which is more than or equal to the
elements being sorted. Sorting which uses equal or
more space is called not-in-place sorting. Merge-sort
is an example of not-in-place sorting.
6
Stable and Not Stable Sorting

 If a sorting algorithm, after sorting the contents,
does not change the sequence of similar content in
which they appear, it is called stable sorting.
7
Stable and Not Stable Sorting

 If a sorting algorithm, after sorting the contents,
changes the sequence of similar content in which
they appear, it is called unstable sorting.
 Stability of an algorithm matters when we wish to maintain

the sequence of original elements, like in a tuple for
example.
8
The Sorting Problem

 To define an instance of a sorting problem, we must
specify:
 The type of the sequence
 The number of items to be sorted
 The ordering relationship.
 Consider the following instance of the sorting
problem: an array of integers A, containing N items
is to be sorted in ascending order.
 We will review three algorithms for sorting known as
elementary sorts:
 The Bubble sort algorithm.
 The Selection sort algorithm.
 The Insertion sort algorithm. 9
Bubble Sort
 Bubble sort is a simple sorting algorithm. This
sorting algorithm is comparison-based algorithm in
which each pair of adjacent elements is compared
and the elements are swapped if they are not in
order.
 This algorithm is not suitable for large data sets as
its average and worst case complexity are of Ο(n2)
where n is the number of items.
10
Bubble Sort
 Compare each element (except the last one) with its
neighbor to the right
 If they are out of order, swap them
 This puts the largest element at the very end
 The last element is now in the correct and final place
 Compare each element (except the last two) with its
 If they are out of order, swap them
 This puts the second largest element next to last
 The last two elements are now in their correct and final places
 Compare each element (except the last three) with its
 Continue as above until you have no unsorted elements on the left
11
Example of Bubble sort
7 2 8 5 4 2 7 5 4 8 2 5 4 7 8 2 4 5 7 8
2 7 8 5 4 2 7 5 4 8 2 5 4 7 8 2 4 5 7 8
2 7 8 5 4 2 5 7 4 8 2 4 5 7 8 (done)
2 7 5 8 4 2 5 4 7 8
2 7 5 4 8
12
Pseudo Code for Bubble sort

Algorithm BubbleSort(Data[0 .. N-1])
//Purpose: Sort a given array by Bubble sorting algorithm
//Input: An array Data[0 .. N-1]
//Output: Array Data [0..N-1] values, sorted in ascending order
Begin
For (i=N-1 to 0) Do
For (j=0 to i-1) Do
If (Data [j] > Data [j+1]) then
Swap (Data [j] with Data [j+1])
Endif
EndFor
EndFor
Return Data[0... N-1]
EndAlgorithm
13
Bubble sort Implementation

public class BubbleSort {
public static int[] bubbleSort(int[] a) {
int outer, inner;
for (outer = a.length - 1; outer > 0; outer--) { // counting down
for (inner = 0; inner < outer; inner++) { // bubbling up
if (a[inner] > a[inner + 1]) { // if out of order...
int temp = a[inner]; // ...then swap
a[inner] = a[inner + 1];
a[inner + 1] = temp; } } }
return a;
}
public static void main(String[] args) {
int[] myArray = { 6,2,8,4,12,77,32,28,16};
int[] sorted = bubbleSort(myArray);
System.out.println(“Array after Sorted : ");
for (int i = 0; i < sorted.length; i++) {
System.out.print(sorted[i] + ", ");
}
}} 14
Analysis of Bubble sort

 for (outer = a.length - 1; outer > 0; outer--) {
for (inner = 0; inner < outer; inner++) {
if (a[inner] > a[inner + 1]) {
// code for swap omitted
} } }
 Let n = a.length = size of the array
 The outer loop is executed n-1 times (call it n, that’s close
enough)
 Each time the outer loop is executed, the inner loop is
executed
 Inner loop executes n-1 times at first, linearly dropping to just once
 On average, inner loop executes about n/2 times for each
execution of the outer loop
 In the inner loop, the comparison is always done (constant time),
the swap might be done (also constant time)
 Result is n * n/2 * k, that is, O(n2/2 + k) = O(n2) 15
Selection Sort
 Selection sort is a simple sorting algorithm. This
sorting algorithm is an in-place comparison-based
algorithm
 The smallest element is selected from the unsorted
array and swapped with the leftmost element, and
that element becomes a part of the sorted array.
This process continues moving unsorted array
boundary by one element to the right.
its average and worst case complexities are of
Ο(n2), where n is the number of items.
16
Selection Sort
 Given an array of length n,
 Search elements 0 through n-1 and select the smallest
 Swap it with the element in location 0
 Continue in this fashion until there’s nothing left to
search.
17
Example of Selection sort
7 2 8 5 4
2 7 8 5 4
2 4 8 5 7
2 4 5 8 7
2 4 5 7 8
18
Pseudo Code for Selection sort

Algorithm SelectionSort(Data[0 .. N-1])
//Purpose: Sort a given array by Selection sorting algorithm
//Input: An array Data[0 .. N-1]
//Output: Array Data [0..N-1] values, sorted in ascending order
Begin
For (i=0 to N-1) Do
Min = i
For (j=i+1 to N-1) Do
If (Data [j] < Data [min]) then
Min = j
Endif
EndFor
Swap (Data [i] with Data [min])
EndFor
Return Data[0... N-1]
EndAlgorithm
19
Selection sort Implementation

public static int[] swap(int[] a, int x, int y) {
int temp = a[x];
a[x] = a[y];
a[y] = temp;
return a;
}
public static int[] selectionSort(int[] a) {
int outer, inner, min;
for (outer = 0; outer < a.length; outer++){
min = outer;
for (inner = outer+1; inner < a.length; inner++){
if (a[inner]< a[min]){
min = inner;
}
}
a = swap(a, outer, min);
}
return a;
} 20
Insertion Sort
 This is an in-place comparison-based sorting
algorithm.
 The array is partitioned into two parts, sorted (on
the left) and unsorted (on the right).
 Initially the unsorted part has one element. In each

pass, the first element of the unsorted part is
inserted in the appropriate location in the sorted left
block.
its average and worst case complexity are of Ο(n2),
where n is the number of items.
21
Example of Insertion sort
sorted next to be inserted

3 4 7 12 14 15 20 21 33 38 10 55 9 23 28 16
temp
less than 10
10
3 4 7 10 12 14 15 20 21 33 38 55 9 23 28 16
sorted
22
Insertion sort Implementation

public static int[] insertionSort(int[] array, int first, int last) {
int temp, k;
for (int i = first; i < last; i++) {
temp = array[i];
k = i;
while ((k > 0) && (array[k - 1] > temp)) {
array[k] = array[k - 1];
k--;
}
array[k] = temp;
}
return array;
}
23
Analysis of Insertion sort

 We run once through the outer loop, inserting each
of n elements; this is a factor of n
 On average, there are n/2 elements already sorted
 The inner loop looks at (and moves) half of these
 This gives a second factor of n/4
 Hence, the time required for an insertion sort of an
array of n elements is proportional to n2/4
 Discarding constants, we find that insertion sort is
O(n2)
24
Summary
 Most of the sorting techniques we have discussed are
O(n2)
 We can do much better than this with somewhat more
complicated sorting algorithms
 Within O(n2),
 Bubble sort is very slow, and should probably never be used for
anything
 Selection sort is intermediate in speed
 Insertion sort is usually faster than selection sort. In fact, for small
arrays (say, 10 or 20 elements), insertion sort is faster than more
complicated sorting algorithms
 Selection sort and insertion sort are “good enough” for small
arrays
25
Exercise
Rewrite the bubble sort, selection sort and insertion

sort algorithms for String data type
26

Algorithms & Data Structure I - Lecture 5

Uploaded by

Document Information

Original Title

Copyright

Available Formats

Share this document

Share or Embed Document

Sharing Options

Did you find this document useful?

Is this content inappropriate?

Copyright:

Available Formats

Algorithms & Data Structure I - Lecture 5

Uploaded by

Copyright:

Available Formats

Algorithm & Data Structure I – AAU – Instructor: Albohtori Mohammed

Algorithm & Data Structure I

Simple Sorting Algorithms

Albohtori Mohammed Salih

Alzaiem Alazhari University

5th Lecture, March 4, 2020

The Sorting Problem

The Sorting Problem

The Sorting Problem

 Bubble sort: swap adjacent pairs that are out of order.

 Selection sort: look for the smallest element, move to front.

 Insertion sort: build an increasingly large sorted front portion.

 Shell sort: This algorithm is a simple extension of Insertion sort.

 Heap sort: place the values into a sorted tree structure.

 Quick sort: recursively partition array based on a middle value.

In-place Sorting and Not-in-place Sorting

Stable and Not Stable Sorting

Stable and Not Stable Sorting

 Stability of an algorithm matters when we wish to maintain

The Sorting Problem

Example of Bubble sort

Pseudo Code for Bubble sort

Bubble sort Implementation

Analysis of Bubble sort

Example of Selection sort

Pseudo Code for Selection sort

Selection sort Implementation

 Initially the unsorted part has one element. In each

Example of Insertion sort

sorted next to be inserted

Insertion sort Implementation

Analysis of Insertion sort

Rewrite the bubble sort, selection sort and insertion

You might also like