建立中序线索二叉树,并分别从第一个结点和最后一个结点遍历

任务

  1. 建立一颗中序线索二叉树;
  2. 分别从第-一个结点和最后一个结点出发输出中序遍历结果;
  3. 输出某结点的前趋和后继结点

思路:

线索二叉树结构类型
typedef struct treenode{
    char data;
    struct treenode *lchild,*rchild;
    int ltag,rtag; //记录指针与指向孩子结点还是后继或前驱 tag为0表示孩子,tag为1表示线索 
 
}treenode,*tree;

先建立一个二叉树
//使用先序建立二叉树
void buildtree(tree &t){
    char ch;
    
    ch = getchar();
    
    if(ch=='#') t = NULL;
    else{
        t = (treenode *)malloc(sizeof(treenode));
        t->data = ch;
        t->lchild = NULL;
        t->rchild = NULL;
        t->ltag = 0;
        t->rtag = 0;
        buildtree(t->lchild);
        buildtree(t->rchild);
 
 
    }
}
二叉树线索化

void inThreadTree(treenode *t,treenode** pre){
    if (t)//判断根节点是否存在
    {	//先左孩子
        inThreadTree(t->lchild,pre);
	//操作根节点
        //进行操作
        if (t->lchild==NULL)
        {
            t->ltag = 1;
            t->lchild = *pre;
        }
        if (*pre !=NULL && (*pre)->rchild == NULL)
        {
            (*pre)->rtag = 1;
            (*pre)->rchild = t;
        }
        *pre = t;
        
        ///最后右孩子
        inThreadTree(t->rchild,pre);
    }
    

}
获得第一个结点
treenode *getFirst(treenode *t){
    while (t->ltag == 0)
    {
        t = t->lchild;

    }
    return t;
    
    
}
获得第最后一个结点
treenode* getLast(treenode* t){
    while(t->rtag == 0){
		t = t->rchild;
	}
    return t;
}
获得后继结点
treenode* getNext(treenode *t){
    if (t->rtag == 1)
    {
        return t->rchild;
    }else{
        return getFirst(t->rchild);
    }
    

}
获得前驱
treenode* getPre(treenode *t){
    if (t->ltag == 0)
    {
        return getLast(t->lchild);   
    }else{
        return t->lchild;
    }
    
}
输出
输出函数(//输出当前结点及其前驱后继)

void PrintNode(treenode* node){
    if(node->lchild == NULL){
		printf("结点前驱:NULL ");
	}
	else{
		if(node->ltag == 1)
			printf("结点前驱:%c    ", node->lchild->data);
		else{
			treenode *p1;
			p1 = getPre(node);
			printf("结点前驱: %c    ", p1->data);
		}
	}
	printf("访问结点:%c   ", node->data);
	if(NULL == node->rchild){
		printf("结点后继:NULL\n");	
	}
	else{
		if(node->rtag == 1)
			printf("结点后继:%c\n", node->rchild->data);
		else{
			treenode *p;
			p = getNext(node);
			printf("结点后继: %c\n", p->data);
		}
	}
}
顺序输出(从第一个结点开始中序输出)
//顺序输出
void outOrder(treenode* t){
    for (treenode* node = getFirst(t); node != NULL; node = getNext(node))
    {
        PrintNode(node);
        printf("%c \n",node->data);

    }
}
最后一个结点遍历
//逆序输出(最后一个结点)
void outReverse(treenode* t){
    for (treenode* node = getLast(t); node != NULL; node = getPre(node))
    {
        PrintNode(node);
        printf("%c \n",node->data);

    }
}

完整代码


#include <iostream>
using namespace std;
#define MAX 20
 
typedef struct treenode{
    char data;
    struct treenode *lchild,*rchild;
    int ltag,rtag;
 
}treenode,*tree;
 
void buildtree(tree &t){
    char ch;
    
    ch = getchar();
    
    if(ch=='#') t = NULL;
    else{
        t = (treenode *)malloc(sizeof(treenode));
        t->data = ch;
        t->lchild = NULL;
        t->rchild = NULL;
        t->ltag = 0;
        t->rtag = 0;
        buildtree(t->lchild);
        buildtree(t->rchild);
 
 
    }
}

void inThreadTree(treenode *t,treenode** pre){
    if (t)
    {
        inThreadTree(t->lchild,pre);
        //进行操作
        if (t->lchild==NULL)
        {
            t->ltag = 1;
            t->lchild = *pre;
        }
        if (*pre !=NULL && (*pre)->rchild == NULL)
        {
            (*pre)->rtag = 1;
            (*pre)->rchild = t;
        }
        *pre = t;
        
        
        inThreadTree(t->rchild,pre);
    }
    

}

treenode *getFirst(treenode *t){
    while (t->ltag == 0)
    {
        t = t->lchild;

    }
    return t;
    
    
}

treenode* getNext(treenode *t){
    if (t->rtag == 1)
    {
        return t->rchild;
    }else{
        return getFirst(t->rchild);
    }
    

}

treenode* getLast(treenode* t){
    while(t->rtag == 0){
		t = t->rchild;
	}
    return t;
}

treenode* getPre(treenode *t){
    if (t->ltag == 0)
    {
        return getLast(t->lchild);   
    }else{
        return t->lchild;
    }
    
}

void PrintNode(treenode* node){
    if(node->lchild == NULL){
		printf("结点前驱:NULL ");
	}
	else{
		if(node->ltag == 1)
			printf("结点前驱:%c    ", node->lchild->data);
		else{
			treenode *p1;
			p1 = getPre(node);
			printf("结点前驱: %c    ", p1->data);
		}
	}
	printf("访问结点:%c   ", node->data);
	if(NULL == node->rchild){
		printf("结点后继:NULL\n");	
	}
	else{
		if(node->rtag == 1)
			printf("结点后继:%c\n", node->rchild->data);
		else{
			treenode *p;
			p = getNext(node);
			printf("结点后继: %c\n", p->data);
		}
	}
}

//顺序输出
void outOrder(treenode* t){
    for (treenode* node = getFirst(t); node != NULL; node = getNext(node))
    {
        PrintNode(node);
        printf("%c \n",node->data);

    }
}
//逆序输出(最后一个结点)
void outReverse(treenode* t){
    for (treenode* node = getLast(t); node != NULL; node = getPre(node))
    {
        PrintNode(node);
        printf("%c \n",node->data);

    }
}
int main(){
    tree t;
    treenode* pre = NULL;
    buildtree(t);
    inThreadTree(t,&pre);
    pre->rtag = 1;
    pre->rchild = NULL;
    // outOrder(t);
    outReverse(t);

    cout<<endl;
    
 
}
  • 1
    点赞
  • 11
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
以下是Python实现建立中序线索二叉树中序遍历中序线索二叉树的代码: ```python class ThreadedNode: def __init__(self, data): self.data = data self.left = None self.right = None self.ltag = 0 self.rtag = 0 class ThreadedBinaryTree: def __init__(self): self.root = None def create_tree(self, pre_order): if not pre_order: return None stack = [] pre_index = 0 n = len(pre_order) root = ThreadedNode(pre_order[pre_index]) pre_index += 1 self.root = root stack.append(root) while pre_index < n: if pre_order[pre_index] < stack[-1].data: node = ThreadedNode(pre_order[pre_index]) stack[-1].left = node stack.append(node) else: while stack and pre_order[pre_index] > stack[-1].data: temp = stack.pop() if not temp.right: node = ThreadedNode(pre_order[pre_index]) temp.right = node stack.append(node) if stack and stack[-1].right: stack.pop() node = ThreadedNode(pre_order[pre_index]) stack[-1].right = node stack.append(node) pre_index += 1 self.inorder_threading(self.root) def inorder_threading(self, node): if node: self.inorder_threading(node.left) if not node.left: node.ltag = 1 node.left = self.pre if self.pre and not self.pre.right: self.pre.rtag = 1 self.pre.right = node self.pre = node self.inorder_threading(node.right) def inorder_traversal(self): node = self.root while node.left: node = node.left while node: print(node.data, node.ltag, node.rtag) if node.rtag == 1: node = node.right else: node = node.right while node and node.ltag == 0: node = node.left def print_tree(self): self._print_tree(self.root) def _print_tree(self, node): if node: self._print_tree(node.left) print(node.data) self._print_tree(node.right) ``` 其中,`ThreadedNode`类表示线索二叉树的节点,包含了节点的值、左右子节点指针以及左右线索标记;`ThreadedBinaryTree`类表示线索二叉树,包含了根节点以及创建线索二叉树中序遍历线索二叉树和打印线索二叉树的方法。 `create_tree`方法用于创建线索二叉树,输入参数为先序序列,先根据先序序列构建一棵二叉树,然后对这棵二叉树进行中序线索化。 `inorder_threading`方法用于中序线索化二叉树,通过递归实现中序遍历,对每个节点进行处理,如果节点的左指针为空,则将其左线索标记设为1,左指针指向上一个节点;如果上一个节点的右指针为空,则将其右线索标记设为1,右指针指向当前节点。最后,将当前节点赋值给上一个节点。 `inorder_traversal`方法用于中序遍历线索二叉树,从根节点开始遍历,一直遍历到最左边的节点,然后输出节点的值和左右线索标记,如果右线索标记为1,则继续遍历右子树,否则向上寻找下一个节点。 `print_tree`方法用于打印线索二叉树,通过中序遍历实现。 下面是一个示例代码,演示如何使用以上代码: ```python tree = ThreadedBinaryTree() tree.create_tree([4, 2, 1, 3, 6, 5, 7]) tree.inorder_traversal() ``` 以上代码将会输出中序遍历线索二叉树的节点值以及节点的左右指针信息。
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

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

抵扣说明:

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

余额充值