C++ 将二叉树转换为双线程二叉树？

我在搜索中找不到任何东西来满足我的问题，如果它存在，我很抱歉

我正在做一个关于线程二叉树的大学作业。即，各种类型的遍历-双TBT上的顺序、后顺序和前顺序

这是TBTNode结构：

struct TBTNode {
  TBTNode *left, *right, *parent;       
  char data;
  bool left_normal, right_normal;
  TBTNode(char d) {
    data = d;
    left = NULL;
    right = NULL;
    parent = NULL;
    left_normal = true;
    right_normal = true;
  }
};

如您所见，二叉树节点和TBT节点之间没有太大区别，除了节点的属性，即。{left，right}_normal在需要时设置为true

要创建树，我有以下内容：

class TBT {
  TBTNode *root;
public:
  TBT() {
    root = new TBTNode(0);
    root->right = root;
    root->right_normal = true;          
    cout << "Root:" ;           
    root->left = create();
    if(root->left)
      root->left_normal = true;
  }
  TBTNode* create();  
};

TBTNode* TBT::create() {
  char data;
  TBTNode *node = NULL;
  cout << endl << "Enter data (0 to quit): ";
  cin >> data;
  if(data == '0')
    return NULL;
  node = new TBTNode(data);
  cout << endl << "Enter left child of " << data;
  node->left = create();
  if(node->left)
    node->left->parent = node;
  else {
    node->left = root;
    node->right = node->parent;
    node->left_normal = node->right_normal = false;
  }
  cout << endl << "Enter right child of " << data;
  node->right = create();
  if(node->right)
    node->right->parent = node;
  else {
    node->left = node;
    node->right = node->parent->parent;
    node->left_normal = node->right_normal = false;
  }
  return node;
}

类TBT{
TBTNode*根；
公众：
技术性贸易壁垒（）{
根=新TBTNode（0）；
根->右=根；
root->right\u normal=true；
cout left=create（）；
如果（根->左）
root->left_normal=true；
}
TBTNode*create（）；
};
TBTNode*TBT:：create（）{
字符数据；
TBTNode*node=NULL；
cout数据；
如果（数据='0'）
返回NULL；
节点=新TBTNode（数据）；
cout left->parent=节点；
否则{
节点->左=根；
节点->右=节点->父节点；
节点->左\u法线=节点->右\u法线=假；
}
cout right->parent=节点；
否则{
节点->左=节点；
节点->右=节点->父节点->父节点；
节点->左\u法线=节点->右\u法线=假；
}
返回节点；
}

---

在使用上述代码递归创建树之后，我想将其转换为双线程二叉树。我知道左边的子对象链接到子对象的顺序前置对象，右边的子对象链接到顺序后继对象，但我无法创建算法。有人能帮我吗？

我自己找到了解决办法。首先按顺序遍历树，然后继续向数组中添加节点。然后处理数组以链接线程，因为对于数组中的给定元素x，x之前的一个将是有序的前置元素，x之后的一个将是有序的后续元素。对于第一个和最后一个元素，将进行特殊检查以将它们链接到头节点（而不是根节点）

不需要父链接，它已被删除

代码如下：

class TBT {
  TBTNode *root;
  void createInorderArray(TBTNode *T);
  TBTNode **array;
  unsigned array_size;
public:
  TBT();
  TBTNode* create();
  void inorder();
  void preorder();
};

TBT::TBT() {
  root = new TBTNode(0);
  root->right = root;
  root->right_normal = true;
  cout << "Root:" ;
  root->left = create();    
  if(!root->left) {
    root->left_normal = false;
    root->left = root;
  }
  array = NULL;
  array_size = 0;
  createInorderArray(root->left);
  for(unsigned i = 0; i < array_size; i++) {
    if(!array[i]->left) {
      array[i]->left = i == 0 ? root : array[i-1];
      array[i]->left_normal = false;
    }
    if(!array[i]->right) {
      array[i]->right_normal = false;
      array[i]->right = i == (array_size - 1) ? root : array[i+1];
    }
  }
  free(array);
  array_size = 0;
}

void TBT::createInorderArray(TBTNode *T) {
  if(!T)
    return;
  createInorderArray(T->left);
  array = (TBTNode**) realloc(array, sizeof(TBTNode**) * ++array_size);
  array[array_size-1] = T;
  createInorderArray(T->right);  
}

类TBT{
TBTNode*根；
void createInorderArray（TBTNode*T）；
TBT节点**阵列；
无符号数组的大小；
公众：
TBT（）；
TBTNode*create（）；
无效顺序（）；
无效前序（）；
};
TBT：：TBT（）{
根=新TBTNode（0）；
根->右=根；
root->right\u normal=true；
cout left=create（）；
如果（！root->left）{
root->left_normal=false；
根->左=根；
}
数组=空；
数组大小=0；
createInorderArray（根->左）；
for（无符号i=0；i左）{
数组[i]->left=i==0？根：数组[i-1]；
数组[i]->左_法线=假；
}
如果（！数组[i]->右侧）{
数组[i]->右\u法线=假；
数组[i]->right=i==（数组大小-1）？根：数组[i+1]；
}
}
自由（数组）；
数组大小=0；
}
无效TBT:：createInorderArray（TBTNode*T）{
如果（！T）
返回；
createInorderArray（T->左）；
数组=（TBTNode**）realloc（数组，大小of（TBTNode**）*++数组大小）；
数组[array_size-1]=T；
createInorderArray（T->右侧）；
}
如果一些C++怪人在这里绊倒，不要建议我STL。分配规则禁止此程序中的STL。