Insertion Sort Animation with User Input

**
**

for (i = 1; i < n; i++) { Inserted = false; // boolean variable j = i; while ((j >= 1) && (Inserted == false)) { if (List[j] < List[j-1]) swap(List[j], List[j-1]) else Inserted = true; j--; } }

**Note** : This algorithm sorts in **ascending** order - i.e., smaller
elements move to the front of the list.

- The "Step" button will perform the next step of the sort, and then the applet operation will pause for further interaction input (i.e., button click).
- The "Slow" button will perform the sort algorithm, with a fairly long pause between two consecutive steps.
- The ">>" button will perform the sort algorithm, with minimal pause between two consecutive steps.
- The "Back" button will
**undo**the last peformed step of the sorting algorithm, and pause for further interaction. Thus, subsequent clicks on "Back" will undo the sort performed so far, step by step. - The "<<" button
**undoes**till the list is back in its first, completely unsorted, state. - The "Reset" button takes the sort back to the first, completely unsorted,
state in
**one step**, so the user may restart. - The "Delay" Bar must be used only in "Slow" mode. Moving the bar to the left decreases the delay (resulting in faster execution), similarly moving the bar to the right increases the delay.
- The "stop" button terminates the operation of the applet (
**Note**: it cannot be restarted after being stopped).

**NOTE** : Clicking on the ">>" or "<<" buttons will move the sort forward
(or backward) at a **VERY FAST** pace, which may be unobservable. These
are essentially "Fast Forward" or "Rewind" buttons. If you want to see the
sort move ahead at a reasonable pace, click on the "Slow" button and then
use the slider bar to adjust the delay to a suitable value.

Insertion Sort Animation with User Input

This algorithm works by first considering the first element of the list
(element 0) to be correctly placed. It may not be, of course. In that case,
it proceeds to the next element (element 1) and considers its magnitude
vis-a-vis element 0. If the magnitude is smaller, it swaps it with element 0.
Now, elements 0 and 1 are sorted, but only **with respect to each other**.
Element 2 is now considered, and is moved to its correct position with
respect to elements 0 and 1, i.e., it may stay where it currently is, or
it may be placed between what are now elements 0 and 1, or it may be
placed before element 0. To do this, elements 2 and 1 may be swapped, resulting
in the placement of element 2 between what is currently element 0 and element
1, and then another swap between what are now elements 0 and 1 may be done
to place the element before what is now element 0 - if all this swapping is
indeed necessary. **TRY THIS** with the first three elements of the
list above (in the applet) and see what happens. This continues over and
over again, considering the elements from element 3 through the last element
of the list. Each element is sought to placed in its "proper" position
vis-a-vis the part of the list you already consider sorted. Note that each
element under consideration is swapped with its immediately preceding
neighbor as it moves towards the front of the list. The moment the swapping
stops, the element's immediately preceding neighbor has lesser magnitude, and
so the current element may be considered to be properly placed.

In this method there are *N*-1 insert operations. The *j*-th
insert operation inserts a new element into a sorted array of *j*
elements and hence takes at most *j* comparisons. Thus the total number
of comparisons is

1 + 2 + 3 + . + (*N*-1) = *N**(*N*-1)/2 = O(*N*^2)