ComparisonBased Sorting

1
Comparison-Based Sorting Analysis
2
Outline

• Several sorting algorithms
• Bubble Sort
• Selection Sort
• Insertion Sort
• Shell Sort
• For each algorithm
• Basic Idea
• Example
• Implementation
• Algorithm Analysis

3
Sorting

• Sorting ordering.
• Sorted ordered based on a particular way.
• Generally, collections of data are presented in a
  sorted manner.
• Examples of Sorting
• Words in a dictionary are sorted (and case
  distinctions are ignored).
• Files in a directory are often listed in sorted
  order.
• The index of a book is sorted (and case
  distinctions are ignored).
• Many banks provide statements that list checks in
  increasing order (by check number).
• In a newspaper, the calendar of events in a
  schedule is generally sorted by date.
• Musical compact disks in a record store are
  generally sorted by recording artist.
• Why?
• Imagine finding the phone number of your friend
  in your mobile phone, but the phone book is not
  sorted.

4
Bubble Sort Idea

• Idea bubble in water.
• Bubble in water moves upward. Why?
• How?
• When a bubble moves upward, the water from above
  will move downward to fill in the space left by
  the bubble.

5
Bubble Sort Example
1
2
3
4

• Notice that at least one element will be in the
  correct position each iteration.

6
Bubble Sort Example
5
6
7
8
Stop here why?
7
Bubble Sort Implementation

• void sort(int a)
• for (int i a.length igt0 i--)
• boolean swapped false
• for (int j 0 jlti j)
• ...
• if (aj gt aj1)
• int T aj
• aj aj1
• aj1 T
• swapped true
• ...
• if (!swapped)
• return

8
Bubble Sort Analysis

• Running time
• Worst case O(N2)
• Best case O(N) -- when? why?
• Variant
• bi-directional bubble sort
• original bubble sort only works to one direction
• bi-directional bubble sort works back and forth.

9
Selection Sort Idea

• We have two group of items
• sorted group, and
• unsorted group
• Initially, all items are in the unsorted group.
  The sorted group is empty.
• We assume that items in the unsorted group
  unsorted.
• We have to keep items in the sorted group sorted.
  
• Select the best (eg. smallest) item from the
  unsorted group, then put the best item at the
  end of the sorted group.
• Repeat the process until the unsorted group
  becomes empty.

10
Selection Sort Example
40
2
1
43
3
4
0
-1
58
3
65
42
40
2
1
43
3
4
0
-1
42
65
58
3
42
40
2
1
3
3
4
0
-1
65
58
43
11
Selection Sort Example
42
40
2
1
3
3
4
0
65
58
43
-1
42
-1
2
1
3
3
4
0
65
58
43
40
42
-1
2
1
3
3
4
65
58
43
40
0
42
-1
2
1
0
3
4
65
58
43
40
3
12
Selection Sort Example
42
-1
2
1
3
4
65
58
43
40
3
0
1
42
-1
0
3
4
65
58
43
40
3
2
1
42
-1
0
3
4
65
58
43
40
3
2
1
42
0
3
4
65
58
43
40
3
2
-1
1
42
0
3
4
65
58
43
40
3
2
-1
13
Selection Sort Implementation

• void sort(int a) throws Exception
• for (int i 0 i lt a.length i)
• int min i
• int j
• /
• Find the smallest element in
• the unsorted list
• /
• for (j i 1 j lt a.length j)
• ...
• if (aj lt amin)
• min j
• ...

14
Selection Sort Implementation

• /
• Swap the smallest unsorted element
• into the end of the
• sorted list.
• /
• int T amin
• amin ai
• ai T
• ...

15
Selection Sort Analysis

• Running time
• Worst case O(N2)
• Best case O(N2)
• Based on big-oh analysis, is selection sort
  better than bubble sort?
• Does the actual running time reflect the analysis?

16
Insertion Sort Idea

• Idea sorting cards.
• 8 5 9 2 6 3
• 5 8 9 2 6 3
• 5 8 9 2 6 3
• 2 5 8 9 6 3
• 2 5 6 8 9 3
• 2 3 5 6 8 9

17
Insertion Sort Idea

• We have two group of items
• sorted group, and
• unsorted group
• Initially, all items in the unsorted group and
  the sorted group is empty.
• We assume that items in the unsorted group
  unsorted.
• We have to keep items in the sorted group sorted.
  
• Pick any item from, then insert the item at the
  right position in the sorted group to maintain
  sorted property.
• Repeat the process until the unsorted group
  becomes empty.

18
Insertion Sort Example
40
2
40
1
43
3
65
0
-1
58
3
42
4
1
2
40
43
3
65
0
-1
58
3
42
4
19
Insertion Sort Example
1
2
40
43
3
65
0
-1
58
3
42
4
1
2
3
40
43
65
0
-1
58
3
42
4
1
2
3
40
43
65
0
-1
58
3
42
4
20
Insertion Sort Example
1
2
3
40
43
65
0
-1
58
3
42
4
1
2
3
40
43
65
0
-1
58
3
42
4
1
2
3
40
43
65
0
58
3
42
4
1
2
3
40
43
65
0
-1
21
Insertion Sort Example
1
2
3
40
43
65
0
58
3
42
4
1
2
3
40
43
65
0
-1
1
2
3
40
43
65
0
58
42
4
1
2
3
3
43
65
0
-1
58
40
43
65
1
2
3
40
43
65
0
42
4
1
2
3
3
43
65
0
-1
58
40
43
65
22
Insertion Sort Implementation

• Insertion sort to sort an array of integers
• public static void insertionSort (int a)
• for (int ii 1 ii lt a.length ii)
• int jj ii
• while (( jj gt 0) (ajj lt ajj - 1))
  
• int temp ajj
• ajj ajj - 1
• ajj - 1 temp
• jj--
• Note value of ajj always the same ?
  possibility for improvement of efficiency.

23
Insertion Sort Efficient Implementation

• A slightly more efficient Insertion sort
• public static void insertionSort2 (int a)
• for (int ii 1 ii lt a.length ii)
• int temp aii
• int jj ii
• while (( jj gt 0) (temp lt ajj - 1))
• ajj ajj - 1
• jj--
• ajj temp

24
Insertion Sort Analysis

• Running time analysis
• Worst case O(N2)
• Best case O(N)
• Is insertion sort faster than selection sort?
• Notice the similarity and the difference between
  insertion sort and selection sort.

25
A Lower Bound

• Bubble Sort, Selection Sort, Insertion Sort all
  have worst case of O(N2).
• Turns out, for any algorithm that exchanges
  adjacent items, this is the best worst case
  O(N2)
• In other words, this is a lower bound!
• See proof in Section 8.3 of Weiss

26
Shell Sort Idea
Donald Shell (1959) Exchange items that are far
apart!
Original
5-sort Sort items with distance 5 element
27
Shell Sort Example
Original
40
2
1
43
3
65
0
-1
58
3
42
4
After 5-sort
40
0
-1
43
3
42
2
1
58
3
65
4
After 3-sort
2
0
-1
3
1
4
40
3
42
43
65
58
After 1-sort
1
2
3
40
43
65
0
42
1
2
3
3
43
65
0
-1
58
4
43
65
42
58
40
43
65
28
Shell Sort Gap Values

• Gap the distance between items being sorted.
• As we progress, the gap decreases. Shell Sort is
  also called Diminishing Gap Sort.
• Shell proposed starting gap of N/2, halving at
  each step.
• There are many ways of choosing the next gap.

29
Shell Sort Analysis
O(N3/2)? O(N5/4)? O(N7/6)?

• So we have 3 nested loops, but Shell Sort is
  still better than Insertion Sort! Why?

30
Generic Sort

• So far we have methods to sort integers. What
  about Strings? Employees? Cookies?
• A new method for each class? No!
• In order to be sorted, objects should be
  comparable (less than, equal, greater than).
• Solution
• use an interface that has a method to compare two
  objects.
• Remember A class that implements an interface
  inherits the interface (method definitions)
  interface inheritance, not implementation
  inheritance.

31
The Comparable Interface

• In Java, generic aspect of comparable is
  defined in an interface in package java.lang
• public interface Comparable
• public int compareTo (Object ob)
• method compareTo returns
• negative integer the object (this) is smaller
  than the parameter ob
• 0 the object is equal to the parameter ob
• positive integer the object (this) is greater
  than the parameter ob

32
Interface Example

• public class CircleComparable extends Circle
• implements Comparable
• public CircleComparable (double r)
• super (r)
• public int compareTo (Object other)
• CircleComparable otherCircle
• (CircleComparable) other
• if (radius lt otherCircle.getRadius ())
• return -1
• else if (radius gt otherCircle.getRadius
  ())
• return 1
• else
• return 0

33
Insertion Sort Generic Sort

• Generic Insertion sort
• public static void insertionSort3 (Comparable
  a)
• for (int ii 1 ii lt a.length ii)
• Comparable temp aii
• int jj ii
• while (( jj gt 0)
• (temp.compareTo (ajj - 1) lt 0))
• ajj ajj - 1
• jj--
• ajj temp

34

• import java.util.
• public class SortCircle
• public static void main (String args)
• CircleComparable ling
• new CircleComparable20
• Random generator new Random ()
• for (int ii 0 ii lt ling.length ii)
  
• lingii new CircleComparable (
• 1 generator.nextInt (100))
• System.out.print (lingii.getRadius
  () " ")
• System.out.println ()
• Sort.insertionSort3 (ling)
• for (int ii 0 ii lt ling.length ii)
  
• System.out.print (lingii.getRadius
  () " ")
• System.out.println ()

35
Other kinds of sort

• Merge Sort
• Quick Sort
• Heap sort. We will discuss this after tree.
• Postman sort / Radix Sort.
• etc.

36
Further Reading

• http//telaga.cs.ui.ac.id/WebKuliah/IKI10100/resou
  rces/animation/
• Weiss book, chapter 8 Sorting Algorithm