Dynamic Allocation Review Structure and list processing

1
Dynamic Allocation ReviewStructure and list
processing

• Lectures 18 19
• 26.3.2001. and 27.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
• num malloc (sizeof (int))
• num 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
Why linked lists ?

• A linked list is a dynamic data structure.
• It can grow or shrink in size during the
  execution of a program.
• It can be made just as long as required.
• It does not waste memory space.
• Linked lists provide flexibility in allowing the
  items to be rearranged efficiently.
• Insert an element.
• Delete an element.

13
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.
14
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.

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

18
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

19
Storage allocation

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

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

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

A second element is added.
n
head
e
NULL
21
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
22
List operations

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

23
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

24
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

25
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
26
/ Count a list recursively /

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

27
/ Count a list iteratively /
int count (LINK head) int cnt 0 for (
head ! NULL headhead-gtnext)
cnt return cnt
void LengthTest (char a) int len LINK
list list StrToList (a) int len count
(list)
28
Stack
Heap
LengthTest()
a
list
n
e
w
NULL
len
98790
count ()
cnt
0
head
29
Stack
Heap
LengthTest()
a
list
n
e
w
NULL
len
98790
count ()
cnt
1
head
30
Stack
Heap
LengthTest()
a
list
n
e
w
NULL
len
98790
count ()
cnt
2
head
31
Stack
Heap
LengthTest()
a
list
n
e
w
NULL
len
98790
count ()
cnt
3
head
32
/ Print a List /

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

33
/ Concatenate two Lists /

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

34
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
35
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
36
Deletion

• Before deletion

p
1
2
3
p-gtnext p-gtnext-gtnext
garbage
p
After deletion
1
2
3
37
Deletion (free memory)

• Before deletion

p
1
2
3
q p-gtnext p-gtnext p-gtnext-gtnext
p
After deletion
1
2
3
q
free (q)
38
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 /

39
Insert an element into a sorted list

• LIST insert ( LIST head, LIST newnode)
• LIST cur
• if ((head NULL) (newnode-gtd lt head-gtd))
  
• newnode-gtnext head
• return newnode
• cur head
• while ((cur-gtnext ! NULL) (cur-gtnext-gtd lt
  newnode-gtd)) cur cur-gtnext
• newnode-gtnext cur-gtnext
• cur-gtnext newnode
• return head

40
InsertSort()

• LINK InsertSort (LINK head)
• LINK result NULL
• LINK cur head
• LINK next
• while (cur ! NULL)
• next cur-gtnext
• result insert (result, cur)
• cur next
• return result

41
Delete an element from a sorted list

• LIST delete ( LIST head, DATA d)
• LIST prev, temp, curr head
• while ((curr ! NULL) (curr-gtd lt d))
• prev curr
• curr curr-gtnext
• if (curr-gtd d)
• temp curr
• prev-gtnext curr-gtnext
• free (temp)
• return head

42
AssignmentReverse a list
head
1
2
3
4
head
1
2
3
4
43
Doubly linked list
A
B
C
Assignment Insertion, deletion in a
doubly linked list