Scribd
Upload
13 views

Assignment 1 Singly Linked list by Jeetansh Arora

The document outlines a programming assignment involving operations on singly linked lists, doubly linked lists, and circular linked lists. It includes functions for union, intersection, insertion, sorting, counting elements, summing integers, concatenating lists, moving nodes, and performing polynomial operations. Additionally, it covers recursive counting of nodes and operations for adding and dividing polynomials.

Uploaded by

harshitchoudhar8
Copyright
© © All Rights Reserved
We take content rights seriously. If you suspect this is your content, claim it here.
Available Formats
Download as DOCX, PDF, TXT or read online on Scribd
13 views

Assignment 1 Singly Linked list by Jeetansh Arora

The document outlines a programming assignment involving operations on singly linked lists, doubly linked lists, and circular linked lists. It includes functions for union, intersection, insertion, sorting, counting elements, summing integers, concatenating lists, moving nodes, and performing polynomial operations. Additionally, it covers recursive counting of nodes and operations for adding and dividing polynomials.

Uploaded by

harshitchoudhar8
Copyright
© © All Rights Reserved
We take content rights seriously. If you suspect this is your content, claim it here.
Available Formats
Download as DOCX, PDF, TXT or read online on Scribd
You are on page 1/ 10

Assignment – 01

Roll no: 241030416


Name : Samriddha Kundu
Batch: 24A11

1. Form a list containing the UNION of the elements of two lists


(singly linked list).

#include <stdio.h>

#include <stdlib.h>

struct Node {

int data;

struct Node* next;

};

struct Node* createNode(int data) {

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

newNode->data = data;

newNode->next = NULL;

return newNode;

void appendNode(struct Node** head, int data) {

struct Node* newNode = createNode(data);

if (*head == NULL) {

*head = newNode;

return;

struct Node* temp = *head;

while (temp->next != NULL) {


temp = temp->next;

temp->next = newNode;

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

struct Node* temp = head;

while (temp != NULL) {

if (temp->data == data) return 1;

temp = temp->next;

return 0;

struct Node* unionLists(struct Node* head1, struct Node* head2) {

struct Node* result = NULL;

struct Node* temp = head1;

while (temp != NULL) {

appendNode(&result, temp->data);

temp = temp->next;

temp = head2;

while (temp != NULL) {

if (!isPresent(result, temp->data)) {

appendNode(&result, temp->data);

temp = temp->next;

return result;

}
2. Form a list containing the INTERSECTION of the elements of
two lists (singly linked list).

struct Node* intersectLists(struct Node* head1, struct Node* head2) {


struct Node* result = NULL;
struct Node* temp1 = head1;
while (temp1 != NULL) {
struct Node* temp2 = head2;
while (temp2 != NULL) {
if (temp1->data == temp2->data && !isPresent(result, temp1-
>data)) {
appendNode(&result, temp1->data);
}
temp2 = temp2->next;
}
temp1 = temp1->next;
}
return result;
}

3. Insert an element after the nth element of a list (singly linked


list).

void insertAfterNth(struct Node* head, int n, int newData) {


struct Node* temp = head;
for (int i = 0; i < n - 1 && temp != NULL; i++) {
temp = temp->next;
}
if (temp != NULL) {
struct Node* newNode = createNode(newData);
newNode->next = temp->next;
temp->next = newNode;
}
}

4. Place the elements of a list in increasing order (singly linked


list).

void sortList(struct Node** head) {


struct Node* current = *head;
struct Node* nextNode;
int temp;
while (current != NULL) {
nextNode = current->next;
while (nextNode != NULL) {
if (current->data > nextNode->data) {
temp = current->data;
current->data = nextNode->data;
nextNode->data = temp;
}
nextNode = nextNode->next;
}
current = current->next;
}
}

5. Return the number of element in a list (singly linked list).

int countElements(struct Node* head) {


int count = 0;
struct Node* temp = head;
while (temp != NULL) {
count++;
temp = temp->next;
}
return count;
}

6. Return the sum of integers in a list (doubly linked list)

struct DNode {
int data;
struct DNode* next;
struct DNode* prev;
};

int sumDoublyList(struct DNode* head) {


int sum = 0;
struct DNode* temp = head;
while (temp != NULL) {
sum += temp->data;
temp = temp->next;
}
return sum;
}

7. Concatenate two lists (circular singly linked list)

struct Node* concatenateCircularLists(struct Node* head1, struct Node*


head2) {
if (head1 == NULL) return head2;
if (head2 == NULL) return head1;

struct Node* temp = head1;


while (temp->next != head1) {
temp = temp->next;
}
temp->next = head2;

temp = head2;
while (temp->next != head2) {
temp = temp->next;
}
temp->next = head1;
return head1;
}

8. Move node (p) forward n position in the list (circular doubly


linked list).

void moveNodeForward(struct DNode** head, int p, int n) {


struct DNode* temp = *head;
for (int i = 0; i < p; i++) {
temp = temp->next;
}
struct DNode* movingNode = temp;
for (int i = 0; i < n; i++) {
movingNode = movingNode->next;
}
// Adjust pointers to move the node forward
}

9. Recursive function to find number of nodes in a linked list


(singly linked list).

int countNodesRecursive(struct Node* head) {


if (head == NULL) return 0;
return 1 + countNodesRecursive(head->next);
}

10. Addition of long positive integers using circular lists


struct Node* addLongIntegersCircular(struct Node* head1, struct Node*
head2) {
// Initialize a result list and add corresponding digits with carry
}

11. Addition of long integers using doubly linked lists

struct DNode* addLongIntegersDoubly(struct DNode* head1, struct


DNode* head2) {
// Initialize a result list and add corresponding digits with carry
}

12. Represent polynomial in three variables ( x, y, and z) be


represented by a circular list

struct PolyNode {
int coeff;
int x;
int y;
int z;
struct PolyNode* next;
};

struct PolyNode* representPolynomial() {


// Create a circular linked list to represent polynomial terms
}

13. Add two polynomial (singly linked list)


struct PolyNode* addPolynomials(struct PolyNode* head1, struct
PolyNode* head2) {
// Initialize a result list and add corresponding terms
}

14. Multiply two polynomial (singly linked list).

struct PolyNode* multiplyPolynomials(struct PolyNode* head1,


struct PolyNode* head2) {
// Initialize a result list and multiply corresponding terms
}

15. Take the PARTIAL DERIVATIVE of polynomial with respect


to any of its variables. (doubly linked list)

struct PolyNode* partialDerivative(struct PolyNode* head, char variable) {


// Derive the polynomial with respect to the given variable
}

16. Divide the polynomial by another polynomial creating a


QUOTIENT and a REMAINDER polynomial ( singly circular
linked list)

struct PolyNode* dividePolynomials(struct PolyNode* head1, struct


PolyNode* head2) {
// Initialize quotient and remainder lists and perform division
}

You might also like