线程二叉树及其实现

比眉伴天荒 2022-12-07 12:55 118阅读 0赞

In this tutorial we are going to see a data structure known as threaded binary tree. Before starting with that we should know what does a binary [tree][] means and after that we can start with the importance of the word threaded in it.

在本教程中，我们将看到一个称为线程二叉树的数据结构。 与我们应该知道什么对二进制开始前[树][tree]手段之后，我们可以在它的螺纹字的重要性开始。

Binary tree is a data structure in computer science where each node has two children represented as left and right children and each node is storing some data.

二叉树是计算机科学中的数据结构，其中每个节点有两个子代，分别表示为左子代和右子代，每个节点都存储一些数据。

struct node
    {
    	int data;
    	struct node* left;
    	struct node* right;
    }

The above is a basic structure of a binary tree. The left and right pointer points to the left and right node of the current node.

以上是二叉树的基本结构。 左右指针指向当前节点的左右节点。

### 线程一词是什么意思？ **(**What does the word threaded mean?**)** ###

![threaded binary tree][]

When a particular node is at the last depth in a binary tree (also known as leaf node) it does not have a left or right child and generally they are set to NULL. But with threaded binary tree the left and right pointers are set to point the inorder predecessor and inorder successor respectively.

当特定节点位于二叉树的最后深度时(也称为叶节点)，它没有左或右子节点，通常将它们设置为NULL。 但是在使用线程二叉树的情况下，左右指针分别设置为指向有序前任和后继。

**What do we mean by inorder predecessor or inorder successor?**

**有序前任或后继有什么意思？**

Inorder predecessor is the node coming before the current node in the inorder traversal of a binary tree. Similarly, Inorder successor is the node coming next to the current node in the inorder traversal of a binary tree.

有序前驱是二叉树有序遍历中当前节点之前的节点。 类似地，有序后继是在二叉树的有序遍历中紧挨当前节点的节点。

So the order of nodes in inorder traversal will be as :

因此，节点在有序遍历中的顺序将为：

…   inorder\_predecessor -> current\_ele -> inorder\_successor ….

…inorder\_predecessor-> current\_ele-> inorder\_successor…。

Now one more question remains is that **how will we know that the left and right pointers are pointing to the child or the predecessor and successor?**

现在还有一个问题是， **我们将如何知道左右指针指向孩子或前任和后继？**

For solving this a new boolean variable is stored in the structure of a linked list node which is true if the tree is threaded for the current node otherwise it’s false. The new structure will look as below :

为了解决这个问题，将一个新的布尔变量存储在链接列表节点的结构中，如果为当前节点线程化该树，则为true，否则为false。 新结构如下所示：

struct node
    {
    	int data;
    	struct node* left;
    	struct node* right;
    	bool rightThreaded;
    }

### 为什么我们需要线程二叉树？ **(**Why do we need threaded binary trees?**)** ###

The structure of the node of binary tree is already decided and is the same for every node but the space is wasted for the leaf node because they do not store any address.

二叉树节点的结构已经确定，每个节点都相同，但是叶节点浪费了空间，因为它们不存储任何地址。

Generally when we do inorder traversal of a binary tree we either need stack or use recursion which again uses stack at some level i.e. extra memory is required for the inorder traversal. By using these threads we can actually simplify the inorder traversal so that it does not use any space for the inorder traversal. So for memory optimizations threaded binary trees are used.

通常，当我们执行二叉树的有序遍历时，我们要么需要堆栈，要么使用递归，而递归又在某种程度上使用了堆栈，即有序遍历需要额外的内存。 通过使用这些线程，我们实际上可以简化有序遍历，以便它不会为有序遍历使用任何空间。 因此，为了进行内存优化，使用了线程二叉树。

### 线程二叉树的类型 **(**Types of Threaded Binary Tree**)** ###

Based on the pointers threaded in a node there are two types of threaded binary trees

根据线程在节点中的指针，有两种类型的线程二叉树

**Single Threaded Trees****:** For every node only one of the pointers is threaded i.e. either the left node is made to point the inorder predecessor OR the right node is made to point to the inorder successor of the tree.

**单线程树** **：**对于每个节点，仅对一个指针进行线程化，即，使左节点指向有序的前任，或者使右节点指向树的有序的后任。

**Double Threaded Trees****:** For every node both of the pointers are threaded i.e. either the left node is made to point the inorder predecessor AND the right node is made to point to the inorder successor of the tree.

**双线程树** **：**对于每个节点，两个指针都经过线程化，即，使左节点指向有序前任树，而使右节点指向树的有序后继树。

### 线程二叉搜索树实现 **(**Threaded Binary Search Tree Implementation**)** ###

We will now see how we can insert and delete elements in a threaded [binary search tree][]. We will use a Double threaded tree for demonstration as Double threaded tree can easily be converted into Single Threaded tree.

现在，我们将看到如何在线程化的[二进制搜索树中][binary search tree]插入和删除元素。 我们将使用双线程树进行演示，因为双线程树可以轻松转换为单线程树。

**Insertion:**

**插入：**

Basic insertion will follow the same rules as binary search tree, only additional thing we need to implement is updating the pointers and the value of left and right pointers and the boolean values rightThreaded and leftThreaded.

基本插入将遵循与二进制搜索树相同的规则，我们仅需执行的另一件事就是更新指针和左右指针的值以及布尔值rightThreaded和leftThreaded。

First of all we need to find the correct place of the new node in the tree using the rules same as we use for binary search tree and thereafter there can be three cases when we are inserting an element in a tree :

首先，我们需要使用与二叉搜索树相同的规则在树中找到新节点的正确位置，此后，在树中插入元素时可能存在三种情况：

*  First element 
    
    第一要素
 *  Left Child
    
    左子
 *  Right Child 
    
    合适的孩子

**Case 1: First element**

**情况1：第一个元素**

While adding the first element there is no meaning of updating the predecessor and successor as they do not exist, so we will just create a new update with left and right pointers as null and update the root of the tree. temp is the new node we created.

在添加第一个元素时，没有更新前任和后任的意思，因为它们不存在，因此我们将使用左指针和右指针创建一个新的更新为null并更新树的根。 temp是我们创建的新节点。

root = temp;
    temp -> left = NULL;
    temp -> right = NULL;

**Case 2: Left Child**

**情况2：左子**

If the tree is not empty then if the value to be inserted (say val) is less than the node value then we will go left otherwise we will go right until we reach a leaf of the tree. The last node we encounter in the process will become the parent of the new node. If val is lesser than the value of parent node it will become its left child.

如果树不为空，则如果要插入的值(例如val)小于节点值，那么我们将向左走，否则我们将向右走直到到达树的叶子。 我们在过程中遇到的最后一个节点将成为新节点的父节点。 如果val小于父节点的值，它将成为其左子节点。

While writing the inorder of the tree after inserting the node the newly inserted node will come in between the predecessor of parent and parent itself so the predecessor of the new node will become the predecessor of parent and successor of the new node will parent.

在插入节点之后编写树的顺序时，新插入的节点将位于父节点的父节点和父节点本身之间，因此新节点的父节点将成为父节点的前任节点，而新节点的后继节点将成为父节点。

Inorder before Insertion :  ..... PredecessorOfPar -> Par->....
    Inorder after Insertion : ......... PredecessorOfPar -> newNode -> Par

If temp is the new node created and parent is the parent of the new node the code will look as below :

如果temp是创建的新节点，并且parent是新节点的父节点，则代码将如下所示：

temp -> left = parent ->left;
    temp -> right = parent;
    parent -> leftThreaded = false;
    parent -> left = temp;

**Case 3: Right Child**

**案例3：正确的孩子**

We will follow the same procedure to find the position of the node using the same procedure and if the parent value if less than a new node value, the new node will now become the right child of the parent.

我们将按照相同的过程使用相同的过程来查找节点的位置，如果父节点的值小于新节点的值，那么新节点现在将成为父节点的右子节点。

Similar to the Case 2 here the successor of the new node will the successor of the parent and predecessor will become the parent itself.

类似于案例2，新节点的后继者将成为父节点的继任者，而前任节点将成为父节点本身。

temp -> left = parent;
    temp -> right = parent -> right;
    parent -> rightThreaded = false;
    parent -> right = temp;

The final code for insertion will look as below:

最终的插入代码如下所示：

struct Node insert(struct Node root, int val)
    {
    	// Search for the correct position
    	struct Node *ptr = root;
    	struct Node *parent = NULL; // parentent of key to be inserted
    	while (ptr != NULL)
    	{
       	 
        	// Moving on left subtree.
        	if (val < ptr->data)
        	{
            	if (ptr -> leftThreaded == false)
                	ptr = ptr -> left;
            	else
                	break;
        	}
     
        	// Moving on right subtree.
        	else
        	{
            	if (ptr->rightThreaded == false)
                	ptr = ptr -> right;
            	else
                	break;
        	}
    	}
     
    	// Create a new node
    	struct Node *temp = (struct Node* )malloc(sizeof(struct Node));
    	temp -> data = val;
    	temp -> leftThreaded = true;
    	temp -> rightThreaded = true;
     
    	if (parent == NULL)
    	{
        	root = temp;
        	temp -> left = NULL;
        	temp -> right = NULL;
    	}
    	else if (val < (parent -> data))
    	{
        	temp -> left = parent -> left;
        	temp -> right = parent;
        	parent -> leftThreaded = false;
        	parent -> left = temp;
    	}
    	else
    	{
        	temp -> left = parent;
        	temp -> right = parent -> right;
        	parent -> rightThreaded = false;
        	parent -> right = temp;
    	}
     
    	return root;
    }

Comment down below if you have any queries related to threaded binary tree.

如果您有关于线程二叉树的任何查询，请在下面注释掉。

> 翻译自: [https://www.thecrazyprogrammer.com/2020/01/threaded-binary-tree.html][https_www.thecrazyprogrammer.com_2020_01_threaded-binary-tree.html]

[tree]: https://www.thecrazyprogrammer.com/2019/09/types-of-trees-in-data-structure.html
[threaded binary tree]: /images/20221123/388e91f6e4634bd4aa4fafd3701af981.png
[binary search tree]: https://www.thecrazyprogrammer.com/2015/03/c-program-for-binary-search-tree-insertion.html
[https_www.thecrazyprogrammer.com_2020_01_threaded-binary-tree.html]: https://www.thecrazyprogrammer.com/2020/01/threaded-binary-tree.html