Open In App

Decimal Equivalent of Binary Linked List

Improve
Improve
Like Article
Like
Save
Share
Report

Given a singly linked list of 0s and 1s find its decimal equivalent.

   Input  : 0->0->0->1->1->0->0->1->0
Output : 50

Input : 1->0->0
Output : 4

The decimal value of an empty linked list is considered as 0.

Initialize the result as 0. Traverse the linked list and for each node, multiply the result by 2 and add the node’s data to it.

C++




// C++ Program to find decimal value of
// binary linked list
#include <bits/stdc++.h>
using namespace std;
 
/* Link list Node */
class Node
{
    public:
    bool data;
    Node* next;
};
 
/* Returns decimal value of binary linked list */
int decimalValue(Node *head)
{
    // Initialized result
    int res = 0;
 
    // Traverse linked list
    while (head != NULL)
    {
        // Multiply result by 2 and add
        // head's data
        res = (res << 1) + head->data;
 
        // Move next
        head = head->next;
    }
    return res;
}
 
// Utility function to create a new node.
Node *newNode(bool data)
{
    Node *temp = new Node;
    temp->data = data;
    temp->next = NULL;
    return temp;
}
 
/* Driver program to test above function*/
int main()
{
    /* Start with the empty list */
    Node* head = newNode(1);
    head->next = newNode(0);
    head->next->next = newNode(1);
    head->next->next->next = newNode(1);
 
    cout << "Decimal value is "
        << decimalValue(head);
 
    return 0;
}
 
// This is code is contributed by rathbhupendra


C




// C Program to find decimal value of
// binary linked list
#include<iostream>
using namespace std;
 
/* Link list Node */
struct Node
{
    bool data;
    struct Node* next;
};
 
/* Returns decimal value of binary linked list */
int decimalValue(struct Node *head)
{
    // Initialized result
    int  res = 0;
 
    // Traverse linked list
    while (head != NULL)
    {
        // Multiply result by 2 and add
        // head's data
        res = (res  << 1) + head->data;
 
        // Move next
        head = head->next;
    }
    return res;
}
 
// Utility function to create a new node.
Node *newNode(bool data)
{
    struct Node *temp = new Node;
    temp->data = data;
    temp->next = NULL;
    return temp;
}
 
/* Driver program to test above function*/
int main()
{
    /* Start with the empty list */
    struct Node* head = newNode(1);
    head->next = newNode(0);
    head->next->next = newNode(1);
    head->next->next->next = newNode(1);
 
    cout << "Decimal value is "
         << decimalValue(head);
 
    return 0;
}


Java




// Java Program to find decimal value of
// binary linked list
class GFG
{
     
// Link list Node /
static class Node
{
    boolean data;
    Node next;
};
 
// Returns decimal value of binary linked list /
static int decimalValue( Node head)
{
    // Initialized result
    int res = 0;
 
    // Traverse linked list
    while (head != null)
    {
        // Multiply result by 2 and add
        // head's data
        res = (res << 1) + (head.data?1:0);
 
        // Move next
        head = head.next;
    }
    return res;
}
 
// Utility function to create a new node.
static Node newNode(int data)
{
    Node temp = new Node();
    temp.data = (data==1? true:false);
    temp.next = null;
    return temp;
}
 
// Driver code/
public static void main(String args[])
{
    // Start with the empty list /
    Node head = newNode(1);
    head.next = newNode(0);
    head.next.next = newNode(1);
    head.next.next.next = newNode(1);
 
    System.out.print( "Decimal value is "+decimalValue(head));
}
}
 
// This code is contributed by Arnab Kundu


Python3




# Python3 program to find decimal value
# of binary linked list
 
# Node Class
class Node:
     
    # Function to initialise the
    # node object
    def __init__(self, data):
         
        # Assign data
        self.data = data
         
        # Initialize next as null
        self.next = None
 
# Linked List class contains
# a Node object
class LinkedList:
 
    # Function to initialize head
    def __init__(self):
         
        self.head = None
 
    # Returns decimal value of binary
    # linked list
    def decimalValue(self, head):
         
        # Initialized result
        res = 0
 
        # Traverse linked list
        while head:
 
            # Multiply result by 2 and
            # add head's data
            res = (res << 1) + head.data
 
            # Move Next
            head = head.next
             
        return res
 
# Driver code
if __name__ == '__main__':
 
    #Start with the empty list
    llist = LinkedList()
 
    llist.head = Node(1)
    llist.head.next = Node(0)
    llist.head.next.next = Node(1)
    llist.head.next.next.next = Node(1)
     
    print("Decimal Value is {}".format(
           llist.decimalValue(llist.head)))
 
# This code is contributed by Mohit Jangra


C#




// C# Program to find decimal value of
// binary linked list
using System;
 
class GFG
{
     
// Link list Node /
public class Node
{
    public Boolean data;
    public Node next;
};
 
// Returns decimal value of binary linked list
static int decimalValue( Node head)
{
    // Initialized result
    int res = 0;
 
    // Traverse linked list
    while (head != null)
    {
        // Multiply result by 2 and add
        // head's data
        res = (res << 1) + (head.data ? 1 : 0);
 
        // Move next
        head = head.next;
    }
    return res;
}
 
// Utility function to create a new node.
static Node newNode(int data)
{
    Node temp = new Node();
    temp.data = (data == 1 ? true : false);
    temp.next = null;
    return temp;
}
 
// Driver code
public static void Main(String []args)
{
    // Start with the empty list
    Node head = newNode(1);
    head.next = newNode(0);
    head.next.next = newNode(1);
    head.next.next.next = newNode(1);
 
    Console.WriteLine("Decimal value is " +
                       decimalValue(head));
}
}
 
// This code is contributed by Rajput-Ji


Javascript




<script>
 
// Javascript Program to find decimal value of
// binary linked list    
// Link list Node /
     class Node {
         constructor(){
         this.data = true;
         this.next = null;
    }
    }
 
    // Returns decimal value of binary linked list /
    function decimalValue(head) {
        // Initialized result
        var res = 0;
 
        // Traverse linked list
        while (head != null) {
            // Multiply result by 2 and add
            // head's data
            res = (res << 1) + (head.data ? 1 : 0);
 
            // Move next
            head = head.next;
        }
        return res;
    }
 
    // Utility function to create a new node.
    function newNode(data) {
var temp = new Node();
        temp.data = (data == 1 ? true : false);
        temp.next = null;
        return temp;
    }
 
    // Driver code/
     
        // Start with the empty list /
var head = newNode(1);
        head.next = newNode(0);
        head.next.next = newNode(1);
        head.next.next.next = newNode(1);
 
        document.write("Decimal value is "
        + decimalValue(head));
 
// This code contributed by aashish1995
 
</script>


Output

Decimal value is 11

Time Complexity: O(n) where n is the number of nodes in the given linked list.
Auxiliary Space: O(1), no extra space is required, so it is a constant.

Another Approach(by reversing the Linked List):
Follow the below steps to solve the given problem
1) First reverse the given linked list.
2) Initialize a ans variable to store ans and pos variable to keep track of position of node in linked list.
3) Perform the operation ans = ans + (rhead.data*(2**pos))%MOD)
4) perform ans = ans%MOD

Below is the implementation of above approach:

C++




#include<bits/stdc++.h>
using namespace std;
// C++ Program to find decimal value
// of binary linked list
 
// node structure
struct Node{
    int data;
    Node* next;
    Node(int data){
        this->data = data;
        this->next = NULL;
    }
};
 
long long unsigned int power(int num,int count){
   if(count ==0) return 1;
   if(count%2==0)
       return (power(num,count/2)%1000000007)*(power(num,count/2)%1000000007);
   else
       return num*(power(num,count/2)%1000000007)*(power(num,count/2)%1000000007);;
}
 
Node* reverse(Node* head){
    if(head == NULL || head->next == NULL) return head;
     
    Node* curr = head;
    Node* prev = NULL;
    Node* nxt = head->next;
    while(nxt != NULL){
        curr->next = prev;
        prev = curr;
        curr = nxt;
        nxt = nxt->next;
    }
    curr->next = prev;
    return curr;
}
 
int decimalValue(Node* head){
    int MOD = 1000000007;
    Node* rhead = reverse(head);
     
    int ans = 0;
    int pos = 0;
    while(rhead != NULL){
        ans = (ans%MOD + ((rhead->data)*power(2,pos)) % MOD) % MOD;
        rhead = rhead->next;
        pos++;
    }
    return ans;
}
 
int main(){
    Node* head = new Node(1);
    head->next = new Node(0);
    head->next->next = new Node(1);
    head->next->next->next = new Node(1);
     
    cout<<"Decimal Value is : "<<decimalValue(head);
}


Java




// Java implementation to find non-leaf
// count of a given Binary tree
import java.util.*;
 
// class to represent the tree node
class Node{
    public int data;
    public Node next;
    public Node(int item){
        data = item;
        next = null;
    }
}
 
public class LinkedList{
    static int power(int num, int count){
        if(count ==0) return 1;
        if(count % 2 ==0)
            return (power(num,count/2)%1000000007)*(power(num,count/2)%1000000007);
        else
            return num*(power(num,count/2)%1000000007)*(power(num,count/2)%1000000007);
    }
     
    static Node reverse(Node head){
        if(head == null || head.next == null) return head;
         
        Node curr = head;
        Node prev = null;
        Node nxt = head.next;
        while(nxt != null){
            curr.next = prev;
            prev = curr;
            curr = nxt;
            nxt = nxt.next;
        }
        curr.next = prev;
        return curr;
    }
     
    static int decimalValue(Node head){
        Node rhead = reverse(head);
         
        int ans = 0;
        int pos = 0;
        while(rhead != null){
            ans = (ans % 1000000007 + ((rhead.data)*((int)power(2,pos))) % 1000000007) % 1000000007;
            rhead = rhead.next;
            pos++;
        }
        return ans;
    }
     
    // driver code to test above function
    public static void main(String args[]){
        Node head = new Node(1);
        head.next = new Node(0);
        head.next.next = new Node(1);
        head.next.next.next = new Node(1);
         
        // function call
        System.out.println("Decimal Value is : " + decimalValue(head));
    }
}


Python3




# Python3 program to find decimal value
# of binary linked list
  
# Node Class
class Node:
    # Function to initialise the
    # node object
    def __init__(self, data):
        # Assign data
        self.data = data
        # Initialize next as null
        self.next = None
         
         
def reverse(head):
    if(head == None or head.next == None):
        return head
    curr = head
    prev = None
    nxt = head.next
    while(nxt):
        curr.next = prev
        prev = curr
        curr = nxt
        nxt = nxt.next
    curr.next = prev
    return curr
 
 
def decimalValue(head):
    MOD=10**9+7
    rhead = reverse(head)
 
    ans = 0
    pos = 0
    while rhead:
        ans = (ans % MOD+(rhead.data*(2**pos)) % MOD) % MOD
        rhead = rhead.next
        pos += 1
    return ans
     
 
head = Node(1)
head.next = Node(0)
head.next.next = Node(1)
head.next.next.next = Node(1)
 
print("Decimal Value is :", end =" ")
print(decimalValue(head))
 
# THIS CODE IS CONTRIBUTED BY YASH AGARWAL(YASHAGARWAL2852002)


C#




using System;
 
// C# Program to find decimal value
// of binary linked list
class GFG{
  public class Node{
    public int data;
    public Node next;
    public Node(int data){
      this.data = data;
      this.next = null;
    }
  }
 
  static int power(int num, int count){
    if(count == 0) return 1;
    if(count%2==0)
      return (power(num,count/2)%1000000007)*(power(num,count/2)%1000000007);
    else
      return num*(power(num,count/2)%1000000007)*(power(num,count/2)%1000000007);
  }
 
  static Node reverse(Node head){
    if(head == null || head.next == null) return head;
    Node curr = head;
    Node prev = null;
    Node nxt = head.next;
    while(nxt != null){
      curr.next = prev;
      prev = curr;
      curr = nxt;
      nxt = nxt.next;
    }
    curr.next = prev;
    return curr;
  }
 
  static int decimalValue(Node head){
    int MOD = 1000000007;
    Node rhead = reverse(head);
 
    int ans = 0;
    int pos = 0;
    while(rhead != null){
      ans = (ans%MOD + ((rhead.data)*power(2,pos)) % MOD) % MOD;
      rhead = rhead.next;
      pos++;
    }
    return ans;
  }
 
  public static void Main(){
    Node head = new Node(1);
    head.next =  new Node(0);
    head.next.next = new Node(1);
    head.next.next.next = new Node(1);
    Console.WriteLine("Decimal Value is : " + decimalValue(head));
  }
}


Javascript




// JavaScript program to find the decimal value
// of binary linked list
// node class
class Node{
    constructor(data){
        this.data = data;
        this.left = null;
        this.right = null;
    }
}
 
function reverse(head){
    if(head == null || head.next == null) return head;
     
    let curr = head;
    let prev = null;
    let nxt = head.next;
    while(nxt != null){
        curr.next = prev;
        prev = curr;
        curr = nxt;
        nxt = nxt.next;
    }
    curr.next = prev;
    return curr;
}
 
function decimalValue(head){
    let MOD = 1000000007;
    let rhead = reverse(head);
     
    let ans = 0;
    let pos = 0;
    while(rhead != null){
        ans = (ans % MOD+(rhead.data*(2**pos)) % MOD) % MOD;
        rhead = rhead.next;
        pos += 1;
    }
    return ans;
}
 
// driver program to test above function
let head = new Node(1);
head.next = new Node(0);
head.next.next = new Node(1);
head.next.next.next= new Node(1);
 
console.log("Decimal Value is : " + decimalValue(head));


Output

Decimal Value is : 11

Time Complexity: O(N) where N is the number of nodes in linked list.
Auxiliary Space: O(1)

 



Last Updated : 28 Dec, 2023
Like Article
Save Article
Previous
Next
Share your thoughts in the comments
Similar Reads