Insertion Sort

a. Test the insert-number procedure from the reading by inserting the number 42

b. Discuss with your partner (or someone nearby) why you think we had you do each of these tests. (That is, why would one want to check that insert-number works on each of these lists?)

c. What would you expect to happen if the list is not in ascending order when insert-number is invoked?

d. Check your answer experimentally.

Write a new insert-string procedure that inserts a string into a list of strings that are in alphabetical order:

> (insert-string (list "ape" "bear" "cat" "emu" "frog") "dog")
("ape" "bear" "cat" "dog" "emu" "frog")

In case you've forgotten, string<=? and string-ci<=? are useful predicates for comparing strings for order.

Your goal in this problem is to follow (and therefore better understand) the pattern of the insert-number procedure. Hence, you may not use the generalized insert procedure in writing insert-string.

a. Add calls to the display and newline procedures to the body of the local helper kernel of numbers-insertion-sort, so that it displays the values of unsorted and sorted, appropriately labeled, at each step of the sorting process.

For example, you might write

  (display (list 'sorted sorted 'unsorted unsorted)) (newline)

b. Use the revised numbers-insertion-sort procedure to sort the values 7, 6, 12, 4, 10, 8, 5, and 1.

When we use a new procedure, we often want to test it on a variety of cases. We've seen that numbers-insertion-sort works on a few simple cases. But we should also check some “special cases”, cases that might stress the algorithm. Come up with some lists that a poorly-implemented insertion sort procedure might have difficulty with.

Review the code for numbers-insertion-sort to figure out what you think it will do for each of the following cases. Then check your answer experimentally.

a. An empty list.

b. A list containing only one element.

c. A list containing all equal values.

d. A list in which the elements are originally in descending numerical order.

e. A list in which the elements are already in ascending numerical order.

f. A list containing some duplicate elements.

Let's see how many times the insert-number method is called. We'll use the techniques from the lab on analyzing procedures.

a. Copy the definitions of counter-new, counter-count!, counter-reset!, and counter-print! into the definitions pane.

b. Define a counter named insert-number-counter.

c. Add the following line to the beginning of the insert-number procedure:

  (counter-count! insert-number-counter)

We can count the number of calls to insert-number for a particular list as follows:

> (counter-reset! insert-number-counter)
> (numbers-insertion-sort list)
> (counter-print! insert-number-counter)

d. Determine how many calls to insert-number are involved in sorting each of the following lists.

i. (iota 5)

ii. (iota 10)

iii. (iota 20)

iv. (iota 40)

v. (reverse (iota 5))

vi. (reverse (iota 10))

vii. (reverse (iota 20))

viii. (reverse (iota 40))

e. Explain, to the best of your ability, what the numbers you got say about the number of function calls the insertion sort algorithm makes. Your answer should take the length of the list into account.

Write a call to the generalized list-insertion-sort to sort the list ("clementine" "starfruit" "apple" "kumquat" "pineapple" "pomegranate") alphabetically.

a. Add the following definition to your definitions pane.

(define numbers (vector 1 5 6 7 2 8 0 3))

b. Check that vector-insert! works by using it to move the 2 into the correct place in the first five spaces in numbers.

Note: Solving this step requires that you understand the parameters to vector-insert!.

c. Extend vector-insert! so that it displays the vector and the position at every step. That is, add calls to display and newline in the kernel, before the cond.

d. Re-create the numbers vector from step a, and observe what happens when we insert the 2, then the 8, then the 0, then the 3.

e. Observe the insertion steps in a vector of about eight randomly-generated numbers.

> (define nums (vector (random 10) (random 10) (random 10) (random 10)
               (random 10) (random 10) (random 10) (random 10)))
> (vector-insertion-sort! nums _____)

f. Explain, in your own words, how vector-insertion-sort! works.

a. Write a call to the generalized list-keyed-insertion-sort to sort the list ("clementine" "starfruit" "apple" "kumquat" "pineapple" "pomegranate") alphabetically.

b. Review the structure of drawing (a list of named objects). Then write a call to the generalized list-keyed-insertion-sort to sort drawing by object name.

c. Write a call to the generalized list-insertion-sort to sort drawing alphabetically by color name.

d. Write a call to the generalized list-keyed-insertion-sort to sort drawing by object width.

Write a procedure, (vector-keyed-insertion-sort vec get-key may-precede?) that sorts a vector of compound objects by key.

While it is possible to write this procedure by converting the vector to a list, using list-keyed-insertion-sort!, and then converting the result back to a vector, you should not use this strategy. Rather, write this procedure directly. (You may want to use vector-insertion-sort! as a template.)