Dynamic Allocation Review Structure and list processing - PowerPoint PPT Presentation

About This Presentation
Title:

Dynamic Allocation Review Structure and list processing

Description:

Concatenate two lists. Insert an element. Delete an element. 26-27.3.2001. ... concatenate (ahead- next, bhead); 26-27.3.2001. Sudeshna Sarkar, CSE, IIT Kharagpur ... – PowerPoint PPT presentation

Number of Views:75
Avg rating:3.0/5.0
Slides: 44
Provided by: roychow
Category:

less

Transcript and Presenter's Notes

Title: 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
Write a Comment
User Comments (0)
About PowerShow.com