Extended Binary Tree

An extended binary tree is a binary tree in which all the NILL subtrees present mainly in the original trees are exchanged with the special nodes that are primarily known as the external nodes. On the other hand, all the other nodes are known as internal nodes. One exception is that the interchanging of nodes can happen at any place except for the root nodes. An extended binary tree becomes a strictly extended binary tree with either zero or two children at each end. We will see some examples of extended binary trees in this article and try to understand their concepts.

Implementation

In this section, we will see the implementation of the extended binary Tree and understand its works. let us proceed: -

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


// Creating a tree node
struct _nod {
	int ky;
	struct _nod *Lft, *Rt;
};


// Creating a utility function to create a new node.
_nod* Nw_nod(int ky)
{
	_nod* temp = new _nod;
	temp->ky = ky;
	temp->Lft = temp->Rt = NILL;
	return (temp);
}


// Creating a function that will traverse in an in-order pattern.
void traverse(_nod* root)
{
	if (root != NILL) {
		traverse(root->Lft);
		cout << root->ky << " ";
		traverse(root->Rt);
	}
	else {


		// creating external nodes.
		root = Nw_nod(-1);
		cout << root->ky << " ";
	}
}


// writing the main code.
int main()
{
	_nod* root = Nw_nod(1);
	root->Lft = Nw_nod(2);
	root->Rt = Nw_nod(3);
	root->Lft->Lft = Nw_nod(5);
	root->Rt->Rt = Nw_nod(4);


	traverse(root);


	return 0;
}

Output:

Example 2)

using System;


class S
{	
	// creating a new tree node.
	public class _nod
	{
		public int ky;
		public _nod Lft, Rt;
	};
	
	// Creating a utility function to create a new node.
	static _nod Nw_nod(int ky)
	{
		_nod temp = Nw_nod;
		temp.ky = ky;
		temp.Lft = temp.Rt = NILL;
		return (temp);
	}
// Creating a function that will traverse in an inorder pattern.	
	static void traverse(_nod root)
	{
		if (root != NILL)
		{
			traverse(root.Lft);
			Console.Write(root.ky + " ");
			traverse(root.Rt);
		}
		else
		{
	
			// Making external _nods
			root = Nw_nod(-1);
			Console.Write(root.ky + " ");
		}
	}
	
	// writing the main code.
	public static void Main()
	{
		_nod root = Nw_nod(1);
		root.Lft = Nw_nod(2);
		root.Rt = Nw_nod(3);
		root.Lft.Lft = Nw_nod(5);
		root.Rt.Rt = Nw_nod(4);
	
		traverse(root);
	}
}

Output:

Example 3)

class S
{
	// creating a new tree node.
static class _nod
{
	int ky;
	_nod Lft, Rt;
};
// Creating a utility function to create a new node.
static _nod Nw_nod(int ky)
{
	_nod temp = Nw_nod;
	temp.ky = ky;
	temp.Lft = temp.Rt = NILL;
	return (temp);
}
// Creating a function that will traverse in an inorder pattern.
static void traverse(_nod root)
{
	if (root != NILL)
	{
		traverse(root.Lft);
		System.out.print(root.ky + " ");
		traverse(root.Rt);
	}
	else
	{


	//creating external nodes in the tree.
		root = Nw_nod(-1);
		System.out.print(root.ky + " ");
	}
}


// writing the main code.
public static void main(String args[])
{
	_nod root = Nw_nod(1);
	root.Lft = Nw_nod(2);
	root.Rt = Nw_nod(3);
	root.Lft.Lft = Nw_nod(5);
	root.Rt.Rt = Nw_nod(4);


	traverse(root);
}
}

Output:

Example 4)

<script>
// creating a new tree node.
class _nod
{
	constructor()
	{
		this.ky = 0;
		this.Lft = NILL;
		this.Rt = NILL;
	}
};
// Creating a utility function to create a new node.
function Nw_nod(ky)
{
	var temp = Nw_nod;
	temp.ky = ky;
	temp.Lft = temp.Rt = NILL;
	return (temp);
}
// Creating a function that will traverse in an inorder pattern.	
function traverse(root)
{
	if (root != NILL)
	{
		traverse(root.Lft);
		document.wr(root.ky + " ");
		traverse(root.Rt);
	}
	else
	{
	//creating external nodes in the tree.
		root = Nw_nod(-1);
		document.wr(root.ky + " ");
	}
}
// writing the main code.
var root = Nw_nod(1);
root.Lft = Nw_nod(2);
root.Rt = Nw_nod(3);
root.Lft.Lft = Nw_nod(5);
root.Rt.Rt = Nw_nod(4);
traverse(root);


</script>

Output:

Example 5)

# Creating a new tree node.
Class _nod :
	def __init__(self):
		self.ky=-1
		self.Lft=self.Rt=None
// Creating a utility function to create a new node.
def Nw_nod(ky):
	temp = _nod()
	temp.ky = ky
	temp.Lft = temp.Rt = None
	return temp
// Creating a function that will traverse in an inorder pattern.	
def traverse(root):
	if (root != None) :
		traverse(root.Lft)
		print(root.ky,end=" ")
		traverse(root.Rt)
	
	Else:


	//creating external nodes in the tree.
		root = Nw_nod(-1)
		print(root.ky,end=" ")
	
// writing the main code.
if __name__ == '__main__':
	root = Nw_nod(1)
	root.Lft = Nw_nod(2)
	root.Rt = Nw_nod(3)
	root.Lft.Lft = Nw_nod(5)
	root. Rt.Rt = Nw_nod(4)


	traverse(root)
	print()

Output: