........... Sorting compares two adjoining values and exchange them if they are not in proper order.

Question

Accepted Answer

The correct option is (3):
The sorting algorithm defined by the rule of comparing two adjoining values and exchanging them if they are not in the proper order is **Bubble Sort**. This algorithm repeatedly makes passes over the entire list. In each pass, it compares every pair of adjacent items, and if the element on the left is greater than the element on the right (for ascending order), they are immediately swapped. This systematic adjacent-pair comparison and potential exchange across the whole list is the foundational characteristic of Bubble Sort, which gives the algorithm its name as larger elements "bubble up" to their correct position at the end of the list after each pass.

The incorrect option is (1):
**Selection Sort** operates by dividing the list into a sorted and an unsorted sublist. In each pass, it finds the smallest element in the *entire* unsorted sublist and swaps it into the first position of the unsorted sublist (at the boundary with the sorted sublist). The algorithm's core mechanism is finding the minimum element, which involves many comparisons across the list, but it performs only a *single swap* per pass, rather than repeatedly comparing and exchanging every adjoining pair.

The incorrect option is (2):
**Heap Sort** is a highly efficient, comparison-based sorting technique that uses a specialized data structure called a binary heap. The process involves building a max-heap (or min-heap) from the input array and then repeatedly extracting the maximum (or minimum) element from the root of the heap and restructuring the remaining elements. The comparisons and swaps are based on maintaining the heap property (parent is greater/less than its children) and do not involve simply stepping through the array and comparing every *adjoining* index pair.

The incorrect option is (4):
**Insertion Sort** builds the final sorted array one item at a time. It works by taking one element at a time from the unsorted part and inserting it into its correct place within the *already sorted* portion of the array. The insertion step involves comparing the current element with the elements to its left and shifting them one position to the right to create a space for the new element. While comparisons with neighboring values occur, the fundamental operation is *insertion* and *shifting*, not the repeated pass-by-pass comparison and swap of all adjacent elements that defines the process described.