Scribd
Upload
19 views

DATA Structure Algorithm Assignment

The document discusses algorithms for common operations on doubly linked lists in C++ including insertion, deletion, reversing, merging, and swapping nodes. It includes functions to insert nodes at the beginning, delete a specified node, reverse the list, merge two lists, and swap two nodes by exchanging their next and prev pointers.

Uploaded by

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

DATA Structure Algorithm Assignment

The document discusses algorithms for common operations on doubly linked lists in C++ including insertion, deletion, reversing, merging, and swapping nodes. It includes functions to insert nodes at the beginning, delete a specified node, reverse the list, merge two lists, and swap two nodes by exchanging their next and prev pointers.

Uploaded by

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

Submitted by IFRA

Submitted to Sir Ghulam Jillani Waqas


Roll no : 0015-BSc.Engg-22
Data structure algorithm
Submission date : 2-10-23 ( Monday)
Assignment no 2:
Doubly linked list [Deletion ( at start, at end, in b/w),Reversing the DLL, Merge
sort for DLL, Swapping of 2 nodes]using algo / c++
#include <iostream>
Using namespace std;

// Node structure for doubly linked list


Struct Node {
Int data;

Node* prev;
Node* next;
};

// Function to insert a node at the beginning of the list


Void insertAtBeginning(Node** head, int newData) {
Node* newNode = new Node();
newNode->data = newData;
newNode->prev = NULL;

newNode->next = (*head);

if (*head != NULL)
(*head)->prev = newNode;
*head = newNode;
}

// Function to delete a node from the list


Void deleteNode(Node** head, Node* delNode) {
If (*head == NULL || delNode == NULL)

Return;

If (*head == delNode)
*head = delNode->next;

If (delNode->next != NULL)
delNode->next->prev = delNode->prev;

if (delNode->prev != NULL)

delNode->prev->next = delNode->next;

delete delNode;
}

// Function to reverse the doubly linked list


Void reverseList(Node** head) {
Node* temp = NULL;

Node* current = *head;

While (current != NULL) {


Temp = current->prev;
Current->prev = current->next;
Current->next = temp;

Current = current->prev;
}

If (temp != NULL)

*head = temp->prev;
}

// Function to merge two doubly linked lists

Node* mergeLists(Node* head1, Node* head2) {


If (head1 == NULL)
Return head2;
If (head2 == NULL)
Return head1;

Node* merged = NULL;

If (head1->data <= head2->data) {


Merged = head1;
Merged->next = mergeLists(head1->next, head2);
} else {
Merged = head2;

Merged->next = mergeLists(head1, head2->next);


}
Merged->next->prev = merged;
Return merged;
}

// Function to swap two nodes in the list


Void swapNodes(Node** head, int x, int y) {
If (x == y)

Return;

Node* nodeX = NULL, *nodeY = NULL;


Node* temp = *head;

While (temp != NULL) {


If (temp->data == x)
nodeX = temp;
else if (temp->data == y)
nodeY = temp;

temp = temp->next;
}

If (nodeX == NULL || nodeY == NULL)


Return;

If (nodeX->prev != NULL)
nodeX->prev->next = nodeY;

else
*head = nodeY;
If (nodeY->prev != NULL)
nodeY->prev->next = nodeX;
else

*head = nodeX;

If (nodeX->next != NULL)
nodeX->next->prev = nodeY;

if (nodeY->next != NULL)
nodeY->next->prev = nodeX;

Node* tempLink = nodeX->next;

nodeX->next = nodeY->next;
nodeY->next = tempLink;

tempLink = nodeX->prev;
nodeX->prev = nodeY->prev;

nodeY->prev = tempLink;
}

// Function to display the doubly linked list


Void displayList(Node* node) {
While (node != NULL) {
Cout << node->data << “ “;
Node = node->next;

}
Cout << endl;
}
// Driver code
Int main() {

Node* head = NULL;

// Inserting nodes
insertAtBeginning(&head, 4);

insertAtBeginning(&head, 3);
insertAtBeginning(&head, 2);
insertAtBeginning(&head, 1);

cout << “Original List: “;


displayList(head);

// Deleting a node
deleteNode(&head, head->next->next);

cout << “List after deletion: “;


displayList(head);

// Reversing the list


reverseList(&head);
cout << “Reversed List: “;
displayList(head);

// Creating another linked list


Node* head2 = NULL;
insertAtBeginning(&head2, 8);
insertAtBeginning(&head2, 6);
insertAtBeginning(&head2, 5);

cout << “List 2: “;


displayList(head2);

// Merging two lists

Head = mergeLists(head, head2);


Cout << “Merged List: “;
displayList(head);

// Swapping nodes
swapNodes(&head, 3, 6);
cout << “List after swapping: “;
displayList(head);

return 0;
}

You might also like