Agregar 1 a un número representado como lista enlazada

El número se representa en la lista enlazada de modo que cada dígito corresponde a un Node en la lista enlazada. Súmale 1. Por ejemplo, 1999 se representa como (1-> 9-> 9 -> 9) y agregarle 1 debería cambiarlo a (2->0->0->0) 

A continuación se muestran los pasos: 

C++

// C++ program to add 1 to a linked list 
#include <bits/stdc++.h>
using namespace std;
  
/* Linked list node */
class Node 
{ 
    public:
    int data; 
    Node* next; 
}; 
  
/* Function to create a new node with given data */
Node *newNode(int data) 
{ 
    Node *new_node = new Node; 
    new_node->data = data; 
    new_node->next = NULL; 
    return new_node; 
} 
  
/* Function to reverse the linked list */
Node *reverse(Node *head) 
{ 
    Node * prev = NULL; 
    Node * current = head; 
    Node * next; 
    while (current != NULL) 
    { 
        next = current->next; 
        current->next = prev; 
        prev = current; 
        current = next; 
    } 
    return prev; 
} 
  
/* Adds one to a linked lists and return the head 
node of resultant list */
Node *addOneUtil(Node *head) 
{ 
    // res is head node of the resultant list 
    Node* res = head; 
    Node *temp; 
  
    int carry = 1, sum; 
  
    while (head != NULL) //while both lists exist 
    { 
        // Calculate value of next digit in resultant list. 
        // The next digit is sum of following things 
        // (i) Carry 
        // (ii) Next digit of head list (if there is a 
        // next digit) 
        sum = carry + head->data; 
  
        // update carry for next calculation 
        carry = (sum >= 10)? 1 : 0; 
  
        // update sum if it is greater than 10 
        sum = sum % 10; 
  
        // Create a new node with sum as data 
        head->data = sum; 
  
        // Move head and second pointers to next nodes 
        temp = head; 
        head = head->next; 
    } 
  
    // if some carry is still there, add a new node to 
    // result list. 
    if (carry > 0) 
        temp->next = newNode(carry); 
  
    // return head of the resultant list 
    return res; 
} 
  
// This function mainly uses addOneUtil(). 
Node* addOne(Node *head) 
{ 
    // Reverse linked list 
    head = reverse(head); 
  
    // Add one from left to right of reversed 
    // list 
    head = addOneUtil(head); 
  
    // Reverse the modified list 
    return reverse(head); 
} 
  
// A utility function to print a linked list 
void printList(Node *node) 
{ 
    while (node != NULL) 
    { 
        cout << node->data; 
        node = node->next; 
    } 
    cout<<endl;
} 
  
/* Driver program to test above function */
int main(void) 
{ 
    Node *head = newNode(1); 
    head->next = newNode(9); 
    head->next->next = newNode(9); 
    head->next->next->next = newNode(9); 
  
    cout << "List is "; 
    printList(head); 
  
    head = addOne(head); 
  
    cout << "\nResultant list is "; 
    printList(head); 
  
    return 0; 
} 
  
// This is code is contributed by rathbhupendra

C

// C program to add 1 to a linked list
#include<bits/stdc++.h>
  
/* Linked list node */
struct Node
{
    int data;
    Node* next;
};
  
/* Function to create a new node with given data */
Node *newNode(int data)
{
    Node *new_node = new Node;
    new_node->data = data;
    new_node->next = NULL;
    return new_node;
}
  
/* Function to reverse the linked list */
Node *reverse(Node *head)
{
    Node * prev   = NULL;
    Node * current = head;
    Node * next;
    while (current != NULL)
    {
        next  = current->next;
        current->next = prev;
        prev = current;
        current = next;
    }
    return prev;
}
  
/* Adds one to a linked lists and return the head
   node of resultant list */
Node *addOneUtil(Node *head)
{
    // res is head node of the resultant list
    Node* res = head;
    Node *temp, *prev = NULL;
  
    int carry = 1, sum;
  
    while (head != NULL) //while both lists exist
    {
        // Calculate value of next digit in resultant list.
        // The next digit is sum of following things
        // (i) Carry
        // (ii) Next digit of head list (if there is a
        //     next digit)
        sum = carry + head->data;
  
        // update carry for next calculation
        carry = (sum >= 10)? 1 : 0;
  
        // update sum if it is greater than 10
        sum = sum % 10;
  
        // Create a new node with sum as data
        head->data = sum;
  
        // Move head and second pointers to next nodes
        temp = head;
        head = head->next;
    }
  
    // if some carry is still there, add a new node to
    // result list.
    if (carry > 0)
        temp->next = newNode(carry);
  
    // return head of the resultant list
    return res;
}
  
// This function mainly uses addOneUtil().
Node* addOne(Node *head)
{
    // Reverse linked list
    head = reverse(head);
  
    // Add one from left to right of reversed
    // list
    head = addOneUtil(head);
  
    // Reverse the modified list
    return reverse(head);
}
  
// A utility function to print a linked list
void printList(Node *node)
{
    while (node != NULL)
    {
        printf("%d", node->data);
        node = node->next;
    }
    printf("\n");
}
  
/* Driver program to test above function */
int main(void)
{
    Node *head = newNode(1);
    head->next = newNode(9);
    head->next->next = newNode(9);
    head->next->next->next = newNode(9);
  
    printf("List is ");
    printList(head);
  
    head = addOne(head);
  
    printf("\nResultant list is ");
    printList(head);
  
    return 0;
}

Java

// Java program to add 1 to a linked list
class GfG {
  
    /* Linked list node */
    static class Node {
        int data;
        Node next;
    }
  
    /* Function to create a new node with given data */
    static Node newNode(int data)
    {
        Node new_node = new Node();
        new_node.data = data;
        new_node.next = null;
        return new_node;
    }
  
    /* Function to reverse the linked list */
    static Node reverse(Node head)
    {
        Node prev = null;
        Node current = head;
        Node next = null;
        while (current != null) {
            next = current.next;
            current.next = prev;
            prev = current;
            current = next;
        }
        return prev;
    }
  
    /* Adds one to a linked lists and return the head
    node of resultant list */
    static Node addOneUtil(Node head)
    {
        // res is head node of the resultant list
        Node res = head;
        Node temp = null, prev = null;
  
        int carry = 1, sum;
  
        while (head != null) // while both lists exist
        {
            // Calculate value of next digit in resultant
            // list. The next digit is sum of following
            // things (i) Carry (ii) Next digit of head list
            // (if there is a next digit)
            sum = carry + head.data;
  
            // update carry for next calculation
            carry = (sum >= 10) ? 1 : 0;
  
            // update sum if it is greater than 10
            sum = sum % 10;
  
            // Create a new node with sum as data
            head.data = sum;
  
            // Move head and second pointers to next nodes
            temp = head;
            head = head.next;
        }
  
        // if some carry is still there, add a new node to
        // result list.
        if (carry > 0)
            temp.next = newNode(carry);
  
        // return head of the resultant list
        return res;
    }
  
    // This function mainly uses addOneUtil().
    static Node addOne(Node head)
    {
        // Reverse linked list
        head = reverse(head);
  
        // Add one from left to right of reversed
        // list
        head = addOneUtil(head);
  
        // Reverse the modified list
        return reverse(head);
    }
  
    // A utility function to print a linked list
    static void printList(Node node)
    {
        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(9);
        head.next.next = newNode(9);
        head.next.next.next = newNode(9);
  
        System.out.print("List is ");
        printList(head);
  
        head = addOne(head);
        System.out.println();
        System.out.print("Resultant list is ");
        printList(head);
    }
}
  
// This code is contributed by prerna saini

Python3

# Python3 program to add 1 to a linked list
import sys
import math
  
# Linked list node
  
  
class Node:
    def __init__(self, data):
        self.data = data
        self.next = None
  
# Function to create a new node with given data */
  
  
def newNode(data):
    return Node(data)
  
# Function to reverse the linked list */
  
  
def reverseList(head):
    if not head:
        return
    curNode = head
    prevNode = head
    nextNode = head.next
    curNode.next = None
  
    while(nextNode):
        curNode = nextNode
        nextNode = nextNode.next
        curNode.next = prevNode
        prevNode = curNode
  
    return curNode
  
# Adds one to a linked lists and return the head
# node of resultant list
  
  
def addOne(head):
  
    # Reverse linked list and add one to head
    head = reverseList(head)
    k = head
    carry = 0
    prev = None
    head.data += 1
  
    # update carry for next calculation
    while(head != None) and (head.data > 9 or carry > 0):
        prev = head
        head.data += carry
        carry = head.data // 10
        head.data = head.data % 10
        head = head.next
  
    if carry > 0:
        prev.next = Node(carry)
    # Reverse the modified list
    return reverseList(k)
  
# A utility function to print a linked list
  
  
def printList(head):
    if not head:
        return
    while(head):
        print("{}".format(head.data), end="")
        head = head.next
  
  
# Driver code
if __name__ == '__main__':
    head = newNode(1)
    head.next = newNode(9)
    head.next.next = newNode(9)
    head.next.next.next = newNode(9)
  
    print("List is: ", end="")
    printList(head)
  
    head = addOne(head)
  
    print("\nResultant list is: ", end="")
    printList(head)
  
  
# This code is contributed by Rohit

C#

// C# program to add 1 to a linked list
using System;
  
class GfG {
  
    /* Linked list node */
    public class Node {
        public int data;
        public Node next;
    }
  
    /* Function to create a new node with given data */
    static Node newNode(int data)
    {
        Node new_node = new Node();
        new_node.data = data;
        new_node.next = null;
        return new_node;
    }
  
    /* Function to reverse the linked list */
    static Node reverse(Node head)
    {
        Node prev = null;
        Node current = head;
        Node next = null;
        while (current != null) {
            next = current.next;
            current.next = prev;
            prev = current;
            current = next;
        }
        return prev;
    }
  
    /* Adds one to a linked lists and return the head
    node of resultant list */
    static Node addOneUtil(Node head)
    {
        // res is head node of the resultant list
        Node res = head;
        Node temp = null, prev = null;
  
        int carry = 1, sum;
  
        while (head != null) // while both lists exist
        {
            // Calculate value of next digit in resultant
            // list. The next digit is sum of following
            // things (i) Carry (ii) Next digit of head list
            // (if there is a next digit)
            sum = carry + head.data;
  
            // update carry for next calculation
            carry = (sum >= 10) ? 1 : 0;
  
            // update sum if it is greater than 10
            sum = sum % 10;
  
            // Create a new node with sum as data
            head.data = sum;
  
            // Move head and second pointers to next nodes
            temp = head;
            head = head.next;
        }
  
        // if some carry is still there, add a new node to
        // result list.
        if (carry > 0)
            temp.next = newNode(carry);
  
        // return head of the resultant list
        return res;
    }
  
    // This function mainly uses addOneUtil().
    static Node addOne(Node head)
    {
        // Reverse linked list
        head = reverse(head);
  
        // Add one from left to right of reversed
        // list
        head = addOneUtil(head);
  
        // Reverse the modified list
        return reverse(head);
    }
  
    // A utility function to print a linked list
    static void printList(Node node)
    {
        while (node != null) {
            Console.Write(node.data);
            node = node.next;
        }
        Console.WriteLine();
    }
  
    /* Driver code */
    public static void Main(String[] args)
    {
        Node head = newNode(1);
        head.next = newNode(9);
        head.next.next = newNode(9);
        head.next.next.next = newNode(9);
  
        Console.Write("List is ");
        printList(head);
  
        head = addOne(head);
        Console.WriteLine();
        Console.Write("Resultant list is ");
        printList(head);
    }
}
  
// This code contributed by Rajput-Ji

Javascript

<script>
  
// Javascript program to add 1 to a linked list 
  
/* Linked list node */
class Node 
{ 
    constructor()
    {
        this.data = 0;
        this.next = null;
    }
}; 
  
/* Function to create a new node with given data */
function newNode(data) 
{ 
    var new_node = new Node(); 
    new_node.data = data; 
    new_node.next = null; 
    return new_node; 
} 
  
/* Function to reverse the linked list */
function reverse(head) 
{ 
    var prev = null; 
    var current = head; 
    var next; 
    while (current != null) 
    { 
        next = current.next; 
        current.next = prev; 
        prev = current; 
        current = next; 
    } 
    return prev; 
} 
  
/* Adds one to a linked lists and return the head 
node of resultant list */
function addOneUtil(head) 
{ 
    // res is head node of the resultant list 
    var res = head; 
    var temp, prev = null; 
  
    var carry = 1, sum; 
  
    while (head != null) //while both lists exist 
    { 
        // Calculate value of next digit in resultant list. 
        // The next digit is sum of following things 
        // (i) Carry 
        // (ii) Next digit of head list (if there is a 
        // next digit) 
        sum = carry + head.data; 
  
        // update carry for next calculation 
        carry = (sum >= 10)? 1 : 0; 
  
        // update sum if it is greater than 10 
        sum = sum % 10; 
  
        // Create a new node with sum as data 
        head.data = sum; 
  
        // Move head and second pointers to next nodes 
        temp = head; 
        head = head.next; 
    } 
  
    // if some carry is still there, add a new node to 
    // result list. 
    if (carry > 0) 
        temp.next = newNode(carry); 
  
    // return head of the resultant list 
    return res; 
} 
  
// This function mainly uses addOneUtil(). 
function addOne(head) 
{ 
    // Reverse linked list 
    head = reverse(head); 
  
    // Add one from left to right of reversed 
    // list 
    head = addOneUtil(head); 
  
    // Reverse the modified list 
    return reverse(head); 
} 
  
// A utility function to print a linked list 
function printList(node) 
{ 
    while (node != null) 
    { 
        document.write( node.data); 
        node = node.next; 
    } 
    document.write("<br>");
} 
  
/* Driver program to test above function */
var head = newNode(1); 
head.next = newNode(9); 
head.next.next = newNode(9); 
head.next.next.next = newNode(9); 
document.write( "List is "); 
printList(head); 
head = addOne(head); 
document.write( "<br>Resultant list is "); 
printList(head); 
  
// This code is contributed by rrrtnx.
</script>

C++

// Recursive C++ program to add 1 to a linked list
#include <bits/stdc++.h>
  
/* Linked list node */
struct Node {
    int data;
    Node* next;
};
  
/* Function to create a new node with given data */
Node* newNode(int data)
{
    Node* new_node = new Node;
    new_node->data = data;
    new_node->next = NULL;
    return new_node;
}
  
// Recursively add 1 from end to beginning and returns
// carry after all nodes are processed.
int addWithCarry(Node* head)
{
    // If linked list is empty, then
    // return carry
    if (head == NULL)
        return 1;
  
    // Add carry returned be next node call
    int res = head->data + addWithCarry(head->next);
  
    // Update data and return new carry
    head->data = (res) % 10;
    return (res) / 10;
}
  
// This function mainly uses addWithCarry().
Node* addOne(Node* head)
{
    // Add 1 to linked list from end to beginning
    int carry = addWithCarry(head);
  
    // If there is carry after processing all nodes,
    // then we need to add a new node to linked list
    if (carry) {
        Node* newNode = new Node;
        newNode->data = carry;
        newNode->next = head;
        return newNode; // New node becomes head now
    }
  
    return head;
}
  
// A utility function to print a linked list
void printList(Node* node)
{
    while (node != NULL) {
        printf("%d", node->data);
        node = node->next;
    }
    printf("\n");
}
  
/* Driver code */
int main(void)
{
    Node* head = newNode(1);
    head->next = newNode(9);
    head->next->next = newNode(9);
    head->next->next->next = newNode(9);
  
    printf("List is ");
    printList(head);
  
    head = addOne(head);
  
    printf("\nResultant list is ");
    printList(head);
  
    return 0;
}

Java

// Recursive Java program to add 1 to a linked list
class GfG {
  
    /* Linked list node */
    static class Node
    {
        int data;
        Node next;
    }
  
    /* Function to create a new node with given data */
    static Node newNode(int data) 
    {
        Node new_node = new Node();
        new_node.data = data;
        new_node.next = null;
        return new_node;
    }
  
    // Recursively add 1 from end to beginning and returns
    // carry after all nodes are processed.
    static int addWithCarry(Node head)
    {
  
        // If linked list is empty, then
        // return carry
        if (head == null)
            return 1;
  
        // Add carry returned be next node call
        int res = head.data + addWithCarry(head.next);
  
        // Update data and return new carry
        head.data = (res) % 10;
        return (res) / 10;
    }
  
    // This function mainly uses addWithCarry(). 
    static Node addOne(Node head)
    {
  
        // Add 1 to linked list from end to beginning
        int carry = addWithCarry(head);
  
        // If there is carry after processing all nodes,
        // then we need to add a new node to linked list
        if (carry > 0)
        {
            Node newNode = newNode(carry);
            newNode.next = head;
            return newNode; // New node becomes head now
        }
  
        return head;
    }
  
    // A utility function to print a linked list
    static void printList(Node node)
    {
        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(9);
        head.next.next = newNode(9);
        head.next.next.next = newNode(9);
  
        System.out.print("List is ");
        printList(head);
  
        head = addOne(head);
        System.out.println();
        System.out.print("Resultant list is ");
        printList(head);
    }
}
  
// This code is contributed by shubham96301

Python

# Recursive Python program to add 1 to a linked list
  
# Node class 
class Node: 
  
    # Constructor to initialize the node object 
    def __init__(self, data): 
        self.data = data 
        self.next = None
  
# Function to create a new node with given data 
def newNode(data):
  
    new_node = Node(0)
    new_node.data = data
    new_node.next = None
    return new_node
  
# Recursively add 1 from end to beginning and returns
# carry after all nodes are processed.
def addWithCarry(head):
  
    # If linked list is empty, then
    # return carry
    if (head == None):
        return 1
  
    # Add carry returned be next node call
    res = head.data + addWithCarry(head.next)
  
    # Update data and return new carry
    head.data = int((res) % 10)
    return int((res) / 10)
  
# This function mainly uses addWithCarry().
def addOne(head):
  
    # Add 1 to linked list from end to beginning
    carry = addWithCarry(head)
  
    # If there is carry after processing all nodes,
    # then we need to add a new node to linked list
    if (carry != 0):
      
        newNode = Node(0)
        newNode.data = carry
        newNode.next = head
        return newNode # New node becomes head now
      
    return head
  
# A utility function to print a linked list
def printList(node):
  
    while (node != None):
      
        print( node.data,end = "")
        node = node.next
      
    print("\n")
  
# Driver program to test above function 
  
head = newNode(1)
head.next = newNode(9)
head.next.next = newNode(9)
head.next.next.next = newNode(9)
  
print("List is ")
printList(head)
  
head = addOne(head)
  
print("\nResultant list is ")
printList(head)
  
  
# This code is contributed by Arnab Kundu

C#

// Recursive C# program to add 1 to a linked list 
using System; 
  
class GfG 
{ 
  
    /* Linked list node */
    public class Node 
    { 
        public int data; 
        public Node next; 
    } 
  
    /* Function to create a new node with given data */
    public static Node newNode(int data) 
    { 
        Node new_node = new Node(); 
        new_node.data = data; 
        new_node.next = null; 
        return new_node; 
    } 
  
    // Recursively add 1 from end to beginning and returns 
    // carry after all nodes are processed. 
    public static int addWithCarry(Node head) 
    { 
  
        // If linked list is empty, then 
        // return carry 
        if (head == null) 
            return 1; 
  
        // Add carry returned be next node call 
        int res = head.data + addWithCarry(head.next); 
  
        // Update data and return new carry 
        head.data = (res) % 10; 
        return (res) / 10; 
    } 
  
    // This function mainly uses addWithCarry(). 
    public static Node addOne(Node head) 
    { 
  
        // Add 1 to linked list from end to beginning 
        int carry = addWithCarry(head); 
        Node newNodes = null;
          
        // If there is carry after processing all nodes, 
        // then we need to add a new node to linked list 
        if (carry > 0) 
        { 
            newNodes = newNode(carry); 
            newNodes.next = head; 
            return newNodes; // New node becomes head now 
        } 
  
        return head; 
    } 
  
    // A utility function to print a linked list 
    public static void printList(Node node) 
    { 
        while (node != null) 
        { 
            Console.Write(node.data); 
            node = node.next; 
        } 
        Console.WriteLine(); 
    } 
  
    /* Driver code */
    public static void Main(String[] args) 
    { 
        Node head = newNode(1); 
        head.next = newNode(9); 
        head.next.next = newNode(9); 
        head.next.next.next = newNode(9); 
  
        Console.Write("List is "); 
        printList(head); 
  
        head = addOne(head); 
        Console.WriteLine(); 
        Console.Write("Resultant list is "); 
        printList(head); 
    } 
} 
  
/* This code contributed by PrinciRaj1992 */

Javascript

<script>
  
      // Recursive JavaScript program
      // to add 1 to a linked list
      /* Linked list node */
      class Node {
        constructor() {
          this.data = 0;
          this.next = null;
        }
      }
  
      /* Function to create a new node with given data */
      function newNode(data) {
        var new_node = new Node();
        new_node.data = data;
        new_node.next = null;
        return new_node;
      }
  
      // Recursively add 1 from end to beginning and returns
      // carry after all nodes are processed.
      function addWithCarry(head) {
        // If linked list is empty, then
        // return carry
        if (head == null) return 1;
  
        // Add carry returned be next node call
        var res = head.data + addWithCarry(head.next);
  
        // Update data and return new carry
        head.data = res % 10;
        return parseInt(res / 10);
      }
  
      // This function mainly uses addWithCarry().
      function addOne(head) {
        // Add 1 to linked list from end to beginning
        var carry = addWithCarry(head);
        var newNodes = null;
  
        // If there is carry after processing all nodes,
        // then we need to add a new node to linked list
        if (carry > 0) {
          newNodes = newNode(carry);
          newNodes.next = head;
          return newNodes; // New node becomes head now
        }
  
        return head;
      }
  
      // A utility function to print a linked list
      function printList(node) {
        while (node != null) {
          document.write(node.data);
          node = node.next;
        }
        document.write("<br>");
      }
  
      /* Driver code */
      var head = newNode(1);
      head.next = newNode(9);
      head.next.next = newNode(9);
      head.next.next.next = newNode(9);
  
      document.write("List is ");
      printList(head);
  
      head = addOne(head);
      document.write("<br>");
      document.write("Resultant list is ");
      printList(head);
        
</script>

C++

// Recursive C++ program to add 1 to a linked list
#include <bits/stdc++.h>
  
/* Linked list node */
struct Node {
    int data;
    Node* next;
};
  
/* Function to create a new node with given data */
Node* newNode(int data)
{
    Node* new_node = new Node;
    new_node->data = data;
    new_node->next = NULL;
    return new_node;
}
  
Node* addOne(Node* head)
{
    // Your Code here
    // return head of list after adding one
    Node* ln = head;
    if (head->next == NULL) {
        head->data += 1;
        return head;
    }
    Node* t = head;
    int prev;
    while (t->next) {
        if (t->data != 9) {
            ln = t;
        }
        t = t->next;
    }
    if (t->data == 9 && ln != NULL) {
        if (ln->data == 9 && ln == head) {
            Node* temp = newNode(1);
            temp->next = head;
            head = temp;
            t = ln;
        }
        else {
            t = ln;
            t->data += 1;
            t = t->next;
        }
        while (t) {
            t->data = 0;
            t = t->next;
        }
    }
    else {
        t->data += 1;
    }
    return head;
}
  
// A utility function to print a linked list
void printList(Node* node)
{
    while (node != NULL) {
        printf("%d->", node->data);
        node = node->next;
    }
    printf("NULL");
    printf("\n");
}
  
/* Driver code */
int main(void)
{
    Node* head = newNode(1);
    head->next = newNode(9);
    head->next->next = newNode(9);
    head->next->next->next = newNode(9);
  
    printf("List is ");
    printList(head);
  
    head = addOne(head);
  
    printf("\nResultant list is ");
    printList(head);
  
    return 0;
}
// This code is contribute bu maddler

Java

// Recursive Java program to add 1 to a linked list
class GFG{
  
// Linked list node
static class Node
{
    int data;
    Node next;
}
  
// Function to create a new node with given data
static Node newNode(int data)
{
    Node new_node = new Node();
    new_node.data = data;
    new_node.next = null;
    return new_node;
}
  
static Node addOne(Node head)
{
      
    // Return head of list after adding one
    Node ln = head;
      
    if (head.next == null)
    {
        head.data += 1;
        return head;
    }
  
    Node t = head;
    int prev;
  
    while (t.next != null) 
    {
        if (t.data != 9) 
        {
            ln = t;
        }
        t = t.next;
    }
    if (t.data == 9 && ln != null)
    {
        t = ln;
        t.data += 1;
        t = t.next;
        while (t != null) 
        {
            t.data = 0;
            t = t.next;
        }
    }
    else 
    {
        t.data += 1;
    }
    return head;
}
  
// A utility function to print a linked list
static void printList(Node node)
{
    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(9);
    head.next.next = newNode(9);
    head.next.next.next = newNode(9);
  
    System.out.print("List is ");
    printList(head);
  
    head = addOne(head);
    System.out.println();
    System.out.print("Resultant list is ");
    printList(head);
}
}
  
// This code is contributed by rajsanghavi9.

Python3

# Recursive Python 3 program to add 1 to a linked list
class GFG :
    # Linked list node
    class Node :
        data = 0
        next = None
    # Function to create a new node with given data
    @staticmethod
    def  newNode( data) :
        new_node = GFG.Node()
        new_node.data = data
        new_node.next = None
        return new_node
    @staticmethod
    def  addOne( head) :
        # Return head of list after adding one
        ln = head
        if (head.next == None) :
            head.data += 1
            return head
        t = head
        prev = 0
        while (t.next != None) :
            if (t.data != 9) :
                ln = t
            t = t.next
        if (t.data == 9 and ln != None) :
            t = ln
            t.data += 1
            t = t.next
            while (t != None) :
                t.data = 0
                t = t.next
        else :
            t.data += 1
        return head
    # A utility function to print a linked list
    @staticmethod
    def printList( node) :
        while (node != None) :
            print(node.data, end ="")
            node = node.next
        print()
    # Driver code
    @staticmethod
    def main( args) :
        head = GFG.newNode(1)
        head.next = GFG.newNode(9)
        head.next.next = GFG.newNode(9)
        head.next.next.next = GFG.newNode(9)
        print("List is ", end ="")
        GFG.printList(head)
        head = GFG.addOne(head)
        print()
        print("Resultant list is ", end ="")
        GFG.printList(head)
      
if __name__=="__main__":
    GFG.main([])
      
    # This code is contributed by mukulsomukesh.

C#

// Recursive C# program to add 1 to a linked list
using System;
  
class GfG {
  
  /* Linked list node */
  public class Node {
    public int data;
    public Node next;
  }
  
  /* Function to create a new node with given data */
  public static Node newNode(int data)
  {
    Node new_node = new Node();
    new_node.data = data;
    new_node.next = null;
    return new_node;
  }
  
  public static Node addOne(Node head)
  {
    // Return head of list after adding one
    Node ln = head;
  
    if (head.next == null) {
      head.data += 1;
      return head;
    }
  
    Node t = head;
  
    while (t.next != null) {
      if (t.data != 9) {
        ln = t;
      }
      t = t.next;
    }
    if (t.data == 9 && ln != null) {
      t = ln;
      t.data += 1;
      t = t.next;
      while (t != null) {
        t.data = 0;
        t = t.next;
      }
    }
    else {
      t.data += 1;
    }
    return head;
  }
  
  // A utility function to print a linked list
  public static void printList(Node node)
  {
    while (node != null) {
      Console.Write(node.data);
      node = node.next;
    }
    Console.WriteLine();
  }
  
  /* Driver code */
  public static void Main(String[] args)
  {
    Node head = newNode(1);
    head.next = newNode(9);
    head.next.next = newNode(9);
    head.next.next.next = newNode(9);
  
    Console.Write("List is ");
    printList(head);
  
    head = addOne(head);
    Console.WriteLine();
    Console.Write("Resultant list is ");
    printList(head);
  }
}
  
/* This code contributed by Abhijeet Kumar(abhijeet19403) */

Javascript

<script>
  
// Recursive JavaScript program to add 1 to a linked list
  
// Linked list node
class Node
{
    constructor()
    {
        this.next = null;
        this.data = 0;
    }
}
      
// Function to create a new node with given data
function newNode(data)
{
    let new_node = new Node();
    new_node.data = data;
    new_node.next = null;
    return new_node;
}
      
function addOne(head)
{
          
    // Return head of list after adding one
    let ln = head;
      
    if (head.next == null)
    {
        head.data += 1;
        return head;
    }
      
    let t = head;
    let prev;
      
    while (t.next != null)
    {
        if (t.data != 9)
        {
            ln = t;
        }
        t = t.next;
    }
    if (t.data == 9 && ln != null)
    {
        t = ln;
        t.data += 1;
        t = t.next;
        while (t != null)
        {
            t.data = 0;
            t = t.next;
        }
    }
    else
    {
        t.data += 1;
    }
    return head;
}
      
// A utility function to print a linked list
function printList(node)
{
    while (node != null)
    {
        document.write(node.data);
        node = node.next;
    }
    document.write("</br>");
}
      
// Driver code
  
let head = newNode(1);
head.next = newNode(9);
head.next.next = newNode(9);
head.next.next.next = newNode(9);
      
document.write("List is ");
printList(head);
      
head = addOne(head);
document.write("</br>");
document.write("Resultant list is ");
printList(head);
  
// This code is contributed by shinjanpatra
  
</script>

Publicación traducida automáticamente

Artículo escrito por GeeksforGeeks-1 y traducido por Barcelona Geeks. The original can be accessed here. Licence: CCBY-SA

Deja una respuesta

Tu dirección de correo electrónico no será publicada. Los campos obligatorios están marcados con *