Linked Lists 28/11/2018. Nodes with member functions. The need for a linked list class

Transcription

1 ECE 150 Fundamentals of Programming Outline 2 In this lesson, we will: Create a linked list class Implement numerous member functions Explain how to step through a linked list Linked Lists Douglas Wilhelm Harder, M.Math Prof. Hiren Patel, Ph.D. hdpatel@uwaterloo.ca dwharder@uwaterloo.ca 2018 by Douglas Wilhelm Harder and Hiren Patel. Some rights reserved. 3 4 Nodes with member functions The need for a linked list class Review our node class Holds an integer datum class Node; class Node { // Member functions to access private member variables Node( int value, Node *p_next = nullptr ); int get_value() const; Node *get_next() const; // Let's make them private now... int node_value; Node *p_next_node; ; A linked list of nodes is, however, difficult to deal with How and were do we add new nodes? Must we do this manually? We will create a linked list class that Stores the address of the first node Has member functions allowing us to access and manipulate the nodes in the linked list int Node::get_value() const { return node_value; Node *Node::get_next() const { return p_next_node; 1

2 5 6 Constructor and destructor Now we introduce a Linked_list class: class Node; class Linked_list; class Linked_list { Linked_list(); ~Linked_list(); ; // Constructor // Destructor Node *p_list_head; // Pointer to head node Constructor initializes the pointer to the head of the list Linked_list::Linked_list(): p_list_head{nullptr { // Nothing else for the constructor to do The destructor needs to delete the linked list, but how Linked_list::~Linked_list() { // To be completed later!!! 7 8 Empty query Inserting node Implement a public member function to check if the linked list is empty If p_list_head equals nullptr, the linked list is empty class Linked_list { Linked_list(); ~Linked_list(); ; // Public member functions bool empty() const; Node *p_list_head; bool Linked_list::empty() const { return ( nullptr == p_list_head ); We can insert a node into the linked list at the front of the list Introduce a public member function that inserts an integer at the front of the linked list void push_front( int datum ); class Linked_list { Linked_list(); ~Linked_list(); ; // Public member functions bool empty() const; void push_front( int datum ); Node *p_list_head; 2

3 Inserting node 9 Inserting into an empty linked list 10 There are two situations we may encounter when inserting a node at the front of a linked list The linked list is empty The linked list has at least one node When inserting (say, 42) into an empty linked list, we want this The steps involved are: Creating a new node storing the new datum that points to null Assigns the address of the new node to p_list_head Inserting into an empty linked list 11 Inserting into a non-empty linked list 12 We can do both in one step: void Linked_list::push_front( int datum ) { // This list is empty p_list_head = new Node{datum, nullptr; else { // This list is not empty When inserting (say, 42) into a non-empty linked list, we want this The steps involved are: Creating a new node storing the new datum that points to what p_list_head used to be storing Assigns the address of the new node to p_list_head 3

4 Inserting into a non-empty linked list 13 Inserting a node 14 We can do both of these, too, in one step: void Linked_list::push_front( int datum ) { // The list is empty p_list_head = new Node{datum, nullptr; else { // List is not empty p_list_head = new Node{datum, p_list_head; Consider this, however: Even when the linked list was empty, p_list_head is assigned the address we need, namely nullptr: void Linked_list::push_front( int datum ) { // The list is empty p_list_head = new Node{datum, nullptr; else { // List is not empty p_list_head = new Node{datum, p_list_head; We can simplify this to: void Linked_list::push_front( int datum ) { p_list_head = new Node{datum, p_list_head; Accessing the value at the front 15 Accessing the value at the front 16 We want the integer stored in the node at the front class Linked_list { Linked_list(); // Constructor ~Linked_list(); // Destructor ; // Public member functions bool empty() const; void push_front( int datum ); int front() const; Node *p_list_head; // Pointer to head node Suppose we want to access the first node: If a node exists, return its value Otherwise, it is nullptr Throw an exception in that case int Linked_list::front() const { std::cerr << "Error: list is empty" << std::endl; throw nullptr; else { return p_list_head->get_value(); 4

5 17 18 Creating a linked list Counting number of nodes in linked list class Node; class Linked_list; int main(); Suppose we want the number of nodes in the linked list This is the size of the linked list int main() { Linked_list list{; list.push_front( 150 ); std::cout << list.front() << std::endl; list.push_front( 105 ); std::cout << list.front() << std::endl; // What happens to the nodes? return 0; Output: We must step through the linked list, counting the nodes as we pass through them Set a counter to zero Assign a temporary pointer p_current_node the address assigned to p_list_head While p_current_node does not equal nullptr Increment the counter Set p_current_node the address of p_current_node->get_next() Counting number of nodes in linked list Counting number of nodes in linked list We will do this in a function size(): std::size_t Linked_list::size() const { size_t list_size{0; Node *p_current_node{p_list_head; while ( p_current_node!= nullptr ) { ++list_size; p_current_node = p_current_node->get_next(); Alternatively, we could use a for loop: std::size_t Linked_list::size() const { std::size_t list_size{0; for ( Node *p_current_node{p_list_head; p_current_node!= nullptr; p_current_node = p_current_node->get_next() ) { ++list_size; return list_size; return list_size; std::size_t Linked_list::size() const { size_t list_size{0; Node *p_current_node{p_list_head; while ( p_current_node!= nullptr ) { ++list_size; p_current_node = p_current_node->get_next(); return list_size; 5

6 21 22 Printing the linked list Finding a value Using this same format, we can print a linked list: void Linked_list::print() const { std::cout << "p_list_head -> "; for ( Node *p_current_node{p_list_head; p_current_node!= nullptr; p_current_node = p_current_node->get_next() ) { std::cout << "(" << p_current_node->get_value() << ") -> "; std::cout << "0" << std::endl; Using this same format, we can also find a value in a linked list: // Returns size() if the value was not found std::size_t Linked_list::find( int datum ) const { std::size_t position{0; for ( Node *p_current_node{p_list_head; (p_current_node!= nullptr) && (p_current_node->get_value()!= datum); p_current_node = p_current_node->get_next() ) { ++position; return position; Creating a linked list 23 Erasing a node 24 class Node; class Linked_list; int main(); int main() { Linked_list list{; list.push_front( 150 ); list.push_front( 105 ); std::cout << "Size: " << list.size() << std::endl; list.print(); To remove a node from the front of a linked list, we require a pop_front() member function We will return true or false, depending on whether or not we were successful in erasing the front node We may encounter three situations when erasing a node: The linked list may be empty There may be only one node in the linked list There may be more than one node in the linked list // What happens to the nodes? return 0; Output: Size: 2 p_list_head -> (105) -> (150) -> 0 6

7 Popping from an empty list Popping from a linked list with one node If the linked list is empty, there is no node to pop: else if ( 1 == size() ) { // Delete the one node in the linked list else { assert( size() > 1 ); // Delete the node at the head of the list Suppose there is only one node in the linked list: We must: Delete the node at the front of the linked list Set p_list_head the value nullptr Return true 27 Popping from a linked list with one node 28 Erasing one node is reasonably straight-forward: else if ( 1 == size() ) { // Delete the one node in the linked list delete p_list_head; p_list_head = nullptr; else { assert( size() > 1 ); // Delete the node at the head of the list Suppose there are many nodes in the linked list: We must: Delete the node at the front of the linked list Set p_list_head the address of the node pointed to by what used to be the node at the front Return true 7

8 29 30 Does this work? else if ( 1 == size() ) { // Delete the one node in the linked list delete p_list_head; p_list_head = nullptr; else { assert( size() > 1 ); delete p_list_head; p_list_head = p_list_head->get_next(); How about this? else if ( 1 == size() ) { // Delete the one node in the linked list delete p_list_head; p_list_head = nullptr; else { assert( size() > 1 ); p_list_head = p_list_head->get_next(); delete???; Instead, we must: Temporarily store the address of the front node Update the pointer to the list head The delete the old node Implementing this: else if ( 1 == size() ) { // Delete the one node in the linked list delete p_list_head; p_list_head = nullptr; else { assert( size() > 1 ); Node *p_previous_list_head{p_list_head; p_list_head = p_list_head->get_next(); delete p_previous_list_head; 8

9 33 Clearing all nodes in a list 34 Now, if the list has only one entry: p_list_head->get_next() is assigned nullptr Calling delete on nullptr is a valid C++ operation that does nothing Suppose we want to empty a non-empty linked list We must pop each node in the linked list Simplifying our implementation: else { assert( size() >= 1 ); Node *p_previous_list_head{p_list_head; p_list_head = p_list_head->get_next(); delete p_previous_list_head; Here is the hard way: void Linked_list::clear() { while ( p_list_head!= nullptr ) { Node *p_previous_list_head{p_list_head; p_list_head = p_current_node->get_next(); delete p_previous_list_head; Clearing all nodes in a list 35 Destructor 36 Question: Why not use member functions we already wrote: void Linked_list::clear() { while (!empty() ) { pop_front(); We can now author a destructor: Linked_list::~Linked_list() { clear(); 9

10 37 38 Summary Here is our Linked_list class so far: class Node; class Linked_list; class Linked_list { Linked_list(); // Constructor ~Linked_list(); // Destructor bool empty() const; std::size_t size() const; int front() const; void print() const; std::size_t find( int datum ) const; Following this lesson, you now Know how to create a simple linked list class Understand how member functions can implement most of the operations in question Know how to step through a linked list void push_front( int datum ); bool pop_front(); void clear(); ; Node *p_list_head; // Pointer to head node References Colophon [1] No references? These slides were prepared using the Georgia typeface. Mathematical equations use Times New Roman, and source code is presented using Consolas. The photographs of lilacs in bloom appearing on the title slide and accenting the top of each other slide were taken at the Royal Botanical Gardens on May 27, 2018 by Douglas Wilhelm Harder. Please see for more information. 10

11 Disclaimer 41 These slides are provided for the ECE 150 Fundamentals of Programming course taught at the University of Waterloo. The material in it reflects the authors best judgment in light of the information available to them at the time of preparation. Any reliance on these course slides by any party for any other purpose are the responsibility of such parties. The authors accept no responsibility for damages, if any, suffered by any party as a result of decisions made or actions based on these course slides for any other purpose than that for which it was intended. 11