Scribd
Upload
8 views

Sorting 1

The document discusses various sorting algorithms including bubble sort, selection sort, insertion sort, heap sort, merge sort, and quick sort. It provides descriptions of how each algorithm works and analyzes their running times, which range from O(n^2) for bubble, selection, and insertion sort to O(n log n) for heap, merge, and quick sort. Key aspects like in-place quick sort and worst cases are also covered.

Uploaded by

Samiksha
Copyright
© © All Rights Reserved
Available Formats
Download as PDF, TXT or read online on Scribd
8 views

Sorting 1

The document discusses various sorting algorithms including bubble sort, selection sort, insertion sort, heap sort, merge sort, and quick sort. It provides descriptions of how each algorithm works and analyzes their running times, which range from O(n^2) for bubble, selection, and insertion sort to O(n log n) for heap, merge, and quick sort. Key aspects like in-place quick sort and worst cases are also covered.

Uploaded by

Samiksha
Copyright
© © All Rights Reserved
Available Formats
Download as PDF, TXT or read online on Scribd
You are on page 1/ 30

Sorting

Sorting
• Given a set (container) of n elements
• E.g. array, set of words, etc.
• Suppose there is an order relation that can be
set across the elements
• Goal Arrange the elements in ascending order

• Start 🡪 1 23 2 56 9 8 10 100
• End 🡪 1 2 8 9 10 23 56 100
Bubble Sort
• Simplest sorting algorithm
• Idea:
• 1. Set flag = false
• 2. Traverse the array and compare pairs of two
elements
• 1.1 If E1 ≤ E2 - OK
• 1.2 If E1 > E2 then Switch(E1, E2) and set flag = true
• 3. If flag = true goto 1.
• What happens?
Bubble Sort
1 1 23 2 56 9 8 10 100
2 1 2 23 56 9 8 10 100
3 1 2 23 9 56 8 10 100
4 1 2 23 9 8 56 10 100
5 1 2 23 9 8 10 56 100
---- finish the first traversal ---- Why Bubble Sort ?
---- start again ----
1 1 2 23 9 8 10 56 100
2 1 2 9 23 8 10 56 100
3 1 2 9 8 23 10 56 100
4 1 2 9 8 10 23 56 100
---- finish the second traversal ----
---- start again ----
………………….
Implement Bubble Sort
with an Array
void bubbleSort (Array S, length n) {
boolean isSorted = false;
int j=1;
while(!isSorted) {
isSorted = true;

for(i = 0; i<n-j; i++) {


if(S[i] > S[i+1]) {
int aux = S[i];
S[i] = S[i+1]; S[i+1] = aux;
isSorted = false;
}
}
j++
}
Running Time for Bubble Sort
• One traversal = move the maximum element
at the end
• Traversal #i : n – i + 1 operations
• Running time:
(n – 1) + (n – 2) + … + 1 = (n – 1) n / 2 = O(n
2
)
• When does the worst case occur ?
• Best case ?
Sorting Algorithms Using Priority
Queues
• Remember Priority Queues = queue where the dequeue operation
always removes the element with the smallest key 🡪 removeMin

• Selection Sort
• insert elements in a priority queue implemented with an
unsorted sequence
• remove them one by one to create the sorted sequence

• Insertion Sort
• insert elements in a priority queue implemented with a
sorted sequence
• remove them one by one to create the sorted sequence
Selection Sort

• insertion: O(1 + 1 + … + 1) = O(n)


• selection: O(n + (n-1) + (n-2) + … + 1) = O(n2)
void selectionSort(int arr[], int n) {
int i, j, minIndex, tmp;
for (i = 0; i < n - 1; i++) {
minIndex = i;
for (j = i + 1; j < n; j++)
if (arr[j] < arr[minIndex])
minIndex = j;
if (minIndex != i) {
tmp = arr[i];\
arr[i] = arr[minIndex];
arr[minIndex] = tmp;
}
}
}
Insertion Sort

• insertion: O(1 + 2 + … + n) = O(n2)


• selection: O(1 + 1 + … + 1) = O(n)
void insertionSort(int arr[], int length) {
int i, j, tmp;
for (i = 1; i < length; i++) {
j = i;
while (j > 0 && arr[j - 1] > arr[j]) {
tmp = arr[j];
arr[j] = arr[j - 1];
arr[j - 1] = tmp;
j--;
}
}
}
Sorting with Binary Trees
• Using heaps (see slides on heaps)
• How to sort using a minHeap ?

• Using binary search trees


• How to sort using BST?
Heap Sorting
• Step 1: Build a heap
• Step 2: removeMin( )
Recall: Building a Heap
• build (n + 1)/2 trivial one-element heaps

• build three-element heaps on top of them


Recall: Heap Removal
• Remove element
from priority queues?
removeMin( )
Recall: Heap Removal
• Begin downheap
Sorting with BST
• Use binary search trees for sorting
• Start with unsorted sequence
• Insert all elements in a BST
• Traverse the tree…. how ?
• Running time?
Next
• Sorting algorithms that rely on the “DIVIDE
AND CONQUER” paradigm
• One of the most widely used paradigms
• Divide a problem into smaller sub problems, solve
the sub problems, and combine the solutions
• Learned from real life ways of solving problems
Divide-and-Conquer
• Divide and Conquer is a method of algorithm
design that has created such efficient algorithms as
Merge Sort.
• In terms or algorithms, 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 Tree:
• Take a binary tree T
• Each node of T represents a recursive call of the merge sort
algorithm.
• We associate with each node v of T a the set of input passed to the
invocation v represents.
• The external nodes are associated with individual elements of S,
upon which no recursion is called.
Merge-Sort
Merge-Sort(cont.)
Merge-Sort (cont’d)
Merging Two Sequences
Quick-Sort
• Another divide-and-conquer sorting algorihm
• To understand quick-sort, let’s look at a high-level description
of the algorithm
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 S’s elements less than x
E, holds S’s elements equal to x
G, holds S’s 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.
Here are some diagrams....
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 (cont’d)

A final swap with the pivot completes the divide step


Running time analysis
• Average case analysis
• Worst case analysis
• What is the worst case for quick-sort?
• Running time?

You might also like