Unit 3: Linked Lists Part 1: Introduction to Singly Linked ... · 1 Introduction 1 Singly linked...

Unit 3: Linked ListsPart 1: Introduction to Singly Linked Lists

Engineering 4892:Data Structures

Faculty of Engineering & Applied ScienceMemorial University of Newfoundland

May 30, 2011

ENGI 4892 (MUN) Unit 3, Part 1 May 30, 2011 1 / 23

1 Introduction

1 Singly linked lists

1 Insertion

1 Deletion

1 Exceptions

Introduction

We will consider two main kinds of linked structures in this course:linked lists and trees.

A linked structure has nodes which store data and alink to another node (or links to other nodes).

Linked lists resolve two of the main problems with arrays:

The size of an array has to be known beforehand to allocate the rightamount of space.

Inserting or deleting items within an array may require other items tobe shifted.

(However, we will see that arrays maintain certain advantages over linkedlists.)

Introduction

We will consider two main kinds of linked structures in this course:linked lists and trees. A linked structure has nodes which store data and alink to another node (or links to other nodes).

Introduction

Singly linked lists

Unlike an array, the nodes in a linked structure are not necessarily heldtogether in memory.

The structure holds together because the nodes storeaddresses (called links) to other nodes.

All nodes in a singly linked list (SLL) have a single link to the successornode which follows it in the list. The following is an example SLL:

What are these links? Pointers.

Note the slash in the 50-node. This indicates a null pointer and marks theend of the list.

Singly linked lists

Unlike an array, the nodes in a linked structure are not necessarily heldtogether in memory. The structure holds together because the nodes storeaddresses (called links) to other nodes.

Singly linked lists

All nodes in a singly linked list (SLL) have a single link to the successornode which follows it in the list.

The following is an example SLL:

Singly linked lists

What are these links?

Pointers.

Singly linked lists

Note the slash in the 50-node.

This indicates a null pointer and marks theend of the list.

Singly linked lists

Consider the following class which represents a node used to store an int,

class IntSLLNode {public :

int info ;IntSLLNode ∗next ;IntSLLNode ( int el , IntSLLNode ∗ptr = 0) {

info = el ; next = ptr ;}

info is the node’s data

The next field stores this node’s link

The constructor initializes both (the link to null if not specified)

class IntSLLNode {

public :int info ;IntSLLNode ∗next ;IntSLLNode ( int el , IntSLLNode ∗ptr = 0) {

int info ;

IntSLLNode ∗next ;IntSLLNode ( int el , IntSLLNode ∗ptr = 0) {

int info ;IntSLLNode ∗next ;

IntSLLNode ( int el , IntSLLNode ∗ptr = 0) {info = el ; next = ptr ;

How can we create a list like this,

First, generate the node containing 10 and set a pointer-to-node variable p

to point to it,

IntSLLNode ∗p = new IntSLLNode ( 1 0 ) ;

Note that the next field is initialized to null. The node whose next fieldis null is the last node in the list.

To create the node containing 8 we will call new IntSLLNode(8). This willbe the new last node so it is acceptable that its next = 0. How do we linkit to our current list?

p−>next = new IntSLLNode ( 8 ) ;

to point to it,

Note that the next field is initialized to null.

The node whose next fieldis null is the last node in the list.

to point to it,

To create the node containing 8 we will call new IntSLLNode(8)

. This willbe the new last node so it is acceptable that its next = 0. How do we linkit to our current list?

to point to it,

To create the node containing 8 we will call new IntSLLNode(8). This willbe the new last node so it is acceptable that its next = 0.

How do we linkit to our current list?

to point to it,

Finally, how do we add the 50-node,

p−>next−>next = new IntSLLNode ( 5 0 ) ;

Note that the following are all valid pointers to nodes:

p (the first node)

p−>next (the second node)

p−>next−>next (the third node)

This strategy can easily get awkward. What if we want to refer to the100th node?

p−>next−>next−>next−>next−>next−>next ... −>next

Clearly a loop is called for. We define an SLL class for integers whichencapsulates standard operations. This class employs two special pointerscalled head and tail which point to the first and last nodes in the list(respectively).

p (the first node)

This strategy can easily get awkward.

What if we want to refer to the100th node?

p (the first node)

Clearly a loop is called for.

We define an SLL class for integers whichencapsulates standard operations. This class employs two special pointerscalled head and tail which point to the first and last nodes in the list(respectively).

p (the first node)

Clearly a loop is called for. We define an SLL class for integers whichencapsulates standard operations.

This class employs two special pointerscalled head and tail which point to the first and last nodes in the list(respectively).

p (the first node)

class IntSLList {

public :IntSLList ( ) {

head = tail = 0 ;}˜IntSLList ( ) ;int isEmpty ( ) {

return head == 0 ;}void addToHead ( int ) ;void addToTail ( int ) ;int deleteFromHead ( ) ; // d e l e t e head , r e t u r n i n f o ;int deleteFromTail ( ) ; // d e l e t e t a i l , r e t u r n i n f o ;void deleteNode ( int ) ;bool isInList ( int ) const ;void printAll ( ) const ;

private :IntSLLNode ∗head , ∗tail ;

class IntSLList {public :

IntSLList ( ) {head = tail = 0 ;

˜IntSLList ( ) ;int isEmpty ( ) {

}˜IntSLList ( ) ;

int isEmpty ( ) {return head == 0 ;

}void addToHead ( int ) ;void addToTail ( int ) ;int deleteFromHead ( ) ; // d e l e t e head , r e t u r n i n f o ;int deleteFromTail ( ) ; // d e l e t e t a i l , r e t u r n i n f o ;void deleteNode ( int ) ;bool isInList ( int ) const ;void printAll ( ) const ;

}˜IntSLList ( ) ;int isEmpty ( ) {

return head == 0 ;}

void addToHead ( int ) ;void addToTail ( int ) ;int deleteFromHead ( ) ; // d e l e t e head , r e t u r n i n f o ;int deleteFromTail ( ) ; // d e l e t e t a i l , r e t u r n i n f o ;void deleteNode ( int ) ;bool isInList ( int ) const ;void printAll ( ) const ;

private :

IntSLLNode ∗head , ∗tail ;} ;

Our previous list would look like this for an IntSLList,

An empty list is represented with both head and tail set to null (althoughit is sufficient to check only head in isEmpty).

We will now consider the various operations of IntSLList in detail:

Insertion

The addToHead method creates a new node at the beginning of the list.

This method has to do the following:

Create a new node

Initialize the node’s info field

Set the node’s next field to the current first node

Update head

All four steps are accomplished by the first line of addToHead:

void IntSLList : : addToHead ( int el ) {head = new IntSLLNode (el , head ) ;. . .

Insertion

The addToHead method creates a new node at the beginning of the list.This method has to do the following:

Create a new node

Update head

Insertion

Create a new node

Update head

Insertion

Create a new node

Update head

Insertion

Create a new node

Update head

Insertion

Create a new node

Update head

Insertion

Create a new node

Update head

Insertion

Create a new node

Update head

Insertion

Create a new node

Update head

void IntSLList : : addToHead ( int el ) {

head = new IntSLLNode (el , head ) ;. . .

Insertion

Create a new node

Update head

Insertion

Create a new node

Update head

(code repeated)

void IntSLList : : addToHead ( int el ) {

head = new IntSLLNode (el , head ) ;. . .

There is one special case to consider. What if the list was previouslyempty. How will tail get set? We have to set it, but only if the list iscurrently empty:

void IntSLList : : addToHead ( int el ) {head = new IntSLLNode (el , head ) ;if ( tail == 0)

tail = head ;}

Note: We have not checked to see whether a new node was properlyallocated from the heap. This check is omitted from IntSLList.

(code repeated)

tail = head ;}

(code repeated)

There is one special case to consider.

What if the list was previouslyempty. How will tail get set? We have to set it, but only if the list iscurrently empty:

tail = head ;}

(code repeated)

There is one special case to consider. What if the list was previouslyempty.

How will tail get set? We have to set it, but only if the list iscurrently empty:

tail = head ;}

(code repeated)

There is one special case to consider. What if the list was previouslyempty. How will tail get set?

We have to set it, but only if the list iscurrently empty:

tail = head ;}

(code repeated)

tail = head ;}

(code repeated)

void IntSLList : : addToHead ( int el ) {head = new IntSLLNode (el , head ) ;

if ( tail == 0)tail = head ;

(code repeated)

tail = head ;}

(code repeated)

tail = head ;}

Note: We have not checked to see whether a new node was properlyallocated from the heap.

This check is omitted from IntSLList.

(code repeated)

tail = head ;}

The steps required by addToTail are quite similar.

However, we now haveto change two existing pointers: tail, the current last node’s next.

void IntSLList : : addToTail ( int el ) {. . .tail−>next = new IntSLLNode (el ) ;tail = tail−>next ;. . .

Special case: Empty list. Must set both head and tail:

void IntSLList : : addToTail ( int el ) {if ( tail != 0) { // i f l i s t not empty ;

tail−>next = new IntSLLNode (el ) ;tail = tail−>next ;

}else head = tail = new IntSLLNode (el ) ;

The steps required by addToTail are quite similar. However, we now haveto change two existing pointers:

tail, the current last node’s next.

The steps required by addToTail are quite similar. However, we now haveto change two existing pointers: tail, the current last node’s next.

void IntSLList : : addToTail ( int el ) {

. . .tail−>next = new IntSLLNode (el ) ;tail = tail−>next ;. . .

void IntSLList : : addToTail ( int el ) {. . .tail−>next = new IntSLLNode (el ) ;

tail = tail−>next ;. . .

Special case:

Empty list. Must set both head and tail:

Special case: Empty list.

Must set both head and tail:

void IntSLList : : addToTail ( int el ) {

if ( tail != 0) { // i f l i s t not empty ;tail−>next = new IntSLLNode (el ) ;tail = tail−>next ;

tail−>next = new IntSLLNode (el ) ;

tail = tail−>next ;}else head = tail = new IntSLLNode (el ) ;

else head = tail = new IntSLLNode (el ) ;}

What is the asymptotic complexity of these two methods?

tail = head ;}

Both are O(1). What would be the complexity of addToTail without thetail pointer? O(n)

tail = head ;}

Both are O(1).

What would be the complexity of addToTail without thetail pointer? O(n)

tail = head ;}

Both are O(1). What would be the complexity of addToTail without thetail pointer?

tail = head ;}

Deletion

The deleteFromHead method deletes the first node of the list, and returnsthe value stored at that node.

This method has to do the following:

Store the value at the head node in a temporary variable

Store the head node itself in a temporary variable

Update head (and maybe tail)

Delete the former head node

Return the stored value

int IntSLList : : deleteFromHead ( ) {int el = head−>info ;IntSLLNode ∗tmp = head ;. . .head = head−>next ;delete tmp ;return el ;

Deletion

The deleteFromHead method deletes the first node of the list, and returnsthe value stored at that node. This method has to do the following:

Deletion

int IntSLList : : deleteFromHead ( ) {

int el = head−>info ;IntSLLNode ∗tmp = head ;. . .head = head−>next ;delete tmp ;return el ;

Deletion

int IntSLList : : deleteFromHead ( ) {int el = head−>info ;

IntSLLNode ∗tmp = head ;. . .head = head−>next ;delete tmp ;return el ;

Deletion

int IntSLList : : deleteFromHead ( ) {int el = head−>info ;IntSLLNode ∗tmp = head ;

. . .head = head−>next ;delete tmp ;return el ;

Deletion

int IntSLList : : deleteFromHead ( ) {int el = head−>info ;IntSLLNode ∗tmp = head ;. . .

head = head−>next ;delete tmp ;return el ;

Deletion

int IntSLList : : deleteFromHead ( ) {int el = head−>info ;IntSLLNode ∗tmp = head ;. . .head = head−>next ;

delete tmp ;return el ;

Deletion

int IntSLList : : deleteFromHead ( ) {int el = head−>info ;IntSLLNode ∗tmp = head ;. . .head = head−>next ;delete tmp ;

return el ;}

Deletion

(code repeated)

int el = head−>info ;IntSLLNode ∗tmp = head ;. . .head = head−>next ;delete tmp ;return el ;

Special case: What if there is only a single node in the list? This code setshead to null, but it should set tail as well...

int IntSLList : : deleteFromHead ( ) {int el = head−>info ;IntSLLNode ∗tmp = head ;if ( head == tail ) // i f o n l y one node i n t he l i s t

head = tail = 0 ;else head = head−>next ;delete tmp ;return el ;

(code repeated)

IntSLLNode ∗tmp = head ;. . .head = head−>next ;delete tmp ;return el ;

(code repeated)

. . .head = head−>next ;delete tmp ;return el ;

(code repeated)

int IntSLList : : deleteFromHead ( ) {int el = head−>info ;IntSLLNode ∗tmp = head ;. . .

head = head−>next ;delete tmp ;return el ;

(code repeated)

int IntSLList : : deleteFromHead ( ) {int el = head−>info ;IntSLLNode ∗tmp = head ;. . .head = head−>next ;

(code repeated)

int IntSLList : : deleteFromHead ( ) {int el = head−>info ;IntSLLNode ∗tmp = head ;. . .head = head−>next ;delete tmp ;

return el ;}

(code repeated)

Special case: What if there is only a single node in the list?

This code setshead to null, but it should set tail as well...

(code repeated)

int el = head−>info ;IntSLLNode ∗tmp = head ;if ( head == tail ) // i f o n l y one node i n t he l i s t

(code repeated)

IntSLLNode ∗tmp = head ;if ( head == tail ) // i f o n l y one node i n t he l i s t

(code repeated)

if ( head == tail ) // i f o n l y one node i n t he l i s thead = tail = 0 ;

else head = head−>next ;delete tmp ;return el ;

(code repeated)

head = tail = 0 ;

else head = head−>next ;delete tmp ;return el ;

(code repeated)

head = tail = 0 ;else head = head−>next ;

(code repeated)

head = tail = 0 ;else head = head−>next ;delete tmp ;

return el ;}

(code repeated)

Special case: What if the list is empty?

This is more difficult to handle.What should we return to the user to indicate this problem? We deal withthis by stipulating the following precondition:

// Pre : The l i s t i s not empty .int IntSLList : : deleteFromHead ( ) ;

It would also be a good idea to use an assert statement to ensure thatthe precondition is adhered to,

int IntSLList : : deleteFromHead ( ) {assert ( ! isEmpty ( ) ) ;. . .

But this assert is just a precaution. The user of this SLL should calldeleteFromHead like this,

if ( ! list . isEmpty ( ) )x = list . deleteFromHead ( ) ;

// do someth ing e l s e . . .

Special case: What if the list is empty? This is more difficult to handle.

What should we return to the user to indicate this problem? We deal withthis by stipulating the following precondition:

Special case: What if the list is empty? This is more difficult to handle.What should we return to the user to indicate this problem?

We deal withthis by stipulating the following precondition:

Special case: What if the list is empty? This is more difficult to handle.What should we return to the user to indicate this problem? We deal withthis by stipulating the following precondition:

assert ( ! isEmpty ( ) ) ;. . .

But this assert is just a precaution.

The user of this SLL should calldeleteFromHead like this,

Exceptions

Another possibility for the case where deleteFromHead is called on anempty list is to throw an exception.

Throwing an exception (by example)

class DivByZero {public :

string msg ;DivByZero ( string inMsg ) { msg = inMsg ; }

double safeDivide ( double num , double den ) {if ( den == 0)

throw DivByZero ("Division by zero in safeDivide" ) ;return num / den ;

If den == 0 the function will construct an instance of DivByZero andterminate, throwing this object up to the caller. The return statement willnot be reached.

Exceptions

If den == 0 the function will construct an instance of DivByZero andterminate, throwing this object up to the caller.

The return statement willnot be reached.

Exceptions

Exception handling

void foo ( ) {safeDivide ( 3 , 0 ) ;

void bar ( ) {try {

foo ( ) ;} catch ( DivByZero &exception ) {

cerr << "Exception: " << exception . msg << endl ;}

int main ( int argc , char ∗∗argv ) {bar ( ) ;return 0 ;

Clearly foo will cause the exception to be thrown. However, the exceptionis caught in bar. The object created in the throw statement can beinspected here.

Exception handling

void bar ( ) {try {

Exception handling

void bar ( ) {try {

foo ( ) ;

} catch ( DivByZero &exception ) {cerr << "Exception: " << exception . msg << endl ;

Exception handling

void bar ( ) {try {

Exception handling

void bar ( ) {try {

cerr << "Exception: " << exception . msg << endl ;

Exception handling

void bar ( ) {try {

Exception handling

void bar ( ) {try {

Exception handling

void bar ( ) {try {

Exception handling

void bar ( ) {try {

Clearly foo will cause the exception to be thrown.

However, the exceptionis caught in bar. The object created in the throw statement can beinspected here.

Exception handling

void bar ( ) {try {

Clearly foo will cause the exception to be thrown. However, the exceptionis caught in bar.

The object created in the throw statement can beinspected here.

Exception handling

void bar ( ) {try {

Notes on exceptions

If left uncaught an exception will propagate all the way up to the user.

Ifthe try and catch statements are removed from bar the exception will getthrown up to main and then actually terminate the program with themessage:

terminate called after throwing an instance of ’DivByZero’

(or similar)

The idea of exceptions in C++ is to allow a problem (i.e. an exception) tobe handled at the appropriate level. For example, deleteFromHead cannotdeal with an empty list. However, if deleteFromHead was modified tothrow an exception, the calling code might be in the position to catch theexception and choose some appropriate course of action.

Note that there are different theories as to how exceptions should be used.Most people advocate using them only for very exceptional circumstances(trying to delete from an empty list probably doesn’t qualify).

Notes on exceptions

If left uncaught an exception will propagate all the way up to the user. Ifthe try and catch statements are removed from bar the exception will getthrown up to main and then actually terminate the program with themessage:

(or similar)

Notes on exceptions

(or similar)

Notes on exceptions

(or similar)

The idea of exceptions in C++ is to allow a problem (i.e. an exception) tobe handled at the appropriate level.

For example, deleteFromHead cannotdeal with an empty list. However, if deleteFromHead was modified tothrow an exception, the calling code might be in the position to catch theexception and choose some appropriate course of action.

Notes on exceptions

(or similar)

The idea of exceptions in C++ is to allow a problem (i.e. an exception) tobe handled at the appropriate level. For example, deleteFromHead cannotdeal with an empty list.

However, if deleteFromHead was modified tothrow an exception, the calling code might be in the position to catch theexception and choose some appropriate course of action.

Notes on exceptions

(or similar)

Notes on exceptions

(or similar)

Note that there are different theories as to how exceptions should be used.

Most people advocate using them only for very exceptional circumstances(trying to delete from an empty list probably doesn’t qualify).

Notes on exceptions

(or similar)

Consider, deleteFromTail.

The idea of this function is similar todeleteFromHead but there are additional complications. The followingtasks must be accomplished:

Store the value of the current last node

Find the predecessor of the current last node

Delete the current last node

Update tail

Update the new last node

The problem is the second step. We must find the node whose next

pointer equals tail.

for ( tmp = head ; tmp−>next != tail ; tmp = tmp−>next ) ;

Consider, deleteFromTail. The idea of this function is similar todeleteFromHead but there are additional complications.

The followingtasks must be accomplished:

Update tail

Consider, deleteFromTail. The idea of this function is similar todeleteFromHead but there are additional complications. The followingtasks must be accomplished:

Update tail

The problem is the second step.

We must find the node whose next

Update tail

for ( tmp = head ;

tmp−>next != tail ; tmp = tmp−>next ) ;

Update tail

for ( tmp = head ; tmp−>next != tail ;

tmp = tmp−>next ) ;

Update tail

We can now proceed with deleteFromTail,

int IntSLList : : deleteFromtail ( ) {int el = tail−>info ;. . .IntSLLNode ∗tmp ; // The p r e d e c e s s o r o f t a i lfor ( tmp = head ; tmp−>next != tail ; tmp = tmp−>next ) ;delete tail ;tail = tmp ;tail−>next = 0 ;. . .return el ;

Special Cases:

The list is empty. Same problem as for deleteFromHead. We employthe same solution (i.e. add a precondition in the documentation andan assert statement to check it in the code).

There is just one node in the list. The predessor search above will notwork! Also, we will now need to modify head.

int IntSLList : : deleteFromtail ( ) {int el = tail−>info ;

. . .IntSLLNode ∗tmp ; // The p r e d e c e s s o r o f t a i lfor ( tmp = head ; tmp−>next != tail ; tmp = tmp−>next ) ;delete tail ;tail = tmp ;tail−>next = 0 ;. . .return el ;

Special Cases:

int IntSLList : : deleteFromtail ( ) {int el = tail−>info ;. . .IntSLLNode ∗tmp ; // The p r e d e c e s s o r o f t a i l

for ( tmp = head ; tmp−>next != tail ; tmp = tmp−>next ) ;delete tail ;tail = tmp ;tail−>next = 0 ;. . .return el ;

Special Cases:

int IntSLList : : deleteFromtail ( ) {int el = tail−>info ;. . .IntSLLNode ∗tmp ; // The p r e d e c e s s o r o f t a i lfor ( tmp = head ; tmp−>next != tail ; tmp = tmp−>next ) ;

delete tail ;tail = tmp ;tail−>next = 0 ;. . .return el ;

Special Cases:

int IntSLList : : deleteFromtail ( ) {int el = tail−>info ;. . .IntSLLNode ∗tmp ; // The p r e d e c e s s o r o f t a i lfor ( tmp = head ; tmp−>next != tail ; tmp = tmp−>next ) ;delete tail ;

tail = tmp ;tail−>next = 0 ;. . .return el ;

Special Cases:

int IntSLList : : deleteFromtail ( ) {int el = tail−>info ;. . .IntSLLNode ∗tmp ; // The p r e d e c e s s o r o f t a i lfor ( tmp = head ; tmp−>next != tail ; tmp = tmp−>next ) ;delete tail ;tail = tmp ;

tail−>next = 0 ;. . .return el ;

Special Cases:

int IntSLList : : deleteFromtail ( ) {int el = tail−>info ;. . .IntSLLNode ∗tmp ; // The p r e d e c e s s o r o f t a i lfor ( tmp = head ; tmp−>next != tail ; tmp = tmp−>next ) ;delete tail ;tail = tmp ;tail−>next = 0 ;

. . .return el ;

Special Cases:

The list is empty.

Same problem as for deleteFromHead. We employthe same solution (i.e. add a precondition in the documentation andan assert statement to check it in the code).

Special Cases:

The list is empty.

Same problem as for deleteFromHead. We employthe same solution (i.e. add a precondition in the documentation andan assert statement to check it in the code).

Special Cases:

The list is empty. Same problem as for deleteFromHead.

We employthe same solution (i.e. add a precondition in the documentation andan assert statement to check it in the code).

Special Cases:

There is just one node in the list.

The predessor search above will notwork! Also, we will now need to modify head.

Special Cases:

There is just one node in the list.

The predessor search above will notwork! Also, we will now need to modify head.

Special Cases:

There is just one node in the list. The predessor search above will notwork!

Also, we will now need to modify head.

Special Cases:

Final version:

int IntSLList : : deleteFromTail ( ) {assert ( ! isEmpty ( ) ) ;int el = tail−>info ;if ( head == tail ) { // i f o n l y one node i n l i s t

delete head ;head = tail = 0 ;

}else { // more than one node

IntSLLNode ∗tmp ; // the p r e d e c e s s o r o f t a i lfor ( tmp = head ; tmp−>next != tail ;

tmp = tmp−>next ) ;delete tail ;tail = tmp ; // p r e d e c e s s o r o f t a i l becomes t a i ltail−>next = 0 ;

}return el ;

Final version:

int IntSLList : : deleteFromTail ( ) {assert ( ! isEmpty ( ) ) ;

int el = tail−>info ;if ( head == tail ) { // i f o n l y one node i n l i s t

}return el ;

Final version:

int IntSLList : : deleteFromTail ( ) {assert ( ! isEmpty ( ) ) ;int el = tail−>info ;

if ( head == tail ) { // i f o n l y one node i n l i s tdelete head ;head = tail = 0 ;

}return el ;

Final version:

}return el ;

Final version:

delete head ;

head = tail = 0 ;}else { // more than one node

}return el ;

Final version:

}return el ;

Final version:

IntSLLNode ∗tmp ; // the p r e d e c e s s o r o f t a i l

for ( tmp = head ; tmp−>next != tail ;tmp = tmp−>next ) ;

delete tail ;tail = tmp ; // p r e d e c e s s o r o f t a i l becomes t a i ltail−>next = 0 ;

}return el ;

Final version:

tmp = tmp−>next ) ;

delete tail ;tail = tmp ; // p r e d e c e s s o r o f t a i l becomes t a i ltail−>next = 0 ;

}return el ;

Final version:

tmp = tmp−>next ) ;delete tail ;

tail = tmp ; // p r e d e c e s s o r o f t a i l becomes t a i ltail−>next = 0 ;

}return el ;

Final version:

tmp = tmp−>next ) ;delete tail ;tail = tmp ;

// p r e d e c e s s o r o f t a i l becomes t a i ltail−>next = 0 ;

}return el ;

Final version:

}return el ;

Final version:

}return el ;

Final version:

}return el ;

deleteFromHead involves no loops, just the manipulation of a few pointers:O(1)

deleteFromTail does have a loop. The body of this loop is entered n − 1times. Hence, deleteFromTail is O(n).

deleteFromHead involves no loops, just the manipulation of a few pointers:

deleteFromTail does have a loop.

The body of this loop is entered n − 1times. Hence, deleteFromTail is O(n).

deleteFromTail does have a loop. The body of this loop is entered n − 1times.

Hence, deleteFromTail is O(n).

Unit 3: Linked Lists Part 1: Introduction to Singly Linked ... · 1 Introduction 1 Singly linked...

Documents

Transcript of Unit 3: Linked Lists Part 1: Introduction to Singly Linked ... · 1 Introduction 1 Singly linked...

CS235102 Data Structures Chapter 4 Lists. Pointers Singly Linked Lists Dynamically Linked Stacks and Queues Polynomials Chain Circularly Linked.

Linked List 3 Stack 33 Queue 40 - WordPress.com By Dhaval S Sheth(9033271276) 3 Linked List Singly Linked List Explain Singly Linked list: - Ans. A singly linked list is a linked list

4-1 4 Linked List Data Structures Linked lists: singly-linked and doubly-linked. Insertion. Deletion. Searching. © 2001, D.A. Watt and D.F. Brown.

Implementation of Singly Linked List

Linked Lists - math.uaa.alaska.eduDoubly-Linked Lists A doubly-linked list maintains pointers in both directions. For example, with a singly linked list, if we want to delete the tail,

BBM 201 DATA STRUCTURES - Hacettepebbm201/Fall2015/Lectures/BBM201-Ders12.pdf · Circular singly linked list representation • To represent sparse matrix in circular singly linked

บทที่ 4 โครงสร้างข้อมูลแบบลิงค์ลิสต์ ( Linked List · Singly linked list รูปที่ 1.2 แสดงส่วนประกอบของ

Unit 3: Linked Lists Part 1: Introduction to Singly Linked ... · Unit 3: Linked Lists Part 1: Introduction to Singly Linked Lists Engineering 4892: Data Structures Faculty of Engineering

CS350: Data Structures Linked Lists - ycpcs.github.io file- singly linked lists - doubly linked lists - circular linked lists • Composed of a set of nodes that hold data and contain

#1. Complete Program for Singly Linked List

3.7 Reversing a Singly Linked List - WordPress.com · 3.7 Reversing a Singly Linked List #include #include struct node { int data; struct node *next;

A program to implement singly linked listcs.uok.edu.in/Files/79755f07-9550-4aeb-bd6f-5d802d56b46d... · 2020. 5. 1. · A program to implement singly linked list #include

Singly Linked Lists - York University · 2018-09-13 · © 2014 Goodrich, Tamassia , Goldwasser Singly Linked Lists 3 A Nested Node Class

1 Linked Lists (Lec 6). 2 Introduction Singly Linked Lists Circularly Linked Lists Doubly Linked Lists Multiply Linked Lists Applications.

1 Array vs. Linked List Array vs. Linked List Pointers & Nodes Pointers & Nodes Singly linked list Singly linked list Doubly linked list Doubly linked.

1 Linked Lists (continued (continued)) Lecture 5 (maybe) Copying and sorting singly linked lists Lists with head and last nodes Doubly linked lists Append/Circular.

singly-linked list and doubly-linked list (eng)

Singly Linked List by mahi

1 Linked Lists Starring: Singly Linked List ListNode Doubly Linked List Iterator Co-Starring: ListIterator.

Linked Lists1 Part-B3 Linked Lists. Linked Lists2 Singly Linked List (§ 4.4.1) A singly linked list is a concrete data structure consisting of a sequence.