1. Linked lists
CSCI 2170

2. Definitions ‘b’ ‘a’ ‘b’ ‘c’ ‘d’ NULL node
(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
data part
pointer part
(linked) list
‘a’
‘b’
‘c’
‘d’
NULL
head (node)
tail (node)
CSCI 2170

3. List manipulation ptr ptr ptr ptr ‘a’ ‘b’ ‘c’ ‘d’ NULL
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 on the 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
ptr
ptr
ptr
ptr
‘a’
‘b’
‘c’
‘d’
NULL
head (node)
tail (node)
pointer to head
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
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 8 2
head_ptr
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 f c
head_ptr
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 d f
head_ptr
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 A Insert a new data A. Call new: newPtr
List before insertion:
After insertion to head:
data
data
data
data
head_ptr A
data
head_ptr
The link value in the new item = old head_ptr
The new value of head_ptr = newPtr
CSCI 2170

15. Insert – at the Tail A Insert a new data A. Call new: newPtr
List before insertion
After insertion at end:
data
data
data
data
head_ptr
data A
head_ptr
The link value in the new item = NULL
The link value of the old last item = newPtr
CSCI 2170

16. Insert – inside the List
data
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
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
data
head_ptr
data
data
data
data
data
head_ptr
The new value of head_ptr = link-value of the old head item
The old head item is deleted and its memory returned
CSCI 2170

18. Delete – the Tail Item List before deletion:
List after deletion of the last item:
data
data
data
data
data
head_ptr
data
data
data
data
data
head_ptr
New value of link value of the next to last item
New link value of new last item = NULL.
CSCI 2170

19. Delete – an inside Item List before deletion:
List after deletion of the 2nd item:
data
data
data
data
data
head_ptr
data
data
data
data
data
head_ptr
New link-value of the item located before the deleted one =
the link-value of the deleted item
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 apps
Node *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: Member functions
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( ); // constructor
int 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){
……………………….. };
CSCI 2170