ਬਾਈਨਰੀ ਟਰੀ


ਬਾਈਨਰੀ ਟ੍ਰੀ ਬੁਨਿਆਦੀ ਡੇਟਾ structureਾਂਚਾ ਹੈ, ਜਿੱਥੇ ਅਸੀਂ ਅਸਾਨੀ ਨਾਲ ਡੇਟਾ ਨੂੰ ਸਟੋਰ ਅਤੇ ਪ੍ਰਾਪਤ ਕਰ ਸਕਦੇ ਹਾਂ. ਇਹ ਨੋਡਾਂ ਦਾ ਬਣਿਆ ਹੁੰਦਾ ਹੈ, ਜਿੱਥੇ ਹਰੇਕ ਨੋਡ ਵਿੱਚ ਖੱਬਾ ਪੁਆਇੰਟਰ, ਸੱਜਾ ਪੁਆਇੰਟਰ ਅਤੇ ਡੇਟਾ ਹੁੰਦਾ ਹੈ.

ਰੂਟ ਪੁਆਇੰਟਰ ਰੁੱਖ ਦੇ ਸਭ ਤੋਂ ਉਪਰਲੇ ਨੋਡ ਵੱਲ ਇਸ਼ਾਰਾ ਕਰਦਾ ਹੈ ਅਤੇ ਖੱਬੇ ਅਤੇ ਸੱਜੇ ਪੁਆਇੰਟਰ ਦੋਵਾਂ ਪਾਸਿਆਂ ਦੇ ਛੋਟੇ ਉਪ-ਸਮੂਹਾਂ ਵੱਲ ਇਸ਼ਾਰਾ ਕਰਦੇ ਹਨ.

ਬਾਈਨਰੀ ਟਰੀ ਦੀ ਰਚਨਾ

ਐਲਗੋਰਿਥਮ

1. ਪਹਿਲਾਂ ਨਵਾਂ ਨੋਡ ਬਣਾਓ
ਇੱਕ ਨੋਡ ਨੂੰ ਪਰਿਭਾਸ਼ਤ ਕਰੋ ਜਿਸ ਵਿੱਚ ਕੁਝ ਡੇਟਾ ਹੈ, ਇਸਦੇ ਖੱਬੇ ਅਤੇ ਸੱਜੇ ਬੱਚੇ ਨੋਡਾਂ ਦਾ ਹਵਾਲਾ ਹੈ.
2. ਪਹਿਲਾ ਮੁੱਲ ਬਣਾਓ ਜੋ ਤੁਸੀਂ ਰੂਟ ਦੇ ਤੌਰ ਤੇ ਪਾਉਂਦੇ ਹੋ.
3. ਜੇ ਤੁਸੀਂ ਅਗਲੇ ਮੁੱਲ ਨੂੰ ਰੂਟ ਦੇ ਖੱਬੇ ਪਾਸੇ ਪਾਉਣਾ ਚਾਹੁੰਦੇ ਹੋ, ਤਾਂ ਰੂਟ-> ਖੱਬੇ ਤੌਰ 'ਤੇ ਪਾਓ, ਜਾਂ ਜੇ ਤੁਸੀਂ ਰੂਟ-> ਸੱਜੇ ਦੇ ਤੌਰ' ਤੇ ਸੱਜਾ ਪਾਉਣਾ ਚਾਹੁੰਦੇ ਹੋ.
4. ਦਰਖ਼ਤ ਵਿਚ ਸਹੀ ਪੋਜ਼ੀਸ਼ਨ ਵਿਚ ਨੋਡ ਪਾਉਣ ਲਈ ਕਦਮ 3 ਨੂੰ ਦੁਹਰਾਓ. ਉਦਾਹਰਣ ਦੇ ਲਈ, ਰੂਟ ਦੇ ਖੱਬੇ ਖੱਬੇ ਪਾਸੇ ਨੋਡ ਪਾਉਣ ਲਈ, ਰੂਟ-> ਖੱਬੇ-> ਖੱਬੇ ਪਾਓ.

ਉਦਾਹਰਨ

ਸੀ ++ ਪ੍ਰੋਗਰਾਮ

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

struct node 
{
	char data;
	struct node *left;
	struct node *right;
};
struct node* newNode(char data)
{
// Allocate memory for new node 
struct node* node = (struct node*)malloc(sizeof(struct node));

// Assign data to this node
node->data = data;

// Initialize left and right children as NULL
node->left = NULL;
node->right = NULL;
return(node);
}
void prinTree(struct node* node)	//Using PreOrder Traversal for Printing a Tree 
{
	if(node == NULL)
		return;
	printf("%c\n",node->data );
	prinTree(node->left);
	prinTree(node->right);

}



int main()
{				//Creating a Tree with nodes A, B, C, D, E, F
struct node *root = newNode('A'); // Creating a root with left and right pointers Null


root->left	 = newNode('B');    // Creating a left node to A 
root->right	 = newNode('C');	// Creating a right node to A


root->left->left = newNode('D');    //Creating a left left node to A
root->left->right = newNode('E');	//Creating a left right node to A
root->right->left = newNode('F');	//Creating a right left node to A
prinTree(root);  //It will print the Tree
return 0;
}