Convert Binary Number in a Linked List to Integer

Convert Binary Number in a Linked List to Integer - Problem

Given the head of a singly-linked list where each node contains either 0 or 1, convert the binary number represented by the linked list to its decimal equivalent.

The binary representation follows the standard format where the most significant bit (MSB) is at the head of the list, and the least significant bit (LSB) is at the tail.

Example: If the linked list contains 1 → 0 → 1, this represents the binary number 101, which equals 5 in decimal.

Your task: Traverse the linked list and compute the decimal value efficiently.

Input & Output

example_1.py — Basic Case

$ Input: head = [1,0,1]

› Output: 5

💡 Note: Binary 101 equals 1×2² + 0×2¹ + 1×2⁰ = 4 + 0 + 1 = 5

example_2.py — Single Node

$ Input: head = [0]

› Output: 0

💡 Note: Single node with value 0 represents binary 0, which equals 0 in decimal

example_3.py — All Ones

$ Input: head = [1,1,1,1]

› Output: 15

💡 Note: Binary 1111 equals 1×2³ + 1×2² + 1×2¹ + 1×2⁰ = 8 + 4 + 2 + 1 = 15

Constraints

The number of nodes in the linked list is in the range [1, 30]
Node.val is either 0 or 1
The most significant bit is at the head of the linked list
The represented binary number will fit in a 32-bit integer

Visualization

Tap to expand

Understanding the Visualization

Initialize

Start with result = 0, ready to process the first bit

Process Bit 1

result = 0 × 2 + 1 = 1 (we now have decimal 1)

Process Bit 0

result = 1 × 2 + 0 = 2 (shifted left, added 0)

Process Bit 1

result = 2 × 2 + 1 = 5 (final result!)

Key Takeaway

🎯 Key Insight: Instead of calculating powers of 2, we can build the decimal value incrementally using the formula `result = result × 2 + current_bit`, which is both more intuitive and more efficient!

Asked in

a Amazon 15 ⊞ Microsoft 12 G Google 8 Apple 6

The optimal solution uses a single-pass traversal with the formula result = result × 2 + current_bit. This approach simulates bit shifting and builds the decimal value incrementally, achieving O(n) time and O(1) space complexity without needing to know the list length beforehand.

Common Approaches

Approach	Time	Space	Notes
✓ Two-Pass Approach (Count Length First)	O(n)	O(1)	Count nodes first, then traverse again to calculate decimal value using powers of 2
One-Pass Optimal Solution	O(n)	O(1)	Build decimal value in single traversal using bit shifting technique

Two-Pass Approach (Count Length First) — Algorithm Steps

First pass: Count the total number of nodes in the linked list
Second pass: For each node, multiply its value by 2^(position from right)
Sum all the calculated values to get the final decimal result

Visualization

Tap to expand

Step-by-Step Walkthrough

Count Nodes

Traverse the entire list to count total nodes (length = 3)

Calculate Powers

Second traversal: 1×2² + 0×2¹ + 1×2⁰ = 4 + 0 + 1 = 5

Return Result

Final decimal value is 5

Code -

solution.c — C

#include <stdio.h>
#include <stdlib.h>
#include <math.h>

// Definition for singly-linked list.
struct ListNode {
    int val;
    struct ListNode *next;
};

int getDecimalValue(struct ListNode* head) {
    // First pass: count the length
    int length = 0;
    struct ListNode* current = head;
    while (current) {
        length++;
        current = current->next;
    }
    
    // Second pass: calculate decimal value
    int result = 0;
    current = head;
    int position = length - 1;
    
    while (current) {
        if (current->val == 1) {
            result += (int)pow(2, position);
        }
        position--;
        current = current->next;
    }
    
    return result;
}

Time & Space Complexity

Time Complexity

⏱️

O(n)

Two passes through the linked list: O(n) to count + O(n) to calculate = O(n) overall

✓ Linear Growth

Space Complexity

O(1)

Only using a few variables regardless of input size

✓ Linear Space

95.4K Views

Medium Frequency

~8 min Avg. Time

3.4K Likes

Ln 1, Col 1

Smart Actions

💡 Explanation

AI Ready

💡 Suggestion Tab to accept Esc to dismiss

// Output will appear here after running code

Code Editor Closed

Click the red button to reopen

Input & Output

Constraints

Visualization

Related Problems

Common Approaches

Two-Pass Approach (Count Length First) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler