二叉树（Binary Tree）

最新推荐文章于 2023-06-06 12:19:00 发布
最新推荐文章于 2023-06-06 12:19:00 发布
阅读量164 收藏
点赞数
分类专栏： 二叉树
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_42727102/article/details/89897457
版权
  1. 树（Tree）：非线性数据结构：树，图
  2. 术语：
    根结点（root）：树中没有前驱的结点
    叶子结点（leaf）：没有后继的结点
    双亲结点：是子女结点的前驱
    子女结点：是双亲结点的后继
    兄弟结点：同一个双亲结点的子女之间互称为兄弟结点
    度：结点的度：一个结点的子女个数（叶子结点度为0）
    树的度：树中度值最大的结点的度
    树的深度：树的层次数
  3. 二叉树：度值最大为2的树
    树状结构：
    i：有且只有一个结点无前驱：根结点
    ii：可有多个结点无后继：叶子结点
    iii：除根和叶子外，其余结点只有一个双亲，可有多个子女
  4. 二叉树性质：
    a》任意一棵非空二叉树的叶子结点总比双分支结点多一个
    n0=n2+1
    b》对二叉树按层编号：0,1,2,3…
    编号为i的层最多可放2^i个结点（最大值）
  5. 满二叉树：一棵h层的二叉树的每一层的结点个数都达到最大值
    结点个数为：2^h - 1
  6. 完全二叉树：一棵h层的完全二叉树：
    i：前h-1层是满的
    ii：最后一层连续缺失右边的结点
    特点：
    ①h-1<log2(n+1)<=h
    ②n为奇数无单分支结点，n为偶数有单分支结点
    ③满二叉树是特殊的完全二叉树
  7. 理想平衡二叉树（理想树）：前h-1层是满的，最后一层任意摆放
    满二叉树<=完全二叉树<=平衡二叉树
  8. 对任意一棵二叉树按层对结点进行编号：1,2,3… 注意：对缺失结点也要编号
    编号为i的结点：若有左子女：编号为：2i
    若有右子女：编号为：2i+1
    编号为i的结点：双亲编号为：【i/2】
    （i>1）

创建一棵二叉查找树，及前中后序遍历输出

#include<stdio.h>
#include<stdlib.h>
typedef struct node{
	int data;
	struct node *left;
	struct node *right;
}BTNode;
BTNode *CreateBTree(int a[],int n)
{
	BTNode *p,*parent,*root,*c;
	int i;
	//创建根结点 
	root=(BTNode *)malloc(sizeof(BTNode));
	root->data=a[0];
	root->left=root->right=NULL;
	//创建其他结点 
	for(i=1;i<n;i++){
		p=(BTNode *)malloc(sizeof(BTNode));
		p->data=a[i];
		p->left=p->right=NULL;
		c=root;//每次循环都要从根开始遍历判断 
		while(c){
			parent=c;//联动指针 
			if(c->data>p->data){
				c=c->left;
			}
			else{
				c=c->right;
			}
		}
		if(parent->data>p->data){//判断要挂哪边的链 
			parent->left=p;
		}
		else{
			parent->right=p;
		}
	} 
	return root;
} 
void Forder(BTNode *root)
{
	if(root){
		printf("%4d",root->data);
		Forder(root->left);//递归遍历左子树 
		Forder(root->right);//递归遍历右子树 
	}
} 
void Inorder(BTNode *root)
{
	if(root){
		Inorder(root->left);
		printf("%4d",root->data);
		Inorder(root->right);
	}
} 
void Porder(BTNode *root)
{
	if(root){
		Porder(root->left);
		Porder(root->right);
		printf("%4d",root->data);
	}
} 
int main()
{
	int n;
	BTNode *root;
	scanf("%d",&n);
	int *a;
	a=(int *)malloc(sizeof(int)*n);
	for(int i=0;i<n;i++){
		scanf("%d",&a[i]);
	}
	root=CreateBTree(a,n);//创建二叉查找树 
	Forder(root);//前序遍历 
	printf("\n"); 
	Inorder(root);//中序遍历 
	printf("\n"); 
	Porder(root);//后序遍历 
	return 0;
}

//设root指向一棵非空二叉树，在二叉树中查找关键字为key的结点，
//并返回地址，若未找到返回null，设每个结点数据域值不重复

#include<stdio.h>
#include<stdlib.h>
typedef struct node{
	int data;
	struct node *left,*right;
}BTNode;
BTNode *CreateBiTree(int a[],int n)
{
	BTNode *root,*c,*p,*q;
	root=(BTNode *)malloc(sizeof(BTNode));
	root->data=a[0];
	root->left=root->right=NULL;
	for(int i=1;i<n;i++){
		p=(BTNode *)malloc(sizeof(BTNode));
		p->data=a[i];
		p->left=p->right=NULL;
		c=root;
		while(c){
			q=c;
			if(c->data>p->data){
				c=c->left;
			}
			else{
				c=c->right;
			}
		}
		if(q->data>p->data){
			q->left=p;
		}
		else{
			q->right=p;
		}
	}
	return root;
}
BTNode *Findkey(BTNode *r,int key)
{
	BTNode *lr,*rr;
	if(!r)
	{
		return NULL;
	}
		if(r->data==key){
			return r;
		}
		else{
			lr=Findkey(r->left,key);
			rr=Findkey(r->right,key);
			if(lr){
				return lr;
			}
			else if(rr){
				return rr;
			}
			else{
				return NULL;
			}
		}
			
}
int main()
{	
	int *a;
	int n,key;
	printf("请输入数组长度：");
	scanf("%d",&n);
	a=(int *)malloc(n*sizeof(int));
	printf("请输入数组元素：");
	for(int i=0;i<n;i++){
		scanf("%d",&a[i]);
	}
	printf("请输入key值：");
	scanf("%d",&key);
	BTNode *root=CreateBiTree(a,n);
	root=Findkey(root,key);
	if(root){
		printf("%d",root->data); 
	}
	else{
		printf("NULL");
	}
	
	return 0;
}

//按行遍历二叉树的每个结点（非递归）

#include<stdio.h>
#include<stdlib.h>
typedef struct node{
	int data;
	struct node *left,*right;
}BTNode;
BTNode *CreateBiTree(int a[],int n)
{
	BTNode *root,*c,*p,*q;
	root=(BTNode *)malloc(sizeof(BTNode));
	root->data=a[0];
	root->left=root->right=NULL;
	for(int i=1;i<n;i++){
		p=(BTNode *)malloc(sizeof(BTNode));
		p->data=a[i];
		p->left=p->right=NULL;
		c=root;
		while(c){
			q=c;
			if(c->data>p->data){
				c=c->left;
			}
			else{
				c=c->right;
			}
		}
		if(q->data>p->data){
			q->left=p;
		}
		else{
			q->right=p;
		}
	}
	return root;
}
void LevelOrder(BTNode *root)
{
	BTNode **Q,*p;//声明指向存储指针的队列的指针
	int front=0,rear=0;//头指针和尾指针 
	Q=(BTNode **)malloc(sizeof(BTNode *)*1000);//队列空间不为循环队列，要尽可能大
	 Q[++rear]=root;
	 while(front!=rear){//队列不空，执行出队，输出，入队操作 
	 	p=Q[++front];//出队 
	 	printf("%5d",p->data);//输出
	 	if(p->left){
		Q[++rear]=p->left;//左子女入队 
		}
		if(p->right){
		Q[++rear]=p->right;//右子女入队 
		}
	 }
}
int main()
{	
	int *a;
	int n,key;
	printf("请输入数组长度：");
	scanf("%d",&n);
	a=(int *)malloc(n*sizeof(int));
	printf("请输入数组元素：");
	for(int i=0;i<n;i++){
		scanf("%d",&a[i]);
	}
	BTNode *root=CreateBiTree(a,n);//建立二叉排序树 
	LevelOrder(root);//二叉树的层次遍历 
	return 0;
}

//非递归前序遍历二叉树

#include<stdio.h>
#include<stdlib.h>
typedef struct node{
	int data;
	struct node *left,*right;
}BTNode;
BTNode *CreateBiTree(int a[],int n)
{
	BTNode *root,*c,*p,*q;
	root=(BTNode *)malloc(sizeof(BTNode));
	root->data=a[0];
	root->left=root->right=NULL;
	for(int i=1;i<n;i++){
		p=(BTNode *)malloc(sizeof(BTNode));
		p->data=a[i];
		p->left=p->right=NULL;
		c=root;
		while(c){
			q=c;
			if(c->data>p->data){
				c=c->left;
			}
			else{
				c=c->right;
			}
		}
		if(q->data>p->data){
			q->left=p;
		}
		else{
			q->right=p;
		}
	}
	return root;
}
void PreOrder(BTNode *root)
{
	BTNode **Q,*p;
	int top=-1;//栈顶指针 
	Q=(BTNode **)malloc(sizeof(BTNode *)*1000);//栈空间尽可能大
	 Q[++top]=root;
	 while(top!=-1){//栈不空 
	 	p=Q[top--];//出栈
	 	printf("%5d",p->data);
	 	if(p->right){//右子女压栈
	 		Q[++top]=p->right;
	 	}
	 	if(p->left){//左子女压栈
	 		Q[++top]=p->left;
	 	}
	 }
}
int main()
{	
	int *a;
	int n,key;
	printf("请输入数组长度：");
	scanf("%d",&n);
	a=(int *)malloc(n*sizeof(int));
	printf("请输入数组元素：");
	for(int i=0;i<n;i++){
		scanf("%d",&a[i]);
	}
	BTNode *root=CreateBiTree(a,n);//建立二叉排序树 
	PreOrder(root);//二叉树的层次遍历 
	return 0;
}

//非递归中序遍历二叉树

#include<stdio.h>
#include<stdlib.h>
typedef struct node{
	int data;
	struct node *left,*right;
}BTNode;
BTNode *CreateBiTree(int a[],int n)
{
	BTNode *root,*c,*p,*q;
	root=(BTNode *)malloc(sizeof(BTNode));
	root->data=a[0];
	root->left=root->right=NULL;
	for(int i=1;i<n;i++){
		p=(BTNode *)malloc(sizeof(BTNode));
		p->data=a[i];
		p->left=p->right=NULL;
		c=root;
		while(c){
			q=c;
			if(c->data>p->data){
				c=c->left;
			}
			else{
				c=c->right;
			}
		}
		if(q->data>p->data){
			q->left=p;
		}
		else{
			q->right=p;
		}
	}
	return root;
}
void InOrder(BTNode *root)
{
	BTNode **Q,*p;
	int top=-1;//栈顶指针 
	Q=(BTNode **)malloc(sizeof(BTNode *)*1000);//栈空间尽可能大
	p=root;
	while(p){//将左线入栈
		Q[++top]=p;
		p=p->left;
	} 
	 while(top!=-1){//栈不空 
	 	p=Q[top--];//出栈
	 	printf("%5d",p->data);
	 	if(p->right){//判断p的右子女是否为空，为空则不做处理
	 		p=p->right;//p指向右子女
	 		while(p){//入栈新的左线
			Q[++top]=p;
			p=p->left;
		} 
	 	}
	 }
}
int main()
{	
	int *a;
	int n,key;
	printf("请输入数组长度：");
	scanf("%d",&n);
	a=(int *)malloc(n*sizeof(int));
	printf("请输入数组元素：");
	for(int i=0;i<n;i++){
		scanf("%d",&a[i]);
	}
	BTNode *root=CreateBiTree(a,n);//建立二叉排序树 
	InOrder(root);//二叉树的层次遍历 
	return 0;
}

//非递归后序遍历
#include<stdio.h>
#include<stdlib.h>
typedef struct node{
	int data;
	struct node *left,*right;
}ElemSN;
ElemSN *CreateBiTree(int a[],int n)
{
	ElemSN *root,*c,*p,*q;
	root=(ElemSN *)malloc(sizeof(ElemSN));
	root->data=a[0];
	root->left=root->right=NULL;
	for(int i=1;i<n;i++){
		p=(ElemSN *)malloc(sizeof(ElemSN));
		p->data=a[i];
		p->left=p->right=NULL;
		c=root;
		while(c){
			q=c;
			if(c->data>p->data){
				c=c->left;
			}
			else{
				c=c->right;
			}
		}
		if(q->data>p->data){
			q->left=p;
		}
		else{
			q->right=p;
		}
	}
	return root;
}
/*void ProBiTree(ElemSN *root)
{
	ElemSN **stack,*p=NULL;
	stack=(ElemSN **)malloc(sizeof(ElemSN *)*1000);//分配栈空间 
	int top=-1;//栈顶指针
	while(root||top!=-1){//根结点不空且栈不空 
		while(root){//将左子树压栈 
			stack[++top]=root;
			root=root->left;
		}
		if(top!=-1){//栈不空 
			root=stack[top];//出栈 
			if(root->right==NULL||root->right==p){//无右孩子或者有孩子已经访问过 
				printf("%4d",root->data);
				top--;
				p=root;
				root=NULL;//避免重复入栈 
			}
			else{//有右孩子，但未被访问过 
				root=root->right;
			}
		}
	} 
}*/
void ProBiTree(ElemSN *root)
{
	ElemSN **stack,*p=NULL;
	stack=(ElemSN **)malloc(sizeof(ElemSN *)*1000);//分配栈空间 
	int top=-1;//栈顶指针
	while(root||top!=-1){//根结点不空且栈不空 
		if(root){//将左子树压栈 
			stack[++top]=root;
			root=root->left;
		}
		else{//栈不空 
			root=stack[top];//出栈 
			if(root->right==NULL||root->right==p){//无右孩子或者有孩子已经访问过 
				printf("%4d",root->data);
				top--;
				p=root;
				root=NULL;//避免重复入栈 
			}
			else{//有右孩子，但未被访问过 
				root=root->right;
			}
		}
	} 
}
int main()
{
	int n;
	int *a;
	printf("请输入数组长度:");
	scanf("%d",&n);
	a=(int *)malloc(sizeof(int)*n);
	for(int i=0;i<n;i++){
		scanf("%d",&a[i]);
	}
	ElemSN *root=CreateBiTree(a,n);
	ProBiTree(root);
	return 0;
}
哦吼~
关注
专栏目录
二叉树 BinaryTree.h
J-SC-30
10-26 1181
#ifndef BINARYTREE_H#define BINARYTREE_Htemplateclass TreeNode{public: T element; // Element contained in the node TreeNode * left; // Pointer to the left child TreeNode * right; // Pointer to the rig
二叉树(BinaryTree)的Java详细实现
离殇丶的博客
02-07 1796
关于二叉树的基本概念：二叉树基本概念 二叉树实现的方法：  * isEmpty()：判断树是否为空。  * clear()：清空二叉树。  * add(BTNode, Type)：向指定节点添加指定的孩子。  * height()：计算二叉树的高度。  * size()：计算二叉树的大小。  * findNode()：查找包含指定数据的节点是否存在。  * findParent()：查找包含指...
二叉树介绍
electronic_J的博客
08-19 742
定义：节点的度最多为2的树型结构。
[BinaryTree] 二叉树类的实现
weixin_30439031的博客
01-30 373
二叉树结点的抽象数据类型： 1 template<class T> 2 class BinaryTreeNode 3 { 4 friend class BinaryTree<T>; 5 private: 6 T element; //结点的数据域 7 BinaryTr...
平衡二叉树
Never_for_Never的专栏
11-14 978
平衡二叉树定义(AVL)：它或者是一颗空树，或者具有以下性质的二叉树：它的左子树和右子树的深度之差的绝对值不超过1，且它的左子树和右子树都是一颗平衡二叉树。 平衡因子(bf)：结点的左子树的深度减去右子树的深度，那么显然-1 很显然，平衡二叉树是在二叉排序树(BST)上引入的，就是为了解决二叉排序树的不平衡性导致时间复杂度大大下降，那么AVL就保持住了(BST)的最好时间复杂度O(logn)，
Java：二叉树Binary Tree
超级马里奥 的博客
11-03 807
Java：二叉树Binary Tree 目录 Java：二叉树Binary Tree 1.创建TreeNode 2.创建Binary Tree类： 3.遍历方法 3.1前序遍历（DLR, Data,LeftChild,Rchild） 3.2中序遍历（LDR） 3.3后序遍历（LRD） 4.测试 1.创建TreeNode 首先先创建单个节点，就叫TreeNode吧： /二叉树节点类 public class TreeNode { private TreeNode left;.
数据结构之二叉树(Binary Tree)详解
swadian2008的博客
06-06 1706
二叉树（Binary Tree）是一种常见的树状数据结构，它由一组节点组成，这些节点通过边连接起来。每个节点最多可以有两个子节点，分别称为左子节点和右子节点。 二叉树的特点包括： 每个节点最多有两个子节点。这两个子节点可以为空（null），也可以存在一个或两个子节点。 左子节点和右子节点的顺序是有意义的，即左子节点在右子节点之前或之后。 每个节点通常包含一个值（或称为关键字）以及其他辅助信息。
二叉树(Binary Tree)
云原生Java Web领域技术博客
12-12 3374
二叉树是研究树型结构的基本类型。任意一棵树均可转换为二叉树(左孩子右兄弟)。因为森林是由树组成，所以也可使用二叉树表示森林（多个二叉树表示）。
数据结构(Python版)：树（Tree）、二叉树（Binary Tree）
xunyishuai5020的博客
06-09 1831
树（Tree）是有限个数据节点（即数据项）组成的集合，其中除根节点和叶的下标为外，每个节点都具有一个直接先驱节点和多个直接后继节点，这与每节点仅具有一个直接先驱节点和一个直接后继节点的线性结构不同；树结构中，根节点（Root）没有先驱节点，叶节点（Leaf）没有后续节点。如果树中的每个节点最多可以有两个后续节点，那么这样的树状结构称为二叉树，这是树状结构中最为常用的一种。二叉树（Binary Tree）定义的操作如下：代码实现： Python语言中，树结构可基于链表或嵌套列表实现。嵌套列表法的优点是：子树的
java-二叉树binaryTree
08-05
在这个"java-二叉树binaryTree"主题中，我们将深入探讨二叉树的实现、操作以及相关的算法。 在Java编程语言中，二叉树可以被表示为一个类，这个类通常包含指向左右子节点的引用，以及可能包含的数据。下面是一个...
二叉树BinaryTree
01-11
对于压缩包中的 "Binary_Tree" 文件，很可能包含了一些二叉树的实例，可能有不同形状和特性的二叉树，如满二叉树（所有层都是满的，除了最后一层可能不满），完全二叉树（除了最后一层外，所有层都是满的，并且最后...
【殷人昆数据结构】第四章5.1 完全二叉树BinaryTree代码的调试
tianty1121的博客
08-30 861
二叉树BinaryTree 主函数 #include "BinaryTree.h" #include <iostream> #include <fstream> #include <iomanip> using namespace std; void visit(BinTreeNode<int> *t){ cout<<t->data<<" "; } int main(){ ifstream fin("data.txt"
二叉树BinaryTree.java类实现以下方法:输出所有二叉树直径及其路径长度 public static<T> void diameterAll(BinaryTree<T> bitree)
07-11
您可以将上述代码保存为`BinaryTree.java`文件，并在您的程序中使用`BinaryTree.diameterAll(bitree)`来输出所有二叉树直径及其路径长度。请注意，上述代码假设您已经实现了其他必要的二叉树操作方法。
数据结构——二叉树BinaryTree基本功能大全及代码实现（递归、非递归遍历、深度、结点数）
Jayphone17的博客
10-05 1165
一、需求分析与功能描述 现代社会生活中，计算机扮演着重要角色，而随着计算机运行速度的不断加快，对数据的处理能力也日益增强，因此，程序所涉及的数据很多，如何科学有效的对数据进行操作，使得计算机的时间和空间利用率最高是一个问题。针对这样的问题，我选择了二叉树对数据的各种操作作为我的课程设计主题，希望通过二叉树来提高对数据的处理能力，促进对数据结构课程的理解。 在二叉树的应用中，常常要求在树中查找...
高分springboot毕设+vue视频点播系统设计与实现-Java源码.zip
11-09
本项目是一个基于Spring Boot和Vue的视频点播系统设计与实现，旨在为计算机相关专业的大学生提供一个完整的毕业设计案例，同时也适合Java学习者进行项目实战练习。该项目不仅涵盖了前后端开发技术，还深入探讨了视频流处理、用户管理和支付系统等关键功能模块。 在系统设计上，后端采用Spring Boot框架，利用其快速开发和部署的优势，实现了高效的服务器端逻辑处理。前端则使用Vue.js，通过其灵活的数据绑定和组件化开发特性，构建了用户友好的交互界面。系统支持多种视频格式的上传与播放，确保了广泛的兼容性。 此外，项目还集成了用户认证与授权机制，保障了系统的安全性。支付功能的加入，使得系统能够模拟真实的商业环境，为用户提供付费点播服务。通过这个项目，学习者可以深入理解前后端协同工作原理，掌握视频点播系统的核心技术和实现方法。
typora软件Windows下编辑Markdown文档神器！截止目前最好用的Markdown编辑器！安装即可使用！无需注册！
11-09
亲测好用！Windows下的Markdown文档编辑神器！一键安装就可使用，无需注册！安装即用。
Win32烧录工具-Portable版本
11-09
Win32烧录工具-Portable版本
Java Script 笔记
最新发布
11-09
Java Script 笔记
基于Spring Boot+Vue的宠物服务管理系统.zip
11-09
基于springboot的毕业设计源码
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值