Skip to main content
UploadLanguage (EN)Support
BusinessMobileSocial MediaMarketingTechnologyArt & PhotosCareerDesignEducationPresentations & Public SpeakingGovernment & NonprofitHealthcareInternetLawLeadership & ManagementAutomotiveEngineeringSoftwareRecruiting & HRRetailSalesServicesScienceSmall Business & EntrepreneurshipFoodEnvironmentEconomy & FinanceData & AnalyticsInvestor RelationsSportsSpiritualNews & PoliticsTravelSelf ImprovementReal EstateEntertainment & HumorHealth & MedicineDevices & HardwareLifestyle
Uploaded byAnSHiKa187943
PPTX, PDF32 views

sorting-160810203705.pptx

The document provides an overview of sorting algorithms including bubble sort, selection sort, insertion sort, and divide and conquer algorithms like merge sort and quick sort. It discusses the time and space complexity of various sorting algorithms and how they work. Internal sorting methods like bubble sort, selection sort, and insertion sort have a worst-case time complexity of O(n2) while divide and conquer algorithms like merge sort and quick sort have better time complexities.

Engineering◦
Download to read offline
Anshika Das 14400121029 CSE PCC-CS 301 Data Structure & Algorithm 2022-23(odd sem)
SORTING
Introduction 3 • Sorting is among the most basic problems in algorithm design. • We are given a sequence of items, each associated with a given key value. And the problem is to rearrange the items so that they are in an increasing(or decreasing) order by key. • The methods of sorting can be divided into two categories: • Internal Sorting • External Sorting
4 • Internal Sorting If all the data that is to be sorted can be adjusted at a time in main memory, then internal sorting methods are used • External Sorting When the data to be sorted can’t be accommodated in the memory at the same time and some has to be kept in auxiliary memory, then external sorting methods are used. NOTE: We will only consider internal sorting
Stable and Not Stable Sorting 5 • If a sorting algorithm, after sorting the contents, does not change the sequence of similar content in which they appear, it is called stable sorting. • If a sorting algorithm, after sorting the contents, changes the sequence of similar content in which they appear, it is called unstable sorting.
Efficiency of Sorting Algorithm 6 • The complexity of a sorting algorithm measures the running time of a function in which n number of items are to be sorted. • The choice of sorting method depends on efficiency considerations for different problems. • Tree most important of these considerations are: • The length of time spent by programmer in coding a particular sorting program • Amount of machine time necessary for running the program • The amount of memory necessary for running the program
Things to remember 7 • An ideal sort is an in-place sort where the algorithm uses no additional array storage, and hence it is possible to sort very large lists without the need to allocate additional working storage. • A sorting algorithm is said to be stable if two objects with equal keys appear in the same order in sorted output as they appear in the input unsorted array. • Some sorting algorithms are stable by nature like Insertion sort, Merge Sort, Bubble Sort, etc. And some sorting algorithms are not, like Heap Sort, Quick Sort, etc.
BUBBLE SORT 8 • In bubble sort, each element is compared with its adjacent element. • We begin with the 0th element and compare it with the 1st element. • If it is found to be greater than the 1st element, then they are interchanged. • In this way all the elements are compared (excluding last) with their next element and are interchanged if required • On completing the first iteration, largest element gets placed at the last position. Similarly in second iteration second largest element gets placed at the second last position and so on.
14
Algorithm 15
TIME COMPLEXITY 17 • Best Case • sorting a sorted array by bubble sort algorithm • In best case outer loop will terminate after one iteration, i.e it involves performing one pass which requires n-1 comparison f (n) = O(n2) • Worst Case • Suppose an array [5,4,3,2,1], we need to move first element to end of an array • n-1 times the swapping procedure is to be called f (n) = O(n2) • Average Case • Difficult to analyse than the other cases • Random inputs, so in general f (n) = O(n2) • Space Complexity • O(n)
SELECTION SORT 18 • Find the least( or greatest) value in the array, swap it into the leftmost(or rightmost) component, and then forget the leftmost component, Do this repeatedly. • Let a[n] be a linear array of n elements. The selection sort works as follows: • Pass 1: Find the location loc of the smallest element in the list of n elements a[0], a[1], a[2], a[3], .........,a[n-1] and then interchange a[loc] and a[0]. • Pass 2: Find the location loc of the smallest element int the sub-list of n-1 elements a[1], a[2], a[3], .........,a[n-1] and then interchange a[loc] and a[1] such that a[0], a[1] are sorted. • Then we will get the sorted list a[0]<=a[2]<=a[3]…...<=a[n-1]
19
20
Time Complexity 21 • Inner loop executes (n-1) times when i=0, (n-2) times when i=1 and so on: • Time complexity = (n-1) + (n-2) + (n-3) + …....... +2+1 = O(n2) Space Complexity • Since no extra space beside n variables is needed for sorting so • O(n)
Insertion Sort 22 • Like sorting a hand of playing cards start with an empty hand and the cards facing down the table. • Pick one card at a time from the table, and insert it into the correct position in the left hand. • Compare it with each of the cards already in the hand, from right to left • The cards held in the left hand are sorted.
23
24
Insertion Sort 25 • Suppose an array a[n] with n elements. The insertion sort works as follows: Pass 1: a[0] by itself is trivially sorted. Pass 2: a[1] is inserted either before or after a[0] so that a[0], a[1] is sorted. Pass 3: a[2] is inserted into its proper place in a[0],a[1] that is before a[0], between a[0] and a[1], or after a[1] so that a[0],a[1],a[2] is sorted. pass N: a[n-1] is inserted into its proper place in a[0],a[1],a[2],........,a[n-2] so that a[0],a[1],a[2],............,a[n-1] is sorted with n elements.
26 7 2 4 5 1 3 2 7 4 5 1 3 2 4 7 5 1 3 2 4 5 7 1 3 1 2 4 5 7 3 1 2 3 4 5 7
Algorithm 27 InsertionSort(){ for (i=1;i<n;i++){ value=C[ i ]; hole= i ; while(hole>0 && C[hole-1]>value){ C[hole]=C[hole-1]; hole=hole-1; } C[hole]=value; } } i value hole 1 2 1 1 2 0 7 2 4 1 5 3 7 7 4 1 5 3 1st Pass 2 7 4 1 5 3
Time Complexity 28 • Best Case: • If the array is all but sorted then • Inner Loop wont execute so only some constant time the statements will run • So Time complexity= O(n) • Worst Case: • Array element in reverse sorted order • Time complexity=O(n2) • Space Complexity • Since no extra space beside n variables is needed for sorting so • Space Complexity = O(n)
Divide and conquer algorithms 29 • The sorting algorithms we’ve seen so far have worst-case running times of O(n2) • When the size of the input array is large, these algorithms can take a long time to run. • Now we will discuss two sorting algorithms whose running times are better • Merge Sort • Quick Sort
30
Divide-and-conquer 31 • Divide-and-conquer, breaks a problem into sub problems that are similar to the original problem, recursively solves the sub problems, and finally combines the solutions to the sub problems to solve the original problem. • Think of a divide-and-conquer algorithm as having three parts: • Divide the problem into a number of subproblems that are smaller instances of the same problem. • Conquer the subproblems by solving them recursively. If they are small enough, solve the subproblems as base cases. • Combine the solutions to the subproblems into the solution for the original problem.
Divide-and-conquer 32