考研数据结构二叉树之中序线索二叉树

考点

1. 遍历序列中的起始为，从根一直往左走，直到不能再走，即为遍历序列的起始节点。注意： 不一定是叶子节点。
2. 遍历序列的最后一个节点，从根一直往右走即可。
3. 找后继节点
   • 若右指针为线索，则右指针指向的即为后继
   • 如果右指针不是线索，就从当前节点向右走一步，再一直向左
4. 找前驱节点
   • 若左指针为线索，左指针指向的节点即为前驱
   • 若左指针指向的不是线索，就从当前节点向左走一步，再一直向右走

代码实现

#include <iostream>

using namespace std;

// 线索二叉树
// 把叶子节点上的空指针利用起来
// 对树的遍历操作相当于遍历链表，减少系统栈调用
// abcde为一棵树的中序表达式    中序线索二叉树中b的前驱节点为a，后继为c

struct node{
    char data;
    int ltag, rtag;  // tag值为一代表当前指针为线索指针
    struct node *lChild;
    struct node *rChild;

    node () {
        ltag = 0;
        rtag = 0;
        lChild = NULL;
        rChild = NULL;
    }
};

// 前序创建二叉树，空指针用#代替
node *create(node *p)
{
    char c;
    
    cin >> c;

    if (c != '#')
    {
        p = new node;
        p->data = c;
        p->lChild = create(p->lChild);
        p->rChild = create(p->rChild);
    }

    return p;
}

// 中序遍历二叉树
void mid(node *p)
{
    if (p)
    {
        mid(p->lChild);
        cout << p->data;
        mid(p->rChild);
    }
}

// 创建线索
void InThread(node *p, node *&pre)
{
    if (p)
    {
        InThread(p->lChild, pre);
        // 左孩子为空，指向pre，变为线索指针
        if (p->lChild == NULL)
        {
            p->lChild = pre;
            p->ltag = 1;
        }

        // pre不为空且右孩子为空，指向p
        if (pre && !pre->rChild)
        {
            pre->rChild = p;
            pre->rtag = 1;
        }

        pre = p;
        InThread(p->rChild, pre);
    }
}

// 创建线索二叉树
node * createInThread(node *root)
{
    node *pre = NULL;

    if (root)
    {
        InThread(root, pre);
        pre->rChild = NULL; // 结束后pre剩下的指针需要处理一下
        pre->rtag = 1;  // pre的空指针也是线索
    }

    return root;
}

// 查找中序序列第一个节点
node *First(node *p)
{
    while (p->ltag==0)
        p = p->lChild;
    
    return p;
}

// 查找节点p在中序下的后继节点的算法
node *Next(node *p)
{
    if (p->rtag == 0)
    {
        return First(p->rChild);
    }
    else
    {
        return p->rChild;
    }
}

// 中序线索树遍历
void Inorder(node *root)
{
    for (node *p = First(root); p!= NULL; p=Next(p))
        cout << p->data;
    cout << endl;
}

int main()
{
    struct node *root;

    root = create(root);
    mid(root);
    cout << endl;
    root = createInThread(root);
    Inorder(root);

    return 0;
}