Week 8 Pointers, Singly Linked Lists. Jimmy Voss

Transcription

1 Week 8 Pointers, Singly Linked Lists Jimmy Voss

2 Pointer Pictures I will use the following pictures for pointers Pointer Pointer Object pointed to Null Pointer? Pointer containing a random/unallocated/bad memory value

3 Thought Exercise How would we implement a binary tree using pointers?

4 Thought Exercise How would we implement a binary tree using pointers? Node Data Data Data

5 Thought Exercise The binary tree consisted of nodes. Each node had: A data field A left node pointer A right node pointer Null pointers indicated the child was an empty tree. Would still need to store additional values height and size separately.

6 Linked List Idea A linked list is a sequence of nodes, each containing 2 fields: Data field next pointer points to next node in the sequence. Most basic implementation has: head pointer points to the first node in the sequence marker pointer points the node currently being accessed.

7 Simplified Linked List marker data data data data Head next Questions: What happens if the list is empty? How do we advance the marker? How do we retreat the marker?

8 Simplified Linked List What happens if the list is empty? Under this simple implementation, the empty list has to be handled as a special case in all operations. How do we advance the marker? self[marker] = (*(self[marker]))[next] How do we retreat the marker? Have to restart from the beginning marker Head data data data data next

9 Resolve/C++ linked list (List_Kernel_1) smart (or dummy) node a node at the front of the singly linked list which contains no data. Having this simplifies member function logic. pre_start pointer which points to the smart node. last_left roughly marks where we are in the list. finish pointer to the last node in the list. left_length Integer storing number of items up to *(self[last_left]) right_length Integer storing number of items after *(self[last_left])

10 Resolve/C++ Linked List (List_Kernel_1) last left finish smart node data data data pre_start? next

11 Resolve/C++ linked list model Mathematically, we model a linked list by a pair of strings of item: List of Integers: (<1, 2, 5, 4>, <7, 8>) last left finish? pre_start?

12 List operations Move_To_Start() Move_To_Finish() Advance() Add_Right(x) Remove_Right(x) Accessor, i.e., [current] Left_Length() Right_Length() Change what last_left points to.

13 list.add_right(x); list.move_to_finish(); list.move_to_start(); list[current] &= x; list.advance(); list.remove_right(x); List Example What last_left points to in list list = (<1, 2>, <3>) x = 8 Node containing 2 list = (<1, 2>, <8, 3>) x = 0 Node containing 2 list = (<1, 2, 8, 3>, <>) x = 0 Node containing 3 list = (<>, <1, 2, 8, 3>) x = 0 smart node list = (<>, <0, 2, 8, 3>) x = 1 smart node list = (<0>, <2, 8, 3>) x = 1 Node containing 0 list = (<0>, <8, 3>) x = 2 Node containing 0

14 Exercise: Writing Add_Right(x) Get into groups and write up the code for the following procedure in List_Kernel_1 which inherits the following spec from List_Kernel: procedure Add_Right ( consumes Item& x ) is_abstract; /*! ensures self.left = #self.left and self.right = <#x> * #self.right!*/ Use the type Node to refer to nodes. Node is a record of 2 fields: data, next. List_Kernel_1 is a representation with the following fields: pre_start, last_left, finish, left_length, right_length

15 Exercise procedure_body Add_Right ( consumes Item& x ) { object Pointer_C <Node> p, q = self[last_left]; New (p); } (*p)[data] &= x; (*p)[next] = (*q)[next]; (*q)[next] = p; if (self[right_length] == 0) { self[finish] = p; } self[right_length]++; Question: What does the smart node give us in this code?

16 Destructors Resolve/C++ provides a Finalize member function for each class. Runs when an object goes out of scope or is destroyed via a call to Delete. In objects which use pointers, the destructor is responsible for deallocating all dynamically allocated memory.

17 Exercise destructor Write the logic required for the destructor of List_Kernel_1 local_procedure_body Finalize () { // fill in code here } Use the type Node to refer to nodes. Node is a record of 2 fields: data, next. List_Kernel_1 is a representation with the following fields: pre_start, last_left, finish, left_length, right_length

18 Exercise destructor local_procedure_body Finalize () { object Pointer_C <Node> p = self[pre_start]; } while (p!= self[finish]) { self[pre_start] = (*p)[next]; Delete (p); p = self[pre_start]; } Delete (p);

19 Announcement Lab 5 is due Thursday, March 8 at 10:00 PM We give you all the code for a singly linked list implementation (admittedly, some of which was in the previous 2 exercises). We ask you to implement a double linked list. Idea: In a doubly linked list, each node stores both a next and a previous pointer. Otherwise, they are fairly similar.