Structure and list processing

1
Structure and list processing

• Lecture 18
• 26.3.2001.

2
Dynamic allocation review

• Variables in C are allocated in one of 3 spots
• the run-time stack variables declared local to
  functions are allocated during execution
• the global data section Global variables are
  allocated here and are accessible by all parts of
  a program.
• the heap Dynamically allocated data items
• malloc, calloc, realloc manage the heap region of
  the mmory. If the allocation is not successful a
  NULL value is returned.

3
Bad Pointers

• When a pointer is first allocated, it does not
  have a pointee.
• The pointer is uninitialized or bad.
• A dereference operation on a bad pointer is a
  serious runtime error.
• Each pointer must be assigned a pointee before it
  can support dereference operations.
• int numPtr
• Every pointer starts out with a bad value.
  Correct code overwrites the bad value.

4
Example pointer code.

• int numPtr
• int num 42
• numPtr num
• numPtr 73
• numPtr malloc (sizeof (int))
• numPtr 73

5

• int a1, b2, c3
• int p, q

a
1
p
xxx
b
2
q
xxx
c
3
6

• p a
• q b

a
1
p
b
2
q
c
3
7

• c p
• p q
• p 13

a
1
p
b
13
q
c
1
8
Bad pointer Example

• void BadPointer ()
• int p
• p 42
• int Bad2 ()
• int num, p
• num 42
• p num
• return p

p
x x x
X
9

• A function call malloc(size) allocates a block of
  mrmory in the heap and returns a pointer to the
  new block. size is the integer size of the block
  in bytes. Heap memory is not deallocated when the
  creating function exits.
• malloc generates a generic pointer to a generic
  data item (void ) or NULL if it cannot fulfill
  the request.
• Type cast the pointer returned by malloc to the
  type of variable we are assigning it to.
• free takes as its parameter a pointer to an
  allocated region and de-allocates memory space.

10
Dynamic memory allocation review

• typedef struct
• int hiTemp
• int loTemp
• double precip
• WeatherData
• main ()
• int numdays
• WeatherData days
• scanf (d, numdays)
• days(WeatherData )malloc (sizeof(WeatherData)n
  umdays)
• if (days NULL) printf (Insufficient
  memory)
• ...
• free (days)

11
Self-referential structures

• Dynamic data structures Structures with pointer
  members that refer to the same structure.
• Arrays and other simple variables are allocated
  at block entry.
• But dynamic data structures require storage
  management routine to explicitly obtain and
  release memory.

12
Self-referential structures

• struct list
• int data
• struct list next

The pointer variable next is called a link. Each
structure is linked to a succeeding structure by
next.
13
Pictorial representation
A structure of type struct list
data
next

• The pointer variable next contains either
• an address of the location in memory of the
• successor list element
• or the special value NULL defined as 0.
• NULL is used to denote the end of the list.

14
struct list a, b, c a.data 1 b.data
2 c.data 3 a.next b.next c.next NULL
a
b
c
1
NULL
2
NULL
3
NULL
data
next
data
next
data
next
15
Chaining these together
a.next b b.next c
a
b
c
1
2
3
NULL
data
next
data
next
data
next

• What are the values of
• a.next-gtdata
• a.next-gtnext-gtdata

2 3
16
Linear Linked Lists

• A head pointer addresses the first element of the
  list.
• Each element points at a successor element.
• The last element has a link value NULL.

17
Header file list.h

• include ltstdio.hgt
• include ltstdlib.hgt
• typedef char DATA
• struct list
• DATA d
• struct list next
• typedef struct list ELEMENT
• typedef ELEMENT LINK

18
Storage allocation

• LINK head
• head malloc (sizeof(ELEMENT))
• head-gtd n
• head-gtnext NULL

creates a single element list.
n
NULL
head
19
Storage allocation

• head-gtnext malloc (sizeof(ELEMENT))
• head-gtnext-gtd e
• head-gtnext-gtnext NULL

A second element is added.
n
head
e
NULL
20
Storage allocation

• head-gtnextgtnext malloc (sizeof(ELEMENT))
• head-gtnext-gtnext-gtd e
• head-gtnext-gtnext-gt NULL

We have a 3 element list pointed to by head. The
list ends when next has the sentinel value NULL.
n
head
e
w
NULL
21
List operations

• Create a list
• Count the elements
• Look up an element
• Concatenate two lists
• Insert an element
• Delete an element

22
Produce a list from a string (recursive
version)

• include list.h
• LINK StrToList (char s)
• LINK head
• if (s0 \0)
• return NULL
• else
• head malloc (sizeof(ELEMENT))
• head-gtd s0
• head-gtnext StrToList (s1)
• return head

23
list from a string (iterative version)

• include list.h
• LINK SToL (char s)
• LINK head NULL, tail
• int i
• if (s0 ! \0)
• head malloc (sizeof(ELEMENT))
• head-gtd s0
• tail head
• for (i1 si ! \0 i)
• tail-gtnext malloc(sizeof(ELEMENT))
• tail tail-gtnext
• tail-gtd si
• tail-gtnext NULL
• return head

24
1. A one-element list
head
4. after assigning NULL
?
A
head
tail
A
NULL
B
2. A second element is attached
head
tail
A
?
?
tail
3. Updating the tail
head
A
?
B
tail
25
/ Count a list recursively /

• int count (LINK head)
• if (head NULL)
• return 0
• return 1count(head-gtnext)

/ Count a list iteratively /
int count (LINK head) int cnt 0 for (
head ! NULL headhead-gtnext)
cnt return cnt
26
/ Print a List /

• void PrintList (LINK head)
• if (head NULL)
• printf (NULL)
• else
• printf (c --gt , head-gtd)
• PrintList (head-gtnext)

27
/ Concatenate two Lists /

• void concatenate (LINK ahead, LINK bhead)
• if (ahead-gtnext NULL)
• ahead-gtnext bhead
• else
• concatenate (ahead-gtnext, bhead)

28
Insertion

• Insertion in a list takes a fixed amount of time
  once the position in the list is found.

Before Insertion
p2
p1
C
A
q
B
29
Insertion

• / Inserting an element in a linked list. /
• void insert (LINK p1, LINK p2, LINK q)
• p1-gtnext q
• q-gtnext p2

After Insertion
p2
p1
C
A
q
B
30
Deletion

• Before deletion

p
1
2
3
p-gtnext p-gtnext-gtnext
garbage
p
After deletion
1
2
3
31
Deletion

• Before deletion

p
1
2
3
q p-gtnext p-gtnext p-gtnext-gtnext
p
After deletion
1
2
3
q
free (q)
32
Delete a list and free memory

• / Recursive deletion of a list /
• void delete_list (LINK head)
• if (head ! NULL)
• delete_list (head-gtnext)
• free (head) / Release storage /