Merkle Tree Builder - Problem

A Merkle tree is a cryptographic data structure where each leaf node represents a data block, and each internal node represents the hash of its children. The root hash represents the integrity of all data blocks.

Build a Merkle tree from an array of data blocks and implement a function to verify if a given data block exists in the tree (proof-of-inclusion).

Requirements:

Use SHA-256 hashing (simulate with simple hash function for this problem)
For odd number of nodes at any level, duplicate the last node
Return the root hash and implement verification

Input & Output

Example 1 — Four Data Blocks

$ Input: data_blocks = ["block1", "block2", "block3", "block4"]

› Output: {"root_hash": "7890", "tree": [["1234", "5678", "9012", "3456"], ["1357", "2468"], ["7890"]], "verify": true}

💡 Note: Build Merkle tree: hash each block to get leaf level, then pair and hash adjacent nodes level by level until reaching single root hash

Example 2 — Odd Number of Blocks

$ Input: data_blocks = ["A", "B", "C"]

› Output: {"root_hash": "4567", "tree": [["1111", "2222", "3333"], ["4444", "3333"], ["4567"]], "verify": true}

💡 Note: With odd number, duplicate last node C at each level: pair A+B, then duplicate C, continue until root

Example 3 — Single Block

$ Input: data_blocks = ["single"]

› Output: {"root_hash": "9999", "tree": [["9999"]], "verify": true}

💡 Note: Single block case: hash the block once, it becomes both leaf and root of the tree

Constraints

1 ≤ data_blocks.length ≤ 1000
1 ≤ data_blocks[i].length ≤ 100
data_blocks[i] contains only alphanumeric characters

Visualization

Tap to expand

Asked in

C Coinbase 25 B Blockchain.com 20 R Ripple 15 M Microsoft 12

The key insight is building a binary tree where each parent node is the hash of its children concatenated. This creates cryptographic proof-of-inclusion where any block can be verified with O(log n) intermediate hashes instead of checking all blocks. Best approach constructs the tree level-by-level from leaves to root. Time: O(n), Space: O(n)

Common Approaches

✓ Binary Tree Construction

⏱️ Time: O(n) Space: O(n)

Construct a complete binary tree where leaf nodes are data block hashes and internal nodes are hashes of their children concatenated. Build level by level until reaching root.

Linear Search Through All Blocks

⏱️ Time: O(n) Space: O(n)

Keep all data blocks in a simple array. For verification, iterate through each block and compare with the target. No tree structure, just basic linear search.

Binary Tree Construction — Algorithm Steps

Hash all leaf nodes (data blocks)
Pair adjacent nodes and hash concatenation
Repeat until single root remains
Store tree structure for proof verification

Visualization

Tap to expand

Step-by-Step Walkthrough

Leaf Level

Hash all data blocks as leaf nodes

Internal Nodes

Pair and hash adjacent nodes level by level

Root Hash

Final single hash representing entire tree

Code -

solution.c — C

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

int hashData(const char* data) {
    int hash = 0;
    for (int i = 0; data[i]; i++) {
        hash = hash * 31 + data[i];
    }
    return abs(hash % 10000);
}

typedef struct {
    char root_hash[20];
    int verify;
    int tree_height;
} MerkleResult;

MerkleResult solution(char dataBlocks[][100], int size) {
    MerkleResult result;
    result.tree_height = 0;
    
    if (size == 0) {
        strcpy(result.root_hash, "");
        result.verify = 0;
        return result;
    }
    
    // Simple Merkle tree construction
    char currentLevel[20][20];
    int currentSize = size;
    
    // Hash all blocks first
    for (int i = 0; i < size; i++) {
        sprintf(currentLevel[i], "%d", hashData(dataBlocks[i]));
    }
    
    // Build tree bottom-up
    while (currentSize > 1) {
        int nextSize = 0;
        char nextLevel[20][20];
        
        for (int i = 0; i < currentSize; i += 2) {
            char combined[100];
            strcpy(combined, currentLevel[i]);
            if (i + 1 < currentSize) {
                strcat(combined, currentLevel[i + 1]);
            } else {
                strcat(combined, currentLevel[i]); // Duplicate last
            }
            sprintf(nextLevel[nextSize], "%d", hashData(combined));
            nextSize++;
        }
        
        // Copy next level to current
        for (int i = 0; i < nextSize; i++) {
            strcpy(currentLevel[i], nextLevel[i]);
        }
        currentSize = nextSize;
        result.tree_height++;
    }
    
    strcpy(result.root_hash, currentLevel[0]);
    result.verify = 1;
    
    return result;
}

int main() {
    char dataBlocks[10][100];
    int size = 4;
    
    // Sample data
    strcpy(dataBlocks[0], "block1");
    strcpy(dataBlocks[1], "block2");
    strcpy(dataBlocks[2], "block3");
    strcpy(dataBlocks[3], "block4");
    
    MerkleResult result = solution(dataBlocks, size);
    printf("{\"root_hash\":\"%s\",\"verify\":%s}\n", result.root_hash, result.verify ? "true" : "false");
    
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n)

Process each block once, then build tree levels - total O(n + n/2 + n/4 + ...) = O(n)

✓ Linear Growth

Space Complexity

O(n)

Store complete tree structure with all internal nodes

⚡ Linearithmic Space

12.0K Views

Medium Frequency

~35 min Avg. Time

450 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

Merkle Tree Builder - Problem

Input & Output

Constraints

Visualization

Related Problems

Common Approaches

Binary Tree Construction — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler