一定要学会二叉树！！

最新推荐文章于 2022-11-11 15:13:41 发布
最新推荐文章于 2022-11-11 15:13:41 发布
阅读量265 收藏 1
点赞数 1
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_21399251/article/details/102577889
版权

一定要学会二叉树！！

一定要学会二叉树！！

一定要学会二叉树！！



#include <stdio.h>
#include <stdlib.h>


/****************************树定义******************************/

typedef enum{
	TREENODE = 0,
	LINKLISTNODE	
}PointType;

typedef struct _BTNode_
{
    char data;
	PointType	lPointType;
	PointType	rPointType;
    struct _BTNode_ *lChild;
    struct _BTNode_ *rChild;
}BTNode, *BTree;

/*****************************栈定义*******************************/

typedef struct __STACK_NODE__
{
	BTree TreeNodeData;
	struct __STACK_NODE__ *next;
}SNode_T, *SNode_P;

typedef struct __STACK__
{
	SNode_P top;
	int Num;
}STACK_T, *STACK_P;


/***************************队列定义********************************/

typedef struct __QUEUE_NODE__
{
	BTree TreeNodeData;
	struct __QUEUE_NODE__ *next;
	struct __QUEUE_NODE__ *pre;
}QNode_T, *QNode_P;

typedef struct __QUEUE__
{
	QNode_P top;
	QNode_P tail;
	int Num;
}QUEUE_T, *QUEUE_P;


/********************************************************************/

//队列初始化
QUEUE_P QueueInit()
{
	QUEUE_P queue = NULL;

	queue = (QUEUE_P)malloc(sizeof(QUEUE_T));
	queue->top = (QNode_P)malloc(sizeof(QNode_T));
	queue->tail = (QNode_P)malloc(sizeof(QNode_T));

	queue->Num = 0;
	queue->top->pre = NULL;
	queue->top->next = queue->tail;
	queue->tail->pre = queue->top;
	queue->tail->next = NULL;
	queue->tail->TreeNodeData = NULL;
	queue->top->TreeNodeData = NULL;
	
	return queue;
}

//入队
void QueuePush(QUEUE_P queue, BTree pTreeNode)
{
	QNode_P newQnode = NULL;
	if ((!pTreeNode)||(!queue))
	{
		return;
	}
	newQnode = malloc(sizeof(QNode_T));
	
	newQnode->next = queue->top->next;
	queue->top->next = newQnode;
	newQnode->pre = newQnode->next->pre;
	newQnode->next->pre = newQnode;

	newQnode->TreeNodeData = pTreeNode;	
	
	queue->Num++;
	return;
}

//出队
BTree QueuePop(QUEUE_P queue)
{
	QNode_P tempnode = NULL;
	BTree PopTreeNode = NULL;
	if (!queue)
	{
		return NULL;
	}
	if (queue->Num == 0)
	{
		return NULL;
	}

	tempnode = queue->tail->pre;

	queue->tail->pre = queue->tail->pre->pre;
	queue->tail->pre->next = queue->tail;
	queue->Num--;
	
	PopTreeNode = tempnode->TreeNodeData;
	free(tempnode);
	
	return PopTreeNode;
}

//栈初始化
STACK_P StackInit()
{
	STACK_P stack = NULL;
	stack = (STACK_P)malloc(sizeof(STACK_T));	
	stack->top = (SNode_P)malloc(sizeof(SNode_T));
	stack->top->next = NULL;
	stack->top->TreeNodeData = NULL;
	stack->Num = 0;
	return stack;
}

//入栈
void StackPush(STACK_P stack, BTree pTreeNode)
{
	SNode_P newSnode = NULL;
	if ((!pTreeNode)||(!stack))
	{
		return;
	}
	newSnode = malloc(sizeof(SNode_T));

	newSnode->TreeNodeData = pTreeNode;
	newSnode->next = stack->top->next;
	stack->top->next = newSnode;
	stack->Num++;
	return;
}

//出栈
BTree StackPop(STACK_P stack)
{
	SNode_P tempnode = NULL;
	BTree PopTreeNode = NULL;
	if (!stack)
	{
		return NULL;
	}
	if (stack->Num == 0)
	{
		return NULL;
	}

	tempnode = stack->top->next;

	stack->top->next = tempnode->next;
	stack->Num--;
	
	PopTreeNode = tempnode->TreeNodeData;
	free(tempnode);
	
	return PopTreeNode;
}

//获取栈顶元素
BTree StackTop(STACK_P stack)
{
	SNode_P tempnode = NULL;
	BTree PopTreeNode = NULL;
	if (!stack)
	{
		return NULL;
	}
	if (stack->Num == 0)
	{
		return NULL;
	}

	return stack->top->next->TreeNodeData;
}

//前序创建二叉树
BTree CreateBTree_Pre()
{
    BTree bt = NULL;
    char ch;
    scanf("%c", &ch);
    if (ch != '#')
    {
        bt = (BTree)malloc(sizeof(BTNode));
        bt->data = ch;
        bt->lChild = CreateBTree_Pre();
        bt->rChild = CreateBTree_Pre();
    }
    return bt;
}

//获取二叉树的高度
int GetTreeHeight(BTree bt)
{
	int lHeight = 0;
	int rHeight = 0;
	if (bt)
	{
		lHeight = GetTreeHeight(bt->lChild);
		rHeight = GetTreeHeight(bt->rChild);
		return (lHeight > rHeight ? lHeight : rHeight) + 1;
	}

	return 0;
}

//销毁二叉树-递归
void BTreeDestroy(BTree bt)
{
	if (bt)
	{
		if (bt->lChild)
		{
			BTreeDestroy(bt->lChild);
		}

		
		if (bt->rChild)
		{
			BTreeDestroy(bt->rChild);
		}

		if ((bt->lChild == NULL)&&(bt->rChild == NULL))
		{
			free(bt);
			bt = NULL;
			return ;
		}
	}

	return ;
}
//销毁二叉树-非递归
int BTreeDestroyNew(BTree bt)
{
	int lHeight = 0;
	int rHeight = 0;
	if (bt)
	{
		lHeight = GetTreeHeight(bt->lChild);
		rHeight = GetTreeHeight(bt->rChild);
		return (lHeight > rHeight ? lHeight : rHeight) + 1;
	}

	return 0;
}


//层序递归遍历二叉树
void LayerOrderTraverse(BTree bt, int level)
{
	if (bt == NULL)
	{
		return;
	}
	if (level == 1)
	{
		printf("%c->", bt->data);
		return;
	}
	LayerOrderTraverse(bt->lChild, level-1);
	LayerOrderTraverse(bt->rChild, level-1);
	return;
}


//中序递归遍历二叉树
void MidOrderTraverse(BTree bt)
{
	if (bt == NULL)
	{
		return;
	}
	MidOrderTraverse(bt->lChild);
	printf("%c->", bt->data);
	MidOrderTraverse(bt->rChild);
}

//后序递归遍历二叉树
void AfterOrderTraverse(BTree bt)
{
	if (bt == NULL)
	{
		return;
	}
	AfterOrderTraverse(bt->lChild);	
	AfterOrderTraverse(bt->rChild);
	printf("%c->", bt->data);
}

//前序递归遍历二叉树
void PreOrderTraverse(BTree bt)
{
	if (bt == NULL)
	{
		return;
	}
	printf("%c->", bt->data);
	PreOrderTraverse(bt->lChild);
	PreOrderTraverse(bt->rChild);
}

//前序遍历-非递归
void PreOrderTraverseByStack(STACK_P stack, BTree bt)
{
	BTree cur = NULL;
	if ((bt == NULL)||(stack == NULL))
	{
		return;
	}

	cur = bt;

	while(cur != NULL || stack->Num)
	{
		while(cur)
		{
			printf("%c->", cur->data);
			StackPush(stack, cur);
			cur = cur->lChild;
		}

		cur = StackPop(stack)->rChild;
	}
	
}

//中序遍历-非递归
void MidOrderTraverseByStack(STACK_P stack, BTree bt)
{
	BTree cur = NULL;
	if ((bt == NULL)||(stack == NULL))
	{
		return;
	}

	cur = bt;

	while(cur != NULL || stack->Num)
	{
		while(cur)
		{
			StackPush(stack, cur);
			cur = cur->lChild;
		}
		cur = StackPop(stack);
		
		printf("%c->", cur->data);
		cur = cur->rChild;
	}
	
}

//后序遍历-非递归
void AfterOrderTraverseByStack(STACK_P stack, BTree bt)
{
	BTree cur = NULL;
	BTree last = NULL;
	BTree top = NULL;
	if ((bt == NULL)||(stack == NULL))
	{
		return;
	}

	cur = bt;

	while(cur != NULL || stack->Num)
	{
		while(cur)
		{
			StackPush(stack, cur);
			cur = cur->lChild;
		}
		
		top = StackTop(stack);

		if ((top->rChild == NULL)||(top->rChild == last))
		{
			StackPop(stack);
			printf("%c->", top->data);
			last = top;
		}
		else
		{
			cur = top->rChild;
		}
	}
	
}


//层序遍历-非递归
void LevelOrderTraverseByQueue(QUEUE_P queue, BTree bt)
{
	BTree top = NULL;
	BTree cur = NULL;
	if ((bt == NULL)||(queue == NULL))
	{
		return;
	}

	cur = bt;
	QueuePush(queue, cur);

	while(queue->Num)
	{
		top = QueuePop(queue);
		
		if (top->lChild)
		{
			QueuePush(queue, top->lChild);
		}		
		if (top->rChild)
		{
			QueuePush(queue, top->rChild);
		}

		printf("%c->", top->data);

	}
	
}


//二叉树线索化
//树结点的左空指针指向前驱，右空结点指向后继

void PreOrderLinkListBTreePrint(BTree bt)
{
	BTree lastpos = NULL;//指向上一次访问过的结点
	if (bt == NULL)
	{
		return;
	}
	if (!bt->lChild)
	{
		bt->lPointType = LINKLISTNODE;		
		bt->lChild = lastpos;//左空结点指向前驱
	}
	if (!lastpos->rChild)
	{
		lastpos->rPointType = LINKLISTNODE;
		lastpos->rChild = bt;//右空结点指向后继
	}
	lastpos = bt;
	PreOrderTraverse(bt->lChild);
	PreOrderTraverse(bt->rChild);
}


//前序线索化二叉树&前序遍历&后序遍历
void PreOrderLinkListBTree(BTree bt)
{
	BTree lastpos = NULL;//指向上一次访问过的结点
	if (bt == NULL)
	{
		return;
	}
	if (!bt->lChild)
	{
		bt->lPointType = LINKLISTNODE;		
		bt->lChild = lastpos;//左空结点指向前驱
	}
	if (!lastpos->rChild)
	{
		lastpos->rPointType = LINKLISTNODE;
		lastpos->rChild = bt;//右空结点指向后继
	}
	lastpos = bt;
	PreOrderTraverse(bt->lChild);
	PreOrderTraverse(bt->rChild);
}

//中序线索化二叉树&前序遍历&后序遍历
void MidOrderLinkListBTree(BTree bt)
{
	BTree lastpos = NULL;//指向上一次访问过的结点
	if (bt == NULL)
	{
		return;
	}
	MidOrderLinkListBTree(bt->lChild);
	if (!bt->lChild)
	{
		bt->lPointType = LINKLISTNODE;		
		bt->lChild = lastpos;
	}
	if (!lastpos->rChild)
	{
		lastpos->rPointType = LINKLISTNODE;
		lastpos->rChild = bt;
	}
	lastpos = bt;
	MidOrderLinkListBTree(bt->rChild);

}

//后序线索化二叉树&前序遍历&后序遍历
void AfterOrderLinkListBTree(BTree bt)
{
	BTree lastpos = NULL;//指向上一次访问过的结点
	if (bt == NULL)
	{
		return;
	}
	MidOrderLinkListBTree(bt->lChild);
	MidOrderLinkListBTree(bt->rChild);
	if (!bt->lChild)
	{
		bt->lPointType = LINKLISTNODE;		
		bt->lChild = lastpos;
	}
	if (!lastpos->rChild)
	{
		lastpos->rPointType = LINKLISTNODE;
		lastpos->rChild = bt;
	}
	lastpos = bt;

}

//层序线索化二叉树&前序遍历&后序遍历
void LevelOrderLinkListBTree()
{
	return;
}

int main()
{
	//AB#D##CE##F##
    BTree bt;
	STACK_P stack = NULL;
	QUEUE_P queue = NULL;
	int i = 0;
	int Height = 0;
	stack = StackInit();
	queue = QueueInit();
    bt = CreateBTree_Pre();	
	
	printf("\n前序递归遍历：");
    PreOrderTraverse(bt);        /* 前序递归遍历 */
	printf("\n中序递归遍历：");
	MidOrderTraverse(bt);        /* 中序递归遍历 */
	printf("\n后序递归遍历：");
	AfterOrderTraverse(bt);        /* 后序递归遍历 */
	printf("\n层序递归遍历：");
	Height = GetTreeHeight(bt);
	for (i = 1; i <= Height; i++)/* 层序递归遍历 */	
	{
		LayerOrderTraverse(bt, i);		  
	}
	printf("\n前序非递归遍历：");
	PreOrderTraverseByStack(stack, bt);
	printf("\n中序非递归遍历：");
	MidOrderTraverseByStack(stack, bt);
	printf("\n后序非递归遍历：");
	AfterOrderTraverseByStack(stack, bt);
	printf("\n层序非递归遍历：");	
	LevelOrderTraverseByQueue(queue, bt);

	free(queue->top);
	free(queue->tail);
	free(queue);
	
	free(stack->top);
	free(stack);
	BTreeDestroy(bt);
	printf("\n\r");
    return 0;
}

 

小火车啊
关注
  • 1
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
为什么使用二叉树？
dengbangtui3521的博客
02-05 2624
一、为什么使用二叉树？ 　　因为二叉树结合了有序数组，链表这两者的优点。在树中查找数据的速度和有序数组中查找一样快。并且插入数据和删除数据的速度和链表一样。 二、在有序数组中插入数据项太慢 　　有序数组：数组中的所有数据项都有序的排列。用二分查找可以在有序数组中快速查找特定的值。 过程是先查看数组的中间的数据，如果中间数据比想要的大，缩写范围，在前半段找。反复过程查找的复杂度就是...
【数据结构】二叉树的原理及实现学习总结
热门推荐
简约人生的博客
04-25 1万+
二叉树概述数组、向量、链表都是一种顺序容器，它们提供了按位置访问数据的手段。而很多情况下，我们需要按数据的值来访问元素，而不是它们的位置来访问元素，二叉树在很大程度上解决了这个问题，二叉树是按值来保存元素，也按值来访问元素。二叉树是树形结构的一个重要类型。许多实际问题抽象出来的数据结构往往是二叉树的形式，即使是一般的树也能简单地转换为二叉树，而且二叉树的存储结构及其算法都较为简单，因此二叉树显得特别重要。
二叉树的学习
m0_63783532的博客
11-11 1387
2.n = n1 + 2n2 + 1（树的结点数 = 总度数 + 1，其中度为0的结点数有n0个，度数和为0×n0；1.n = n0 + n1 + n2（树的结点数 = 度为0的结点数 + 度为1的结点数 + 度为2的结点数）分析：第一层有1个结点；总共有1+2+2^2......+2^(h-1)=(1-2^h)/(1-2)=2^h-1。又推出若完全二叉树有2k个（偶数）个结点，则必有n1=1，n0=k，n2=k-1。若完全二叉树有2k-1个（奇数）个结点，则必有n1=0，n0=k，n2=k-1。
树
qq_35912930的博客
06-20 2539
算法的定义 两种算法的比较 算法的特性 算法设计的要求 算法效率的度量方法 函数的渐进增长 算法时间复杂度 常见的时间复杂度 算法空间复杂度
二叉树的基本概念(为什么需要树这样数据结构+树示意图+二叉树的概念+二叉树的遍历说明)
PDyee的博客
01-02 434
二叉树的基本概念 一、为什么需要树这样数据结构 1.数组存储方式分析 优点：通过下表方式访问元素，速度快。对于有序数组没还可以使用二分查找提高检索速度。 缺点：如果要检索某一个具体值，效率比较低下 2.链式存储方式分析 优点：在一定程度上对数组存储方式进行优化（比如插入一个节点，只需要将插入节点，链接到链表当中可删除的效率也很好）。 缺点：在进行检索时，效率仍然比较低，比如（检索某个数值，需要从头结点开始遍历） 3.树存储方式分析 能提高数据存储，读取的效率，比如利用二叉排序树，既可以保证数据的检索速度。同
为啥要用二叉树呢？
Hi, Sun
10-07 1463
    为啥要用二叉树呢？奇怪的问题！   答：因为二叉树结合了数组和链表的优点，插入和删除，查找的速度很快，就是这么简单。   红黑树--平衡二叉树 要点：        1.每个点要么是红色，要么是黑色        2.根是黑色        3.如果节点是红色，那么它的子节点必须是黑色的        4.从根节点到叶子节点或者到空子节点，都必须包含了相同数目的黑色节...
二叉树及其应用.docx
01-26
我们还学会了使用C语言来实现二叉树的建立和遍历，并使用哈夫曼树来实现哈夫曼编码和译码。 六、结论 本文档详细介绍了二叉树的定义、性质、存储方式、建立、遍历及其算法的实现，并深入了解哈夫曼树的建立、...
实验五 二叉树的基本操作实现
04-30
通过本实验，学生将掌握对二叉树每一种操作的具体实现，学会利用递归方法和非递归方法编写对二叉树这种递归数据结构进行处理的算法。 二、实验内容 实验内容包括设计程序实现链式存储二叉树结点的类型定义和对...
数据结构作业唯一确定一棵二叉树.doc
12-02
数据结构作业唯一确定一棵二叉树 数据结构作业中的二叉树是一种基础数据结构，它广泛应用于...首先，用户需要编译运行程序，然后根据提示输入要构建的二叉树的结点、前序序列和中序序列。最后，回车后即可得出结果。
实验七 二叉树操作验证
04-27
在实际操作中，学生需要理解二叉链表的构造，学会如何通过输入构建二叉树，并掌握各种遍历方法的实现。实验不仅要求理论知识，还强调实践能力，通过编写和运行代码加深对二叉树的理解。 总结起来，这个实验涵盖了...
二叉树及其作用浅析
独行猫a 的沉淀、积累、总结。天天学习，好好向上...c/c++,嵌入式 linux,Android,HarmonyOS)
10-14 1万+
在学习数据结构和算法时看到各种树，把人都整蒙了，枯燥且提不起学习兴趣。等逐渐感受到二叉树的神奇作用和巨大的应用价值后，觉得二叉树原来也这么有趣，值得好好学习。 先从整体上认识下二叉树及其他各种树的区别和用途。 大致有哪些树？ 树有很多种，其中二拆树因为其特殊的结构和特点在计算上最为常用。 常见的二叉树：二叉查找树，平衡二叉树(AVL)，红黑树，B+树，B-树，字典树，满二叉树，完全二叉树，霍夫曼树，伸展树，最小堆，最大堆等。 二叉树有什么用？ 二叉树应用非常广泛。 在操作系统源程序中，树和.
学习二叉树必须知道的基本性质
听老罗娓娓道来
11-03 3928
二叉树 首先二叉树为什么是我们讨论的对象，那么多叉树，比如3叉树，4叉树，5叉树。其实我也不知道为什么讨论二叉树，但是二叉树的使用范围是非常广泛的。所以我们会深入的去讲解二叉树。 二叉树为何物，即定义是什么，二叉树还有个英文名在国外叫Binary Tree.是不是非常的熟悉。首先我们要知道二叉树并不是真的树，在计算中是描述了一个数据节点持有2个子节点并且仅最多2个节点。这2个子节点是没有任何交集也就
研究树为什么要重点研究二叉树？一次性搞懂二叉树和树的初阶知识
CS_boy的博客
10-15 1123
  本文记录了一些有关树这种数据结构相对初阶的知识。   如果你是已经有一定的树这种数据结构的基础想知道为什么研究树要重点研究二叉树，可以去看目录 13、树、森林与二叉树的转化；如果你是和我一样的小白想循序了解一些树的有关知识，可以从头看起。 文章目录✨1.树的定义✨2.结点的度 叶结点 树的度????1. 结点的度(Degree)????2. 叶结点(Leaf)????3. 树的度✨3.结点间的关系✨4.树的其他概念✨5.树的存储结构????1. 双亲表示法????2. 孩子表示法????3. 孩子兄弟
二叉树一文带你轻松学会
qq_58259923的博客
11-28 1306
二叉树的那些事儿。
几张图学会树、森林、二叉树之间的相互转换（手动模拟方法）
糖长老莫小贝的博客
06-29 3395
树转二叉树 二叉树转树 ps：图中标注是为了便于理解。
python二叉树搜索树我没学会
最新发布
05-17
二叉搜索树是一种特殊的二叉树，它的左子树上所有节点的值都小于根节点的值，右子树上所有节点的值都大于根节点的值，这样的树就称为二叉搜索树。 在 Python 中实现二叉搜索树，你可以先定义一个节点类，来表示树的...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值