线索二叉树和非递归遍历(中序)

基于中序遍历的线索二叉树和非递归遍历

#include <stdio.h>
#include <malloc.h>
#define MaxSize 100
typedef char ElemType;
typedef struct node 
{
	ElemType data;
	int ltag,rtag;      //增加的线索标记
	struct node *lchild;
	struct node *rchild;
} TBTNode;
void CreateTBTNode(TBTNode * &b,char *str)
{
	TBTNode *St[MaxSize],*p=NULL;
	int top=-1,k,j=0;  
	char ch;
	b=NULL;				//建立的二叉树初始时为空
	ch=str[j];
	while (ch!='\0')	//str未扫描完时循环
	{
   	   	switch(ch) 
		{
		case '(':top++;St[top]=p;k=1; break;		//为左结点
		case ')':top--;break;
		case ',':k=2; break;                      	//为右结点
		default:p=(TBTNode *)malloc(sizeof(TBTNode));
				p->data=ch;p->lchild=p->rchild=NULL;
		        if (b==NULL)					//*p为二叉树的根结点
					b=p;
				else  							//已建立二叉树根结点
				{	
					switch(k) 
					{
					case 1:St[top]->lchild=p;break;
					case 2:St[top]->rchild=p;break;
					}
				}
		}
		j++;
		ch=str[j];
	}
}
void DispTBTNode(TBTNode *b) 
{
	if (b!=NULL)
	{
		printf("%c",b->data);
		if (b->lchild!=NULL || b->rchild!=NULL)
		{
			printf("(");
			DispTBTNode(b->lchild);
			if (b->rchild!=NULL) printf(",");
			DispTBTNode(b->rchild);
			printf(")");
		}
	}
}
TBTNode *pre;						//全局变量
void Thread(TBTNode *&p)
{
	if (p!=NULL)	
	{	
		Thread(p->lchild);    		//左子树线索化
		if (p->lchild==NULL)		//前驱线索
		{
			p->lchild=pre;        	//建立当前结点的前驱线索
			p->ltag=1;
		}
		else p->ltag=0;
		if (pre->rchild==NULL)		//后继线索
		{	
			pre->rchild=p;     		//建立前驱结点的后继线索
		   	pre->rtag=1;
		}
		else pre->rtag=0;
	    pre=p;
	   	Thread(p->rchild);  		//右子树线索化
	}
}
TBTNode *CreaThread(TBTNode *b)     //中序线索化二叉树
{
	TBTNode *root;
	root=(TBTNode *)malloc(sizeof(TBTNode));  //创建根结点
	root->ltag=0;root->rtag=1;
	root->rchild=b;
	if (b==NULL)                //空二叉树
		root->lchild=root;
	else
	{  	
		root->lchild=b;
		pre=root;             	//pre是*p的前驱结点,供加线索用
		Thread(b);   			//中序遍历线索化二叉树
		pre->rchild=root;    	//最后处理,加入指向根结点的线索
		pre->rtag=1;
		root->rchild=pre;    	//根结点右线索化
	}
    return root;
}
void ThInOrder(TBTNode *tb)
{
	TBTNode *p=tb->lchild;		//指向根结点
	while (p!=tb)		
	{
		while (p->ltag==0) p=p->lchild;
		printf("%c ",p->data);
		while (p->rtag==1 && p->rchild!=tb)
		{
			p=p->rchild;
			printf("%c ",p->data);
		}
		p=p->rchild;
	}
}
void main()
{
	TBTNode *b,*tb;
	CreateTBTNode(b,"A(B(D(,G)),C(E,F))");
	printf(" 二叉树:");DispTBTNode(b);printf("\n");
	tb=CreaThread(b);
	printf(" 线索中序序列:");ThInOrder(tb);printf("\n");
}

 

  • 1
    点赞
  • 9
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
二叉树非递归遍历常用的方法有两种,一种是使用栈,一种是使用 Morris 遍历。下面我将分别给出两种方法的 Python 代码实现。 ## 栈实现非递归遍历 ```python class TreeNode: def __init__(self, val): self.val = val self.left = None self.right = None def preorderTraversal(root): if not root: return [] stack, res = [root], [] while stack: node = stack.pop() res.append(node.val) if node.right: stack.append(node.right) if node.left: stack.append(node.left) return res def inorderTraversal(root): if not root: return [] stack, res = [], [] while stack or root: if root: stack.append(root) root = root.left else: node = stack.pop() res.append(node.val) root = node.right return res def postorderTraversal(root): if not root: return [] stack, res = [root], [] while stack: node = stack.pop() res.append(node.val) if node.left: stack.append(node.left) if node.right: stack.append(node.right) return res[::-1] ``` 上述代码实现了二叉树的前序遍历中序遍历和后序遍历,分别用 `preorderTraversal`、`inorderTraversal` 和 `postorderTraversal` 表示。这些函数的实现都是基于栈的非递归遍历方法,使用栈保存待访问的节点。在遍历时先将根节点入栈,然后循环执行以下操作: - 弹出栈顶节点,记录其值; - 将栈顶节点的右子节点(如果有)入栈; - 将栈顶节点的左子节点(如果有)入栈。 由于栈的特性,上述循环会先访问左子树,然后是右子树,符合二叉树遍历的先左后右的规则。针对后序遍历,需要将结果数组反转。 ## Morris 遍历实现非递归遍历 ```python class TreeNode: def __init__(self, val): self.val = val self.left = None self.right = None def inorderTraversal(root): if not root: return [] cur, res = root, [] while cur: if not cur.left: res.append(cur.val) cur = cur.right else: pre = cur.left while pre.right and pre.right is not cur: pre = pre.right if not pre.right: pre.right = cur cur = cur.left else: pre.right = None res.append(cur.val) cur = cur.right return res ``` 上述代码实现了二叉树中序遍历,使用 Morris 遍历方法。Morris 遍历方法基于线索二叉树的思想,利用空闲的指针保存访问过的节点,从而避免使用栈或者递归占用额外的空间。具体实现方法如下: - 如果当前节点的左子节点为空,记录当前节点的值,然后将当前节点指向其右子节点; - 如果当前节点的左子节点不为空,找到其左子树的最右节点,记为 `pre`; - 如果 `pre` 的右指针为空,将其右指针指向当前节点,然后将当前节点指向其左子节点; - 如果 `pre` 的右指针不为空,说明当前节点的左子树已经访问完毕,记录当前节点的值,然后将 `pre` 的右指针置为空,将当前节点指向其右子节点。 由于 Morris 遍历方法只使用了常数级别的空间,因此在空间复杂度上优于基于栈的遍历方法。但是,由于需要修改树的结构,因此在时间复杂度上可能会劣于基于栈的遍历方法。

“相关推荐”对你有帮助么?

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 1
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

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

抵扣说明:

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

余额充值