Upload
jalyn-prall
View
290
Download
8
Embed Size (px)
Citation preview
Linked List
1.1. Introduction to Linked ListIntroduction to Linked List
2.2. Node ClassNode Class
3.3. Linked ListLinked List
4.4. The Bag Class with Linked ListThe Bag Class with Linked List
Linked List
Linked ListLinked List Is a series of connected nodes, where each Is a series of connected nodes, where each
node is a data structure with data field and node is a data structure with data field and pointer(s) field.pointer(s) field.
Advantages over array implementationAdvantages over array implementation Can grow and shrink in size, with no upper limitCan grow and shrink in size, with no upper limit Fast insertion and deletionFast insertion and deletion
Ωhead
For this presentation, nodes in a linked list are objects, as shown
here.
data_field
link_field
10
data_field
link_field
15
data_field
link_field
7
null
class node{public: typedef double value_type; ...private value_type data_field; node *link_field;};
DeclarationsDeclarations forfor LinkedLinked ListsLists
typedef Keyword
typedef int age_t;typedef int age_t;typedef int count_t;typedef int count_t;typedef double gpa_t;typedef double gpa_t;……age_t myAge = 21;age_t myAge = 21;count_t numElements = 5;count_t numElements = 5;gpa_t myGPA = 3.8;gpa_t myGPA = 3.8;
void someFunc(age_t age, count_t count);void someFunc(age_t age, count_t count);
is clearer than is clearer than
void someFunct(int age, int count);void someFunct(int age, int count);
Why Use typedef?
Using typedefs can make your code clearer
Using ypedefs can make your code easier to modify
The data_field of each node is a type called value_type, defined by a typedef.
data_field
link_field
10
data_field
link_field
15
data_field
link_field
7
null
class node{public: typedef int value_type; ...private value_type data_field; node *link_field;};
DeclarationsDeclarations forfor LinkedLinked ListsLists
Each node also contains a link_field which is a pointer to another node.
data_field
link_field
10
data_field
link_field
15
data_field
link_field
7
null
class node{public: typedef int value_type; ...private value_type data_field; node *link_field;};
DeclarationsDeclarations forfor LinkedLinked ListsLists
Your Turn
Write the public interface for the Node Write the public interface for the Node class—e.g, Constructors, accessors, class—e.g, Constructors, accessors, modifiers.modifiers.
Solution
class node{public: //CONSTRUCTORS node(); node(const valueType& value, node* ptr); //CONSTANT FUNCTIONS valueType getData(); node* getNext(); //MODIFIER FUNCTIONS void setData(valueType newData); void setLink(node* newLink);
private: valueType data; node* next;};
Declarations for Linked Lists
A program can keep track of the front node by using a pointer variable such as head_ptr in this example.
Notice that head_ptr is not a node -- it is a pointer to a node.
head_ptr
data_field
link_field
10
data_field
link_field
15
data_field
link_field
7
null
Declarations for Linked Lists
A program can keep track of the front node by using a pointer variable such as head_ptr.
Notice that head_ptr is not a node -- it is a pointer to a node.
We represent the empty list by storing null in the head pointer.
head_ptr null
void list_head_insert(node*& head_ptr, const node::value_type& entry);
Inserting a Node at the Front
We want to add a new entry, We want to add a new entry, 13, to the 13, to the frontfront of the linked of the linked list shown here.list shown here.
10
15
7
nullhead_ptr
entry
13
Inserting a Node at the Front
Create a new node, pointed to by a local variable insert_ptr.
10
15
77
nullhead_ptrentry
13
insert_ptr
void list_head_insert(node*& head_ptr, const node::value_type& entry);
Inserting a Node at the Front
insert_ptr = new node;
10
15
7
nullhead_ptr
entry
13
insert_ptr
void list_head_insert(node*& head_ptr, const node::value_type& entry);
Inserting a Node at the Front
10
15
7
nullhead_ptr
entry
13
insert_ptr13
insert_ptr = new node;
Place the data in the new node's data_field.
void list_head_insert(node*& head_ptr, const node::value_type& entry);
Inserting a Node at the Front
10
15
7
nullhead_ptr
entry
13
insert_ptr
13
insert_ptr = new node;
Place the data in the new node's data_field.
Connect the new node to the front of the list.
void list_head_insert(node*& head_ptr, const node::value_type& entry);
Inserting a Node at the Front
10
15
7
nullhead_ptr
entry
13
insert_ptr13
insert_ptr = new node(entry, head_ptr);
The correct new node can be The correct new node can be completely created in one completely created in one step by calling an appropriate step by calling an appropriate node constructor.node constructor.
void list_head_insert(node*& head_ptr, const node::value_type& entry);
Inserting a Node at the Front
10
15
7
nullhead_ptr
entry
13
insert_ptr
13
insert_ptr = new node(entry, head_ptr);Make the old head pointer point to the new node.
void list_head_insert(node*& head_ptr, const node::value_type& entry);
Inserting a Node at the Front
10
15
7
nullhead_ptr
entry
13
insert_ptr
13
insert_ptr = new node(entry, head_ptr);head_ptr = insert_ptr;
void list_head_insert(node*& head_ptr, const node::value_type& entry);
Inserting a Node at the Front
insert_ptr = new node(entry, head_ptr);
head_ptr = insert_ptr;
10
15
7
nullhead_ptr
13
When the function returns, thelinked list has a new node at thefront.
void list_head_insert(node*& head_ptr, const node::value_type& entry);
void list_head_insert(node*& head_ptr, const node::value_type& entry){ node *insert_ptr;
insert_ptr = new node(entry, head_ptr);
head_ptr = insert_ptr;
}
Inserting a Node at the Front
Inserting a Node at the Front
void list_head_insert(node*& head_ptr, const node::value_type& entry){ node *insert_ptr;
insert_ptr = new node(entry, head_ptr);
head_ptr = insert_ptr;
} Does the function work
correctly for the empty list ?
head_ptrentry
13 null
Inserting a Node at the Front
Does the function work
correctly for the empty list ?
void list_head_insert(node*& head_ptr, const node::value_type& entry){ node *insert_ptr;
insert_ptr = new node(entry, head_ptr);
head_ptr = insert_ptr;
}
Inserting a Node at the Front
head_ptrentry
13 null
insert_ptr
13
void list_head_insert(node*& head_ptr, const node::value_type& entry){ node *insert_ptr;
insert_ptr = new node(entry, head_ptr);
head_ptr = insert_ptr;
}
null
Inserting a Node at the Front
head_ptrentry
13
insert_ptr
13
null
void list_head_insert(node*& head_ptr, const node::value_type& entry){ node *insert_ptr;
insert_ptr = new node(entry, head_ptr);
head_ptr = insert_ptr;
}
Inserting a Node at the Front
head_ptr
13
null
void list_head_insert(node*& head_ptr, const node::value_type& entry){ node *insert_ptr;
insert_ptr = new node(entry, head_ptr);
head_ptr = insert_ptr;
}When the function
returns, the linked list has one node.
Caution!
Always make sure that your linked list functions work correctly with an empty list.
Pseudocode for Inserting Nodes
Nodes are often inserted at places other than the front of a linked list.
There is a general pseudocode that you can follow for any insertion function. . .
Pseudocode for Inserting Nodes
Determine whether the new node will be the first node in the linked list. If so, then there is only one step:
list_head_insert(head_ptr, entry);
Pseudocode for Inserting Nodes
Determine whether the new node will be the first node Determine whether the new node will be the first node in the linked list. If so, then there is only one step:in the linked list. If so, then there is only one step:
The
func
tion
we
alre
ady
wro
te
list_head_insert(head_ptr, entry);
Pseudocode for Inserting Nodes
Determine whether the new node will be the first node in the linked list. If so, then there is only one step:
list_head_insert(head_ptr, entry);
A pointerto the
head ofthe list
Pseudocode for Inserting Nodes
Determine whether the new node will be the first node in the linked list. If so, then there is only one step:
list_head_insert(head_ptr, entry);
The data to put
in the new node
Pseudocode for Inserting Nodes
Otherwise (if the new node will not be first): Start by setting a pointer named previous_ptr to point to the
node which is just before the new node's position.
Pseudocode for Inserting Nodes
15
10
7
nullhead_ptr
Otherwise (if the new node will not be first): Start by setting a pointer named previous_ptr to point to the
node which is just before the new node's position.
In this example, thenew node will bethe second node
previous_ptr
Pseudocode for Inserting Nodes
15
10
7
nullhead_ptr
Otherwise (if the new node will not be first): Start by setting a pointer named previous_ptr to point to the
node which is just before the new node's position
What is the name of this orange pointer ?
Look at the pointerwhich is in the node
*previous_ptr
previous_ptr
Pseudocode for Inserting Nodes
15
10
7
nullhead_ptr
Otherwise (if the new node will not be first): Start by setting a pointer named previous_ptr to point to the
node which is just before the new node's position
This pointer is calledprevious_ptr->link_field(although this name maybe private to the node)
What is the name of What is the name of this orange pointer ?this orange pointer ?
previous_ptr
Pseudocode for Inserting Nodes
15
10
7
nullhead_ptr
Otherwise (if the new node will not be first): Start by setting a pointer named previous_ptr to point to the
node which is just before the new node's position
previous_ptr->link_fieldpoints to the headof a small linkedlist, with 10 and 7
previous_ptr
Pseudocode for Inserting Nodes
15
10
7
nullhead_ptr
Otherwise (if the new node will not be first): Start by setting a pointer named previous_ptr to point to the
node which is just before the new node's position.
The new node mustbe inserted at thefront of this small
linked list.
13
Write one C++ statement which will do the insertion.
previous_ptr
Pseudocode for Inserting Nodes
15
10
7
nullhead_ptr
Otherwise (if the new node will not be first): Start by setting a pointer named previous_ptr to point to the
node which is just before the new node's position.13
What might cause this statement to fail to compile?
previous_ptr
list_head_insert(previous_ptr->link_field, entry);
Pseudocode for Inserting Nodes
15
10
7
nullhead_ptr
Otherwise (if the new node will not be first): Start by setting a pointer named previous_ptr to point to the
node which is just before the new node's position.13
Use a node member function to get the link field if needed.
previous_ptr
list_head_insert(previous_ptr->link( ), entry);
Pseudocode for Inserting Nodes
Determine whether the new node will be the first node in the linked list. If so, then there is only one step:
list_head_insert(head_ptr, entry);
Otherwise (if the new node will not be first): Set a pointer named previous_ptr to point to the node
which is just before the new node's position. Make the function call:
list_head_insert(previous_ptr->link( ), entry);
Pseudocode for Inserting Nodes
The process of adding a new node in the The process of adding a new node in the middle of a list can also be incorporated as a middle of a list can also be incorporated as a separate function. This function is called separate function. This function is called list_insert in the linked list toolkit of Section list_insert in the linked list toolkit of Section 5.2.5.2.
Pseudocode for Removing Nodes
Nodes often need to be removed from a linked list.
As with insertion, there is a technique for removing a node from the front of a list, and a technique for removing a node from elsewhere.
We’ll look at the pseudocode for removing a node from the front of a linked list.
Removing the Head Node
10 15 7
nullhead_ptr
13
Start by setting up a temporary pointer named remove_ptr to the head node.
remove_ptr
Removing the Head Node
10 15 7
nullhead_ptr
13
Set up remove_ptr. head_ptr = remove_ptr->link( );
remove_ptr
Draw the change that this statement will make to the linked list.
Removing the Head Node
10 15 7
nullhead_ptr
13
Set up remove_ptr. head_ptr = remove_ptr->link( );
remove_ptr
Removing the Head Node
Set up remove_ptr. head_ptr = remove_ptr->link( ); delete remove_ptr; // Return the node's memory to heap.
10 15 7
nullhead_ptr
13
remove_ptr
Removing the Head Node
Here’s what the linked list looks like after the removal finishes.
10 15 7
nullhead_ptr
It is easy to insert a node at the front of a list. The linked list toolkit also provides a function
for inserting a new node elsewhere It is easy to remove a node at the front of a
list. The linked list toolkit also provides a function
for removing a node elsewhere--you should read about this function and the other functions of the toolkit.
Summary
Doubly Linked List
head Ω
class node{ . . .private: elementType data; node* next; node* previous;};
class list{ . . .private: node* head; int count;};
Ω
insertAtFront()
head ΩΩ
newPtr ΩΩ
head Ω
newPtrΩ
insertAtFront()
void list::insertAtFront(valueType item){ node* temp = new node(item, NULL, NULL); if (isEmpty()) head = temp; else { temp->setNext(head); head->setPrevious(temp); head = temp; } count++;}
removeFromFront()
head ΩΩ
head Ω
temp
ΩΩ
removeFromFront()
valueType list::removeFromFront(){ valueType result = NIL;
if (!isEmpty()) { result = head->getData();
node* temp = head; head->setPrevious(NULL); head = head->getNext(); delete temp; count--; } return result;}
insertAtBack()
head ΩΩ
newPtr ΩΩ
headΩ
newPtr Ω
temp
temp
insertAtBack()void list::insertAtBack(valueType item){ node* newPtr = new node(item, NULL, NULL);
// find the last node if (isEmpty()) head = newPtr; else { node* temp = head; while (temp->getNext() != NULL) { temp = temp->getNext(); } temp->setNext(newPtr); newPtr->setPrevious(temp); } count++;}
removeFromBack()
head ΩΩ
head Ω
temp
ΩΩ
removeFromBack()
valueType list::removeFromBack(){ valueType result = NIL;
if (!isEmpty()) { // find last node node* temp = head; while (temp->getNext() != NULL) { temp = temp->getNext(); } // remove last node temp->getPrevious()->setNext(NULL); delete temp; } return result;}
Tail Pointer (to the last node)
head Ω
class node{ . . .private: elementType data; node* next;};
class list{ . . .private: node* head; node* tail; int count;};
tail