Notes Data-Structure

INDEX
Sr. No Topic Name Page no 1 Intro. Data Structures & Classification 2 2 Search
ing 3 3 Sorting 5 4 Runtime memory management 9 5 Linked List 11 6 Stacks 31
7 Infix, Postfix and Prefix notations 39 8 Queues 42 9 Priority Queues 46 1
0 Circular Queues 48 11 Hashing 50 12 Trees & Binary Trees 56 13 Tree Sort &
Heap Sort 67 14 Graphs 69
What is Data Structure?
Data structure is collection of data elements organized in specified manner and
accessing functions are defined to store and retrieve individual data elements.
Data structures are sometimes called as data types.
What is Abstract Data type?
In abstract data type we recognize relationship among data elements and function
s but we do not decide how data will actually be stored in memory or how the fun
ctions or operations will be implemented. Example of the abstract data type is Cl
ass in oops.
Classification of Data Structure: -
A data type may be defined as a set and the elements of the set are called the v
alues of the type. There are four basic or atomic or primitive data types in C.
these are int, float, char and double. Other data structures can be built from o
ne or more primitive data structure. The simple data types built from primitives
are arrays, pointers, strings and records with which we can build new types cal
led structured or composite types such as stacks, queues, trees etc. these struc
tured data types can be categorized as linear and non-linear. The linear data st
ructures are stacks , queues and linked lists . The non-linear data structures are tre
nd graphs .
Searching
Information retrieval is one of the most important application of the computers.
A number of search techniques for searching large amount of data to retrieve a
particular piece of information. There are some simple techniques like linear se
arch and binary search for searching information from a table or file.
Linear search Sequential search Simple search
The simplest search technique is the sequential search. In this technique we sta
rt at a beginning of a list or a table and search for the desired record by exam
ining each subsequent record until either the desired record is found or the lis
t is finished. The technique is suitable for a table organized either as an arra
y or as a linked list. It can be applied to an unordered table but the efficienc
y of the search may be improved if the list is ordered.
Program on Linear search
void main()
{
int num[8]={300,4,12,6,8,50,25,500};
int data,i,f=0;
clrscr();
for(i=0;i<8;i++)
printf("%d\t",num[i]);
printf("\nEnter data to search = ");

scanf("%d",&data);
for(i=0;i<8;i++)
{
if(data == num[i])
{
printf("\nElement found at %d position",i+1);
f=1;
break;
}
}
if(f==0)
printf("\nElement not exist");
getch();
}
Binary Search
Sequential search is a simple and easy method. It is efficient for small lists b
ut highly inefficient for larger lists. In the worst case, we will have to make
N comparisons as to search for the last records in the list we examine each reco
rd preceding it once. It is just like to find a one name into the whole telephon
e directory from first number to last.
This method is called as binary search because at each step, we reduce the lengt
h of the table to be searched by half and the table is divided into two equal pa
rts.
Algorithm for binary search
First find out the middle element from the list as mid = low + high / 2
If the middle element contents a target key (find element) then stop the search
and print the position
If the middle element is larger than target then search first half list that is
from low to mid 1 otherwise search second half of the list that is from mid + 1
to high.
Continue the step third till the target is not found and low is not greater than
high. If low is greater then high then stop the search and print message element
not found .
Program on Binary search
void main()
{
int num[10]={10,20,30,40,50,60,70,80,90,100};
int low,high,target,mid,f=0,i;
clrscr();
printf("\nData in table \n");
for(i=0;i<10;i++)
printf("\nEnter data to find := ");
scanf("%d",&target);
low=0; high=9;
while(low<=high)
{
mid = (low+high)/2;
if(num[mid]==target)
{
printf("\nElement found at %d position",mid+1);
f=1;
break;
}
else
{
if(num[mid] > target)
high = mid - 1;
else
low = mid + 1;
}
}
if(f==0)
printf("\nElement does not exist");
getch();
}
Sorting
Sorting is very important operation performed most commonly on large storage of
information. Sorting is the operation of arranging the records of a table accord
ing to the key value of each record.
Selection Sort: -
Selection sort is a method of sorting a table. We perform a search through the t
able, staring from the first record, to locate the element with the smallest key
. When this record is found, we interchange it with the first record in the tabl
e. As a result of this interchange, the smallest key is placed in the first posi
tion of the table. In the second interaction we locate second smallest key exami
ning the keys of the records starting from the second record onwards. We then in
terchange this record with the second record in the table. We continue this proc
ess of searching for the record with the smallest key in the unsorted portion of
the table and placing it in its property place until we have placed all the rec
ords in the proper order.
Program on selection sort :-
void main()
{
int num[8]={7,10,8,3,95,45,28,5};
int i,j,t,minpos;
clrscr();
printf("\nArray before sort\n");
for(i=0;i<8;i++)
for(i=0;i<8;i++)
{
minpos = i;
for(j=i+1;j<8;j++)
{
if(num[j] < num[minpos])
minpos = j;
}
if(i!=minpos)
{
t=num[i];
num[i]=num[minpos];
num[minpos]=t;
}
}
printf("\nArray After sort\n");
for(i=0;i<8;i++)
getch();
}
Bubble sort
The basic idea underlying the bubble sort is to pass through the table sequentia
lly several times. Each pass puts the largest unsorted element in its correct pl
ace by comparing each element in the table with its next and interchanging the t
wo elements if they are not in proper order. The first pass puts the largest ele
ment of the table in the n 1th position. The next pass puts the largest element
in the unsorted part of the table. This way each element slowly bubbles up to its
proper place; this is why the method is called as bubble sort.
Program on bubble sort: -
void main()
{
int p[8]={20,10,50,30,80,40,90,60};
int i,j,k,t,c;
clrscr();
printf("\nArray before sort\n");
for(i=0;i<8;i++)
printf("%d\t",p[i]);
for(i=0;i<8;i++)
{
c=0;
for(j=0,k=j+1;k<8;j++,k++)
{
if(p[j] > p[k])
{
c++;
t=p[j];
p[j]=p[k];
p[k]=t;
}
}
if(c==0)
break;
}
printf("\nArray after sort\n");
for(i=0;i<8;i++)
printf("%d\t",p[i]);
getch();
}
Merge sort:-
Merging is the process of combining two or more sorted files into a third sorted
file. We can use the technique of merging to sort a file. Let us write a routin
e that accepts two sorted arrays x and y containing elements n1 and n2 respectiv
ely and merges them into a third array z containing n3 elements.
Program on Merge sort -
void main()
{
int arr1[10]={2,4,6,8,10,12,14,16,18,20};
int arr2[5]={1,3,5,7,9};
int arr3[15];
int i=0,j=0,k=0,t;
clrscr();
while(i<10 && j<5)
{
if(arr1[i] < arr2[j])
{
arr3[k]=arr1[i];
k++; i++;
}
else
{
arr3[k]=arr2[j];
k++; j++;
}
}
while(i<10)
{
arr3[k]=arr1[i];
k++; i++;
}
while(j<5)
{
arr3[k]=arr2[j];
k++; i++;
}
printf("\nNew sorted array");
for(i=0;i<10;i++)
printf("\n%d",arr3[i]);
getch();
}
Insertion sort: -
Insertion sort is based on the idea of inserting records into an existing sorted
file. To insert a record, we must find the proper place where insertion is to b
e made. To find this place, we need to search. Once we have found the correct pl
ace, we need to move the records to make a place for the new record. We can redu
ce our work by combing the two operations of searching and shifting. We can star
t searching from the end of the array and keep on moving the records till we fin
d its proper place.
void main()
{
int num[5]={5,10,20,25};
int new,k;
clrscr();
for(k=0;k<4;k++)
printf("\n%d",num[k]);
printf("\nEnter new value to insert := ");
scanf("%d",&new);
for(k=3;k>=0;k--)
{
if(new<num[k])
{
num[k+1]=num[k];
num[k]=new;
}
else
{
num[k+1]=new;
break;
}
}
for(k=0;k<5;k++)
printf("\n%d",num[k]);
getch();
}
Quick Sort: -
We have noticed that it is much easier to sort short lists than long ones. If we
can find a way to divide the list into two roughly same sized lists and sort th
em separately, we will save work. This way we can divide a problem into smaller
but similar sub problems. We keep on dividing the list till there is only one en
try left.
To partition the list, we first choose some key from the list for which about ha
lf the keys will come before and half after. This selected key is called pivot.
We next partition the entries so that all the keys which are less than the pivot
come in one sub list and all the keys which are greater than the pivot come in
the another sub list. This method is also called as partition-exchange sort.
One partition contains elements smaller than the key value
Another partition contains elements larger than the key value.
void main()
{
int num[10]={30,40,20,100,70,50,80,60,90,10};
int i;
clrscr();
quick(num,0,9);
for(i=0;i<10;i++)
printf("\n%d",num[i]);
getch();
}
quick(int num[], int left, int right)
{
int i,j,p,t;
i=left;
j=right;
p = num[(left+right)/2];
do
{
while(num[i]<p && i<right)
i++;
while(num[j]>p && j>left)
j--;
if(i<=j)
{
t=num[i];
num[i]=num[j];
num[j]=t;
i++;
j--;
}
}while(i<=j);
if(left<j)
quick(num,left,j);
if(i<right)
quick(num,i,right);
}
Radix sort
If we have a list of 100 names and we want to sort them alphabetically then firs
t we take the names which start with alphabet A and then we take the names which s
tart from alphabet B and so on.
Similarly if we have list of numbers then there will be 10 parts from 0 to 9
because radix is 10. In first pass we take the numbers in parts on the basis of
unit digit(least significant digit). In second pass the base will be tens digi
t and similarly for other passes. If the largest number has 3 digits then numbe
r will be sorted in maximum 3 passes.
We may note that in this sorting technique , the less-significant digits are sor
ted first, Therefore when all the numbers are sorted on a more significant digit
, numbers that have the same digit at that position but distinct digits in a le
ss significant position are already sorted on a less-significant position.
Shell sort
Shell sort is named after its discover D.L Shell.It is also called diminishing-i
ncrement sort.In case of insertion sort we can move entries only one position be
cause it compares only adjacent keys, to modify this method ,we first compare ke
ys that are far apart and then sort the entries far apart. At the end list will
be maintained with increment 1 and we will sort them with insertion sort. We tak
e the decreasing increments for making the list so this sorting is also called a
s diminishing increment sort.
We choose the sequence (5,3,1) as increments, Any other sequence may be chosem w
hich might work as well or better.
Run time memory management in C
For complex program we need extra memory anytime. C facilitates us to manage mem
ory dynamically. This means allocating memory at runtime. You can allocate as we
ll as free the memory dynamically.
Memory management functions: -
1) Malloc: - it allocates a portion of memory of a given size dynamically. It al
ways returns a pointer of type char. Therefore whenever we call malloc() we must
supply a pointer that points to allocated memory. Malloc() always allocate data
based on the number of bytes. On failure this function returns pointer value as
NULL.
Syntax :- Pointer variable = (Data type *) malloc (sizeof(datatype));
E.g :-
int *p;
p=(int *) malloc (sizeof(int));
this statement will dynamically allocate memory of 2 bytes and stores base the a
ddress of the allocated memory location in pointer p. As malloc() returns pointe
r of character type we must typecast this value to integer.
2) Free: - It is used to free storage or memory of dynamically allocated variabl
e.
Syntax :- Free(pointer variable);
Note: - To use above function we required to include <alloc.h> header file.
Program to allocate runtime memory for array
#include<alloc.h>
void main()
{
int *p,n,i;
clrscr();
printf("\nEnter no of students := ");
scanf("%d",&n);
p = (int *) malloc (sizeof(int)*n);
if(p==NULL)
{
printf("\nError");
getch();
exit();
}
for(i=0;i<n;i++)
scanf("%d",(p+i));
for(i=0;i<n;i++)
printf("\n%d",*(p+i));
getch();
}
Program for runtime memory allocation using structure
#include<alloc.h>
void main()
{
struct sample
{
char name[10];
int age;
}*s;
int n=0,i;
clrscr();
printf("\nEnter no of records = ");
scanf("%d",&n);
s=(struct sample *) malloc (sizeof(struct sample) * n);
for(i=0;i<n;i++)
{
printf("\nEnter name and age := ");
scanf("%s %d",(s+i)->name,&(s+i)->age);
}
for(i=0;i<n;i++)
{
printf("\n%s \t %d",(s+i)->name,(s+i)->age);
}
getch();
}
Linked List
Till we studied about the data structure array having the property that successi
ve nodes of the data object were stored at a fixed distance apart. In this chapt
er we will study another data structure called link list in which each item may
be placed anywhere in the memory.
Array is called as a sequence of data elements. There is also the next
element to each element. But the successive elements do not occupy the consecuti
ve memory location. In arrays between two successive elements there is no place
for any other element. A lot of shifting is required for such an operation. But i
n case of linked list any number of new elements can be accommodated between two
successive elements. No shifting is required, as they are not occupying the cons
ecutive locations.
What is required to be done is just manipulation of the links. Actually in this
case each element along with data also remember the address of the next element.
This is known as a link from one element to next.
Suppose that initially A and B are the successive and we are require to place C
in between them now initially A contains the link that goes to B as C is to be i
nserted the link of A should go to C, and also the link C should go to B. this i
s known as link manipulation.
List:-list is collection of short pieces of information
A list in memory is to use a structure which is self referential structure.O
ne member of this structure is a pointer that points to the structure itself.
Struct node{
int data;
struct node *link;
};
Here member of the structure struct node *link points to the structure itself.
This type of structure is called Linked list
A link list is collection of elements called nodes .Each nodes has two parts
First, part contains information field(DATA)
Second part contains the address of the next node . The address part of last node o
f linked list will have NULL value.
Clearly there will be two fields in any node of the list, the data field and the
link field. The data could be any type but the link could be always pointer to
the next node that is the address of the next node.
Singly linked list
In the single linked list each node or item contain at list two fields, an infor
mation field and the next address field. The first, field contains the actual el
ement on the list which may be a simple integer, a character, a string or even a
large record. The second field, which is a pointer, contains the address of the
next node in the list used to access the next node.
The entire linked list is accessed from an external pointer list pointing to the
first node in the list. We can access the first node through the external point
er, the second node through the next pointer of the first node, the third node t
hrough the next pointer of the second node till the end of the list. The next ad
dress field of the last node contains a special value, known as the null value.
This is not a valid address. This only tells us that we have reached the end of
the list.
Info :-information part of the node

Link:- Address part of the node which contains the address of the next node
Implementation of linked list

#include<alloc.h>
void main()
{
struct node
{
int data;
struct node *link;
};
struct node *p=NULL,*q;
int d; char ch;
clrscr();
do
{
if(p==NULL)
{
p = (struct node *) malloc (sizeof(struct node));
q = p;
}
else
{
q->link=(struct node *) malloc (sizeof(struct node));
q=q->link;
}
printf("\nEnter data := ");
scanf("%d",&d);
q->data=d;
q->link=NULL;
printf("\nNext node (y/n) ?");
ch=getche();
}while(ch=='y');
q=p;
while(q!=NULL)
{
printf("\n%d",q->data);
q=q->link;
}
getch();
}
Sample Program
#include<alloc.h>
void main()
{
struct book
{
int bno;
char bname[10];
int price;
struct book *next;
};
struct book *p=NULL,*q;
char ch;
clrscr();
do
{
if(p==NULL)
{
p = (struct book *) malloc (sizeof(struct book));
q = p;
}
else
{
q->next=(struct book *) malloc (sizeof(struct book));
q=q->next;
}
printf("\nEnter Book no, Book name and Price := \n");
scanf("%d%s%d",&q->bno,q->bname,&q->price);
q->next=NULL;
printf("\nNext book (y/n) ?");
ch=getche();
}while(ch=='y');
q=p;
printf("\nBookno \t\tBookname \tPrice");
while(q!=NULL)
{
printf("\n%d\t\t%s\t\t%d",q->bno,q->bname,q->price);
q=q->next;
}
getch();
}
Program to add node at beginning
#include<alloc.h>
void main()
{
struct node
{
int data;
struct node *link;
};
struct node *p=NULL,*q,*t;
int d; char ch;
clrscr();
do
{
if(p==NULL)
{
q=p;
}
else
{
q->link = (struct node *) malloc (sizeof(struct node));
q=q->link;
}
scanf("%d",&d);
q->data=d;
q->link=NULL;
printf("\nAdd next (y/n) ?");
ch=getche();
}while(ch=='y');
q=p;
while(q!=NULL)
{
q=q->link;
}
printf("\nEnter value to add at beginning := ");
scanf("%d",&d);
t=(struct node *) malloc (sizeof(struct node));
t->data=d;
t->link=p;
p=t;
q=p;
while(q!=NULL)
{
q=q->link;
}
getch();
}
Program to add node at end
#include<alloc.h>
void main()
{
struct node
{
int data;
struct node *link;
};
int d; char ch;
clrscr();
do
{
if(p==NULL)
{
q=p;
}
else
{
q=q->link;
}
scanf("%d",&d);
q->data=d;
q->link=NULL;
ch=getche();
}while(ch=='y');
q=p;
while(q!=NULL)
{
t=q;
q=q->link;
}
printf("\nEnter value to add at the end := ");
scanf("%d",&d);
t->link=(struct node *) malloc (sizeof(struct node));
t=t->link;
t->data=d;
t->link=NULL;
q=p;
while(q!=NULL)
{
q=q->link;
}
getch();
}
Program to add node at given position
#include<alloc.h>
void main()
{
struct node
{
int data;
struct node *link;
};
struct node *p=NULL,*q,*t,*e;
int d,pos,c=0; char ch;
clrscr();
do
{
if(p==NULL)
{
q=p;
}
else
{
q=q->link;
}
scanf("%d",&d);
q->data=d;
q->link=NULL;
ch=getche();
}while(ch=='y');
q=p;
while(q!=NULL)
{
q=q->link;
}
printf("\nEnter position for new value := ");
scanf("%d",&pos);
printf("\nEnter new value := ");
scanf("%d",&d);
t->data=d;
q=p;
while(q!=NULL)
{
c++;
if(c==pos)
{
e=q;
q=t;
q->link=e;
}
q=q->link;
}
getch();
}
Program to delete a node
#include<alloc.h>
void main()
{
struct node
{
int data;
struct node *link;
};
int d; char ch;
clrscr();
do
{
if(p==NULL)
{
q=p;
}
else
{
q=q->link;
}
scanf("%d",&d);
q->data=d;
q->link=NULL;
ch=getche();
}while(ch=='y');
q=p;
while(q!=NULL)
{
q=q->link;
}
printf("\nEnter data to delete := ");
scanf("%d",&d);
q=p;
while(q!=NULL)
{
if(q->data==d)
{
if(q==p)
{
p=q->link;
free(q);
}
else
{
t->link=q->link;
free(q);
}
}
t=q;
q=q->link;
}
q=p;
while(q!=NULL)
{
q=q->link;
}
getch();
}
Program to search element from list
#include<alloc.h>
void main()
{
struct node
{
int data;
struct node *link;
};
int d,pos,f=0; char ch;
clrscr();
do
{
if(p==NULL)
{
q=p;
}
else
{
q=q->link;
}
scanf("%d",&d);
q->data=d;
q->link=NULL;
ch=getche();
}while(ch=='y');
q=p;
while(q!=NULL)
{
q=q->link;
}
printf("\nEnter data to search := ");
scanf("%d",&d);
q=p; pos=0;
while(q!=NULL)
{
pos++;
if(q->data==d)
{
printf("\nData found at %d",pos);
f=1;
break;
}
q=q->link;
}
if(f==0)
printf("\nData not found");
getch();
}
Program to create ordered link list
#include<alloc.h>
void main()
{
struct node
{
int data;
struct node *link;
};
struct node *p=NULL,*q,*t,*minpos;
int d,temp; char ch;
clrscr();
do
{
if(p==NULL)
{
q=p;
}
else
{
q=q->link;
}
scanf("%d",&d);
q->data=d;
q->link=NULL;
ch=getche();
}while(ch=='y');
q=p;
while(q!=NULL)
{
minpos=q;
t=minpos;
while(t!=NULL)
{
if(minpos->data > t->data)
minpos = t;
t=t->link;
}
if(q!=minpos)
{
temp=q->data;
q->data=minpos->data;
minpos->data=temp;
}
q=q->link;
}
q=p;
while(q!=NULL)
{
q=q->link;
}
getch();
}
Program to insert element in ordered list
#include<alloc.h>
void main()
{
struct node
{
int data;
struct node *link;
};
struct node *p=NULL,*q,*t,*e,*minpos;
int d,temp,i=0; char ch;
clrscr();
do
{
if(p==NULL)
{
q=p;
}
else
{
q=q->link;
}
scanf("%d",&d);
q->data=d;
q->link=NULL;
ch=getche();
}while(ch=='y');
q=p;
while(q!=NULL)
{
minpos=q;
t=minpos;
while(t!=NULL)
{
if(minpos->data > t->data)
minpos = t;
t=t->link;
}
if(q!=minpos)
{
temp=q->data;
q->data=minpos->data;
minpos->data=temp;
}
q=q->link;
}
q=p;
while(q!=NULL)
{
q=q->link;
}
printf("\nEnter new value to add := ");
scanf("%d",&d);
q=p;
while(q!=NULL)
{
e=(struct node *) malloc (sizeof(struct node));
e->data=d;
if(d < q->data)
{
i=1;
if(q==p)
p=e;
e->link=q;
t->link=e;
break;
}
t=q;
q=q->link;
}
if(i==0)
{
e->link=NULL;
t->link=e;
}
q=p;
while(q!=NULL)
{
q=q->link;
}
getch();
}
Menu driven program for linked list
#include<alloc.h>
void main()
{
struct node
{
int data;
struct node *link;
};
struct node *p=NULL,*q,*t,*e,*minpos,*tmp=NULL;
int d,temp,choice,opt,pos,c=0,f=0;
char ch;
clrscr();
while(1)
{
clrscr();
printf("\n1. Add \n2. Read \n3. Modify \n4. Delete \n5. Search \n6. Exit \
nChoice :=");
scanf("%d",&choice);
switch(choice)
{
case 1:
printf("\n1. At beginning \n2. At end \n3. At given position \nChoic
e :=");
scanf("%d",&opt);
switch(opt)
{
case 1:
scanf("%d",&d);
t->data=d;
t->link=p;
p=t;
break;
case 2:
if(p==NULL)
{
printf("\nThere is no node at beginning");
printf("\t.....Node not inserted");
getch();
break;
}
printf("\nEnter value to add at the end := ");
scanf("%d",&d);
q=p;
while(q!=NULL)
{
t=q;
q=q->link;
}
t->link=(struct node *) malloc (sizeof(struct node));
t=t->link;
t->data=d;
t->link=NULL;
break;
case 3:
if(p==NULL)
{
printf("\nThere is no node at beginning or end");
printf("\t.....Node not inserted");
getch();
break;
}
printf("\nEnter position to add new value := ");
scanf("%d",&pos);
scanf("%d",&d);
t->data=d;
q=p; c=0;
while(q!=NULL)
{
c++;
if(c==pos)
{
e=q;
q=t;
q->link=e;
tmp->link=q;
}
tmp=q;
q=q->link;
}
break;
default:
printf("\nWrong choice");
break;
}
break;
case 2:
if(p==NULL)
{
printf("\nData not available");
getch();
break;
}
q=p;
while(q!=NULL)
{
q=q->link;
}
getch();
break;
case 3:
if(p==NULL)
{
getch();
break;
}
printf("\nEnter position to modify := ");
scanf("%d",&pos);
printf("\nEnter new data := ");
scanf("%d",&d);
q=p; c=0;
while(q!=NULL)
{
c++;
if(c==pos)
{
q->data=d;
break;
}
q=q->link;
}
break;
case 4:
if(p==NULL)
{
getch();
break;
}
printf("\nEnter data to delete := ");
scanf("%d",&d);
q=p;
while(q!=NULL)
{
if(q->data==d)
{
if(q==p)
{
p=q->link;
free(q);
}
else
{
t->link=q->link;
free(q);
}
}
t=q;
q=q->link;
}
break;
case 5:
if(p==NULL)
{
getch();
break;
}
printf("\nEnter data to search := ");
scanf("%d",&d);
q=p; pos=0; f=0;
while(q!=NULL)
{
pos++;
if(q->data==d)
{
printf("\nData found at %d",pos);
f=1;
break;
}
q=q->link;
}
getch();
if(f==0)
break;
case 6:
exit();
break;
default:
break;
}
}
getch();
}
Doubly linked List
In single link list, it is not possible to delete a node, given only pointer to
that node. Also it is not possible to traverse the list backwards.
For handling such difficulties we can use doubly linked lists in which each node
contain two links, one to its predecessor and another to its successor.
Each node of a doubly link list contains three fields: -

Info to contain the information stored in the node
Next to contain pointer to the next node
Back to contain pointer to the previous node.
Program to implement doubly linked list
#include<alloc.h>
void main()
{
struct dnode
{
struct dnode *pre;
int data;
struct dnode *next;
};
struct dnode *p,*q;
clrscr();
p=(struct dnode *) malloc (sizeof(struct dnode));
q=(struct dnode *) malloc (sizeof(struct dnode));
p->pre=NULL;
p->data=10;
p->next=q;
q->pre=p;
q->data=20;
q->next=NULL;
q=p;
while(q!=NULL)
{
q=q->next;
}
getch();
}
Implementation program
#include<alloc.h>
void main()
{
struct dnode
{
struct dnode *pre;
int data;
struct dnode *next;
};
struct dnode *p=NULL,*q,*t;
char ch; int d;
clrscr();
do
{
if(p==NULL)
{
p->pre=NULL;
q=p;
}
else
{
t=q;
q->next=(struct dnode *) malloc (sizeof(struct dnode));
q=q->next;
q->pre=t;
}
printf("\nEnter value := ");
scanf("%d",&d);
q->data=d;
q->next=NULL;
ch=getche();
}while(ch=='y');
q=p;
while(q!=NULL)
{
q=q->next;
}
getch();
}
To add node at beginning
#include<alloc.h>
void main()
{
struct dnode
{
struct dnode *pre;
int data;
struct dnode *next;
};
struct dnode *p=NULL,*q,*t;
char ch; int d;
clrscr();
do
{
if(p==NULL)
{
p->pre=NULL;
q=p;
}
else
{
t=q;
q=q->next;
q->pre=t;
}
scanf("%d",&d);
q->data=d;
q->next=NULL;
ch=getche();
}while(ch=='y');
q=p;
while(q!=NULL)
{
q=q->next;
}
scanf("%d",&d);
t=(struct dnode *) malloc (sizeof(struct dnode));
t->pre=NULL;
t->next=p;
p->pre=t;
t->data=d;
p=t;
q=p;
while(q!=NULL)
{
q=q->next;
}
getch();
}
To add node at end
#include<alloc.h>
void main()
{
struct dnode
{
struct dnode *pre;
int data;
struct dnode *next;
};
struct dnode *p=NULL,*q,*t,*e;
char ch; int d;
clrscr();
do
{
if(p==NULL)
{
p->pre=NULL;
q=p;
}
else
{
t=q;
q=q->next;
q->pre=t;
}
scanf("%d",&d);
q->data=d;
q->next=NULL;
ch=getche();
}while(ch=='y');
q=p;
while(q!=NULL)
{
e=q;
q=q->next;
}
printf("\nEnter value to add at end := ");
scanf("%d",&d);
t=(struct dnode *) malloc (sizeof(struct dnode));
t->pre=e;
e->next=t;
t->next=NULL;
t->data=d;
q=p;
while(q!=NULL)
{
q=q->next;
}
getch();
}
To add node at given position
#include<alloc.h>
void main()
{
struct dnode
{
struct dnode *pre;
int data;
struct dnode *next;
};
char ch; int d,pos,c=1;
clrscr();
do
{
if(p==NULL)
{
p->pre=NULL;
q=p;
}
else
{
t=q;
q=q->next;
q->pre=t;
}
scanf("%d",&d);
q->data=d;
q->next=NULL;
ch=getche();
}while(ch=='y');
q=p;
while(q!=NULL)
{
q=q->next;
}
printf("\nEnter position to add new value := ");
scanf("%d",&pos);
scanf("%d",&d);
e=(struct dnode *) malloc (sizeof(struct dnode));
e->data=d;
q=p;
while(q!=NULL)
{
if(c==pos)
{
if(q==p)
{
e->next=p;
e->pre=NULL;
p->pre=e;
q=e;
}
else
{
e->pre=t;
e->next=q;
t->next=e;
q->pre=e;
q=e;
}
}
c++;
t=q;
q=q->next;
}
getch();
}
To delete node
#include<alloc.h>
void main()
{
struct dnode
{
struct dnode *pre;
int data;
struct dnode *next;
};
char ch; int d,pos,c=1;
clrscr();
do
{
if(p==NULL)
{
p->pre=NULL;
q=p;
}
else
{
t=q;
q=q->next;
q->pre=t;
}
scanf("%d",&d);
q->data=d;
q->next=NULL;
ch=getche();
}while(ch=='y');
q=p;
while(q!=NULL)
{
q=q->next;
}
printf("\nEnter position to delete := ");
scanf("%d",&pos);
q=p;
while(q!=NULL)
{
if(c==pos)
{
if(q==p)
{
q=q->next;
free(p);
p=q;
}
else
{
t->next=q->next;
q->next->pre=t;
free(q);
}
}
c++;
t=q;
q=q->next;
}
q=p;
while(q!=NULL)
{
q=q->next;
}
getch();
}
Circular Linked List
By now, you must have noticed that if we wish to access all nodes in the list, w
e must always have the pointer to the beginning of the list. As, given a pointer
P to a node anywhere in the list, we can access all of the nodes that follow, b
ut none of the nodes that precede node(P).
We can improve this by replacing the null pointer in the last node of a list wit
h the address of its first node. Such a list is called as a circularly linked li
st or circular list. Now starting from any given node, we can traverse all nodes
merely by chaining through the list.
When we are traversing a circular list, we must be careful, as there is a possib
ility to get into an infinite loop! If we are not able to defect the end of the
list. To do that we must look for the staring node. We can keep an external poin
ter as the starting node and look for this external pointer as a stop sign.
Sample Program
#include<alloc.h>
void main()
{
struct cnode
{
int data;
struct cnode *link;
};
struct cnode *p,*q;
clrscr();
p=(struct cnode *) malloc (sizeof(struct cnode));
q=(struct cnode *) malloc (sizeof(struct cnode));
p->data=10;
q->data=20;
p->link=q;
q->link=p;
q=p;
while(q!=NULL)
{
q=q->link;
}
getch();
}
#include<alloc.h>
void main()
{
struct cnode
{
int data;
struct cnode *link;
};
struct cnode *p=NULL,*q,*f=NULL,*r=NULL;
char ch; int d;
clrscr();
do
{
scanf("%d",&d);
q=(struct cnode *) malloc (sizeof(struct cnode));
if(f==NULL)
f=q;
else
r->link=q;
r=q;
q->data=d;
q->link=f;
ch=getche();
}while(ch=='y');
q=f;
while(q!=p)
{
q=q->link;
p=f;
}
getch();
}
Stacks
One of the most important linear data structures of variable size is the stack.
A linear list in which we are allowed to delete an element from and insert an el
ement to any position in the list. If we put a restriction on the lists so that
the insertion or deletion of an element occurs only at one end, we get an import
ant subclass of lists called stack.
The removal or addition of elements can take place only at the top of the stack.
A common example of stack, which permits the selection of only its end element,
is a pile of coins. Another example could be a pile of trays or a pile of saree
s. A person desiring a coin can pick up only the top coin and if one wants to pl
ace a coin on the pile one has to place it on the top.
When we add an element to a stack we say that we push it on the stack and if we
delete an element from a stack we say that we pop it from the stack.
Application of stack
As stack is a LIFO (Last in first out) structure, it is an appropriate data stru
cture for applications in which information must be saved and later retrieved in
reverse order. Consider what happens within the computer system when subprogram
s are called. How your program remembers where to continue execution after retur
ning from a subprogram? How it remembers all the local variables, processor regi
sters and the other information used by subprogram? Hence a stack plays a key ro
le in invoking sub programs in a computer system.
Implementation of stack using array -
void main()
{
int num[5],pos=-1,data;
char ch;
clrscr();
do
{
pos++;
if(pos==4)
{
printf("\nStack overflow");
break;
}
printf("\nEnter data = ");
scanf("%d",&data);
num[pos]=data;
printf("\nPush (y/n) ?");
ch= getche();
}while(ch=='y');
printf("\nPop items (y/n) ?");
ch=getche();
while(ch=='y')
{
if(pos == -1)
{
printf("\nStack underflow");
break;
}
printf("\n%d",num[pos]);
pos--;
printf("\nPop next (y/n) ?");
ch=getche();
}
getch();
}
Implementation of stack using array and structure
#define max 5
struct stack
{
int top;
int element[max];
};
void main()
{
void push();
void clearstack();
struct stack s;
int data;
char ch;
clrscr();
clearstack(&s);
do
{
scanf("%d",&data);
if(fullstack(&s))
{
break;
}
push(&s,data);
printf("\nPush next (y/n) ?");
ch=getche();
}while(ch=='y');
do
{
printf("\nPop (y/n) ?");
ch=getche();
if(ch=='n')
break;
if(emptystack(&s))
{
break;
}
data = pop(&s);
printf("\n%d",data);
}while(ch=='y');
getch();
}
void push(ts,x)
struct stack *ts;
int x;
{
ts->top++;
ts->element[ts->top]=x;
}
fullstack(ts)
struct stack *ts;
{
if(ts->top == max - 1)
return 1;
else
return 0;
}
void clearstack(ts)
struct stack *ts;
{
ts->top = -1;
}
pop(ts);
struct stack *ts;
{
return ts->element[ts->top--];
}
emptystack(ts)
struct stack *ts;
{
if(ts->top == -1)
return 1;
else
return 0;
}
Implementation of stack using linked list
#include<alloc.h>
void main()
{
struct node
{
int data;
struct node *link;
};
struct node *p=NULL,*top;
int d; char ch;
clrscr();
do
{
top=(struct node *) malloc (sizeof(struct node));
top->link=p;
scanf("%d",&d);
top->data=d;
printf("\nPush node (y/n) ?");
ch=getche();
p=top;
}while(ch=='y');
top=p;
do
{
printf("\nPop node (y/n) ?");
ch=getche();
if(ch=='n')
break;
if(top==NULL)
{
printf("\nStack empty");
break;
}
printf("\n%d",top->data);
top=top->link;
}while(ch=='y');
getch();
}
Infix, Postfix and Prefix notations
There are three notations for expressing the sum of A and B using the symbols A,
B, and +. These are
A + B Infix
+ A B Prefix
A B + Postfix
We may notice that it is the relative position of the operator with respect to t
he two operands which defines the prefix pre, post or in. in infix notation the
operator is between the two operands, in prefix notation the operator precedes t
he two operands and in postfix notation the operator follow the two operands.
Let us see how an expression given in infix notation can be written in postfix n
otation.
A + (B * C)
A + (B C *)
A (B C * ) +
A B C * +
Note that after a portion of the expression has been converted to postfix it is
treated as a single operand.
Another example is (A + B) * C
(A B +) * C
(A B +) C *
A B + C * postfix form
In the above example the parenthesis, addition is done before multiplication.
Some more examples to understand the conversion from infix to postfix
Infix Postfix
X + Y Z XY + Z
(X+Y) * (Z-A) XY + ZA - *
A * (B + C) * D ABC+ * D *
B * C D + E / F / (G+H) BC * D EF / GH + / +
Suppose we have to evaluate the following postfix expression i.e. 98 + 382 / * 2
+ -
We can show the contents of the stack, symbol, operand1, operand2 and result aft
er each iteration of the loop.
Symb Op1 Op2 Result Stack 9 9 8 9,8 + 9 8 17 17 3 17,3 8 17,3,8
2 17,3,8,2 / 8 2 4 17,3,4 * 3 4 12 17,12 2 17,12,2 + 12 2 14 17,14
- 17 14 3 3
Program for postfix evaluation
#include<stdio.h>
#define maxcols 10
#define true 1
#define false 0
double eval();
double pop();
void push();
int empty();
int isdigit();
double oper();
struct stack
{
int top;
double items[maxcols];
};
void main()
{
char expr[maxcols];
int pos=0;
clrscr();
while((expr[pos++]=getchar())!='\n');
expr[--pos]='\0';
printf("\n%f",eval(expr));
getch();
}
double eval(char expr[maxcols])
{
int x,i;
double op1, op2, value;
struct stack s;
s.top=-1;
for(i=0;(x=expr[i])!='\0';i++)
{
if(isdigit(x))
push(&s,(double) (x-'0'));
else
{
op2 = pop(&s);
op1 = pop(&s);
value = oper(x,op1,op2);
push(&s,value);
}
}
return(pop(&s));
}
int isdigit(char symb)
{
return(symb >= '0' && symb <='9');
}
double oper(int symb,double op1,double op2)
{
switch(symb)
{
case '+' : return (op1 + op2);
case '-' : return (op1 - op2);
case '*' : return (op1 * op2);
case '/' : return (op1 / op2);
default : printf("illegal operation"); return 0;
}
}
void push(struct stack *ps, double x)
{
if(ps->top==maxcols-1)
{
getch(); exit();
}
else
{
ps->top++;
ps->items[ps->top]=x;
}
}
int empty(struct stack *ps)
{
if(ps->top==-1)
return(true);
else
return(false);
}
double pop(struct stack *ps)
{
if(empty(ps))
{
getch(); exit();
}
else
{
return(ps->items[ps->top--]);
}
}
Queues
A queue is an ordered group of elements in which elements are added at one end (
known as the rear end) and elements are removed from the other end (known as the
front end).
We come across a number of examples of queue in real life situations. For exampl
e, consider a line of students at a fees counter. Whenever a student enters a qu
eue he stands at the end of the queue and every time the student at the front of
the queue deposits the fees and leaves the queue. Therefore, this data structu
re is commonly known as FIFO (First in first out).
Adding an element in a queue is known as ENQ and deleting an element is knows as
DEQ.
Applications of queue
Queues are very useful in a time-sharing computer system where many users share
the system simultaneously. Whenever a user requests the system to run a particul
ar program, the operating system adds the request at the end of the queue of job
s waiting to be executed. Queues are also used in the output devices like printe
rs to print the job one by one from the starting to end.
Implementation of queue in array
void main()
{
int num[5],front=0,rear=-1,data;
char ch;
clrscr();
do
{
rear++;
if(rear==5)
{
printf("\nQueue full");
break;
}
scanf("%d",&data);
num[rear]=data;
ch=getche();
}while(ch=='y');
do
{
printf("\nView data (y/n) ?");
ch=getche();
if(ch=='n')
break;
if(front == rear)
{
printf("\nQuery Empty");
break;
}
else
{
printf("\n%d",num[front]);
front++;
}
}while(ch=='y');
getch();
}
Implementation of Queue using array and structure
#define max 5
struct queue
{
int front,rear;
int items[max];
};
void main()
{
void clearqueue();
void enq();
struct queue q;
int data;
char ch;
clrscr();
clearqueue(&q);
do
{
if(fullqueue(&q))
{
printf("\nQueue is full");
break;
}
scanf("%d",&data);
enq(&q,data);
printf("\nEnqueue next (y/n) ?");
ch=getche();
}while(ch=='y');
do
{
printf("\nDequeue data (y/n) ?");
ch=getche();
if(ch=='n')
break;
if(emptyqueue(&q))
{
printf("\nQuery is empty");
break;
}
data = dequeue(&q);
printf("\n%d",data);
}while(ch=='y');
getch();
}
void clearqueue(tq)
struct queue *tq;
{
tq->front = 0;
tq->rear = -1;
}
fullqueue(tq)
struct queue *tq;
{
if(tq->rear == max - 1)
return 1;
else
return 0;
}
void enq(tq,x)
struct queue *tq;
int x;
{
tq->rear++;
tq->items[tq->rear]=x;
}
emptyqueue(tq)
struct queue *tq;
{
if(tq->front > tq->rear)
return 1;
else
return 0;
}
dequeue(tq)
struct queue *tq;
{
return tq->items[tq->front++];
}
Implementation of queue using linked list
#include<alloc.h>
void main()
{
struct node
{
int data;
struct node *link;
};
struct node *f=NULL,*r,*q;
int d; char ch;
clrscr();
do
{
scanf("%d",&d);
q=(struct node *) malloc (sizeof(struct node));
q->data=d;
q->link=NULL;
if(f==NULL)
f=q;
else
r->link=q;
r=q;
printf("\nEnqueue node (y/n) ?");
ch=getche();
}while(ch=='y');
do
{
q=f;
printf("\nDequeue node (y/n) ?");
ch=getche();
if(ch=='n')
break;
if(q==NULL)
{
printf("\nQueue empty");
break;
}
f=q->link;
}while(ch=='y');
getch();
}
Priority Queues
There are queues in which we can insert items or delete items from any position
based on some property. Queues based on the property of priority of the task to
be processed are refereed to as priority queues.
In the computer system, jobs are assigned some priority according to the priorit
y of the job, it is inserted at the end of the last of other jobs with same prio
rity.
void main()
{
int num[5][2],arr[5],front=0,rear=-1;
int minpos,k,i,j,t=0,data,pr;
char ch;
clrscr();
do
{
rear++;
if(rear == 5)
{
printf("\nQueue full");
break;
}
scanf("%d",&data);
printf("\nPriority := ");
scanf("%d",&pr);
num[rear][0]=data;
num[rear][1]=pr;
ch=getche();
}while(ch=='y');
for(front=0;front<rear;front++)
{
printf("\n%d",num[front][0]);
printf("\t%d",num[front][1]);
}
front=0;
k=0;
for(i=0;i<5;i++)
{
if(k==5)
break;
minpos=5;
for(j=0;j<5;j++)
{
if((num[j][1] < minpos) && (num[j][1] > t))
minpos=num[j][1];
}
t=minpos;
j=0;
while(j<5)
{
if(minpos==num[j][1])
{
arr[k]=num[j][0];
k++;
}
j++;
}
}
do
{
printf("\nView data (y/n) ?");
ch=getche();
if(ch=='n')
break;
printf("\n%d",arr[front]);
front++;
if(front == rear)
{
printf("\nQueue empty");
break;
}
}while(ch=='y');
getch();
}
Circular queues
It is easier to represent a queue as a circular list than as a linear list. As a
linear list, two pointers specify a queue, one to the front of the list and the
other to its rear. However, by using a circle list, a queue may be specified by
a single pointer q to that list.node(q) is the rear of the queue and the follow
ing node is its front.
Program on circle queues using linked list
#include<alloc.h>
void main()
{
struct node
{
int data;
struct node *link;
};
struct node *f=NULL,*r=NULL,*t=NULL,*e=NULL;
int d,choice; char ch;
clrscr();
while(1)
{
clrscr();
printf("\n1. Add node \n2.View nodes \n3.Delete node \n4.Exit");
printf("\nyour choice := ");
switch(choice)
{
case 1:
scanf("%d",&d);
t=r;
r=(struct node *) malloc (sizeof(struct node));
r->data=d;
r->link=NULL;
if(f==NULL)
f=r;
else
t->link=r;
t=r;
r->link=f;
break;
case 2:
e=NULL;
t=f;
while(t!=e)
{
r=t;
printf("\n%d",t->data);
t=t->link;
e=f;
}
getch();
break;
case 3:
printf("\nAre you sure to delete node (y/n) ?");
ch=getche();
if(ch=='y')
{
t=f->link;
free(f);
f=t;
r->link=f;
}
break;
case 4:
exit();
default:
printf("\nWrong choice := ");
break;
}
}
getch();
}
Hashing
The search techniques discussed so far are based exclusively on comparing keys.
The organization of the file and the order in which the keys are inserted affect
the number of keys that must be examined before getting the desired one.
If the location of the record within the table depends only on the value of the
key and not on the locations of other keys, we can retrieve each key in a single
access. The most obvious and the efficient way to achieve this is to store each
record at a single offset from the base application of the table. This suggests
the user of arrays. If the record keys are integers the keys themselves can ser
ve as the index to the array.
Another approach is to convert a key into an integer within a limited range. Thi
s key to address transformation is known as hashing function. Which maps the key
space (K) into an address space (A). Given a key value a hash function h produc
es a table address where the record may be located. The address that h produces
should cover the entire set of indices in the table.
Ideally no two keys should be converted into the same addresses. Unfortunately,
no existing hashing function guarantees this. Usually the key space is much larg
er than the address space, therefore many keys are mapped to the same addresses.
This situation is called as hash collision.
Sample program for hash function (By finding remainder)
void main()
{
int tab[10],i,pos,no;
clrscr();
for(i=0;i<10;i++)
tab[i]=0;
i=0;
while(i<10)
{
scanf("%d",&no);
pos=hash(no);
tab[pos]=no;
i++;
}
printf("\nThe hash table is ..\n");
for(i=0;i<10;i++)
printf("\n%d",tab[i]);
printf("\nEnter value to search := ");
scanf("%d",&no);
pos=hash(no);
if(tab[pos]==no)
printf("\nValue found at %d pos",pos+1);
else
printf("\nElement not found");
getch();
}
Collision Resolution Techniques
Given a set of keys a prefect hash function may be defined as a hash function, w
hich yields an address that is unique. That means no collisions occur under a pe
rfect hash function. Unfortunately, it is not always possible to find such a has
h function for a changing key set, therefore we must find ways to resolve the co
llisions. There are two techniques for collision resolution as follow: -
Collision resolution by open addressing
The simplest way to resolve a collision is to start with the hash address and do
a sequential search through the table for an empty location. The idea is to pla
ce the record in the next available position in the array. This method is called
linear probing. An empty record is indicated by a special value called null. Th
e array should be considered circular, so that when the last location is reached
the search proceeds to the first record of the array. While searching a record,
the same sequence of locations is checked until either that record is found or
an empty record position is encountered in which case the desired record is not
their in the array. But the major drawback of the linear probe method is that of
clustering. When the table is empty it is equally that the random record will b
e placed at any empty position within the array.
Sample program for hash function (By finding remainder)
void main()
{
int tab[10];
int i,j,pos,npos,flag=0,no;
char ch;
clrscr();
for(i=0;i<10;i++)
tab[i]=-1;
do
{
flag=0;
printf("\nEnter value in table := ");
scanf("%d",&no);
pos=hash(no);
if(tab[pos]==-1)
{
tab[pos]=no;
printf("\nValue inserted at %d pos",pos);
flag=1;
}
else
{
npos=pos+1;
while(npos<10 && flag==0)
{
if(tab[npos]==-1)
{
tab[npos]=no;
printf("\nValue inserted at %d pos",npos);
flag=1;
}
npos++;
}
npos=0;
while(npos<pos && flag==0)
{
if(tab[npos]==-1)
{
tab[npos]=no;
printf("\nValue inserted at %d pos",npos);
flag=1;
}
npos++;
}
}
if(flag==0)
{
printf("\nHash table full...");
break;
}
printf("\nNext no (y/n) ?");
ch=getche();
}while(ch=='y');
printf("\nThe hash table is ..\n");
for(i=0;i<10;i++)
printf("\n%d",tab[i]);
flag=0;
scanf("%d",&no);
pos=hash(no);
if(tab[pos]==no)
{
printf("\nValue found at %d pos",pos+1);
flag=1;
}
else
{
npos=pos+1;
while(npos<10 && flag==0)
{
if(tab[npos]==no)
{
printf("\nValue found at %d pos",npos+1);
flag=1;
break;
}
npos++;
}
npos=0;
while(npos<pos && flag==0)
{
if(tab[npos]==no)
{
printf("\nValue found at %d pos",npos+1);
flag=1;
break;
}
npos++;
}
}
if(flag==0)
printf("\nElement not found");
getch();
}
int hash(int data)
{
int pos;
pos = data % 10;
return(pos);
}
Collision resolution by chaining
Another technique for handling collisions is called chaining. Here, the collidin
g records are chained into a special overflow area, which is separate from the p
rime area. The prime area contains the part of the array into which the records
are initially hashed. Each record in the primary area contains a pointer field t
o maintain a separate linked list. It is possible to keep only the header nodes
in the array and the actual records are kept in the linked lists.
#include<alloc.h>
#include<stdio.h>
struct node
{
int data;
struct node *next;
};
struct node *bucket[10];
void initialise();
void insert();
void search();
void display();
void main()
{
int i;
char ch;
clrscr();
initialise();
do
{
insert();
printf("\nMore no (y/n) ?");
ch=getch();
}while(ch=='y');
printf("\nThe data is stored");
display();
search();
getch();
}
void display()
{
int i=0;
struct node *temp;
while(i<10)
{
if(bucket[i]!=NULL)
{
temp=bucket[i];
while(temp!=NULL)
{
printf("\n%d",temp->data);
temp=temp->next;
}
}
i++;
}
}
void initialise()
{
int i;
for(i=0;i<10;i++)
bucket[i]=NULL;
}
void insert()
{
int d,ind;
struct node *nn,*temp;
nn=(struct node *)malloc(sizeof(struct node));
printf("\nEnter the data");
scanf("%d",&d);
nn->data=d;
nn->next=NULL;
ind=hash(d);
if(bucket[ind]==NULL)
{
bucket[ind]=nn;
return;
}
temp=bucket[ind];
while(temp->next!=NULL)
temp=temp->next;
temp->next=nn;
}
void search()
{
int d,ind;
struct node *temp;
printf("\nEnter the data to be searched");
scanf("%d",&d);
ind=hash(d);
if(bucket[ind]==NULL)
printf("\nThe data not found");
else
{
temp=bucket[ind];
while(temp!=NULL)
{
if(temp->data==d)
{
printf("\nThe data found");
break;
}
temp=temp->next;
}
}
}
int hash(int data)
{
int pos;
pos = data % 10;
return(pos);
}
Different types of hashing functions
Hash function using sum of digits method
In this method all the digits of given values are added together and then its su
m is inserted at the calculated position in table.
E.g. if inserted value is 15 then 1+5 = 6 is the position in the table.
Hash function division method
The most commonly used hash function is the division method in which an integer
key x is divided by the table size m and the remainder is taken as the hash valu
e. It is defined as
E.g. H(x) = x % m or H(x) = x % m + 1
Hash function using Midsquare method
In this method a key is multiplied by itself and the hash value is obtained by s
electing an appropriate number of digits from the middle of the square. The numb
er of the digits chosen depends on the number of digits allowed in the index.
E.g. if inserted key is 25 then 25 * 25 = 625 then the middle value from the squ
are is 2.
Tree & Binary Trees
Till now we have been discussing linear lists like array, structures, stacks and
queues. In this chapter we will introduce a data structure tree which is non li
near. Trees are used in many applications to represent the relationship among da
ta elements.
Similarly, the history of family representing information about ancestors and de
scendents can be recognized into a tree structure. For example,
In the above example Jaggi and Sunil are children of Rahul, Karan and Rahul are
children of Ravi. Most of the terminology used in computer science to discuss tr
ees is derived from such a family tree.
A tree consists of a collection of nodes, which are connected by directed arcs.
A tree contains a unique first element known as the root that is shown the top o
f the tree structure (Ravi in the family tree is the root). A node that points t
o other nodes is said to be the parent of the nodes to which it is pointing and
these nodes in tree are called children of that node (E.g. Ravi is parent of Nat
asha, Karan and Rahul)
The root is the only node in the tree that does not posses a parent. All other n
odes in the tree have exactly on parent. There are nodes in the tree, which do n
ot have children. Such nodes are called the leaf nodes (Sunny, Kush, Jaggi and S
unil are leaf nodes). On other hand the nodes which posses children are called t
he interior nodes.
The nodes are siblings if they have the same parents. (e.g. Sunny and Honey are
siblings). A node is an ancestor of another node if it is the parent of that nod
e or the parent of some other ancestor of that node. The ancestors of Sunny are
Natasha and Ravi). The root is an ancestor of every other node in the tree. Simi
larly, we can define a node to be descendent of another node if it is the child
of the node or the child of some other descendent of that node. (e.g. the descen
dants of Natasha are Sunny, Honey and Asha).
An important feature of trees is that there is a single unique path along arcs f
rom the root to any particular node. The length of the longest path from the roo
t to any node is known as the depth of the tree. The root is at level 0 and the
level of any other node in the tree is one more that the level of its parent. Fo
r example, Sunny is at level 2 and Asha at level 3. The depth of the binary tree
can also be defined as the maximum level of any leaf in the tree. In a valid tr
ee, any node can be considered to the root of the tree formed by considering onl
y the descendant of that node. This second tree is called as subtree which itsel
f a tree.
Binary Tree
If we make a restriction that each node can have maximum two children, we can ha
ve a binary tree. We can give the formal definition of a binary tree as a tree w
hich is either empty or consists of a root node together with two binary trees,
a left sub tree and a right sub tree of the root.
A binary tree with a single node is a binary tree with a root whose left and rig
ht sub trees are empty.
If there are two nodes in the binary tree, one will be the root and the other ca
n either be left child or the right child of the root. Hence left and right are
important for binary trees.
A binary three is called a strictly binary tree if every non leaf node in the bi
nary tree has nonempty left and right sub tree. This means each node in a binary
tree will have either 0 or 2 children.
A complete binary tree can be defined as a binary tree whose non-leaf nodes have
nonempty left and right sub tree and all leaves are at the same level.
If a binary tree has the property that all elements in the left sub tree of a no
de n are less than the contents of n and all elements in the right sub tree are
greater than the contents of n, such a binary tree is called as the binary searc
h tree. As the same suggest they are very useful for searching an element just a
s with binary search. If we search an element in binary search tree, we move to
the left sub tree for smaller values and to right sub tree for larger values and
reduce the search list by half.
E.g :- The binary tree will displayed for the following values as follow
10, 20, 15, 8, 5, 3, 35, 6
Operations on Binary Tree
Insertion into binary tree
Another important operation is to create and maintain a binary search tree. Whil
e inserting any node we have to take care that the resulting tree satisfies the
properties of binary search tree. A new node will always be inserted at its prop
er position in the binary tree as a leaf.
Program to insert node into binary tree
#include<alloc.h>
void main()
{
struct tree
{
struct tree *left;
int data;
struct tree *right;
};
struct tree *p,*r=NULL,*t,*b;
int d; char ch;
clrscr();
do
{
t=(struct tree *) malloc (sizeof(struct tree));
t->left=NULL;
t->right=NULL;
scanf("%d",&d);
t->data=d;
if(r==NULL)
r=t;
else
{
b=r;
while(b!=NULL)
{
p=b;
if(t->data > b->data)
b=b->right;
else
b=b->left;
}
if(p->data > t->data)
p->left=t;
else
p->right=t;
}
printf("\nAdd new node (y/n) ?");
ch=getche();
}while(ch=='y');
getch();
}
Search the tree
To search the tree we use a traversal pointer, p and set it equal to the root of
the tree. Then we compare the information of p with the given value. If the inf
ormation is equal to the given value we exit the routine. If give value is less
than information of p then we search in the left subtree of p, otherwise we sear
ch in the right subtree.
Program to search value in tree
#include<alloc.h>
void main()
{
struct tree
{
struct tree *left;
int data;
struct tree *right;
};
int d; char ch;
clrscr();
do
{
t->left=NULL;
t->right=NULL;
scanf("%d",&d);
t->data=d;
if(r==NULL)
r=t;
else
{
b=r;
while(b!=NULL)
{
p=b;
b=b->right;
else
b=b->left;
}
p->left=t;
else
p->right=t;
}
ch=getche();
}while(ch=='y');
scanf("%d",&d);
b=r;
while(b!=NULL)
{
if(d == b->data)
{
printf("\nData found");
getch();
exit();
}
else
{
if(d > b->data)
b=b->right;
else
b=b->left;
}
}
getch();
}
Tree Traversals
Another useful operation on a binary tree is traversal which is to move through
all the nodes of the binary tree, visiting each one in turn, for example to prin
t all of the values in the tree.
While traversing a list, we simply start with from the first node and then follo
w the links from one node to the next until we encounter a NULL value. But for t
rees, once we start from the root, there are two way to go, either left or right
.
For the tree traversals there are three methods as follow: -
Pre Order Root ( Left ( Right
Post Order Left ( Right ( Root
In Order Left ( Root ( Right
If the root is visited before its sub tree then it is called pre order traversal
. If root is visited after the traversing its sub tree then it is called post or
der traversal. If root is visited in between its sub tree then it is called in o
rder traversal.
Pre Order A ( B ( C
Post Order B ( C ( A
In Order B ( A ( C
Pre Order A ( B ( C ( D ( E ( F ( G ( H ( I ( J
Post Order C ( E ( D ( B ( G ( I ( J ( H ( F ( A
In Order C ( B ( D ( E ( A ( G ( F ( I ( H ( J
Pre Order 20 ( 15 ( 10 ( 18 ( 17 ( 30 ( 25 ( 40 ( 35 ( 38 ( 50
Post Order 10 ( 17 ( 18 ( 15 ( 25 ( 38 ( 35 ( 50 ( 40 ( 30 ( 20
In Order 10 ( 15 ( 17 ( 18 ( 20 ( 25 ( 30 ( 35 ( 38 ( 40 ( 50
Program using Tree Traversal (Pre Order)
#include<alloc.h>
struct tree
{
struct tree *left;
int data;
struct tree *right;
};
void main()
{
void preorder();
int d; char ch;
clrscr();
do
{
t->left=NULL;
t->right=NULL;
scanf("%d",&d);
t->data=d;
if(r==NULL)
r=t;
else
{
b=r;
while(b!=NULL)
{
p=b;
b=b->right;
else
b=b->left;
}
p->left=t;
else
p->right=t;
}
ch=getche();
}while(ch=='y');
printf("\nUsing Pre-Order");
preorder(r);
getch();
}
void preorder(p)
struct tree *p;
{
if(p!=NULL)
{
printf("\n%d",p->data);
preorder(p->left);
preorder(p->right);
}
}
Program using Tree Traversal (Post Order)
#include<alloc.h>
struct tree
{
struct tree *left;
int data;
struct tree *right;
};
void main()
{
void postorder();
int d; char ch;
clrscr();
do
{
t->left=NULL;
t->right=NULL;
scanf("%d",&d);
t->data=d;
if(r==NULL)
r=t;
else
{
b=r;
while(b!=NULL)
{
p=b;
b=b->right;
else
b=b->left;
}
p->left=t;
else
p->right=t;
}
ch=getche();
}while(ch=='y');
printf("\nUsing Post-Order");
postorder(r);
getch();
}
void postorder(p)
struct tree *p;
{
if(p!=NULL)
{
postorder(p->left);
postorder(p->right);
}
}
Program using Tree Traversal (In Order)
#include<alloc.h>
struct tree
{
struct tree *left;
int data;
struct tree *right;
};
void main()
{
void inorder();
int d; char ch;
clrscr();
do
{
t->left=NULL;
t->right=NULL;
scanf("%d",&d);
t->data=d;
if(r==NULL)
r=t;
else
{
b=r;
while(b!=NULL)
{
p=b;
b=b->right;
else
b=b->left;
}
p->left=t;
else
p->right=t;
}
ch=getche();
}while(ch=='y');
printf("\nUsing In-Order");
preorder(r);
getch();
}
void inorder(p)
struct tree *p;
{
if(p!=NULL)
{
inorder(p->left);
inorder(p->right);
}
}
We may note that when we traverse a binary search tree in in-order the keys will
be in sorted order because all the keys in the left subtree are less than the k
ey in the root and all the keys in the right subtree are greater than that in th
e root. Therefore, given the entries we can build them into a binary search tree
and use in order traversal to get them in sorted order. This sorting method is
known as tree sort.
Program to delete node from tree
#include<alloc.h>
struct tree
{
struct tree *left;
int data;
struct tree *right;
};
void main()
{
struct tree *p,*r=NULL,*t,*b,*pos=NULL;
int d; char ch;
void preorder();
void delete();
clrscr();
do
{
t->left=NULL;
t->right=NULL;
scanf("%d",&d);
t->data=d;
if(r==NULL)
r=t;
else
{
b=r;
while(b!=NULL)
{
p=b;
b=b->right;
else
b=b->left;
}
p->left=t;
else
p->right=t;
}
ch=getche();
}while(ch=='y');
preorder(r);
printf("\nEnter value to delete := ");
scanf("%d",&d);
b=r;
while(b!=NULL)
{
if(d == b->data)
{
pos=b;
printf("\nData deleted");
break;
}
else
{
if(d > b->data)
{
t=b;
b=b->right;
}
else
{
t=b;
b=b->left;
}
}
}
delete(pos,t);
preorder(r);
getch();
}
void preorder(p)
struct tree *p;
{
if(p!=NULL)
{
preorder(p->left);
preorder(p->right);
}
}
void delete(p,t)
struct tree *p,*t;
{
struct tree *temp;
if(p==NULL)
printf("\nThis data not exist");
else if(p->left==NULL)
{
temp=p;
p=p->right;
if(temp->data < t->data)
t->left=p;
else
t->right=p;
}
else if(p->right==NULL)
{
temp=p;
p=p->left;
if(temp->data < t->data)
t->left=p;
else
t->right=p;
}
else if((p->left!=NULL) && (p->right!=NULL))
{
temp=p->right;
while(temp->left!=NULL)
temp = temp->left;
temp->left = p->left;
temp=p;
p=p->right;
if(p->data < t->data)
t->left=p;
else
t->right=p;
}
free(temp);
}
Application of trees
A binary search tree is an appropriate data structure for searching a value for
applications in which search time must be minimized. A binary tree may also be s
ued for manipulation of arithmetic expressions. Another interesting application
of trees is the construction and maintenance of symbol tables. The trees also pl
ay an important role in the area of syntax analysis. Another interesting applica
tion of trees is in playing of games such as tic-tac-toe, chess, and checkers.
Tree Sort & Heap Sort
We are using two sorting techniques, which are based on tree representation of g
iven array. The first technique is called binary tree sort and the second techni
que called heap sort also involves binary tree but it is must more complex.
Binary tree sort consist of two phases, a construction phase and a traversal pha
se. We scan each element of the input array and place it into its proper positio
n in a binary tree. Once the tree is obtained by putting each input element in i
ts proper position in the tree, it can be traversed in In-order to obtain a sort
ed array. But hit sort required that one tree node be reserved for each array el
ement. Depending upon the method used to implement the tree space may be require
d for tree pointers. The time efficiency for sorted or reverse order input repre
sented the primary drawback of the binary tree sort.
We present second technique using binary tree, which is called heap sort. This s
ort technique has an advantage over binary tree sort that it requires only O(n l
og n) operations regardless of the order of the original data.
Heap sort is based on the heap structure, which is a special type of binary tree
. The heap sort consists of two phases : creation of the heap and processing of
the heap.
A heap of size n is a binary tree of n nodes that satisfies the following two co
nstraints.
The binary tree is almost compete which means there is an integer k such that ev
er leaf of the tree is at lever k or k+1 and if a node has a right descendant at
level k+1 then that node also has a left descendant at level k+1.
The keys in the nodes are arranged such that the contents of each node is less t
han or equal to the contents of its father. Which means for each node info[i] <=
info[j] where j is the father of node i. This condition means that levels of t
he heap are filled left to right and that a node is not placed on a new level un
til the preceding lever is full. All the binary trees are heaps.
Program to implement heap sort for processing and sorting
void main()
{
int arr[10],i=0,no;
void heap();
void sort();
clrscr();
while(i<10)
{
printf("\nEnter Value := ");
scanf("%d",&no);
heap(arr,i,no);
i++;
}
for(i=0;i<10;i++)
{
printf("\n%d",arr[i]);
}
sort(arr);
for(i=0;i<10;i++)
{
printf("\n%d",arr[i]);
}
getch();
}
void heap(int arr[],int i,int no)
{
int s,p;
s=i;
p = (s - 1)/2;
while(s>0 && arr[p] < no)
{
arr[s]= arr[p];
s=p;
p = (s-1)/2;
}
arr[s]=no;
}
void sort(int arr[])
{
int maxnode,i,temp,t=9;
while(t>=0)
{
maxnode=0;
for(i=1;i<=t;i++)
{
if(arr[i] > arr[maxnode])
maxnode = i;
}
temp=arr[t];
arr[t]=arr[maxnode];
arr[maxnode]=temp;
t--;
}
}
Graphs
Trees provide a very useful way of representing relationships in which a hierarc
hy exists. If we remove the restriction that each node may be pointed to by at m
ost one node, we come across another data structure called graphs.
A graph is defined as a set of nodes or vertices and a set of lines or edges or

arcs that connect that the two vertices. The set of vertices is specified by lis
ting the vertices as in a set e.g. {a,b,c,d} and the set of edges is specified a
s a sequence of edges e.g. {(a,b),(b,c),(c,d),(d,a)} each edge is specified by a
pair of vertices that the edge connects as (a,b). if the pairs of vertices that
connect the edges are ordered, the graph is called as directed graph or digraph
. And the direction of the line is indicated by which node is listed first.
Generally a graph defined as G = (V,E)
Where V(G) is a finite, non empty set of vertices or nodes and E(G) is a set of
pairs of vertices each representing an edge.
We may note that the arrow between the vertices represents edges. This arrow ind
icates the direction of the edge. The head of the arrow represents the second ve
rtex in the edge pair and the tail of the arrow represents the first vertex in t
he edge pair.
A graph is completely determined by its set of nodes and set of edges. The actua
l positioning of these points on the page is non important.
The degree of a vertex is the number of edges incident to it. The in degree of a
vertex is the number of edges pointing to that vertex and the out degree of the
vertex is the number of edges pointing from this vertex. For example in above
graph the out degree of node C is 2 and its in degree is one. The degree of the
edge is 3.
A tree is a special case of a directed graph. A graph need not be a tree but a t
ree must be a graph. Also note that a vertex may not necessarily have any edges
associated with it. Node E in graph has no edges associated with it. In graph, a
node, which is not adjacent to any other node, is called an isolated node. For
example node E in graph G3 is an isolated node. A graph containing only isolated
nodes is called a null graph. A null graph contains an empty set of edges.
Graph: - A,B,C,D
Edges :- (A,B), (B,A), (B,C), (C,B), (C,D), (D,C), (A,D), (D,A)
A graph containing a cycle is called as a cyclic graph and a graph, which does n
ot contain a cycle, is called an acyclic graph. A directed graph containing no c
ycle is called as directed acyclic graph or dag in short.
The edge of a graph may carry a value, which may represent some important inform
ation. Such a graph is called as weighed graph, which is used to represent situa
tions where the value of the relation between the vertices is also important alo
ng with the existence of the relation.
Representation of graph
There are three major approaches to represent graphs: - Matrix Representation, L
ist Representation and multi list representation.
Matrix representation of graph
We can either use the adjacency matrix, i.e. a matrix whose rows and columns bot
h represent the vertices. In such a matrix when the i th row and j the column el
ement is 1, we say that there is an edge between i th and j th vertex. When ther
e is no edge the value will be zero.
Matrix representation of above directed graph

A B C D A 0 0 1 0 B 1 0 0 0 C 0 0 0 1 D 0 1 0 0
Matrix representation of above undirected graph

A B C D A 0 1 1 0 B 1 0 0 1 C 1 0 0 1 D 0 1 1 0
Matrix representation of above weighted graph

A B C D A 0 0 8 0 B 5 0 9 0 C 0 0 0 0 D 0 6 0 0
Implementation of Graph
Following steps are involved in implementation of graph.
1) Initialize initialize all the locations to the 0 or false.
2) Join to add an edge into the graph
3) Delete to remove an existing edge from the graph.
Program to implement Directed graph
#define maxnode 4
void main()
{
int graph[maxnode][maxnode];
int r,c;
int choice;
void initialize();
void print();
void join();
void remove();
void adj();
clrscr();
initialize(graph);
while(1)
{
printf("\n\n1.Join \n2.Print \n3.Remove \n4.Clear \n5.Check Adjacency \n6.Ex
it \nchoice := ");
switch(choice)
{
case 1:
printf("\nEnter row and column to join := ");
scanf("%d %d",&r,&c);
join(graph,r,c);
break;
case 2:
print(graph);
break;
case 3:
printf("\nEnter row and column to remove := ");
remove(graph,r,c);
break;
case 4:
clrscr();
break;
case 5:
printf("\nEnter row and column no := ");
scanf("%d%d",&r,&c);
adj(graph,r,c);
break;
case 6:
exit();
default:
printf("\nInvalid choice");
break;
}
}
getch();
}
void initialize(int graph[][maxnode])
{
int i,j;
for(i=0;i<maxnode;i++)
{
for(j=0;j<maxnode;j++)
{
graph[i][j]=0;
}
}
}
void join(int graph[][maxnode],int r,int c)
{
graph[r][c]=1;
}
void remove(int graph[][maxnode],int r,int c)
{
graph[r][c]=0;
}
void print(int graph[][maxnode])
{
int i,j;
{
printf("\n");
{
printf("%d\t",graph[i][j]);
}
}
}
void adj(int graph[][maxnode],int r,int c)
{
if(graph[r][c]==1)
printf("\nPath found");
else
printf("\nPath not found");
}
Program to impliment weighted directed graph
#define maxnode 5
void main()
{
int r,c,wt;
int choice;
void winit();
void wprint();
void wjoin();
void wdelete();
void wadj();
clrscr();
winit(graph);
while(1)
{
printf("\n\n1.Join \n2.Print \n3.Remove \n4.Clear \n5.Check Adjacency \n6.Ex
it \nchoice := ");
switch(choice)
{
case 1:
printf("\nEnter weight to join := ");
scanf("%d",&wt);
wjoin(graph,r,c,wt);
break;
case 2:
wprint(graph);
break;
case 3:
wdelete(graph,r,c);
break;
case 4:
clrscr();
break;
case 5:
printf("\nEnter row and column no := ");
scanf("%d%d",&r,&c);
wadj(graph,r,c);
break;
case 6:
exit();
default:
break;
}
}
getch();
}
void winit(int graph[][maxnode])
{
int i,j;
{
{
graph[i][j]=0;
}
}
}
void wjoin(int graph[][maxnode],int r,int c,int wt)
{
graph[r][c]=wt;
}
void wdelete(int graph[][maxnode],int r,int c)
{
graph[r][c]=0;
}
void wprint(int graph[][maxnode])
{
int i,j;
for(i=0;i<4;i++)
{
printf("\n");
for(j=0;j<4;j++)
{
}
}
}
void wadj(int graph[][maxnode],int r,int c)
{
if(graph[r][c]==0)
printf("\nPath not found");
else
printf("\nPath found of %d weight",graph[r][c]);
}
Prog. to find Degree, Indegree, Outdegree of given vertex and count edges of gr
aph
#define maxnode 4
void main()
{
int r,c,v;
int choice;
void init();
void print();
void join();
void finddeg();
void remove();
void edges();
clrscr();
init(graph);
while(1)
{
printf("\n\n1.Join \n2.Print \n3.Remove \n4.Find Degree \n5.Count Edges \n6.
Exit \nchoice := ");
switch(choice)
{
case 1:
join(graph,r,c);
break;
case 2:
print(graph);
break;
case 3:
remove(graph,r,c);
break;
case 4:
printf("\nEnter vertex no to find degree := ");
scanf("%d",&v);
finddeg(graph,v);
break;
case 5:
edges(graph);
break;
case 6:
exit();
default:
break;
}
}
getch();
}
void init(int graph[][maxnode])
{
int i,j;
{
{
graph[i][j]=0;
}
}
}
{
graph[r][c]=1;
}
void remove(int graph[][maxnode],int r,int c)
{
graph[r][c]=0;
}
{
int i,j;
{
printf("\n");
{
}
}
}
void finddeg(int graph[][maxnode],int v)
{
int deg=0,indeg=0,outdeg=0;
int i,ch;
printf("\n1. In degree \n2. Out degree \n3. Degree \nChoice := ");
scanf("%d",&ch);
switch(ch)
{
case 1:
{
if(graph[i][v]==1)
indeg++;
}
printf("\nIn degree of vertex = %d",indeg);
break;
case 2:
{
if(graph[v][i]==1)
outdeg++;
}
printf("\nOut degree of vertex = %d",outdeg);
break;
case 3:
{
if(graph[i][v]==1)
deg++;
if(graph[v][i]==1)
deg++;
}
printf("\nDegree of the vertex = %d",deg);
break;
default:
break;
}
}
void edges(int graph[][maxnode])
{
int i,j,edg=0;
{
{
if(graph[i][j]==1)
edg++;
}
}
printf("\nTotal edges in graph = %d",edg);
}
Matrix representation of above graph

A B C D E A 0 0 1 1 0 B 0 0 1 0 0 C 0 0 0 1 1 D 0 0 0 0 1 E 0 0 0 1 0
Warshall s algorithm
The warshall s algorithm is used to obtain the path matrix of a simple directed gr
pah. The warshall algorithm to produce a path matrix P for a given adjacency mat
rix A is as follow
Initialize P to A
For(k=0;k<maxnode;k++)
For(i=0;i<maxnode;i++)
For(j=0;j<maxnode;j++)
P ij = P ij || (P ik && P kj)
Return;
Path matrix for above graph using Warshall algorithm
A B C D E A 0 0 1 1 1 B 0 0 1 1 1 C 0 0 0 1 1 D 0 0 0 1 1 E 0 0 0 1 1
Program to find a length of path between two vertices
#define maxnode 5
void main()
{
int r,c; int len;
int choice;
void init();
void print();
void join();
clrscr();
init(graph);
while(1)
{
printf("\n\n1.Join \n2.Print \n3.Find Path \n4.Exit \nchoice := ");
switch(choice)
{
case 1:
join(graph,r,c);
break;
case 2:
print(graph);
break;
case 3:
printf("\nEnter row and column to find ways := ");
len = path(graph,r,c);
if(len!=0)
printf("\nThere is a path from %d to %d of length %d",r,c,len);
else
printf("\nThere is no path from %d to %d",r,c);
break;
case 4:
exit();
default:
break;
}
}
getch();
}
void init(int graph[][maxnode])
{
int i,j;
{
{
graph[i][j]=0;
}
}
}
{
graph[r][c]=1;
}
{
int i,j;
{
printf("\n");
{
}
}
}
path(int graph[][maxnode],int r,int c)
{
int p[maxnode][maxnode];
int i,j,k,len=0;
{
{
p[i][j]=graph[i][j];
}
}
for(k=0;k<maxnode;k++)
{
{
{
p[i][j]=p[i][j] || (p[i][k] && p[k][j]);
}
}
}
for(i=0;i<=c;i++)
{
if(p[r][i]==1)
len++;
}
return(len); }
Matrix representation of above undirected graph

V1 V2 V3 V4 V5 V6 V7 V8 V1 0 1 1 0 0 0 0 0 V2 1 0 0 1 1 0 0 0 V3 1 0 0 0 0 1
1 0 V4 0 1 0 0 0 0 0 1 V5 0 1 0 0 0 0 0 1 V6 0 0 1 0 0 0 0 1 V7 0 0 1 0 0 0
0 1 V8 0 0 0 1 1 1 1 0 Linked representation of above graph (Adjacency List)
Implimentation of graph using linked list
#include<alloc.h>
#include<stdio.h>
#define true 1
#define false 0
#define max 8
int visited[max];
int q[8];
struct node
{
int data;
struct node *next;
};
struct node *newnode;
void main()
{
struct node *arr[max];
struct node *getnode_write(int val);
struct node *v1,*v2,*v3,*v4,*v5,*v6,*v7,*v8;
clrscr();
v1 = getnode_write(1);
arr[0]=v1;
v1->next = v2 = getnode_write(2);
v3->next=NULL;
arr[1]=v2;
v3->next=NULL;
arr[2]=v3;
v7->next=NULL;
arr[3]=v4;
v8->next=NULL;
arr[4]=v5;
v8->next=NULL;
arr[5]=v6;
v8->next=NULL;
arr[6]=v7;
v8->next=NULL;
arr[7]=v8;
v7->next=NULL;
getch();
}
struct node *getnode_write(int val)
{
newnode=(struct node *) malloc (sizeof(struct node));
newnode->data=val;
return newnode;
}
Applications of Graph
Graphs have many properties and they are very important as they will be actually
representing amny practial situations like networks, traveling salesman problem
, transportation problem and so on. The graphs are used in wide variety of appli
cations. Some of these applications are analysis of electrical circuits, project
planning and finding shortest routes. A directed graph is a natural way of desc
ribing, represting and analyzing complex projects which consists of many interre
lated activites. There are a number of management techniques such as PERT(progra
m evaluation and review technique) and CPM(critical path method) which employ gr
aph as the structure on which analysis is based.
Depth First Traversal (Depth First Search)
depth first traversal of an undirected graph is roughtly analogous to preorder t
raversal of an ordered tree. The start vertex V is visited first. Let w1, w2, w3
, w4, be the vertices adjacent to V. then the vertex w1 is visited next. After vi
siting w1 all the vertices adjacent to w1 are visited in depth first manner befo
re returning to traverse w2, ,wk. The search terminates when no unvisited vertiex
can be reached as a recursive algorithm.
A flow chart for recursive depth first traversal is as follow
Use this function at the end of above program for Depth First Search (Traversal)
dfs(int v,struct node **p,int n)
{
struct node *q;
visited[v-1]=true;
printf("%d",v);
q = *(p+v-1);
while(q!=NULL)
{
if(visited[q->data-1] == false)
dfs(q->data,p,n);
else
q=q->next;
} }
Breadth First Traversal
The breadth first traversal differs from the depth first traversal in that all u
nvisited vertices adjacent to v are visited after visiting the starting vertext
v and marking it as visited. Next the unvisited vertices adjacent to these verti
ces are visited and so on until the entire graph have been traversed.
This traversal algorithm uses a queue to store the nodes of each level of the g
raph as and when they are visited. These nodes are then taken one by one and the
ir adjacent nodes are visited and so on until all nodes have benn visited, the a
lgorithm terminates when the queue becomes empty.
Program on Breadth first traversal
#include<alloc.h>
#include<stdio.h>
#define true 1
#define false 0
#define max 8
int visited[max];
int q[8];
int front,rear;
struct node
{
int data;
struct node *next;
};
struct node *newnode;
void main()
{
struct node *arr[max];
struct node *getnode_write(int val);
struct node *v1,*v2,*v3,*v4,*v5,*v6,*v7,*v8;
void bfs();
clrscr();
arr[0]=v1;
v3->next=NULL;
arr[1]=v2;
v3->next=NULL;
arr[2]=v3;
v7->next=NULL;
arr[3]=v4;
v8->next=NULL;
arr[4]=v5;
v8->next=NULL;
arr[5]=v6;
v8->next=NULL;
arr[6]=v7;
v8->next=NULL;
arr[7]=v8;
v7->next=NULL;
clrscr();
front=rear=-1;
bfs(1,arr);
getch();
}
void bfs(int v,struct node **p)
{
struct node *u;
void addqueue();
visited[v-1]=true;
printf("%d",v);
addqueue(v);
while(isempty()==false)
{
v = deletequeue();
u = *(p+v-1);
while(u!=NULL)
{
if(visited[u->data - 1]==false)
{
addqueue(u->data);
visited[u->data-1]=true;
printf("%d",u->data);
}
u=u->next;
}
}
}
void addqueue(int vertex)
{
if(rear==max-1)
{
printf("\nQueue Overflow");
exit();
}
rear++;
q[rear]=vertex;
if(front == -1)
front = 0;
}
deletequeue()
{
int data;
if(front==-1)
{
printf("\nQueue underflow");
exit();
}
data = q[front];
if(front==rear)
front = rear = -1;
else
front++;
return data;
}
isempty()
{
if(front==-1)
return true;
else
return false;
}
struct node *getnode_write(int val)
{
newnode = (struct node *) malloc (sizeof(struct node));
newnode->data=val;
return newnode;
}

Reference Notes Data Stuctures
Ashwath Computers, Solapur Page - PAGE 2
Null Value
INFO.
NEXT
Info.
Info.
Info.
Info.
Ravi
Natasha
Asha
Sunny
Rahul
Honey
Karan
Kush
Sunil
Jaggi
A
A
B
C
A
B
C
D
E
F
G
A
B
C
D
E
F
G
Strictly binary tree
A
B
C
D
E
F
G
Non Strictly binary tree
Complete binary tree
A
B
C
D
E
F
G
10
8
20
5
3
15
35
6
Binary Tree Representation
A
B
C
A
B
F
C
D
H
G
I
J
E
50
38
35
40
25
30
18
17
10
15
20
A
D
C
B
E
G
F
A
B
D
C
6
9
8
5
D
C
B
A
Weighed directed graph
A
B
C
D
A
B
C
D
6
9
8
5
D
C
B
A
V 7
V 6
V 8
V 5
V 4
V 3
V1
V 2
V 1
V2
V3
V2
V1
V4
V5
V4
V8
V8
V3
V7
V8
V3
V6
V8
V2
V5
V8
V2
V4
V6
V1
V3
V5
V7
V6
V7
Yes
No
Yes
No
Return
Perform this routine with this node as first node
Point to the next node on the adjacency list
Is the vertex is already visited ?
Are you at the end of adjacency list ?
Point to the first node into vertex s adjacency list.
Vsisit and mark first vertex of the graph
B
A
C
D
E
!"NO]^jk¥§¨©ÒÓßàõö

7 8 T U b d | Q
m
6
²
µ
ï
ó
´
Ê
Ï
Ð
Ö
×
Ù
Ú
à
á
æ
ç
ó
ô
ú
õçõçõçõçõçõÜõçõÜõçõÜõçõçõçõçõçõçõçõçõçÐÅÐÅõçõçõ¶õ®õ®õ®õ®õ®õ®õ¶õ¶õ®õ®h VëCJ4aJ4h Vëh¡MÃB*CJ
Ö 0ÿÿÿÿÿÿö 6ööÖ
ÿÿÿÖ
ÿÿÿÖ
ÿÿÿÖ
ÿÿÿ4Ö
laö T $$Ifa$ $$Ifa$ $$Ifa$$a$ Õx3y2}ýýý$LNOQ[]ùðdðùð k d¹$$IfT lÖ ÖF
ÿ1ü& Ù
ÿÿÿÖ
ÿÿÿÖ
ÿÿÿÖ
ÿÿÿ4Ö
laö T $$Ifa$$If]^`hjsjdj$If $$Ifa$ k dr$$IfT lÖ ÖF
ÿ1ü& Ù
ÿÿÿÖ
ÿÿÿÖ
ÿÿÿÖ
ÿÿÿ4Ö
laö Tjkmsjdj$If $$Ifa$ k d+$$IfT lÖ ÖF
ÿ1ü& Ù
ÿÿÿÖ
ÿÿÿÖ
ÿÿÿÖ
ÿÿÿ4Ö
laö Tsjdj$If $$Ifa$ k dä$$IfT lÖ ÖF
ÿ1ü& Ù
ÿÿÿÖ
ÿÿÿÖ
ÿÿÿÖ
ÿÿÿ4Ö
laö T¥¨sjdj$If $$Ifa$ k d $ $IfT lÖ ÖF
ÿ1ü& Ù
ÿÿÿÖ
ÿÿÿÖ
ÿÿÿÖ
ÿÿÿ4Ö
laö T¨©«ÏÒsjdj$If $$Ifa$ k dV$$IfT lÖ ÖF
ÿ1ü& Ù
ÿÿÿÖ
ÿÿÿÖ
ÿÿÿÖ
ÿÿÿ4Ö
laö TÒÓÕÜßsjdj$If $$Ifa$ k d$$IfT lÖ ÖF
ÿ1ü& Ù
ÿÿÿÖ
ÿÿÿÖ
ÿÿÿÖ
ÿÿÿ4Ö
laö Tßàâòõsjdj$If $$Ifa$ k dÈ$$IfT lÖ ÖF
ÿ1ü& Ù
ÿÿÿÖ
ÿÿÿÖ
ÿÿÿÖ
ÿÿÿ4Ö
laö Tõöù
sjdj$If $$Ifa$ k d $ $IfT lÖ ÖF
ÿ1ü& Ù
ÿÿÿÖ
ÿÿÿÖ
ÿÿÿÖ
ÿÿÿ4Ö
laö T

sjdj$If $$Ifa$ k d: $$IfT lÖ ÖF ÿ1ü& Ù
ÿÿÿÖ
ÿÿÿÖ
ÿÿÿÖ
ÿÿÿ4Ö
laö T 4 7 sjdj$If $$Ifa$ k dó $$IfT lÖ ÖF ÿ1ü& Ù
ÿÿÿÖ
ÿÿÿÖ
ÿÿÿÖ
ÿÿÿ4Ö
laö T7 8 ; Q T sjdj$If $$Ifa$ k d¬$$IfT lÖ ÖF
ÿ1ü& Ù
ÿÿÿÖ
ÿÿÿÖ
ÿÿÿÖ
ÿÿÿ4Ö
laö TT U X _ b sjdj$If $$Ifa$ k de $$IfT lÖ ÖF ÿ1ü& Ù
Ö0ÿÿÿÿÿÿö 6ööÖ
ÿÿÿÖ
ÿÿÿÖ
ÿÿÿÖ
ÿÿÿ4Ö
laö Tb c | P
Q
m
m
n

/0;snnnnnnlnne$¤ða$$a$ k d
$$IfT lÖ ÖF ÿ1ü& Ù
ÿÿÿÖ
ÿÿÿÖ
ÿÿÿÖ
ÿÿÿ4Ö
laö T
%&,-"/4An / =Jfp ïø¾Ñ¼Ùå%0[ÆÕ3!6!û!"å#ó#%%=%W'j'¿)Ú)Ê*å*ñ*+Ö-×-P.Q.ä/0z0÷0õíõíõÞõÞõÐõÁõÐõÐõ
&
F
Æ Ðh h^ h%<TU~ ²ÈÏäúý1:EHNQk ¡ ¤«¬ºßíïýýýýýýýýýýýýýýýýýýýýýýýýýýýýýïø½¾Ñ»¼Ùåç
!"/0Th ±ÊÒíþ"øööööööööööööööööööööööööööö$¤ða$".DU]bc ¸ÄÆÇÕú!û!"""$"K"]"^"k"l" "¤"¿"À"
####-#:#J#W#[#c#s#}# # #¦#º#Õ#Ö#â#ä#å#ó#$%%%=%I%L%ýýýýýýýýýýýýýýýýýýýýýýýýýýýýýL%{% %¬ %Ä%Å%
&&&&5&9&@&D&[&k&o&v&w& & &¡&¬&³&´&Ä&Ë&ýýýýýýýýýýýýýýýýýýýýýýýýýýýýýË&Ý&è&ï&ð&''+'D'E'S'V'W'
&
Fgd-S& . . .©.ª.½.¾.Ó.ï.ð.ü.þ.$/&/7/8/D/Q/n/u/{/ / /»/Ä/Å/Ï/Ò/à/ó/ýýýýýýýýýýýýýýýýýýýýýýýýý
000(0)080R0b0w0y0z0 0M1³2ð3û3ù5l6 6P7Q7q7¸8þ8ýýýýýýýýýýýýöìììâØØìýýýýý $¤ða$gdÙ.Ù $¤ð
:: : :Í:þ:a< <e>r>A?J? ? ?À@Á@DAEA{A|AJC\C]C^CvE|EFïFõêßêßêßêßÔÉÔÉ»°»°»°»°»°»°»°¡° ° ¡ ° °»
:]: : :Ì:Í:þ:;;;-;.;;;<;e;x;y; ;¡;°;µ;Î;Ý;ë;ð;ý÷÷ýýýýýýýýýýýýýýýýýýýýýýýýý Ð` Ðð;<<<3<Q<R<^
=
===@=S=T= = =¤=ýýýýýýýýýýýýýýýýýýýýýýýýýýýýý¤=©=Ò=ÿ=>>>>P>U>V>b>d>e>r> ?|AOB^C C5DBDaD D¡Dð
fGfjf fgg góg"hÚij:jZjlClòlmym²m¿oÛoIqeqs`s-zCzo{p{=|õçÜÇÜ¿¿¬ÜçÜçÜçÜ ÜçÜ ÜçÜ Ü ÜçÜçÜçÜ Ü Ü
LL"L[LiLrL L¬L¾LÓLÔLúLM#M$M-M@MFMeMwMýýýýýýýýýýýýýýýýýýýýýýýýýýýýýwM}M M M M M±M½M¿MÏMÕMåMü
QQQ.QGQýýýýýýýýýýýýýýýýýýýýýýýýýýýýýGQMQkQ~Q Q Q Q Q©Q±QåQìQôQÿQ RARNRVRxR R R³R´RØRëRÿRSSSS
ff,fAfIfffvfwf f f f¨f¸fÐfåfífþfgg
gg#gAgRgWgXgdgfgýýýýýýýýýýýýýýýýýýýýýýýýýýýýýfggg g¥g±g³gÂgÇg×gðgögh;hHhIhOhThfhnh¢h©h±h¼hÄ
ii5iKi\iýýýýýýýýýýýýýýýýýýýýýýýýýýýýý\ipiqi iï¼i½iÅi×iÜiìiüijj6jFjGjTj\jpjxj j jµj½jÎjÓjÔj
pp@pjpyp pýýýýýýýýýýýýýýýýýýýýýýýýýýýýý p p½pÐpØpêpïpùqp
qFqTqbqsq}q~q q«q°qèqr!r.r3rgr|r}r¡r´rµrýýýýýýýýýýýýýýýýýýýýýýýýýýýýýµrèrör÷rsss&s's7s>sKsX
x"x*xMxYxcxkx x«x¬xÄxØxßxîxyy5yýýýýýýýýýýýýýýýýýýýýýýýýýýýýý5y>yIySyfymy{y y¬y¸y¹yÃyÏyÚyÛyæ
|=|>|h|z| | | | |¶|Æ|à|æ|ç|þ|
}
}A}v}w} } }¤}±}À}Ñ}Ò}ýýýýýýýýýýýýýýýýýýýýýýýýýýýýý=|h|3~O~ã ÿ P ¶ Ë L v Þ û £ $ N L Y
@®®²®Ô®è´ð´õ¶9=aef ù¸¹k» »*ÀVÀ>ÃPÃÊÄãÄ ÆîÆòçòçòçØçòçØçØçòçØçØçòçØçòçÃçòçòçòçòçòçòç
( 7 8 W e z { ¼ Î Ô á ã ä ÿ ýýýýýýýýýýýýýýýýýýýýýýýýýýýýýÿ 0 6 P a | £ ¸ Æ Í
N \ i l § ¶ Ö ä ù ú ( G Y _ ` £ ¤ Ú è ÷ ýýýýýýýýýýýýýýýýýýýýýýýýýýýýý÷
B C R a o } ~ » Ì Ñ Ý ß ø
) / @ [ b £ ¤ ² ýýýýýýýýýýýýýýýýýýýýýýýýýýýýý² ¹ ¿ ä õ ö ) 6 ? E T U [ g s t ¡ ¶ À
¡ ¢ º Ì Í ó ÿ * + 9 : A G U V h q £ ¤ Æ à øööööööööööööööööööööööööööö$¤ða$à á ÷ ø
?øöïïïïïïïïïïïïïïïïïïïèèèèèè
Æ¼
Æ¨
H$¤ða$?@ ®®
®®®®®øøøøééééé$
ÆØ $Ifa$
Æ¼ ® ®"®#®$®%®'®TEEEEE$
ÆØ $Ifa$«kd×
$$IfT lÖr Ö ÿdö èZ`````Ö0ÿÿÿÿÿÿö6ÖÿÿÿÿÿÖÿÿÿÿÿÖÿÿÿÿÿÖÿÿÿÿÿ4Ö
laö T'®(®*®+®,®-®1®TEEEEE$
ÆØ $Ifa$«kd
$ $IfT lÖr
Ö ÿdö èZ`````Ö0ÿÿÿÿÿÿö6ÖÿÿÿÿÿÖÿÿÿÿÿÖÿÿÿÿÿÖÿÿÿÿÿ4Ö
laö T1®2®4®6®8®;®>®TEEEEE$
ÆØ $Ifa$«kdA
$$IfT lÖr
laö T>®?®A®B®C®D®I®TEEEEE$
ÆØ $Ifa$«kdö
laö TI®J®L®M®N®O®V®TEEEEE$
ÆØ $Ifa$«kd«
laö TV®W®Y®Z®[®\®e®TEEEEE$
ÆØ $Ifa$«kd`$$IfT lÖrÖ ÿdö èZ`````Ö0ÿÿÿÿÿÿö6ÖÿÿÿÿÿÖÿÿÿÿÿÖÿÿÿÿÿÖÿÿÿÿÿ4Ö
laö Te®f®h®j®l®n®u®TEEEEE$
ÆØ $Ifa$«kd$$IfT lÖr
laö Tu®v®x®z®|® ® ®TEEEEE$
ÆØ $Ifa$«kdÊ$$IfT lÖr Ö ÿdö èZ`````Ö0ÿÿÿÿÿÿö6ÖÿÿÿÿÿÖÿÿÿÿÿÖÿÿÿÿÿÖÿÿÿÿÿ4Ö
laö T ® ® ® ® ® ® ®TEEEEE$
ÆØ $Ifa$«kd $ $IfT lÖr Ö ÿdö èZ`````Ö0ÿÿÿÿÿÿö6ÖÿÿÿÿÿÖÿÿÿÿÿÖÿÿÿÿÿÖÿÿÿÿÿ4Ö
laö T ® ® ® ® ® ®¤®TEEEEE$
ÆØ $Ifa$«kd4$$IfT lÖr Ö ÿdö èZ`````Ö0ÿÿÿÿÿÿö6ÖÿÿÿÿÿÖÿÿÿÿÿÖÿÿÿÿÿÖÿÿÿÿÿ4Ö
laö T¤®¥®§®ª®®‾®±®TEEEEE$
ÆØ $Ifa$«kdé$$IfT lÖr Ö ÿdö èZ`````Ö0ÿÿÿÿÿÿö6ÖÿÿÿÿÿÖÿÿÿÿÿÖÿÿÿÿÿÖÿÿÿÿÿ4Ö
laö T±®²®³®Ô®æ®ù® ‾‾‾TMMKKKKK
ÆØ «kd $$IfT lÖr
laö ‾T(‾6‾C‾P‾_‾n‾o‾|‾~‾ ‾¤‾§‾¨‾´‾¶‾Î‾Ý‾ë‾ì‾°,°-°L°M°Z°\°|°~° °ýýýýýýýýýýýýýýýýýýýýýýýýýýýýý
¼¼/¼=¼J¼X¼Y¼m¼n¼u¼{¼ýýýýýýýýýýýýýýýýýýýýýýýýýýýýý{¼ ¼ ¼°¼»¼¾¼¿¼Ý¼ñ¼ò¼½½%½3½H½I½P½V½ ½ ½ ½§½
¿¿¿¿-¿?¿F¿H¿ýýýýýýýýýýýýýýýýýýýýýýýýýýýýýH¿X¿s¿u¿v¿ ¿ ¿ ¿¶¿Ç¿Ð¿á¿ã¿ä¿ð¿ÀÀ'À)À*ÀVÀhÀtÀvÀ À À
ÂÂ3Â4Â;ÂAÂLÂtÂ Âýýýýýýýýýýýýýýýýýýýýýýýýýýýýý Â Â Â¢Â£ÂµÂ½ÂØÂáÂéÂêÃÂÃ.Ã;Ã=Ã>ÃPÃ"ÄÉÄÊÄãÄïÄñÄÅ
Æ
Æ Æ2Æ3ÆRÆ`ÆuÆvÆ Æ ÆÅÆêÆðÆñÆþÆýýýýýýýýýýýýýýýýýýýýýýýýýýýýýþÆ ÇÇ"Ç2Ç;ÇLÇdÇmÇ ÇÇÀÇÑÇÝÇïÇøÇÈÈ
òó$ó ó ó®ó¶ô
óôø#ø8øGøÑùÒù ú ú ú ú ú ú¼úÐújûkûlû ûüüõæõØõØõæõØõØõØõØõæõØõØõØõØõÃ³õØõØõØõØõØõØ
ÎÎ+Î,Î8ÎpÎ Î Î Î¡Î‾Î»ÎÃÎÑÎýýýýýýýýýýýýýýýýýýýýýýýýýýýýýÑÎÚÎÛÎéÎêÎöÎÏÏÏ8ÏFÏJÏLÏWÏYÏZÏcÏMÐûÑp
à8àMàNà`àaàvà|à¬à»àÁàÊàÐàãàáýýýýýýýýýýýýýýýýýýýýýýýýýýýýýá
á!á%áTáaámáqá{á á áµá¾áÓáØâáâ#â(â3â<âBâCâSâxâyâ â â â âýýýýýýýýýýýýýýýýýýýýýýýýýýýýý â§â¨â½â
è*è;èHèXèfè}è è èýýýýýýýýýýýýýýýýýýýýýýýýýýýýý è è è²èËèÞèîèðèþèé
é éLé]éké é¤éªééÁéÕéÙéðé÷éê*ê1êDêHêKêýýýýýýýýýýýýýýýýýýýýýýýýýýýýýKêMê`êbênê ê ê ê ê½ê¾êéê
G
O
P
V
W
^
i
p
q
x
y

Ü
ï
8
L

¡
¢
°
±
´
µ
Ç
È
Ë
Ì
Ü
Ý
à
á
æ
ç

õçõçÏçõçõçõçõçõçõÁõÁõçõÁõÁõçõÁõÁõçõçõçõçõ¬õÁõÁõÁõÁõÁõÁõ¬õÁõÁõÁõÁõÁõÁ(jh4^Zh¡MÃCJ4UaJ4mHnHu
:MVjmn ´µÂÄÅ×01SýýýýýýýýýýýýýýýýýýýýýýýýýýýýýSeqs £´ÏÖ×ù
$*[jz{ ª «¸ÅÎÔýýýýýýýýýýýýýýýýýýýýýýýýýýýýýÔ×àóù"2>MSm ¡ÄÒçè ' ( 1 D J b k ýýýýýýýýýýý

+8:;M

>
^

¡
¸
ý ýýýýýýýýýýýýýýýýýýýýøøøýýýý
&
F¸
Ï
ä
å
æ
è
é
ê
ë
ì
í
î
ï
ð
ñ
ò
$
W
©
ª
¬

®
‾
°
±
²
³
´
µ
ýýýýýýýýýýýýýýýýýýýýýýýýýýýýý

!
3
4
7
8
;
<
?
@
C
D
G
H
K
L
O
P
S
T
d
e
h
i
l
m
p
q
t
u
x
y
|
}

ª
«
Ì
Í
Ñ
Ò
Ö
×
Û
Ü
à
á
å
æ
ê
ë
ï
ð
ô
õ
ù
ú

"
#
'
(
,
-
1
2
6
7
;
õ çõçõçõçõçõçõçõçõçõçõçõçõçõçõçõçõçõçõçõçõçõÒõçõçõçõçõçõçõçõçõçõçõçõçõçõçõçõçõçõçõçõ(jh4^Zh¡
¶

¸
¹
º
»
½
þ
@

ª
¼
È
Î
è
ù
' )>`tu ýýýýýýýýýýýýýýýýýýýýýýýýýýýýý;
<
N
O
S
T
X
Y
]
^
b
c
g
h
l
m
q
r
v
w
{
|

ª
" LÊòdeþ- !¦! # #7+s+P. . . . .Ð1Ú1.5/5è7é7\9]9c9f9g9 9 :(:>;?;E;x;‾;°;è;<òçòçòçòçòçòçòçòçòç
$%CD]bde
-?KQk| ª¬Øì"#*0ýýýýýýýýýýýýýýýýýýýýýýýýýýýýý0ap ° ±½¾ËÔÚÝæùÿ
(8DSYs £¦§ÊýýýýýýýýýýýýýýýýýýýýýýýýýýýýýÊØíîÿ+?@I\bz ª ´½ÉÒåêö '9>ýýýýýýýýýýýýýýýýýýýýýýýý
#68M[ «¼ýýýýýýýýýýýýýýýýýýýýýýýýýýýýý¼½Ûèò " / ? @ ^ k u ¶ º Î ë ÿ !!(!9!:!U!b!l!ýý
&
F$¤ða$þ+,,",+,1,2,H,N,l,r,s, , , , ,½,Ã,Ä,Ñ,Ó,õ,÷,-
- ->-D-[-g-ýýýýýýýýýýýýýýýýýýýýýýýýýýýýýg-{- - - -§-©-Å-Õ-Û-ê-..!.5.;.L.e.|. . . . .y/z/{/|
7
7
77^7_7`7a7b7c7d7e7f7g7ýýýýýýýýýýýýýýýýýýýýýýýýýýýýýg7h7i7C8[9\9^9_9`9a9b9c9d9e9f9h9i9j9 9:
; ; ; ; ; ; ;TNNNNN$If«kdS$$IfT lÖr Ö ÿôT´
t`````Ö0ÿÿÿÿÿÿö6ÖÿÿÿÿÿÖÿÿÿÿÿÖÿÿÿÿÿÖÿÿÿÿÿ4Ö
laö T ; ; ; ; ; ; ;TNNNNN$If«kdö$$IfT lÖr Ö ÿôT´
laö T ; ; ; ; ; ;¢;TNNNNN$If«kd $$IfT lÖr Ö ÿôT´
laö T¢;£;¥;§;©;«;;TNNNNN$If«kd<$$IfT lÖr Ö ÿôT´
laö T;®;‾;±;²;³;´;µ;¶;TRKKKKKK$¤xa$«kdß$$IfT lÖr Ö ÿôT´
laö ¶; T ;è;é;ë;í;ï;ñ;ò;øøòòòòòG«kd $ $IfT lÖr Ö ÿôT´
laö T$If$¤xa$ ò; ô;ö;ø;ú;ü;ý;ÿ;<ùùùùùNùù«kd%$$IfT lÖr Ö ÿôT´
laö T$I<f << <
<
<<<ùùùNùùùù«kdÈ$$IfT lÖr Ö ÿôT´
laö T$I<f <<<<<<<ùNùùùùù«kdk$$IfT lÖr Ö ÿôT´
laö T$If <<<!<"<#<$<%<&<TRKKKKKK$¤xa$«kd$$IfT lÖr Ö ÿôT´
laö <T <V< <§<~= = =¦=CæCUJ«JTT TªTôUwVxV°VE]F] ]«^¬^^¾^ï^ e§eWh h j j jújÞkúkSnynÕxÖxØxÙx
h¡MÃCJh<ßjh<ßU(jh4^Zh¡MÃCJ4UaJ4mHnHuh4^Zh¡MÃCJ4aJ4h4^Zh¡MÃ5CJ4\aJ4.jh4^Zh¡MÃ5CJ4U\aJ4mHnHu7&<'<V
laö T$If$¤xa$ `< b<d<f<h<j<k<m<o<ùùùùùNùù«kdT$$IfT lÖr
Ö ÿôT´
laö T$Io< f q<s<u<v<x<z<|<~<ùùùNùùùù«kd÷$$IfT lÖrÖ ÿôT´
laö T$I~<f < < < < < < <ùNùùùùù«kd $ $IfT lÖr
Ö ÿôT´
laö T$If < < <§<à< =H= = =¦=TRRRRRRRR«kd=$$IfT lÖr Ö ÿôT´
laö T ¦=¸=Ä=Æ=ç=ô=>>>.>?>R>b>p>q> > > > >ÿ>??,?2?;?n? ? ?«?¬?ýýýýýýýýýýýýýýýýýýýýýýýýýýýý
A-A9A?AEAFAýýýýýýýýýýýýýýýýýýýýýýýýýýýýýFASAUA{A}A A£AÄÅAÍAÞAæAëAíABB.B0B^B`BsBuB B B¤B¾BÃ
H$H)HFHNH_HgHlHnHýýýýýýýýýýýýýýýýýýýýýýýýýýýýýnHoH£H¥H¹H»H¼HëHíHIII%I'I3IGILIÌwI I I¥IªI¬I
K
KK/K@KTKgKyK K K K K§KKL+L,L?LELýýýýýýýýýýýýýýýýýýýýýýýýýýýýýELNL L L²L¾L¿LÈLÛLçLèLñL&MAMY
NNNýýýýýýýýýýýýýýýýýýýýýýýýýýýýýN%NFNRNXN^NkNmNnN N N N¶N»NØNàNñNùNþNOO-O/OBODOEOsOuO O Oýý
PP0P8P=P?P@PiPkP P P PáPöP÷PQ
QQ0Q6QQQ_Qýýýýýýýýýýýýýýýýýýýýýýýýýýýýý_QeQ Q Q¡QªQÌQÒQíQüQR4R?RHRcRiR R R R«R¶R¼RëRöR÷RSS*
3 S SSSSSÖ0ÿÿÿÿÿÿö6ÖÿÿÿÿÿÿÖÿÿÿÿÿÿÖÿÿÿÿÿÿÖÿÿÿÿÿÿ4Ö
l aö T $$Ifa$QTSTUTWTYT[T]Töööööö $$Ifa$]T^T`TbTdTfThTA88888 $$Ifa$¾kd $ $IfT lÖ
l aö ThTjTkTmToTqTsTö8öööö¾kd6$$IfT lÖ ÿç: à
l aö T $$Ifa$sTuTwTxTzT|T~Töö8ööö¾kdá$$IfT lÖ ÿç: à
l aö T $$Ifa$~T T T T T T Tööö8öö¾kd $ $IfT lÖ ÿç: à
l aö T $$Ifa$ T T T T T Töööö8¾kd7 $$IfT lÖ ÿç: à
l aö T $$Ifa$ T TªTÙaUsU U¤UÁUêUëUóUôU)V*V,V.V0V2V4Vúõõõõõõõõõõõîåååååå $ $Ifa$$¤ða$
l aö T?VAVBVDVFVHVJVö8öööö¾kd !$$IfT lÖ ÿç: à
l aö T $$Ifa$JVLVNVOVQVSVUVöö8ööö¾kd8"$$IfT lÖ ÿç: à
l aö T $$Ifa$UVWVYV[V\V^V`Vööö8öö¾kdã"$$IfT lÖ ÿç: à
l aö T $$Ifa$`VbVdVfVhViVkVöööö8ö¾kd #$$IfT lÖ ÿç: à
l aö T $$Ifa$kVmVoVqVsVuVvVööööö8¾kd9$$$IfT lÖ ÿç: à
l aö T $$Ifa$vVwV°VÂVÎVÐVñW VWW*W<WMW[W\WmWnW{W WÉWâWãWöWüWX8XSXiXuXúõóóóóóóóóóóóóóóóóóóóóóó
ZZZ%Z'Z(ZHZJZVZýýýýýýýýýýýýýýýýýýýýýýýýýýýýýVZpZuZ Z Z«Z³Z¸ZºZ»ZçZéZüZþZÿZ ["[.[H[M[a[~[ [¤
^
^^^^^^^öñöööööööööìöööööööööçööööFf-Ff +FfW( $ $Ifa$^^^^ ^"^#^&^(^*^,^.^0^2^4^6^7^:^<^>^@
u!u7uJuZu[uvu{u uªu«uÁuÊuíuòu
výýýýýýýýýýýýýýýýýýýýýýýýýýýýý
v*vFvKvYvbvgviv v v v v¿vÍvÒvÝvðvwww$w&w4wFwLwpw w w w wýýýýýýýýýýýýýýýýýýýýýýýýýýýýý w‾wÈw
z
z
zz'z(z=z>z@zAzCzDzFzGzIzJzLzMzOzPzRzSzVzWzYzZz]z^zòæàÜØÜÑÜÑÜÑÜÑÜÑÜÑÜÑÜÑÜÑÜÑÜÑÜÑÜÑÜÑÜÑÜÑÜÑÜÑ
h¡MÃ5 \ h<ßh¡MÃ
h¡MÃCJjh¡MÃ0JCJUhæa 0 JCJmHnHuR y y y y y y y y y¥y¦y¬yy‾y°y²y³yµy¶y¸y¹y»y¼y¾y¿yÁyÂyÄyÅyÇyýýý
z
z
zz'z(z=z>z@zAzCzDzFzGzIzJzLzMzOzPzRzSzVzWzYzýýýýýýýøýøýýýýýýýýýýýýýýýóýý$a$$a$YzZz]z^z`zazc
h¡MÃ5 \ U z z¢z£z¥z¦z¨z©z«z¬z®z‾z±z²zµz¶z¹zºz½z¾zÁzÂzÅzÆzÉzÊzÍzÎzÑzÒzýýýýýýýýýýýýýýýýýýýýýý
{
{
{{{{{{{{.{/{1{2{4{5{7{8{:{;{={>{úøúøúøúøúøúøúøúøöøúøúøúøúøúø$a$>{@{A{C{D{F{G{I{J{L{M{O{P{R{
Ð$$If !vh5Ö 5 ÖË5Ö #v # vË#v :V
l Ö0ÿÿÿÿÿÿö 6 ö,Ö5ÖÙ5Ö
5Ö 4Ö T$$If !vh5Ö 5 ÖË5Ö #v #vË#v :V
5Ö 4Ö T³$$If !vh5ÖÐ5Ö 5 Ö 5Ö`5Ör #vÐ#v # v`#vr :V
lÖ0ÿÿÿÿÿÿö6ö5Ö`4Ö T³$$If ! vh5ÖÐ5Ö 5 Ö 5 Ö`5Ör #vÐ#v # v`#vr :V
lÖ0ÿÿÿÿÿÿö6ö5Ö`4Ö T¡$$If ! vh5Ö`5Ö`5Ö`5Ö`5Ö`#v`:V
lÖ0ÿÿÿÿÿÿö6ö5Ö`4Ö T©$$If ! vh5ÖS5ÖS5ÖS5ÖS5ÖS5ÖS#vS:V
lÖ0ÿÿÿÿÿÿö6ö5ÖS4Ö T©$$If ! vh5ÖS5ÖS5ÖS5ÖS5ÖS5ÖS#vS:V
lÖ0ÿÿÿÿÿÿö6ö5ÖS4Ö TÁ$$If ! v h5ÖT5ÖT5ÖT5ÖT5ÖT5ÖT5Ö T5ÖT5Ö T#v T:V
lÖ0ÿÿÿÿÿÿö6ö5Ö S4Ö Tëkdä$$$IfT lÖÊ
Ö ÿè< ä
8 à 4 SSSSSSSSSÖ0ÿÿÿÿÿÿö6Ö$ÿÿÿÿÿÿÿÿÿÖ$ÿÿÿÿÿÿÿÿÿÖ$ÿÿÿÿÿÿÿÿÿÖ$ÿÿÿÿÿÿÿÿÿ4Ö
l aö TÁ$$If ! v h5ÖT5ÖT5ÖT5ÖT5ÖT5ÖT5Ö T5ÖT5Ö T#v T:V
lÖ0ÿÿÿÿÿÿö6ö5Ö S4Ö Tëkd '$$IfT lÖÊ
Ö ÿè< ä
lÖ0ÿÿÿÿÿÿö6ö5Ö S4Ö TëkdD*$$IfT lÖÊ
Ö ÿè< ä
lÖ0ÿÿÿÿÿÿö6ö5Ö S4Ö Tëkdô,$$IfT lÖÊ
Ö ÿè< ä
lÖ0ÿÿÿÿÿÿö6ö5Ö S4Ö Tëkd¤/$$IfT lÖÊ
Ö ÿè< ä
lÖ0ÿÿÿÿÿÿö6ö5Ö S4Ö TëkdT2$$IfT lÖÊ
Ö ÿè< ä
lÖ0ÿÿÿÿÿÿö6ö5Ö S4Ö Tëkd5$$IfT lÖÊ
Ö ÿè< ä
lÖ0ÿÿÿÿÿÿö6ö5Ö S4Ö Tëkd´7$$IfT lÖÊ
Ö ÿè< ä
lÖ0ÿÿÿÿÿÿö6ö5Ö S4Ö Tëkdd:$$IfT lÖÊ
Ö ÿè< ä
l aö T @ @ñÿ@
NormalCJ_HaJmH sH tH @@@
Heading 1$$@&a$5\D@D
Heading 2$$@&a$
5CJ\>@>
Heading $3@&
5 CJ\D@D
Heading 4$$@&a$
5CJ\D@D
Heading 5$$@&a$
5CJ\DA@òÿ¡D
Default Paragraph FontVi@óÿ³V

Table Normal :V
ö4Ö4Ö
laö
(kôÿÁ( No List
4B@ò4
Body Tex$ta$8P@8

Body Text $2a$4@4
Header

ÆàÀ!4 @"4
Footer

ÆàÀ!.)@¢1.

Page Number6>@B6
Titl$ea$
5CJ$\
'.5;DJQX_flsz} ¡¤§ª°ÆÉÌÏÒÕØÛõ
$'+.159<X[âdgjmpsvy| £ §«®±´º½ÀÃÆÉÌÏÒÕØÛÞáäüÿ
#&),16;@EJNSX\`dhlptx| ¤¨¬°´¸¼ÀÄÉÍÒÖÞ?d Ãîñô÷úýþ3uÿÿÿÿ ÿÿÿÿiÿÿÿÿjÿÿÿÿnÿÿÿÿrÿÿÿÿvÿÿ
ÿÿÿÿ
ÿÿÿÿ ÿÿÿÿÿÿÿÿÊÿÿÿÿÉÿÿÿÿÈÿÿÿÿÇÿÿÿÿÆÿÿÿÿÅÿÿÿÿ[ÿÿÿÿÄÿÿÿÿÃÿÿÿÿ_ÿÿÿÿbÿÿÿÿeÿÿÿÿhÿÿÿÿkÿÿÿÿúÿÿÿ
ÿÿÿÿdÿÿÿÿcÿÿÿÿ[ÿÿÿÿZÿÿÿÿWÿÿÿÿVÿÿÿÿUÿÿÿÿTÿÿÿÿSÿÿÿÿRÿÿÿÿQÿÿÿÿ?ÿÿÿÿ@ÿÿÿÿAÿÿÿÿBÿÿÿÿCÿÿÿÿÿÿÿÿ
'.5;DJQX_flsz} ¡¤§ª°ÆÉÌÏÒÕØÛõ
$'+.159<X[âdgjmpsvy| £ §«®±´º½ÀÃÆÉÌÏÒÕØÛÞáäüÿ
#&),16;@EJNSX\`dhlptx| ¤¨¬°´¸¼ÀÄÉÍÒÖÞ?d Ãîñô÷úýþ

!"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_àbcdefghijklmnopqrstuvwxyz

478;QTUX_bc|PQmmn / 0;r s ¥ m n À Ô Õ ã

B
Y
Z
o
u

É
Ñ
Û
ä
ê
ë
ø

,
.
/
=
¤
I
J
f
®
Á pq Í ñò%<TU~ ²ÈÏäúý1:EHNQk ¡ ¤«¬ºßíïø½¾Ñ»¼Ùåç
!"/0Th ±ÊÒíþ".DU]bc ¸ÄÆÇÕúû"$K]^kl ¤¿ÀÔÙä
&59@D[kovw ¡¬³´ÄËÝèïð+DESVWj^!_!k!m! ! ! !¥!¦!º!Ö!×!"""0"5"J"R"d"q"y" " " "£"«"°"±"Å"á"â"î
((((()(8(R(b(w(y(z( (M)³*ð+û+ù-l. .P/Q/q/¸0þ011.1
2]2 2 2Ì2Í2þ2333-3.3;3<3e3x3y3 3¡3°3µ3Î3Ý3ë3ð344434Q4R4^4`4a4 4«44¹4Ê4Ï4ä4ó4û4ü4
5
555@5S5T5 5 5¤5©5Ò5ÿ56666P6U6V6b6d6e6r6 7|9O:^; ;5<B<a< <¡<ð< =v=£=ï>ð>?{@eBgBhBiB BÙBÚBÛBÜ
DD"D[DiDrD D¬D¾DÓDÔDúDE#E$E-E@EFEeEwE}E E E E E±E½E¿EÏEÕEåEüEF(F/F0FLFYFgFhFoFuF F FÆFÐFÙFå
III.IGIMIkI~I I I I I©I±IåIìIôIÿI JAJNJVJxJ J J³J´JØJëJÿJKKKK=KNKSKTK K K KÏKÝKëKìKôKüKLL1LB
?PNPSPcP|P P£P¾PËPÌPÒP×PéPñP%Q,Q4Q?QGQ Q Q Q¸QÎQßQóQôQR+R?R@RHRZR_R}R R R RÅRÚRÛRÿRSSFSTSUS
LVjV{V V VªV½V¾VÆVØVÝVòVúVW WW'W+W2W6WLWZW^WfWqW W W W W¢W§WÅWÖWÛWÜWèWêWëWX#X/X1X@XEXUX
[a[f[g[s[ [ [¡[£[¤[Ê[Ü[è[ê[ù[þ[\'\-\S\k\x\y\ \ \ \ \Ò\Ù\á\ì\ô\.];]C]e]{] ] ]¡]Å]Ø]ì]í]õ] ^
^^,ÂÎ^f^v^w^ ^ ^ ^¨^¸^Ð^å^í^þ^__
__#_A_R_W_X_d_f_g_ _¥_±_³_Â_Ç_×_ð_ö_`;`HÌÒ`T`f`n`¢`©`±`¼`Ä`þ`
aa5aKa\apaqa aä¼a½aÅa×aÜaìaüabb6bFbGbTb\bpbxb b bµb½bÎbÓbÔbÜbîbóbc"c'c(cScfcgcoc c c¼cÍcãc
+g2gBgvg g¼gÊgØgàgêgëgûg
hh@hjhyh h h½hÐhØhêhïhùi
h
iFiTibisi}i~i i«i°ièij!j.j3jgj|j}j¡j´jµjèjöj÷jkkk&k'k7k>kKkXkkk k k k£k¨k²k³kÄkákëkòkþkÿk
o6oMoWodojo{o o o o o¶oÅoËoÒoÜoìoóoÿop
p"p*pMpYpcpkp p«p¬pÄpØpßpîpqq5q>qIqSqfqmq{q q¬q¸q¹qÃqÏqÚqÛqæqrrrr+r-r.rCrÖrosqsrssstssâs
t=t>thtzt t t t t¶tÆtàtætçtþt
u
uAuvuwu u u¤u±uÀuÑuÒuÚuìuñuv v%v&v2v5v6vOvavmvov v v v±vÌvÓvóv www#w0w3whwxw w w w w wÏwÝwê
xx(x7x8xWxexzx{x x x x¼xÎxÔxáxãxäxÿxyyy0y6yPyay|y y£yy¸yÆyÍyÓyàyãyz(z0z3z9z<zDz z z z z»zÌ
~~N~\~i~l~ ~ ~§~¶~~Ö~ä~ù~ú~ ( G Y _ ` £ ¤ Ú è ÷ " 5 ; Z l r s £ µ Á Ã Ô Ú
B C R a o } ~ » Ì Ñ Ý ß ø
) / @ [ b £ ¤ ² ¹ ¿ ä õ ö ) 6 ? E T U [ g s t ¡ ¶ À Ð Ö õ & ( ) 1
¡ ¢ º Ì Í ó ÿ * + 9 : A G U V h q £ ¤ Æ à á ÷ ø . C D g x y ¢ ¦ È Ô Ø Ù ô ý þ
¥?¥@¥ ¥¦¦
¦¦¦¦¦ ¦"¦#¦$¦%¦'¦(¦*¦+¦,¦-¦1¦2¦4¦6¦8¦;¦>¦?¦A¦B¦C¦D¦I¦J¦L¦M¦N¦O¦V¦W¦Y¦Z¦[¦\¦e¦f¦h¦j¦l¦n¦u¦v¦
´´/´=´J´XÝ´mńú´{´ ´ ´°´»´¾´¿´Ý´ñ´ò´µµ%µ3µHµIµPµVµ µ µ µ§µ±µ²µÌµÕµôµþµ ¶#¶$¶@¶A¶V¶W¶d¶f¶g
-?FHXsuv ¶ÇÐáãäð¸¸'¸)¸*¸V¸h¸t¸v¸ ¸ ¸ ¸«¸²¸³¸Ò¸è¸é¸÷¸ø¸ÿ¸¹(¹?¹@¹w¹ ¹
ºº3º4º;ºAºLºtº º º º¢º£ºµº½ºØºáºéºê»
º».»;»=»>»P»"¼É¼Ê¼ã¼ï¼ñ¼½=½J½K½Y½`½f½o½~½ ½ ½¨½«½¬½É½Ý½Þ
¾
¾ ¾2¾3¾R¾`¾u¾v¾ ¾ ¾Å¾ê¾ð¾ñ¾þ¾ ¿¿"¿2¿;¿L¿d¿m¿ ¿¿À¿Ñ¿Ý¿ï¿ø¿ÀÀ3À;ÀDÀPÀVÀ\À]ÀdÀjÀ À¤À¥À¸ÀÁÀÂÀä
ÆÆ+Æ,Æ8ÆpÆ Æ Æ Æ¡Æ‾Æ»ÆÃÆÑÆÚÆÛÆéÆêÆöÆÇÇÇ8ÇFÇJÇLÇWÇYÇZÇcÇMÈûÉpË Ì ÌÇÌÓÌÕÌïÌýÌþÌÍ%Í&Í/Í?ÍEÍiÍ
Ø8ØMØNØ`ØaØvØ|Ø¬Ø»ØÁØÊØÐØãØÙ
Ù!Ù%ÙTÙaÙmÙqÙ{Ù Ù ÙµÙ¾ÙÓÙØÚÙÚ#Ú(Ú3Ú<ÚBÚCÚSÚxÚyÚ Ú Ú Ú Ú§Ú¨Ú½Ú¾ÚÏÚÑÚÒÚõÚÇÜÈÜÚÜìÜøÜúÜÝÝÝÝ6Ý7ÝM
à*à;àHàXàfà}à à à à à²àËàÞàîàðàþàá
á áLá]áká á¤áªááÁáÕáÙáðá÷áâ*â1âDâHâKâMâ`âbânâ â â â â½â¾âéâlãmãµã¶ãÖã ä ä¼ä½äääÒåÓå-æBæ?çÏ
úú ú:úMúVújúmúnú ú ú´úµúÂúÄúÅú×ú0ü1üSüeüqüsü ü ü£ü´üÏüÖü×üùü
ýýýý$ý*ý[ýjýzý{ý ýªý«ýý¸ýÅýÎýÔý×ýàýóýùýþ"þ2þ>þMþSþmþ þ þ þ þ¡þÄþÒþçþèþÿ'ÿ(ÿ1ÿDÿJÿbÿkÿ ÿ ÿ

+8:;M>^ ¡¸Ïäåæèéêëìíîïðñò$W©ª¬®‾°±²³´µ¶¸¹º»½þ@ ª¼ÈÎèù')>`tu ÂÑáâ , 5 ; > G Z `

&
'
.
4
e
t

£
´
µ
Á
Â
Ï
Ø
Þ
á
ê
ý

,
<
H
W
]
w

§
ª
«
Î
Ü
ñ
ò

&
3
5
G
W
Y
h
m

£
¤
Â
Ç
É
Ê
ò

0
A
\
c
o
q

§
»
¼
Ê
Ë
Ò
Ø
()GXYefs| ¡ §³Ðàìû.7KNOr ¶ ÇÔÖæöø
$%CD]bde
-?KQk| ª¬Øì"#*0ap °±½¾ËÔÚÝæùÿ
(8DSYs £¦§ÊØíîÿ+?@I\bz ª´½ÉÒåêö ' 9>GMàr ¢ ¤³¸Ö×ðñ
#68M[ «¼½Ûèò"/?@^ku ¶ ºÎëÿ(9:Ublz~ ¦ îÍw Ò µ!6#7#s# # # #ª#»#É#Ê#Ú#à#þ#$$"$+$1$2$H$N
% %>%D%[%g%{% % % %§%©%Å%Õ%Û%ê%&&!&5&;&L&e&|& & & & &y'z'{'|'}'~' ' ' ' ' ' ' ' ' '³)Ú)X*V+
/
/
//^/_/`/a/b/c/d/e/f/g/h/i/C0[1\1^1_1`1a1b1c1d1e1f1h1i1j1 12 2(2=3>3@3A3B3C3D3E3F3G3H3I3x3y3
4
444444444444!4"4#4$4%4&4'4V4W4Y4[4]4_4`4b4d4f4h4j4k4m4o4q4s4u4v4x4z4|4~4 4 4 4 4 4 4 4 4 4§
9-999?9E9F9S9U9{9}9 9£9¨9Å9Í9Þ9æ9ë9í9::.:0:^:`:s:u: : :¤:¾:Ã:×:ô:ü:;";';);T;V;l; ; ;´;¶;;æ
@$@)@F@N@_@g@l@n@o@£@¥@¹@»@¼@ë@í@AAA%A'A3AGALAÀwA A A¥AªA¬AAÙAÛAñABBRBTBUBVB«B½BÉBËBìBûB
C
CC/C@CTCgCyC C C C C§CCD+D,D?DEDND D D²D¾D¿DÈDÛDçDèDñD&EAEYEeEfEoE¤E¹EÐEÜEÝEæEøEFF
FF%FFFRFXF^FkFmFnF F F F¶F»FØFàFñFùFþFGG-G/GBGDGEGsGuG G G G¬G®GºGÔGÙGíG
HH0H8H=H?H@HiHkH H H HáHöH÷HI
II0I6IQI_IeI I I¡IªIÌIÒIíIüIJ4J?JHJcJiJ J J J«J¶J¼JëJöJ÷JKK*K0K2K3KTKVKiK K K¨K±KÇKÔKÝKãKLL
RRR%R'R(RHRJRVRpRuR R R«R³R¸RºR»RçRéRüRþRÿR S"S.SHSMSaS~S S¤S¬S±S³S´SÛSÝSúSTT+T1TOTXTpTyT T
V
VVVVVVVVVV V"V#V&V(V*V,V.V0V2V4V6V7V:V<V>V@VBVDVFVHVJVKVNVPVRVTVVVXVZV\V^V_VbVdVfVhVjVlVnVp
m!m7mJmZm[mvm{m mªm«mÁmÊmímòm
n*nFnKnYnbngnin n n n n¿nÍnÒnÝnðnooo$o&o4oFoLopo o o o o‾oÈoÑoàoáoòoôoþopp&p/pDpFpjplp¨p¿pÓ
r
r
rr'r(r=r>r@rArCrDrFrGrIrJrLrMrOrPrRrSrVrWrYrZr]r^r`rarcrdrgrhrkrlrnror r r r r r r r r r r
s
s
ssssssss.s/s1s2s4s5s7s8s:s;s=s>s@sAsCsDsFsGsIsJsLsMsOsPsRsSsUsVsXsYs[s\s^s_scsdshsismsnsrss
0 y 0 y 0 y 0 y 0 y 0 y 0 y 0 y 0 y 0 y 0 y 0 y 0 y 0 y 0 y 0 y 0 y 0 y
0 y 0 y 0 y 0 y 0 y 0 y 0 y 0 y 0 y 0 y 0 y ¡0 y Ð ¡0 y Ð ¡0 y Ð ¡0 y Ð ¡0 y Ð
ò 0 I 0
ò 0 I 0 ò 0 I 0 ò 0 I 0 ò 0 I 0ò 0 I 0ò 0 I 0ò 0 I 0ò 0 I 0ò 0 øI 0ò 0 I 0 !ò 0 I
Ì 0 I 0
Ì 0 I 0 Ì 0 I 0 Ì 0 I 0 Ì 0 I 0 Ì 0 I 0 Ì 0 I 0©Ì 0 I 0 «Ì 0 øI 0Ì 0 I 0‾
0 I 0 á
0 I 0 á 0 I 0 á 0 I 0 á 0 I 0 á 0 I 0 á 0 I 0 ñ 0 I 0 ñ 0 I 0 ñ 0 I 0 ñ 0 I 0 ñ 0
0 I 0 ñ
0 I 0
0 I 0
0 I 0
0 I 0
0 I 0

0 I 0
1 0 I 0
/ 0 I 0
- 0 I 0
+ 0 I 0
) 0 I 0
' 0 I 0
% 0 I 0
# 0 I 0
! 0 I 0
0 I 0
0 I 0
0 I 0
0 I 0
0 I 0
0 I 0
0 I 0

0 I 0

0 I 0
0 I 0
0 I 0 5
0 I 0 7
0 I 0 9 0 I 0 9 0 I 0 9 0 I 0 9 0 I 0 9 0 I 0 9 0 I 0 9 0 I 0 9 0 I 0 9 0 I 0 9
0 I 0 9
0 I 0 ñ 0 I 0 ó 0 I 0 õ 0 I 0 ÷ 0 I 0 ù 0 I 0 I 0 |X

..]]]` ÷0ïF=|îÆü
;
< .y^z3}¿ÐÜáþ0BIKg ¡ $]j¨Òßõ
7 T b ;ä%ï"Ô"L%Ë&0* .ó/þ8ð;¤=vE KwMîNGQSÐT¨VcXZZù[»]6_`
µ
+ÉHÊ| 0Ê>¼l!þ+g-~/g7E; ; ; ;¢;;¶;ò;<<<&<`<o<~< <¦=¬?FAüBÆDüFnHJELN O_Q2SFTQT]ThTsT~T T T4
v wáx yÇyzYz zÒzÿz>{n{«{æ{õ|3}ÀÂÃÄÅÆÇÈÉÊËÌÍÎÏÑÒÓÔÕÖ×ØÙÚÛÝÞßàâãäåæçèéêëìíîïðñòóôõö÷øùúûüýÿ

!"#$%&'()*+,-./123456789:;<=>?@ACDEFGHJLMNOPQRSTUVWXYZ[\]^_àbcdefhijklmnopqrstuvwxyz{|}~
ðì ðb ð 0*!*$6
ðf
ð # "ñ
ð ðð`¢
gð
C
ð g ¿ðÿ 0 *¸ +ð
ðð ` ¢
hð
C
ð h¿ðÿph.¨
Ð/ð
ð ð `¢
ið
C
ð
i¿ðÿN
¼4 $6ð
ð
ð `¢
jð
C
ð
j¿ðÿ 81Ø 2ð
ð
ð `¢
kð
C
ð
k¿ðÿ(#Y.`'Á/ð
ð
ð`¢
lð
C
ð
l¿ðÿô
81, 2ð
ð
ð `¢
mð
C
ð m ¿ðÿS . î /ð
ðð`¢
nð
C
ð n ¿ðÿq)1© 2ð
ðð`¢
oð
C
ð o ¿ðÿé%V1!*¾2ð
ðð`¢
pð
C
ð p ¿ðÿ<e1t"Í2ð
ððZB
ðqB
S
ðD ¿Ñÿð@
+ h .ððZB
ðr
S
ðD ¿Ñÿðè +è/ððZB
ðs
S
ðD ¿ÑÿðP+Ü#h.ððZB
ðt
S
ðD ¿Ñÿð
Ð/\
81ððZB
ðuB
S
ðD ¿Ñÿð¼ Ð/
81ððZB
ðv
S
ðD ¿ÑÿðèÐ/è81ððZB
ðw
S
ðD ¿Ñÿð§
2§
¼4ððZB
ðxB
S
ðD ¿Ñÿð¤Ð/ $ì1ððZB
ðy
S
ðD ¿Ñÿð $Ð/`'ì1ððH2
ð{
#
ð
ðð
ððH2
ð|
#
ð
ðð
ððH2
ð}
#
ð
ð
ð
ððH2
ð~
#
ð
ð ð
ððzðT ðÏ0H'K<
ðÖ#"ñ
ð ððZ2
ð
3
ð ð Ï0 "ë2ð
ððZ2
ð
3
ð ðÔ 3ð»5ð
ððZ2
ð
3
ð ðÔ" 3ð$»5ð
ððZ2
ð
3
ð ðo6 8ð
ððZ2
ð
3
ð ð o6 " 8ð
ððZ2
ð
3
ð ð,%ç6H'9ð
ððZ2
ð
3
ð ðñ#/:
&K<ð
ðð`B
ð
c
ð$D ¿Ñÿ ð! 2#ù3ðð`B
ð
c
ð$D ¿Ñÿ ð´$ 5¤%#7ðð`B
ðB
c
ð$D ¿Ñÿ ðJ%Ö8þ%>:ðð`B
ðB
c
ð$D ¿Ñÿ ðØd2@ Ì3ðð`B
ðB
c
ð$D ¿Ñÿ ða5É6ðð`B
ð
c
ð$D ¿Ñÿ ðR5m º6ððTB
ð
c
ð$D ¿Ñÿ ððTB
ð@
c
ð$D ¿Ñÿ ð ðð,
ðN ðD
¤ &´-
ð
ð ð
ðð ð` ð$ ¤°±-
ð#
ð
ðD
¤Ð±-ððT2
ð
#
ð
ðÄ¤àÀ!ð
ððT2
ð
#
ð
ðô
t" $ð
ððT2
ð
#
ð
ð t"° $ð
ððT2
ð
#
ð
ð$ D%@
`'ð
ð ðT2
ð
#
ð
! ðÄD%à`'ð
ð!ðT2
ð
#
ð
" ðàÈ(üä*ð
ð"ðT2
ð
#
ð
# ð¨
È(Ää*ð
ð#ðZB
ð
S
ðD ¿Ñÿðwf!ßÎ"ððZB
ðB
S
ðD ¿Ñÿð
9!¡"ððZB
ð B
S
ðD ¿Ñÿð×
6$?
%ððZB
ð
S
ðD ¿ÑÿðÅ
'$- %ððZB
ð
S
ðD ¿Ñÿð,`' È (ððZB
ðB
S
ðD ¿Ñÿð`'xÈ(ððZ¢
ð
3
ð $ ¿ðÿÕ +°±-ð
ð$ð,ðt ð ¤ %´-
ð#
ð
#"ñ
ð ¼¤ &´-ððFðn ðè&
ð
ð # " ñ
ð ¤ % +ððT2
ð
#
ð
% ð¤À!*ð
ð%ðT2
ð¡
#
ð
& ¡ðÔÞðúð
ð&ðT2
ð¢
#
ð
' ¢ðt"Þ $úð
ð'ðT2
ð£
#
ð
( £ð® Êð
ð(ðT2
ð¤
#
ð
) ¤ð¤®À!Êð
ð)ðT2
ð¥
#
ð
* ¥ðÌ$&è&Bð
ð*ðT2
ð¦
#
ð
+ ¦ð #n% ð
ð+ðZB
ð§
S
ðD ¿ÑÿðW!Ð¿"8ððZB
ð¨
S
ðD ¿ÑÿðT$¾D%bððZB
ð©B
S
ðD ¿Ñÿðê$ %}ððZB
ðªB
S
ðD ¿Ñÿðx£à
ððZB
ð«B
S
ðD ¿Ñÿðð ðZB
ð¬
S
ðD ¿Ñÿð¥
ùððZ¢
ð
3
ð , ¿ðÿ +D%´-ð
ð,ððb ð\
Ð/PY:
ð®
ð # "ñ
ð
ððZ¢
‾ð
3
ð - ¿ðÿÄ@8 Y:ð
ð-ðFðn ð, 0 ô8
ð°
ð # "ñ
ð \
Ð/P@8ððT2
ð±
#
ð
. ±ð 04 2ð
ð.ðT2
ð²
#
ð
/ ²ðHT3dp5ð
ð/ðT2
ð³
#
ð
0 ³ðèT3p5ð
ð0ðT2
ð´
#
ð
1 ´ð,Ø6Hô8ð
ð1ðT2
ðµ
#
ð
2 µð°Ø6Ìô8ð
ð2ðT2
ð¶
#
ð
3 ¶ð Ø 6ºô8ð
ð3ðT2
ð
#
ð
4 ðØ6 ô8ð
ð4ðZB
ð¸
S
ðD ¿ÑÿðËF23®3ððZB
ð¹B
S
ðD ¿Ñÿðì2T 3ððZB
ðºB
S
ðD ¿Ñÿð p5üØ6ððZB
ð»
S
ðD ¿Ñÿð°p5dØ6ððZB
ð¼B
S
ðD ¿Ñÿðèp5 Ø 6ððZB
ð½
S
ðD ¿ÑÿðPp5¸Ø6ððZðb ð
Ä=Å
ð¾
ð # "ñ
ð
ððT2
ð¿
#
ð
5 ¿ð°Ä àð
ð5ðT2
ðÀ
#
ð
6 Àð¤²ÀÎð
ð6ðT2
ðÁ
#
ð
7 ÁðR " °ð
ð7ðT2
ðÂ
#
ð
8 Âð 6 Rð
ð8ðT2
ðÃ
#
ð
9 Ãð
¥Áð
ð9ðT2
ðÄ
#
ð
: Äðc34ð
ð:ðT2
ðÅ
#
ð
; Åðmë= ð
ð;ðT2
ðÆ
#
ð
< ÆðI e £ð
ð<ðZB
ðÇ
S
ðD ¿ÑÿðSh»ÐððZB
ðÈB
S
ðD ¿Ñÿð ûýððZB
ðÉB
S
ðD ¿Ñÿð4°èððZB
ðÊ
S
ðD ¿Ñÿð¹t!ÜððZB
ðË
S
ðD ¿Ñÿð;=£¥ððZB
ðÌB
S
ðD ¿ÑÿððÎX6ððZB
ðÍB
S
ðD ¿Ñÿðk
=Ó¥ððZ¢
Îð
3
ð = ¿ðÿu©Åð
ð=ð<ðb ðüü0l$6
ðÏ
ð # "ñ
ð ððN2
ðÐ

ð > ðSü0«Ü2ð
ð>ðT2
ðÑ
#
ð
? Ñð4ü$6ð
ð?ðT2
ðÒ
#
ð
@ Òð4Pl$6ð
ð@ðZB
ðÓ
S
ðD ¿Ñÿð`Ü2ÈD4ððZB
ðÔB
S
ðD ¿Ñÿðd 24 ððt ðb ð$Ôà)ð
ðÕ
ð # "ñ
ð ððT2
ðÖ
#
ð
A Öð<ÔX ðð
ðAðT2
ð×
#
ð
B ×ðô 8 ð
ðBðT2
ðØ
#
ð
C Øð(#TD%pð
ðCðT2
ðÙ
#
ð
D Ùð$ì @
ð
ðDðT2
ðÚ
#
ð
E ÚðÄì à
ð
ðEðT2
ðÛ
#
ð
F Ûð % '¸
ð
ðFðT2
ðÜ
#
ð
G Üð
!Ø (#ô
ð
ðGðZB
ðÝ
S
ðD ¿Ñÿ%ð4ø%Ø ððZB
ðÞ
S
ðD ¿Ñÿð'¤
x(À
ððZB
ðßB
S
ðD ¿Ñÿð×Þ?F
ððZB
ðà
S
ðD ¿ÑÿðÅÏ-7
ððT2
ðá
#
ð
H áð´#Ô
Ð%ðð
ðHðT2
ðâ
#
ð
I âðÄ'¬
à)Èð
ðIðT2
ðã
#
ð
J ãðH
$"dð
ðJðZB
ðäB
S
ðD ¿Ñÿðt"pÜ#Ø ððZB
ðåB
S
ðD ¿Ñÿðà$¤
H&À
ððZB
ðæ
S
ðD ¿ÑÿðTô
¼ \
ððZB
ðç
S
ðD ¿Ñÿðl d<#ÌððZB
ðèB
S
ðD ¿Ñÿð\ xððpðT ðHæ!çÌ-
ð#"ñ
ð ððN2
ðÿ

ð V ðHý%d(ð
ðVðN2
ð

ð W ð#&*?(ð
ðWðN2
ð

ð X ð§º)ÃÖ+ð
ðXðT2
ð
#
ð
Y ð°Å"Ìá$ð
ðYðN2
ð

ð Z ðËÍ(çé*ð
ðZðT2
ð
#
ð
[ ð æ!<$ð
ð[ðN2
ð

ð \ ðZ°+vÌ-ð
ð\ðZB
ð
S
ðD ¿ÑÿðÍó'5*ððZB
ð
S
ðD ¿Ñÿð¹ +!Q,ððZB
ð

S
ðD ¿Ñÿð,(4 )ððZB
ð

S
ðD ¿Ñÿð=,(=°+ððZB
ð

S
ðD ¿Ñÿðûº'")ððZB
ð

S
ðD ¿Ñÿð ô#¸&ððZB
ð
S
ðD ¿Ñÿðü¨$d&ðð$ðT ðeU.)@8
ð#"ñ
ð ððN2
ð

ð ] ð°U. q0ð
ð]ðN2
ð

ð ^ ðe825T4ð
ð^ðN2
ð

ð _ ðYq2) 4ð
ð_ðN2
ð

ð ` ð$6è@8ð
ð`ðTB
ð
C
ðD ¿ÿð 8 0QT2ððTB
ð
C
ðD ¿ÿð4 0 2ððTB
ðB
C
ðD ¿ÿð!74ñS6ððTB
ð
C
ðD ¿ÿð4° ]6ððT¢
&ð
C
ð i &¿ðÿð
ðiðbðb ð4-È 5
ð'
ð # "ñ
ð ððT2
ð(
#
ð
j (ð4-0/ð
ðjðT2
ð)
#
ð
k )ð4 0 2ð
ðkðT2
ð*
#
ð
l *ðø1È,3ð
ðlðT2
ð+
#
ð
m +ð
|3Ü 5ð
ðmðZB
ð,
S
ðD ¿Ñÿðd¤.èÀ0ððZB
ð-
S
ðD ¿ÑÿðP¤.Ôt1ððZB
ð.B
S
ðD ¿ÑÿðPÜ2 D4ððZB
ð/Â
S
ðD ¿Ñÿðd(24D4ððzðb ð ¥ ()
ð0
ð # "ñ
ð ððT2
ð1
#
ð
n 1ð ¥ dÁ ð
ðnðT2
ð2
#
ð
o 2ð d1
ð
ðoðT2
ð3
#
ð
p 3ðX¡ (½
ð
ðpðT2
ð4
#
ð
q 4ðl
<)ð
ðqð`B
ð5
c
ð$D ¿ÐÑÿðÄ5 HQ ðð`B
ð6
c
ð$D ¿ÐÑÿð°5 4
ð ð`B
ð7B
c
ð$D ¿ÐÑÿðY
ÐÁ
ðð`B
ð8Â
c
ð$D ¿ÐÑÿðÄ¹
Õ
ððÄ+ð@ ðnMr"
ðððð4ðt ð %@
¬'
ð]#
ð
#"ñ
ð nM¦iððT
ð[
#
ð
[ð %@
¬'ð
ð ð TB
ð\
C
ðD ¿ÿð % ¬'ðð4ðt ð %@
¬'
ð^#
ð
#"ñ
ð
MFiððT
ð_
#
ð
_ð %@
¬'ð
ð ð TB
ð`
C
¬'
ða#
ð
#"ñ
ð ®MæiððT
ðb
#
ð
bð %@
¬'ð
ð ð TB
ðc
C
¬'
ðd#
ð
#"ñ
ð n«¦Ç
ððT
ðe
#
ð
eð %@
¬'ð
ð ð TB
ðf
C
¬'
ðg#
ð
#"ñ
ð
«FÇ
ððT
ðh
#
ð
hð %@
¬'ð
ð ð TB
ði
C
¬'
ðj#
ð
#"ñ
ð ®«æÇ
ððT
ðk
#
ð
kð %@
¬'ð
ð ð TB
ðl
C
ðD ¿ÿð % ¬'ðð`B
ð¤
c
ð$D ¿Ñÿ ðQ> m
> ðð`B
ð¥
c
ð$D ¿Ñÿ ðñ
>
> ðð`B
ð¦
c
ð$D ¿Ñÿ ð4} P
} ðð`B
ð§
c
ð$D ¿Ñÿ ðú
s s ðð4ðt ð %@
¬'
ð¨#
ð
#"ñ
ð nû
¦
ð ðT
ð©
#
ð
©ð %@
¬'ð
ð ð TB
ðª
C
¬'
ð«#
ð
#"ñ
ð
û
F
ð ðT
ð¬
#
ð
¬ð %@
¬'ð
ð ð TB
ð
C
¬'
ð®#
ð
#"ñ
ð ®û
æ
ð ðT
ð‾
#
ð
‾ð %@
¬'ð
ð ð TB
ð°
C
ðº
c
ð$D ¿Ñÿ ðQÁ
m
Á
ðð`B
ð»
c
ð$D ¿Ñÿ ðñ
Á

Á
ð ð4ðt ð %@
¬'
ð#
ð
#"ñ
ð ¾ÒÚ
ððT
ð
#
ð
ð %@
¬'ð
ð ð TB
ð
C
ð
c
ð$D ¿Ñÿ ðæ ðð4ðt ð %@
¬'
ð#
ð
#"ñ
ð û
Ò
ð ðT
ð
#
ð
ð %@
¬'ð
ð ð TB
ð
C
ð
c
ð$D ¿Ñÿ ðæ

ðð ð` ð8
"ü
ð#"ñ
ð n^
r"ðð4ðt ð %@
¬'
ð±#
ð
#"ñ
ð 8@
TððT
ð²
#
ð
²ð %@
¬'ð
ð ð TB
ð³
C
¬'
ð´#
ð
#"ñ
ð ¨
8àTððT
ðµ
#
ð
µð %@
¬'ð
ð ð TB
ð¶
C
¬'
ð#
ð
#"ñ
ð H8 T ððT
ð¸
#
ð
¸ð %@
¬'ð
ð ð TB
ð¹
C
ð¼
c
ð$D ¿Ñÿ ðÎ
8ê
8ðð`B
ð½
c
ð$D ¿Ñÿ ð . °.ðð¬ðL ðI
"
ð©
"üðð4ðt ð %@
¬'
ð¾#
ð
#"ñ
ð I@
eððT
ð¿
#
ð
¿ð %@
¬'ð
ð ð TB
ðÀ
C
¬'
ðÁ#
ð
#"ñ
ð ¨
IàeððT
ðÂ
#
ð
Âð %@
¬'ð
ð ð TB
ðÃ
C
¬'
ðÄ#
ð
#"ñ
ð HI e ððT
ðÅ
#
ð
Åð %@
¬'ð
ð ð TB
ðÆ
C
¬'
ðÇ#
ð
#"ñ
ð ±@
ÍððT
ðÈ
#
ð
Èð %@
¬'ð
ð ð TB
ðÉ
C
¬'
ðÊ#
ð
#"ñ
ð ¨
±àÍððT
ðË
#
ð
Ëð %@
¬'ð
ð ð TB
ðÌ
C
¬'
ðÍ#
ð
#"ñ
ð H± Í ððT
ðÎ
#
ð
Îð %@
¬'ð
ð ð TB
ðÏ
C
ðÐ
c
ð$D ¿Ñÿ ðë
e
eðð`B
ðÑ
c
ð$D ¿Ñÿ ð e §eðð`B
ðÒ
c
ð$D ¿Ñÿ ðÎ
±ê
±ðð`B
ðÓ
c
ð$D ¿Ñÿ ð § °§ðð4ðt ð %@
¬'
ðê#
ð
#"ñ
ð @
+ððT
ðë
#
ð
ëð %@
¬'ð
ð ð TB
ðì
C
¬'
ðí#
ð
#"ñ
ð ¨
à+ððT
ðî
#
ð
îð %@
¬'ð
ð ð TB
ðï
C
¬'
ð#
ð
#"ñ
ð H +ððT
ðñ
#
ð
ñð %@
¬'ð
ð ð TB
ðò
C
¬'
ðó#
ð
#"ñ
ð w@
ððT
ðô
#
ð
ôð %@
¬'ð
ð ð TB
ðõ
C
¬'
ðö#
ð
#"ñ
ð ¨
wà ððT
ð÷
#
ð
÷ð %@
¬'ð
ð ð TB
ðø
C
¬'
ðù#
ð
#"ñ
ð Hw ð ðT
ðú
#
ð
úð %@
¬'ð
ð ð TB
ðû
C
ðü
c
ð$D ¿Ñÿ ðë
+
+ðð`B
ðý
c
ð$D ¿Ñÿ ð + §+ðð`B
ðþ
c
ð$D ¿Ñÿ ðÎ
wê
wðð`B
ðÿ
c
ð$D ¿Ñÿ ð m °mðð4ðt ð %@
¬'
#ð
ð
#"ñ
ð èw ð ðT
ð
#
ð
ð %@
¬'ð
ð ð TB
ð

C
ð

c
ð$D ¿Ñÿ ð4mPmðð4ðt ð %@
¬'
ð
#
ð
#"ñ
ð Ô
" ð ðT
ð

#
ð

ð %@
¬'ð
ð ð TB
ð
C
ð
c
ð$D ¿Ñÿ ð v<vððÐðT ð¨
ÐÝ,

ðÁ#"ñ
ð ððT2
ð?
#
ð
© ?ð¨
ÐÄìð
ð©ðN2
ð@

ð ª ðàÄ,
ð
ðªðT2
ðA
#
ð
« AðØ4ôð
ð«ðT2
ðB
#
ð
¬ Bð ,
ð
ð¬ðT2
ðC
#
ð
CðÁ%ÝAð
ððZB
ðE
S
ðD ¿Ñÿðñ* * ððZB
ðF
S
ðD ¿Ñÿð !ððZB
ðIB
S
ðD ¿Ñÿði/U³ððZB
ðJ
S
ðD ¿Ñÿð4óÔüððZB
ðK
S
ðD ¿ÑÿðÄ7ëððZB
ðL
S
ðD ¿Ñÿð ôð4ðZB
ðN
S
ðD ¿Ñÿðñ )^ððBðb ð
j
H) )
ðP
ð # "ñ
ð ððZ¢
Qð
3
ð ¨ ð¿Jÿj
Ö =ð
ð¨ð`¢
Rð
C
ð § R^ð¿Hÿ1ð
ð§ð`B
ðS
C
ð ¦ Sð¿,ÿF¸jð
ð¦ð`B
ðT
C
ð ¥ Tð¿(ÿò´ú$ð
ð¥ð`¢
Uð
C
ð ¤ Uð¿&ÿÍ&f )ð
ð¤ð`¢
Vð
C
ð £ VAð¿ÿH)#ð
ð£ð`¢
Wð
C
ð ¢ Wð¿ñÿ#ñð
ð¢ðZB
ðX
S
ðD ¿Ñÿð£Ø'ØððZB
ðY
S
ðD ¿Ñÿð£v!'v!ðð`¢
Zð
C
ð ¡ Z¿ðÿ Æ!.!ð
ð¡ð`¢
[ð
C
ð [¿ðÿ´8 ð
ð ðZB
ð\
S
ðD ¿ÑÿðqMq<ððZB
ð]
S
ðD ¿ÑÿðiØ$iô&ððZB
ð^
S
ðD ¿Ñÿðoo°ððZB
ð_
S
ðD ¿ÑÿðI0I ð ðTB
ð`B
C
ðD ¿ÿð
(7 (ððTB
ða
C
ðD ¿ÿðª
òª
(ððZB
ðb
S
ðD ¿Ñÿð»
Þ[Þðð`¢
cð
C
ð c ¿ðÿº6pð
ð ð `¢
dð
C
ð d ¿ðÿáÍ$e5&ð
ð ð ¦ ðT ð Ò 'È(.
ðÕ #"ñ
ð ðð4
ðg
ð Ò 'Óî)ððTB
ðh
C
ðD ¿ÿð3Ò'3î)ðð`¢
ið
C
ð i ¿ðÿ ( 39*ð
ðð`¢
jð
C
ð j ¿ðÿ3(Ó9*ð
ððvðn ð-¨
F/
ðk
ð # "ñ
ð V+?
-ðð4
ðl
ð -¨
/ððTB
ðm
C
ðD ¿ÿð
-
/ ðð`¢
nð
C
ð n ¿ðÿD *-È
F/ð
ððvðn ð-¨
F/
ðo
ð # "ñ
ð V+‾ -ðð4
ðp
ð -¨
/ððTB
ðq
C
ðD ¿ÿð
-
/ ðð`¢
rð
C
ð r ¿ðÿD *-È
F/ð
ððvðn ð-¨
F/
ðs
ð # "ñ
ð V+ -ðð4
ðt
ð -¨
/ððTB
ðu
C
ðD ¿ÿð
-
/ ðð`¢
vð
C
ð v ¿ðÿD *-È
F/ð
ððvðn ð-¨
F/
ðw
ð # "ñ
ð ïV+ % -ðð4
ðx
ð -¨
/ððTB
ðy
C
ðD ¿ÿð
-
/ ðð`¢
zð
C
ð z¿ðÿD *-È
F/ð
ð ðZB
ð{
S
ðD ¿Ñÿðô
U,U,ððZB
ð|
S
ðD ¿Ñÿðdd,èd,ððZB
ð}
S
ðD ¿ÑÿðÔd,ïd,ððTB
ð~
C
ðD ¿ÿðs#V+ %r-ðð`¢
ð
C
ð ¿ ðÿD%8+È.
(ð
ððl
ðb ðpØ ¬&@

ð
ð # "ñ
ð ððjðn ðØ ô
@

ð
ð # "ñ
ð pØ \
@
ð ð4
ð
ðØ ô
@
ððTB
ð
C
ðD ¿ÿðpØ p@
ððTB
ð
C
ðD ¿ÿð#
Ø #
@
ððjðn ðØ ô
@

ð
ð # "ñ
ð ÄØ °@
ðð4
ð
ðØ ô
@
ððTB
ð
C
ðD ¿ÿðpØ p@
ððTB
ð
C
ðD ¿ÿð#
Ø #
@
ððjðn ðØ ô
@

ð
ð # "ñ
ð Ø @
ðð4
ð
ðØ ô
@
ððTB
ð
C
ðD ¿ÿðpØ p@
ððTB
ð
C
ðD ¿ÿð#
Ø #
@
ððjðn ðØ ô
@

ð
ð # "ñ
ð lØ X @
ðð4
ð
ðØ ô
@
ððTB
ð
C
ðD ¿ÿðpØ p@
ððTB
ð
C
ðD ¿ÿð#
Ø #
@
ððjðn ðØ ô
@

ð
ð # "ñ
ð À!Ø ¬&@
ðð4
ð
ðØ ô
@
ððTB
ð
C
ðD ¿ÿðpØ p@
ððTB
ð
C
ðD ¿ÿð#
Ø #
@
ððTB
ð
C
ðD ¿ÿðD%Ø ¬&@
ððTB
ð
C
ðD ¿ÿðpØ Ø @
ððZB
ð
S
ðD ¿Ñÿð\
A
ÄA
ððZB
ð
S
ðD ¿Ñÿð°A
A
ððZB
ð
S
ðD ¿ÑÿðA
lA
ððZB
ð
S
ðD ¿ÑÿðX A
À!A
ððZB
ðB
S
ðD ¿ÑÿðX ×
À!×
ððZB
ðB
S
ðD ¿Ñÿð×
l×
ððZB
ðB
S
ðD ¿Ñÿð°×
×
ððZB
ðB
S
ðD ¿Ñÿð\
×
Ä×
ððª
ðb ð¼ HÈ(d
ð
ð # "ñ
ð ððpðt ðØ ô
@

ð#
ð
#"ñ
ð ÷üã
dðð4
ð¡
ð Ø ô
@
ððTB
ð¢
C
ðD ¿ÿðpØ p@
ððTB
ð£
C
ðD ¿ÿð#
Ø #
@
ððpðt ðØ ô
@

¤ð#
ð
#"ñ
ð Kü7dðð4
ð¥
ð Ø ô
@
ððTB
ð¦
C
ðD ¿ÿðpØ p@
ððTB
ð§
C
ðD ¿ÿð#
Ø #
@
ððpðt ðØ ô
@

¨ð#
ð
#"ñ
ð ü d ðð4
ð©
ð Ø ô
@
ððTB
ðª
C
ðD ¿ÿðpØ p@
ððTB
ð«
C
ðD ¿ÿð#
Ø #
@
ððpðt ðØ ô
@

¬ð#
ð
#"ñ
ð óüß dðð4
ð
ð Ø ô
@
ððTB
ð®
C
ðD ¿ÿðpØ p@
ððTB
ð‾
C
ðD ¿ÿð#
Ø #
@
ððpðt ðØ ô
@

°ð#
ð
#"ñ
ð G"ü3'dðð4
ð±
ð Ø ô
@
ððTB
ð²
C
ðD ¿ÿðpØ p@
ððTB
ð³
C
ðD ¿ÿð#
Ø #
@
ððZB
ð´
S
ðD ¿Ñÿðã
eKeððZB
ðµ
S
ðD ¿Ñÿð7e e ððZB
ð¶
S
ðD ¿Ñÿð eóeððZB
ð
S
ðD ¿Ñÿðß eG"eððZB
ð¸B
S
ðD ¿Ñÿðß ûG"ûððZB
ð¹B
S
ðD ¿Ñÿð ûóûððZB
ðºB
S
ðD ¿Ñÿð7û û ððZB
ð»B
S
ðD ¿Ñÿðã
ûKûððZB
ð¼
S
ðD ¿Ñÿð¼ °$ °ððZB
ð½B
S
ðD ¿Ñÿð'°È(°ððTB
ð¾
C
ðD ¿ÿð¹(H¹(°ððTB
ð¿
C
ðD ¿ÿð¼ W¼ ¿ððTB
ðÀ
C
ðD ¿ÿð¼ HÈ(Hðð¸ðb ð@
"Ü#a"
ðÂ
ð # "ñ
ð ððT2
ðÃ
#
ð
Ãð¦"*>ð
ð ð N2
ðÄ

ð ð x ü ð
ð ð N2
ðÅ

ð ð úû~ð
ð ð N2
ðÆ

ð ~ ð@
¸ ÄÔð
ð~ðN2
ðÇ

ð } ðü¸ Ô ð
ð}ðN2
ðÈ

ð | ðÌE Pa"ð
ð|ðN2
ðÉ

ð { ð ¸ Ôð
ð{ðN2
ðÊ

ð z ðX ¸Ü#Ôð
ðzðTB
ðË
C
ðD ¿ÿð\
cH¸ððTB
ðÌ
C
ðD ¿ÿðnÖò¦ððTB
ðÍ
C
ðD ¿ÿð° 4ððTB
ðÎ
C
ðD ¿ÿð Ì
!ððTB
ðÏ
C
ðD ¿ÿðÔ4X ððTB
ðÐ
C
ðD ¿ÿðH °¸ððTB
ðÑ
C
ðD ¿ÿð
ðTB
ðÒ
C
ðD ¿ÿð= ù Ó ððTB
ðÓB
C
ðD ¿ÿðèÔX ððTB
ðÔ
C
ðD ¿ÿððÞ
!úðð2ðb ð@
ÿ $ü
ð×
ð # "ñ
ð ððT2
ðØ
#
ð
U Øðÿèð
ðUðT2
ðÙ
#
ð
T ÙðóÏÃëð
ðTðT2
ðÚ
#
ð
S Úð@
S
o
ð
ðSðT2
ðÛ
#
ð
R Ûð×Ä
§àð
ðRðT2
ðÜ
#
ð
Q Üð S
Zo
ð
ðQðT2
ðÝ
#
ð
P ÝðPÏ ëð
ðPðT2
ðÞ
#
ð
O Þð -
cI
ð
ðOðT2
ðß
#
ð
N ßð<S

!o
ð
ðNðT2
ðà
#
ð
M àðl×
<óð
ðMðT2
ðá
#
ð
L áð¤àt!üð
ðLðT2
ðâ
#
ð
K âðÀ!×
$óð
ðKðZB
ðãB
S
ðD ¿Ñÿð ÙQA ððZB
ðäB
S
ðD ¿Ñÿð
²eÎ
ððZB
ðå
S
ðD ¿Ñÿð é²
ððZB
ðæB
S
ðD ¿ÑÿðHo
d×
ððZB
ðç
S
ðD ¿ÑÿðÕÆ¥. ððZB
ðèB
S
ðD ¿ÑÿðëlS
ððZB
ðé
S
ðD ¿ÑÿðÁÝ»
ððZB
ðêB
S
ðD ¿Ñÿð o
ð×
ððZB
ðë
S
ðD ¿Ñÿð¤
t"ððZB
ðì
S
ðD ¿Ñÿð®±ððöðb ðô
ðú
ð # "ñ
ð ððT2
ðû
#
ð
h ûðô Ä,
ð
ðhðT2
ðü
#
ð
g üðô
Ä ð
ðgðT2
ðý
#
ð
f ýð¸
(ð
ðfðT2
ðþ
#
ð
e þðÌx ð
ðeðZB
ðÿ
S
ðD ¿Ñÿðü
¨
ððZB
ðÂ
S
ðD ¿ÑÿðüÌ,ððZB
ð
S
ðD ¿Ñÿð
l\
ððZB
ð
S
ðD ¿Ñÿð°À
¸À
ðð`¢
ð
C
ð d ¿ðÿü
÷
ð
ðdð`¢
ð
C
ð c ¿ðÿ´
Ð ÷
ð
ðcðZ¢
ð
3
ð b ¿ðÿÌD
è‾
ð
ðbðZ¢
ð
3
ð a ¿ðÿÔðkð
ðaðöðb ðô
ð
ð # "ñ
ð ððT2
ð
#
ð
y ðô Ä,
ð
ðyðT2
ð
#
ð
x ðô
Ä ð
ðxðT2
ð

#
ð
w
ð¸
(ð
ðwðT2
ð

#
ð
v
ðÌx ð
ðvðZB
ð

S
ðD ¿Ñÿðü
¨
ððZB
ð
Â
S
ðD ¿ÑÿðüÌ,ððZB
ð
S
ðD ¿Ñÿð
l\
ððZB
ð
S
ðD ¿Ñÿð°À
¸À
ðð`¢
ð
C
ð u ¿ðÿü
÷
ð
ðuð`¢
ð
C
ð t ¿ðÿ´
Ð ÷
ð
ðtðZ¢
ð
3
ð s ¿ðÿÌD
è‾
ð
ðsðZ¢
ð
3
ð r ¿ðÿÔðkð
ðrðB
ðS
ð¿Ëÿ ?ðeBos6 ÏçÑñ ò ò ò ò ò òjóô ö¡æª &.-\1f1>3‾34LEU¬V b3uÕK»t"ñt Í X 5t « $Çtf þÿÿ #
tÖCg ã
t|`X@t{Ø~ô t äüÿÿÿdt à 8H t~Ð~ì
t}|~ t <% 5t®ô
PèÙ
t¾Ê°±tÏQ ytÕlÓ(#ï
t× qðnt
4tÖ= !(tú
ìÿÿÿ pt&ô
ZPvt'¼

Pt0¨
Q<Õt
ìÿÿÿ ptÁ¸] tÂ < Öt ètP+CÜ$ytÿÿßL9à h q q4ulq q4u9* urn:schemas-microsoft-com:office:smarttag
T<?%- Ä Ç È Ð Ù ß ì í

#
&
,
F
K
N
V
b
c

¡
¤
¬
ÿ

#
(
¢ÒÕÖë÷ý
. /=CHNOPZ`ci ×ß
» ÁÄÌäéê
!%+39<B[\nty ¥«®‾äêòø*+0DFUflou ¦«±²³»À25'*NQR[agoux~ ª°µ¹º»ÇÈ ®ÀÆËÏÐÑÙÞQT ¡ ±´
"""Ê"á"å"ê"J&O&R&V&W&]&c&f& & & & & &¥&Å&Æ&Ø&Þ&á&é&ê&ë&ó&ø&' '''''*'-'.'5'<'='^'h' ' ' ' '
11111 1&1'1*11½1¶2½2 33!3$3&3+31373?3E3H3N3h3m3p3u3 3 3 3 3 3 3 3 3»3Á3Ä3Ê3Ô3Ù3÷3ø3ý34
4444&4'4,4/4:4@4C4F4J4M4U4Z4¢4©4¼4Â4ê4í4ÿ45555"5%5+5C5H5K5P5Z5`5k5q5s5y5z5 5 5 5 5 5®5´55½
6
666#6)6,6/686;6D6G6Y6^6Ü;é;5<;<W<Z<v<|<¾<Ä<C
C!C'C4C7C?CEC^CdCzC}C C C C CÍCÓCÜCâCäCêCëCñC.D4D=DCDEDKDLDRDyD D D D D¡D¤D©DÛDáDäDéDEEE
EEEMESEVE\E E EË‾EÃEÉEÜEßEàEãEñEöEFFF4F:FUFWF]FcF F F¨F®F°F¶FF½FúFG GGGGGGEGKGNGTG G G
H
H"H(H+H2H6H?HAHGHkHqHtH H H H H H¼HÁHóHúH
II$I'I4I:IPIVInIqIzI|I I I¸I¾IÇIÍIÏIÕIÖIÜIJJ#J)J+J1J2J8J\JbJeJkJ~J J J JºJÀJÃJÇJÞJàJáJçJõJ÷
MMAMGMPMVMXM^M_MeM M£M¬M²M´MºM»MÁMåMëMîMôM N
NNNCNINLNPNgNiNjNpN~N N¹N¿NÂNÈNëNñNôNúNO"O%O*O:O@OIOOOQOWOXOÔjOuOxO O O O O OºOÀOÃOÉOëOðO(
QQQQQTQZQcQiQkQqQrQxQ Q¢Q¥Q«Q¾QÃQÆQËQúQRR RR R!R'R5R7ReRkRnRtR R R R¦RÈRÍRÐR×RÞRäRçRíRS S
SSSS(S.S0S6S7S=SzS S S S S S S¤S¾SÄSÇSÍSðSõS T'T:T@TQTTTaTgT}T T T T§T©T®T´TåTëTôTúTüTUU
V
VVV"V$VRVXV[VaV V V V VV²VµVºVW³W¶W¼WßWäWX!X4X:XKXNX[XaXwX}X X X X X©X«X°X¶XçXíXöXüXþXYY
YCYIYRYXYZY`YaYgY Y Y Y YY²YµYºYéYïYòYöY
ZZZZ$Z&ZTZZZ]ZcZ Z Z Z Z‾Z´ZZ¼Z[[["[-[3[x[~[ [ [ [ [Ó[Ú[í[ó[\ \
\
^^^"^*^2^@^G^H^K^Z^[^p^q^r^s^t^y^ ^ ^ ^ ^ ^¦^ô_ù_ÿ_````"`%`&`0`2`Ûaâaêaòaúabbbbb*b+b@bAbBbC
;dCdLdQdRdWdze e e e e ee²eµe¶eÓeØeÈgÍgÖgÛgÞgãgègógRiWiìeiqivi{i ik!k$k,k6k<k=kFkIkSkVk`k
M}S}Y}Z}_}`}p}v}z}{}}} }æ ì õ û
! % + 1 2 7 8 H N R S U W / 8 A G î ô ú û ) & ( / 5 t z } « ± ´ º Í Ò
" $ * 9 ; H N Q U k m n t « ± ´ º Û á ä ì
" # ) 8 = ¤ § á ë ó ù
# ) 2 < V \ _ e y ~ ‾ µ ¸ ¾ è î ø þ & 5 7 T Z ] a t v w } ® ¸ Ê Ð Ó Ù
# % S Y \ b ¾ À Ì Ñ Ù ¥¥¥¥¥¥¥¥¥¥¥¥¥¥¥¥¥¥ ¥!¥&¥(¥*¥+¥,¥-¥.¥/¥0¥1¥3¥4¥5¥6¥8¥9¥:¥;
²²"²$²%²+²:²<²Y²_²b²g² ² ² ² ² ² ²Ð²Ö²Ù²ß²³³³%³O³Q³_³d³³³³¿³Â³Ã³Í³Ò³Õ³ý³ ´´´´%´3´6´F´HŃ´T
µµ&µ(µ)µ/µ>µ@µ]µcµfµnµ µ µ µ µ µ µ¼µÆµØµÞµáµçµ¶¶+¶1¶4¶=¶L¶N¶[¶`¶l¶v¶w¶y¶{¶ ¶ ¶ ¶ ¶ ¶¤¶¦¶¶¶¿
¹¹¹¹/¹4¹7¹<¹J¹P¹Y¹_¹a¹g¹h¹n¹è¹î¹ñ¹ù¹ºººº)º+ºRºXº[ºcºzº|º}º º º º¿ºÅºÈºÎºðºöºùºÿº$»&»2»7»õ¼ø
ÃÃ&Ã,Ã9Ã<ÃDÃJÃcÃiÃ Ã Ã Ã Ã©Ã«Ã²Ã¸ÃÔÃXÅbÅeÅnÅwÅ Å Å Å Å Å Å Å¡ ÅªÅÅ¶ÅÁÅÉÅÊÅÎÅÑÅÖÅìÅñÅúÅÿÅÆ
Æ
ÆÆÆÆ=ÇNÇSÇÙÌÜÌåÌíÌóÌùÌÍ;ÖDÖEÖMÖSÖYÖZÖ_ÖeÖkÖyÖzÖ|Ö}Ö Ö Ö Ö Ö«Ö³ÖcP"Q"}"~"7#c&i&z& & & & & &
WWAWDWSWVW^WdWoWrW|W W W W W¦WºWÀWÇWÊWÔWÚWáWîWïWòWóWöWüWX,X2X?XLXTXWXrX X X¤XÄXÑXÙXÜX÷XYY)Y
\,\9\A\D\_\l\ \ \©\¶\Î\Û\ö\û\] ]]]]] ]#]+]2]4]:]C]I]K]Q]R]X]e]l]s]v] ] ]^ ^
^^?_I_ _ _¶`¾`bbúbýbþbcc
ccc c&cIcOcRcVc«c®c²cºc d dff f f f fËfÎfÝfàfçfêfëfõføfþf g
ggg,g2g9g@gTgZgagdgngtg{g g g g g g g gËgÎgÕgÛgègõgýghh(h@hMhmhzh h h hhÅhÒhêh÷hi$i,i/iJiW
k#k0kPk]kekhk k k¨kµkÕkâkêkík
ll-l:lRl_lwl l l¥l¾lÁlÍlÒlÝlàlálälålílýlmmm:m@mCmGmMmUmdmkm m m
44"4&4:4A4U4[4«4‾4¼4Â4Õ4Ù4ê4í4ÿ45555#5C5I5X5Z5 5 5®5µ5×5Ý56
6#6*6Y6_6ó9û9<<A<W<Z<v<|<X=\= = =iBoB B BCC!C'C4C7C?CEC^CdCzC}C C C C¢C°C³CäCëCDD,D.DyD D D
|F F°FFàFäFøFúFEGLG G GÌGÓGòGõGH H"H)HOHUHkHrH¼HÂHüHI
II$I'I4I:IPIVInIqI I I I I I IÏIÖIúIþI+J2J\JcJ~J JºJÁJÞJáJîJôJ
KK%K,KWK^K K K K¢KÒKÜKàKêKÿKLL LJLPL L L L LL°L½LÃLÙLßL÷LúL
MMMM&M)MXM_M M M´M»MåMìM N
NCNJNgNjNwN}N N N¹NÀNëNòNO#O1O2OjOtOxO O O O O O O¦OºOÁOëOñO1P5PBPHPYP\PiPoP P P P¢P¦P©PÁPÈ
)T-T:T@TQTTTaTgT}T T T T®TµT¼T¾TÊTÍTüTU'U+UXU_U U U«U±UçUîU
VVV!V8V>VRVYV V VV³VÉVÏVãVæVüVÿVW#W-W1W;W<WQWVW W WW´WßWåW#X'X4X:XKXNX[XaXwX}X X X°XX¾XÀ
ZZZ#Z:Z@ZTZ[Z Z Z‾ZµZÆZÌZÓZÙZíZðZúZýZ[[A[F[j[m[x[ [ [ [Ü[à[í[ó[\ \\\0\6\V\Y\n\u\|\~\ \ \¼\Ã
^
^^^"^+^2^@^K^N^jû^y^ ^ ^ ^ª^‾^Ò^Ø^__)_0_[_a_¥_©_¶_¼_Í_Ð_Ý_ã_ó_õ_ù_`"`%`>È`L`N`Z`]` ` ``»
c c cÂcÃcÓcÖcôc÷c d
dd d#d)d0d2d8d<dWdZdkdld d d d¡dµd¼dçdíd+e/e<eBeSeVeceieye{e e®e²eµeØeÜeäeëeòeøef
ffftfzf f f©ff¶f½fÃfÔfÕfàf g
gg&g:g>gEgLgyg g g g¿gÉgÍg×gãgègóg÷gþghhhFhMhphvh h h h hÀhÆhÛháhiiIiSiWiaieifivi{i i i i¢i
OlUlZlul{l l lÁlÇlÏlÔlÙlÝlílðlm
m'm-m3m8mGmNmvm|m m m³m¹mÚmàmømùmnn-n2n]nbngnkn{n~n n nµn»nÁnÆnÕnÜnoo o&o>oAo[oô o o o o¥o¦
rr"r(r
t<tzt~t t t£t©t¼t¿tÌtÒtêtðtu
uuuEuGuzu{u u u u uÝuãu÷uþu)v/vavevsvyv v v§vªv¸v¾v×vÝv÷vûv
wwww$w'w7w9wkwlw w w w wîwõw
xx9x@xXx[xixox x x¤x«xØxÞxyy#y)y=yCyWyZyhyny y y§y«y¼yÃyÊyÌyÔy×yçyéyzz4z8zNzPz z¥z¼zÂzézðz{
{{{8{>{T{[{ { {¾{Ä{Ô{Ö{ |||$|)|2|7|A|F|J|Y|_|u|||ª|°|Ý|á|ï|õ| }}#}&}4}:}L}N}S}q}v}z} } }
/ 6 d k © « Þ ç ì ö û ü
& , B I w } µ ¹ Ç Í á ç û þ
$ & + I N R k r y { Ê Ë ã ç ý ÿ M T k q º È Î ç í
8 ? m s © ‾ ¿ Á ô õ
) , @ C L N T ^ e q x ¥ ® µ ¿ Æ Ð × à ç ë ï ñ ø ú
M S ~ ª ° Ä Ç Õ Û í ï ô 4 ; B D L O _ a ¬ ° Æ È 4 : a h ° ¶ Ì Ó
" 6 9 G M f l ¨ ‾ ¶ ¸ Ç Î å ë ø ú * - @ D I J u | ¥ « Ä Ê Ý ä # ó ó ÷ ! % /
# * 2 = G I V ] y ‾ ¶ Í Ò â ç ø ÿ . 4 D F T [ t w ¡ « ® Ê Ñ ê ï 3 9
# - 2 ; > S Z n s ¤ ¨ ½ Ì Ò L¡N¡n¢¼¢J£M£
¥>¥â¥ö¥§§(§.§6§:§C§F§P§S§_§e§o§u§ § § § §¨§¬§º§¾§Ò§Õ§á§è§ð§ö§¨¨1¨8¨Q¨W¨\¨b¨ ¨ ¨ ¨ ¨«¨±¨Î¨Ò¨
©©+©/©@©D©Q©U©\©a©w©|© © ©¬©‾©É©Ð©î©ô©ª&ª7ª;ª\ª`ª ª ª¦ªªªËªÔª
«
«3«6«U«\«w«}« « «¥«§«¶«¸«Ó«Ö«ô«÷«
¬¬¬¬&¬-¬7¬=¬Y¬\¬r¬y¬ ¬ ¬³¬¬Ã¬Ê¬± ±.±1±S±W±`±g±o±q±y±}± ± ± ± ±²±±¾±Å±Ü±â±ñ±õ±²
²"²%²3²9²I²K²Y²`² ² ² ² ²£²¨²²²µ²Ð²×²ì²ñ²³ ³³³2³7³H³N³_³e³³³³¿³Â³Ò³Õ³æ³ê³ø³ü³´´´%´3´6ÁÉ´
µ&µ)µ7µ=µMµOµ]µdµ µ µ µ µªµ‾µ¹µ¼µØµßµ÷µüµ¶¶+¶2¶E¶K¶[¶a¶g¶k¶{¶ ¶ ¶ ¶¤¶¦¶¶¶À¶Ä¶Ê¶Û¶Þ¶ù¶ÿ¶
"-3?BLN\^v ½ÃËÏ×Ýäìðö¸¸h¸l¸z¸ ¸ ¸ ¸ ¸ ¸¸½¸Ö¸Ù¸í¸ô¸ü¸þ¸
¹¹/¹5¹H¹J¹¦¹©¹Á¹Å¹É¹Ê¹è¹ï¹ºº"º(º8º:ºRºYºzº}º º º º º©º¬º¿ºÆºÚºßºðº÷º»#»2»8»{¼ ¼ã¼ç¼õ¼ø¼½"½A
¾¾!¾%¾4¾;¾S¾V¾d¾j¾z¾~¾ ¾ ¾§¾Ä¾Ì¾é¾õ¾û¾
¿¿)¿,¿4¿9¿B¿I¿S¿W¿d¿ÔpÕpÕp×p×pØpØpÚpÛpÝpÞpàpáp&q0q3q?qDqLqQqSqXqZq_qaqfq t tt½t¿tôt1u4u 3
3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3
3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3
3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3
3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3
3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3
3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3
3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3
3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3
3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3
3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3
3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3
3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3
3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3
3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3
3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3
3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3
3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3
3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3
3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3
3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3
3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3
3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3
3 3 3 3 3 3 3 3 3 3 «ÏdÏÐÖ×ÙÚàáæçóôö %&,-1Ì
ÿ
,
/
J
f
Ò÷ Ðû5U ± äðñ"#Ö%P&z(l. 7 7À8Á8D9E9{9|9];iBØB¦ì§> # 7#y33é3'4W4§4LªL*NwNºUsVÓpÔpÕpÕp×p×pØp
r
rr&r(r<r>r?rArBrDrErGrHrJrKrMrNrPrQrSrUrWrXrZr\r^r_rarbrdrfrhrjrlrmror r r r r r r r r r r
s
ssssssss-s/s0s2s3s5s6s8s9s;s<s>s?sAsBsDsEsGsHsJsKsMsNsPsQsSsTsVsWsYsZs\s]s_sbsdsgsislsnsqss
þÆ@
^ @
` þ. þÆ^ ` þ. à LÿÆà^ à` Lÿ. ° þÆ°^ °` þ. þÆ ^ ` þ . P LÿÆP^ P` Lÿ. Ð þÆÐ^
þÆ@
^ @
` þ. þÆ^ ` þ. à LÿÆà^ à` Lÿ. ° þÆ°^ °` þ. þÆ ^ ` þ . P LÿÆP^ P` Lÿ. 8 0ýÆ8^
þÆ@
^ @
` þOJQJo( h Hð þÆ^ ` þOJQJ^Jo( h Ho à þÆà^ à` þOJQJo( h H§ð ° þÆ°^ °` þOJQJo( h
þÆ@
^ @
` þ. þÆ^ ` þ. à LÿÆà^ à` Lÿ. ° þÆ°^ °` þ. þÆ ^ ` þ . P LÿÆP^ P` Lÿ. Ð þÆÐ^
þÆ@
^ @
` þ. þÆ^ ` þ. à LÿÆà^ à` Lÿ. ° þÆ°^ °` þ. þÆ ^ ` þ . P LÿÆP^ P` Lÿ.}³,§Î,6'í

478;QTUX_bc¦
¦¦¦¦¦ ¦"¦#¦$¦%¦'¦(¦*¦+¦,¦-¦1¦2¦4¦6¦8¦;¦>¦?¦A¦B¦C¦D¦I¦J¦L¦M¦N¦O¦V¦W¦Y¦Z¦[¦\¦e¦f¦h¦j¦l¦n¦u¦v¦
4
44444444444V4W4Y4[4]4_4`4b4d4f4h4j4k4m4o4q4s4u4v4x4z4|4~4 4 4 4 4 4 4 4 4ELFLHLJLLLNLPLQLSL
V
VVVVVVVVVV V"V#V&V(V*V,V.V0V2V4V6V7V:V<V>V@VBVDVFVHVJVKVNVPVRVTVVVXVZV\V^V_VbVdVfVhVjVlVnVp
z ÿArial; Wingdings?5 z ÿCourier New"1
ðÐhjÄ Fdº f Æc
7É9¼
7É9¼ !ðnn´´ 4dpp3 QÜ ðHðÿ
P ?äÿÿÿ ÿÿÿ ÿÿÿ ÿÿÿ ÿÿÿ ÿÿÿ ÿÿÿ ðd 2ÿÿWhat is Data Structure
Administratoradmin

þÿà òùOh«+'³Ù0 ÀÌäð ü
(
H
T
`
l x äWhat is Data StructureAdministrator
N ormal
admin14Microsoft Office Word@ Ô
@ H øÃ@¨ gÏúÃ@Äwd×XÄ
7É9þÿÕÍÕ . + ,ù®0
hp
¨°¸
À
ãAäshwath
¼pæ

What is Data Structure
Title




ÿÿÿÿÿÿÿÿÿÿÿÿ«=1TableÿÿÿÿÊ éWordDocumentÿÿÿÿ2TSummaryInformation(ÿÿÿÿÿÿÿÿÿÿÿÿ¿DocumentSummar
ÿÿÿÿ ÀFMicrosoft Office Word Document
MSWordDocWord.Document.8ô9²q

Notes Data-Structure

Transféré par

Informations du document

Description originale:

Titre original

Copyright

Formats disponibles

Partager ce document

Partager ou intégrer le document

Options de partage

Avez-vous trouvé ce document utile ?

Ce contenu est-il inapproprié ?

Droits d'auteur :

Formats disponibles

Notes Data-Structure

Transféré par

Droits d'auteur :

Formats disponibles

INDEX

printf("\nEnter data to search = ");

Info :-information part of the node

Implementation of linked list

Each node of a doubly link list contains three fields: -

A graph is defined as a set of nodes or vertices and a set of lines or edges or

Matrix representation of above directed graph

Matrix representation of above undirected graph

Matrix representation of above weighted graph

Matrix representation of above graph

Matrix representation of above undirected graph

Vous aimerez peut-être aussi