Scribd
Upload
20 views

Data Assignment 1

The document discusses different types of linked lists including singly linked lists, doubly linked lists and circular linked lists. It provides C++ implementations for each with functions to insert, delete and search nodes. The time complexity of each function is also specified.

Uploaded by

Rafay Naveed
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
20 views

Data Assignment 1

The document discusses different types of linked lists including singly linked lists, doubly linked lists and circular linked lists. It provides C++ implementations for each with functions to insert, delete and search nodes. The time complexity of each function is also specified.

Uploaded by

Rafay Naveed
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/ 13

Question 1

1. T(n) = 3n^2 + 1000n + 360


o Dominant term: 3n^2
o Big O notation: O(n^2)
2. T(n) = 120n + 4n log(n) + 3
o Dominant term: 4n log(n)
o Big O notation: O(n log(n))
3. T(n) = 50 log(n) + 0.3 log(n)^2 + 25
o Dominant term: log(n)^2
o Big O notation: O(log(n)^2)
4. T(n) = 30n^2 + 45n! + 66
o Dominant term: 45n!
o Big O notation: O(n!)
5. T(n) = n log(n) + 15 log(n)^2 + 4
o Dominant term: 15 log(n)^2
o Big O notation: O(log(n)^2)

Question 2
#include <iostream>
using namespace std;
struct Node
{
int data;
Node* next;
Node(int val) : data(val), next(NULL) {}
};
class LinkedList
{
private:
Node* head = NULL;
public:

void insertNodeAtBeginning(int data) // Worst-case complexity: O(1)


{
Node* newNode = new Node(data);
newNode->next = head;
head = newNode;
}
void insertNodeInMiddle(int data, int key) // Worst-case complexity: O(n)
{
Node* newNode = new Node(data);
Node* temp = head;
while (temp != NULL && temp->data != key)
{
temp = temp->next;
}
if (temp != NULL)
{
newNode->next = temp->next;
temp->next = newNode;
}
}
void insertNodeAtEnd(int data) // Worst-case complexity: O(n)
{
Node* newNode = new Node(data);
if (head == NULL)
{
head = newNode;
}
else {
Node* temp = head;
while (temp->next != NULL)
{
temp = temp->next;
}
temp->next = newNode;
}
}
bool deleteFirstNode() // Worst-case complexity: O(1)
{
if (head == NULL)
{
return false;
}
Node* temp = head;
head = head->next;
delete temp;
return true;
}
bool deleteNode(int key) // Worst-case complexity: O(n)
{
if (head == NULL)
{
return false;
}
if (head->data == key)
{
Node* temp = head;
head = head->next;
delete temp;
return true;
}
Node* prev = head;
Node* curr = head->next;
while (curr != NULL && curr->data != key)
{
prev = curr;
curr = curr->next;
}
if (curr != NULL)
{
prev->next = curr->next;
delete curr;
return true;
}
return false;
}
bool deleteLastNode() // Worst-case complexity: O(n)
{
if (head == NULL)
{
return false;
}
if (head->next == NULL)
{
delete head;
head = NULL;
return true;
}
Node* prev = NULL;
Node* curr = head;
while (curr->next != NULL)
{
prev = curr;
curr = curr->next;
}
delete curr;
prev->next = NULL;
return true;
}
void display() // Worst-case complexity: O(n)
{
Node* temp = head;
while (temp != NULL)
{
cout << temp->data << " ";
temp = temp->next;
}
cout <<endl;
}
bool search(int data) // Worst-case complexity: O(n)
{
Node* temp = head;
while (temp != NULL)
{
if (temp->data == data)
{
return true;
}
temp = temp->next;
}
return false;
}
};

int main()
{
LinkedList list;
list.insertNodeAtBeginning(1);
list.insertNodeAtEnd(4);
list.insertNodeInMiddle(2, 1);
list.display();
list.deleteNode(2);
list.display();

system("pause");
return 0;
}

Question 3
Doubly linked list:

#include <iostream>
using namespace std;
struct Node
{
int data;
Node* prev;
Node* next;
};
class DoublyLinkedList
{
private:

Node* head = NULL;

public:

void insertNodeAtBeginning(int data) // Time Complexity: O(1)


{
Node* newNode = new Node();
newNode->data = data;
newNode->prev = NULL;
newNode->next = head;
if (head != NULL)
{
head->prev = newNode;
}
head = newNode;
}
void insertNodeInMiddle(int data, int key) // Time Complexity: O(n)
{
Node* newNode = new Node();
newNode->data = data;
Node* current = head;
while (current != NULL && current->data != key)
{
current = current->next;
}
if (current != NULL)
{
newNode->prev = current;
newNode->next = current->next;
if (current->next != NULL)
{
current->next->prev = newNode;
}
current->next = newNode;
}
}
void insertNodeAtEnd(int data) // Time Complexity: O(n)
{
Node* newNode = new Node();
newNode->data = data;
newNode->next = NULL;
if (head == NULL)
{
newNode->prev = NULL;
head = newNode;
return;
}
Node* last = head;
while (last->next != NULL)
{
last = last->next;
}
last->next = newNode;
newNode->prev = last;
}
// Time Complexity: O(1)
bool deleteFirstNode()
{
if (head == NULL)
{
return false;
}
Node* temp = head;
head = head->next;
if (head != NULL)
{
head->prev = NULL;
}
delete temp;
return true;
}
bool deleteNode(int key) // Time Complexity: O(n)
{
Node* current = head;
while (current != NULL && current->data != key)
{
current = current->next;
}
if (current == NULL)
{
return false;
}
if (current->prev != NULL)
{
current->prev->next = current->next;
}
else
{
head = current->next;
}
if (current->next != NULL)
{
current->next->prev = current->prev;
}
delete current;
return true;
}
bool deleteLastNode() // Time Complexity: O(n)
{
if (head == NULL)
{
return false;
}
Node* last = head;
while (last->next != NULL)
{
last = last->next;
}
if (last->prev != NULL)
{
last->prev->next = NULL;
}
else
{
head = NULL;
}
delete last;
return true;
}
void display() // Time Complexity: O(n)
{
Node* current = head;
while (current != NULL)
{
cout << current->data << " ";
current = current->next;
}
cout << endl;
}
bool search(int data) // Time Complexity: O(n)
{
Node* current = head;
while (current != NULL)
{
if (current->data == data)
{
return true;
}
current = current->next;
}
return false;
}
};

int main()
{
DoublyLinkedList dll;
dll.insertNodeAtBeginning(1);
dll.insertNodeAtEnd(3);
dll.insertNodeInMiddle(2, 1);
dll.display();

dll.deleteNode(2);
dll.display();

system("pause");
return 0;
}

Circular linked list:


#include <iostream>
using namespace std;
struct Node
{
int data;
Node* next;
};
class LinkedList
{
private:
Node* head = NULL;
public:

void insertNodeAtBeginning(int data)


{
Node* newNode = new Node;
newNode->data = data;
if (head == NULL)
{
head = newNode;
newNode->next = head;
}
else
{
Node* temp = head;
while (temp->next != head)
{
temp = temp->next;
}
temp->next = newNode;
newNode->next = head;
head = newNode;
}
}
void insertNodeInMiddle(int data, int key)
{
Node* newNode = new Node;
newNode->data = data;
if (head == NULL)
{
head = newNode;
newNode->next = head;
}
else
{
Node* temp = head;
while (temp->data != key && temp->next != head)
{
temp = temp->next;
}
if (temp->data == key)
{
Node* nextNode = temp->next;
temp->next = newNode;
newNode->next = nextNode;
}
else
{
cout << "Key not found in the LinkedList." << endl;
}
}
}
void insertNodeAtEnd(int data)
{
Node* newNode = new Node;
newNode->data = data;
if (head == NULL)
{
head = newNode;
newNode->next = head;
}
else
{
Node* temp = head;
while (temp->next != head)
{
temp = temp->next;
}
temp->next = newNode;
newNode->next = head;
}
}
bool deleteFirstNode()
{
if (head == NULL)
{
cout << "LinkedList is empty." << endl;
return false;
}
else {
Node* temp = head;
if (temp->next == head)
{
delete temp;
head = NULL;
}
else
{
Node* lastNode = head;
while (lastNode->next != head)
{
lastNode = lastNode->next;
}
head = temp->next;
lastNode->next = head;
delete temp;
}
return true;
}
}
bool deleteNode(int key)
{
if (head == NULL)
{
cout << "LinkedList is empty." << endl;
return false;
}
else
{
Node* temp = head;
Node* prev = NULL;
while (temp->data != key && temp->next != head)
{
prev = temp;
temp = temp->next;
}
if (temp->data == key)
{
if (temp == head)
{
deleteFirstNode();
}
else
{
prev->next = temp->next;
delete temp;
}
return true;
}
else
{
cout << "Key not found in the LinkedList." << endl;
return false;
}
}
}
bool deleteLastNode()
{
if (head == NULL)
{
cout << "LinkedList is empty." << endl;
return false;
}
else
{
Node* temp = head;
Node* prev = NULL;
while (temp->next != head)
{
prev = temp;
temp = temp->next;
}
if (temp == head)
{
deleteFirstNode();
}
else
{
prev->next = head;
delete temp;
}
return true;
}
}
void display()
{
if (head == NULL)
{
cout << "LinkedList is empty." << endl;
}
else
{
Node* temp = head;
do
{
cout << temp->data << " ";
temp = temp->next;
} while (temp != head);
cout << endl;
}
}
bool search(int data)
{
if (head == NULL)
{
cout << "LinkedList is empty." << endl;
return false;
}
else
{
Node* temp = head;
do {
if (temp->data == data)
{
cout << "Data found in the LinkedList." << endl;
return true;
}
temp = temp->next;
} while (temp != head);
cout << "Data not found in the LinkedList." << endl;
return false;
}
}
};
int main()
{
LinkedList list;
list.insertNodeAtBeginning(10);
list.insertNodeAtEnd(20);
list.insertNodeInMiddle(15, 10);
list.display();
list.deleteNode(20);
list.display();
list.search(15);
list.search(30);

system("pause");
return 0;
}

Question:4
#include <iostream>
using namespace std;
class Node
{
public:
int data;
Node* next;
Node(int value) : data(value), next(nullptr) {}
};
class LinkedList
{
public:
Node* head;
LinkedList() : head(nullptr) {}

void insertAtStart(int value)


{
Node* newNode = new Node(value);
newNode->next = head;
head = newNode;
}
void display()
{
Node* current = head;
while (current != nullptr)
{
cout << current->data << " ";
current = current->next;
}
cout << endl;
}
Node* merge(Node* left, Node* right)
{
Node* result = nullptr;

if (left == nullptr) return right;


if (right == nullptr) return left;

if (left->data <= right->data)


{
result = left;
result->next = merge(left->next, right);
}
else
{
result = right;
result->next = merge(left, right->next);
}
return result;
}
void mergeSort()
{
head = mergeSort(head);
}
Node* mergeSort(Node* head)
{
if (head == nullptr || head->next == nullptr) return head;

Node* mid = nullptr;


Node* temp = head;

while (temp != nullptr && temp->next != nullptr)


{
mid = (mid == nullptr) ? temp : mid->next;
temp = temp->next->next;
}
Node* right = mid->next;
mid->next = nullptr;

Node* leftSorted = mergeSort(head);


Node* rightSorted = mergeSort(right);

return merge(leftSorted, rightSorted);


}
};
int main()
{
LinkedList list;
list.insertAtStart(3);
list.insertAtStart(7);
list.insertAtStart(1);
list.insertAtStart(5);
list.insertAtStart(4);

cout << "Before sorting: ";


list.display();

list.mergeSort();

cout << "After sorting: ";


list.display();
system("pause");
return 0;
}

Question:5
#include <iostream>
using namespace std;

struct Node {
int data;
Node* next;
};
class CircularLinkedList
{
private:
Node* head;

public:
CircularLinkedList() : head(nullptr) {}

void insert(int value)


{
Node* newNode = new Node();
newNode->data = value;

if (head == nullptr)
{
newNode->next = newNode;
head = newNode;
}
else
{
newNode->next = head->next;
head->next = newNode;
head = newNode;
}
}
void shift(int n)
{
if (head == nullptr)
{
return;
}
while (n < 0)
{
n += 1;
head = head->next;
}
while (n > 0)
{
n -= 1;
Node* current = head;
while (current->next != head)
{
current = current->next;
}
head = current;
}
}
void display()
{
if (head == nullptr)
{
cout << "Circular Linked List is empty" << endl;
return;
}
Node* current = head;
do {
cout << current->data << " ";
current = current->next;
} while (current != head);
cout << endl;
}
};

int main()
{
CircularLinkedList list;

list.insert(1);
list.insert(2);
list.insert(3);
list.insert(4);
list.insert(5);
cout << "Circular Linked List before shifting: ";
list.display();

list.shift(2);
cout << "Circular Linked List after shifting: ";
list.display();

system("pause");
return 0;
}

You might also like