Challenge

Project 1 - Creation of user defined data type to implement the user interfaces for working with ‘Set’ (Mathematical Set theory) using Linked List

RRobert Rino4 Aug 2022

PROJECT-1

Creation of user defined data type to implement the user interfaces for working with ‘Set’ (Mathematical Set theory)

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 created as a linked list. so here we are creating a structure it has a collection of different data. Here is the process to first create two lists using the reference address. The main concept of LinkedList is self-referential structure.

Implementation of interface for mathematical Set Theory using C programming.

First, we are creating the structure as a typedef model to rename the user-defined name. In that, we are creating two data types 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 and list 2 using the for loop and using the many functions call in that. And then we are creating the different functions which are mentioned in the main program.

Creating two lists of data using the linked list method.

First:

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 head address and value from the user.

Inside the inserted node, we are creating the size of the list using the malloc function. 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.

we get a function call of getting union with the argument of head1 and head2 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 function as same as the function which is used for the creation of the linked list. Using another while loop 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 union in the list.

Getting Intersection, the 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 the different lists by using different arguments passing to the display function. So, creating the temporary 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 is last node.

Program:

#include<stdio.h>
#include<conio.h>
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,*head_union,*head_intersection,*newnode,*tail,*res_union,*res_intersection;//declaring the different variable in structure type
/* Declaring diffferent function with the argumrnts*/
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,Node *head_pointer2);
int compare(Node *head,int data);
void display_list(Node *head_ref)//function used to dispaly the nodes data .
{
	    if(head_ref == 0)
	    {
	        printf(" List is empty.");
	    }
	    else
	    {
	        tail = head_ref;//we are transfering address if the list to tail
	        while(tail != 0)
	        {
	            printf("%d ", tail->data);// prints the data of current node
	            tail = tail->next;// advances the position of current node
	        }
	        tail = newnode;
	    }
}

Node *insert_node(Node *head_ref,int n)//function used create the new list
{
		printf("\nInserting Elements at the beginning...\n");
		newnode =(Node*) malloc(sizeof(Node));//allocating the memory to the nodes
		printf("Address of created newnode :%d\n",newnode);
		newnode->data = n;//assigning the value to node
		printf("Inserted value is :%d\n",newnode->data);
		newnode->next = head_ref;//address of the pervious address is transfered to the new node
		head_ref = newnode;//transfering the new address to the head ref for linking new node
		return head_ref;
}

Node *get_union(Node *head_pointer1,Node *head_pointer2)//function used to union to list
{
	while(head_pointer1 != 0)
	{
			head_union = insert_node(head_union,head_pointer1->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_pointer2 != 0)
	{
		if(!compare(head_union,head_pointer2->data))//Here we are  insering the element from list 2 number where not in the in th list1 to the union
			head_union = insert_node(head_union,head_pointer2->data);//inserting the element not 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 lsit for instersection
        	head_intersection = insert_node(head_intersection,head_pointer1->data);//transferring the that value to the intersection
        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++)
		{
			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);//Displacing 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 < second_list_nodes;f++)
		{
			fflush(stdout);
			scanf("%d",&second_list_items);//getting the data in run time
			head2 = insert_node(head2,second_list_items);
		}
		display_list(head2);//Displacing 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 values as arguments to display function
		res_intersection = get_intersection(head1,head2);//Transferring the result of intersection function to the res intersection

		printf("Here is the result of intersection: ");//Transferring the result of intersection function to the res intersection
		display_list(res_intersection);//Transferring the values as arguments to display function

}

Output:

Enter the number of Nodes in first List:4

Enter 4 the elements:8