Scribd
Upload
127 views23 pages

MIT6 087IAP10 Lec08

The document summarizes pointers, stacks, queues, expressions, hash tables, and function pointers in C. It discusses void pointers, callbacks, and implementing a hash table using an array of linked lists with chaining. Function pointers allow functions to be passed as arguments to other functions like callbacks. Hash tables provide efficient data structures by mapping keys to values using hash functions to minimize collisions.

Uploaded by

Santosh Kumar
Copyright
© Attribution Non-Commercial (BY-NC)
We take content rights seriously. If you suspect this is your content, claim it here.
Available Formats
Download as PDF, TXT or read online on Scribd
127 views23 pages

MIT6 087IAP10 Lec08

The document summarizes pointers, stacks, queues, expressions, hash tables, and function pointers in C. It discusses void pointers, callbacks, and implementing a hash table using an array of linked lists with chaining. Function pointers allow functions to be passed as arguments to other functions like callbacks. Hash tables provide efficient data structures by mapping keys to values using hash functions to minimize collisions.

Uploaded by

Santosh Kumar
Copyright
© Attribution Non-Commercial (BY-NC)
We take content rights seriously. If you suspect this is your content, claim it here.
Available Formats
Download as PDF, TXT or read online on Scribd
You are on page 1/ 23

6.

087 Lecture 8 – January 21, 2010

Review

Pointers
Void pointers
Function pointers

Hash table

1
Review:Pointers

• pointers: int x; int∗ p=&x;


• pointers to pointer: int x; int∗ p=&x;int∗∗ pp=&p;
• Array of pointers: char∗ names[]={"abba","u2"};
• Multidimensional arrays: int x [20][20];

1
Review: Stacks

• LIFO: last in first out data structure.


•
items are inserted and removed from the same end.
• operations: push(),pop(),top()

• can be implemented using arrays, linked list

2
Review: Queues

• FIFO: first in first out


•
items are inserted at the rear and removed from the front.
• operations: queue(),dequeue()

• can be implemented using arrays, linked list

3
Review: Expressions

• Infix: (A+B)*(C-D)
• prefix: *+AB-CD
• postfix: AB+CD-*

4
6.087 Lecture 8 – January 21, 2010

Review

Pointers
Void pointers
Function pointers

Hash table

5
Void pointers

• C does not allow us to declare and use void variables.


• void can be used only as return type or parameter of a
function.
• C allows void pointers
• Question: What are some scenarios where you want to
pass void pointers?
• void pointers can be used to point to any data type
• int x; void∗ p=&x; /∗points to int ∗/
• float f ;void∗ p=&f; /∗points to float ∗/
• void pointers cannot be dereferenced. The pointers should
always be cast before dereferencing.
void∗ p; printf ("%d",∗p); /∗ invalid ∗/
void∗ p; int ∗px=(int∗)p; printf ("%d",∗px); /∗valid ∗/

5
Function pointers

• In some programming languages, functions are first class


variables (can be passed to functions, returned from
functions etc.).
• In C, function itself is not a variable. But it is possible to
declare pointer to functions.
• Question: What are some scenarios where you want to
pass pointers to functions?
• Declaration examples:
• int (∗fp )( int ) /∗notice the () ∗/
• int (∗fp )( void∗,void∗)
• Function pointers can be assigned, pass to and from
functions, placed in arrays etc.

6
Callbacks

Definition: Callback is a piece of executable code passed to

functions. In C, callbacks are implemented by passing function

pointers.

Example:

void qsort(void∗ arr, int num,int size, int (∗fp )( void∗ pa,void∗pb))

• qsort() function from the standard library can be sort an


array of any datatype.
• Question: How does it do that? callbacks.
• qsort() calls a function whenever a comparison needs to
be done.
• The function takes two arguments and returns (<0,0,>0)
depending on the relative order of the two items.

7
Callback (cont.)

int arr []={10 ,9 ,8 ,1 ,2 ,3 ,5};


/∗ callback ∗/
i n t asc ( void ∗ pa , void ∗ pb )
{
r e t u r n ( ∗ ( i n t ∗ ) pa − ∗ ( i n t ∗ ) pb ) ;
}
/∗ callback ∗/
i n t desc ( void ∗ pa , void ∗ pb )
{
r e t u r n ( ∗ ( i n t ∗ ) pb − ∗ ( i n t ∗ ) pa ) ;
}
/ ∗ s o r t i n ascending o r d e r ∗ /
q s o r t ( a r r , s i z e o f ( a r r ) / s i z e o f ( i n t ) , s i z e o f ( i n t ) , asc ) ;
/ ∗ s o r t i n descending o r d e r ∗ /
q s o r t ( a r r , s i z e o f ( a r r ) / s i z e o f ( i n t ) , s i z e o f ( i n t ) , desc ) ;

8
Callback (cont.)

Consider a linked list with nodes defined as follows:


s t r u c t node {
i n t data ;
s t r u c t node∗ n e x t ;
};
Also consider the function ’apply’ defined as follows:
void a p p l y ( s t r u c t node∗ phead ,
void ( ∗ f p ) ( void ∗ , void ∗ ) ,
void ∗ arg ) / ∗ o n l y f p has t o be named ∗ /
{
s t r u c t node∗ p=phead ;
while ( p ! =NULL )
{
f p ( p , arg ) ; / ∗ can a l s o use ( ∗ f p ) ( p , arg ) ∗ /
p=p−>n e x t ;
}
}
9
Callback (cont.)

Iterating:
s t r u c t node∗ phead ;
/ ∗ p o p u l a t e somewhere ∗ /
void p r i n t ( void ∗ p , void ∗ arg )
{
s t r u c t node∗ np =( s t r u c t node ∗ ) p ;
p r i n t f ( "%d " , np−>data ) ;
}
a p p l y ( phead , p r i n t , NULL ) ;

10
Callback (cont.)
Counting nodes:

void d o t o t a l ( void ∗ p , void ∗ arg )


{
s t r u c t node∗ np =( s t r u c t node ∗ ) p ;
int ∗ ptotal =( i n t ∗ ) arg ;
∗ p t o t a l += np−>data ;
}
i n t t o t a l =0;
a p p l y ( phead , d o t o t a l ,& t o t a l ) ;

11
Array of function pointers

Example:Consider the case where different functions are called


based on a value.
enum TYPE{SQUARE, RECT, CIRCILE ,POLYGON } ;
s t r u c t shape {
f l o a t params [MAX ] ;
enum TYPE t y p e ;
} ;

void draw ( s t r u c t shape∗ ps )

switch ( ps−>t y p e )
{
case SQUARE:
draw_square ( ps ) ; break ;
case RECT:
d r a w _ r e c t ( ps ) ; break ;
...
}
}
12
Array of function pointers

The same can be done using an array of function pointers


instead.
void ( ∗ f p [ 4 ] ) ( s t r u c t shape∗ ps )=

{& draw_square ,& draw_rec ,& d r a w _ c i r c l e ,& draw_poly } ;

typedef void ( ∗ f p ) ( s t r u c t shape∗ ps ) drawfn ;

drawfn f p [ 4 ] =

{& draw_square ,& draw_rec ,& d r a w _ c i r c l e ,& draw_poly } ;

void draw ( s t r u c t shape∗ ps )

( ∗ f p [ ps−>t y p e ] ) ( ps ) ; / ∗ c a l l t h e c o r r e c t f u n c t i o n ∗ /
}

13
6.087 Lecture 8 – January 21, 2010

Review

Pointers
Void pointers
Function pointers

Hash table

14
Hash table

Hash tables (hashmaps) combine linked list and arrays to


provide an efficient data structure for storing dynamic data.
Hash tables are commonly implemented as an array of linked
lists (hash tables with chaining).

keys buckets entries


000
Lisa Smith 521-8976
001
John Smith
002
: : John Smith 521-1234
Lisa Smith
151
152
Sam Doe Sandra Dee 521-9655
153
154
Sandra Dee
: : Ted Baker 418-4165
253
Ted Baker
254
Sam Doe 521-5030
255

Figure: Example of a hash table with chaining (source: wikipedia)

14
Hash table

• Each data item is associated with a key that determines its


location.
• Hash functions are used to generate an evenly distributed
hash value.

• A hash collision is said to occur when two items have the

same hash value.


• Items with the same hash keys are chained
• Retrieving an item is O(1) operation.

15
Hash tables

Hash functions:
• A hash function maps its input into a finite range: hash
value, hash code.
• The hash value should ideally have uniform distribution.
why?
• Other uses of hash functions: cryptography, caches
(computers/internet), bloom filters etc.
• Hash function types:
• Division type
• Multiplication type
• Other ways to avoid collision: linear probing, double
hashing.

16
Hash table: example

# define MAX_BUCKETS 1000


# define MULTIPLIER 31
s t r u c t wordrec
{
char ∗ word ;

unsigned long count ;

s t r u c t wordrec ∗ n e x t ;

};

/ ∗ hash bucket ∗ /
s t r u c t wordrec ∗ t a b l e [ MAX_LEN ] ;

17
Hash table: example

unsigned long h a s h s t r i n g ( const char ∗ s t r )


{
unsigned long hash =0;
while ( ∗ s t r )
{
hash= hash∗MULTIPLIER+∗ s t r ;
s t r ++;
}
r e t u r n hash%MAX_BUCKETS;
}

18
Hash table: example

s t r u c t wordrec ∗ lookup ( const char ∗ s t r , i n t c r e a t e )


{
s t r u c t wordrec ∗ c u r r =NULL ;
unsigned long hash= h a s h s t r i n g ( s t r ) ;
s t r u c t wordrec ∗ wp= t a b l e [ hash ] ;
f o r ( c u r r =wp ; c u r r ! =NULL ; c u r r = c u r r −>n e x t )
/ ∗ search ∗ / ;
notfound :
i f ( create )
/ ∗ add t o f r o n t ∗ /
return c u r r ;
}

19
MIT OpenCourseWare
http://ocw.mit.edu

6.087 Practical Programming in C


January (IAP) 2010

For information about citing these materials or our Terms of Use,visit: http://ocw.mit.edu/terms.

You might also like