Technical Blog

My one of the most favourite sorting algorithms technique during when I was studying in the university and while also working at the company's office. Quick Sort is a sort of Divide-And-Conquer Technique for sorting given arrays based on a partitioning strategy. Since the specifics of this partitioning can vary significantly, Quicksort is actually a family of essentially comparable algorithms. No element in the first sub-range is greater than any element in the second sub-range when partitioning is used to split a range of at least two elements between two consecutive, non-empty sub-ranges. Quick Sort sorts the sub-ranges recursively after applying this partition, possibly after removing a portion from them at the division point that is now known to be at its ultimate location. Because Quicksort is recursive, it has to be built exactly to the partition routine.

Why Quick Sort is saying i'm so much "Lucky" algorithm technique because choosing an appropriate pivot a key plays an important role in terms of efficiency means that directly impact on complexity of algorithm. Quicksort can achieve its optimum efficiency where the pivot choice "luckily" generates balanced partitions, which is O(NlogN). But performance diminishes to its worst-case efficiency O(N^2) scenario if the pivot pick is consistently unsatisfactory and we can say it falls in poor condition.

1. Which sorting algorithm is the quickest among the following?

(i) Bucket sort (ii) Quick sort (iii) Merge sort (iv) Index sort

Answer is option(ii) Quick sort algorithm

2. In the worst scenario, how difficult is the Quick sort's time?

(i) O(N) (ii) O(N^2) (iii) O(N^3) (iv) O(NlogN)

Answer is option(ii) O(N^2)

3. In the best or average scenario, how much easiest is the Quick sort's time?

(i) O(N) (ii) O(N^2) (iii) O(N^3) (iv) O(NlogN)

Answer is option(iv) O(NlogN)

4. Which of the following best describes Quick Sort?

(i) Dynamic (ii) Static (iii) Greedy (iv) Divider and Conquer

Answer is option(iv) Divider and Conquer

5. Which of the following data structure best way to implement Quick Sort?

(i) Set (ii) List (iii) Stack (iv) Queue

Answer is option(iii) Stack

Another the most an important sorting algorithm is Heap Sort which is a comparison based sorting algorithm everything in this world is relative to each other that effectively this logic to sorts the data with the help of a binary heap data structure and one of second favourite sorting algorithm after quick sort. It is an in-place, non-recursive technique that sorts the array by continually extracting the maximum or minimum, depending on the kind of heap element after building a heap from the input data.

The array is first rearranged into a binary max-heap using Heap Sort Technique . After that, the algorithm continually replaces the heap's root the largest element still present with its last element, which is subsequently identified as a component of the sorted suffix. The largest element is then once more at the root when the heap that has been damaged by replacing the root is mended. Until there is just one value left in the heap, this process is repeated.

Heap Sort is typically done in place that's why we have to the array is separated into an unsorted prefix and a heap-ordered suffix which is initially empty in the first phase. The prefix gets smaller and the suffix gets bigger with each stage. This stage is finished when the prefix is empty. The array is separated into a heap-ordered prefix and a sorted suffix which is initially empty in the second phase. The prefix gets smaller and the suffix gets bigger with each stage. The array is sorted when its prefix is empty.

Although this simple method uses it mainly as a teaching help and performs poorly in practical situations, it is not commonly used in corporate industries. The sorting libraries provided in popular programming languages like Python , PHP and Java employ more efficient algorithms like quicksort or merge sort, however most of the time I found the Bubble sort algorithm to be really hilarious at the time when I was doing practical in my university Laboratory. However, bubble sort is far faster than parallel implementations of selection sort or insertion sort that do not parallelize efficiently, sorting in O(N) time if parallel processing is implemented.

For a simple Real life example in the rainy season

⛈️

flows of every water droplet 💦 on the ground parallelly from the cloud act exactly similar to Bubble Sort.

This sorting algorithm was first described as a "Sorting Exchange Algorithm" in a 1956 paper by mathematician and actuary Edward Harry Friend. Although Friend's paper was first ignored, it was recovered after a few years later by a number of computer scientists 👨‍💻 , Specifically Kenneth E. Iverson, who came up with the algorithm's current name.

Merge Sort is a sorting algorithm that is very effective, stable, and well understood. It works in O(NlogN) time in all cases, making it ideal for large amount of the data. But O(N) is not in-place and requires more space, which can be a problem in memory-constrained environments. Despite this, it is a widely used sorting algorithm in many applications, especially where worst-case or bad circumstance time complexity guarantees are important.

Merge Sort is a divide-and-conquer sorting algorithm that efficiently sorts an array by recursively dividing it into two halves, sorting each halve, and then merging the two halves back together In all cases best, average, and worst , it is one of the best general purpose sorting algorithms with a time complexity of O(NlogN). Merge sort is stable, which means it maintains the relative order of equal elements, and it works in a divide and conquer technique, which makes it suitable for large data.

Shell Sort is an insertion based sorting algorithm that extends Insertion Sort so that separate elements can be exchanged by dividing the input list into smaller sub-lists and using a gap sequence to sort each of them individually, we can say it is the improve version of the basic insertion sort algorithm. The main concept is to move elements far apart to reduce the number of inversions . This allows the array to be partially sorted more quickly, making the final insertion sort phase more efficient.

For Sorting Integers, Radix Sort is very effective, especially in cases where the range of numbers is not too wide. Because Radix sort processes each character or digit in a string, it can also be used to sort strings and good example sorting words are Lexicographically. Radix sort is a non-comparative sorting algorithm in computer science.By placing elements into buckets 🚰 according to their radix, it prevents comparison. For elements with more than one significant digit, this bucketing procedure is repeated for each digit, keeping the previous order until all digits have been taken into account bucket sort and digital sort are other names for radix sort.

For small or nearly sorted datasets, insert sort is a simple, in-place, and stable sorting algorithm. Because of its simplicity, it is a good choice for situations where performance isn't important or when small data sizes are needed. However, when compared to more complex algorithms like quick sort, merge sort, or heap sort, insertion sort becomes ineffective for larger datasets. Despite its Quadratic Time Complexity O(N^2), it is a useful algorithm for many practical applications because it works well in certain cases, is easy to implement, and has a stable behavior.

Insertion Sort is a simple algorithm based on comparison sort due to that creates the finished sorted array one element at a time and similar to sorting playing cards in your hand starting with an empty hand, you pick up each card and place them in right hand side.

Binary Tree Sort is a comparison-based sorting method that uses the features of a Binary Search Tree (BST) to organize data.

Sorting a Binary Tree usually entails transforming it into a sorted data structure like an array or linked list. Binary search trees are the most popular type of binary trees used for sorting. In a BST, the left child contains nodes with lower values than the parent node, whereas the right child    has nodes with higher values.

Selection sort is a comparison sorting algorithm that operates in-place. It has a temporal complexity of O(N^2) making it inefficient on large lists and often performing worse than the equivalent insertion sort. The selection sort is known for its simplicity.

Selection sort has a O(N^2) efficiency, hence there are other sorting strategies with a lower time complexity than Selection Sort .

Counting sort is not a comparison based sorting technique. It employs key values as indexes into an array, therefore the Ω(NlogN) and then lower constraint for comparison sorting does not apply. Bucket sort can be used instead of counting sort and requires a comparable time analysis.

Counting Sort is an efficient algorithm in certain situations, especially when the range of values is limited in relation to the input size. Algorithms like Quick Sort or Merge Sort are frequently more useful for larger use cases.