二叉树的基本用法总结

最新推荐文章于 2025-07-04 12:08:04 发布
原创 最新推荐文章于 2025-07-04 12:08:04 发布 · 2.2k 阅读 · 5 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。

本文总结了二叉树的基础操作，包括树的创建、删除及四种遍历方式（先序、后序、中序、层次遍历）。此外，还涵盖了节点查找、插入、寻找兄弟节点与父节点，计算树的深度、叶子数、节点数，以及树的复制、对比和满树、完全树的判断。虽然代码质量有待提高，但实现了所有基本功能。

摘要生成于 C知道 ，由 DeepSeek-R1 满血版支持， 前往体验 >

下面列举了二叉树的一些常用方法，水平有限 代码写的质量不怎么地，基本功能是实现了的

功能有：树的建立、删除；

先序、后序、中序、层次遍历；

节点的查找，节点的插入；

兄弟的查找，父节点的查找；

计算树的深度、叶子数、节点数；

树的拷贝；

判断两个树是否相等；

判断是否是满树、完全树；

#include<iostream>
#include<stack>
#include<stdlib.h>
#include<math.h>
#include<deque>
using namespace std;

typedef struct BTreeNode
{
  char data;
  struct BTreeNode * LeftChild;
  struct BTreeNode * RightChild;
}node,*root;

void CreateTree(root &root_node)//创建树 指针的引用 #代表空节点  先序输入  如ABD##E##CF##G##（中间不要有空格）
{
	char c='#';
	c=getchar();
	if (c=='#')
	{
		root_node=NULL;
		return ;
	}
   //否则
    root_node=(root)malloc(sizeof(node));
	root_node->data=c;
	CreateTree(root_node->LeftChild);
	CreateTree(root_node->RightChild);
	return ;

}

void PreOrder(root root_node)//先序输出
{
  if (root_node==NULL)
  {
	  return;
  }
  else
  {
	  cout<<root_node->data;
	  PreOrder(root_node->LeftChild);
	  PreOrder(root_node->RightChild);
  }
}

void InOrder(root root_node)//中序
{
	if (root_node==NULL)
	{
		return;
	}
	else
	{
		InOrder(root_node->LeftChild);
		cout<<root_node->data;
		InOrder(root_node->RightChild);
	}

}

void PostOrder(root root_node)//后序
{
  if (root_node==NULL)
  {
	  return;
  }
  else
  {
	  PostOrder(root_node->LeftChild);
	  PostOrder(root_node->RightChild);
	  cout<<root_node->data;
  }
}

void LevelOrder(root root_node)//层次遍历
{
	deque<root>node_list;
	if (root_node==NULL)
	{
		return;
	}
	else
		node_list.insert(node_list.begin(),root_node);

	while(node_list.size()!=0)
	{
		root node_temp=node_list[0];
		node_list.pop_front();
		cout<<node_temp->data;

		if (node_temp->LeftChild!=NULL)
		{
			node_list.push_back(node_temp->LeftChild);
		}
		if (node_temp->RightChild!=NULL)
		{
			node_list.push_back(node_temp->RightChild);
		}

	}
	

}

bool IsEmpty(root root_node) //判空
{
	return ((root_node==NULL)?true:false);
}

void DestoryTree(root &root_node)//删除以root_node为根的树
{
  if (root_node==NULL)
  {
	  return;
  }
  else
  {
	  DestoryTree(root_node->LeftChild);
	  DestoryTree(root_node->RightChild);
	  free(root_node);
	  root_node=NULL;
  }
}

root GetParent(root root_node,root p)//找p的双亲  root_node为树根节点
{
	root root_q;
	if (root_node==NULL || p==NULL)
	{
		root_q=NULL;
		return root_q;
	}

  if (root_node->LeftChild==p || root_node->RightChild==p)
  {
	  return root_node;
  }
  else
  {
    root_q=GetParent(root_node->LeftChild,p);
	if (root_q!=NULL)
	{
		return root_q;
	}

	root_q=GetParent(root_node->RightChild,p);
	return root_q;
  }
}

root GetPoint(root root_node,char c)//在树root_node中找到节点值为c的节点 返回其指针
{
	root q;
   if(root_node==NULL)
	   return NULL;
   if(root_node->data==c)
	   return root_node;
   else
   {
	   q=GetPoint(root_node->LeftChild,c);
	   if(q!=NULL)
		   return q;

	   q=GetPoint(root_node->RightChild,c);
		   return q;
   }
}

root GetLeftBrother(root root_node,root p)//找p的左侧兄弟
{

	if (root_node==NULL || p==NULL)
	{
		return NULL;
	}
	root pr_node=GetParent(root_node,p);
	if (pr_node==NULL || p==pr_node->LeftChild)
	{
		return NULL;
	}
	else 
	{
		return pr_node->LeftChild;
	}

}

root GetRightBrother(root root_node,root p)//找p的右侧兄弟
{
	if (root_node==NULL || p==NULL)
	{
		return NULL;
	}
	root pr_node=GetParent(root_node,p);
	if (NULL==pr_node || p==pr_node->RightChild)
	{
		return NULL;
	}
	else
		return pr_node->RightChild;

}

int GetDepth(root root_node)//计算树的深度  
{
	int n_left;
	int n_right;
  if (root_node==NULL)
  {
	  return 0;
  }
  else
  {
	  n_left=GetDepth(root_node->LeftChild);
	  n_right=GetDepth(root_node->RightChild);
	  return (n_left>n_right?n_left:n_right)+1;

  }
}

int GetLeaves(root root_node)//计算叶子数
{
	int leaves;
	int L_leaves;
	int R_leaves;
	if(root_node==NULL)
		return 0;
	if (root_node->LeftChild ==NULL && root_node->RightChild==NULL)
	{
       return 1;
	}
	else
	{
		L_leaves=GetLeaves(root_node->LeftChild);
		R_leaves=GetLeaves(root_node->RightChild);
		leaves=L_leaves+R_leaves;
		return leaves;
	}
}

void CopyTree(root root_node1,root &root_node2)//拷贝树 root_node1拷贝到root_node2
{
	root newnode;
	if (root_node1==NULL)
	{
		root_node2=NULL;
		return;
	}
	root_node2=(root)malloc(sizeof(node));
	root_node2->data=root_node1->data;
	CopyTree(root_node1->LeftChild,root_node2->LeftChild);
	CopyTree(root_node1->RightChild,root_node2->RightChild);
   
}

void InsertLeftChild(root &node_p,char c)//为节点node_p插入一个左儿子 值为c,node_p原来的的左儿子作为新节点的左儿子
{
	if (node_p==NULL)
	{
		return;
	}

	root left_child=node_p->LeftChild;
   root newnode=(root)malloc(sizeof(node));
   node_p->LeftChild=newnode;
   newnode->LeftChild=left_child;
   newnode->data=c;
   newnode->RightChild=NULL;
}
void InsertRightChild(root &node_p,char c)//为节点node_p插入一个右儿子 值为c，node_p原来的的右儿子作为新节点的右儿子
{
	if (node_p==NULL)
	{
		return;
	}

	root right_child=node_p->RightChild;
	root newnode=(root)malloc(sizeof(node));
	node_p->RightChild=newnode;
	newnode->RightChild=right_child;
	newnode->data=c;
	newnode->LeftChild=NULL;
}

bool IsTreeEqual(root root_node1,root root_node2)//判断两个树是否相等
{
   if (root_node1==NULL && root_node2==NULL)
   {
	   return true;
   }
   if (root_node1==NULL && root_node2!=NULL)
   {
	   return false;
   }
   if (root_node1!=NULL && root_node2==NULL)
   {
	   return false;
   }

   if (root_node1->data==root_node2->data && IsTreeEqual(root_node1->LeftChild,root_node2->LeftChild)==true && IsTreeEqual(root_node1->RightChild,root_node2->RightChild)==true)
   {
	   return true;
   }
   else 
	   return false;

}

int GetNodeCount(root root_node)//计算树的节点数
{
	int L_count,R_count,ALL_count;
	if (root_node==NULL)
	{
		return 0;
	}
	else
	{
		L_count=GetNodeCount(root_node->LeftChild);
		R_count=GetNodeCount(root_node->RightChild);
        ALL_count=L_count+R_count+1;
		return ALL_count;
	}

}

bool IsCompleteTree(root root_node)//是否是完全树
{
	deque<root>node_list;
	if (root_node==NULL)
	{
		return false;
	}
	else
		node_list.insert(node_list.begin(),root_node);

	int i=0;
	root temp;
	while(i<node_list.size())//所有节点全部进入队列  包括空节点
	{
		temp=node_list[i];
		if (temp!=NULL)
		{
			node_list.push_back(temp->LeftChild);
			node_list.push_back(temp->RightChild);
		}
		i++;
	}

	i=0;
	while (i<node_list.size())//查找空节点后面是否会有非空节点  若有则说明不是完全树
	{
		if (node_list[i]==NULL)
		{
			int j=i;
			while (j<node_list.size())//查找空节点后面是否会有非空节点
			{
				if (node_list[j]!=NULL)
				{
					return false;
				}
				j++;
			}
			return true;
		}
		else
		{
			i++;
			continue;
		}
	}
   return false;
} 



bool IsFullTree(root root_node)//是否是满树
{
   int count=GetNodeCount(root_node);//节点数
   int depth=GetDepth(root_node);//深度
   double a=2.0;
   int num=(int)(pow(a,double(depth)))-1;
   if (num==count)//节点数是否等于2^k-1
   {
	   return true;
   }
   else
	   return false;

}


void EatLine()//消除回车
{
  while(getchar()!='\n')
	{
	}
}


void main()//用来测试
{
    char c;
	char d;
	root root_node;
	root root_node2=NULL;

	CreateTree(root_node);
	EatLine();

	bool empty;
	empty=IsEmpty(root_node);
	if (empty==true)
	{
		cout<<"the tree is empty\n";
	}
	else
		cout<<"the tree is not empty\n";

	int depth=GetDepth(root_node);
	cout<<"the depth of tree is "<<depth<<endl;

	int leaves=GetLeaves(root_node);
	cout<<"the COUNT of leaves is "<<leaves<<endl;

	bool comlete=IsCompleteTree(root_node);
	if (comlete==true)
	{
		cout<<"the tree is comlete\n";
	}
	else
		cout<<"the tree is not comlete\n";

	bool full=IsFullTree(root_node);
	if (full==true)
	{
		cout<<"the tree is full\n";
	}
	else
		cout<<"the tree is not full\n";

	

	cout<<"pre:\n";
	PreOrder(root_node);
	cout<<endl;
	cout<<"In:\n";
	InOrder(root_node);
	cout<<endl;
	cout<<"post:\n";
	PostOrder(root_node);
	cout<<endl;
	cout<<"level:\n";
	LevelOrder(root_node);
	cout<<"\n"<<endl;

	CopyTree(root_node,root_node2);
	cout<<"copy tree in pre:\n";
	PreOrder(root_node2);
	cout<<endl;
	cout<<"copy tree in In:\n";
	InOrder(root_node2);
	cout<<endl;
	cout<<"copy tree in post:\n";
	PostOrder(root_node2);
	cout<<endl;
	cout<<"copy tree in level:\n";
	LevelOrder(root_node);
	cout<<"\n"<<endl;

	if(IsTreeEqual(root_node,root_node2)==true)
	{
		cout<<"the two tree is equal\n";
	}
	else
		cout<<"the two tree is not equal\n";



	cout<<"input the node and char wanted insert in tree root_node2(end of #)\n";//插入左儿子
	while (1)
	{
		cout<<"input node ：";//在哪个节点插入
		c=getchar();
		EatLine();

		if(c=='#')
			break;
		cout<<"input char wangted insert ：";//插入什么值
		d=getchar();
		EatLine();

		if(d=='#')
			break;

		root temp=GetPoint(root_node2,c);
		InsertLeftChild(temp,d);
		cout<<"InsertLeftChild "<<d<<" behead of "<<c<<" in pre:\n";
		PreOrder(root_node2);
		cout<<"\n"<<endl;

		int depth=GetDepth(root_node2);
		cout<<"the depth of tree is "<<depth<<endl;

		int leaves=GetLeaves(root_node2);
		cout<<"the COUNT of leaves is "<<leaves<<endl;

		if(IsTreeEqual(root_node,root_node2)==true)
		{
			cout<<"the two tree is equal\n";
		}
		else
			cout<<"the two tree is not equal\n";


		comlete=IsCompleteTree(root_node2);
		if (comlete==true)
		{
			cout<<"the tree is comlete\n";
		}
		else
			cout<<"the tree is not comlete\n";
 
	}

	cout<<"\n"<<endl;



	cout<<"input the char wanted delete in tree root_node2(end of #)\n";//删除子树
	while (1)
	{
		cout<<"input char wangted delete ：";
		d=getchar();
		EatLine();

		if(d=='#')
			break;

		root P_delete=GetPoint(root_node2,d);//找到要删除的节点的指针
		root temp=P_delete;//备份这个指针
		root p=GetParent(root_node2,P_delete);//找到此点的父节点
		DestoryTree(P_delete);//删掉这个节点子树
		if (p->LeftChild==temp)//在树中把这个节点指针赋值为空
		{
			p->LeftChild=NULL;
		}
		else
			p->RightChild=NULL;

		cout<<"after DestoryTree "<<d<<" in pre:\n";
		PreOrder(root_node2);
		cout<<"\n";

		depth=GetDepth(root_node2);
		cout<<"the depth of tree is "<<depth<<endl;

		leaves=GetLeaves(root_node2);
		cout<<"the COUNT of leaves is "<<leaves<<endl;

		if(IsTreeEqual(root_node,root_node2)==true)
		{
			cout<<"the two tree is equal\n";
		}
		else
			cout<<"the two tree is not equal\n"<<endl;

		comlete=IsCompleteTree(root_node2);
		if (comlete==true)
		{
			cout<<"the tree is comlete\n";
		}
		else
			cout<<"the tree is not comlete\n";

		bool full=IsFullTree(root_node2);
		if (full==true)
		{
			cout<<"the tree is full\n";
		}
		else
			cout<<"the tree is not full\n";
	}
        


	cout<<"input the char wanted find in tree root_node(end of #)\n";//查找节点
	while((c=getchar())!='#')
	{
	 EatLine();
     root q_find=GetPoint(root_node,c);
	 root parent=GetParent(root_node,q_find);
	 if(parent!=NULL)
		cout<<"parent of "<<c<<" is："<<parent->data<<endl;
	 else
		cout<<"can't find parent"<<endl;
	 
	 root left_brother=GetLeftBrother(root_node,q_find);
	 if (left_brother!=NULL)
	 {
		 cout<<"left brother of "<<c<<" is："<<left_brother->data<<endl;
	 }
	 else
         cout<<"can't find left brother"<<endl;

	 root right_brother=GetRightBrother(root_node,q_find);
	 if (right_brother!=NULL)
	 {
		 cout<<"right brother of "<<c<<" is："<<right_brother->data<<endl;
	 }
	 else
		 cout<<"can't find right brother"<<endl;

	}
	

	

	system("pause");
}


简单二叉树的基本功能(一)
hjl_heart的博客
04-29 1084
本文介绍了二叉树（结构较简单的那种，没考虑很多因素进去）的基本实现功能:1.二叉树的插入2.二叉树的查询3.二叉树的前序遍历、中序遍历、后序遍历这里我首先建立了一个节点类://节点类 public class Node { //数据项 public int data; public String sdata; //左孩子 public Node leftChild; //右孩子 ...
二叉树的基本运算实验报告C语言,实验三 二叉树基本操作与应用实验
weixin_31690531的博客
05-18 5062
实验三二叉树基本操作与应用实验第三次实验主要包括两部分内容：1.二叉树基本操作实验；2.二叉树应用—赫夫曼树与赫夫曼编码实验。基本操作包括存储结构建立和遍历算法，本文只给出部分参考程序，请大家尽量完成多数基本操作。第一部分 基本操作实验[问题描述] 二叉树采用二叉链表作存储结构，试编程实现二叉树的如下基本操作1．按先序序列构造一棵二叉链表表示的二叉树T；2．对这棵二叉树进行遍历：先序、中序、后序以...
二叉树的用法
红叶的专栏
03-09 447
计算二叉树深度int BinTreeDepth(ChainBinTree *bt)//bt:表示父节点指针 { int dep1,dep2; if(bt==NULL) return 0;//对于空树，深度为0 else { dep1=BinTreeDepth(bt->left);//左子树深度（递归调用） dep2=Bi
二叉树(Binary tree)
最新发布
weixin_73966418的博客
07-04 1136
本文系统介绍了树型结构尤其是二叉树的基本概念、实现方法及其应用。树作为一种非线性数据结构，在计算机科学中有着广泛应用。文章首先阐述了树的基本定义、术语和表示方法，然后重点探讨了二叉树的特性，包括完全二叉树和满二叉树的区别、二叉树的遍历算法（前序、中序、后序、层序）及其Java实现。通过详细的代码示例，展示了二叉树的创建、遍历、节点计数等基本操作。同时，文章也介绍了二叉树的数学性质、存储方式（数组与链式结构）以及在实际问题中的应用。掌握二叉树需要理解递归思想，将复杂问题分解为子问题处理。
浅谈二叉树的使用
Lzinner的博客
05-03 396
2018/5/31.说在前面:由于数据结构已经学完了树，对于这种比较难的结构，说一点看法2.二叉树：1.由一个根节点和两个互不相较的子二叉树（左子树和右子树）组成的树2.相关操作介绍：1.创建结构体实现树的建立对于树而言，依旧采取结构体指针的方式，树拥有着一个左子树，一个右子树和一个储存数据的位置typedef struct Node { int data; struct Node *left...
二叉树的基本功能实现
zzp0753的博客
08-10 903
整理了一下关于二叉树的各种操作，为了方便直接全程使用排序二叉树。 涉及到的有如下的几种功能： **1、定义二叉树数据结构； 2、由前序遍历及中序遍历构造二叉树； 3、将一组数构造成二叉搜索树； 4、求二叉树的高度； 5、查找某个结点的递归与非递归实现； 6、在指定位置插入的实现（递归与非递归）； 7、寻找最大、最小结点的递归与非递归实现； 8、删除指定结点；** 首先是定义相应的
实验四 二叉树基本操作的实现
12-18
在本实验中，我们将深入探讨数据结构中的一个重要概念——二叉树，并实现其基本操作。二叉树是一种非线性的数据结构，它由一个有限集合的节点构成，每个节点最多有两个子节点，通常称为左子节点和右子节点。这个实验...
PHP排序二叉树基本功能实现方法示例
10-18
在本文中，我们将深入探讨如何使用PHP实现排序二叉树的基本功能。首先，我们要了解排序二叉树的概念。排序二叉树是一种特殊的二叉树，其中每个节点的左子节点的值小于其父节点，而右子节点的值大于其父节点。这种...
C++二叉树基本操作实验报告.doc
06-14
最后，通过上述程序设计与分析，我们可以总结出C++实现二叉树基本操作的流程和方法，这不仅涉及到二叉树结构的建立和遍历，还包括如何递归地访问树节点以及如何使用栈来实现非递归遍历等重要技术点。掌握这些内容...
使用C语言构建基本的二叉树数据结构
09-03
在本文中，我们将深入探讨如何使用C语言构建基本的二叉树数据结构，特别关注根据前序序列和中序序列重建二叉树的方法。二叉树是一种非线性数据结构，由节点组成，每个节点最多有两个子节点，分别称为左子节点和右子...
二叉树的应用二叉树的应用二叉树的应用二叉树的应用二叉树的应用
08-07
二叉树的应用二叉树的应用二叉树的应用二叉树的应用二叉树的应用二叉树的应用二叉树的应用
二叉树的应用
06-12
二叉树的应用 (必做)（二叉树） [问题描述] 　　　编程实现二叉树的建立，先序、中序、后序、层序遍历（递归和非递归方法），二叉树的高度、繁茂度，交换左右子树，统计叶子节点的数目，判断是否为完全二叉树，按树的形态在屏幕上打印输出； [基本要求] （1） 从文件中读入建树信息，树的节点数目不小于20个，树的高度不小于4。 （2） 建树信息采用两行英文字符表示，每个英文字符代表一个结点，第1行为树的先序遍历结果，第2行为树的中序遍历结果。
二叉树个主要功能
11-04
这是我用C++VIrtual 2013编写的，所以运行的时候要在2013环境下运行，否则可能会出现错误。关于这个算法，我主要用结点来构造二叉树的，并在代码中进行了详细的解释。代码还算详细
二叉树的基本操作小结
weixin_34417200的博客
05-28 128
转自：http://www.cnblogs.com/marrywindy/archive/2010/08/21/1805336.html 二叉树的一般操作，实现了下： 主要练习了二叉树的非递归遍历，利用栈，和队列来完成。算法思想，没描述清楚，表达能力很差...崩溃.... 代码 #include "stdio.h" #include "malloc.h" #define M...
二叉树的基本使用
08-02 1146
创建树，前序遍历，中序遍历，后序遍历，查找二叉树结点个数，查找二叉树叶子结点个数，查找二叉树度数为1的结点的个数 #include "iostream" using namespace std; struct tree { int data; tree *left,*right; }; class Tree { static int n; st
二叉树的一些功能
weixin_51382726的博客
12-26 645
//寻找值为x的节点的祖先节点 stack<BTNode *> FindAncestorsNode(BTNode *b, ElemType x) { BTNode *p = b, *r; stack<BTNode *> sq; bool flag; do { while (p != NULL) { sq.push(p); p = p->lchild; }
二叉树的构建
li123128的博客
11-10 3566
二叉树是一种非常重要的数据结构。本文总结了二叉树的常见操作：二叉树的构建，查找，删除，二叉树的遍历(包括前序遍历、中序遍历、后序遍历、层次遍历)，二叉搜索树的构造等。
【二叉树基本操作总结1】
cherryDarling7的博客
05-01 1427
已修改，BiTree类少了一个getArray2()声明
掌握C语言中二叉树的基本操作和遍历方法
C语言中的二叉树基本操作是数据结构与算法领域的重要概念之一。二叉树作为一种基础且应用广泛的树形数据结构，在程序设计中扮演着核心角色。二叉树的每个节点最多有两个子节点，通常称为左子节点和右子节点，这使得...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值