Linked Lists

1
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.

2
Definition of Linked Lists

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

3
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 self-loop

4
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

tail_ptr
head_ptr
5
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

tail_ptr
head_ptr
6
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

tail_ptr
head_ptr
7
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

tail_ptr
head_ptr
8
Examples of Linked Lists(A Polynomial)

• A polynomial of degree n is the function
  Pn(x)a0a1xa2x2anxn. The ais are called the
  coefficients of the polynomial
• The polynomial can be represented by a linked
  list (2 data members and a link per item)

9
Operations on Linked Lists

• Insert a new item
• At the head of the list, or
• At the tail 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( )

10
Insert At the Head

• Insert a new data A. Call new newPtr
• List before insertion
• After insertion to head

head_ptr
tail_ptr
tail_ptr
head_ptr

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

11
Insert at the Tail

• Insert a new data A. Call new newPtr
• List before insertion
• After insertion to tail

head_ptr
tail_ptr
tail_ptr
head_ptr

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

12
Insert inside the List

• Insert a new data A. Call new newPtr
• List before insertion
• After insertion in 3rd position

head_ptr
tail_ptr
tail_ptr
head_ptr

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

13
Delete the Head Item

• List before deletion
• List after deletion of the head item

tail_ptr
head_ptr
head_ptr
tail_ptr

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

14
Delete the Tail Item

• List before deletion
• List after deletion of the tail item

tail_ptr
head_ptr
tail_ptr
head_ptr

• New value of tail_ptr link-value of the 3rd
  from last item
• New link-value of new last item NULL.

15
Delete an inside Item

• List before deletion
• List after deletion of the 2nd item

tail_ptr
head_ptr
tail_ptr
head_ptr

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

16
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.

17
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.

18
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)

19
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

20
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
21
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 x0Node ptrNULL) // constructor
• int getData( )
• Node getNext( )
• void setData(int x)
• void setNext(Node ptr)

22
Class Node Implementation

• NodeNode(int x, Node p) datax nextp
• int NodegetData( )return data
• Node NodegetNext( )return next
• void NodesetData(int x) datax
• void NodesetNext(Node ptr)nextptr

23
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

24
Class Design for List

• The member variables are
• Node head_ptr Node tail_ptr
• int numOfItems
• 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( )

25
Class List Type

• class List
• private
• Node head_ptr Node tail_ptr int numOfItems
• 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)

26
Implementation of Class List

• ListList( )head_ptr NULL tail_ptrNULL
  numOfItems0
• int Listsize( )return numOfItems
• Node ListgetHead( ) return head_ptr
• Node ListgetTail( ) return tail_ptr
• bool ListisEmpty() return (numOfItem0)

27
Implementation of search( )

• Node Listsearch(int x)
• Node currentPtr getHead( )
• while (currentPtr ! NULL)
• if (currentPtr-gtgetData( ) x)
• return currentPtr
• else
• currentPtr currentPtr-gtgetNext()
• return NULL // Now x is not, so return NULL

28
Implementation of itemAt( )

• Node ListitemAt(int position)
• if (positionlt0 positiongtnumOfItems)
• return NULL
• Node currentPtr getHead( )
• for(int k0k ! position k)
• currentPtr currentPtr -gt getNext( )
• return currentPtr

29
Implementation of removeHead( )

• void ListremoveHead( )
• if (numOfItems 0)
• return
• Node currentPtr getHead( )
• head_ptrhead_ptr-gtgetNext( )
• delete currentPtr
• numOfItems--

30
Implementation of removeTail( )

• void ListremoveTail( )
• if (numOfItems 0)
• return
• if (head_ptr tail_ptr)
• head_ptrNULL tail_ptr NULL
• numOfItems0 return
• Node beforeLast itemAt(numOfItems-2)
• beforeLast-gtsetNext(NULL) // beforeLast
  becomes last
• delete tail_ptr // deletes the last object
• tail_ptrbeforeLast
• numOfItems--

31
Implementation of remove( )

• void Listremove(int x)
• if (numOfItems 0) return
• if (head_ptrtail_ptr head_ptr-gtgetData()x
  )
• head_ptrNULL tail_ptr NULL
  numOfItems0 return
• Node beforePtrhead_ptr // beforePtr trails
  currentPtr
• Node currentPtrhead_ptr-gtgetNext()
• Node tail getTail()
• while (currentPtr ! tail)
• if (currentPtr-gtgetData( ) x) // x is
  found. Do the bypass
• beforePtr-gtsetNext(currentPtr-gtgetNe
  xt())
• delete currentPtr
  numOfItems--
• else // x is not found yet. Forward
  beforePtr currentPtr.
• beforePtr currentPtr
• currentPtr currentPtr-gtgetNext()
  

32
Implementation of insertHead( )

• void ListinsertHead(int x)
• Node newHead new Node(x,head_ptr)
• head_ptr newHead
• if (tail_ptr NULL) // only one item in list
• tail_ptr head_ptr
• numOfItems

33
Implementation of insertTail( )

• void ListinsertTail(int x)
• if (isEmpty())
• insertHead(x)
• else
• Node newTail new Node(x)
• tail_ptr-gtsetNext(newTail)
• tail_ptr newTail numOfItems

34
Implementation of insert( )

• // inserts item x after the item pointed to by
  p
• void Listinsert(Node p, int x)
• Node currentPtr head_ptr
• while(currentPtr !NULL currentPtr ! p)
• currentPtr currentPtr-gtgetNext()
• if (currentPtr ! NULL ) // p is found
• Node newNdnew Node(x,p-gtgetNext())
• p-gtsetNext(newNd)
• numOfItems

35
For your Work in the Lab

• Make the necessary modifications to the List
  class implementations so that no two Nodes have
  the same data value. This is useful when using
  linked lists to implement sets.
• Make the necessary changes to the List class so
  that the Nodes are in increasing order of data
  values. In particular, replace all the insert
  methods, and replace them with insert(int x),
  which inserts x in the right position so that the
  List remains sorted.