Sorting Algorithms

What are the three things that sorting routines are evaluated on

The steps for the Heap Sort algorithm are as follows:
1. Put the items to be sorted in a [A] binary tree
2. Build the initial [B]
3. Repeatedly remove the [C] and [D]

Which sort has the highest memory overhead?

Which sort recursively combines sorted sub-arrays?

Which sort recursively breaks the data set into two pieces based on a pivot value?

Which sort requires a tree to be built which has a particular shape and order?

Which sort is very simple to code and is the best for almost sorted data?

When performing swaps within a sort method

What is unique about the Binary Tree sort over the other sorts discussed in this chapter?

What is the theoretical minimum Big-Oh for comparison-based algorithms.

When creating a priority queue where the priorities are 1 - 4 where 1 is the highest priority:
1. This would be implemented with a (min, max) [A] heap
2. To insert to priority queue, place the new item to be sorted at the [B] of the array
3. The parent of an object at index 12 would be at index [C]

The algorithm for the Binary Search Sort requires that all items to be sorted be inserted into a Binary Search Tree. Then use the [A] traversal for ascending order and the [B] traversal for descending order.

The steps for the Merge Sort algorithm
1. Break the array into [A] sub-arrays
2. [B] each subarray
3. [C] the sorted subarrays together
4. Base case of the recursive algorithm is when the size of the sub-array is [D]

The speed of a sorting algorithm depends upon the number of [A] and the number of [B]

Objects in an array to be sorted must be of the same class.

Sorting a chain of linked nodes is usually easier than sorting an array

Selection sort is efficient for large arrays.

Implementing the insertion sort for a linked chain of nodes is generally difficult.

The iterative merge sort algorithm is much simpler than the recursive algorithm

In quick sort, the partition places the pivot in the position that it will occupy in the final sorted array.

The radix sort restricts the data that it sorts on.

Divide and conquer algorithms can only be written recursively.