Linked Lists

1
Linked Lists

• CS-212
• Dick Steflik

2
Linked Lists

• A sequential collection of information
• Can be unordered i.e. in no specific order
• Can be ordered may be organized in ascending or
  descending order based on some specific piece of
  information called a key
• List header contains
• a link to the first node
• A link to the last node
• Other optional info (size)?
• List is made up of items called a node which
  contains
• The key
• Other pertinent information
• A field called a link that indicated the location
  of the next node

3
Unordered List
Head
Tail
Size
4
AddAtFront()? AddAtTail()? TakeFromFront()? TakeFr
omTail()?
4
Unordered Lists

• Stacks and Queues are special cases of unordered
  lists
• An unordered list where only AddAtFront and
  TakeFromFront are used is a stack
• An unordered list where only AddAtFront()
  andTakeFromRear() are used is a queue

5
Ordered List
Head
Tail
Size
4
9
7
2
5
Insert() Take() Delete() Find()
Key
Info
Link
6
Representations

• Static
• usually used on systems without dynamic
  allocation
• Array
• Array based list of static nodes
• Struct
• Dynamic
• Array
• Collection of dynamically allocated nodes
• use when you have no idea of how big or small the
  list will ultimately be

7
Static Array Based
int front, rear , cursor item listMAXSIZE
Problem a lot of data movement especialy on
inserts or add at front
Static Struct Based
typedef struct
int front, rear , cursor
item dataMAXSIZE
list Problem same as above
8
Array of Nodes
typedef struct
item v int
next node typedef
struct int
front , freelist , cursor
node dataMAXSIZE
list
9
lets say that an item is just an int so a node is
just a struct of two ints and the list is an
array where each element is two ints (it kinda
looks like a 2 dim array) , but we will treat it
as if it were two lists a list of unused nodes
and a list of nodes in use
next
to initialize the list(s) as empty, link all of
the nodes to gether set free to point at the
first free node and set front to -1 to indicate
that the list is empty. There are two lists a
list of free nodes that has all of the nodes and
a empty list that has no nodes
1
front
-1
2
free
0
3
4
cursor
5
6
7
-1
10
to insert a node
insert(7)
take the free pointer and put it in front take
the next pointer of the front node an put it in
free replace the next pointer of the front node
with -1 to indicate it is the end of the list put
the data (7) in the front node Now the list has
one node in it and the free list is one node
shorter
next
-1
7
front
0
2
free
1
3
4
cursor
5
6
7
-1
11
allocate
Lets call this process of moving a node from the
free list to the list allocate it should
always move the node at the front of the freelist
to wherever a new piece of data is to be added
(front, back or middle i.e. between two nodes).
Every insert should start off by allocating a
node, then inserting it into the list and finally
putting the data into it This is exactly like
using malloc to allocate dynamic node from the
system heap, malloc and free allow the OS to
manage the memory. In the absence of an OS
(embedded systems) you have to do this yourself
12
deallocate
This is the process of moving a node from the
list back to the free list and is functionally
the same as the free operation used to move
unneeded memory back to the system heap. In the
case of deleting a node from the list the process
consists of two steps find the node to be
deleted then deallocate it Note that deleting
a node will effect the next pointers of the node
preceding it and that the list will now be one
node shorter. The deallocated node should always
be added at the front of the free list making it
one node longer
13
Linked List Improvements

• Header Node
• if instead of using a variables for the front
  pointer we use a node that contains no
  information (dumy node) that just points to the
  first node
• then insertion into an empty list and insertion
  at the end of the list look the same and
  eliminate one of the 3 special cases (front,
  back and middle) that need to be checked for

14
cursor id-gtfront while (id-gtNodescursor.next
! NULL) cursor id-gtNodescursor.
next //insert after cursor t
allocate() id-gtNodest.next
NULL id-gtNodescursor.next t
cursor
dummy
front
cursor
dummy
front
See how the empty case and the end case look the
same
15
Another Improvement

• Make the list circular with a dummy header node
• If the dummy header node initially points at
  itself then the insertion of the first node looks
  like its between the front and back
• List is empty when front dummy.next

16
cursor
this again simplifies insertion and deletion as
the action is always taking place between two
nodes
dummy
front
cursor id-gtfront while (id-gtNodescursor.next
! NULL) cursor id-gtNodescursor.
next //insert after cursor t
allocate() id-gtNodest.next
NULL id-gtNodescursor.next t
cursor
dummy
front
17
Doubly Linked Lists

• each node has two pointers
• one to the predecessor
• one to the successor
• this simplifies insert and delete as you always
  have a pointer to the predecessor
• you dont have to drag an extra pointer behind
  the cursor to keep track where the predecessor is
• The cost of this is
• one additional pointer per node
• two additional assignment instructions

18
prev
next
// inserting t allocate(id) pv
id-gtNodescursor.prev id-gtNodespv.next
t id-gtNodescursor.prev t id-gtNodest.next
cursor id-gtNodest.prev pv //
deleting pv id-gtNodescursor.prev nx
id-gtNodescursor.next id-gtNodespv.next nx
id-gtNodesnx.prev pv deallocate(cursor)
cursor
t
cursor
19
DLL Improvements

• Make it circular
• eliminates special cases for empty list and
  adding at the end of list

20
Multilists

• if a list needs to be sorted by different key
  values for various reasons
• add an additional next pointer for each sorting
• insert then inserts a node into several list at
  the same time
• can get very complicated very quickly but can be
  very useful if you need data sorted multiple ways

21
Sparse Arrays

• Another use for linked lists is to represent
  sparse arrays
• needs two forward links per node
• one for row pointer
• one for column pointer

22
2 0 0 04 0 0 30 0 0 08 0 0 10 0 6 0
typedef enum head,entry tagfield typedef
struct matrixNode matrixPointer typedef struct
entryNode int row int col
int value typedef struct matrixNode
matrixPointer down
martixPointer right tagfield tag
union matrixPointer
next entryNode entry
u matrixPointer
hdnodeMAXSIZE