Set data structure

Introduction
• A set is a collection of objects need not to be
in any particular order.
• It is just applying the mathematical concept in
computer.
• Rules:
 Elements should not be repeated.
 Each element should have a reason to be in the
set.

Set example :
 Assume we are going to store Indian
cricketers in a set.
* The names should not be repeated, as
well the name who is not in a team can’t be
inserted.
* This is the restriction we found in a set.

NULL SET(EMPTY SET)
• The set with no element is called null set or
empty set.
For example:
A={x | x is a prime number, where 24<x<29}
This set can’t contain a element. We don’t
have any prime number within the limit 24
and 29.
A={ }

Basic Operations

o set union(set1,set2)
o set intersection(set1,set2)
o set difference(set1,set2)
o int subset(set1,set2)

UNION
• Combine two or more sets(here two sets),
without violating the rules for set.

INTERSECTION
• Gathering common elements in both the sets
together as a single set.

DIFFERENCE
• Forming a set with elements which are in first
set and not in second set.

• A-B= {x| for all x belongs to A but not in B}

SUBSET
• int subset(set1 , set2)
• Returns 1 if the set1 is the subset of the set2.,
otherwise 0 if not.
• Here, A c B(A contained in B)

Types

Immutable Mutable

(Static) (Dynamic)

Operations on Mutable
• void* create(n)
• add(set , element);
• delete(set , element);
• int capacity(set);

CREATE
• void* create(int n)
– It simply create the set that can be used to store
‘n’ elements and return the starting address of the
set in memory.

int *set=create(30);

ADD
• add(set set_name , type value)
– This function add one element into the set
specified in the function argument.
– The set_name argument is to mention the set
which is going to be updated.
– value argument is the value to be inserted into
the set that passed to the function.

DELETE
• delete (set set_name , type value)
– This function delete one element from the set
specified in the function argument.
– The set_name argument is to mention the set
which is going to be updated.
– value argument is the value to be deleted from
the set that passed to the function.

CAPACITY
• int capacity(set set_name)
– This function is used to find the maximum number
of elements can be stored into the set that passed
to the function.
– Find the count and return the integer value.

Operations on Immutable
• int elementof(x , S)
• int empty(S)
• int size(S)
• void* build(x1 , x2 , … , xn)

ELEMENTOF
• int elementof(type x , set set_name)
– This function check for the element ‘x’ in the
passed set.
– Returns the value whether 0 or 1.
– If the X is there in the set, return 1 otherwise 0.

EMPTY
• int empty(set set_name)
– This function checks for the emptiness of the set
that passed to the function.
– If the set is empty, return 1 else 0.

SIZE
• int size(set set_name)
– Returns the number of elements in set.

BUILD
• void* build(set_elements)
– This function create the set with the given
elements and return the address of the first
element.
– Return the void* , we can assign that pointer to
the type* which type we declared the set.

• intersection()
Here, function for set with the type int.
int* intersection(int set1[100],int set2[100])
{
int inter[100],k=0;
for(i=0;i<size(set1);i++)
for(j=0;j<size(set2);j++)
if(set1[i]==set2[j])
{
inter[k]=set[i];
k++;
}
return inter;
}

• union()
int* union(int set1[100],int set2[100])
{
int uin[100];
{
uin[i]=set1[i];
}
for(j=0;j<size(set2);j++)
{
if(!find(uin,set2[j]))
{
uin[i]=set2[j];
i++;
}
}
return uin;
}

• elementof()
int elementof(int set[100],int x)
{
{
if(set[i]==x)
return 1;
}
return 0;
}

Dynamic memory allocation
 Header file for this is <alloc.h>
void* malloc(int size_of_block)
void* calloc(int number_of_blocks, int size_of_each_block)
void free(void* ptr)
realloc(void* ptr, int size)

HASH FUNCTION
• Before entering into an application of set data
structure, we need to discuss about hash function.
• Hash function is a function that generate an integer
number with a particular logic.
• This function is like a one way entry. We can’t reverse
this function. But by doing the process with the same
number we may get an answer.

• Sometimes the same value may be generated
for the different values. In that case, we need
to check for the data in that location.
• In some cases, same values will generate the
different output. Both are possible.
• We have to select a hash function which is not
repeating the values generated.

Spelling checker
• Here, is a simple example for spelling checker.
• This concept applied by using the hash table
data structure.
• The two files are provided to us for process.
One is “dictionary file”, which is the collection
of meaningful words, and another one is
“input file”, that contains the word to be
validated for spell.

• Initially the words from the dictionary file and
also from input file be inserted into the hash
tables separately.
• And the intersection operation will be done
between the two hash tables.
• If the set with one element is the result of the
intersection, then the word is in dictionary.
Spell is perfect. If, null set returned form the
intersection, then the spell is wrong.

The set data structure is indirectly
implemented using such as trees, tries, hash
tables, arrays, by restricting ourself while
storing data. This is widely used data structure
when we need no repetition as well a
collection.

Set data structure

More Related Content

Set data structure