Scribd
Upload
30 views

CSCE 3110 Data Structures & Algorithm Analysis: Rada Mihalcea Sorting (II) Reading: Chap.7, Weiss

The document discusses various sorting algorithms. It begins with a review of merge sort and quick sort, then introduces bucket sort and radix sort. Bucket sort works by distributing elements into buckets based on their value, then concatenating the buckets. Radix sort treats input as digit strings and sorts by digit place value from least to most significant. Both bucket and radix sort run in O(n) time when assumptions are met.

Uploaded by

Wil-Ly de la Cerna
Copyright
© Attribution Non-Commercial (BY-NC)
Available Formats
Download as PPT, PDF, TXT or read online on Scribd
30 views

CSCE 3110 Data Structures & Algorithm Analysis: Rada Mihalcea Sorting (II) Reading: Chap.7, Weiss

The document discusses various sorting algorithms. It begins with a review of merge sort and quick sort, then introduces bucket sort and radix sort. Bucket sort works by distributing elements into buckets based on their value, then concatenating the buckets. Radix sort treats input as digit strings and sorts by digit place value from least to most significant. Both bucket and radix sort run in O(n) time when assumptions are met.

Uploaded by

Wil-Ly de la Cerna
Copyright
© Attribution Non-Commercial (BY-NC)
Available Formats
Download as PPT, PDF, TXT or read online on Scribd
You are on page 1/ 26

CSCE 3110 Data Structures & Algorithm Analysis

Rada Mihalcea http://www.cs.unt.edu/~rada/CSCE3110 Sorting (II) Reading: Chap.7, Weiss

Today
Quick Review
Divide and Conquer paradigm Merge Sort Quick Sort

Two more sorting algorithms


Bucket Sort Radix Sort

Divide-and-Conquer
Divide and Conquer is a method of algorithm design. This method has three distinct steps: Divide: If the input size is too large to deal with in a straightforward manner, divide the data into two or more disjoint subsets. Recur: Use divide and conquer to solve the subproblems associated with the data subsets. Conquer: Take the solutions to the subproblems and merge these solutions into a solution for the original problem.

Merge-Sort
Algorithm:
Divide: If S has at leas two elements (nothing needs to be done if S has zero or one elements), remove all the elements from S and put them into two sequences, S1 and S2, each containing about half of the elements of S. (i.e. S1 contains the first n/2 elements and S2 contains the remaining n/2 elements. Recur: Recursive sort sequences S1 and S2. Conquer: Put back the elements into S by merging the sorted sequences S1 and S2 into a unique sorted sequence.

Merge-Sort Example

Running Time of Merge-Sort


At each level in the binary tree created for Merge Sort, there are n elements, with O(1) time spent at each element
O(n) running time for processing one level

The height of the tree is O(log n)


Therefore, the time complexity is O(nlog n)

Quick-Sort
1) Divide : If the sequence S has 2 or more elements, select an element x from S to be your pivot. Any arbitrary element, like the last, will do. Remove all the elements of S and divide them into 3 sequences:
L, holds Ss elements less than x E, holds Ss elements equal to x G, holds Ss elements greater than x

2) Recurse: Recursively sort L and G 3) Conquer: Finally, to put elements back into S in order, first inserts the elements of L, then those of E, and those of G.

Idea of Quick Sort


1) Select: pick an element

2) Divide: rearrange elements so that x goes to its final position E 3) Recurse and Conquer: recursively sort

Quick-Sort Tree

In-Place Quick-Sort
Divide step: l scans the sequence from the left, and r from the right.

A swap is performed when l is at an element larger than the pivot and r is at one smaller than the pivot.

In Place Quick Sort (contd)

A final swap with the pivot completes the divide step

Quick Sort Running Time


Worst case: when the pivot does not divide the sequence in two At each step, the length of the sequence is only reduced by 1 Total running time
2 length ( S ) O ( n ) i i n 1

General case:
Time spent at level i in the tree is O(n) Running time: O(n) * O(height)

Average case:
O(n log n)

More Sorting Algorithms


Bucket Sort Radix Sort Stable sort
A sorting algorithm where the order of elements having the same key is not changed in the final sequence Is bubble sort stable? Is merge sort stable?

Bucket Sort
Bucket sort
Assumption: the keys are in the range [0, N) Basic idea:
1. Create N linked lists (buckets) to divide interval [0,N) into subintervals of size 1 2. Add each input element to appropriate bucket 3. Concatenate the buckets

Expected total time is O(n + N), with n = size of original sequence


if N is O(n) sorting algorithm in O(n) !

Bucket Sort
Each element of the array is put in one of the N buckets

Bucket Sort

Now, pull the elements from the buckets into the array

At last, the sorted array (sorted in a stable way):

Does it Work for Real Numbers?


What if keys are not integers?
Assumption: input is n reals from [0, 1) Basic idea:
Create N linked lists (buckets) to divide interval [0,1) into subintervals of size 1/N Add each input element to appropriate bucket and sort buckets with insertion sort

Uniform input distribution O(1) bucket size


Therefore the expected total time is O(n)

Distribution of keys in buckets similar with . ?

Radix Sort
How did IBM get rich originally? Answer: punched card readers for census tabulation in early 1900s.
In particular, a card sorter that could sort cards into different bins
Each column can be punched in 12 places (Decimal digits use only 10 places!)

Problem: only one column can be sorted on at a time

Radix Sort
Intuitively, you might sort on the most significant digit, then the second most significant, etc. Problem: lots of intermediate piles of cards to keep track of Key idea: sort the least significant digit first
RadixSort(A, d) for i=1 to d StableSort(A) on digit i

Radix Sort
Can we prove it will work? Inductive argument:
Assume lower-order digits {j: j<i}are sorted Show that sorting next digit i leaves array correctly sorted
If two digits at position i are different, ordering numbers by that digit is correct (lower-order digits irrelevant) If they are the same, numbers are already sorted on the lower-order digits. Since we use a stable sort, the numbers stay in the right order

Radix Sort
What sort will we use to sort on digits? Bucket sort is a good choice:
Sort n numbers on digits that range from 1..N Time: O(n + N)

Each pass over n numbers with d digits takes time O(n+k), so total time O(dn+dk)
When d is constant and k=O(n), takes O(n) time

Radix Sort Example


Problem: sort 1 million 64-bit numbers
Treat as four-digit radix 216 numbers Can sort in just four passes with radix sort! Running time: 4( 1 million + 216 ) 4 million operations

Compare with typical O(n lg n) comparison sort


Requires approx lg n = 20 operations per number being sorted Total running time 20 million operations

Radix Sort
In general, radix sort based on bucket sort is
Asymptotically fast (i.e., O(n)) Simple to code A good choice

Can radix sort be used on floating-point numbers?

Summary: Radix Sort


Radix sort:
Assumption: input has d digits ranging from 0 to k Basic idea:
Sort elements by digit starting with least significant Use a stable sort (like bucket sort) for each stage

Each pass over n numbers with 1 digit takes time O(n+k), so total time O(dn+dk)
When d is constant and k=O(n), takes O(n) time

Fast, Stable, Simple Doesnt sort in place

Sorting Algorithms: Running Time


Assuming an input sequence of length n
Bubble sort Insertion sort Selection sort Heap sort Merge sort Quick sort Bucket sort Radix sort

Sorting Algorithms: In-Place Sorting


A sorting algorithm is said to be in-place if
it uses no auxiliary data structures (however, O(1) auxiliary variables are allowed) it updates the input sequence only by means of operations replaceElement and swapElements

Which sorting algorithms seen so far can be made to work in place?

You might also like