#include

#include

#include

// Link list node

struct Node {

int data;

struct Node* next;

};

//function declaration

void push(struct Node** head_ref, int new_data);

int isPresent(struct Node* head, int data);

// Function to get union of two linked lists head1 and head2

struct Node* getUnion(struct Node* head1, struct Node* head2)

{

struct Node* result = NULL;

struct Node *t1 = head1, *t2 = head2;

// Insert all elements of list1 to the result list

while (t1 != NULL)

{

push(&result, t1->data);

t1 = t1->next;

}

// Insert those elements of list2 which are not present in result list

while (t2 != NULL)

{

if (!isPresent(result, t2->data))

{

push(&result, t2->data);

}

t2 = t2->next;

}

return result;

}

// Function to get intersection of two linked lists head1 and head2

struct Node* getIntersection(struct Node* head1, struct Node* head2)

{

struct Node* result = NULL;

struct Node* t1 = head1;

// Traverse list1 and search each element of it in list2. If the element is present in list 2, then insert the element to result

while (t1 != NULL)

{

if (isPresent(head2, t1->data))

{

push(&result, t1->data);

}

t1 = t1->next;

}

return result;

}

// A utility function to insert a node at the beginning of a linked list

void push(struct Node** head_ref, int new_data)

{

// allocate node

struct Node* new_node = (struct Node*)malloc(sizeof(struct Node));

// put in the data

new_node->data = new_data;

// link the old list off the new node

new_node->next = (*head_ref);

// move the head to point to the new node

(*head_ref) = new_node;

}

// function to print a linked list

void printList(struct Node* node)

{

while (node != NULL)

{

printf("%d ", node->data);

node = node->next;

}

}

// function that returns true if data is present in linked list else return false

int isPresent(struct Node* head, int data)

{

struct Node* t = head;

while (t != NULL)

{

if (t->data == data)

{

return 1;

}

t = t->next;

}

return 0;

}

// Driver program to test above function

int main()

{

int n,m,temp;

printf("enter the value of number of value in link list(both):-");

fflush(stdout);

scanf("%d %d", &n, &m);

// Starth structure pointer with the empty list

struct Node* head1 = NULL;

struct Node* head2 = NULL;

struct Node* intersecn = NULL;

struct Node* unin = NULL;

//for loop for link list1

for(int i=0;i<n;i++)

{

printf("Enter the value in link list1 %d:-",i);

fflush(stdout);

scanf("%d", &temp);

push(&head1, temp);

}

//for loop for link list2

for(int i=0;i<m;i++)

{

printf("Enter the value in link list2 %d:-",i);

fflush(stdout);

scanf("%d", &temp);

push(&head2, temp);

}

//call the function of intersection

intersecn = getIntersection(head1, head2);

//call the function of union

unin = getUnion(head1, head2);

printf("\n First list is ");

//function calling with structure pointer as argument

printList(head1);

printf("\n Second list is ");

printList(head2);

printf("\n Intersection list is ");

printList(intersecn);

printf("\n Union list is ");

printList(unin);

return 0;

}

Overview of the Project: (5 to 6 lines)

In this project, interfaces for mathematical Set Theory are implemented using C programming language. User can give the input like two list of data and this program will give the output as the union and intersection of these two lists

Aim:

Goals (2 to 3 points)

• Implementation of interface for mathematical Set Theory using C programming.
• Giving two list of data as input to get the output as union & intersection for given list of data.

Key Highlights of the Project: (4 to 5 point)

• Creating two list of data using linked list method.
• Insert the node to 1st and 2nd list accordingly.
• Intersection of data of two lists.
• Getting Union of two list.

Deliverables of this project: (4 to 5 points)

• Intersection of data of two list.
• Union of data of two list

Expected Outcomes: (4 to 5 points)

• Student will get the Knowledge of creating the nodes using Linked List.
• Getting the intersection and Union of data of two list.
• Comparing the elements of two list.

Solution:

Overview of the project:

Here the main objective of the project is to do the mathematical set operation. The set operation has many operations here they are told to do the union and intersection of the list crerated as a linked lisr. so here we are creating a structure it has a collecion different dara. Here is the process to first creare two lisrs using the reference address. The main concept of linkedlist is self referential structure.

Implementation Of C interface for mathematical set theory using C progamming:

First, we are creating the structure as a tyoedef model to rename the user defined name.

In that, we are creating two datatypes int for storing the integer value, and the pointer variable is used it storing the address of the same structure itself.

And after we are creating the main function we get the values of list 1 anf list 2 using the for loop and using the many function call in that.

And then we are creating the different functions wha are mentioned in the main program.

Creating two lists of data using the linked list method:

Firsr, we are getting the size of the list. Using the for loop we are inserting the data inside the foe loop, we use the insert node function.

In these functions, we are using arguments are heas address and value from the user.

Inside the inserted node, we are creating the size of the lisr using the malloc funciton.

Entering the data in the data area, and storing the address of the head to the next pointer and we are storing the new node address in the head for the next update.

Likewise, we are creating the two lists.

Getting Union of two lists:

Here, we get a function call of getting union with the argument of head1 and head 2

In the union function , we are using the head unit as a list by inserting the value of the first list in the union and jumping to the next area by addressing stores in the next.

Insert node funcgtion as same as the function which is used for the creation of the inked lisr.

Using another while loo[ we are getting the second list. Using the compare function using not we are getting only the value that is not placed in the list one and inserted in the unionn in the list.

Getting Intersection of two lists.

In the intersection, we are easy to get an intersection because just we compare to list and return the value which is placed in both lists commonly.

Using the if command comparing the data of lists 1 and 2

If the condition is true it passes the next step which has an intersection list and using the insert function we are inserting the data into that list.

Display function:

It is used to display the data of teh different lists by using different arguments passing to the display function.

So creating the temaparary list with the head is null. And print data and use the next address stored in the pointer variable pointing to the structure.

if head next has it recognize it has last node.

Full Code:

#include

#include

#include

typedef struct node//defining the structure

{

int data;// creating the data type of the variable

struct node *next;// creating self referential node

}

node;// changing the structure name as node

static Node *head1,*head2,*head_union,*head_intersection,*newnode,*tail,*res_union,*res_intersecton;// declaring the different varable in structure type

/*Declaring different function with arguments*/

Node *insert_node(Node *head_ref,int n);

void display_list(Node *head_ref);

Node*get_union(Node *head_pointer1,Node *head_pointer2);

Node *get_intersection(Node *head_pointer1,Nide *head_pointer2);

int compare(Node *head, int data);

void display_list(Node *head_ref)// function used to display the nodes data

{

if(head_ref == 0)

{

printf(" List is empty. ");

}

else

{

tail = head_ref;// we are transferring address if the list to tail

while(tail != 0)

{

Printf("%d", tail->data);// priints the data of current node

tail = tail->next;// advances the position of current node

{

while(head_pointer1 !=0)

{

head_union = insert_node(head_union,head_pointter1->data);//here we are inserting the data of list 1 into the union function

head_pointer1 = head_pointer1->next;//we transverse the node using the address in next.

}

while(head_ponter2 != 0)

{

If( !compare(head_union,head_pointer2->data))//Here we are inserting the element from list 2 number where in the list1 to the union

head_union = insert_node(head_union,head_pointer2->data);//inserting the elementnot in the list2

head_pointer2 = head_pointer2->next;//travelling to next node

}

return head_union;

}

int compare(Node *head,int data)

{

while (head != NULL)

{

if (head->data ==data)//comparing the data of list 2 with list 1

return 1;

head = head->next;

}

return 0;

}

Node *get_intersection(Node *head_pointer1,Node *head_pointer2)

{

while (head_pointer1 != 0)

{

if (compare(head_pointer2, head_pointer1->data))//we are comparing the both list for intersection

head_intersection = insert_node(head_intersection,head_pointer1->data);//transferring the value to the intersection

}

tail = newnode;

}

Node *insert_node(Node *head_ref, int n)// functionused create the new list

{

printf("nInserting Elements at the beginning...n");

head_pointer1 = head+pointer1->next;

}

return head_intersection;

}

int main()

{

int first_list_nodes = 0, second_list_nodes = 0, first_list_items = 0, second_list_items = 0;

int f;

printf("Enter the number of Nodes in first List:");

fflush(stdout);

scanf("%d",&first_list_nodes);

printf("Enter %d the elements:", first_list_nodes);//getting the number of element in the lists

for(f=0; f<first_list_nodes; f++)<="" p=""></first_list_nodes;>

{

fflush(stdout);

scanf("%d",&first_list_items);//getting the data in run time

head1 = insert_node(head1,first_list_items);//inserting the data in list

}

display_list(head1);//displaying the head1 list

printf("nEnter the number of Nodes in second List:");

fflush(stdout);

scanf("%d",&second_list_nodes);

printf("Enter %d the elements:", second_list_nodes);

for(f=0; f<seconf_list_nodes; f++)<="" p=""></seconf_list_nodes;>

{

fflush(stdout);

scanf("%d",&second_list_items);//getting the data in the run time

head2 = insert_node(head2, second_list_items);

}

display_list(head2);//displaying the head1 list

res_union = get_union(head1 , head2);//transferring the result of union function to the res union

printf("Here is the result of union:");

display_list(res_union);//transferring the result of intersection to the res intersection

res_intersection = get_intersection(head1, head2);//transferring the result of intersection function to res intersecton