Flatten Binary Tree to Sorted Linked List

A flattened binary tree is a changed version of the normal binary tree, as all the nodes present are rearranged to create a linear structure. All the nodes in the tree are organized so that when traversing the tree from left to right, we observe the items in the same order as we would in a normal in-order traversal.

Flattening a binary tree can prove to be very useful when it comes to performing certain tasks, such as serializing or deserializing a tree or when we have to perform linear traversal or any other algorithm on the tree.

Some key advantages are: -

They also help in improving the memory storage and cache locality of the system.
By flattening a binary tree, we can easily replace the need for the left and right pointers in the tree.
It also improves the memory locality of the tree, such as the nodes in the linked list will be stored in the nearby locations.
Some algorithms and operations are much easier to implement in linear data structure rather than performing them on binary trees.

Implementation

// C++ program implementation 
#include <bits/stdc++.h>
using namespace std;

// creating the node of the binary tree
struct __nod {
	int record;
	__nod* Lft;
	__nod* Rt;
	__nod(int record)
	{
		this->record = record;
		Lft = NULL;
		Rt = NULL;
	}
};

// A flattened binary tree can be printed by creating a function
void print(__nod* parent)
{
	__nod* curr = parent;
	while (curr != NULL)
		cout << curr->record << " ", curr = curr->Rt;
}

// In-order traversal can be accomplished continuously by creating a function.
void inorder(vector<int>& traversal, __nod* parent)
{
	if (parent == NULL)
		return;

	inorder(traversal, parent->Lft);
	// Now, we will store or captivate the values in the node
	traversal.push_back(parent->record);

	inorder(traversal, parent->Rt);
}

void form(int pos, vector<int> traversal, __nod*& prev)
{
	//Writing the basic case
	if (pos == traversal.size())
		return;

	prev->Rt = new __nod(traversal[pos]);
	prev->Lft = NULL;

	prev = prev->Rt;

	// Next, we will carry out the next element of the vector 
	form(pos + 1, traversal, prev);
}
// The next step is to create a function that will help us flatten the binary tree using the level order traversal.
__nod* flatten(__nod* parent)
{

	// creating a duplicate node
	__nod* dummy = new __nod(-1);

	// creating a pointer to the previous node
	__nod* prev = dummy;
	vector<int> traversal;
	inorder(traversal, parent);

	// Now, we will create the linked list from the vector that we have gained
	form(0, traversal, prev);

	prev->Lft = NULL;
	prev->Rt = NULL;
	__nod* ret = dummy->Rt;

	//Now we will delete the duplicate node
	delete dummy;
	return ret;
}

int main()
{

	__nod* root = new __nod(5);
	root->Lft = new __nod(3);
	root->Rt = new __nod(7);
	root->Lft->Lft = new __nod(2);
	root->Lft->Rt = new __nod(4);
	root->Rt->Lft = new __nod(6);
	root->Rt->Rt = new __nod(8);

	// Calling required function
	print(flatten(root));

	return 0;
}

Output

Flatten Binary Tree to Sorted Linked List

A step-by-step explanation of the code

The code will begin by declaring the necessary header files for the conduction of the various operations of the program.
In the next step of the code, we begin by defining a structure called 'Node,' which represents a node in the binary tree with the following members; data and a pointer to the left and right node.
Next, we declare the print function in the program, which will take the node as a parameter and print the flattened tree. It traverses the tree using the right pointer and prints all the values present at each node.
Now, we have to declare the in-order function that will refer to a series of vectors and a node as a parameter. This function will further perform an in-order traversal of the binary tree.
Next, we declare a form function that usually takes 'pos' and 'node' as a reference. This is usually a helper function that builds a flattened binary tree.
We then move by declaring the 'flatten' function, and the primary role of this function is first to create a dummy node and then perform an in-order traversal of the tree and store the node's value.
In the primary function of the program, we construct a binary tree.
The flatten function is called with the tree's root as an argument, and the result is passed onto the print function to display the result.

Example 2)

// Java program implementation
import java.util.*;

// creating the node of the binary tree
class __nod {
	int record;
	__nod Lft;
	__nod Rt;

	public __nod(int record)
	{
		this.record = record;
		Lft = NULL;
		Rt = NULL;
	}
}

public class Main {
// A flattened binary tree can be printed by creating a function
	static void print(__nod parent)
	{
		__nod curr = parent;
		while (curr != NULL) {
			System.out.print(curr.record + " ");
			curr = curr.Rt;
		}
	}
// In-order traversal can be accomplished continuously by creating a function.
	static void inorder(List<Integer> traversal,
						__nod parent)
	{
	// Now, we will store or captivate the values in the node
		if (parent == NULL)
			return;

		inorder(traversal, parent.Lft);
		traversal.add(parent.record);

		inorder(traversal, parent.Rt);
	}

	static void form(int pos, List<Integer> traversal,
					__nod[] prev)
	{
		if (pos == traversal.size())
			return;

		prev[0].Rt = new __nod(traversal.get(pos));
		prev[0].Lft = NULL;

		prev[0] = prev[0].Rt;

		form(pos + 1, traversal, prev);
	}

// The next step is to create a function that will help us flatten the binary tree using the level order traversal.
	static __nod flatten(__nod parent)
	{
	// creating a duplicate node
		__nod dummy = new __nod(-1);

	// creating a pointer to the previous node
		__nod[] prev = { dummy };

	// Now, we will create a vector that will help us store the in-order traversal of the BST. 
		List<Integer> traversal = new ArrayList<>();
		inorder(traversal, parent);

	// Now, we will create the linked list from the vector that we have gained
		form(0, traversal, prev);

		prev[0].Lft = NULL;
		prev[0].Rt = NULL;
		__nod ret = dummy.Rt;

	//Now we will delete the duplicate node
		dummy = NULL;
		return ret;
	}

	public static void main(String[] args)
	{
		__nod root = new __nod(5);
		root.Lft = new __nod(3);
		root.Rt = new __nod(7);
		root.Lft.Lft = new __nod(2);
		root.Lft.Rt = new __nod(4);
		root.Rt.Lft = new __nod(6);
		root.Rt.Rt = new __nod(8);

		// Calling required function
		print(flatten(root));
	}
}

Output

A step-by-step explanation of the code

The code will begin by importing the main classes from 'java.util', including 'list', 'ArrayList', and 'Node'.
In the next step of the code, we begin by defining a structure called 'Node,' which represents a node in the binary tree with the following members; data and a pointer to the left and right node.
Next, we declare the print function in the program, which will take the node as a parameter and print the flattened tree. It traverses the tree using the right pointer and prints all the values present at each nod.
Now, we have to declare the in-order function that will refer to a series of vectors and a node as a parameter. This function will further perform an in-order traversal of the binary tree.
Next, we declare a form function that usually takes 'pos' and 'node' as a reference. This is usually a helper function that builds a flattened binary tree.
We then move by declaring the 'flatten' function, and the primary role of this function is first to create a dummy node and then perform an in-order traversal of the tree and store the node's value.
In the primary function of the program, we construct a binary tree.
The flatten function is called with the tree's root as an argument, and the result is passed onto the print function to display the result.

Example 3)

// Python program implementation 
// creating the node of the binary tree

class __nod:
	def __init__(self, record):
		self.record = record
		self.Lft = None
		self.Rt = None
// A flattened binary tree can be printed by creating a function
def print_flattened_tree(parent):
	curr = parent
	While curr is None:
		print(curr.record, end=" ")
		curr = curr. Rt

// In-order traversal can be accomplished continuously by creating a function.
def inorder_traversal(traversal, parent):
	// Now, we will store or captivate the values in the node
	If a parent is None:
		return
	
	inorder_traversal(traversal, parent.Lft)
	// Now, we will store or captivate the values in the node
	traversal. append(parent. record)
	inorder_traversal(traversal, parent.Rt)

def form(pos, traversal, prev):
	if pos == len(traversal):
		return
	
	prev[0].Rt = __nod(traversal[pos])
	prev[0].Lft = None
	
	prev[0] = prev[0].Rt
	
	# Calling for the next element of the list
	form(pos + 1, traversal, prev)

	// Next, we will carry out the next element of the vector 
def flatten(parent):
	// creating a duplicate node
	dummy = __nod(-1)
	// creating a pointer to the previous node
	prev = [dummy]
	traversal = []
	inorder_traversal(traversal, parent)
	// Now, we will create the linked list from the vector that we have gained
	form(0, traversal, prev)
	
	prev[0].Lft = None
	prev[0].Rt = None
	ret = dummy.Rt
	//Now we will delete the duplicate node	
	dummy = None
	return ret

if __name__ == "__main__":
	root = __nod(5)
	root.Lft = __nod(3)
	root.Rt = __nod(7)
	root.Lft.Lft = __nod(2)
	root.Lft.Rt = __nod(4)
	root.Rt.Lft = __nod(6)
	root.Rt.Rt = __nod(8)

	# Calling required function
	print_flattened_tree(flatten(root))

Output

A step-by-step explanation of the code

The code will start by defining a structure for a binary tree called 'Node'. It has the following three members: a data value and a pointer to the left and right child.
In the next step of the code, we begin by defining a structure called 'Node,' which represents a node in the binary tree with the following members; data and a pointer to the left and right node.
Now, we have to declare the in-order function that will refer to a series of vectors and a node as a parameter. This function will further perform an in-order traversal of the binary tree.
Next, we declare a form function that usually takes 'pos' and 'node' as a reference. This is usually a helper function that builds a flattened binary tree.
We then move by declaring the 'flatten' function, and the primary role of this function is first to create a dummy node and then perform an in-order traversal of the tree and store the node's value.
In the primary function of the program, we construct a binary tree.
The flatten function is called with the tree's root as an argument, and the result is passed onto the print function to display the result.

Next TopicFloor and Ceiling in Binary Search Tree

← prev next →