线索二叉树之「先序」线索二叉树


typedef struct ThreadNode{
    int data;
    struct ThreadNode *lchild,*rchild;
    int ltag,rtag;
}ThreadNode,*ThreadTree;

ThreadNode *pre=NULL;

//初始化一棵树
void initTree(ThreadTree &T){
    T = (ThreadNode *)malloc(sizeof(ThreadNode));
    ThreadNode *n2 =(ThreadNode *)malloc(sizeof(ThreadNode));
    ThreadNode *n3 =(ThreadNode *)malloc(sizeof(ThreadNode));
    ThreadNode *n4 =(ThreadNode *)malloc(sizeof(ThreadNode));
    ThreadNode *n5 =(ThreadNode *)malloc(sizeof(ThreadNode));
    
    T->data=1;
    T->ltag=T->rtag=0;

    n2->data=2;
    n2->ltag=n2->rtag=0;
    n2->rchild=NULL;
    T->lchild=n2;
    
    n3->data=3;
    n3->ltag=n3->rtag=0;
    n3->lchild=NULL;
    T->rchild=n3;
    
    n4->data=4;
    n4->ltag=n4->rtag=0;
    n4->lchild=n4->rchild=NULL;
    n2->lchild=n4;
    
    n5->data=5;
    n5->ltag=n5->rtag=0;
    n5->lchild=n5->rchild=NULL;

    n3->rchild=n5;
}

void visit(ThreadNode *q){
    if (q->lchild==NULL) {
        q->lchild=pre;
        q->ltag=1;
    }
    if (pre!=NULL&&pre->rchild==NULL) {
        pre->rchild=q;
        pre->rtag=1;
    }
    pre=q;
}

void PreThread(ThreadTree T){
    if (T!=NULL) {
        visit(T);
        if (T->ltag==0) {
            PreThread(T->lchild);
        }
        if(T->rtag==0){
            PreThread(T->rchild);
        }
    }
}

//先序线索化二叉树T
void CreatePreThread(ThreadTree T){
    if (T!=NULL) {
        PreThread(T);
        pre->rchild=NULL;
        pre->rtag=1;
    }
}

ThreadNode *NextNode(ThreadNode *p){
    if (p->lchild!=NULL&&p->ltag==0) {
        return p->lchild;
    }
      return p->rchild;
}

void printing(ThreadNode *q){
    printf("%d",q->data);
}
//先序遍历(写法一)
void PreOrder(ThreadNode *T){
    if (T!=NULL) {
        for (ThreadNode *p=T; p!=NULL; p=NextNode(p)) {
            printing(p);
        }
    }
}
//先序遍历(写法二)
void PreOrder2(ThreadNode *T){
    ThreadNode *p =T;
    while (p!=NULL) {
        while (p->ltag==0) {
            printing(p);
            p=p->lchild;
        }
        printing(p);
        p=p->rchild;
    }
}

  • 0
    点赞
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
线索二叉树是一种对普通二叉树进行优化的数据结构,它的主要特点是将原本为空的左右子树指针利用起来,指向该节点在某种遍历方式下的前驱或后继节点,从而实现遍历时的快速跳转。线索二叉树先序遍历可以通过以下步骤实现: 1. 从根节点开始,如果当前节点不为空,则输出该节点的值。 2. 判断当前节点是否有左子树,如果有,则将当前节点的左子树指针作为线索指向该节点的前驱节点,然后将当前节点移动到其左子树。 3. 如果当前节点没有左子树,则将当前节点的左子树指针作为线索指向该节点的前驱节点的后继节点,然后将当前节点移动到其右子树。 4. 重复步骤2和3,直到当前节点为空或者遍历完整棵树。 下面是一个示例代码,其中`preorder_threading`函数用于将普通二叉树转换为线索二叉树,`preorder_traversal`函数用于实现线索二叉树先序遍历: ```python class ThreadedBinaryTreeNode: def __init__(self, value): self.value = value self.left = None self.right = None self.left_thread = False self.right_thread = False def preorder_threading(root): def _preorder_threading(node, prev): if node is None: return prev if node.left is None: node.left = prev node.left_thread = True if prev is not None and prev.right is None: prev.right = node prev.right_thread = True next_node = node.right if node.left_thread else node.left return _preorder_threading(node.left, node) if node.left else _preorder_threading(node.right, prev) _preorder_threading(root, None) def preorder_traversal(root): node = root while node is not None: print(node.value) if node.left_thread: node = node.left.right else: node = node.left ```
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值