Hemos discutido el árbol binario enhebrado . La idea de los árboles binarios enhebrados es hacer que el recorrido en orden sea más rápido y hacerlo sin pila y sin recursividad. En un árbol binario de subprocesos simple, los punteros derechos NULL se utilizan para almacenar el sucesor en orden. Dondequiera que un puntero a la derecha sea NULL, se usa para almacenar el sucesor en orden.
El siguiente diagrama muestra un ejemplo de árbol binario de subproceso único. Las líneas punteadas representan hilos.
C
struct Node {
int key;
Node *left, *right;
// Used to indicate whether the right pointer is a normal right
// pointer or a pointer to inorder successor.
bool isThreaded;
};
Java
static class Node {
int key;
Node left, right;
// Used to indicate whether the right pointer is a normal right
// pointer or a pointer to inorder successor.
boolean isThreaded;
};
// This code is contributed by umadevi9616
Python3
class Node: def __init__(self): self.Key = 0; self.left = None; self.right = None; # Used to indicate whether the right pointer is a normal right # pointer or a pointer to inorder successor. self.isThreaded = False; # This code is contributed by Rajput-Ji
C#
class Node {
int key;
Node left, right;
// Used to indicate whether the right pointer is a normal right
// pointer or a pointer to inorder successor.
bool isThreaded;
};
// This code is contributed by Rajput-Ji
Javascript
class Node
{
constructor(item)
{
// Used to indicate whether the right pointer is a normal
// right pointer or a pointer to inorder successor.
let isThreaded;
this.data=item;
this.left = this.right = null;
}
}
C++
/* C++ program to convert a Binary Tree to Threaded Tree */
#include <bits/stdc++.h>
using namespace std;
/* Structure of a node in threaded binary tree */
struct Node {
int key;
Node *left, *right;
// Used to indicate whether the right pointer is a normal
// right pointer or a pointer to inorder successor.
bool isThreaded;
};
// Helper function to put the Nodes in inorder into queue
void populateQueue(Node* root, std::queue<Node*>* q)
{
if (root == NULL)
return;
if (root->left)
populateQueue(root->left, q);
q->push(root);
if (root->right)
populateQueue(root->right, q);
}
// Function to traverse queue, and make tree threaded
void createThreadedUtil(Node* root, std::queue<Node*>* q)
{
if (root == NULL)
return;
if (root->left)
createThreadedUtil(root->left, q);
q->pop();
if (root->right)
createThreadedUtil(root->right, q);
// If right pointer is NULL, link it to the
// inorder successor and set 'isThreaded' bit.
else {
root->right = q->front();
root->isThreaded = true;
}
}
// This function uses populateQueue() and
// createThreadedUtil() to convert a given binary tree
// to threaded tree.
void createThreaded(Node* root)
{
// Create a queue to store inorder traversal
std::queue<Node*> q;
// Store inorder traversal in queue
populateQueue(root, &q);
// Link NULL right pointers to inorder successor
createThreadedUtil(root, &q);
}
// A utility function to find leftmost node in a binary
// tree rooted with 'root'. This function is used in inOrder()
Node* leftMost(Node* root)
{
while (root != NULL && root->left != NULL)
root = root->left;
return root;
}
// Function to do inorder traversal of a threaded binary tree
void inOrder(Node* root)
{
if (root == NULL)
return;
// Find the leftmost node in Binary Tree
Node* cur = leftMost(root);
while (cur != NULL) {
cout << cur->key << " ";
// If this Node is a thread Node, then go to
// inorder successor
if (cur->isThreaded)
cur = cur->right;
else // Else go to the leftmost child in right subtree
cur = leftMost(cur->right);
}
}
// A utility function to create a new node
Node* newNode(int key)
{
Node* temp = new Node;
temp->left = temp->right = NULL;
temp->key = key;
return temp;
}
// Driver program to test above functions
int main()
{
/* 1
/ \
2 3
/ \ / \
4 5 6 7 */
Node* root = newNode(1);
root->left = newNode(2);
root->right = newNode(3);
root->left->left = newNode(4);
root->left->right = newNode(5);
root->right->left = newNode(6);
root->right->right = newNode(7);
createThreaded(root);
cout << "Inorder traversal of created threaded tree is\n";
inOrder(root);
return 0;
}
Java
// Java program to convert binary tree to threaded tree
import java.util.LinkedList;
import java.util.Queue;
/* Class containing left and right child of current
node and key value*/
class Node {
int data;
Node left, right;
// Used to indicate whether the right pointer is a normal
// right pointer or a pointer to inorder successor.
boolean isThreaded;
public Node(int item)
{
data = item;
left = right = null;
}
}
class BinaryTree {
Node root;
// Helper function to put the Nodes in inorder into queue
void populateQueue(Node node, Queue<Node> q)
{
if (node == null)
return;
if (node.left != null)
populateQueue(node.left, q);
q.add(node);
if (node.right != null)
populateQueue(node.right, q);
}
// Function to traverse queue, and make tree threaded
void createThreadedUtil(Node node, Queue<Node> q)
{
if (node == null)
return;
if (node.left != null)
createThreadedUtil(node.left, q);
q.remove();
if (node.right != null)
createThreadedUtil(node.right, q);
// If right pointer is NULL, link it to the
// inorder successor and set 'isThreaded' bit.
else {
node.right = q.peek();
node.isThreaded = true;
}
}
// This function uses populateQueue() and
// createThreadedUtil() to convert a given binary tree
// to threaded tree.
void createThreaded(Node node)
{
// Create a queue to store inorder traversal
Queue<Node> q = new LinkedList<Node>();
// Store inorder traversal in queue
populateQueue(node, q);
// Link NULL right pointers to inorder successor
createThreadedUtil(node, q);
}
// A utility function to find leftmost node in a binary
// tree rooted with 'root'. This function is used in inOrder()
Node leftMost(Node node)
{
while (node != null && node.left != null)
node = node.left;
return node;
}
// Function to do inorder traversal of a threaded binary tree
void inOrder(Node node)
{
if (node == null)
return;
// Find the leftmost node in Binary Tree
Node cur = leftMost(node);
while (cur != null) {
System.out.print(" " + cur.data + " ");
// If this Node is a thread Node, then go to
// inorder successor
if (cur.isThreaded == true)
cur = cur.right;
else // Else go to the leftmost child in right subtree
cur = leftMost(cur.right);
}
}
// Driver program to test for above functions
public static void main(String args[])
{
BinaryTree tree = new BinaryTree();
tree.root = new Node(1);
tree.root.left = new Node(2);
tree.root.right = new Node(3);
tree.root.left.left = new Node(4);
tree.root.left.right = new Node(5);
tree.root.right.left = new Node(6);
tree.root.right.right = new Node(7);
tree.createThreaded(tree.root);
System.out.println("Inorder traversal of created threaded tree");
tree.inOrder(tree.root);
}
}
// This code has been contributed by Mayank Jaiswal
Python3
# Python3 program to convert
# a Binary Tree to Threaded Tree
# Structure of a node in threaded binary tree
class Node:
def __init__(self, key):
self.key = key
self.left = None
self.right = None
# Used to indicate whether the right pointer
# is a normal right pointer or a pointer to
# inorder successor.
self.isThreaded = False
# Helper function to put the Nodes
# in inorder into queue
def populateQueue(root, q):
if root == None: return
if root.left:
populateQueue(root.left, q)
q.append(root)
if root.right:
populateQueue(root.right, q)
# Function to traverse queue,
# and make tree threaded
def createThreadedUtil(root, q):
if root == None: return
if root.left:
createThreadedUtil(root.left, q)
q.pop(0)
if root.right:
createThreadedUtil(root.right, q)
# If right pointer is None, link it to the
# inorder successor and set 'isThreaded' bit.
else:
if len(q) == 0: root.right = None
else: root.right = q[0]
root.isThreaded = True
# This function uses populateQueue() and
# createThreadedUtil() to convert a given
# binary tree to threaded tree.
def createThreaded(root):
# Create a queue to store inorder traversal
q = []
# Store inorder traversal in queue
populateQueue(root, q)
# Link None right pointers to inorder successor
createThreadedUtil(root, q)
# A utility function to find leftmost node
# in a binary tree rooted with 'root'.
# This function is used in inOrder()
def leftMost(root):
while root != None and root.left != None:
root = root.left
return root
# Function to do inorder traversal
# of a threaded binary tree
def inOrder(root):
if root == None: return
# Find the leftmost node in Binary Tree
cur = leftMost(root)
while cur != None:
print(cur.key, end = " ")
# If this Node is a thread Node,
# then go to inorder successor
if cur.isThreaded:
cur = cur.right
# Else go to the leftmost child
# in right subtree
else:
cur = leftMost(cur.right)
# Driver Code
if __name__ == "__main__":
root = Node(1)
root.left = Node(2)
root.right = Node(3)
root.left.left = Node(4)
root.left.right = Node(5)
root.right.left = Node(6)
root.right.right = Node(7)
createThreaded(root)
print("Inorder traversal of created",
"threaded tree is")
inOrder(root)
# This code is contributed by Rituraj Jain
C#
// C# program to convert binary tree to threaded tree
using System;
using System.Collections.Generic;
/* Class containing left and right child of current
node and key value*/
public class Node {
public int data;
public Node left, right;
// Used to indicate whether the right pointer is a normal
// right pointer or a pointer to inorder successor.
public bool isThreaded;
public Node(int item)
{
data = item;
left = right = null;
}
}
public class BinaryTree {
Node root;
// Helper function to put the Nodes in inorder into queue
void populateQueue(Node node, Queue<Node> q)
{
if (node == null)
return;
if (node.left != null)
populateQueue(node.left, q);
q.Enqueue(node);
if (node.right != null)
populateQueue(node.right, q);
}
// Function to traverse queue, and make tree threaded
void createThreadedUtil(Node node, Queue<Node> q)
{
if (node == null)
return;
if (node.left != null)
createThreadedUtil(node.left, q);
q.Dequeue();
if (node.right != null)
createThreadedUtil(node.right, q);
// If right pointer is NULL, link it to the
// inorder successor and set 'isThreaded' bit.
else {
if (q.Count != 0)
node.right = q.Peek();
node.isThreaded = true;
}
}
// This function uses populateQueue() and
// createThreadedUtil() to convert a given binary tree
// to threaded tree.
void createThreaded(Node node)
{
// Create a queue to store inorder traversal
Queue<Node> q = new Queue<Node>();
// Store inorder traversal in queue
populateQueue(node, q);
// Link NULL right pointers to inorder successor
createThreadedUtil(node, q);
}
// A utility function to find leftmost node in a binary
// tree rooted with 'root'. This function is used in inOrder()
Node leftMost(Node node)
{
while (node != null && node.left != null)
node = node.left;
return node;
}
// Function to do inorder traversal of a threaded binary tree
void inOrder(Node node)
{
if (node == null)
return;
// Find the leftmost node in Binary Tree
Node cur = leftMost(node);
while (cur != null) {
Console.Write(" " + cur.data + " ");
// If this Node is a thread Node, then go to
// inorder successor
if (cur.isThreaded == true)
cur = cur.right;
else // Else go to the leftmost child in right subtree
cur = leftMost(cur.right);
}
}
// Driver code
public static void Main(String[] args)
{
BinaryTree tree = new BinaryTree();
tree.root = new Node(1);
tree.root.left = new Node(2);
tree.root.right = new Node(3);
tree.root.left.left = new Node(4);
tree.root.left.right = new Node(5);
tree.root.right.left = new Node(6);
tree.root.right.right = new Node(7);
tree.createThreaded(tree.root);
Console.WriteLine("Inorder traversal of created threaded tree");
tree.inOrder(tree.root);
}
}
// This code has been contributed by 29AjayKumar
Javascript
<script>
// JavaScript program to convert
// binary tree to threaded tree
/* Class containing left and right child of current
node and key value*/
class Node
{
constructor(item)
{
// Used to indicate whether the right pointer is a normal
// right pointer or a pointer to inorder successor.
let isThreaded;
this.data=item;
this.left = this.right = null;
}
}
let root;
// Helper function to put the Nodes in inorder into queue
function populateQueue(node,q)
{
if (node == null)
return;
if (node.left != null)
populateQueue(node.left, q);
q.push(node);
if (node.right != null)
populateQueue(node.right, q);
}
// Function to traverse queue, and make tree threaded
function createThreadedUtil(node,q)
{
if (node == null)
return;
if (node.left != null)
createThreadedUtil(node.left, q);
q.shift();
if (node.right != null)
createThreadedUtil(node.right, q);
// If right pointer is NULL, link it to the
// inorder successor and set 'isThreaded' bit.
else {
node.right = q[0];
node.isThreaded = true;
}
}
// This function uses populateQueue() and
// createThreadedUtil() to convert a given binary tree
// to threaded tree.
function createThreaded(node)
{
// Create a queue to store inorder traversal
let q = [];
// Store inorder traversal in queue
populateQueue(node, q);
// Link NULL right pointers to inorder successor
createThreadedUtil(node, q);
}
// A utility function to find leftmost node in a binary
// tree rooted with 'root'. This function is used in inOrder()
function leftMost(node)
{
while (node != null && node.left != null)
node = node.left;
return node;
}
// Function to do inorder traversal of a threaded binary tree
function inOrder(node)
{
if (node == null)
return;
// Find the leftmost node in Binary Tree
let cur = leftMost(node);
while (cur != null) {
document.write(" " + cur.data + " ");
// If this Node is a thread Node, then go to
// inorder successor
if (cur.isThreaded == true)
cur = cur.right;
else // Else go to the leftmost child in right subtree
cur = leftMost(cur.right);
}
}
// Driver program to test for above functions
root = new Node(1);
root.left = new Node(2);
root.right = new Node(3);
root.left.left = new Node(4);
root.left.right = new Node(5);
root.right.left = new Node(6);
root.right.right = new Node(7);
createThreaded(root);
document.write(
"Inorder traversal of created threaded tree<br>"
);
inOrder(root);
// This code is contributed by rag2127
</script>
Publicación traducida automáticamente
Artículo escrito por GeeksforGeeks-1 y traducido por Barcelona Geeks. The original can be accessed here. Licence: CCBY-SA