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 cant 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 cant contain a element. We dont 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 (Static)

Mutable (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]; for(i=0;i<size(set1);i++) { 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) { for(i=0;i<size(set1);i++) { 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 cant 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.