Linked Lists, Motivation and Basic Idea

• You should read chapter 7, up to Smart Pointers.
• For our game, I think we will need an collection of bad guys.
  • We will need to add to this as new rooms are generated.
  • We will need to iterate through this when it is the Monster Phase.
  • We will need to delete items from this in the Hero Phase
• It is always problematic in my mind
  • Does the map hold the tokens, like his chess implementation
    • If we do this, iterating over all tokens is problematic.
    • Searching from top to bottom, left to right would be expensive.

    • for each row in the map
         for each column in the row
             if map[row][column].HasCritter()
                 map[row][colum].GetCritter().Move() 

    • Consider this as situation

      +-0-+       +-0-+
      |AB |       | BA|
      0   0   =>  0   0
      |   |       |   |
      +-0-+       +-0-+
      
      In the above picture, the algorithm found A and moved it two
      spaces to the right.  Next it will move B, but after that it will find A again
      and attempt to move it again.  

    • We could have a moved field associated with each critter

  • for each row in the map
       for each column in the row
           if map[row][column].HasCritter()
               map[row][colum].GetCritter().ResetMove() 
           
    for each row in the map
       for each column in the row
           if map[row][column].HasCritter() and map[row][colum].GetCritter.DidNotMove()
               map[row][colum].GetCritter().Move() 

  • This is terrably inefficient, we loop over the entire map twice
    • What if the map were 50 x 50
    • And there were 10 critters?
• An array of critters might be ok.
  • For static arrays we would need to know the max.
  • For a dynamic array like we built last semester we don't need to know that.
  • But what if we need to delete a monster in the middle of the array

  •         0 1 2 3 4 5
    Array:  A B C D E F
    Delete C
    The array  sould become
            0 1 2 3 4
    Array:  A B D E F 

  • If order is important we would have to move all of the elements beyond C down one.
• Deleting from an ordered array is a problem.
• As is inserting into an ordered array.
  • While our application does not require an ordered array, many do.
• A linked list would be an approprate solution.
• In a linked list
  • There is a head of the list, a pointer to the first item.
  • Each data item is contained in a node
  • A node holds data and a pointer to next item in a list.
• Think of a train
  • The engine (head) is connected to the first car.
  • The second car is connected to the first car
  • ...
  • If a link between cars breaks, the cars beyond that link are lost.
• In C++

  • struct NodeT {
        dataType data;
        NodeT * next;
    };
        

• 
• We will need to
  • Make sure that all pointers are either pointing to valid memory or nullptr.
• Draw adding and deleting a node.