In-place Conversion of Sorted DLL to Balanced BST

In this tutorial, we will learn about in-place conversion of sorted DLL to balanced BST.

Method No. 1 (Simple)

The following is a simple algorithm in which we first find the middle node of the list and make it the root of the tree to be built.

1) Make the middle of the linked list to the root.

2) Go same recursively for right and left half.

Obtain middle of left turn making it left child of the root
step 1: created
Take the centre of the right half and make it the right child of the
Step 1 resulted in the creation of a root.

O(nLogn) is time complexity, where n indicates the number of nodes in the Linked List.

Method No. 2 (Tricky)

Method 1 builds the tree from the roots to the leaves. We build from the leaves to the root in this method. The concept is to add nodes in BST in the exact order that they show up in Doubly Linked List, to ensure that the tree can really be built in O(n) time. We begin by figuring out the number of nodes in the provided Linked List. Let's say the count is n. After counting nodes, we take the left n/2 nodes and construct the left subtree recursively. After constructing the left subtree, we allocate the middle node to root and connect the left subtree to root. Finally, we recursively build the correct subtree and connect it to the root.

We continue to move the list head pointer to next while constructing the BST so that we get the correct pointer in each recursive call.

The execution of method 2 is shown below. The primary code that generates Balanced BST is illustrated.

C Program:

#include<stdio.h>
#include<stdlib.h>
struct Node
{
	int data;
	struct Node* next;
	struct Node* prev;
};
int countNodes ( struct Node *head );
struct Node* sortedListToBSTRecur( struct Node **head_ref, int n );
struct Node* sortedListToBST ( struct Node *head )
{
	int n = countNodes ( head );
	return sortedListToBSTRecur ( &head, n );
}
struct Node* sortedListToBSTRecur ( struct Node **head_ref, int n )
{
	if ( n <= 0 )
		return NULL;
	struct Node *left = sortedListToBSTRecur ( head_ref, n/2 );
	struct Node *root = *head_ref;
	root -> prev = left;
	*head_ref = ( *head_ref ) -> next;
	root -> next = sortedListToBSTRecur ( head_ref, n-n/2-1 );
	return root;
}
int countNodes ( struct Node *head )
{
	int count = 0;
	struct Node *temp = head;
	while( temp )
	{
		temp = temp -> next;
		count++;
	}
	return count;
}
void push ( struct Node** head_ref, int new_data )
{
	struct Node* new_node =
			( struct Node* ) malloc( sizeof ( struct Node ) );
	new_node -> data = new_data;
	new_node -> prev = NULL;
	new_node -> next = ( *head_ref );
	if ( (*head_ref ) != NULL )
	( *head_ref ) -> prev = new_node ;
	( *head_ref ) = new_node;
}
void printList ( struct Node *node )
{
	while ( node!=NULL )
	{
		printf ( "%d ", node -> data );
		node = node->next;
	}
}
void preOrder ( struct Node* node )
{
	if ( node == NULL )
		return;
	printf ( "%d ", node -> data );
	preOrder ( node->prev );
	preOrder ( node->next );
}
int main ()
{
	struct Node* head = NULL;
	push ( &head, 14 );
	push ( &head, 13 );
	push ( &head, 12 );
	push ( &head, 11 );
	push ( &head, 10 );
	push ( &head, 9 );
	push ( &head, 8 );
	printf ( "Given Linked List\n" );
	printList (head);
	struct Node *root = sortedListToBST (head);
	printf ( "\n PreOrder Traversal of constructed BST \n " );
	preOrder (root);

	return 0;
}

C++ Program:

#include <bits/stdc++.h>
using namespace std;
class Node1
{
	public:
	int data;
	Node1* next;
	Node1* prev;
};
int counttheNodes ( Node1 *head );
Node1* sortedLstToBSTRecur ( Node1 **head_ref, int no );
Node1* sortedLstToBST ( Node1 *head )
{
	int no = counttheNodes ( head );
	return sortedLstToBSTRecur ( &head, no );
}
Node1* sortedLstToBSTRecur ( Node1 **head_ref, int no )
{
	if ( no <= 0 )
		return NULL;
	Node1 *left = sortedLstToBSTRecur( head_ref, no/2 );
	Node1 *root = *head_ref;
	root -> prev = left;
	*head_ref = ( *head_ref ) -> next;
	root -> next = sortedLstToBSTRecur ( head_ref, no-no/2-1 );
	return root;
}
int counttheNodes ( Node1 *head )
{
	int count = 0;
	Node1 *temp = head;
	while ( temp )
	{
		temp = temp -> next;
		count++;
	}
	return count;
}
void push ( Node1** head_ref, int new_data )
{
	Node1* new_node = new Node1 ();
	new_node -> data = new_data;
	new_node -> prev = NULL;
	new_node -> next = ( *head_ref );
	if ( ( *head_ref ) != NULL )
	( *head_ref ) -> prev = new_node ;
	( *head_ref ) = new_node;
}
void printtheList ( Node1 *node )
{
	while ( node!=NULL )
	{
		cout << node -> data << " ";
		node = node -> next;
	}
}
void preOrder ( Node1* node )
{
	if ( node == NULL )
		return;
	cout << node -> data <<" ";
	preOrder ( node -> prev );
	preOrder ( node -> next );
}
int main ()
{
	Node1* head = NULL;
	push ( &head, 14 );
	push ( &head, 13 );
	push ( &head, 12 );
	push ( &head, 11 );
	push ( &head, 10 );
	push ( &head, 9 );
	push ( &head, 8 );
	cout << "Given Linked List\n";
	printtheList ( head );
	Node1 *root = sortedLstToBST (head);
	cout << "\nPreOrder Traversal of constructed BST \n ";
	preOrder (root);

	return 0;
}

Output:

Given Linked List
8 9 10 11 12 13 14 
 PreOrder Traversal of constructed BST 
 11 9 8 10 13 12 14

Time Complexity will be O(n).

Next TopicMerge Two Balanced Binary Search Trees

← prev next →

Latest Courses

We provides tutorials and interview questions of all technology like java tutorial, android, java frameworks

Contact info

G-13, 2nd Floor, Sec-3, Noida, UP, 201301, India

[email protected].

Python

AI, ML and Data Science

Java

B.Tech and MCA

Web Technology

Software Testing

Technical Interview

Java Interview

Web Interview

Database Interview

Company Interviews

C Tutorial

C Control Statements

C Functions

C Array

C Pointers

C Dynamic Memory

C Strings

C Math

C Structure Union

C File Handling

C Preprocessor

C Command Line

C Misc

C Programming Test

C Programs

MCQ

Math

C Interview

C Fundamental Test

C Control Test

C Function Test

C Array Test

C Pointers Test

C String Test

C Structure Test

C Preprocessor Test

In-place Conversion of Sorted DLL to Balanced BST

Method No. 1 (Simple)

Method No. 2 (Tricky)

Latest Courses

Contact info

Follow us

Tutorials

Interview Questions

Online Compiler