CS 171: Introduction to Computer Science II

Simple Sorting

Li Xiong

Bonus question Give the big Oh cost of the following code fragments:

a. int sum = 0;

for (int i = N; i > 0; i /= 2)

for (int j = 0; j < i; j++)

sum++;

b. int sum = 0;

for (int i = 1; i < N; i *= 2)

for(int j = 0; j < i; j++)

sum++;

c. int sum = 0;

for (int i = 1; i < N; i *= 2)

for (int j = 0; j < N; j++)

sum++;

Useful Approximations

• Harmonic sum

1 + 1/2 + 1/3 + … + 1/N ~ lnN

• Triangular sum

1 + 2 + 3 + … + N = N(N+1)/2 ~ N2/2

• Geometric sum

1 + 2 + 4 + … + N = 2N -1 ~ 2N when N = 2n

• Stirling’s approximation

lg N! = lg1 + lg2 + lg3 + … + lgN ~ NlgN

Today

• Elementary sorting algorithms

–Bubble sort

–Selection sort

–Insertion sort

Sorting problem

Sorting Problem

Sorting Problem

• sorting a hand of bridge cards

Sorting any type of data

The Comparable Interface

10

// This interface is defined in

// java.lang package

package java.lang;

public interface Comparable {

public int compareTo(Object o);

}

String and Date Classes

• Many classes (e.g., String and Date) in the Java library implement Comparable to define a natural order for the objects

11

public class String extends Object

implements Comparable {

// class body omitted

}

public class Date extends Object

implements Comparable {

// class body omitted

}

Interface

Two useful sorting abstractions

Bubble Sort

• Intuition: – Find the biggest number.

– Find the second biggest number.

– Find the third biggest number.

– …

• Bubble sort achieves this by repeatedly swapping two adjacent numbers.

• After one pass, we find the biggest number.

• It’s like the biggest ‘bubble’ floats to the top of the surface, hence the name ‘bubble sort’.

Bubble Sort

• In the second pass, we repeat the same process, but now we only have N-1 numbers to work on.

• The third pass is the same, with only N-2 numbers.

• …

• Repeat until all players are in order.

Bubble Sort

Analysis of Bubble Sort

• Number of comparisons?

• Number of swaps?

= O(N )

= O(N )

Analysis of Bubble Sort

• Number of comparisons?

• Number of swaps?

best case:

worst cast:

average:

2 N(N -1)

2

= O(N2) 2

N(N -1)

2

N(N -1)

4

O(1)

Selection Sort

1. Keep track of the index of the smallest number in each round.

2. Swap the smallest number towards the beginning of the array.

3. Repeat the above two steps.

Selection Sort

Selection Sort

Selection Sort Implementation

Selection Sort

• Online demo –http://www.sorting-algorithms.com/selection-sort

• Gypsy dance demo –http://www.youtube.com/watch?v=Ns4TPTC8whw

http://www.sorting-algorithms.com/selection-sorthttp://www.sorting-algorithms.com/selection-sorthttp://www.sorting-algorithms.com/selection-sorthttp://www.sorting-algorithms.com/selection-sorthttp://www.sorting-algorithms.com/selection-sorthttp://www.youtube.com/watch?v=Ns4TPTC8whw

Selection Sort

• Number of comparisons?

• Number of swaps?

O(N2)

Selection Sort

• Number of comparisons?

• Number of swaps?

O(N)

Insertion Sort

• How do you sort a hand of poker cards?

Insertion Sort

• Idea – Assume the left portion of the array is partially

sorted (however, unlike selection sort, the elements are not necessarily in their final positions)

– For each remaining element on the right portion, insert it to the left portion (similar to insertion in an ordered array).

– Repeat until done.

Insertion Sort Implementation

Insertion Sort

• Online demo –http://www.sorting-algorithms.com/insertion-sort

• Romanian dance demo –http://www.youtube.com/watch?v=ROalU379l3U

http://www.sorting-algorithms.com/insertion-sorthttp://www.sorting-algorithms.com/insertion-sorthttp://www.sorting-algorithms.com/insertion-sorthttp://www.sorting-algorithms.com/insertion-sorthttp://www.sorting-algorithms.com/insertion-sorthttp://www.youtube.com/watch?v=ROalU379l3U

Insertion Sort

• Number of comparisons?

• Number of exchangess?

Insertion sort

• Best case

–N-1 comparisons

–0 exchanges

• Worst case

–~N2/2 comparisons

–~N2/2 exchanges

• Average case

–~N2/4 comparisons

–~N2/4 exchanges

Summary

• Selection and insertion sort are comparison

based.

• Both have an average comparison cost

• Later we will learn several faster sorting algorithms, with a typical cost of O(N logN)

of O(N2)

Java’s Sorting Methods

• Primitive Type Arrays: Arrays.sort(int[]);

Arrays.sort(int[], int fromIdx, int toIdx);

Arrays.sort(float[]);

……

Java’s Sorting Methods • Object Type Arrays:

Arrays.sort(Object[], Comparator);

Arrays.sort(Object[], int fromIdx, int toIdx, Comparator);

……

• Comparator is used to define how to compare two objects (i.e. which is bigger / smaller).

Arrays.sort(Object[]);

int compare(T o1, T o2)

boolean equals(Object obj)

http://download.oracle.com/javase/6/docs/api/java/util/Comparator.htmlhttp://download.oracle.com/javase/6/docs/api/java/util/Comparator.htmlhttp://download.oracle.com/javase/6/docs/api/java/lang/Object.html