NAME= ANURAG YADAV

STUDENT ID=202212095

M.Sc IT

SEM-1

LAB02

1.Reverse singly list

// dsa.cpp : This file contains the 'main' function. Program execution begins and ends there.

#include<iostream>
using namespace std;

struct node {
int data;
struct node* next;
};

void insert(struct node** head_ref, int data) {

struct node* node;
node = (struct node*)malloc(sizeof(struct node));
node->data = data;
node->next = (*head_ref);
(*head_ref) = node;
}

void reverse(struct node** head_ref) {

struct node* nxt = NULL;
struct node* prev = NULL;
struct node* current = (*head_ref);
while (current != NULL) {
nxt = current->next;
current->next = prev;
prev = current;
current = nxt;
}
(*head_ref) = prev;
}

void printnodes(struct node* head) {

while (head != NULL) {
cout << head->data << " ";
head = head->next;
}
 }

int main() {
struct node* head = NULL;
insert(&head, 1);
insert(&head, 3);
insert(&head, 2);
insert(&head, 5);
insert(&head, 4);
cout << "Linked List Before Reversing" << endl;
printnodes(head);
reverse(&head);
cout << endl;
cout << "Linked List After Reversing" << endl;
printnodes(head);
return 0;
}

2. Remove duplicated from sorted linked list

#include <iostream>
using namespace std;
class Node
{
public:
int data;
 Node* next;
};

void removeDuplicates(Node* head)

{
Node* current = head;

Node* next_next;

if (current == NULL)
return;

while (current->next != NULL)

{
if (current->data == current->next->data)
{
next_next = current->next->next;
free(current->next);
current->next = next_next;
}
else
{
current = current->next;
}
}
}

void push(Node** head_ref, int new_data)

{

Node* new_node = new Node();

new_node->data = new_data;

new_node->next = (*head_ref);

(*head_ref) = new_node;
}
void printList(Node* node)
{
while (node != NULL)
{
cout << " " << node->data;
node = node->next;
}
}

int main()
{
Node* head = NULL;
 push(&head, 4);
push(&head, 4);
push(&head, 3);
push(&head, 2);
push(&head, 2);
push(&head, 1);

cout << "Linked list before duplicate removal "<<endl;

printList(head);

removeDuplicates(head);

cout << "\nLinked list after duplicate removal "<<endl;

printList(head);

return 0;
}

3. Count nodes in circular linked list

#include <iostream>
struct node {
int data;
struct node* next;
};
void push(struct node** head_ref, int data) {
struct node* ptr1 = (struct node*)malloc(sizeof(struct node));
struct node* temp = *head_ref;
ptr1->data = data;
ptr1->next = *head_ref;

if (*head_ref != NULL) {
while (temp->next != *head_ref) {
temp = temp->next;
}
temp->next = ptr1;
}
else {
ptr1->next = ptr1;
}
*head_ref = ptr1;
}

int count_fun(struct node* head) {

struct node* temp = head;
int result = 0;
if (head != NULL) {
do {
temp = temp->next;
result++;
} while (temp != head);
}
return result;
}
int main() {

struct node* head = NULL;

push(&head, 10);
push(&head, 20);
push(&head, 30);
push(&head, 40);
printf("count of nodes are: %d", count_fun(head));
return 0;
}
4.Delete element from doubly linked list (position wise)

include<iostream>
using namespace std;

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

void deleteNode(struct Node** head_ref, struct Node* del)

{
if (*head_ref == NULL || del == NULL)
return;

if (*head_ref == del)
*head_ref = del->next;

if (del->next != NULL)
del->next->prev = del->prev;

if (del->prev != NULL)
 del->prev->next = del->next;

free(del);
}

void deleteNodeAtGivenPos(struct Node** head_ref, int n)

{

if (*head_ref == NULL || n <= 0)

return;

struct Node* current = *head_ref;

int i;

for (int i = 1; current != NULL && i < n; i++)

current = current->next;

if (current == NULL)
return;

deleteNode(head_ref, current);
}

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

{

struct Node* new_node =

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

new_node->data = new_data;

new_node->prev = NULL;

new_node->next = (*head_ref);

if ((*head_ref) != NULL)
(*head_ref)->prev = new_node;

(*head_ref) = new_node;
}

void printList(struct Node* head)

{
while (head != NULL) {
cout << head->data << " ";
head = head->next;
 }
}
int main()
{

struct Node* head = NULL;

push(&head, 5);
push(&head, 4);
push(&head, 3);
push(&head, 2);
push(&head, 1);
cout << "Doubly linked list before deletion: ";
printList(head);
int n;
cout <<endl<< "enter n=";
cin >> n;
cout << endl;

deleteNodeAtGivenPos(&head, n);

cout << "Doubly linked list after deletion : ";

printList(head);

return 0;
}

5. Find the middle element of the singly linked list

#include <iostream>
using namespace std;

struct node
{
int num;
node* nextptr;
}*stnode;

void make(int n)
{
struct node* frntNode, * tmp;
int num, i;

stnode = (struct node*)malloc(sizeof(struct node));

if (stnode == NULL)
{
cout << "Memory can not be allocated";
}
else
{

cout << "Enter the data for node 1: ";

cin >> num;
stnode->num = num;
stnode->nextptr = NULL;
tmp = stnode;

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

{
frntNode = (struct node*)malloc(sizeof(struct node));

if (frntNode == NULL)
{
cout << "Memory can not be allocated";
break;
}
else
{
cout << "Enter the data for node= " << i << ": ";
cin >> num;
frntNode->num = num;
frntNode->nextptr = NULL;
tmp->nextptr = frntNode;
tmp = tmp->nextptr;
}
}
}
}
void print()
{
struct node* tmp;
if (stnode == NULL)
{
cout << "List is empty";
}
else
{
tmp = stnode;
cout << "Linked List=\t";
while (tmp != NULL)
{
cout << tmp->num << "\t";
tmp = tmp->nextptr;
}
}
}
void printMiddle(struct node* stnode)
{
struct node* single_ptr = stnode;
struct node* twice_ptr = stnode;

if (stnode != NULL)
{
while (twice_ptr != NULL && twice_ptr->nextptr != NULL)
{
twice_ptr = twice_ptr->nextptr->nextptr;
single_ptr = single_ptr->nextptr;
}
cout <<endl<< "The middle element is= " << single_ptr->num;
}
}
int main()
{
int n, num;

cout << "Enter the number of nodes= ";

cin >> n;
make(n);
cout << "\nLinked list data= \n";
print();
printMiddle(stnode);

return 0;
}