Dynamic Data Structures

Point to Derived Data Values

• So far, we saw examples where pointers pointed to targets that are simple or array variables

• Targets can be of arbitrary types

• It becomes interesting when targets are of derived types

• Suppose Cricketer is a derived data type. Then

Type(Cricketer), pointer:: cri_p

declares pointer variable cri_p that points to an instance of type Cricketer

Referring to cri_p

• A new instance of the structure Cricketer can be created using

– allocate(cri_p,stat=pt_stat)

• The fields can be referred as usual:

– cri_p%name, cri_p%country

• As before, if it appears on the lhs then the field is updated

– cri_p%name = "Tendulkar“

• If it appears on ths rhs, value stored in the field is referred

– cntry = cri_p%country

Pointers can be components

• One of the components can be of pointer type!

• This pointer can point to an object of the same type or a different type

Example:

type:: list

integer:: info

type(list), pointer:: next

end

• The component info contains some integer value

• The second component is a pointer to a similar structure

• using this structure, we can build dynamic data structures

• Lists or Linked lists

Lists

Building Linked lists

• Given a set of N values build a linked list that store these N items

• This list can later be accessed for extracting the stored items

• Compare and contrast this with arrays

• The size of the list need not be known a priori

• The list can grow or shrink dynamically

• Efficient Utilization of Space

• Accessing an item requires some amount of effort

Program Build_list

Type:: list
integer:: info
type(list), pointer:: next
end type

type(list), pointer:: head, current, prev
integer:: value, N
integer:: l_stat, i

read *, N
nullify(head)
if (N > 0) then
allocate(head, stat=l_stat)
read *, value
head%info = value
prev => head
do i = 2, N
allocate(current, stat=l_stat)
prev%next => current
read *, value
current%info = value
prev => current
end do
nullify(prev%next)
endif

Printing the values in the list

subroutine print_list(head)

implicit none

type(list), pointer:: head

type(list), pointer:: current

current => head
do
if (.not. (associated(current))) exit
print *, current%info
current => current%next
end do

end subroutine

Pointers in subprograms

• Actual pointer argument should match the type, kind and rank of the dummy argument

• Pointer dummy argument can not have INTENT attribute

• Procedures with pointer or target dummy arguments must have an explicit interface

• Declare a module in which include the type declaration and all the procedures

• More on this later

Accessing an element in the list

subroutine find(head, val)

type(list), pointer:: head
integer:: val, i
type(list), pointer:: current

current => head
i = 1
do
if (.not. (associated(current))) then
print *, "item not found"
elseif (current%info == val) then
print *, val, " found at ", i
else
current => current%next
i = i + 1
endif
end do

end subroutine

Inserting an element

subroutine insert_next(p, val)

type(list), pointer:: p
integer:: val, i, istat
type(list), pointer:: temp

allocate(temp, stat = istat)
temp%info = val
temp%next => p%next
p%next => temp

end subroutine

Deleting an element

subroutine delete(p, head)

type(list), pointer:: p, head, current, prev

current => head
do
if (.not. associated(p)) exit
if (.not. associated(current)) exit
if (.not. associated(current, p)) then
prev => current
current => current%next
else
if (associated(current, head)) then
head => head%next
else
prev%next => current%next
endif
exit
endif

end do

end subroutine

Other Dynamic Data Structures

Doubly Linked lists

– Forward and Backward Traversal possible

Stacks

– Insertion and Deletion from one end

Queues

– Insertion from front end and deletion from the back

Trees

– Root, Leaf and Intermediate nodes

Graphs