树和二叉树

最新推荐文章于 2023-06-25 09:25:12 发布
最新推荐文章于 2023-06-25 09:25:12 发布
阅读量64 收藏
点赞数 1
文章标签： 二叉树
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/mlyhzt/article/details/109899218
版权

树和二叉树

1.二叉树的表示
2.二叉树的遍历
3.二叉树的基本操作

1.二叉树的表示

  • 结构设计
#define END '#'
typedef char ElemType;
typedef struct BtNode
{
	struct BtNode* leftchild;
	struct BtNode* rightchild;
	ElemType data;
}BtNode,*BinaryTree;

2.二叉树的遍历

所谓树的遍历，就是按某种次序访问树中的结点，要求每个结点访问一次且仅访问一次。

递归遍历

void PreOrder(BtNode* p)//先序遍历
{
	if (p != NULL)
	{
		printf("%c ", p->data);
		PreOrder(p->leftchild);
		PreOrder(p->rightchild);
	}
}

void InOrder(BtNode* p)//中序遍历
{
	if (p != NULL)
	{
		InOrder(p->leftchild);
		printf("%c ", p->data);
		InOrder(p->rightchild);
	}
}

void PastOrder(BtNode* p)//后序遍历
{
	if (p != NULL)
	{
		PastOrder(p->leftchild);
		PastOrder(p->rightchild);
		printf("%c ", p->data);
	}
}

非递归遍历

//非递归的先序遍历
void NicePreOrder(BtNode* ptr)
{
	if (ptr == NULL)
		return;
	stack<BtNode*> st;
	st.push(ptr);
	while (!st.empty())
	{
		ptr = st.top();
		st.pop();
		cout << ptr->data << " ";
		if (ptr->rightchild != NULL)
		{
			st.push(ptr->rightchild);
		}
		if (ptr->leftchild != NULL)
		{
			st.push(ptr->leftchild);
		}
	}
	cout << endl;
}

//非递归的中序遍历
void NiceInOrder(BtNode* ptr)
{
	if (ptr == NULL)
	{
		return;
	}
	stack<BtNode*> st;

	while (ptr != NULL || !st.empty())
	{
		while (ptr != NULL)
		{
			st.push(ptr);
			ptr = ptr->leftchild;
		}
		ptr = st.top();
		st.pop();
		cout << ptr->data << " ";
		ptr = ptr->rightchild;
	}
	cout << endl;
}

//非递归的后序遍历
//法一：
void NicePastOrder(BtNode* ptr)
{
	if (ptr == NULL)
	{
		return;
	}
	stack<BtNode*> st;
	BtNode* tag = NULL;
	while (ptr != NULL || !st.empty())
	{
		while (ptr != NULL)
		{
			st.push(ptr);
			ptr = ptr->leftchild;
		}
		ptr = st.top();
		st.pop();
		if (ptr->rightchild == NULL || ptr->rightchild == tag)
		{
			cout << ptr->data << " ";
			tag = ptr;
			ptr = NULL;
		}
		else
		{
			st.push(ptr);
			ptr = ptr->rightchild;
		}
	}
	cout << endl;
}
//法二：
struct StkNode
{
	int popnum;
	BtNode* pnode;
public:
	StkNode(BtNode* p = NULL) : popnum(0),pnode(p){}
};
void StkNicePastOrder(BtNode* ptr)
{
	if (ptr == NULL)
		return;
	stack<StkNode> st;
	st.push(StkNode(ptr));
	while (!st.empty())
	{
		StkNode node = st.top();
		st.pop();
		if (++node.popnum == 3)
		{
			cout << node.pnode->data << " ";
		}
		else
		{
			st.push(node);
			if (node.popnum == 1 && node.pnode->leftchild != NULL)
			{
				st.push(StkNode(node.pnode->leftchild));
			}
			else if (node.popnum == 2 && node.pnode->rightchild != NULL)
			{
				st.push(StkNode(node.pnode->rightchild));
			}
		}
	}
	cout << endl;
}

创建二叉树

struct BtNode* Buynode()//创建一个结点
{
	BtNode* s = (BtNode*)malloc(sizeof(*s));
	if (NULL == s)
		exit(EXIT_FAILURE);
	memset(s, 0, sizeof(*s));
	return s;
}
BtNode* CreateTree()
{
	ElemType ch;
	BtNode* s = NULL;
	cin >> ch;
	if (ch != END)
	{
		s = Buynode();
		s->data = ch;
		s->leftchild = CreateTree();
		s->rightchild = CreateTree();
	}
	return s;
}

利用先序和中序创建二叉树

int FindIs(char* is, int n, char val)
{
	int pos = -1;
	for (int i = 0; i < n; i++)
	{
		if (is[i] == val)
		{
			pos = i;
			break;
		}
	}
	return pos;
}
BtNode* CreatePI(char* ps, char* is, int n)
{
	BtNode* s = NULL;
	if (n > 0)
	{
		s = Buynode();
		s->data = ps[0];
		int pos = FindIs(is, n, ps[0]);
		if (pos == -1)
		{
			exit(EXIT_FAILURE);
		}
		s->leftchild = CreatePI(ps + 1, is, pos);
		s->rightchild = CreatePI(ps + 1 + pos, is + 1 + pos, n - pos - 1);
	}
	return s;
}
BtNode* CreateTreePI(char* ps, char* is, int n)//利用先序和中序创建二叉树
{
	BtNode* s = NULL;
	if (ps != NULL && is != NULL && n > 0)
	{
		s = CreatePI(ps, is, n);
	}
	return s;
}

利用中序和后序创建二叉树

int FindIs(char* is, int n, char val)
{
	int pos = -1;
	for (int i = 0; i < n; i++)
	{
		if (is[i] == val)
		{
			pos = i;
			break;
		}
	}
	return pos;
}
BtNode* CreateIL(char* is, char* ls, int n)
{
	BtNode* s = NULL;
	if (n > 0)
	{
		s = Buynode();
		s->data = ls[n - 1];
		int pos = FindIs(is, n, ls[n - 1]);
		if (pos == -1)
			exit(EXIT_FAILURE);
		s->leftchild = CreateIL(is, ls, pos);
		s->rightchild = CreateIL(is + pos + 1, ls + pos, n - pos - 1);
	}
	return s;
}
BtNode* CreateTreeIL(char* is, char* ls, int n)//利用中序和后序创建二叉树
{
	BtNode* root = NULL;
	if (is != NULL && ls != NULL && n > 0)
	{
		root = CreateIL(is, ls, n);
	}
	return root;
}

遍历字符串
1.层次遍历 == 心跳打印
/利用一个队列进行操作/

void NiceLevelOrder(BtNode* ptr)
{
	if(ptr == NULL)
	{
		return ;
	}
	queue<BtNode*> qu;
	qu.push(ptr);
	while(!qu.empty())
	{
		ptr = qu.front();//取队头元素
		qu.pop();//删除队头元素
		cout<<ptr->data<<" ";
		if(ptr->leftchild != NULL)
		{
			qu.push(ptr->leftchild);
		}
		if(ptr->rightchild != NULL)
		{
			qu.push(ptr->rightchild);
		}
		cout<<endl;
	}
}

2.“Z字形遍历”
/利用两个栈来进行操作/

void ZNiceLevelOrder(BtNode* ptr)
{
	if(ptr == NULL)
	{
		return ;
	}
	stack<BtNode*> lst;
	stack<BtNode*> rst;
	lst.push(ptr);
	while(!lst.empty() || !rst.empty())
	{
		while(!lst.empty())
		{
			ptr = lst.top();
			lst.pop();
			cout<<ptr->data<<" ";
			if(ptr->leftchild != NULL)
			{
				rst.push(ptr->leftchild);
			}
			if(ptr->rightchild != NULL)
			{
				rst.push(ptr->rightchild);
			}
		}
		while(!rst.empty())
		{
			ptr = rst.top();
			rst.pop();
			cout<<ptr->data<<" ";
			if(ptr->rightchild != NULL)
			{
				lst.push(ptr->rightchild);
			}
			if(ptr->leftchild != NULL)
			{
				lst.push(ptr->leftchild);
			}
		}
	}
	cout<<endl;
}

计算二叉树结点的个数

int GetSize(BtNode* ptr)
{
	if(ptr == NULL)
	{
		return 0;
	}
	else
	{
		return GetSize(ptr->leftchild) + GetSize(ptr->rightchild) + 1;
	}
}

计算二叉树的深度

int Get_Depth(BtNode* ptr)
{
	if(ptr == NULL)
	{
		return 0;
	}
	else
	{
		return std::max(Get_Depth(ptr->leftchild),Get_Depth(ptr->rightchild)) + 1;
	}
}

寻找某结点的值

法一：利用先序遍历进行寻找（比较）
BtNode* Findvalue(BtNode* ptr,ElemType val)
{
	if(root == NULL)
	{
		return NULL;
	}
	stack<BtNode*> st;
	st.push(ptr);
	while(!st.empty())
	{
		ptr = st.top();
		st.pop();
		if(ptr->data == val)
		{
			return ptr;
		}
		if(ptr->leftchild != NULL)
		{
			st.push(ptr->leftchild);
		}
		if(ptr->rightchild != NULL)
		{
			st.push(ptr->rightchild);
		}
	}
	return NULL;
}

//法二：
BtNode* FindValue(BtNode* ptr,ElemType val)
{
	if(ptr == NULL || ptr->data == val)
	{
		return ptr;
	}
	else
	{
		BtNode* p = FindValue(ptr->leftchild,val);
		if(nullptr == p)
		{
			p = FindValue(ptr->rightchild,val);
		}
		return p;
	}
}

判断是否为满二叉树

//法一：
bool Is_Full(BtNode* ptr)
{
	return (ptr == NULL) && Is_Full(ptr->leftchild) && Is_Full(ptr->rightchild) && Get_Depth(ptr->leftchild) == Get_Depth(ptr->rightchild);
}
//法二：
bool Is_Full_BinaryTree(BtNode* ptr)
{
	bool res = true;
	if(ptr == NULL)
	{
		return res;
	}
	queue<BtNode*> qu1,qu2;
	int n = 1;
	qu1.push(ptr);
	while(!qu1.empty() || !qu2.empty())
	{
		if(n != qu1.size())
		{
			res = false;
			break;
		}
		while(!qu1.empty())
		{
				BtNode* p = qu1.front();
				qu1.pop();
				if(p->leftchild != NULL)
				{
					qu2.push(p->leftchild);
				}
				if(p->rightchild != NULL)
				{
					qu2.push(p->rightchild);
				}
				n += n;
				if(n != qu2.size())
				{
					res = false;
					break;
				}
				while(!qu2.empty())
				{
					BtNode* p = qu2.front();
					qu2.pop();
					if(p->leftchild != NULL)
					{
						qu1.push(p->leftchild);
					}
					if(p->rightchild != NULL)
					{
						qu1.push(p->rightchild);
					}
				}
				n += n;
	   	}
	   	return res;
}

判断是否为完全二叉树

bool Is_Comp_BonaryTree(BtNode* ptr)
{
	bool res = true;
	if(ptr == nullptr)
	{
		return res;
	}
	queue<BtNode*> qu;
	qu.push(ptr);
	while(!qu.empty())
	{
		BtNode* p = qu.front();
		qu.pop();
		if(p == NULL)
		{
			break;
		}
		qu.push(p->leftchild);
		qu.push(p->rightchild);
		}
		while(!qu.empty())
		{
			BtNode* p = qu.front();
			qu.pop();
			if(p != NULL)
			{
				res = false;
				break;
			}
		}
		return res;
}

求最大路径和并输出路径

void PrintPath(BtNode* ptr,int val,vector<int>& vec)
{
	if(ptr == NULL)
	{
		return;
	}
	vec.push_back(ptr->data);
	if(ptr->leftchild == NULL && ptr->rightchild == NULL)
	{
		int sum = 0;
		for(int i = 0; i < vec.size(); i++)
		{
			sum += vec[i];
		}
		if(sum == val)
		{
			for(int i = 0; i < vec.size(); i++)
			{
				cout<<vec[i]<<" ";
			}
			cout<<endl;
		}
	}
	PrintPath(ptr->leftchild,val,vec);
	PrintPath(ptr->rightchild,val,vec);
	vec.pop_back();
}

将二叉搜索树变为二叉链表

//法一：利用非递归的中序遍历改成链式的过程
void CNiceInOrder(BtNode* ptr)
{
	if(ptr == NULL)
	{
		return ;
	}
	stack<BtNode*> st;
	BtNode* head = NULL:
	BtNode* nt = NULL;
	while(!st.empty() || ptr != NULL)
	{
		while(ptr != NULL)
		{
			st.push(ptr);
			ptr = ptr->leftchild;
		}
		ptr = st.top();
		st.pop();
		if(head == NULL)
		{
			head = ptr;
			nt = ptr;
		}
		else
		{
			nt->rightchild = ptr;
			ptr->leftchild = nt;
			nt = ptr;
		}
		ptr = ptr->rightchild;
	}
	cout<<endl;
}
//法二：利用递归的中序遍历改为链式
void InList(BtNode* ptr,BtNode*& pre,BtNode*& head)
{
	if(ptr != NULL)
	{
		InList(ptr->leftchild,pre);
		if(pre != NULL)
		{
			pre->rightchild = ptr;
			ptr->leftchild = pre;
		}
		else
		{
			head = ptr;
		}
		pre = ptr;
		InList(ptr->rightchild,pre,head);
	}
}
BtNode* InOrder_Lt(BtNode* ptr)
{
	if(ptr != NULL)
	{
		return NULL;
	}
	BtNode* pre = NULL;
	BtNode* head = NULL;
	InList(ptr,pre,head);
	return head;
}

//将二叉搜索树变成倒过来的链式存储

BtNode* RCNiceInOrder(BtNode* ptr)
{
	if(ptr == NULL)
	{
		return NULL;
	}
	stack<BtNode*> st;
	BtNode* head = NULL;
	BtNode* nt = NULL;
	while(!st.empty() || ptr != NULL)
	{
		while(ptr != NULL)
		{
			st.push(ptr);
			ptr = ptr->leftchild;
		}
		ptr = st.top();
		st.pop();
		if(head == NULL)
		{
			head = ptr;
		}
		else
		{
			nt = ptr->rightchild;
			head->leftchild = ptr;
			ptr->rightchild = head;
			head = ptr;
		}
		ptr = nt;
	}
	return head;
}
马兰花呀
关注
  • 1
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
数据结构之树和二叉树
花&败
05-19 1813
对于树这种数据结构，使用最频繁的是二叉树。每个节点最多只有2个子节点的树，叫做二叉树。二叉树中，每个节点的子节点作为根的两个子树，一般叫做节点的左子树和右子树。任意节点左子树如果不为空，则左子树中节点的值均小于根节点的值任意节点右子树如果不为空，则右子树中节点的值均大于根节点的值任意节点的左右子树，也分别是二叉搜索树没有键值相等的节点基于二叉搜索树的这种特点，在查找某个节点的时候，可以采取类似于二分查找的思想，快速找到某个节点。
数据结构与算法——树与二叉树篇详解
♚焕蓝·未来的博客
05-01 4062
树型结构是一类重要的非线性结构。树型结构是结点之间有分支，并且具有层次关系的结构，它非常类似于自然界中的树。树结构在客观世界国是大量存在的，例如家谱、行政组织机构都可用树形象地表示。树在计算机领域中也有着广泛的应用，例如在编译程序中，用树来表示源程序的语法结构；在数据库系统中，可用树来组织信息；在分析算法的行为时，可用树来描述其执行过程。
二叉树-树和二叉树的基本概念
C_TQH的博客
05-10 2276
前言： 本篇主要记录树和二叉树的基本概念 目录 1.树概念及结构 1.1树的概念 1.2 树的相关概念 1.3 树的表示 1.4 树在实际中的运用（表示文件系统的目录树结构） 2.二叉树概念及结构 2.1概念 2.2现实中的二叉树： 2.3 特殊的二叉树： 2.4 二叉树的性质 2.4.1 5道练习加深领悟 2.5 二叉树的存储结构 2.5.1 顺序存储 2.5.2 链式存储 3.总结 1.树概念及结构 1.1树的概念 树是一种非线性的数据结构，它是由n（n&.
【数据结构】树和二叉树详细分析（全）
码农研究僧的博客
06-23 9513
树的定义 树(Tree)是n(n>=0)个结点的有限集，它或为空树(n= 0); 或为非空树，对于非空树T: (1)有且仅有一个称之为根的结点； (2)除根结点以外的其余结点可分为 m(m>O）个互不相交的有限集 T1 T2 , …Tm，其中每一个集合本身又是一棵树，并且称为根的子树(SubTree)。 树的基本术语 ...
数据结构——树与二叉树
yue152152的博客
04-10 2897
从树到二叉树的概念及结构，文末附上了二叉树顺序结构和链式结构实现的入口
树和二叉树源码
11-08
在计算机科学领域，树和二叉树是两种重要的数据结构，它们在许多应用中发挥着核心作用，如文件系统、数据库索引、编译器设计等。本篇将深入探讨这些概念及其相关的算法。 首先，我们要理解“树”这一概念。树是一种...
python数据结构树和二叉树简介
01-20
一、树的定义 树形结构是一类重要的非线性结构。树形结构是结点之间有分支，并具有层次关系的结构。...它或者是空集，或者是由一个根和称为左、右子树的两个不相交的二叉树组成。特点：（1）二叉树是有序树，
树和二叉树课件
01-31
此外，满二叉树和完全二叉树有特殊的数组表示方法，可以节省空间并优化某些操作。 课件中还涉及到了二叉树的实现，包括创建、插入、删除等基本操作。例如，二叉搜索树（Binary Search Tree）是一种特殊的二叉树，...
实验三 树和二叉树.rar
03-01
在数据结构的学习中，树和二叉树是两个至关重要的概念。它们被广泛应用于计算机科学的各个领域，如操作系统、数据库、编译器设计、图形学等。本实验旨在帮助初学者深入理解树与二叉树的基本概念，通过编写代码来实现...
c代码-树和二叉树
07-16
在IT领域，树和二叉树是数据结构中的基本概念，它们在算法设计和软件开发中扮演着重要角色。C语言作为系统级编程的主要工具，常用于实现这些数据结构。以下将详细介绍树和二叉树的基本概念，以及如何在C语言中实现...
树和二叉树hahahhahaha
最新发布
05-05
树和二叉树hahahhahaha
树和二叉树详细讲解
关注我！带你一路 "狂飙" 到底！
06-25 5299
树(Tree)是非线性结构的典型代表。在树型数据结构中，数据元素之间存在一对多的关系。树是由n(n>0)个有限结点组成一个具有层次关系的集合。当n=0时，称为空树。之所以把这些由层次关系的结点集合称之为树，主要是因为其在形状上看起来特别像一棵倒挂的树，即树根朝上，树叶朝下。首先壹哥给出树结构所具备的特点：(1). 树有且仅有一个特定的根(Root)结点。(2). 除了根结点，其余每个结点都有且只有一个直接前驱，这个前驱结点叫父结点(3). 树的每个结点都可以有多个后继，叫做子结点。没有后继的结点称为。
数据结构（树与二叉树）
jxttutu的博客
03-12 4452
5.1.1树和二叉树的定义 树：是n(n>=0)个结点的有限集，或为空树(n==0),或为非空树 非空树满足：1.有且仅有一个称之为根的结点 2.除根节点之外的其余结点可分为m(m>0)个互不相交的有限集，其中每个集合本身又是一棵树，并且称为根的子树。（递归定义） 5.1.2树的基本术语： 1.结点：树中的一个独立单元，包含一个数据元素和若干个指向子树的分支 2.根结点：非空树中无前趋的结点 ...
数据结构--树与二叉树
qq_37672171的博客
01-03 556
二、树的性质 三、二叉树 二叉树的性质 三、二叉树的存储结构 四、二叉树的遍历 线索二叉树 树和森林（树的存储） 二叉排序树 平衡二叉树 哈弗曼树 ...
树和二叉树的概念与应用
"该资源为‘树和二叉树.ppt’，涵盖了树的基本概念、二叉树的性质、遍历、二叉树与树的转换、线索二叉树、赫夫曼树及其编码等内容，适合学习数据结构的IT专业人员。" 在计算机科学中，树是一种非常重要的数据结构，...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值