From 35dfbbd0c2df36879456d21e49de277abf7a68de Mon Sep 17 00:00:00 2001 From: Dishant Pal <98953611+dishant4163@users.noreply.github.com> Date: Thu, 12 Sep 2024 11:40:54 +0530 Subject: [PATCH] adding Add_1_To_A_NumberRepresentedByLL.c++ --- .../Add_1_To_A_NumberRepresentedByLL.c++ | 234 ++++++++++++++++++ 1 file changed, 234 insertions(+) create mode 100644 Lecture051 Linked List Day8/Add_1_To_A_NumberRepresentedByLL.c++ diff --git a/Lecture051 Linked List Day8/Add_1_To_A_NumberRepresentedByLL.c++ b/Lecture051 Linked List Day8/Add_1_To_A_NumberRepresentedByLL.c++ new file mode 100644 index 00000000..19fd3da9 --- /dev/null +++ b/Lecture051 Linked List Day8/Add_1_To_A_NumberRepresentedByLL.c++ @@ -0,0 +1,234 @@ +/*//Add 1 to a Number Represented by LL_Coding Ninja -> https://tinyurl.com/3hrjsb36 + +int addCarry(Node* temp) { + //Base case of recursive function + if (temp == NULL) return 1; + + int carry = addCarry(temp->next); + //start backtracking the recursive stackspace + temp->data += carry; + + if (temp->data < 10) return 0; + temp->data = 0; + return 1; +} + + +Node *addOne(Node *head) +{ + // Write Your Code Here. + int carry = addCarry(head); + + if (carry == 1) { + Node* newNode = new Node(1); + newNode->next = head; + return newNode; + } + return head; +} + + +*/ + +#include +using namespace std; + + +class Node { +public: + // Data stored in the node + int data; + + // Pointer to the next node in the list + Node* next; + + // Constructor with both data and + // next node as parameters + Node(int data1, Node* next1) { + data = data1; + next = next1; + } + + // Constructor with only data as a + // parameter, sets next to nullptr + Node(int data1) { + data = data1; + next = nullptr; + } +}; + + + +/*//Soln 1: Brute Force(using Reversing) + Number is represented in linked list such that each digit corresponds to a node in linked list. Add 1 to it. For example 1999 is represented as (1-> 9-> 9 -> 9) and adding 1 to it should change it to (2->0->0->0) + +Below are the steps : + # Reverse given linked list. For example, 1-> 9-> 9 -> 9 is converted to 9-> 9 -> 9 ->1. + # Start traversing linked list from leftmost node and add 1 to it. If there is a carry, move to the next node. Keep moving to the next node while there is a carry. + # Reverse modified linked list and return head. + + Complexity Analysis: + # TC:- O(3N) + # SC:- O(1) +*/ +/*Node* reverseLL(Node* head) { + if(head == NULL || head->next == NULL) return head; + + Node* newHead = reverseLL(head->next); + Node* front = head->next; + front->next = head; + head->next = NULL; + + return newHead; +} + +Node* add1ToLL(Node* head) { + head = reverseLL(head); + Node* temp = head; + int carry = 1; + while(temp != NULL) { + temp->data = temp->data + carry; + // If no carry is needed + if(temp->data < 10) { + carry = 0; + break; + } + // If there’s a carry (i.e., data >= 10) + else { + temp->data = 0; + carry = 1; // carry over to the next node. + } + temp = temp->next; + } + + // if still Carry is 1 then we neeed new Node + // Before the head of the LL + if(carry == 1) { + Node* newNode = new Node(1); //Create a new node with data with carry 1. + head = reverseLL(head); + newNode->next = head; + return newNode; + } + else { + head = reverseLL(head); + } + return head; +} +*/ + + + + +/*//Soln 2: Recursive/Optimal (without reversing LL) + Approach:- +1. Recursive Carry Addition (addCarry function): + # This function traverses the linked list recursively from the end to the beginning to handle the carry addition. + # Base Case: If the current node (temp) is NULL, it returns 1 to indicate a carry is needed. + # Recursive Case: It recursively calls itself with the next node. After processing the next node, it adds the carry value to the current node’s data. + # Carry Handling:- + If the updated data in the current node is less than 10, it means no carry is needed, so it returns 0. + If the data is 10 or more, it sets the data to 0 (effectively resetting it) and returns 1 to indicate that a carry is needed for the next node. + +2. Adding One to the Number (addOne function): + # It calls addCarry with the head of the linked list to process the carry addition. + # If addCarry returns 1, it means there was a carry from the most significant digit (the head of the list), so a new node with value 1 is created, and this new node becomes the new head of the list. + # If no carry is needed (i.e., addCarry returns 0), it simply returns the original head of the list. + + +STEPS:- + 1. Initiate the carry addition process by calling addOne with the head of the linked list. + 2. Recursively traverse the linked list from the end using addCarry to process each node. + 3. Update each node’s value and manage carry:- + If adding carry results in a value less than 10, no further carry is needed. + If the value is 10 or more, reset it to 0 and pass carry to the next node. + 4. Handle carry at the most significant digit:- + If there’s still a carry after processing all nodes, create a new node with value 1 and set it as the new head. + + + Complexity Analysis: + # Time Complexity:- O(N) + # Space Complexity:- O(N) + Reason-> stroing in stackspace for recursion +*/ +/*int addCarry(Node* temp) { +//Recursion Function for adding carry + if(temp == NULL) return 1; //Base case of recursive function + + int carry = addCarry(temp->next); + //start backtracking the recursive stackspace + temp->data += carry; + + if (temp->data < 10) return 0; + temp->data = 0; + return 1; +} + +Node* addOne(Node* head) { + int carry = addCarry(head); + + if (carry == 1) { + Node* newNode = new Node(1); + newNode->next = head; + return newNode; + } + //simple returs head:(no need to define else statement) + return head; +} +*/ + + + + + +// Function to print the linked list +void printLinkedList(Node* head) { + Node* temp = head; + while (temp != nullptr) { + // Print the data of the current node + cout << temp->data << " "; + // Move to the next node + temp = temp->next; + } + cout << endl; +} + + +int main() { + +/*//Soln 1: Brute Force + //Creating the LL: 1 -> 9 -> 9 -> 9 + Node *head = new Node(1); + head->next = new Node(9); + head->next->next = new Node(9); + head->next->next->next = new Node(9); + + cout << "List is: "; + printLinkedList(head); + + head = add1ToLL(head); + + cout << "Resultant list is: "; + printLinkedList(head); +*/ + + +/*//Soln 2: OPtimal + // Creating the LL: 9 -> 9 -> 9 -> 9 + Node* head = new Node(9); + head->next = new Node(9); + head->next->next = new Node(9); + head->next->next->next = new Node(9); + + cout << "List is: "; + printLinkedList(head); + + head = addOne(head); + + cout << "Resultant list is: "; + printLinkedList(head); +*/ + + + + return 0; +}