CSCI 2170 1

Linked lists

CSCI 2170 2

Definitions (linked) list is a data structure for efficient

dynamic data storage node - element of a list

data part - holds information contained in the list pointer (reference) part - a pointer to type(class) node

nodes are allocated dynamically list is formed by having the reference part of one node point to the next

node head (node) - first node in the list tail (node) - last node in the list

the reference part of the tail points to NULL

‘a’ ‘b’ ‘c’ ‘d’ NULL

‘b’

(linked) list

datapart

pointerpart

node

head (node) tail (node)

CSCI 2170 3

List manipulation since head points to the next node and (transitively) to all the other

nodes, all the information necessary to get the list data is a pointer to the head

list traversal - going through list elements to collect information onthe list’s structure or data stored

to traverse

1. allocate pointer variable for traversal (ptr)

2. assign address of head (from pointer to head) to ptr

3. look up the pointer part of node and assign it to ptr

4. Repeat step 3 until NULL is encountered since nodes are allocated dynamically, they can be removed and added

to the list with only minimum modifications required

‘a’ ‘b’ ‘c’ ‘d’NULLhead (node) tail (node)

pointer to head

ptr ptr ptr ptr

CSCI 2170 4

Review what is a list? what is a node? what does data part of node contain? what does the reference part of node contain? what is the head of a list? what is the tail of a list? what does the reference part of the tail of the list points to? what is list traversal? why would you want to traverse a

list?

CSCI 2170 5

Linked Lists

• Definition of Linked Lists

• Examples of Linked Lists

• Operations on Linked Lists

• Linked List as a Class

• Linked Lists as Implementations of Stacks, Sets, etc.

CSCI 2170 6

Definition of Linked Lists

• A linked list is a sequence of items (objects) where every item is linked to the next.

• Graphically:

data data data data

head_ptr

CSCI 2170 7

Definition Details

• Each item has a data part (one or more data members), and a link that points to the next item

• One natural way to implement the link is as a pointer; that is, the link is the address of the next item in the list

• It makes good sense to view each item as an object, that is, as an instance of a class.

• We call that class: Node• The last item does not point to anything. We set its

link member to NULL. This is denoted graphically by a slash in the link.

CSCI 2170 8

Examples of Linked Lists(A Waiting Line)

• A waiting line of customers: John, Mary, Dan, Sue (from the head to the tail of the line)

• A linked list of strings can represent this line:

John Mary Dan Sue

head_ptr

CSCI 2170 9

Examples of Linked Lists(A Stack of Numbers)

• A stack of numbers (from top to bottom): 10, 8, 6, 8, 2

• A linked list of ints can represent this stack:

10 8 6 2

head_ptr

8

CSCI 2170 10

Examples of Linked Lists(A Set of Non-redundant Elements)

• A set of characters: a, b, d, f, c

• A linked list of chars can represent this set:

a b d c

head_ptr

f

CSCI 2170 11

Examples of Linked Lists(A Sorted Set of Non-redundant Elements)• A set of characters: a, b, d, f, c

• The elements must be arranged in sorted order: a, b, c, d, f

• A linked list of chars can represent this set:

a b c f

head_ptr

d

CSCI 2170 12

Examples of Linked Lists(A Polynomial)

• A polynomial of degree n is the function Pn(x)=a0+a1x+a2x2+…+anxn. The ai’s are called the coefficients of the polynomial

• The polynomial can be represented by a linked list (2 data members and a link per item):

a0,0 a1,1 a2,2 an,n

head_ptr

CSCI 2170 13

Operations on Linked Lists• Insert a new item

– At the head of the list, or– At the end of the list, or– Inside the list, in some designated position

• Search for an item in the list– The item can be specified by position, or by some value

• Delete an item from the list– Search for and locate the item, then remove the item,

and finally adjust the surrounding pointers

• size( );• isEmpty( )

CSCI 2170 14

Insert– At the Head• Insert a new data A. Call new: newPtr

List before insertion:

• After insertion to head:

data data data data

head_ptr

A

data data data data

head_ptr

A

•The link value in the new item = old head_ptr•The new value of head_ptr = newPtr

CSCI 2170 15

Insert – at the Tail• Insert a new data A. Call new: newPtr

List before insertion

• After insertion at end:

data data data data

head_ptr

A

data data data data

head_ptr

A

•The link value in the new item = NULL•The link value of the old last item = newPtr

CSCI 2170 16

Insert – inside the List• Insert a new data A. Call new: newPtr

List before insertion:

• After insertion in 3rd position:

data data data data

head_ptr

data

data A data data

head_ptr

data

•The link-value in the new item = link-value of 2nd item•The new link-value of 2nd item = newPtr

CSCI 2170 17

Delete – the Head Item• List before deletion:

• List after deletion of the head item:

data data data data

head_ptr

data data data data

head_ptr

data

•The new value of head_ptr = link-value of the old head item•The old head item is deleted and its memory returned

data

CSCI 2170 18

Delete – the Tail Item• List before deletion:

• List after deletion of the last item:

data data data data

head_ptr

data data data

head_ptr

•New value of link value of the next to last item•New link value of new last item = NULL.

data

datadata

CSCI 2170 19

Delete – an inside Item• List before deletion:

• List after deletion of the 2nd item:

data data data data

head_ptr

data data

head_ptr

•New link-value of the item located before the deleted one = the link-value of the deleted item

data

data datadata

CSCI 2170 20

size() and isEmpty()

• We need to scan the items in the list from the head_ptr to the last item marked by its link-value being NULL

• Count the number of items in the scan, and return the count. This is the size().

• Alternatively, keep a counter of the number of item, which gets updated after each insert/delete. The function size( ) returns that counter

• If head_ptr is NULL, isEmpty() returns true; else, it returns false.

CSCI 2170 21

Searching for an Item

• Suppose you want to find the item whose data value is A

• You have to search sequentially starting from the head item rightward until the first item whose data member is equal to A is found.

• At each item searched, a comparison between the data member and A is performed.

CSCI 2170 22

Time of the Operations

• Time to search() is O(L) where L is the relative location of the desired item in the List. In the worst case. The time is O(n). In the average case it is O(N/2)=O(n).

• Time for remove() is dominated by the time for search, and is thus O(n).

• Time for insert at head or at tail is O(1).• Time for insert at other positions is dominated by

search time, and thus O(n).• Time for size() is O(1), and time for isEmpty() is O(1)

CSCI 2170 23

Implementation of an Item

• Each item is a collection of data and pointer fields, and should be able to support some basic operations such as changing its link value and returning its member data

• Therefore, a good implementation of an item is a class

• The class will be called Node

CSCI 2170 24

Class Node Design for Item• The member variables of Node are:

– The data field(s)– The link pointer, which will be called next

• The functions are:

Function Action Why Needed

getNext( ) returns the link. for navigation

getData( ) returns the data for search

setNext(Node *ptr) sets link to ptr for insert/delete

setData(type x) sets data to x. to modify data contents

CSCI 2170 25

Class Node Type• class Node {

private:int data; // different data type for other appsNode *next; // the link pointer to next item

public: Node(int x=0;Node * ptr=NULL); // constructor

int getData( );Node *getNext( );void setData(int x);void setNext(Node *ptr);

};

CSCI 2170 26

Class Node Implementation

• Node::Node(int x, Node *p){ data=x; next=p;};• int Node::getData( ){return data;};• Node * Node::getNext( ){return next;};• void Node::setData(int x) {data=x;};• void Node::setNext(Node *ptr){next=ptr;};

CSCI 2170 27

Implementation of Linked List

• A linked list is a collection of Node objects, and must support a number of operations

• Therefore, it is sensible to implement a linked list as a class

• The class name for it is List

CSCI 2170 28

Class Design for List• The member variables are:

– Node *head_ptr;

• Member functions– Node * search(int x); Node * itemAt(int position);

– void removeHead(); void removeTail();

void remove(int x);

– void insertHead(int x); void insertTail(int x);

void insert(Node *p, int x) // inserts item after the item // pointed to by p

– int size( ); Node *getHead( ); Node getTail( );

– bool isEmpty( );

CSCI 2170 29

Class List Type• class List {

private:Node *head_ptr;

public:

List( ); // constructorint size( ); Node *getHead( ); Node *getTail( );

bool isEmpty( );Node *search(int x); Node *itemAt(int position);

void removeHead(); void removeTail();

void remove(int x); // delete leftmost item having x

void insertHead(int x); void insertTail(int x); void insert(Node *p, int x);

};

CSCI 2170 30

Implementation of Class List• List::List( ){head_ptr= NULL};• int List::size( ){return numOfItems;};• Node * List::getHead( ) {return head_ptr;};• Node * List::getTail( ) {……..};• bool List::isEmpty() {return (!head_ptr);};

CSCI 2170 31

Implementation of search( )• Node *List::search(int x){

Node * currentPtr = getHead( );while (currentPtr != NULL){

if (currentPtr->getData( ) == x)return currentPtr;

else currentPtr = currentPtr->getNext();

} return NULL; // Now x is not, so return

NULL };

CSCI 2170 32

Implementation of itemAt( )• Node *List::itemAt(int position){

……………………

return currentPtr;

};

CSCI 2170 33

Implementation of removeHead( )

• void List::removeHead( ){

…..what if head is null…..???

Node * currentPtr = head_ptr( );

head_ptr=head_ptr->getNext( );

delete currentPtr;

};

CSCI 2170 34

Implementation of removeTail( )• void List::removeTail( ){……………….

};

CSCI 2170 35

Implementation of remove( )• void List::remove(int x){…………………

};

CSCI 2170 36

Implementation of insertHead( )

• void List::insertHead(int x){Node * newHead = new

Node(x,head_ptr);

head_ptr= newHead;

};

CSCI 2170 37

Implementation of insertTail( )

• void List::insertTail(int x){………………

};

CSCI 2170 38

Implementation of insert( )• // inserts item x after the item pointed to by

p

• void List::insert(Node *p, int x){

………………………..

};