1.

Inserting a node into a sorted Doubly Linked List

DoublyLinkedListNode* sortedInsert(DoublyLinkedListNode* head, int data) {

DoublyLinkedListNode *New = create_doubly_linked_list_node(data);

if (!head)

head = New;

return head;

else if (data < (head->data))

New->next = head;

head->prev = New;

New->prev = NULL;

head = New;

return head;

else

DoublyLinkedListNode *temp = head;

while ( ((temp->next) != NULL) && ((temp->next->data) <= data))

temp = temp->next;

if (temp->next != NULL)

DoublyLinkedListNode *next = temp->next;

next->prev = New;

New->next = next;

else

New->next = NULL;
 temp->next = New;

New->prev = temp;

return head;

2.Reverse a Doubly Linked List

DoublyLinkedListNode* reverse(DoublyLinkedListNode* llist) {

if(llist==NULL || llist->next==NULL){
return llist;
}
DoublyLinkedListNode* curr= llist;
while(curr!=NULL){
if (curr->next == NULL)
llist = curr;
DoublyLinkedListNode* temp=curr->next;
curr->next=curr->prev;
curr->prev=temp;
curr=curr->prev;
}
return llist;
}
1. Write a c program to find Sum of Elements in CLL

#include <stdio.h>

#include <stdlib.h>

struct Node {

int data;

struct Node *next;

};
struct Node* insertEnd(struct Node* last, int data) {

if (last == NULL) {

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

newNode->data = data;

newNode->next = newNode;

return newNode;

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

newNode->data = data;

newNode->next = last->next;

last->next = newNode;

return newNode;

int sumOfElements(struct Node* last) {

if (last == NULL)

return 0;

struct Node* current = last->next;

int sum = 0;

do {

sum += current->data;

current = current->next;

} while (current != last->next);

return sum;

}
int main() {

struct Node* last = NULL;

int n, data;

scanf("%d", &n);

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

scanf("%d", &data);

last = insertEnd(last, data);

int sum = sumOfElements(last);

printf("%d\n", sum);

return 0;

Post lab

1. Node* removeDuplicates(Node* head) {

if (head == NULL || head->next == NULL) {
return head;
}

Node* current = head;

while (current->next != NULL) {
if (current->data == current->next->data) {
Node* temp = current->next;
current->next = current->next->next;
free(temp);
} else {

current = current->next;
}
}
return head;
}
};
 2. CYCLE
bool has_cycle(SinglyLinkedListNode* head) {

SinglyLinkedListNode* fast=head;

SinglyLinkedListNode* slow=head;

while(fast->next!=NULL && fast->next->next!=NULL){

fast=fast->next->next;

slow=slow->next;

if(fast==slow)

return 1;

return 0;

SKILL

1. DESIGN LINKEDLIST

struct Node {

int val;

struct Node *next;

};

typedef struct MyLinkedList{

struct Node *head;

} MyLinkedList;

struct Node *createNode(int val)

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

newNode->next = NULL;
 newNode->val = val;

return newNode;

MyLinkedList* myLinkedListCreate() {

MyLinkedList *obj = malloc(sizeof(MyLinkedList));

obj->head = NULL;

return obj;

int myLinkedListGet(MyLinkedList* obj, int index) {

struct Node *current = obj->head;

if(index == 0 && current)

return current->val;

else if(index == 0 && !current)

return -1;

else

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

if(current->next)

current = current->next;

else

return -1;

return current->val;

void myLinkedListAddAtHead(MyLinkedList* obj, int val) {

if(obj->head == NULL)

obj->head = createNode(val);
 else

struct Node *temp = obj->head;

obj->head = createNode(val);

obj->head->next = temp;

void myLinkedListAddAtTail(MyLinkedList* obj, int val) {

struct Node *current;

if(!obj->head)

myLinkedListAddAtHead(obj,val);

else

current = obj->head;

while(current->next != NULL)

current = current->next;

current->next = createNode(val);

void myLinkedListAddAtIndex(MyLinkedList* obj, int index, int val) {

struct Node *current = obj->head;

struct Node *temp;

if(index == 0)

myLinkedListAddAtHead(obj,val);

else if(index > 0 && current)

for(int i = 1;i<index;i++)
 {

if(current->next)

current = current->next;

else

return;

temp = current->next;

current->next = createNode(val);

current = current->next;

current->next = temp;

else

return;

void myLinkedListDeleteAtIndex(MyLinkedList* obj, int index) {

struct Node *current = obj->head;

struct Node *deleteNode;

if(index == 0 && current->next)

obj->head = current->next;

free(current);

else if(index == 0 && !current->next)

obj->head = NULL;

else if(current->next)

for(int i = 1;i < index; i++)

 {

if(current->next->next)

current = current->next;

else

return;

deleteNode = current->next;

current->next = deleteNode->next;

//free the deleted node from the heap's memory

free(deleteNode);

void myLinkedListFree(MyLinkedList* obj) {

struct Node *temp = obj->head;

struct Node *next;

if(temp && temp->next)

next = temp->next;

free(temp);

while(next->next)

temp = next;

next = next->next;

free(temp);

free(next);

else if(temp)

{
 free(temp);

else

return;

void display(MyLinkedList* obj)

struct Node * current = obj->head;

printf("Data in all linked list: ");

if(obj->head == NULL)

printf("NULL\n");

return;

while(current != NULL)

printf("%d ", current->val);

current = current->next;

printf("\n");

2. Flatten a Multilevel Doubly Linked List

Node* flatten(Node* head) {

for (Node* h = head; h; h = h->next){

if (h->child){

Node* next = h->next;

h->next = h->child;

h->next->prev = h;

h->child = NULL;
 Node* temp = h->next;

while (temp->next) temp = temp->next;

temp->next = next;

if (next) next->prev = temp;

return head;

3.Find the Winner of the Circular Game

int findTheWinner(int n, int k) {

int last=1;

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

last=(last+k-1)%i+1;

return last;

3. Linked List Cycle II

struct ListNode *detectCycle(struct ListNode *head) {

struct ListNode* p1 = head, *p2 = head;

while (p2 != NULL && p2->next != NULL) {

p1 = p1->next;

p2 = p2->next->next;

if (p1 == p2) break;

if (p2 == NULL || p2->next == NULL) return NULL;

while (head != p1) {

head = head->next;
 p1 = p1->next;

return head;

5.LARGEST ELEMENT IN A DOUBLY LINKED LIST

#include <stdio.h>

#include <string.h>

#include <math.h>

#include <stdlib.h>

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

void findMaxAndPredecessor(struct Node* head) { if (head == NULL) { printf("The list is empty.\n");

return; }

struct Node* maxNode = head;

struct Node* temp = head->next;

while (temp != NULL) {

if (temp->data > maxNode->data) {

maxNode = temp;

temp = temp->next;

if (maxNode->prev != NULL) {

printf("%d\n", maxNode->prev->data);

} else {

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

int main() { int n; scanf("%d",&n); struct Node* head = (struct Node*)malloc(sizeof(struct Node));
head->data = n; head->next = NULL; head->prev = NULL;

findMaxAndPredecessor(head);
return 0;

6. DELETE THE ELEMENT FROM A SPECIFIED POSITION IN A DOUBLY LINKED LIST

#include <stdio.h>

#include <string.h>

#include <math.h>

#include <stdlib.h>

struct Node

int data;

struct Node *next;

struct Node *pre;

};

struct Node *head=NULL;

void create()

struct Node *New,*temp;

temp=head;

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

scanf("%d",&New->data);

New->next=NULL;

if(head==NULL){

head=New;

head->pre= NULL;

else

{
 while(temp->next!=NULL)

temp=temp->next;

temp->next=New;

New-> pre=temp;

void display()

struct Node *temp;

temp=head;

while(temp!=NULL)

printf("%d deleted",temp->data);

temp=temp->next;

void del_pos()

struct Node *temp;

temp=head;

head=head->next;

head->pre=NULL;

free(temp);

int main() {

create();

//del_pos();

display();

return 0;
}