Introduction to Linked Lists.

We have discussed arrays.
- Zero or more items of a single data type.
  - Perhaps up to MAX_ITEMS
- The data is accessible via an index operation.
  - We have not discussed this, but access is constant time.
- The data is normally contiguous
- We can insert, remove and access data.
  - But we can run into a problem with holes in the array.
  - So we tend to keep everything at the "small" end of the array.
A new data type is a list
- This is a collection of 0 or more items of the same data type.
- Perhaps up to MAX_ITEMS
- It is stored with a linear relationship.
  - Every item but the first has a unique predecessor
  - Every item but the last has a unique successor.
  - Think a train, or a line of school children.
  - You only have access to the first element.
  - You have some marker that says this is the last element.
  - To get to the end, you start at the front and "walk through" each entry.

The ADT might be

         Type   List
         Domain: a collection of 0 or more items 
                 all of the same type
                 up to MAX_ITEMS
         Operations
              Make a new list
              Is the list Empty
              Is the list Full
              Get the length of the list
              Is an item in the list?
              Delete an item from the list (move everything forward), no holes
              Insert an item in the list (always at the end)
              Get the first item
              Get the next item

We will implement several versions
The first version is a "random" order with a static list.
- How will we delete an item?
  - Two choices
    - Just swap it with the end and decrease the size by one.
    - Move everything above in in the array down and decrease the size by one.
  - I selected the second.
- I built a random test that I like.
  - But it uses a fallthrough in a switch statement.
  - The compiler warns about this, which is a good thing.
  - but there is an [[falltrhough]] attribute in c++17 that helps with this.
  - reference
Look at the code
How about a list where the items are kept in order?
- Insert becomes much like the delete in the previous program.
- Move everything bigger than the element "up" one in the array.
- Insert the element at the new empty location.
This is the basis for insertion sort.
We can now take advantage of binary search.

BinarySearch(array, key)

 start = 0
 stop = size of the array.
 while start <= stop  
    mid = (start+stop)/2
    if array[mid] == key
        return key
    else if array[mid] > key
        stop = mid-1
    else
        start = mid+1;

It is a bit to analyze this, but the performance is $O(lg_2 n)$
- The argument goes like this:
- Each time we cut the search area in 1/2
- so 1024->512->256->128->64->32->16->8->4->2->1
- Or $lg_2 n $

the code