数据结构二叉树代码(非递归前中后序遍历，中序线索化)

最新推荐文章于 2022-10-15 19:22:28 发布
最新推荐文章于 2022-10-15 19:22:28 发布
阅读量229 收藏
点赞数
分类专栏： 408 文章标签： 数据结构 链表 c++
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qingfengwuyue/article/details/125118051
版权
这篇博客详细介绍了如何使用C++实现数据结构中的二叉树，包括非递归方式的前序、中序、后序遍历以及中序线索化的操作，涉及到的主要函数和代码实现分别在不同的文件中定义和实现。
摘要由CSDN通过智能技术生成

主函数main

//#include"BiTreenode.h"
#include"Linknode.h"

SqBitreeptr make_tree1();
ThreadTreeptr make_tree2();
void main() {
	/*
	BiTreeptr T = (BiTree*)malloc(sizeof(BiTree));
	if (T == NULL)
		return;
	InitBitree(T);
	Showall(*T);
	int x;
	x = Comm_Ancestor(T, 10, 23);
	printf("%d ", x);
	*/
	SqBitreeptr S=NULL;
	// 手工构造一课树
	/*
		   1
		 2    3
		4 5  6 7
	   8
	*/
	S = make_tree1();
	//visit(S);
	Preorder2(S);
	Preorder(S);
	//printf("\n");
	//Postorder(S);
	//printf("\n");
	//Postorder2(S);
	/*
	ThreadTreeptr S2 = NULL;
	ThreadTreeptr pre = NULL;
	S2 = make_tree2();
	//InThread(S2, pre);
	//CreateInThread(&S2);
	S2 = InThread(S2, pre);
	visit(S2->lchild->lchild->lchild->rchild->rchild);
	*/
}

SqBitreeptr make_tree1() {
	SqBitreeptr S8 = (SqBitree*)malloc(sizeof(SqBitree));
	S8->data = 8, S8->lchild = NULL, S8->rchild = NULL;
	SqBitreeptr S7 = (SqBitree*)malloc(sizeof(SqBitree));
	S7->data = 7, S7->lchild = NULL, S7->rchild = NULL;
	SqBitreeptr S6 = (SqBitree*)malloc(sizeof(SqBitree));
	S6->data = 6, S6->lchild = NULL, S6->rchild = NULL;
	SqBitreeptr S5 = (SqBitree*)malloc(sizeof(SqBitree));
	S5->data = 5, S5->lchild = NULL, S5->rchild = NULL;
	SqBitreeptr S4 = (SqBitree*)malloc(sizeof(SqBitree));
	S4->data = 4, S4->lchild = S8, S4->rchild = NULL;
	SqBitreeptr S3 = (SqBitree*)malloc(sizeof(SqBitree));
	S3->data = 3, S3->lchild = S6, S3->rchild = S7;
	SqBitreeptr S2 = (SqBitree*)malloc(sizeof(SqBitree));
	S2->data = 2, S2->lchild = S4, S2->rchild = S5; 
	SqBitreeptr S1 = (SqBitree*)malloc(sizeof(SqBitree));
	S1->data = 1, S1->lchild =S2, S1->rchild = S3;
	return S1;
}

ThreadTreeptr make_tree2() {
	ThreadTreeptr S8 = (ThreadTreeptr)malloc(sizeof(ThreadTree));
	S8->data = 8, S8->lchild = NULL, S8->rchild = NULL,S8->rtag=S8->ltag=0;
	ThreadTreeptr S7 = (ThreadTreeptr)malloc(sizeof(ThreadTree));
	S7->data = 7, S7->lchild = NULL, S7->rchild = NULL, S7->rtag = S7->ltag = 0;
	ThreadTreeptr S6 = (ThreadTreeptr)malloc(sizeof(ThreadTree));
	S6->data = 6, S6->lchild = NULL, S6->rchild = NULL, S6->rtag = S6->ltag = 0;
	ThreadTreeptr S5 = (ThreadTreeptr)malloc(sizeof(ThreadTree));
	S5->data = 5, S5->lchild = NULL, S5->rchild = NULL, S5->rtag = S5->ltag = 0;
	ThreadTreeptr S4 = (ThreadTreeptr)malloc(sizeof(ThreadTree));
	S4->data = 4, S4->lchild = S8, S4->rchild = NULL, S4->rtag = S4->ltag = 0;
	ThreadTreeptr S3 = (ThreadTreeptr)malloc(sizeof(ThreadTree));
	S3->data = 3, S3->lchild = S6, S3->rchild = S7, S3->rtag = S3->ltag = 0;
	ThreadTreeptr S2 = (ThreadTreeptr)malloc(sizeof(ThreadTree));
	S2->data = 2, S2->lchild = S4, S2->rchild = S5, S2->rtag = S2->ltag = 0;
	ThreadTreeptr S1 = (ThreadTreeptr)malloc(sizeof(ThreadTree));
	S1->data = 1, S1->lchild = S2, S1->rchild = S3, S1->rtag = S1->ltag = 0;
	return S1;
}

头文件SqTree.h

#include<stdio.h>
#include<stdlib.h>
#pragma once
#define ElemType int
#define bool int
#define MaxSize 50

typedef struct Bitreenode {
	ElemType data[MaxSize];
	int length;
}BiTree,*BiTreeptr;
// 顺序存储二叉树

void InitBitree(BiTreeptr T);
bool IsEmpty(BiTreeptr T);
bool GetRoot(BiTreeptr T);
ElemType Comm_Ancestor(BiTreeptr T, int i, int j);
void Showall(BiTree T);

void visit1(BiTreeptr T);

头文件Linknode.h

#include<stdio.h>
#include<stdlib.h>
#include"SqBitree.h"
#define bool int
#pragma once

// 栈的链式存储
typedef struct Linknode {
	ThreadTree* data;
	struct Linknode* next;
}Linknode, * LinknodePtr;

void LinknodeStackmemo();  //定义主函数
void LinkInit(LinknodePtr L);			//初始化
bool LinkEmpty(LinknodePtr L);
LinknodePtr LinkPush(LinknodePtr L, ThreadTree* x);
LinknodePtr LinkPop(LinknodePtr L, ThreadTree** x);
bool LinkGetTop(LinknodePtr L, ThreadTree** x);

函数文件SqBiTree.c

#include"Linknode.h"

// 树的函数
void InitSqBitree(SqBitreeptr T) {
	return;
}

SqBitreeptr Insert_Sqtree(SqBitreeptr T,ElemType x) {
	SqBitreeptr new = (SqBitree*)malloc(sizeof(SqBitree));
	if (new == NULL)
		return T;
		return T;
	new->data = x;
	new->lchild =new->rchild= NULL;
	if (T == NULL) {
		T = new;
		return T;
	}
	else {
		while (T->lchild!= NULL) {
			T = T->lchild;
		}
		T->lchild = new;
		return T;
	}
}

void visit(SqBitreeptr T) {
	if(T != NULL) {
		printf("%d ",T->data);
	}
}

void Preorder(SqBitreeptr T) {
	if (T != NULL) {
		visit(T);   //访问根节点
		Preorder(T->lchild);   //访问左孩子
		Preorder(T->rchild);   //访问右孩子
	}
}

void Inorder(SqBitreeptr T) {
	if (T != NULL) {
		Inorder(T->lchild);
		visit(T);
		Inorder(T->rchild);
	}
}

void Postorder(SqBitreeptr T) {
	if (T != NULL) {
		Postorder(T->lchild);
		Postorder(T->rchild);
		visit(T);
	}
}

void Preorder2(SqBitreeptr T) {  //非递归先序遍历
	Linknode* S=NULL;
	SqBitreeptr p = T;
	LinkInit(S);
	while (p!=NULL || !LinkEmpty(S)) {
		if (p!=NULL) {
			visit(p);				//访问当前根节点
			S=LinkPush(S, p);		//压入当前根节点
			p = p->lchild;			//向左走
		}
		else {						
			S=LinkPop(S, &p);		//弹出当前根节点
			p = p->rchild;			//向右走
		}
	}
}

void Inorder2(SqBitreeptr T) {    //非递归中序遍历
	Linknode* S = NULL;
	SqBitreeptr p = T;
	LinkInit(S);
	while (p || !LinkEmpty(S)) {
		if (p) {
			S=LinkPush(S, p);
			p = p->lchild;
		}
		else {
			S=LinkPop(S, &p);
			visit(p);
			p = p->rchild;
		}
	}
}

void Postorder2(SqBitreeptr T) {		//非递归后续遍历
	Linknode* S = NULL;
	SqBitreeptr p = T;
	LinkInit(S);
	SqBitreeptr r = NULL;
	while (p || !LinkEmpty(S)) {
		if (p) {
			S = LinkPush(S, p);  //走到最左边
			p = p->lchild;
		}
		else {							//向右走
			LinkGetTop(S, &p);			//读取栈顶
			if (p->rchild && p->rchild != r) {   //判断右子树存在且未被访问过
				p = p->rchild;			//转向右
			}
			else {						//否则弹出栈顶并访问
				S = LinkPop(S, &p);		//弹出节点
				visit(p);				//访问节点
				r = p;					//记录最近访问的节点
				p = NULL;				//节点访问完毕，重置p指针。
			}
		}
	}
}

ThreadTreeptr InThread(ThreadTreeptr T, ThreadTreeptr pre) {		//中序线索化
	Linknode* S = NULL;
	ThreadTreeptr p = T;
	LinkInit(S);
	while (p || !LinkEmpty(S)) {
		if (p) {
			S = LinkPush(S, p);
			p = p->lchild;
		}
		else {
			S = LinkPop(S, &p);
			if (p->lchild == NULL) {
				p->lchild = pre;
				p->ltag = 1;
			}
			if (pre != NULL && pre->rchild == NULL) {
				pre->rchild = p;
				p->rtag = 1;
			}
			pre = p;
			p = p->rchild;
		}
	}
	pre->rchild = NULL;
	pre->rtag = 1;
	return T;
}

void Inorder_Thread(ThreadTreeptr T) {
	if (T != NULL) {
		Inorder_Thread(T->lchild);
		visit_Thread(T);
		Inorder_Thread(T->rchild);
	}
}

void visit_Thread(ThreadTreeptr T) {
	if (T != NULL)
		printf("%d ", T->data);
}

void InThread1(ThreadTreeptr *T,ThreadTreeptr *pre) {
	if (*T != NULL) {
		InThread1(&((*T)->lchild), pre);
		if ((*T)->lchild == NULL) {
			(*T)->lchild = *pre;
			(*T)->ltag = 1;
		}
		if (*pre != NULL && (*pre)->rchild == NULL) {
			(*pre)->rchild = *T;
			(*pre)->rtag = 1;
		}
		*pre = *T;
		InThread1(&(*T)->rchild, pre);
	}
}

void CreateInThread(ThreadTreeptr* T) {
	ThreadTreeptr pre = NULL;
	if (T != NULL) {
		InThread1(T, &pre);
		pre->rchild = NULL;
		pre->rtag = 1;
	}
}

函数文件Linknode.c

#include"Linknode.h"

void LinkInit(LinknodePtr L)			//初始化
{
	L = NULL;
}

bool LinkEmpty(LinknodePtr L)
{
	if (L == NULL)
		return 1;
	else
		return 0;
}
LinknodePtr LinkPush(LinknodePtr L, ThreadTree *x)
{
	Linknode* newdata = NULL;
	newdata = (Linknode*)malloc(sizeof(Linknode));
	if (newdata == NULL)
		return L;
	newdata->data = x;
	if (L == NULL) {
		L = newdata;
		newdata->next = NULL;
		return L;
	}
	else {
		newdata->next = L;
		L = newdata;
		return L;
	}
}
LinknodePtr LinkPop(LinknodePtr L, ThreadTree** x)
{
	if (L != NULL) {
		*x=L->data;
		/*
		(*x)->data = L->data->data;
		(*x)->lchild = L->data->lchild;
		(*x)->rchild = L->data->rchild;
		*/
		L = L->next;
		return L;
	}
	return L;
}
bool LinkGetTop(LinknodePtr L, ThreadTree** x)
{
	if (L != NULL) {
		*x = L->data;
		return 1;
	}
	return 0;
}

波克布林猪猪怪
关注
专栏目录
数据结构--二叉树的遍历
Meskjei的博客
06-30 522
文章目录遍历的概念搜索路径遍历算法（非递归）先序遍历中序遍历后序遍历先序遍历代码描述遍历算法（递归）中序遍历先序遍历由二叉树的先序和中序序列建树 遍历的概念 顺着某一条搜索路径巡访二叉树中的结点，使得每个结点均被访问一次，而且仅被访问一次。 “访问”的含义可以很广，如:输出结点的信息等。 “遍历”是任何类型均有的操作，对线性结构而言，只有一条搜索路径(因为每个结点均只有一个后继)，故不需要另加讨论...
数据结构之线索二叉树的前序,中序和后序遍历
热门推荐
微风
10-09 1万+
BinaryTree线索化二叉树      二叉树是一种非线性结构，在之前实现的二叉树遍历中不管是递归还是非递归用二叉树作为存储结构时只能取到该结点的左孩子和右孩子，不能得到该结点的前驱和后继。为了保存这种在遍历中需要的信息，同时也为了充分利用结点中的空指针域，我们利用二叉树中指向左右子树的空指针来存放结点的前驱和后继.同时在有n个结点的二叉链表中必定存在n+1个空链域.      那仫问题来
二叉树线索化代码
在氏博客
10-14 514
先序遍历线索化 typedef int ElemType; //为 int 类型取一个新的名字,方便重新修改二叉树结构体中的数据类型 /*线索二叉树结点（结构体）*/ typedef struct TreadNode { ElemType data; struct TreadNode *lchild,*rchild; int ltag,rtag; }ThreadNode,*ThreadTree; //全局变量 pre,指向当前访问结点的前驱 ThreadNode *pre = NULL; vo
数据结构——二叉树遍历及常见操作c代码实现
weixin_45491420的博客
06-28 333
二叉树遍历及常见操作代码实现。
数据结构(C语言版)严蔚敏---二叉树遍历、操作二叉树的相关代码
坚持不懈的大白的博客
10-15 728
本篇文章主要提供二叉树的遍历、操作二叉树的相关代码，仅供参考！
数据结构 —— 二叉树的4种遍历，java代码实现
Eaxker
01-08 710
import java.util.LinkedList; public class TreeSearch { //https://blog.csdn.net/xiaojin21cen/article/details/96971188 //创建一个二叉树 public TreeNode getTargetTree(){ //叶子节点 TreeNode G=new TreeNode("G"); TreeNode D=new TreeNo.
非递归前序,中序,后序遍历二叉树(优化算法).rar_nooneyh_二叉树 非递归_前序 中序 后序_树遍历算法_遍历二叉树
09-14
非递归后序遍历（Postorder Traversal）： 后序遍历的顺序是左子树 -> 右子树 -> 根节点。非递归实现较为复杂，因为后序遍历的顺序需要在访问完左右子树之后才访问根节点。一种常用的方法是使用两个栈，一个用于存储...
二叉树的非递归建立，前序、中序、后序遍历
07-17
关于数据结构实验的二叉树问题
线索二叉树(中序、先序和后序及遍历)
12-21
线索二叉树是一种特殊的二叉树数据结构，它在普通链式存储的二叉树基础上增加了额外的信息，以便更高效地进行遍历操作。在普通的二叉树中，每个节点只有左右子节点的指针，而在线索二叉树中，除了原有的子节点指针外...
中序线索化二叉树[C语言实现及注释]
bahunj93679的博客
12-22 1191
根据我自己的理解给代码加了注释。 /* 中序线索二叉树 2014/11/14 */ #include<stdio.h> #include<stdlib.h> typedef struct BiTrNoDe{ char data; struct BiTrNoDe *lchild; struct BiT...
中序线索化二叉树的c++代码
11-19
个人认为比较简洁 使用递归方式 创建使用扩展二叉树更加便捷 且有部分先序线索化代码 不够完善
二叉树的线索化（中序线索二叉树）
04-09
NULL 博文链接：https://128kj.iteye.com/blog/1634367
数据结构（代码实现）（五）：二叉树的遍历
qq_30207251的博客
06-06 189
//二叉树的遍历之递归实现（中序为例） void InOrderTravelsal(BinTree BT) {     if(BT)     {         InOrderTravelsal(BT-&gt;Left);         printf("%d", BT-&gt;Data);         InOrdweTravelsal(BT-&gt;Right);     } }//二叉树的...
【数据结构】二叉树遍历（递归遍历和非递归遍历）
珍心
10-30 1716
学而不思则罔，思而不学则殆 【数据结构】二叉树遍历二叉树递归遍历递归前序遍历递归中序遍历递归后序遍历二叉树相关学习的网站 二叉树 定义：每个节点最多有两个子树的数成为二叉树 递归遍历 public class TreeNode { TreeNode left; TreeNode right; char values; public TreeNode(char values) { this.values = values; } } 递归前序遍历
整理大二数据结构代码之二叉树的遍历
qq_41696136的博客
01-22 155
#include&lt;iostream&gt; #include&lt;cstdlib&gt; using namespace std; #define BiTree ElemType #define MAXSIZE 10 #define INCREMENT 10 enum Status{OK,ERROR}; //-----二叉树的二叉链表存储表示-------- typedef str...
二叉树遍历代码
qq_43556545的博客
10-15 288
今天复习了一下二叉树的遍历，当初学数据结构的时候没有好好理解，迭代的代码如下： //前序 vector preorderTraversal(TreeNode* root) { if(!root) return {}; vector result; stack<TreeNode*> stk; stk.push(root); while(!stk.empty()){ TreeNode* node = stk.top(); stk.pop(); if(node){ if(node -> righ
数据结构-二叉树四种遍历方法（代码）
有朋自远方来，不亦乐乎。
08-26 4083
例图：以下的几种遍历均以此图为基准。
数据结构 实现二叉树的遍历
qq_20880939的博客
11-26 173
【二叉树的遍历】 二叉树的遍历方式有四种: 前序遍历，中序遍历，后序遍历，层次遍历。其中前三种遍历方式二叉树常用的遍历方式。 【代码实现遍历】 当实现二叉树的遍历时，递归是实现前序遍历，中序遍历与后序遍历的最简单的方式，因为树的结构本身就是一种层次上不同，但结构是一致的，利用递归思想写出的代码简洁易懂。 // 二叉树三种遍历递归实现 #include<stdio.h> #in...
【数据结构】二叉树（遍历方法、递归实现）的JAVA代码实现
Yngz_Miao的博客
03-31 1万+
二叉树的遍历 二叉树的遍历是指按照某种顺序访问二叉树中的每个结点，使每个结点被访问一次且仅被访问一次。通过一次完整的遍历，可使二叉树中的结点信息由非线性排列变成某种意义上的线性序列。也就是说，遍历操作是非线性结构线性化。 由二叉树的定义可知，一棵二叉树由根结点、左子树和右子树三部分组成。因此，只需要依次遍历这三个部分，就可以遍历整个二叉树。若以D、L、R分别表示访问根结点、遍历根结点的左子树和...
C语言二叉树的前序、中序与后序遍历详解及其实现
在C语言中，二叉树的遍历是基础且重要的操作，它涉及到数据结构的深度理解。二叉树的遍历主要分为三种：前序遍历、中序遍历和后序遍历。这些名称的由来源于访问节点的顺序，例如： - **前序遍历**（Preorder ...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值