Advertisement

Dec. 1, 2022•0 likes## 0 likes

•3 views## views

Be the first to like this

Show More

Total views

0

On Slideshare

0

From embeds

0

Number of embeds

0

Download to read offline

Report

Data & Analytics

Hi everyone i hope you will be fine plz support me i hope you well statisfied with this slide and course.

SajalFayyazFollow

Advertisement

- CS261 DATA STRUCTURES & ALGORITHMS (WEEK-8) LECTURE-15 & 16 INTRODUCTION TO DATA STRUCTURES & ALGORITHMS Lecturer Azka Aziz Azka.a@scocs.edu.pk
- Data structures & Algorithms Lecture#15 Merge Sort
- Lecture Contents Divide & Conquer Divide & Conquer ….. Application (Merge Sort) mergeSort() Merge() Analysis
- Divide & Conquer Idea Distribute a larger problem into many small similar problems Solve every smaller problem recursively Combine results of smaller solutions to form the overall solution Usage A typical idea be to split a list of n items into two lists of n/2 size and try to sort them Consequence Running time of sorting can be improved from O(n2) to O(n log n)
- Divide & Conquer ….. Application (Merge Sort) Divide and conquer strategy is applicable in a huge number of computational problems. The first application of divide and conquer strategy is a simple and efficient sorting procedure called Merge Sort Input: a list of n numbers is provided as an array A[1…n] Output: a permutation of this sequence sorted in increasing order Method: Split Recursively, Sort, Merge
- Merge Sort Algorithm proc mergeSort(arr[1…n], p, r) if p < r then q (p+r)/2 mergeSort(arr, p, q) mergeSort(arr, q+1, r) merge(arr, p, q, r) end if end proc Every pass of mergeSort() procedure consists of two recursive function calls followed by one call to merge
- Merge Sort Algorithm proc mergeSort(arr[1…n], p, r) if p < r then q (p+r)/2 mergeSort(arr, p, q) mergeSort(arr, q+1, r) merge(arr, p, q, r) end if end proc mergeSort(arr, p, r) function checks whether p (index) is less than r (index) If it is so, it makes two calls to itself splitting the array into two halves Every further call splits array into further two halves with available indexes until p is not less than r (when will this happen?)
- Merge Sort Algorithm proc mergeSort(arr[1…n], p, r) if p < r then q (p+r)/2 mergeSort(arr, p, q) mergeSort(arr, q+1, r) merge(arr, p, q, r) end if end proc Every further call splits array into further two halves with available indexes until p is not less than r (when will this happen?) At this point a merge(arr, p, q, r) call will me made to merge two halves into a sorted chunk
- mergeSort() calls … Visually
- merge() call merge(arr, p, q, r) assumes that two halves of array [p….q], [q+1….r] are sorted (Why is it? We have not sorted anything yet? Is there some statement in mergeSort() procedure that does the sorting part?) proc mergeSort(arr[1…n], p, r) if p < r then q (p+r)/2 mergeSort(arr, p, q) mergeSort(arr, q+1, r) merge(arr, p, q, r) end if end proc
- mergeSort() calls … Visually We have not sorted anything yet? Is there some statement in mergeSort() procedure that does the sorting part? We just relied on a simple fact that splitting an array into equal halves will result into smaller and smaller arrays till there is only one element in array Is single element array sorted? Always?
- merge(arr, p, q, r) calls … Every merge() call receives three parameters (except the data array) i.e. p, q, r Values between indexes p….q and q+1……r are sorted (independent of each other) Having two sorted sub-arrays, merging part is easier:::
- merge(arr, p, q, r) calls … proc merge(arr, p, q, r) ip, kp, jq+1 temp[p…r] // using a temporary array while i ≤ q and j ≤ r do if arr[i] < arr[j] then temp[k++] arr[i++] else temp[k++] arr[j++] end if next
- merge(arr, p, q, r) calls … continued while i ≤ q do temp[k++] arr[i++] next while j ≤ r do temp[k++] arr[j++] next for i p to r do arr[i] temp[i] next end proc
- merge() calls … Visually
- Merge Sort Analysis First we analyze merge() procedure First let us consider the running time of the procedure merge(A, p, q, r). Let n = r - p + 1 denote the total length of both the left and right sub- arrays. What is the running time of Merge as a function of n?
- Merge Sort Analysis Cost of mergeSort(with n elements) = cost of mergeSort(n/2 elements) + cost of mergeSort(n/2 elements) + cost of merge(n elements) MS(n) = MS(n/2) + MS(n/2)+M(n) MS(n) = 2MS(n/2) + M(n)
- Merge Sort Analysis T(1) = 1 T(2) = T(1) + T(1) + 2 = 1 + 1 + 2 = 4 T(3) = T(2) + T(1) + 3 = 4 + 1 + 3 = 8 T(4) = T(2) + T(2) + 4 = 8 + 8 + 4 = 12 T(5) = T(3) + T(2) + 5 = 8 + 4 + 5 = 17 . . . T(8) = T(4) + T(4) + 8 = 12 + 12 + 8 = 32 . . . T(16) = T(8) + T(8) + 16 = 32 + 32 + 16 = 80 T(32) = T(16) + T(16) + 32 = 80 + 80+ 32 = 192
- Merge Sort Analysis T(1) = 1 T(2) = T(1) + T(1) + 2 = 1 + 1 + 2 = 4 T(3) = T(2) + T(1) + 3 = 4 + 1 + 3 = 8 T(4) = T(2) + T(2) + 4 = 8 + 8 + 4 = 12 T(5) = T(3) + T(2) + 5 = 8 + 4 + 5 = 17 . . . T(8) = T(4) + T(4) + 8 = 12 + 12 + 8 = 32 . . . T(16) = T(8) + T(8) + 16 = 32 + 32 + 16 = 80 T(32) = T(16) + T(16) + 32 = 80 + 80+ 32 = 192 Is there some pattern? Let’s try T(n)/n = log n + 1 T(n) = n log n + n O(n log n)
- Merge Sort Analysis … Recurrence Relation T(n) = 2 T(n/2) + n Expanding we get T(n) = 2 (2T(n/4)+n/2)+n ….. ? How? = 4 T(n/4) + n + n = 8 T(n/8) + n + n + n = 16 T(n/16) + n + n + n + n = ……………. Now to solve it assuming that n = 2k, T(n) = 2k T(n/2k) + (n+n+n+n k items) T(n) = 2k T(n/2k) + kn
- Merge Sort Analysis … Recurrence Relation T(n) = 2 T(n/2) + n Expanding we get T(n) = 2 (2T(n/4)+n/2)+n = 4 T(n/4) + n + n = 8 T(n/8) + n + n + n = 16 T(n/16) + n + n + n + n = ……………. Now to solve it assuming that n = 2k, T(n) = 2k T(n/2k) + (n+n+n+n k Since n = 2k, i.e. k = log n T(n) = 2log n T(n/2log n) + (log n)n T(n) = n T(1) + n log n T(n) = n + n log n i.e. T(n) = O (n)
- Merge Sort Analysis … Recurrence Relation
- Data structures & Algorithms Lecture#16 Queue
- Queue Data Structure Queue is a data structure that is used to store data items. Data items are stored in Queue one by one. Stored data items when removed from Queue follow First In First Out order.
- Queue Queue maintains two control variables i. rear ii. front Data items are removed from Queue (deque() operation) using control variable ‘rear’ Data items are added to the Queue (enque() operation) using control variable ‘front’ Data item being enqued to Queue earliest will be removed from Queue earliest following First In First Out order (FIFO) Queue can be implemented using an Array as well as a Linked List
- Queue Operations … Operation Description Pseudocode Queue() Initialize ‘rear’ and ‘front’ with -1 Assign -1 to ‘rear’ Assign -1 to ‘front’ int is_empty() Returns TRUE if Queue is empty Returns FALSE if Queue is not empty If ‘rear’ is less than ‘front’ Return FALSE Otherwise Return TRUE int is_full() Returns TRUE if Queue is empty Returns FALSE if Queue is not empty If ‘rear’ is equal to -1 AND ‘front’ is equal to MAX-1 then Return TRUE Otherwise Return FALSE
- Queue Operations … Operation Description Pseudocode int deque() Removes one item from queue using ‘rear’ If Queue is empty It returns -1 Otherwise Increment ‘rear’ by 1 Return value at current location of ‘rear’ void refresh() Relocates the queue elements so that empty positions are available post ‘front’ pointer All elements are relocated to the smaller index positions making empty positions available post the ‘front’ locations Assign -1 to ‘rear’ and value of (‘front’-’rear’-1) to ‘front’ void enque() Added an new data item to the Queue using ‘front’ pointer If Queue is full, Nothing can be added Else if ‘front’ is equal to MAX-1 then Refresh is called, ‘front’ is incremented by 1, New element is added at ‘front’ location Otherwise ‘front’ is incremented by 1, New element is added at ‘front’ location
- Queue using array … implementation Implementation details and issues have been discussed during class
- Queue ADT … (implementing with linked list)
- Queue ADT … (implementing with linked list) QueueNode *Front; QueueNode *Rear; Queue(); int is_empty(); void enque(int); QueueNode* deque();
- Queue Operations … Operation Description Pseudocode Queue() Initialize ‘rear’ and ‘front’ with NULL Assign NULL to ‘rear’ Assign NULL to ‘front’ int is_empty() Returns TRUE if Queue is empty Returns FALSE if Queue is not empty If ‘front’ is equal to NULL Return TRUE Otherwise Return FALSE QueueNode* deque() Removes one item from queue using ‘rear’ If Queue is empty It returns NULL Else if ‘rear’ and ‘front’ point to same node Assign the node to QueueNode pointer ‘temp’ Assign NULL to ‘rear’ and ‘front’ Return ‘temp’ Else Assign QueueNode pointed by ‘rear’ to ‘temp’ Assign ‘prev’ of ‘rear’ to ‘rear’ Set NULL to ‘next’ of ‘rear’ Return ‘temp’
- Queue Operations … Operation Description Pseudocode void enque(int) Added an new data item to the Queue using ‘front’ pointer Create new node using the parameter of function and point it by ‘temp’ If Queue is empty Assign ‘temp’ to ‘front’ Assign ‘temp’ to ‘rear’ Else Assign ‘front’ to ‘next’ of ‘temp’ Assign ‘temp’ to ‘prev’ of ‘front’ Assign ‘temp’ to ‘front’
- Queue using array … implementation Implementation details and issues have been discussed during class
- Queue applications Level order tree traversal Any job management software following FIFO order Operating System maintains a queue of processes that are ready to execute Many computer based systems maintains a queue of messages to be communicated among their components Queue of people at any service point Queue of packets in data communication Queue of planes waiting for landing

Advertisement