Sorted Linked List to Balanced BST

Last Updated : 8 Sep, 2026

Given a singly linked list whose elements are sorted in ascending order, construct a height-balanced Binary Search Tree (BST) containing the same elements as the linked list. A height-balanced BST is defined as a binary tree in which the depth difference between the left and right subtrees of every node is at most 1.

  • It is guaranteed that the linked list does not contain duplicate values.
  • The middle element would always be the root. In case of even elements, pick the root as second mid as root.
  • You need to return root of the tree, the preorder traversal is printed by the driver code to test your result.

Examples:

Input: Linked List : 1->2->3       Output: 2 1 3
Explanation: The BST formed using elements of the linked list is -
       Hence, the preorder traversal of this tree is 2 1 3.

Input: 1 2 3 4 5 6 7

pairwise_swap_of_nodes_in_linkedlistq_1

Output: 4 2 1 3 6 5 7
Explanation: The BST formed using elements of the linked list is -

420851421

Hence, the preorder traversal of this tree is 4 2 1 3 6 5 7.

Try It Yourself
redirect icon

Table of Content

[Naive Approach] Using an Array - O(n) time and O(n) space

The core idea involves converting the linked list into an array. Then, the middle element of this array is used as the root, recursively building a balanced BST.

C++ 
#include <iostream>
#include <vector>
using namespace std;

class LNode
{
  public:
    int data;
    LNode *next;
    LNode(int x)
    {
        data = x;
        next = nullptr;
    }
};

class TNode
{
  public:
    int data;
    TNode *left;
    TNode *right;
    TNode(int x)
    {
        data = x;
        left = nullptr;
        right = nullptr;
    }
};

TNode *buildTree(vector<int> &arr, int start, int end)
{
    if (start > end)
        return nullptr;

    int mid = (start + end + 1) / 2;
    TNode *root = new TNode(arr[mid]);

    root->left = buildTree(arr, start, mid - 1);
    root->right = buildTree(arr, mid + 1, end);

    return root;
}

TNode *sortedListToBST(LNode *head)
{
    vector<int> arr;

    // Store elements of linked list into array
    while (head)
    {
        arr.push_back(head->data);
        head = head->next;
    }

    // Build BST from array
    return buildTree(arr, 0, arr.size() - 1);
}

void printTree(TNode *root)
{
    if (!root)
        return;
    cout << root->data << " ";
    printTree(root->left);
    printTree(root->right);
}

int main()
{
    LNode *head = new LNode(1);
    head->next = new LNode(2);
    head->next->next = new LNode(3);
    head->next->next->next = new LNode(4);
    head->next->next->next->next = new LNode(5);
    head->next->next->next->next->next = new LNode(6);
    head->next->next->next->next->next->next = new LNode(7);

    TNode *root = sortedListToBST(head);
    printTree(root);
    return 0;
}
Java 
import java.util.ArrayList;

class LNode {
    int data;
    LNode next;
    LNode(int x) {
        data = x;
        next = null;
    }
}

class TNode {
    int data;
    TNode left;
    TNode right;
    TNode(int x) {
        data = x;
        left = null;
        right = null;
    }
}

class GfG {
    static TNode buildTree(ArrayList<Integer> arr, int start, int end) {
        if (start > end) return null;

        int mid = (start + end + 1) / 2;
        TNode root = new TNode(arr.get(mid));

        root.left = buildTree(arr, start, mid - 1);
        root.right = buildTree(arr, mid + 1, end);

        return root;
    }

    static TNode sortedListToBST(LNode head) {
        ArrayList<Integer> arr = new ArrayList<>();

        // Store elements of linked list into array
        while (head != null) {
            arr.add(head.data);
            head = head.next;
        }

        // Build BST from array
        return buildTree(arr, 0, arr.size() - 1);
    }

    static void printTree(TNode root) {
        if (root == null) return;
        System.out.print(root.data + " ");
        printTree(root.left);
        printTree(root.right);
    }

    public static void main(String[] args) {
        LNode head = new LNode(1);
        head.next = new LNode(2);
        head.next.next = new LNode(3);
        head.next.next.next = new LNode(4);
        head.next.next.next.next = new LNode(5);
        head.next.next.next.next.next = new LNode(6);
        head.next.next.next.next.next.next = new LNode(7);

        TNode root = sortedListToBST(head);
        printTree(root);
    }
}
Python 
class LNode:
    def __init__(self, x):
        self.data = x
        self.next = None

class TNode:
    def __init__(self, x):
        self.data = x
        self.left = None
        self.right = None

def buildTree(arr, start, end):
    if start > end:
        return None

    mid = (start + end + 1) // 2
    root = TNode(arr[mid])

    root.left = buildTree(arr, start, mid - 1)
    root.right = buildTree(arr, mid + 1, end)

    return root

def sortedListToBST(head):
    arr = []

    # Store elements of linked list into array
    while head:
        arr.append(head.data)
        head = head.next

    # Build BST from array
    return buildTree(arr, 0, len(arr) - 1)

def printTree(root):
    if not root:
        return
    print(root.data, end=" ")
    printTree(root.left)
    printTree(root.right)

if __name__ == "__main__":
    head = LNode(1)
    head.next = LNode(2)
    head.next.next = LNode(3)
    head.next.next.next = LNode(4)
    head.next.next.next.next = LNode(5)
    head.next.next.next.next.next = LNode(6)
    head.next.next.next.next.next.next = LNode(7)

    root = sortedListToBST(head)
    printTree(root)
C# 
using System;
using System.Collections.Generic;

class LNode {
    
    public int data;
    public LNode next;
    
    public LNode(int x) {
        
        data = x;
        next = null;
    }
}

class TNode {
    
    public int data;
    public TNode left;
    public TNode right;
    
    public TNode(int x) {
        
        data = x;
        left = null;
        right = null;
    }
}

class GfG {
    static TNode buildTree(List<int> arr, int start, int end) {
        
        if (start > end) return null;

        int mid = (start + end + 1) / 2;
        TNode root = new TNode(arr[mid]);

        root.left = buildTree(arr, start, mid - 1);
        root.right = buildTree(arr, mid + 1, end);

        return root;
    }

    static TNode sortedListToBST(LNode head) {
        List<int> arr = new List<int>();

        // Store elements of linked list into array
        while (head != null) {
            arr.Add(head.data);
            head = head.next;
        }

        // Build BST from array
        return buildTree(arr, 0, arr.Count - 1);
    }

    static void printTree(TNode root) {
        
        if (root == null) return;
        
        Console.Write(root.data + " ");
        
        printTree(root.left);
        printTree(root.right);
    }

    public static void Main(string[] args) {
        
        LNode head = new LNode(1);
        head.next = new LNode(2);
        head.next.next = new LNode(3);
        head.next.next.next = new LNode(4);
        head.next.next.next.next = new LNode(5);
        head.next.next.next.next.next = new LNode(6);
        head.next.next.next.next.next.next = new LNode(7);

        TNode root = sortedListToBST(head);
        printTree(root);
    }
}
JavaScript 
class LNode {
    
    constructor(x) {
        
        this.data = x;
        this.next = null;
    }
}

class TNode {
    
    constructor(x) {
        
        this.data = x;
        this.left = null;
        this.right = null;
    }
}

function buildTree(arr, start, end) {
    
    if (start > end) return null;

    const mid = Math.floor((start + end + 1) / 2);
    const root = new TNode(arr[mid]);

    root.left = buildTree(arr, start, mid - 1);
    root.right = buildTree(arr, mid + 1, end);

    return root;
}

function sortedListToBST(head) {
    
    const arr = [];

    // Store elements of linked list into array
    while (head) {
        
        arr.push(head.data);
        head = head.next;
    }

    // Build BST from array
    return buildTree(arr, 0, arr.length - 1);
}

function printTree(root) {
    
    if (!root) return;
    
    process.stdout.write(root.data + " ");
    
    printTree(root.left);
    printTree(root.right);
}

const head = new LNode(1);
head.next = new LNode(2);
head.next.next = new LNode(3);
head.next.next.next = new LNode(4);
head.next.next.next.next = new LNode(5);
head.next.next.next.next.next = new LNode(6);
head.next.next.next.next.next.next = new LNode(7);

const root = sortedListToBST(head);
printTree(root);

Output
4 2 1 3 6 5 7

[Expected Approach] In-Order Traversal - O(n) time and O(log n) space

This approach uses Inorder traversal to construct the tree directly from the linked list.

We first count nodes and use this count in the recursive calls to decide whether the current node would be root, go to left subtree or right subtree.

Let the count of nodes be n, we mainly pass n/2 to left subtree, build root and pass n - n/2 - 1 to right subtree.

C++ 
#include <iostream>
using namespace std;

class LNode
{
  public:
    int data;
    LNode *next;
    LNode(int x)
    {
        data = x;
        next = nullptr;
    }
};

class TNode
{
  public:
    int data;
    TNode *left;
    TNode *right;
    TNode(int x)
    {
        data = x;
        left = nullptr;
        right = nullptr;
    }
};

int countNodes(LNode *head)
{
    int count = 0;
    while (head)
    {
        count++;
        head = head->next;
    }
    return count;
}

TNode *buildTree(LNode *&headRef, int n)
{
    if (n <= 0)
        return nullptr;

    // Build left subtree
    TNode *left = buildTree(headRef, n / 2);

    // Create root node
    TNode *root = new TNode(headRef->data);
    root->left = left;

    // Move list head forward
    headRef = headRef->next;

    // Build right subtree
    root->right = buildTree(headRef, n - n / 2 - 1);

    return root;
}

TNode *sortedListToBST(LNode *head)
{
    int n = countNodes(head);
    return buildTree(head, n);
}

void printTree(TNode *root)
{
    if (!root)
        return;
    cout << root->data << " ";
    printTree(root->left);
    printTree(root->right);
}

int main()
{
    LNode *head = new LNode(1);
    head->next = new LNode(2);
    head->next->next = new LNode(3);
    head->next->next->next = new LNode(4);
    head->next->next->next->next = new LNode(5);
    head->next->next->next->next->next = new LNode(6);
    head->next->next->next->next->next->next = new LNode(7);

    TNode *root = sortedListToBST(head);
    printTree(root);
    return 0;
}
Java 
class LNode {
    int data;
    LNode next;
    LNode(int x) {
        data = x;
        next = null;
    }
}

class TNode {
    int data;
    TNode left;
    TNode right;
    TNode(int x) {
        data = x;
        left = null;
        right = null;
    }
}

class GfG {
    static int countNodes(LNode head) {
        int count = 0;
        while (head != null) {
            count++;
            head = head.next;
        }
        return count;
    }

    static TNode buildTree(LNode[] headRef, int n) {
        if (n <= 0) return null;

        // Build left subtree
        TNode left = buildTree(headRef, n / 2);

        // Create root node
        TNode root = new TNode(headRef[0].data);
        root.left = left;

        // Move list head forward
        headRef[0] = headRef[0].next;

        // Build right subtree
        root.right = buildTree(headRef, n - n / 2 - 1);

        return root;
    }

    static TNode sortedListToBST(LNode head) {
        int n = countNodes(head);
        LNode[] headRef = new LNode[]{head};
        return buildTree(headRef, n);
    }

    static void printTree(TNode root) {
        if (root == null) return;
        System.out.print(root.data + " ");
        printTree(root.left);
        printTree(root.right);
    }

    public static void main(String[] args) {
        LNode head = new LNode(1);
        head.next = new LNode(2);
        head.next.next = new LNode(3);
        head.next.next.next = new LNode(4);
        head.next.next.next.next = new LNode(5);
        head.next.next.next.next.next = new LNode(6);
        head.next.next.next.next.next.next = new LNode(7);

        TNode root = sortedListToBST(head);
        printTree(root);
    }
}
Python 
class LNode:
    def __init__(self, x):
        self.data = x
        self.next = None

class TNode:
    def __init__(self, x):
        self.data = x
        self.left = None
        self.right = None

def countNodes(head):
    count = 0
    while head:
        count += 1
        head = head.next
    return count

def buildTree(headRef, n):
    if n <= 0:
        return None

    # Build left subtree
    left = buildTree(headRef, n // 2)

    # Create root node
    root = TNode(headRef[0].data)
    root.left = left

    # Move list head forward
    headRef[0] = headRef[0].next

    # Build right subtree
    root.right = buildTree(headRef, n - n // 2 - 1)

    return root

def sortedListToBST(head):
    n = countNodes(head)
    headRef = [head]
    return buildTree(headRef, n)

def printTree(root):
    if not root:
        return
    print(root.data, end=" ")
    printTree(root.left)
    printTree(root.right)

if __name__ == "__main__":
    head = LNode(1)
    head.next = LNode(2)
    head.next.next = LNode(3)
    head.next.next.next = LNode(4)
    head.next.next.next.next = LNode(5)
    head.next.next.next.next.next = LNode(6)
    head.next.next.next.next.next.next = LNode(7)

    root = sortedListToBST(head)
    printTree(root)
C# 
using System;

class LNode {
    public int data;
    public LNode next;
    public LNode(int x) {
        data = x;
        next = null;
    }
}

class TNode {
    public int data;
    public TNode left;
    public TNode right;
    public TNode(int x) {
        data = x;
        left = null;
        right = null;
    }
}

class GfG {
    static int countNodes(LNode head) {
        int count = 0;
        while (head != null) {
            count++;
            head = head.next;
        }
        return count;
    }

    static TNode buildTree(ref LNode headRef, int n) {
        if (n <= 0) return null;

        // Build left subtree
        TNode left = buildTree(ref headRef, n / 2);

        // Create root node
        TNode root = new TNode(headRef.data);
        root.left = left;

        // Move list head forward
        headRef = headRef.next;

        // Build right subtree
        root.right = buildTree(ref headRef, n - n / 2 - 1);

        return root;
    }

    static TNode sortedListToBST(LNode head) {
        int n = countNodes(head);
        return buildTree(ref head, n);
    }

    static void printTree(TNode root) {
        if (root == null) return;
        Console.Write(root.data + " ");
        printTree(root.left);
        printTree(root.right);
    }

    public static void Main(string[] args) {
        LNode head = new LNode(1);
        head.next = new LNode(2);
        head.next.next = new LNode(3);
        head.next.next.next = new LNode(4);
        head.next.next.next.next = new LNode(5);
        head.next.next.next.next.next = new LNode(6);
        head.next.next.next.next.next.next = new LNode(7);

        TNode root = sortedListToBST(head);
        printTree(root);
    }
}
JavaScript 
class LNode {
    constructor(x) {
        this.data = x;
        this.next = null;
    }
}

class TNode {
    constructor(x) {
        this.data = x;
        this.left = null;
        this.right = null;
    }
}

function countNodes(head) {
    let count = 0;
    while (head) {
        count++;
        head = head.next;
    }
    return count;
}

function buildTree(headRef, n) {
    if (n <= 0) return null;

    // Build left subtree
    let left = buildTree(headRef, Math.floor(n / 2));

    // Create root node
    let root = new TNode(headRef[0].data);
    root.left = left;

    // Move list head forward
    headRef[0] = headRef[0].next;

    // Build right subtree
    root.right = buildTree(headRef, n - Math.floor(n / 2) - 1);

    return root;
}

function sortedListToBST(head) {
    let n = countNodes(head);
    let headRef = [head];
    return buildTree(headRef, n);
}

function printTree(root) {
    if (!root) return;
    process.stdout.write(root.data + " ");
    printTree(root.left);
    printTree(root.right);
}

let head = new LNode(1);
head.next = new LNode(2);
head.next.next = new LNode(3);
head.next.next.next = new LNode(4);
head.next.next.next.next = new LNode(5);
head.next.next.next.next.next = new LNode(6);
head.next.next.next.next.next.next = new LNode(7);

let root = sortedListToBST(head);
printTree(root);

Output
4 2 1 3 6 5 7
Comment

Explore