Given the head of the linked list representing a positive integer, the task is to print the updated linked list after subtracting 1 from it.
Examples:
Input: LL = 1 -> 2 -> 3 -> 4
Output: 1 -> 2 -> 3 -> 3Input: LL = 1 -> 2
Output: 1 -> 1
Approach: The given problem can be solved by using recursion. Follow the steps below to solve the problem:
-
Define a function, say subtractOneUtil(Node *head) that takes the head of the linked list as the arguments and perform the following steps:
- Base Case: If the head node of the Linked List is NULL, then return -1 from that recursive call.
- Recursive Call: Recursively call for the next node of the linked list and let the value returned by this recursive call be borrow.
- If the value of borrow is -1 and the value of the head node is 0, then update the value of the head node to 9 and return -1 from the current recursive call.
- Otherwise, decrement the value of the head node by 1 and return 0 from the current recursive call.
- Subtract 1 from the Linked List by calling the above function as subtractOneUtil(head).
- If the update linked list has leading 0s, then move the head pointer.
- After completing the above steps, print the updated linked list as the resultant linked list.
Below is the implementation of the above approach:
// C++ program for the above approach #include <bits/stdc++.h> using namespace std;
// Linked list Node class Node {
public :
int data;
Node* next;
}; // Function to create a new node with // the given data Node* newNode( int data)
{ // Create a new node
Node* new_node = new Node;
new_node->data = data;
new_node->next = NULL;
// Return the created node
return new_node;
} // Recursive function to subtract 1 // from the linked list and update // the node value accordingly int subtractOneUtil(Node* head)
{ // Base Case
if (head == NULL)
return -1;
// Recursively call for the next
// node of the head
int borrow = subtractOneUtil(
head->next);
// If there is a borrow
if (borrow == -1) {
// If the head data is 0, then
// update it with 9 and return -1
if (head->data == 0) {
head->data = 9;
return -1;
}
// Otherwise, decrement head's
// data by 1 and return 0
else {
head->data = head->data - 1;
return 0;
}
}
// Otherwise, return 0
else {
return 0;
}
} // Function to subtract 1 from the given // Linked List representation of number Node* subtractOne(Node* head) { // Recursively subtract 1 from
// the Linked List
subtractOneUtil(head);
// Increment the head pointer
// if there are any leading zeros
while (head and head->next
and head->data == 0) {
head = head->next;
}
return head;
} // Function to print a linked list void printList(Node* node)
{ // Iterate until node is NULL
while (node != NULL) {
cout << node->data;
node = node->next;
}
cout << endl;
} // Driver Code int main()
{ Node* head = newNode(1);
head->next = newNode(0);
head->next->next = newNode(0);
head->next->next->next = newNode(0);
cout << "List is " ;
printList(head);
head = subtractOne(head);
cout << "Resultant list is " ;
printList(head);
return 0;
} |
// Java program for the above approach import java.util.*;
class GFG{
// Linked list Node static class Node
{ int data;
Node next;
}; // Function to create a new node with // the given data static Node newNode( int data)
{ // Create a new node
Node new_node = new Node();
new_node.data = data;
new_node.next = null ;
// Return the created node
return new_node;
} // Recursive function to subtract 1 // from the linked list and update // the node value accordingly static int subtractOneUtil(Node head)
{ // Base Case
if (head == null )
return - 1 ;
// Recursively call for the next
// node of the head
int borrow = subtractOneUtil(
head.next);
// If there is a borrow
if (borrow == - 1 )
{
// If the head data is 0, then
// update it with 9 and return -1
if (head.data == 0 )
{
head.data = 9 ;
return - 1 ;
}
// Otherwise, decrement head's
// data by 1 and return 0
else
{
head.data = head.data - 1 ;
return 0 ;
}
}
// Otherwise, return 0
else
{
return 0 ;
}
} // Function to subtract 1 from the given // Linked List representation of number static Node subtractOne(Node head)
{ // Recursively subtract 1 from
// the Linked List
subtractOneUtil(head);
// Increment the head pointer
// if there are any leading zeros
while (head != null && head.next != null &&
head.data == 0 )
{
head = head.next;
}
return head;
} // Function to print a linked list static void printList(Node node)
{ // Iterate until node is null
while (node != null )
{
System.out.print(node.data);
node = node.next;
}
System.out.println();
} // Driver Code public static void main(String[] args)
{ Node head = newNode( 1 );
head.next = newNode( 0 );
head.next.next = newNode( 0 );
head.next.next.next = newNode( 0 );
System.out.print( "List is " );
printList(head);
head = subtractOne(head);
System.out.print( "Resultant list is " );
printList(head);
} } // This code is contributed by 29AjayKumar |
# Python3 program for the above approach # Linked list Node class Node:
def __init__( self , d):
self .data = d
self . next = None
# Recursive function to subtract 1 # from the linked list and update # the node value accordingly def subtractOneUtil(head):
# Base Case
if (head = = None ):
return - 1
# Recursively call for the next
# node of the head
borrow = subtractOneUtil(head. next )
# If there is a borrow
if (borrow = = - 1 ):
# If the head data is 0, then
# update it with 9 and return -1
if (head.data = = 0 ):
head.data = 9
return - 1
# Otherwise, decrement head's
# data by 1 and return 0
else :
head.data = head.data - 1
return 0
# Otherwise, return 0
else :
return 0
# Function to subtract 1 from the given # Linked List representation of number def subtractOne(head):
# Recursively subtract 1 from
# the Linked List
subtractOneUtil(head)
# Increment the head pointer
# if there are any leading zeros
while (head and head. next and
head.data = = 0 ):
head = head. next
return head
# Function to print a linked list def printList(node):
# Iterate until node is None
while (node ! = None ):
print (node.data, end = "")
node = node. next
print ()
# Driver Code if __name__ = = '__main__' :
head = Node( 1 )
head. next = Node( 0 )
head. next . next = Node( 0 )
head. next . next . next = Node( 0 )
print ( "List is " , end = "")
printList(head)
head = subtractOne(head)
print ( "Resultant list is " , end = "")
printList(head)
# This code is contributed by mohit kumar 29 |
// C# program for the above approach using System;
class GFG{
// Linked list Node class Node
{ public int data;
public Node next;
}; // Function to create a new node with // the given data static Node newNode( int data)
{ // Create a new node
Node new_node = new Node();
new_node.data = data;
new_node.next = null ;
// Return the created node
return new_node;
} // Recursive function to subtract 1 // from the linked list and update // the node value accordingly static int subtractOneUtil(Node head)
{ // Base Case
if (head == null )
return -1;
// Recursively call for the next
// node of the head
int borrow = subtractOneUtil(
head.next);
// If there is a borrow
if (borrow == -1)
{
// If the head data is 0, then
// update it with 9 and return -1
if (head.data == 0)
{
head.data = 9;
return -1;
}
// Otherwise, decrement head's
// data by 1 and return 0
else
{
head.data = head.data - 1;
return 0;
}
}
// Otherwise, return 0
else
{
return 0;
}
} // Function to subtract 1 from the given // Linked List representation of number static Node subtractOne(Node head)
{ // Recursively subtract 1 from
// the Linked List
subtractOneUtil(head);
// Increment the head pointer
// if there are any leading zeros
while (head != null && head.next != null &&
head.data == 0)
{
head = head.next;
}
return head;
} // Function to print a linked list static void printList(Node node)
{ // Iterate until node is null
while (node != null )
{
Console.Write(node.data);
node = node.next;
}
Console.WriteLine();
} // Driver Code public static void Main()
{ Node head = newNode(1);
head.next = newNode(0);
head.next.next = newNode(0);
head.next.next.next = newNode(0);
Console.Write( "List is " );
printList(head);
head = subtractOne(head);
Console.Write( "Resultant list is " );
printList(head);
} } // This code is contributed by SURENDRA_GANGWAR |
<script> // JavaScript program for the above approach // Linked list Node class Node { constructor()
{
this .next = null ;
}
} // Function to create a new node with // the given data function newNode(data)
{ // Create a new node
let new_node = new Node();
new_node.data = data;
new_node.next = null ;
// Return the created node
return new_node;
} // Recursive function to subtract 1 // from the linked list and update // the node value accordingly function subtractOneUtil(head)
{ // Base Case
if (head == null )
return -1;
// Recursively call for the next
// node of the head
let borrow = subtractOneUtil(head.next);
// If there is a borrow
if (borrow == -1)
{
// If the head data is 0, then
// update it with 9 and return -1
if (head.data == 0)
{
head.data = 9;
return -1;
}
// Otherwise, decrement head's
// data by 1 and return 0
else
{
head.data = head.data - 1;
return 0;
}
}
// Otherwise, return 0
else
{
return 0;
}
} // Function to subtract 1 from the given // Linked List representation of number function subtractOne(head)
{ // Recursively subtract 1 from
// the Linked List
subtractOneUtil(head);
// Increment the head pointer
// if there are any leading zeros
while (head != null && head.next != null &&
head.data == 0)
{
head = head.next;
}
return head;
} // Function to print a linked list function printList(node)
{ // Iterate until node is null
while (node != null )
{
document.write(node.data);
node = node.next;
}
document.write( "<br>" );
} // Driver Code let head = newNode(1); head.next = newNode(0); head.next.next = newNode(0); head.next.next.next = newNode(0); document.write( "List is " );
printList(head); head = subtractOne(head); document.write( "Resultant list is " );
printList(head); // This code is contributed by Dharanendra L V. </script> |
List is 1000 Resultant list is 999
Time Complexity: O(N), N is the length of the given linked list.
Auxiliary Space: O(1)
New Approach by reverse the linked list :
- Subtract 1 from the first node (i.e., the ones place), and then handle the carry if require.
- .Then, reverse the linked list back to its original form and return the updated linked list.
Below is the implementation of the above approach:
// C++ program for the above approach #include <bits/stdc++.h> using namespace std;
// Linked list Node class Node {
public :
int data;
Node* next;
}; // Function to create a new node with // the given data Node* newNode( int data)
{ // Create a new node
Node* new_node = new Node;
new_node->data = data;
new_node->next = NULL;
// Return the created node
return new_node;
} // Function to reverse a linked list Node* reverseList(Node* head) { Node *prev = NULL, *curr = head, *next;
while (curr != NULL) {
next = curr->next;
curr->next = prev;
prev = curr;
curr = next;
}
return prev;
} // Function to subtract 1 from the given // Linked List representation of number Node* subtractOne(Node* head) { // Reverse the linked list
head = reverseList(head);
// Subtract 1 from the first node
head->data -= 1;
// Handle the carry if required
Node* curr = head;
while (curr->data < 0) {
curr->data += 10;
if (curr->next == NULL) {
curr->next = newNode(0);
}
curr->next->data -= 1;
curr = curr->next;
}
// Reverse the linked list back to
// its original form
head = reverseList(head);
// Increment the head pointer
// if there are any leading zeros
while (head and head->next and head->data == 0) {
head = head->next;
}
return head;
} // Function to print a linked list void printList(Node* node)
{ // Iterate until node is NULL
while (node != NULL) {
cout << node->data;
node = node->next;
}
cout << endl;
} // Driver Code int main()
{ Node* head = newNode(1);
head->next = newNode(0);
head->next->next = newNode(0);
head->next->next->next = newNode(0);
cout << "List is " ;
printList(head);
head = subtractOne(head);
cout << "Resultant list is " ;
printList(head);
return 0;
} //This code is contributed by chinmaya121221 |
public class Main {
// Linked list Node
static class Node {
int data;
Node next;
}
// Function to create a new node with
// the given data
static Node newNode( int data)
{
// Create a new node
Node new_node = new Node();
new_node.data = data;
new_node.next = null ;
// Return the created node
return new_node;
}
// Function to reverse a linked list
static Node reverseList(Node head) {
Node prev = null , curr = head, next;
while (curr != null ) {
next = curr.next;
curr.next = prev;
prev = curr;
curr = next;
}
return prev;
}
// Function to subtract 1 from the given
// Linked List representation of number
static Node subtractOne(Node head) {
// Reverse the linked list
head = reverseList(head);
// Subtract 1 from the first node
head.data -= 1 ;
// Handle the carry if required
Node curr = head;
while (curr.data < 0 ) {
curr.data += 10 ;
if (curr.next == null ) {
curr.next = newNode( 0 );
}
curr.next.data -= 1 ;
curr = curr.next;
}
// Reverse the linked list back to
// its original form
head = reverseList(head);
// Increment the head pointer
// if there are any leading zeros
while (head != null && head.next != null && head.data == 0 ) {
head = head.next;
}
return head;
}
// Function to print a linked list
static void printList(Node node) {
// Iterate until node is NULL
while (node != null ) {
System.out.print(node.data);
node = node.next;
}
System.out.println();
}
public static void main(String[] args) {
Node head = newNode( 1 );
head.next = newNode( 0 );
head.next.next = newNode( 0 );
head.next.next.next = newNode( 0 );
System.out.print( "List is " );
printList(head);
head = subtractOne(head);
System.out.print( "Resultant list is " );
printList(head);
}
} |
# Linked list Node class Node:
def __init__( self , data):
self .data = data
self . next = None
# Function to create a new node with the given data def newNode(data):
# Create a new node
new_node = Node(data)
# Return the created node
return new_node
# Function to reverse a linked list def reverseList(head):
prev = None
curr = head
next = None
while curr ! = None :
next = curr. next
curr. next = prev
prev = curr
curr = next
return prev
# Function to subtract 1 from the given # Linked List representation of number def subtractOne(head):
# Reverse the linked list
head = reverseList(head)
# Subtract 1 from the first node
head.data - = 1
# Handle the carry if required
curr = head
while curr.data < 0 :
curr.data + = 10
if curr. next = = None :
curr. next = newNode( 0 )
curr. next .data - = 1
curr = curr. next
# Reverse the linked list back to its original form
head = reverseList(head)
# Increment the head pointer if there are any leading zeros
while head and head. next and head.data = = 0 :
head = head. next
return head
# Function to print a linked list def printList(node):
# Iterate until node is NULL
while node ! = None :
print (node.data, end = "")
node = node. next
print ()
# Driver Code head = newNode( 1 )
head. next = newNode( 0 )
head. next . next = newNode( 0 )
head. next . next . next = newNode( 0 )
print ( "List is " )
printList(head) head = subtractOne(head)
print ( "Resultant list is " )
printList(head) |
// C# program for the above approach using System;
// Linked list Node class Node {
public int data;
public Node next;
}; // Main class class MainClass {
// Function to create a new node with
// the given data
static Node newNode( int data)
{
// Create a new node
Node new_node = new Node();
new_node.data = data;
new_node.next = null ;
// Return the created node
return new_node;
}
// Function to reverse a linked list
static Node reverseList(Node head)
{
Node prev = null , curr = head, next;
while (curr != null ) {
next = curr.next;
curr.next = prev;
prev = curr;
curr = next;
}
return prev;
}
// Function to subtract 1 from the given
// Linked List representation of number
static Node subtractOne(Node head)
{
// Reverse the linked list
head = reverseList(head);
// Subtract 1 from the first node
head.data -= 1;
// Handle the carry if required
Node curr = head;
while (curr.data < 0) {
curr.data += 10;
if (curr.next == null ) {
curr.next = newNode(0);
}
curr.next.data -= 1;
curr = curr.next;
}
// Reverse the linked list back to
// its original form
head = reverseList(head);
// Increment the head pointer
// if there are any leading zeros
while (head != null && head.next != null
&& head.data == 0) {
head = head.next;
}
return head;
}
// Function to print a linked list
static void printList(Node node)
{
// Iterate until node is NULL
while (node != null ) {
Console.Write(node.data);
node = node.next;
}
Console.WriteLine();
}
// Driver Code
public static void Main()
{
Node head = newNode(1);
head.next = newNode(0);
head.next.next = newNode(0);
head.next.next.next = newNode(0);
Console.Write( "List is " );
printList(head);
head = subtractOne(head);
Console.Write( "Resultant list is " );
printList(head);
}
} // This code is contributed by rutikbhosale |
// Linked list Node class Node { constructor(data) {
this .data = data;
this .next = null ;
}
} // Function to create a new node with the given data function newNode(data)
{ // Create a new node
let new_node = new Node(data);
// Return the created node
return new_node;
} // Function to reverse a linked list function reverseList(head) {
let prev = null ,
curr = head,
next;
while (curr != null ) {
next = curr.next;
curr.next = prev;
prev = curr;
curr = next;
}
return prev;
} // Function to subtract 1 from the given // Linked List representation of number function subtractOne(head) {
// Reverse the linked list
head = reverseList(head);
// Subtract 1 from the first node
head.data -= 1;
// Handle the carry if required
let curr = head;
while (curr.data < 0) {
curr.data += 10;
if (curr.next == null ) {
curr.next = newNode(0);
}
curr.next.data -= 1;
curr = curr.next;
}
// Reverse the linked list back to its original form
head = reverseList(head);
// Increment the head pointer if there are any leading zeros
while (head && head.next && head.data == 0) {
head = head.next;
}
return head;
} // Function to print a linked list function printList(node) {
// Iterate until node is NULL
while (node != null ) {
process.stdout.write(node.data + "" );
node = node.next;
}
console.log();
} // Driver Code let head = newNode(1); head.next = newNode(0); head.next.next = newNode(0); head.next.next.next = newNode(0); console.log( "List is " );
printList(head); head = subtractOne(head); console.log( "Resultant list is " );
printList(head); |
List is 1000 Resultant list is 999
Time Complexity: O(n), where n is the length of the linked list.
Space Complexity: O(n), where n is the length of the linked list.
Another approach using Stack:
#include <bits/stdc++.h> using namespace std;
// Linked list Node class Node {
public :
int data;
Node* next;
}; // Function to create a new node with // the given data Node* newNode( int data)
{ // Create a new node
Node* new_node = new Node;
new_node->data = data;
new_node->next = NULL;
// Return the created node
return new_node;
} // Function to subtract 1 from the given // Linked List representation of number using stack Node* subtractOne(Node* head) { stack< int > s;
// Traverse the linked list and push values onto the stack
Node* curr = head;
while (curr != NULL) {
s.push(curr->data);
curr = curr->next;
}
int borrow = 1;
Node* new_head = NULL;
// Pop elements from the stack and subtract borrow
while (!s.empty()) {
int val = s.top() - borrow;
borrow = 0;
if (val < 0) {
val += 10;
borrow = 1;
}
s.pop();
Node* new_node = newNode(val);
new_node->next = new_head;
new_head = new_node;
}
// Remove leading zeros
while (new_head != NULL && new_head->data == 0) {
Node* temp = new_head;
new_head = new_head->next;
delete temp;
}
return new_head;
} // Function to print a linked list void printList(Node* node)
{ // Iterate until node is NULL
while (node != NULL) {
cout << node->data;
node = node->next;
}
cout << endl;
} // Nikunj Sonigara // Driver Code int main()
{ Node* head = newNode(1);
head->next = newNode(0);
head->next->next = newNode(0);
head->next->next->next = newNode(0);
cout << "List is " ;
printList(head);
head = subtractOne(head);
cout << "Resultant list is " ;
printList(head);
return 0;
} |
import java.util.Stack;
// Linked list Node class Node {
int data;
Node next;
Node( int data)
{
this .data = data;
this .next = null ;
}
} public class Main {
// Function to subtract 1 from the given
// Linked List representation of number using stack
static Node subtractOne(Node head)
{
Stack<Integer> s = new Stack<>();
// Traverse the linked list and push values onto the
// stack
Node curr = head;
while (curr != null ) {
s.push(curr.data);
curr = curr.next;
}
int borrow = 1 ;
Node new_head = null ;
// Pop elements from the stack and subtract borrow
while (!s.empty()) {
int val = s.pop() - borrow;
borrow = 0 ;
if (val < 0 ) {
val += 10 ;
borrow = 1 ;
}
Node new_node = new Node(val);
new_node.next = new_head;
new_head = new_node;
}
// Remove leading zeros
while (new_head != null && new_head.data == 0 ) {
Node temp = new_head;
new_head = new_head.next;
temp = null ;
}
return new_head;
}
// Function to print a linked list
static void printList(Node node)
{
// Iterate until node is null
while (node != null ) {
System.out.print(node.data);
node = node.next;
}
System.out.println();
}
// Driver Code
public static void main(String[] args)
{
Node head = new Node( 1 );
head.next = new Node( 0 );
head.next.next = new Node( 0 );
head.next.next.next = new Node( 0 );
System.out.print( "List is " );
printList(head);
head = subtractOne(head);
System.out.print( "Resultant list is " );
printList(head);
}
} |
# Linked list Node class Node:
def __init__( self , data):
self .data = data
self . next = None
# Function to create a new node with the given data def new_node(data):
# Create a new node
new_node = Node(data)
# Return the created node
return new_node
# Function to subtract 1 from the given Linked List representation of number using stack def subtract_one(head):
stack = []
# Traverse the linked list and push values onto the stack
curr = head
while curr is not None :
stack.append(curr.data)
curr = curr. next
borrow = 1
new_head = None
# Pop elements from the stack and subtract borrow
while stack:
val = stack.pop() - borrow
borrow = 0
if val < 0 :
val + = 10
borrow = 1
new_node = Node(val)
new_node. next = new_head
new_head = new_node
# Remove leading zeros
while new_head is not None and new_head.data = = 0 :
temp = new_head
new_head = new_head. next
del temp
return new_head
# Function to print a linked list def print_list(node):
# Iterate until node is None
while node is not None :
print node.data, # Adding a comma to suppress the newline character
node = node. next
print # Print a newline after the loop
# Driver Code if __name__ = = "__main__" :
head = new_node( 1 )
head. next = new_node( 0 )
head. next . next = new_node( 0 )
head. next . next . next = new_node( 0 )
print "List is " ,
print_list(head)
head = subtract_one(head)
print "Resultant list is " ,
print_list(head)
# Contributed by sinudp5vi |
using System;
using System.Collections.Generic;
// Linked list Node class Node {
public int data;
public Node next;
} class GFG {
// Function to create a new node with
// the given data
static Node NewNode( int data)
{
// Create a new node
Node new_node = new Node();
new_node.data = data;
new_node.next = null ;
// Return the created node
return new_node;
}
// Function to subtract 1 from the given
// Linked List representation of number using stack
static Node SubtractOne(Node head)
{
Stack< int > stack = new Stack< int >();
// Traverse the linked list and push values onto the
// stack
Node curr = head;
while (curr != null ) {
stack.Push(curr.data);
curr = curr.next;
}
int borrow = 1;
Node new_head = null ;
// Pop elements from the stack and subtract borrow
while (stack.Count > 0) {
int val = stack.Pop() - borrow;
borrow = 0;
if (val < 0) {
val += 10;
borrow = 1;
}
Node new_node = NewNode(val);
new_node.next = new_head;
new_head = new_node;
}
// Remove leading zeros
while (new_head != null && new_head.data == 0) {
new_head = new_head.next;
}
return new_head;
}
// Function to print a linked list
static void PrintList(Node node)
{
// Iterate until node is null
while (node != null ) {
Console.Write(node.data);
node = node.next;
}
Console.WriteLine();
}
// Driver code
static void Main()
{
Node head = NewNode(1);
head.next = NewNode(0);
head.next.next = NewNode(0);
head.next.next.next = NewNode(0);
Console.Write( "List is " );
PrintList(head);
head = SubtractOne(head);
Console.Write( "Resultant list is " );
PrintList(head);
}
} |
// Linked list Node class Node { constructor(data) {
this .data = data;
this .next = null ;
}
} // Function to create a new node with the given data function new_node(data) {
// Create a new node
const new_node = new Node(data);
// Return the created node
return new_node;
} // Function to subtract 1 from the given Linked List representation of number using stack function subtract_one(head) {
const stack = [];
// Traverse the linked list and push values onto the stack
let curr = head;
while (curr !== null ) {
stack.push(curr.data);
curr = curr.next;
}
let borrow = 1;
let new_head = null ;
// Pop elements from the stack and subtract borrow
while (stack.length > 0) {
let val = stack.pop() - borrow;
borrow = 0;
if (val < 0) {
val += 10;
borrow = 1;
}
const new_node = new Node(val);
new_node.next = new_head;
new_head = new_node;
}
// Remove leading zeros
while (new_head !== null && new_head.data === 0) {
const temp = new_head;
new_head = new_head.next;
// Delete temp (Not required in JavaScript as memory management is automatic)
}
return new_head;
} // Function to print a linked list function print_list(node) {
// Iterate until node is null
while (node !== null ) {
console.log(node.data);
node = node.next;
}
} // Driver Code const head = new_node(1); head.next = new_node(0); head.next.next = new_node(0); head.next.next.next = new_node(0); console.log( "List is:" );
print_list(head); const newHead = subtract_one(head); console.log( "Resultant list is:" );
print_list(newHead); |
List is 1000 Resultant list is 999
Time Complexity: O(n)
Space Complexity: O(n)