Presentation is loading. Please wait.

Presentation is loading. Please wait.

Fundamental Structures of Computer Science II

Published byOliver Ødegård Modified over 5 years ago

Similar presentations

Presentation on theme: "Fundamental Structures of Computer Science II"— Presentation transcript:

1 Fundamental Structures of Computer Science II
Sorting - 2 CS 202 – Fundamental Structures of Computer Science II Bilkent University Computer Engineering Department CS 202, Spring 2003 Fundamental Structures of Computer Science II Bilkent University

2 Fundamental Structures of Computer Science II
Heapsort For a binary heap, building the heap takes O(N) time. In a binary heap, deleteMin gives the smallest element. Running time of O(logN). Basic strategy for heap sort given N elements Build a binary heap from N elements (O(N)) Perform N deleteMin operations (N*logN) Put the result of deleteMins in a new array. The new array is sorted. CS 202, Spring 2003 Fundamental Structures of Computer Science II Bilkent University

3 Fundamental Structures of Computer Science II
Heapsort The problem is that: This strategy uses a new array This means waste of space for large N. A way for using only one array. When minimum item is deleted, put it to the end of the array. After N deleteMins: The original array will have the elements in sorted order from max to min. If you want items in increasing order (from min to max), then use a Max-Heap. CS 202, Spring 2003 Fundamental Structures of Computer Science II Bilkent University

4 Fundamental Structures of Computer Science II
Example Assume the input that is to be sorted: 31, 41, 59, 26, 53, 58, 97 N = 7. We need first to build a binary heap (a Max-Heap) A max-Heap is heap that has the largest item in root. CS 202, Spring 2003 Fundamental Structures of Computer Science II Bilkent University

5 Fundamental Structures of Computer Science II
Example 97 1 2 3 4 5 6 7 8 9 10 53 59 97 53 59 26 41 58 31 58 31 26 41 deleteMax Max-Heap after BuildHeap() 59 1 2 3 4 5 6 7 8 9 10 53 58 59 53 58 26 41 31 97 31 97 26 41 Heap after first DeleteMin() CS 202, Spring 2003 Fundamental Structures of Computer Science II Bilkent University

6 Fundamental Structures of Computer Science II
Example After 5 more deleteMins, the array will look like the following. 1 2 3 4 5 6 7 8 9 10 26 31 41 53 58 59 97 This is a sorted array CS 202, Spring 2003 Fundamental Structures of Computer Science II Bilkent University

7 template <class Comparable>
i is running from N/2 to 0 template <class Comparable> void heapsort( vector<Comparable> & a ) { /* 1*/ for( int i = a.size( ) / 2; i >= 0; i-- ) /* buildHeap */ /* 2*/ percDown( a, i, a.size( ) ); /* 3*/ for( int j = a.size( ) - 1; j > 0; j-- ) /* 4*/ swap( a[ 0 ], a[ j ] ); /* deleteMax */ /* 5*/ percDown( a, 0, j ); } j is running from N -1 to 1 Swap first and last elements CS 202, Spring 2003 Fundamental Structures of Computer Science II Bilkent University

8 template <class Comparable>
Point from where to start percolate down Logical size of heap template <class Comparable> void percDown( vector<Comparable> & a, int i, int n ) { int child; Comparable tmp; /* 1*/ for( tmp = a[ i ]; leftChild( i ) < n; i = child ) /* 2*/ child = leftChild( i ); /* 3*/ if( child != n - 1 && a[ child ] < a[ child + 1 ] ) /* 4*/ child++; /* 5*/ if( tmp < a[ child ] ) /* 6*/ a[ i ] = a[ child ]; else /* 7*/ break; } /* 8*/ a[ i ] = tmp; CS 202, Spring 2003 Fundamental Structures of Computer Science II Bilkent University

9 Fundamental Structures of Computer Science II
heapsort() 1 2 3 4 5 6 7 8 9 97 53 59 26 41 58 31 j=6 a.size = 7 swap a[0] with a[6] 1 2 3 4 5 6 7 8 9 31 53 59 26 41 58 97 a.size = 7 percolatedown(a, 0, 6) CS 202, Spring 2003 Fundamental Structures of Computer Science II Bilkent University

10 Fundamental Structures of Computer Science II
percDown() 1 2 3 4 5 6 7 8 9 31 53 59 26 41 58 97 i=0 tmp = 31, n=6 1 2 3 4 5 6 7 8 9 59 53 26 41 58 97 1 2 3 4 5 6 7 8 9 59 53 26 41 58 97 i=2 tmp = 31, n=6 1 2 3 4 5 6 7 8 9 59 53 58 26 41 31 97 Go out of for loop! CS 202, Spring 2003 Fundamental Structures of Computer Science II Bilkent University

11 Fundamental Structures of Computer Science II
heapsort() 1 2 3 4 5 6 7 8 9 59 53 58 26 41 31 97 j=5 Swap(a[0], a[5]) 1 2 3 4 5 6 7 8 9 31 53 58 26 41 59 97 j=5 percolateDown(a, 0, 5) CS 202, Spring 2003 Fundamental Structures of Computer Science II Bilkent University

12 Fundamental Structures of Computer Science II
percDown() 1 2 3 4 5 6 7 8 9 31 53 58 26 41 59 97 i=0 1 2 3 4 5 6 7 8 9 58 53 31 26 41 59 97 CS 202, Spring 2003 Fundamental Structures of Computer Science II Bilkent University

13 Fundamental Structures of Computer Science II
MergeSort CS 202, Spring 2003 Fundamental Structures of Computer Science II Bilkent University

14 Fundamental Structures of Computer Science II
MergeSort Runs in O(NlogN) worst case running time. A recursive algorithm Based on merging to sorted lists List 1: 2,3,5,9, 10 List 2: 1, 4, 6,7, 11 Merged List: 1,2,3, 4,5,6,7,10,11 It is enough to do one pass over the list 1 and list 2 CS 202, Spring 2003 Fundamental Structures of Computer Science II Bilkent University

15 Fundamental Structures of Computer Science II
Merging Algorithm Merge Array A Array B Array C 1 13 24 26 2 15 27 38 Actr Bctr Cctr We maintain 3 counters: Actr, Bctr, Cctr CS 202, Spring 2003 Fundamental Structures of Computer Science II Bilkent University

16 Fundamental Structures of Computer Science II
Pseudo-code for merge While both Actr and Bctr did not reach to end of arrays { if A[Actr] < B[Bctr] then C[Cctr] = A[Actr] Actr++ else C[Cctr] = B[Bctr] Bctr++ } If Actr did not reach end of array A copy rest of A to C If B ctr did not reach end of array B copy rest of B to C CS 202, Spring 2003 Fundamental Structures of Computer Science II Bilkent University

17 Fundamental Structures of Computer Science II
Array A Array B Array C 1 13 24 26 2 15 27 38 Actr Bctr Cctr Array A Array B Array C 1 13 24 26 2 15 27 38 1 Actr Bctr Cctr 1 13 24 26 2 15 27 38 1 2 Actr Bctr Cctr CS 202, Spring 2003 Fundamental Structures of Computer Science II Bilkent University

18 Fundamental Structures of Computer Science II
1 13 24 26 2 15 27 38 1 2 13 Actr Bctr Cctr 1 13 24 26 2 15 27 38 1 2 13 15 Actr Bctr Cctr 1 13 24 26 2 15 27 38 1 2 13 15 24 Actr Bctr Cctr CS 202, Spring 2003 Fundamental Structures of Computer Science II Bilkent University

19 Fundamental Structures of Computer Science II
Exhausted 1 13 24 26 2 15 27 38 1 2 13 15 24 26 Actr Bctr Cctr Copy rest of B to C 1 13 24 26 2 15 27 38 1 2 13 15 24 26 27 38 Actr Bctr Cctr Result of merge CS 202, Spring 2003 Fundamental Structures of Computer Science II Bilkent University

20 MergeSort Algorithm Description
Mergesort (A[1:N]) If N = 1 then return Else Mergesort (A[1:N/2]) Mergesort (A[N/2+1:N] Merge (A[1:N/2], A[N/2+1:N]) CS 202, Spring 2003 Fundamental Structures of Computer Science II Bilkent University

21 Fundamental Structures of Computer Science II
example Mergesort the following array CS 202, Spring 2003 Fundamental Structures of Computer Science II Bilkent University

22 Fundamental Structures of Computer Science II
Level 1 10 5 20 7 3 30 1 9 10 5 20 7 3 30 1 9 Divide(1) Level 2 Level 2 10 5 20 7 3 30 1 9 Mergesort(2) Mergesort(2) Merge(1) CS 202, Spring 2003 Fundamental Structures of Computer Science II Bilkent University

23 Fundamental Structures of Computer Science II
Level 2 10 5 20 7 3 30 1 9 Level 2 10 5 20 7 Divide(2) Level 3 Level 3 10 5 20 7 Mergesort(3) Mergesort(3) Merge(2) CS 202, Spring 2003 Fundamental Structures of Computer Science II Bilkent University

24 Fundamental Structures of Computer Science II
Level 2 10 5 20 7 3 30 1 9 Level 2 3 30 1 9 Divide (2) Level 3 Level 3 3 30 1 9 Mergesort(3) Mergesort(3) Merge(2) CS 202, Spring 2003 Fundamental Structures of Computer Science II Bilkent University

25 Fundamental Structures of Computer Science II
Level 3 before 10 5 20 7 3 30 1 9 Level 3 after 5 10 20 7 3 30 1 9 10 5 Divide (3) Level 3 Level 3 10 5 Mergesort(4) Mergesort(4) 10 10 Merge(3) 5 10 CS 202, Spring 2003 Fundamental Structures of Computer Science II Bilkent University

26 Fundamental Structures of Computer Science II
Level 3 before 10 5 20 7 3 30 1 9 Level 3 after 10 5 7 20 3 30 1 9 20 7 Divide (3) Level 3 Level 3 20 7 Mergesort(4) Mergesort(4) 20 7 Merge(3) 7 20 CS 202, Spring 2003 Fundamental Structures of Computer Science II Bilkent University

27 Fundamental Structures of Computer Science II
Level 3 before 10 5 20 7 3 30 1 9 Level 3 after 10 5 20 7 3 30 1 9 3 30 Divide (3) Level 3 Level 3 3 3 Mergesort(4) Mergesort(4) 30 30 Merge(3) 3 30 CS 202, Spring 2003 Fundamental Structures of Computer Science II Bilkent University

28 Fundamental Structures of Computer Science II
Level 3 before 10 5 20 7 3 30 1 9 Level 3 after 10 5 20 7 3 30 1 9 1 9 Divide (3) Level 3 Level 3 1 9 Mergesort(4) Mergesort(4) 1 9 Merge(3) 1 9 CS 202, Spring 2003 Fundamental Structures of Computer Science II Bilkent University

29 Fundamental Structures of Computer Science II
Back to Level 2 before 10 5 20 7 3 30 1 9 Level 2 after 5 7 10 20 3 30 1 9 10 5 20 7 Divide (2) Level 3 Level 3 10 5 20 7 Mergesort(3) Mergesort(3) 5 10 7 20 Merge(2) 5 7 10 20 CS 202, Spring 2003 Fundamental Structures of Computer Science II Bilkent University

30 Fundamental Structures of Computer Science II
Back to Level 2 before 10 5 20 7 3 30 1 9 Level 2 after 5 7 10 20 1 3 9 30 3 30 1 9 Divide (2) Level 3 Level 3 3 30 1 9 Mergesort(3) Mergesort(3) 3 30 1 9 Merge(2) 1 3 9 30 CS 202, Spring 2003 Fundamental Structures of Computer Science II Bilkent University

31 Fundamental Structures of Computer Science II
Back to Level 1 before 10 5 20 7 3 30 1 9 after 1 3 5 7 9 10 20 30 10 5 20 7 3 30 1 9 Divide (1) Level 2 Level 2 10 5 20 7 3 30 1 9 Mergesort(2) Mergesort(2) 5 7 10 20 1 3 9 30 Merge(1) Result 1 3 5 7 9 10 20 30 CS 202, Spring 2003 Fundamental Structures of Computer Science II Bilkent University

32 Fundamental Structures of Computer Science II
MergeSort The sorted array is 1,3,5,7,9,10,20,30 MergeSort is an example of Divide and Conquer Approach in Algorithm Design. CS 202, Spring 2003 Fundamental Structures of Computer Science II Bilkent University

Download ppt "Fundamental Structures of Computer Science II"

Similar presentations

Back to Sorting – More efficient sorting algorithms.

Back to Sorting – More efficient sorting algorithms.
COL 106 Shweta Agrawal and Amit Kumar

COL 106 Shweta Agrawal and Amit Kumar
Sorting I / Slide 1 Mergesort Based on divide-and-conquer strategy * Divide the list into two smaller lists of about equal sizes * Sort each smaller list.

Sorting I / Slide 1 Mergesort Based on divide-and-conquer strategy * Divide the list into two smaller lists of about equal sizes * Sort each smaller list.
CS 315 March 24 Goals: Heap (Chapter 6) priority queue definition of a heap Algorithms for Insert DeleteMin percolate-down Build-heap.

CS 315 March 24 Goals: Heap (Chapter 6) priority queue definition of a heap Algorithms for Insert DeleteMin percolate-down Build-heap.
Insertion sort, Merge sort COMP171 Fall 2006. Sorting I / Slide 2 Insertion sort 1) Initially p = 1 2) Let the first p elements be sorted. 3) Insert the.

Insertion sort, Merge sort COMP171 Fall Sorting I / Slide 2 Insertion sort 1) Initially p = 1 2) Let the first p elements be sorted. 3) Insert the.
Merge sort csc326 information structures Spring 2009.

Merge sort csc326 information structures Spring 2009.
Merge sort, Insertion sort

Merge sort, Insertion sort
Sorting. Introduction Assumptions –Sorting an array of integers –Entire sort can be done in main memory Straightforward algorithms are O(N 2 ) More complex.

Sorting. Introduction Assumptions –Sorting an array of integers –Entire sort can be done in main memory Straightforward algorithms are O(N 2 ) More complex.
CS2420: Lecture 9 Vladimir Kulyukin Computer Science Department Utah State University.

CS2420: Lecture 9 Vladimir Kulyukin Computer Science Department Utah State University.
Merge sort, Insertion sort. Sorting I / Slide 2 Sorting * Selection sort or bubble sort 1. Find the minimum value in the list 2. Swap it with the value.

Merge sort, Insertion sort. Sorting I / Slide 2 Sorting * Selection sort or bubble sort 1. Find the minimum value in the list 2. Swap it with the value.
1 Chapter 7 Sorting Sorting of an array of N items A [0], A [1], A [2], …, A [N-1] Sorting in ascending order Sorting in main memory (internal sort)

1 Chapter 7 Sorting Sorting of an array of N items A [0], A [1], A [2], …, A [N-1] Sorting in ascending order Sorting in main memory (internal sort)
CSC 2300 Data Structures & Algorithms March 20, 2007 Chapter 7. Sorting.

CSC 2300 Data Structures & Algorithms March 20, 2007 Chapter 7. Sorting.
1 7.5 Heapsort Average number of comparison used to heapsort a random permutation of N items is 2N logN - O (N log log N).

1 7.5 Heapsort Average number of comparison used to heapsort a random permutation of N items is 2N logN - O (N log log N).
Sorting CS-212 Dick Steflik. Exchange Sorting Method : make n-1 passes across the data, on each pass compare adjacent items, swapping as necessary (n-1.

Sorting CS-212 Dick Steflik. Exchange Sorting Method : make n-1 passes across the data, on each pass compare adjacent items, swapping as necessary (n-1.
Heaps and heapsort COMP171 Fall 2005 Part 2. Sorting III / Slide 2 Heap: array implementation 1 2 4 8 9 10 5 3 7 6 Is it a good idea to store arbitrary.

Heaps and heapsort COMP171 Fall 2005 Part 2. Sorting III / Slide 2 Heap: array implementation Is it a good idea to store arbitrary.
CS 202, Spring 2003 Fundamental Structures of Computer Science II Bilkent University1 Sorting CS 202 – Fundamental Structures of Computer Science II Bilkent.

CS 202, Spring 2003 Fundamental Structures of Computer Science II Bilkent University1 Sorting CS 202 – Fundamental Structures of Computer Science II Bilkent.
CS 202, Spring 2003 Fundamental Structures of Computer Science II Bilkent University1 Sorting - 3 CS 202 – Fundamental Structures of Computer Science II.

CS 202, Spring 2003 Fundamental Structures of Computer Science II Bilkent University1 Sorting - 3 CS 202 – Fundamental Structures of Computer Science II.
Insertion sort, Merge sort COMP171 Fall 2005. Sorting I / Slide 2 Insertion sort 1) Initially p = 1 2) Let the first p elements be sorted. 3) Insert the.

Insertion sort, Merge sort COMP171 Fall Sorting I / Slide 2 Insertion sort 1) Initially p = 1 2) Let the first p elements be sorted. 3) Insert the.
Week 11 Sorting Algorithms. Sorting Sorting Algorithms A sorting algorithm is an algorithm that puts elements of a list in a certain order. We need sorting.

Week 11 Sorting Algorithms. Sorting Sorting Algorithms A sorting algorithm is an algorithm that puts elements of a list in a certain order. We need sorting.
Sorting Sorting includes internal sorting and external sorting – Internal sorting: the entire sort can be done in main memory, i.e., all elements needed.

Sorting Sorting includes internal sorting and external sorting – Internal sorting: the entire sort can be done in main memory, i.e., all elements needed.

Similar presentations

Ads by Google