Overview of the Project:

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.

In this project stdio.h header file is used and stdlib.h header file is used as we are usinf node function.The node function is defined in standard library header file.

The node data is passed as structure in this code.

void insert fun() is used to insert the specified number of integers.

struct node* findunion is used to find common nodes and intersect two nodes.

The detailed c code is shown below.

C CODE:

#include <stdio.h>

#include <stlib.h>

// A structure of linked list node
struct node

{
int data;
struct node *next;

} *LLOne, *LLTwo, *unionLL, *intersectionLL;

void initialize()

{
LLOne = LLTwo = NULL;
}
//Given a Inserts a node in front of a singly linked list.

void insert(struct node **head, int num)

{
// Create a new Linked List node
struct node* newNode = (struct node*) malloc(sizeof(struct node));
newNode->data = num;
// Next pointer of new node will point to head node of linked list
newNode->next = *head;
//make new node as new head of linked list
*head = newNode;
}

// Searches an element in Linked List by linearly traversing from head to tail
int search(struct node *head, int num)

{
while (head != NULL)

{
if (head->data == num)

{
return 1;
}
head = head->next;
}
return 0;

}

//Returns the union of two given linked list

struct node* findunion(struct node *LLOne, struct node *LLTwo)

{
unionLL = NULL;
// Add all nodes of first Linked List to unionLL
struct node *temp = LLOne;
while(temp != NULL)

{
insert(&unionLL, temp->data);
temp = temp->next;
}
// Insert those nodes of LLTwo which is not present in LLOne
while(LLTwo != NULL)

{
if(!search(LLOne, LLTwo->data))

{
insert(&unionLL, LLTwo->data);
}
LLTwo = LLTwo->next;
}
return unionLL;
}

//Returns the Linked List which contains common nodes of two given linked list

struct node* intersection(struct node *LLOne, struct node *LLTwo)

{
intersectionLL = NULL;
//Search every element of LLOne in LLTwo, If found then add it to intersection List
while(LLOne != NULL)

{
if(search(LLTwo, LLOne->data))

{
insert(&intersectionLL, LLOne->data);
}
LLOne = LLOne->next;
}
return intersectionLL;
}
//Prints a linked list from head node till tail node

void printLinkedList(struct node *nodePtr)

{
while (nodePtr != NULL)

{
printf("%d", nodePtr->data);
nodePtr = nodePtr->next;
if(nodePtr != NULL)
printf("-->");

}
}

int main()

{
int i, LLOneCount, LLTwoCount, temp;
initialize();
//Creating First linked List
printf("Enter number of nodes in first Linked Listn");
scanf("%d", &LLOneCount);
printf("Enter %d integersn", LLOneCount);
for(i=0; i<LLOneCount; i++)

{
scanf("%d", &temp);
insert(&LLOne, temp);
}
printLinkedList(LLOne);
printf("nEnter number of nodes in second Linked Listn");
scanf("%d", &LLTwoCount);
printf("Enter %d integersn", LLTwoCount);
for(i=0; i<LLTwoCount; i++)

{
scanf("%d", &temp);
insert(&LLTwo, temp);
}
printLinkedList(LLTwo);
//printing Union of two given linked list
findunion(LLOne, LLTwo);
intersection(LLOne, LLTwo);
printf("nUnion Linked Listn");
printLinkedList(unionLL);
printf("nIntersection Linked Listn");
printLinkedList(intersectionLL);

return 0;
}

Result:

The ouput of the program is shown below.