更新树

Code/Code/head/link_tree.h

@@ -9,32 +9,32 @@ typedef struct BinaryTreeNode {
 } BinaryTreeNode, *BinaryTree;
 
 // 前序遍历
-bool PreOrder(BinaryTree &tree, bool( *function)(BinaryTree&)){
+bool PreOrderBinaryTree(BinaryTree &tree, bool( *function)(BinaryTree&)){
     if(tree!= nullptr){
         if(!function(tree))
             return false;
-        PreOrder(tree->left_child, function);
-        PreOrder(tree->right_child, function);
+        PreOrderBinaryTree(tree->left_child, function);
+        PreOrderBinaryTree(tree->right_child, function);
     }
     return true;
 }
 
 // 中序遍历
-bool InOrder(BinaryTree &tree, bool(* function)(BinaryTree&)){
+bool InOrderBinaryTree(BinaryTree &tree, bool(* function)(BinaryTree&)){
     if(tree!= nullptr){
-        PreOrder(tree->left_child, function);
+        PreOrderBinaryTree(tree->left_child, function);
         if(!function(tree))
             return false;
-        PreOrder(tree->right_child, function);
+        PreOrderBinaryTree(tree->right_child, function);
     }
     return true;
 }
 
 // 后序遍历
-bool PostOrder(BinaryTree &tree, bool(* function)(BinaryTree&)){
+bool PostOrderBinaryTree(BinaryTree &tree, bool(* function)(BinaryTree&)){
     if(tree!= nullptr){
-        PreOrder(tree->left_child, function);
-        PreOrder(tree->right_child, function);
+        PreOrderBinaryTree(tree->left_child, function);
+        PreOrderBinaryTree(tree->right_child, function);
         if(!function(tree))
             return false;
     }
@@ -42,7 +42,7 @@ bool PostOrder(BinaryTree &tree, bool(* function)(BinaryTree&)){
 }
 
 // 非递归先序遍历
-bool PreOrderNonRecursive(BinaryTree &tree, bool(* function)(BinaryTree&)){
+bool PreOrderNonRecursiveBinaryTree(BinaryTree &tree, bool(* function)(BinaryTree&)){
     // 初始化栈，栈元素为tree指针
     std::stack<BinaryTree> stack;
     // 赋值一个新树
@@ -76,7 +76,7 @@ bool PreOrderNonRecursive(BinaryTree &tree, bool(* function)(BinaryTree&)){
 }
 
 // 非递归中序遍历
-bool InOrderNonRecursive(BinaryTree &tree, bool(* function)(BinaryTree&)){
+bool InOrderNonRecursiveBinaryTree(BinaryTree &tree, bool(* function)(BinaryTree&)){
     // 初始化栈，栈元素为tree指针
     std::stack<BinaryTree> stack;
     // 赋值一个新树
@@ -110,7 +110,7 @@ bool InOrderNonRecursive(BinaryTree &tree, bool(* function)(BinaryTree&)){
 }
 
 // 层序遍历
-bool LevelOrder(BinaryTree &tree, bool(* function)(BinaryTree&)){
+bool LevelOrderBinaryTree(BinaryTree &tree, bool(* function)(BinaryTree&)){
     // 初始化辅助队列
     std::queue<BinaryTree> queue;
     // 初始化树结点

Code/Code/head/thread_tree.h

@@ -1,11 +1,158 @@
 #include "head.h"
 
 // 线索二叉树结点
-typedef struct ThreadTreeNode{
+typedef struct ThreadBinaryTreeNode {
     // 数据
     element_type data;
     // 左右孩子结点
-    ThreadTreeNode *left_child, *right_child;
+    ThreadBinaryTreeNode *left_child, *right_child;
     // 左右线索指针
     int left_tag, right_tag;
-} ThreadTreeNode, *ThreadTree;
+} ThreadBinaryTreeNode, *ThreadBinaryTree;
+
+// 中序遍历线索化
+bool InOrderThreadBinaryTree(ThreadBinaryTree &tree, ThreadBinaryTree &pre) {
+    if (tree != nullptr) {
+        // 递归线索化左子树
+        InOrderThreadBinaryTree(tree->left_child, pre);
+        // 左子树为空，建立前驱线索
+        if (tree->left_child == nullptr) {
+            // 将左子树指向前驱
+            tree->left_child = pre;
+            tree->left_tag = 1;
+        }
+        // 当其前驱不为空且前驱的右子树为空
+        if (pre != nullptr && pre->right_child == nullptr) {
+            // 将前驱的后继线索指向当前结点
+            pre->right_child = tree;
+            pre->right_tag = 1;
+        }
+        // 将当前结点设为前驱结点
+        pre = tree;
+        // 递归线索化右子树
+        InOrderThreadBinaryTree(tree->right_child, pre);
+    }
+    return true;
+}
+
+// 建立中序线索二叉树
+bool CreateInOrderThreadBinaryTree(ThreadBinaryTree tree) {
+    ThreadBinaryTreeNode *pre = nullptr;
+    if (tree != nullptr) {
+        // 线索化二叉树
+        InOrderThreadBinaryTree(tree, pre);
+        // 处理遍历的最后一个结点
+        pre->right_child = nullptr;
+        pre->right_tag = 1;
+    }
+    return true;
+}
+
+// 中序线索二叉树中序序列第一个结点
+ThreadBinaryTreeNode *FirstInOrderBinaryTreeNode(ThreadBinaryTreeNode *node) {
+    // 当有左孩子结点
+    while (node->left_tag == 0) {
+        // 最左下的结点，不一定是叶子结点
+        node = node->left_child;
+    }
+    return node;
+}
+
+// 中序线索二叉树中序序列后继
+ThreadBinaryTreeNode *NextInOrderBinaryTreeNode(ThreadBinaryTreeNode *node){
+    // 如果有右孩子结点，则找到其右子树的最左结点
+    if(node->right_tag==0){
+        return FirstInOrderBinaryTreeNode(node->right_child);
+    }
+    else
+        // 若有后继线索则直接返回线索
+        return node->right_child;
+}
+
+// 中序遍历线索二叉树
+bool InOrderThreadBinaryTree(ThreadBinaryTree *tree,bool( *function)(ThreadBinaryTreeNode)){
+    for(ThreadBinaryTreeNode *node= FirstInOrderBinaryTreeNode(*tree);node != nullptr;node= NextInOrderBinaryTreeNode(node)){
+        if(!function(*node))
+            return false;
+    }
+    return true;
+}
+
+// 先序遍历线索化
+bool PreOrderThreadBinaryTree(ThreadBinaryTree &tree, ThreadBinaryTree &pre) {
+    if (tree != nullptr) {
+        // 左子树为空，建立前驱线索
+        if (tree->left_child == nullptr) {
+            // 将左子树指向前驱
+            tree->left_child = pre;
+            tree->left_tag = 1;
+        }
+        // 当其前驱不为空且前驱的右子树为空
+        if (pre != nullptr && pre->right_child == nullptr) {
+            // 将前驱的后继线索指向当前结点
+            pre->right_child = tree;
+            pre->right_tag = 1;
+        }
+        // 将当前结点设为前驱结点
+        pre = tree;
+        // 需要判断是否有左孩子
+        if(tree->left_tag==0){
+            // 递归线索化左子树
+            InOrderThreadBinaryTree(tree->left_child, pre);
+        }
+        // 递归线索化右子树
+        InOrderThreadBinaryTree(tree->right_child, pre);
+    }
+    return true;
+}
+
+// 建立先序线索二叉树
+bool CreatePreOrderThreadBinaryTree(ThreadBinaryTree tree) {
+    ThreadBinaryTreeNode *pre = nullptr;
+    if (tree != nullptr) {
+        // 线索化二叉树
+        PreOrderThreadBinaryTree(tree, pre);
+        // 处理遍历的最后一个结点
+        pre->right_child = nullptr;
+        pre->right_tag = 1;
+    }
+    return true;
+}
+
+// 先序后历线索化
+bool PostOrderThreadBinaryTree(ThreadBinaryTree &tree, ThreadBinaryTree &pre) {
+    if (tree != nullptr) {
+        // 递归线索化左子树
+        InOrderThreadBinaryTree(tree->left_child, pre);
+        // 递归线索化右子树
+        InOrderThreadBinaryTree(tree->right_child, pre);
+        // 左子树为空，建立前驱线索
+        if (tree->left_child == nullptr) {
+            // 将左子树指向前驱
+            tree->left_child = pre;
+            tree->left_tag = 1;
+        }
+        // 当其前驱不为空且前驱的右子树为空
+        if (pre != nullptr && pre->right_child == nullptr) {
+            // 将前驱的后继线索指向当前结点
+            pre->right_child = tree;
+            pre->right_tag = 1;
+        }
+        // 将当前结点设为前驱结点
+        pre = tree;
+    }
+    return true;
+}
+
+// 建立后序线索二叉树
+bool CreatePostOrderThreadBinaryTree(ThreadBinaryTree tree) {
+    ThreadBinaryTreeNode *pre = nullptr;
+    if (tree != nullptr) {
+        // 线索化二叉树
+        PreOrderThreadBinaryTree(tree, pre);
+        // 处理遍历的最后一个结点
+        pre->right_child = nullptr;
+        pre->right_tag = 1;
+    }
+    return true;
+}