Sorting Algorithms: Insertion and Shell Sort

A sorting algorithm that compares and swaps pairs of elements in a list until the list is sorted. It compares the first two elements, then the second and third, and so on, repeatedly checking and swapping pairs to ensure the list is sorted.

A sorting algorithm that divides the list into two parts: a sorted portion and an unsorted portion. It takes the first element from the unsorted portion and inserts it into the correct position within the sorted portion. This process is repeated until the entire list is sorted.

A sorting algorithm that repeatedly finds the minimum element in the unsorted portion of a list and swaps it with the element at the beginning of the unsorted portion. This process continues until the entire list is sorted.

A recursive sorting algorithm that divides the list into two halves, sorts each half recursively, and then merges the sorted halves back together.

A recursive sorting algorithm that selects a pivot element and partitions the list around the pivot such that all elements smaller than the pivot are placed before it, and all elements larger than the pivot are placed after it. This process is applied recursively to the sub-lists until the entire list is sorted.

The sorted portion of the list in Insertion Sort, which starts with a single element and grows as elements are inserted into their correct positions.

The unsorted portion of the list in Insertion Sort, which shrinks as elements are moved to the sorted portion.

The element being considered for insertion within the sorted portion in Insertion Sort.

The position where the new item is to be inserted within the sorted portion in Insertion Sort.

The element in the sorted portion that the new item is compared to in Insertion Sort.

The process of shifting elements in the sorted portion to the right to make space for the new item in Insertion Sort.

The condition that determines when the new item has reached its correct position within the sorted portion in Insertion Sort.

The process of repeatedly finding the minimum element in the unsorted portion of the list in Selection Sort.

The element at the beginning of the unsorted portion in Selection Sort, which is swapped with the minimum element.

The process of swapping the minimum element with the first element in the unsorted portion in Selection Sort.

The process of breaking the list into smaller sub-lists in Merge Sort.

The process of sorting the sub-lists recursively in Merge Sort.

The process of merging the sorted sub-lists back together in Merge Sort.

The element used to partition the list in Quick Sort.

The process of dividing the list into two sub-lists around the pivot in Quick Sort.

The process of recursively applying Quick Sort to the sub-lists in Quick Sort.

The computational complexity of a sorting algorithm, which describes how the algorithm's runtime grows as the input size increases.

The amount of additional memory space required by a sorting algorithm beyond the original input data.

A sorting algorithm that is efficient for small lists but becomes less efficient for large lists.

A sorting algorithm that is efficient for both small and large lists.

A sorting algorithm that is generally considered efficient and widely used.

A sorting algorithm that is not efficient for large lists because it takes a long time to sort.

The process of comparing and swapping elements in a list until the list is sorted.

The process of sorting elements without comparing them directly.