Data Structures

Lecture : Sorting and Searching Algorithm

http://visualgo.net/
Go to the link for course materials:
https://drive.google.com/open?id=0B88ti1PlrP6qRjVmSkxsOXJGcXM
 Scope
• Several sorting algorithms, including:
– bubble sort
– selection sort
– insertion sort
– counting sort

•Searching, includes:
– linear search
– binary search algorithms

• Complexity of the search and sort algorithms

2
 Sorting
 Process to convert the Unordered list to Ordered list.

Index 0 1 2 3 4

Unordered 21 20 27 19 16
list

Index 0 1 2 3 4

Ordered 16 19 20 21 27
list

Ascending order
Descending order
3
 Bubble Sort
Concept:
 Compare 1st two elements
 If out of order, exchange them to put in order
 Move down one element, compare 2nd and 3rd
elements, exchange if necessary. Continue until end
of array.
 Pass through array again, exchanging as necessary
 Repeat until pass made with no exchanges.

4
 Step-by-step example
First Pass:( 5 1 4 2 8 )
( 1 5 4 2 8 ), Swaps since 5 > 1. move on
( 1 4 5 2 8 ), Swap since 5 > 4. move on
( 1 4 2 5 8 ), Swap since 5 > 2. move on
( 1 4 2 5 8 ), does not swap. End of pass#1
2nd Pass: ( 1 4 2 5 8 )
( 1 4 2 5 8 ) does not swap. move on
( 1 2 4 5 8 ), Swap since 4 > 2. move on
( 1 2 4 5 8 ) does not swap. move on
( 1 2 4 5 8 ) does not swap. End of pass#2
5
Now, the array is already sorted, but the algorithm
does not know if it is completed. The algorithm
needs one whole pass without any swap to know it is
sorted.

Third Pass:( 1 2 4 5 8 )
(12458)
(12458)
( 1 2 4 5 8 ) Terminate.

6
 Bubble Sort Function

/* Bubble sort for integers */

void SWAP(a,b) { int t; t=a; a=b; b=t; }

void bubble( int a[], int n ) {

int pass, i;
for(pass=1;pass<n;pass++) { // n-1 passes thru the array.
for(i=0;i<(n-1);i++)// From start to the end of
unsorted part
{ // If adjacent items out of order, swap
if( a[i]>a[i+1] )
SWAP(a[i],a[i+1]);
}
}
}

This code will not be able to terminate

the bubble sort operation on the third
pass. Need to modify the algorithm. 7
Example 2:

8
Bubble SortFunction (re-define)
void SWAP(int *a,int *b) { int t; t=*a;
*a=*b; *b=t; }
void bubble( int a[], int n ) {
int pass, j, flag;
for(pass=1;pass<n;pass++) {//break if no swap
flag = 0;
for(j=0;j<(n-pass);j++) { //discard the
last
if( a[j]>a[j+1] ) {
SWAP(&a[j+1],&a[j]); flag = 1;}
}
if (flag==0) break;
} 9

}
Bubble Sort - Tradeoffs
 Benefit:
 Easy to understand and implement

 Disadvantage:
 Inefficient: slow for large arrays

1-10
Selection Sort
 Concept for sort in ascending order:
 Locate smallest element in array.
Exchange it with element in position 0
 Locate next smallest element in array.
Exchange it with element in position 1.
 Continue until all elements are arranged in
order

1-11
 Selection Sort - Example

Array numlist contains:

11 2 29 3

1. Smallest element is 2. Exchange 2

with element in 1st position in array:
2 11 29 3

12
 Example (Continued)
2. Next smallest element is 3. Exchange 3 with
element in 2nd position in array:

2 3 29 11

3. Next smallest element is 11. Exchange 11

with element in 3rd position in array:

2 3 11 29

13
 For 4 elements:
 How many positions were selected?

 How many selection will be needed for n

number of elements?

14
Min Min
value Index

8 0

5 1

1 3

5 1

3 5

7 2

5 5

8 3

7 5

9 4

8 5
15
A Selection Sort Function:
void selectionSort(int array[], int n)
{
int select, minIndex, minValue;

for (select = 0; select < (n - 1); select++)

{ //select the location and find the minimum value
minIndex = select;
minValue = array[select];
for(int i = select + 1; i < n; i++)
{ //start from the next of selected one to find minimum
if (array[i] < minValue)
{
minValue = array[i];
minIndex = i;
}
}
array[minIndex] = array[select];
array[select] = minValue;
}
} 16
Selection Sort - Tradeoffs
 Benefit:
 More efficient than Bubble Sort, since
fewer exchanges

 Disadvantage:
 May not be as easy as Bubble Sort to
understand

1-17
Insertion Sort

Mark first element as sorted,

Next for each unsorted element
'extract' the element
  for i = last Sorted Index to 0
    if current SortedElement > extracted
Element
       move/shift sorted element to the right by 1
    else: insert extracted element

18
Pseudocode of Insertion Sort

19
Insertion Sort
 To sort array A[0..n-1], sort A[0..n-2] recursively and
then insert A[n-1] in its proper place among the sorted
A[0..n-2]
 Usually implemented bottom up (non-recursively)

Example: 6, 4, 1, 8, 5
0 1 2 3 4
6 |4 1 8 5
4 6|1 8 5
1 4 6|8 5
1 4 6 8|5
1 4 5 6 8
20
Example: The following table shows the steps for
sorting the sequence {3, 7, 4, 9, 5, 2, 6, 1}. In each
step, the item under consideration is underlined. The
item that was moved (or left in place because it was
biggest yet considered) in the previous step is shown
in bold.
37495261
37495261
34795261
34795261
34579261
23457961
23456791
12345679 21
 Counting Sort
Counting sort is a sorting technique based on keys between a specific range. It
works by counting the number of objects having distinct key values. Then
doing some arithmetic to calculate the position of each object in the output
sequence

Time Complexity: O(n+k) where n is the number of elements in input array

and k is the range of input.
Auxiliary Space: O(n+k)

Points to be noted:
1. Counting sort is efficient if the range of input data is not significantly greater
than the number of objects to be sorted. Consider the situation where the input
sequence is between range 1 to 10K and the data is 10, 5, 10K, 5K.
2. It is not a comparison based sorting. It running time complexity is O(n) with
space proportional to the range of data.
3. Counting sort uses a partial hashing to count the occurrence of the data
object in O(1).
4. Counting sort can be extended to work for negative inputs also.
22
23
 Introduction to Search Algorithms

 Search: locate/find an item in a list of

information

 Two algorithms we will examine:

 Linear/Sequential search
 Binary search
Alternate ref: Schaum’s Outline Series:
Theory and Problems of Data Structures by Seymour Lipschutz
24
Linear Search
 Starting at the first element
 this algorithm steps sequentially
through an array
 examine each element until it locates
the value it is searching for.

25
 Linear Search - Example

 Array numlist contains:

17 23 5 11 2 29 3
 Searching for the the value 11
 linear search examines 17, 23, 5, and 11 then
stop with getting 11 at index 3 in the
list.
 Searching for the the value 7
 linear search examines 17, 23, 5, 11, 2, 29,
and 3 then stop without getting 7 in the
list.
26
 Linear Search

 Algorithm:
 Start search operation for 0 index to last index
 Compare the item to the first element of array
 If item is equal to the array element stop search
and send the found message with the index.
 If item is not found continue the comparison with
the next element by increasing the index by 1
until the last element.
27
 A Linear Search Function

int searchList(int list[], int numElems, int value)

{
int index = 0; // Used as a subscript to search array
int position = -1; // To record position of search value
bool found = false; // Flag to indicate if value was found

while (index < numElems && !found)

{
if (list[index] == value) // If the value is found
{
found = true; // Set the flag
position = index; // Record the value's subscript
}
index++; // Go to the next element
}
return position; // Return the position, or -1
} 28
Linear Search - Tradeoffs
 Benefits:
 Easy algorithm to understand
 Array can be in any order

 Disadvantages:
 Inefficient (slow): for array of N elements,
examines N/2 elements on average for value
in array, N elements for value not in array

1-29
 Binary Search

Requires array elements to be in order (sorted)

1. Divides the array into three sections:
 middle element
 elements on one side of the middle element
 elements on the other side of the middle element
2. If the middle element is the correct value, done.
Otherwise, go to step 1. using only the half of the
array that may contain the correct value.
3. Continue steps 1. and 2. until either the value is
found or there are no more elements to examine
30
Binary Search - Example

31
Binary Search

Set first index = 0.

Set last index = the last subscript in the array.
Set found = false.
Set position = -1.
While found is not true and first is less than or equal to last
Set middle to the subscript half-way between array[first] and array[last].
If array[middle] equals the desired value
Set found to true.
Set position to middle.
Else If array[middle] is greater than the desired value
Set last to middle - 1.
Else
Set first to middle + 1.
End If.
End While.
Return position.
32
A Binary Search Function

int binarySearch(int array[], int n, int value)

{
int first = 0, // First array element
last = n - 1, // Last array element
middle, // Mid point of search
position = -1; // Position of search value
bool found = false; // Flag

while (!found && first <= last)

{
middle = (first + last) / 2; // Calculate mid point
if (array[middle] == value) // If value is found at mid
{
found = true;
position = middle;
}
else if (array[middle] > value) // If value is in lower half
last = middle - 1;
else
first = middle + 1; // If value is in upper half
}
return position;
} 33
Binary Search - Tradeoffsç
 Benefits:
 Much more efficient than linear search.
For array of N elements, performs at most
log2N comparisons

 Disadvantages:
 Requires that array elements be sorted

1-34
 Ref. link

1. http://visualgo.net/

2. http://www.comp.nus.edu.sg/~stevenha/visualization/index.html

3. http://en.wikipedia.org/wiki/Bubble_sort#mediaviewer/File:Bubble-sort-
example-300px.gif

4. https://www.youtube.com/watch?v=JP5KkzdUEYI

5. http://en.wikipedia.org/wiki/Selection_sort#mediaviewer/File:Selection-
Sort-Animation.gif

35