File Name: time complexity of all sorting and searching algorithms file.zip

Size: 24921Kb

Published: 27.05.2021

## Sorting algorithm

In computer science , a sorting algorithm is an algorithm that puts elements of a list in a certain order. The most frequently used orders are numerical order and lexicographical order. Efficient sorting is important for optimizing the efficiency of other algorithms such as search and merge algorithms that require input data to be in sorted lists.

Sorting is also often useful for canonicalizing data and for producing human-readable output. More formally, the output of any sorting algorithm must satisfy two conditions:. For optimum efficiency, the input data in fast memory should be stored in a data structure which allows random access rather than one that allows only sequential access.

Sorting algorithms are often referred to as a word followed by the word "sort" and grammatically are used in English as noun phrases, for example in the sentence, "it is inefficient to use insertion sort on large lists" the phrase insertion sort refers to the insertion sort sorting algorithm.

From the beginning of computing, the sorting problem has attracted a great deal of research, perhaps due to the complexity of solving it efficiently despite its simple, familiar statement. Algorithms not based on comparisons, such as counting sort , can have better performance. Asymptotically optimal algorithms have been known since the midth century—useful new algorithms are still being invented, with the now widely used Timsort dating to , and the library sort being first published in Sorting algorithms are prevalent in introductory computer science classes, where the abundance of algorithms for the problem provides a gentle introduction to a variety of core algorithm concepts, such as big O notation , divide and conquer algorithms , data structures such as heaps and binary trees , randomized algorithms , best, worst and average case analysis, time—space tradeoffs , and upper and lower bounds.

Sorting small arrays optimally in least amount of comparisons and swaps or fast i. Similarly optimal by various definition sorting on a parallel machine is an open research topic. Stable sort algorithms sort repeated elements in the same order that they appear in the input.

When sorting some kinds of data, only part of the data is examined when determining the sort order. For example, in the card sorting example to the right, the cards are being sorted by their rank, and their suit is being ignored. This allows the possibility of multiple different correctly sorted versions of the original list. Stable sorting algorithms choose one of these, according to the following rule: if two items compare as equal, like the two 5 cards, then their relative order will be preserved, so that if one came before the other in the input, it will also come before the other in the output.

Stability is important for the following reason: say that student records consisting of name and class section are sorted dynamically on a web page, first by name, then by class section in a second operation. If a stable sorting algorithm is used in both cases, the sort-by-class-section operation will not change the name order; with an unstable sort, it could be that sorting by section shuffles the name order. Using a stable sort, users can choose to sort by section and then by name, by first sorting using name and then sort again using section, resulting in the name order being preserved.

Some spreadsheet programs obey this behavior: sorting by name, then by section yields an alphabetical list of students by section. More formally, the data being sorted can be represented as a record or tuple of values, and the part of the data that is used for sorting is called the key. In the card example, cards are represented as a record rank, suit , and the key is the rank. A sorting algorithm is stable if whenever there are two records R and S with the same key, and R appears before S in the original list, then R will always appear before S in the sorted list.

When equal elements are indistinguishable, such as with integers, or more generally, any data where the entire element is the key, stability is not an issue. Stability is also not an issue if all keys are different. Unstable sorting algorithms can be specially implemented to be stable. One way of doing this is to artificially extend the key comparison, so that comparisons between two objects with otherwise equal keys are decided using the order of the entries in the original input list as a tie-breaker.

Remembering this order, however, may require additional time and space. One application for stable sorting algorithms is sorting a list using a primary and secondary key. This can be done by first sorting the cards by rank using any sort , and then doing a stable sort by suit:. Within each suit, the stable sort preserves the ordering by rank that was already done.

This idea can be extended to any number of keys and is utilised by radix sort. The same effect can be achieved with an unstable sort by using a lexicographic key comparison, which, e. In this table, n is the number of records to be sorted.

The columns "Average" and "Worst" give the time complexity in each case, under the assumption that the length of each key is constant, and that therefore all comparisons, swaps, and other needed operations can proceed in constant time. The run times and the memory requirements listed below should be understood to be inside big O notation , hence the base of the logarithms does not matter; the notation log 2 n means log n 2. Below is a table of comparison sorts.

A comparison sort cannot perform better than O n log n. The following table describes integer sorting algorithms and other sorting algorithms that are not comparison sorts. Samplesort can be used to parallelize any of the non-comparison sorts, by efficiently distributing data into several buckets and then passing down sorting to several processors, with no need to merge as buckets are already sorted between each other.

Some algorithms are slow compared to those discussed above, such as the bogosort with unbounded run time and the stooge sort which has O n 2. These sorts are usually described for educational purposes in order to demonstrate how run time of algorithms is estimated. The following table describes some sorting algorithms that are impractical for real-life use in traditional software contexts due to extremely poor performance or specialized hardware requirements.

Theoretical computer scientists have detailed other sorting algorithms that provide better than O n log n time complexity assuming additional constraints, including:. While there are a large number of sorting algorithms, in practical implementations a few algorithms predominate. Insertion sort is widely used for small data sets, while for large data sets an asymptotically efficient sort is used, primarily heap sort, merge sort, or quicksort.

Efficient implementations generally use a hybrid algorithm , combining an asymptotically efficient algorithm for the overall sort with insertion sort for small lists at the bottom of a recursion.

For more restricted data, such as numbers in a fixed interval, distribution sorts such as counting sort or radix sort are widely used. Bubble sort and variants are rarely used in practice, but are commonly found in teaching and theoretical discussions.

When physically sorting objects such as alphabetizing papers, tests or books people intuitively generally use insertion sorts for small sets. For larger sets, people often first bucket, such as by initial letter, and multiple bucketing allows practical sorting of very large sets. Often space is relatively cheap, such as by spreading objects out on the floor or over a large area, but operations are expensive, particularly moving an object a large distance — locality of reference is important.

Merge sorts are also practical for physical objects, particularly as two hands can be used, one for each list to merge, while other algorithms, such as heap sort or quick sort, are poorly suited for human use. Other algorithms, such as library sort , a variant of insertion sort that leaves spaces, are also practical for physical use. Two of the simplest sorts are insertion sort and selection sort, both of which are efficient on small data, due to low overhead, but not efficient on large data.

Insertion sort is generally faster than selection sort in practice, due to fewer comparisons and good performance on almost-sorted data, and thus is preferred in practice, but selection sort uses fewer writes, and thus is used when write performance is a limiting factor.

Insertion sort is a simple sorting algorithm that is relatively efficient for small lists and mostly sorted lists, and is often used as part of more sophisticated algorithms. It works by taking elements from the list one by one and inserting them in their correct position into a new sorted list similar to how we put money in our wallet.

Shellsort see below is a variant of insertion sort that is more efficient for larger lists. Selection sort is an in-place comparison sort. It has O n 2 complexity, making it inefficient on large lists, and generally performs worse than the similar insertion sort. Selection sort is noted for its simplicity, and also has performance advantages over more complicated algorithms in certain situations. The algorithm finds the minimum value, swaps it with the value in the first position, and repeats these steps for the remainder of the list.

Practical general sorting algorithms are almost always based on an algorithm with average time complexity and generally worst-case complexity O n log n , of which the most common are heap sort, merge sort, and quicksort. Each has advantages and drawbacks, with the most significant being that simple implementation of merge sort uses O n additional space, and simple implementation of quicksort has O n 2 worst-case complexity. These problems can be solved or ameliorated at the cost of a more complex algorithm.

While these algorithms are asymptotically efficient on random data, for practical efficiency on real-world data various modifications are used. First, the overhead of these algorithms becomes significant on smaller data, so often a hybrid algorithm is used, commonly switching to insertion sort once the data is small enough.

Second, the algorithms often perform poorly on already sorted data or almost sorted data — these are common in real-world data, and can be sorted in O n time by appropriate algorithms. Finally, they may also be unstable , and stability is often a desirable property in a sort. Thus more sophisticated algorithms are often employed, such as Timsort based on merge sort or introsort based on quicksort, falling back to heap sort.

Merge sort takes advantage of the ease of merging already sorted lists into a new sorted list. It starts by comparing every two elements i. It then merges each of the resulting lists of two into lists of four, then merges those lists of four, and so on; until at last two lists are merged into the final sorted list.

It is also easily applied to lists, not only arrays, as it only requires sequential access, not random access. However, it has additional O n space complexity, and involves a large number of copies in simple implementations.

Merge sort has seen a relatively recent surge in popularity for practical implementations, due to its use in the sophisticated algorithm Timsort , which is used for the standard sort routine in the programming languages Python [25] and Java as of JDK7 [26]. Merge sort itself is the standard routine in Perl , [27] among others, and has been used in Java at least since in JDK1. Heapsort is a much more efficient version of selection sort.

It also works by determining the largest or smallest element of the list, placing that at the end or beginning of the list, then continuing with the rest of the list, but accomplishes this task efficiently by using a data structure called a heap , a special type of binary tree. When it is removed and placed at the end of the list, the heap is rearranged so the largest element remaining moves to the root.

Using the heap, finding the next largest element takes O log n time, instead of O n for a linear scan as in simple selection sort. This allows Heapsort to run in O n log n time, and this is also the worst case complexity. Quicksort is a divide and conquer algorithm which relies on a partition operation: to partition an array, an element called a pivot is selected. This can be done efficiently in linear time and in-place. The lesser and greater sublists are then recursively sorted.

This yields average time complexity of O n log n , with low overhead, and thus this is a popular algorithm. Efficient implementations of quicksort with in-place partitioning are typically unstable sorts and somewhat complex, but are among the fastest sorting algorithms in practice. Together with its modest O log n space usage, quicksort is one of the most popular sorting algorithms and is available in many standard programming libraries.

The important caveat about quicksort is that its worst-case performance is O n 2 ; while this is rare, in naive implementations choosing the first or last element as pivot this occurs for sorted data, which is a common case.

The most complex issue in quicksort is thus choosing a good pivot element, as consistently poor choices of pivots can result in drastically slower O n 2 performance, but good choice of pivots yields O n log n performance, which is asymptotically optimal. Finding the median, such as by the median of medians selection algorithm is however an O n operation on unsorted lists and therefore exacts significant overhead with sorting.

Shellsort was invented by Donald Shell in This means that generally, they perform in O n 2 , but for data that is mostly sorted, with only a few elements out of place, they perform faster.

So, by first sorting elements far away, and progressively shrinking the gap between the elements to sort, the final sort computes much faster. One implementation can be described as arranging the data sequence in a two-dimensional array and then sorting the columns of the array using insertion sort.

This, combined with the fact that Shellsort is in-place , only needs a relatively small amount of code, and does not require use of the call stack , makes it is useful in situations where memory is at a premium, such as in embedded systems and operating system kernels.

## Complexity of all sorting algorithms pdf file

We have learned that in order to write a computer program which performs some task we must construct a suitable algorithm. However, whatever algorithm we construct is unlikely to be unique — there are likely to be many possible algorithms which can perform the same task. Are some of these algorithms in some sense better than others? Algorithm analysis is the study of this question. Algorithm analysis should begin with a clear statement of the task to be performed. This allows us both to check that the algorithm is correct and to ensure that the algorithms we are comparing perform the same task. Although there are many ways that algorithms can be compared, we will focus on two that are of primary importance to many data processing algorithms:.

## Bubble sort

In this chapter you will be dealing with the various sorting techniques and their algorithms used to manipulate data structure and its storage. Sorting method can be implemented in different ways - by selection, insertion method, or by merging. Various types and forms of sorting methods have been explored in this tutorial. Sorting refers to the operation or technique of arranging and rearranging sets of data in some specific order. A collection of records called a list where every record has one or more fields.

Sorting is nothing but arranging the data in ascending or descending order. The term sorting came into picture, as humans realised the importance of searching quickly. There are so many things in our real life that we need to search for, like a particular record in database, roll numbers in merit list, a particular telephone number in telephone directory, a particular page in a book etc. All this would have been a mess if the data was kept unordered and unsorted, but fortunately the concept of sorting came into existence, making it easier for everyone to arrange data in an order, hence making it easier to search. If you ask me, how will I arrange a deck of shuffled cards in order, I would say, I will start by checking every card, and making the deck as I move on.

#### Different Sorting Algorithms

Time Complexity: Time Complexity is defined as the number of times a particular instruction set is executed rather than the total time is taken. Space Complexity: Space Complexity is the total memory space required by the program for its execution. One important thing here is that in spite of these parameters the efficiency of an algorithm also depends upon the nature and size of the input. Please write comments if you find anything incorrect, or you want to share more information about the topic discussed above. Attention reader! Writing code in comment? Please use ide.

Sorting algorithms are a set of instructions that take an array or list as an input and arrange the items into a particular order. Sorts are most commonly in numerical or a form of alphabetical called lexicographical order, and can be in ascending A-Z, or descending Z-A, order. Since sorting can often reduce the complexity of a problem, it is an important algorithm in Computer Science. These algorithms have direct applications in searching algorithms, database algorithms, divide and conquer methods, data structure algorithms, and many more. When using different algorithms some questions have to be asked. How big is the collection being sorted?

Bubble sort , sometimes referred to as sinking sort , is a simple sorting algorithm that repeatedly steps through the list, compares adjacent elements and swaps them if they are in the wrong order. The pass through the list is repeated until the list is sorted.

A comprehensive note on complexity issues in sorting algorithms. The last section describes algorithms that sort data and implement dictionaries for very large files. Source code for each algorithm, in ansi c, is included. Indeed it is very fast on the average but can be slow for some input, unless precautions are taken. All permutation can be written as a product of of transpositions of two consecutive elements.