Lists

• What is a list?
  • Homogeneous
  • Linear access time.
  • Constant insert and delete, after the position or item has been found.
• How are lists normally implemented?
  • A node holds the data and a link.
  • The link is normally implemented as a pointer

  • struct NodeT {
        SomeTypeT   payload;
        NodeT * next;   
    }; 

• Note: no contiguous requirement.
• Is sorting possible?
  • Yes, but ...
  • Most of the fast sorting algorithms rely on constant access.
• The three faces of NULL
  • 0
  • NULL
  • nullptr
• Insert in order
  • Assume bool SomeTypeT::operator < exists
  • Write this iteratively.
  • Write this recursively.
  • The big three for each.
  • Which is better?
• Find a node
• Delete a node
• I have started using smart pointers for everything but intro to lists.
  • If you kept Gregorie, chapter 7
  • If you didn't, there are many editions floating around.
  • Shared pointers
    • Many pointers can point to the same memory.
    • The pointer maintains an access count
      • Each time a pointer points to the same memory, the count is increased.
      • Each time a pointer no longer points to the same memory, the count is decremented.
      • When the count reaches 0, the memory is freed.
    • #include <memmory>
    • shared_ptr<Type> var;
    • ptrT = make_shared<Type>() , various see this reference
  • Unique pointers exist as well
    • Only one pointer to each
    • make_unique, move,
    • A reference that includes code for a semi-stack.
• What does it cost to
  • Increase the size of a list?
  • Of a static array?
• Performance Expectations

  Item	Array	List
  Insert an Item
  Delete an Item
  Find an Item
  Copy the Data Structure
  Increase size of the Data Structure

• When do you choose a static array vs a list?