ICS 220

1
ICS 220 Data Structures and Algorithm Analysis

• Dr. Ken Cosh
• Week 3

2
Review

• Week 2
• Complexity Analysis
• Computational Asymptotic Analysis
• Big-O Notation
• Properties of Big-O
• Big O and Big T
• Amortized Analysis
• NP-Complete Problems

3
This Week

• Our First Data Structure
• Linked Lists
• Singly
• Doubly
• Circular
• Skip Lists
• Self Organising Lists
• Sparse Tables

4
Linked Lists

• We came across linked lists in Computer
  Programming II, this week we continue to look at
  linked lists.
• Why to use linked lists?
• How to use linked lists?
• Different Types of linked list.

5
Arrays

• But first, lets review arrays.
• A very useful structure provided by programming
  languages
• However, arrays have at least 2 limitations
• The size has to be known at compilation.
• The data in the array are separated in the
  computers memory by the same distance.
• These limitations make inserting an item inside
  the array difficult.

6
Linked Lists

• Linked Lists can be used to get around the
  limitations of arrays by linking data
  independently from where it is stored in the
  computers memory.
• To create a linked list, each piece of data in
  the set of data, simply has to also store the
  address of the next piece of data in the set.

7
A Simple Linked List
P
0
8
Singly Linked Lists

• The example on the previous page was an example
  of a singly linked list.
• A pointer (P) to the first element in the list
• Each element stores some data, and a pointer to
  the next element in the list
• The final element points towards NULL (0), to
  indicate it is the final element.
• The data stored in a linked list can be anything
  from a simple integer to a user defined class.

9
Node Code

• class Node
• public
• Node()
• next 0
• Node(int i, Node in0)
• info i next in
• int info
• Node next

• This basic node has an integer (info), and a
  pointer to the next node in the linked list.
• There are 2 constructors,
• One for creating an empty list, which points
  towards NULL
• One for creating a new node in a list, with info
  i, again pointing towards NULL

10
Creating a linked list of Node

• Node p new Node(1)
• Creates a pointer p pointing to a new dynamic
  object of Node type
• p-gtnext new Node(2)
• Creates the second node in the list.
• p-gtnext-gtnext new Node(3)
• Creates the third node in the list.

11
-gtnext

• We need a way to avoid needing excessive and
  error-prone use of
• -gtnext-gtnext-gtnext-gtnext-gtnext-gtnext-gtnext
• So we need to add some useful member functions,
  to perform tasks such as
• Insertion
• Deletion
• Searching

12
Insertion

• For a basic Linked list, we have two choices for
  insertion
• head_insert()
• tail_insert()
• Otherwise known as
• push_front()
• push_back()

13
head_insert
14
tail_insert

• To insert a node at the end (tail) of a list, we
  first need a pointer to the last node in the
  list.
• It is often a good idea to maintain 2 pointers,
  one to the head of a linked list, and one to the
  tail of a linked list.
• Using the tail pointer, the steps are similar to
  head_insert.

15
Deletion

• Deleting Nodes from a list is another important
  function.
• Deleting from the head of the list
• Deleting from the tail of the list
• Deleting from somewhere in the middle of the
  list.
• For each it is important not to lose the list
  i.e. maintain a pointer to the rest of the list
  when deleting the head node etc.
• Discuss how you would solve each function.

16
Considerations

• Will the code work in all of these cases?
• Attempting to delete a node from an empty list.
• Deleting the only node from a one node list.
• Attempting to delete a node which isnt in the
  list.

17
Searching

• Searching a singly linked list involves starting
  at the head and following the pointers through
  the list until either the node is found or the
  tail is reached.
• A temporary pointer is used, tmp, where at each
  step it is pointed to the following node,
  tmp-gtnext.

18
Doubly Linked Lists

• The delete from tail function highlighted a
  difficulty inherent in singly linked lists.
• In order to find the last element in a list, we
  have to scan through the entire list till we find
  the element pointing to NULL, we then have to
  delete this element, while tracking the previous
  element and pointing that to NULL.
• If we are dealing with a long list, or frequent
  tail_delete function calls, it may be useful to
  have a Doubly Linked List.

19
Doubly Linked List
Tail
Head
0
0
20
Doubly Linked Lists

• The two key changing functions for Doubly Linked
  are to add and delete from the tail of a doubly
  linked list.
• Work through each of these functions taking care
  not to lose the list.

21
Circular Linked Lists

• Another type of Linked List is a circular linked
  list
• Here the final node in the list points back to
  the first node.
• This can be useful for tracking things
  continually in sequence

22
Doubly Circular Linked Lists
Tail
Note that only one entry point (Tail) is required
23
Searching Inefficiency

• With the linked lists we have encountered so far,
  there is a certain searching inefficiency.
• If we want to find a particular node we have to
  start at a position and work through every node
  in the list until either we find the node we are
  looking for, or we reach the end of the list.
• Skip Lists were introduced to offer an
  alternative searching structure.

24
Skip Lists

• In a Skip List, each node can have a different
  number of pointers some may have 1, some have 2
  etc.
• Using different pointers we can skip different
  nodes in the list until we find the element we
  are searching for.

25
Skip List
Suppose we were to search the above Skip List for
the number 17. Starting at the top level, with
node 1 we reach node 27. Returning to the
next level, we go from node 1 to node 13 to
node 27. Next the third level from node 13
reaches node 19, and finally the fourth level is
nodes 13, 16, 19, so we can then tell that the
node is not in the list.
26
Skip Lists

• Skip Lists are efficient for searching, assuming
  they are configured correctly.
• However, there are difficulties when it comes to
  other functionality
• Adding or deleting a node from part way through a
  skip list would demand a redesign of the whole
  skip list to maintain efficiencies.

27
Arrays vs Linked Lists

• Linked Lists have the advantage over arrays as
  they allow dynamic allocation of the necessary
  amount of memory
• Memory can be added or deleted at any point in a
  linked list
• Arrays have advantages over linked lists firstly
  because they allow random access
• We can access the 10th element in an array
  quicker than the 10th element in a linked list.
• Arrays can also sometimes take up less memory
• Linked lists can take up more space to store all
  the necessary pointers
• Sometimes Arrays can waste memory if the array
  isnt full
• So how would you choose between an array and a
  linked list?

28
List Organisation

• Clearly a list which is better organised will be
  more efficient than a disorganised list.
• Therefore there are ways to reorder the linked
  list to maximise its efficiency.
• Items that are more likely to be searched for can
  be placed at the start of the linked list, so
  they will be found first.
• Options include
• Move-To-Front
• Transpose
• Count
• Ordering
• Amortised Cost Analysis can be used to predict
  which method should be used.

29
List Organisation Methods

• Move-To-Front
• Each time a node is searched for it is moved to
  the head of the list.
• Transpose
• Each time a node is searched, swap it with the
  previous node.
• Count
• Add a data element to each node, containing a
  count of the number of times it has been accessed
  then order the list by the count.
• Ordering
• Use a natural criteria for list ordering, such as
  alphabetic order.
• The first 3 methods aim to self organise the
  list, rearranging its order dynamically new
  additions are automatically tail_inserted.

30
ltlistgt

• The Standard Template Library contains a library
  called ltlistgt, which contains many of the
  functions we have discussed, and more.
• The contents of the library are introduced on
  page 111 of the course text.
• Take some time to familiarise yourselves with the
  list library.

31
Deque

• A Deque is a double ended Queue i.e. a list
  which allows access to both ends of the list, or
  a doubly linked list.
• The STL also contains a deque class, which
  extends the functionality of the ltlistgt library.
• The ltdequegt class excludes some functions from
  the list class, including the merge function.

32
Homework

• As a gentle reintroduction to programming
• Write a merge function, which takes as
  parameters pointers to the heads of two deques.
• The function should merge the two deques leaving
  the first list as a sorted version of both lists.
• There are several ways this can be done!
  Calculate big-O for your algorithm.