数据结构之树（五）——二叉树的操作（代码篇）

最新推荐文章于 2023-05-05 20:10:36 发布
最新推荐文章于 2023-05-05 20:10:36 发布
阅读量620 收藏 4
点赞数 3
分类专栏： 数据结构 文章标签： 数据结构 二叉树操作
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/YongshuangZhao/article/details/78929299
版权

这里，我将给出关于二叉树常用操作的代码，包括顺序存储结构和链式存储结构。关于基础部分可以戳这里

源码出自《大话数据结构》

顺序存储结构实现

#include "stdafx.h"
#include "stdio.h"    
#include "stdlib.h"   
#include "io.h"  
#include "math.h"  
#include "time.h"
#define OK 1
#define ERROR 0
#define TRUE 1
#define FALSE 0

#define MAXSIZE 100 /* 存储空间初始分配量 */
#define MAX_TREE_SIZE 100 /* 二叉树的最大结点数 */

typedef int Status;		/* Status是函数的类型,其值是函数结果状态代码，如OK等 */
typedef int TElemType;  /* 树结点的数据类型，目前暂定为整型 */
typedef TElemType SqBiTree[MAX_TREE_SIZE]; /* 0号单元存储根结点  */

typedef struct
{
	int level, order; /* 结点的层,本层序号(按满二叉树计算) */
}Position;

TElemType Nil = 0; /*  设整型以0为空 */

Status visit(TElemType c)
{
	printf("%d ", c);
	return OK;
}

/* 构造空二叉树T。因为T是固定数组，不会改变，故不需要& */
Status InitBiTree(SqBiTree T)
{
	int i;
	for (i = 0; i<MAX_TREE_SIZE; i++)
		T[i] = Nil; /* 初值为空 */
	return OK;
}

/* 按层序次序输入二叉树中结点的值(字符型或整型), 构造顺序存储的二叉树T */
Status CreateBiTree(SqBiTree T)
{
	int i = 0;
	printf("请按层序输入结点的值(整型)，0表示空结点，输999结束。结点数≤%d:\n", MAX_TREE_SIZE);
	while (i<10)
	{
		T[i] = i + 1;

		if (i != 0 && T[(i + 1) / 2 - 1] == Nil && T[i] != Nil) /* 此结点(不空)无双亲且不是根 */
		{
			printf("出现无双亲的非根结点%d\n", T[i]);
			exit(ERROR);
		}
		i++;
	}
	while (i<MAX_TREE_SIZE)
	{
		T[i] = Nil; /* 将空赋值给T的后面的结点 */
		i++;
	}

	return OK;
}

#define ClearBiTree InitBiTree /* 在顺序存储结构中，两函数完全一样 */

/* 初始条件: 二叉树T存在 */
/* 操作结果: 若T为空二叉树,则返回TRUE,否则FALSE */
Status BiTreeEmpty(SqBiTree T)
{
	if (T[0] == Nil) /* 根结点为空,则树空 */
		return TRUE;
	else
		return FALSE;
}

/* 初始条件: 二叉树T存在。操作结果: 返回T的深度 */
int BiTreeDepth(SqBiTree T)
{
	int i, j = -1;
	for (i = MAX_TREE_SIZE - 1; i >= 0; i--) /* 找到最后一个结点 */
		if (T[i] != Nil)
			break;
	i++;
	do
		j++;
	while (i >= powl(2, j));/* 计算2的j次幂。 */
	return j;
}

/* 初始条件: 二叉树T存在 */
/* 操作结果:  当T不空,用e返回T的根,返回OK;否则返回ERROR,e无定义 */
Status Root(SqBiTree T, TElemType *e)
{
	if (BiTreeEmpty(T)) /* T空 */
		return ERROR;
	else
	{
		*e = T[0];
		return OK;
	}
}

/* 初始条件: 二叉树T存在,e是T中某个结点(的位置) */
/* 操作结果: 返回处于位置e(层,本层序号)的结点的值 */
TElemType Value(SqBiTree T, Position e)
{
	return T[(int)powl(2, e.level - 1) + e.order - 2];
}

/* 初始条件: 二叉树T存在,e是T中某个结点(的位置) */
/* 操作结果: 给处于位置e(层,本层序号)的结点赋新值value */
Status Assign(SqBiTree T, Position e, TElemType value)
{
	int i = (int)powl(2, e.level - 1) + e.order - 2; /* 将层、本层序号转为矩阵的序号 */
	if (value != Nil && T[(i + 1) / 2 - 1] == Nil) /* 给叶子赋非空值但双亲为空 */
		return ERROR;
	else if (value == Nil && (T[i * 2 + 1] != Nil || T[i * 2 + 2] != Nil)) /*  给双亲赋空值但有叶子（不空） */
		return ERROR;
	T[i] = value;
	return OK;
}

/* 初始条件: 二叉树T存在,e是T中某个结点 */
/* 操作结果: 若e是T的非根结点,则返回它的双亲,否则返回＂空＂ */
TElemType Parent(SqBiTree T, TElemType e)
{
	int i;
	if (T[0] == Nil) /* 空树 */
		return Nil;
	for (i = 1; i <= MAX_TREE_SIZE - 1; i++)
		if (T[i] == e) /* 找到e */
			return T[(i + 1) / 2 - 1];
	return Nil; /* 没找到e */
}


/* 初始条件: 二叉树T存在,e是T中某个结点 */
/* 操作结果: 返回e的左孩子。若e无左孩子,则返回＂空＂ */
TElemType LeftChild(SqBiTree T, TElemType e)
{
	int i;
	if (T[0] == Nil) /* 空树 */
		return Nil;
	for (i = 0; i <= MAX_TREE_SIZE - 1; i++)
		if (T[i] == e) /* 找到e */
			return T[i * 2 + 1];
	return Nil; /* 没找到e */
}

/* 初始条件: 二叉树T存在,e是T中某个结点 */
/* 操作结果: 返回e的右孩子。若e无右孩子,则返回＂空＂ */
TElemType RightChild(SqBiTree T, TElemType e)
{
	int i;
	if (T[0] == Nil) /* 空树 */
		return Nil;
	for (i = 0; i <= MAX_TREE_SIZE - 1; i++)
		if (T[i] == e) /* 找到e */
			return T[i * 2 + 2];
	return Nil; /* 没找到e */
}

/* 初始条件: 二叉树T存在,e是T中某个结点 */
/* 操作结果: 返回e的左兄弟。若e是T的左孩子或无左兄弟,则返回＂空＂ */
TElemType LeftSibling(SqBiTree T, TElemType e)
{
	int i;
	if (T[0] == Nil) /* 空树 */
		return Nil;
	for (i = 1; i <= MAX_TREE_SIZE - 1; i++)
		if (T[i] == e && i % 2 == 0) /* 找到e且其序号为偶数(是右孩子) */
			return T[i - 1];
	return Nil; /* 没找到e */
}

/* 初始条件: 二叉树T存在,e是T中某个结点 */
/* 操作结果: 返回e的右兄弟。若e是T的右孩子或无右兄弟,则返回＂空＂ */
TElemType RightSibling(SqBiTree T, TElemType e)
{
	int i;
	if (T[0] == Nil) /* 空树 */
		return Nil;
	for (i = 1; i <= MAX_TREE_SIZE - 1; i++)
		if (T[i] == e && i % 2) /* 找到e且其序号为奇数(是左孩子) */
			return T[i + 1];
	return Nil; /* 没找到e */
}

/* PreOrderTraverse()调用 */
void PreTraverse(SqBiTree T, int e)
{
	visit(T[e]);
	if (T[2 * e + 1] != Nil) /* 左子树不空 */
		PreTraverse(T, 2 * e + 1);
	if (T[2 * e + 2] != Nil) /* 右子树不空 */
		PreTraverse(T, 2 * e + 2);
}

/* 初始条件: 二叉树存在 */
/* 操作结果: 先序遍历T。 */
Status PreOrderTraverse(SqBiTree T)
{
	if (!BiTreeEmpty(T)) /* 树不空 */
		PreTraverse(T, 0);
	printf("\n");
	return OK;
}

/* InOrderTraverse()调用 */
void InTraverse(SqBiTree T, int e)
{
	if (T[2 * e + 1] != Nil) /* 左子树不空 */
		InTraverse(T, 2 * e + 1);
	visit(T[e]);
	if (T[2 * e + 2] != Nil) /* 右子树不空 */
		InTraverse(T, 2 * e + 2);
}

/* 初始条件: 二叉树存在 */
/* 操作结果: 中序遍历T。 */
Status InOrderTraverse(SqBiTree T)
{
	if (!BiTreeEmpty(T)) /* 树不空 */
		InTraverse(T, 0);
	printf("\n");
	return OK;
}

/* PostOrderTraverse()调用 */
void PostTraverse(SqBiTree T, int e)
{
	if (T[2 * e + 1] != Nil) /* 左子树不空 */
		PostTraverse(T, 2 * e + 1);
	if (T[2 * e + 2] != Nil) /* 右子树不空 */
		PostTraverse(T, 2 * e + 2);
	visit(T[e]);
}

/* 初始条件: 二叉树T存在 */
/* 操作结果: 后序遍历T。 */
Status PostOrderTraverse(SqBiTree T)
{
	if (!BiTreeEmpty(T)) /* 树不空 */
		PostTraverse(T, 0);
	printf("\n");
	return OK;
}

/* 层序遍历二叉树 */
void LevelOrderTraverse(SqBiTree T)
{
	int i = MAX_TREE_SIZE - 1, j;
	while (T[i] == Nil)
		i--; /* 找到最后一个非空结点的序号 */
	for (j = 0; j <= i; j++)  /* 从根结点起,按层序遍历二叉树 */
		if (T[j] != Nil)
			visit(T[j]); /* 只遍历非空的结点 */
	printf("\n");
}

/* 逐层、按本层序号输出二叉树 */
void Print(SqBiTree T)
{
	int j, k;
	Position p;
	TElemType e;
	for (j = 1; j <= BiTreeDepth(T); j++)
	{
		printf("第%d层: ", j);
		for (k = 1; k <= powl(2, j - 1); k++)
		{
			p.level = j;
			p.order = k;
			e = Value(T, p);
			if (e != Nil)
				printf("%d:%d ", k, e);
		}
		printf("\n");
	}
}


int main()
{
	Status i;
	Position p;
	TElemType e;
	SqBiTree T;
	InitBiTree(T);
	CreateBiTree(T);
	printf("建立二叉树后,树空否？%d(1:是 0:否) 树的深度=%d\n", BiTreeEmpty(T), BiTreeDepth(T));
	i = Root(T, &e);
	if (i)
		printf("二叉树的根为：%d\n", e);
	else
		printf("树空，无根\n");
	printf("层序遍历二叉树:\n");
	LevelOrderTraverse(T);
	printf("前序遍历二叉树:\n");
	PreOrderTraverse(T);
	printf("中序遍历二叉树:\n");
	InOrderTraverse(T);
	printf("后序遍历二叉树:\n");
	PostOrderTraverse(T);
	printf("修改结点的层号3本层序号2。");
	p.level = 3;
	p.order = 2;
	e = Value(T, p);
	printf("待修改结点的原值为%d请输入新值:50 ", e);
	e = 50;
	Assign(T, p, e);
	printf("前序遍历二叉树:\n");
	PreOrderTraverse(T);
	printf("结点%d的双亲为%d,左右孩子分别为", e, Parent(T, e));
	printf("%d,%d,左右兄弟分别为", LeftChild(T, e), RightChild(T, e));
	printf("%d,%d\n", LeftSibling(T, e), RightSibling(T, e));
	ClearBiTree(T);
	printf("清除二叉树后,树空否？%d(1:是 0:否) 树的深度=%d\n", BiTreeEmpty(T), BiTreeDepth(T));
	i = Root(T, &e);
	if (i)
		printf("二叉树的根为：%d\n", e);
	else
		printf("树空，无根\n");

	return 0;
}

链式存储结构实现

#include "stdafx.h"
#include "stdlib.h"  
#include "string.h"
#include "stdio.h"    
#include "stdlib.h"   
#include "io.h"  
#include "math.h"  
#include "time.h"
#define OK 1
#define ERROR 0
#define TRUE 1
#define FALSE 0

#define MAXSIZE 100 /* 存储空间初始分配量 */

typedef int Status;		/* Status是函数的类型,其值是函数结果状态代码，如OK等 */

						/* 用于构造二叉树********************************** */
int index = 1;
typedef char String[24]; /*  0号单元存放串的长度 */
String str;

Status StrAssign(String T, char *chars)
{
	int i;
	if (strlen(chars)>MAXSIZE)
		return ERROR;
	else
	{
		T[0] = strlen(chars);
		for (i = 1; i <= T[0]; i++)
			T[i] = *(chars + i - 1);
		return OK;
	}
}
/* ************************************************ */

typedef char TElemType;
TElemType Nil = ' '; /* 字符型以空格符为空 */

Status visit(TElemType e)
{
	printf("%c ", e);
	return OK;
}

typedef struct BiTNode  /* 结点结构 */
{
	TElemType data;		/* 结点数据 */
	struct BiTNode *lchild, *rchild; /* 左右孩子指针 */
}BiTNode, *BiTree;


/* 构造空二叉树T */
Status InitBiTree(BiTree *T)
{
	*T = NULL;
	return OK;
}

/* 初始条件: 二叉树T存在。操作结果: 销毁二叉树T */
void DestroyBiTree(BiTree *T)
{
	if (*T)
	{
		if ((*T)->lchild) /* 有左孩子 */
			DestroyBiTree(&(*T)->lchild); /* 销毁左孩子子树 */
		if ((*T)->rchild) /* 有右孩子 */
			DestroyBiTree(&(*T)->rchild); /* 销毁右孩子子树 */
		free(*T); /* 释放根结点 */
		*T = NULL; /* 空指针赋0 */
	}
}

/* 按前序输入二叉树中结点的值（一个字符） */
/* #表示空树，构造二叉链表表示二叉树T。 */
void CreateBiTree(BiTree *T)
{
	TElemType ch;

	/* scanf("%c",&ch); */
	ch = str[index++];

	if (ch == '#')
		*T = NULL;
	else
	{
		*T = (BiTree)malloc(sizeof(BiTNode));
		if (!*T)
			exit(OVERFLOW);
		(*T)->data = ch; /* 生成根结点 */
		CreateBiTree(&(*T)->lchild); /* 构造左子树 */
		CreateBiTree(&(*T)->rchild); /* 构造右子树 */
	}
}

/* 初始条件: 二叉树T存在 */
/* 操作结果: 若T为空二叉树,则返回TRUE,否则FALSE */
Status BiTreeEmpty(BiTree T)
{
	if (T)
		return FALSE;
	else
		return TRUE;
}

#define ClearBiTree DestroyBiTree

/* 初始条件: 二叉树T存在。操作结果: 返回T的深度 */
int BiTreeDepth(BiTree T)
{
	int i, j;
	if (!T)
		return 0;
	if (T->lchild)
		i = BiTreeDepth(T->lchild);
	else
		i = 0;
	if (T->rchild)
		j = BiTreeDepth(T->rchild);
	else
		j = 0;
	return i>j ? i + 1 : j + 1;
}

/* 初始条件: 二叉树T存在。操作结果: 返回T的根 */
TElemType Root(BiTree T)
{
	if (BiTreeEmpty(T))
		return Nil;
	else
		return T->data;
}

/* 初始条件: 二叉树T存在，p指向T中某个结点 */
/* 操作结果: 返回p所指结点的值 */
TElemType Value(BiTree p)
{
	return p->data;
}

/* 给p所指结点赋值为value */
void Assign(BiTree p, TElemType value)
{
	p->data = value;
}

/* 初始条件: 二叉树T存在 */
/* 操作结果: 前序递归遍历T */
void PreOrderTraverse(BiTree T)
{
	if (T == NULL)
		return;
	printf("%c", T->data);/* 显示结点数据，可以更改为其它对结点操作 */
	PreOrderTraverse(T->lchild); /* 再先序遍历左子树 */
	PreOrderTraverse(T->rchild); /* 最后先序遍历右子树 */
}

/* 初始条件: 二叉树T存在 */
/* 操作结果: 中序递归遍历T */
void InOrderTraverse(BiTree T)
{
	if (T == NULL)
		return;
	InOrderTraverse(T->lchild); /* 中序遍历左子树 */
	printf("%c", T->data);/* 显示结点数据，可以更改为其它对结点操作 */
	InOrderTraverse(T->rchild); /* 最后中序遍历右子树 */
}

/* 初始条件: 二叉树T存在 */
/* 操作结果: 后序递归遍历T */
void PostOrderTraverse(BiTree T)
{
	if (T == NULL)
		return;
	PostOrderTraverse(T->lchild); /* 先后序遍历左子树  */
	PostOrderTraverse(T->rchild); /* 再后序遍历右子树  */
	printf("%c", T->data);/* 显示结点数据，可以更改为其它对结点操作 */
}


int main()
{
	int i;
	BiTree T;
	TElemType e1;
	InitBiTree(&T);

	String str1="ABDH#K###E##CFI###G#J##";
	StrAssign(str, str1);

	CreateBiTree(&T);

	printf("构造空二叉树后,树空否？%d(1:是 0:否) 树的深度=%d\n", BiTreeEmpty(T), BiTreeDepth(T));
	e1 = Root(T);
	printf("二叉树的根为: %c\n", e1);

	printf("\n前序遍历二叉树:");
	PreOrderTraverse(T);
	printf("\n中序遍历二叉树:");
	InOrderTraverse(T);
	printf("\n后序遍历二叉树:");
	PostOrderTraverse(T);
	ClearBiTree(&T);
	printf("\n清除二叉树后,树空否？%d(1:是 0:否) 树的深度=%d\n", BiTreeEmpty(T), BiTreeDepth(T));
	i = Root(T);
	if (!i)
		printf("树空，无根\n");

	return 0;
}

BackkomCoder
关注
  • 3
    点赞
  • 踩
  • 4
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
数据结构——二叉树的生成与遍历
02-18
数据结构，实现二叉树的生成与遍历的算法。包含利用先序、中序、后序遍历二叉树算法，二叉树基本操作。（注意没有左子树或右子树时用@或#作为结束符号）
严蔚敏《数据结构》源码 顺序表——二叉树
06-08
目前写在了图，之后的内容会在github上持续更新，数据结构系列更新完之后，可能会更新算法的教程（参考屈婉玲版《算法设计与分析》）希望可以帮到各位！！ InitList.cpp------顺序表 LinkList.cpp------链表 ...
二叉树创建-代码
zhanghongxian123的专栏
01-19 2388
package binarytree; import java.util.ArrayList; public class BinaryTree { // 二叉树本身的成员 Node root; int size; // 操作 // 初始化空树 public BinaryTree() { root = null; size = 0; } // 建立的树的初始节点数组 Arr
数据结构A（5章）
qq_61938547的博客
05-05 290
数据结构第五章、二叉树相关知识
二叉树——二叉树代码，你想要的都在这里
哦豁果奶的博客
11-23 941
本篇文章仅给出关于二叉树的部分代码，若想深入了解二叉树请查看我的其他文章因为本次实验二叉树考察的内容太多了，所以我把它拆分成了三个部分，分别是建立，处理，遍历三个板块，三篇文章可以在我的博客或专栏中找到。以下是链接二叉树递归总头文件：建立二叉树结构，二叉树的三种建立。遍历按层次非递归遍历、先序非递归、先中后序递归遍历二叉树的链表结构处理求二叉树的高度、叶节点数、单分支节点数、双分支节点数，交换左右子树目录。
数据结构之二叉树（C语言附详细代码）
热门推荐
m0_68210771的博客
07-23 1万+
关于树的简要概念和二叉树的重点内容，以及二叉树的操作代码，前中后序遍历代码以及层次遍历代码
有关二叉树的基本操作
absorb2601078490的博客
06-26 1022
​本文只有代码，介绍了有关二叉树的基本操作。 已经过调试没有很大问题。 如有错误，还请批评指正。
广工数据结构课程设计——平衡二叉树操作的演示
07-06
广工数据结构课程设计——平衡二叉树操作的演示 内含源代码、可执行程序以及相应的说明文档 实验的功能包括： [实现提示] (1) 初始，平衡二叉树为空树，操作界面给出查找、插入和删除三种操作供选择。每种操作均要...
广工数据结构实验——平衡二叉树
07-06
广工数据结构实验——平衡二叉树 里面含有：源代码、可执行程序、说明文档
广工数据结构实验课程设计-平衡二叉树的演示
最新发布
12-18
广工数据结构课程设计——平衡二叉树操作的演示 内含源代码、可执行程序以及相应的说明文档 实验的功能包括： [实现提示] (1) 初始，平衡二叉树为空树，操作界面给出查找、插入和删除三种操作供选择。每种操作均要...
二叉树的构造
11-04
树的构造与删除以及各种遍历，求叶子数，以及相互交换
java代码构建二叉树(二叉查找树)
不见其长，日有所长
06-16 4489
1. 前言 1.1 二叉树定义 二叉树是N个结点的有限集合，该集合或者为空集，或者由一个根节点跟两棵互不相交的、分别称为根节点的左子树或者右子树的二叉树组成。 1.2 二叉树的特点 每个结点最多有两个子树 左子树跟右子树是有序的 树中某个结点只有一棵子树,也要区分是左子树还是右子树 1.3 二叉树的形态 空二叉树 只有一个根结点 根结点只有左子树 根结点只有右子树 根结点既有左子树,又有右子树 2. java构建二叉树代码示例 2.1 二叉树的存储结构 以二叉链表存储为例
二叉树的代码编写
weixin_45043411的博客
03-26 5196
提示：文章写完后，目录可以自动生成，如何生成可参考右边的帮助文档 文章目录一、二叉树的建立（C语言）二、前序遍历1.前序遍历的方式2.代码实现三、中序遍历1.中序遍历的实现方式2.代码实现四、后序遍历1.后序遍历的实现方式2.代码实现完整代码 一、二叉树的建立（C语言） 二叉树的节点的结构体创建 typedef struct node { int date; //数据 struct node *left; //左子树 struct node *right; //右子树 }Node; 在.
（树_13）构造二叉树
jasscical's blog
10-11 242
106. 从中序与后序遍历序列构造二叉树 参考资料：代码随想录 解题思路 后序：左右中 中序：左中右 分为以下几步： 1.后序、中序是否为空，为空直接返回空树，否则进入后续步骤 2.获取后序最后一个元素，作为根节点 3.由后序最后一个元素在中序里找到分割点delimiter 4.由分割点对中序进行分割成子序列：左中序，右中序 5.然后对后序进行分割成子序列：左后序，右后序（需要借助左中序来判断分割点位置，详情看代码注释） 6.递归构造左子树，右子树 ...
建立一棵二叉树
满城丶琉璃月
02-26 2720
首先，要想建立一棵二叉树就要知道二叉树的三种遍历方法：前序遍历，中序遍历和后序遍历。不知道的可自行查阅。 为了方便二叉树的表示，我们首先对二叉树进行扩展，将仅有空指针的结点变成虚节点，引入左右孩子（用^或#等符号表示），我们称这种变形后的二叉树为扩展二叉树。 原二叉树 扩展二叉树 有了扩展二叉树，按照前序遍历的方法，上述树可写成AB#D##C## 外面代码实现了二叉树的建立和前序...
01二叉树顺序结构实现_BiTreeArray
AKK188888881的博客
10-06 426
#include<stdio.h> #include<stdlib.h> #include<math.h> #define OK 1 #define ERROR 0 #define TRUE 1 #define FALSE 0 #define MAXSIZE 100 /* 存储空间初始分配量 */ #define MAX_TREE_SIZE 100 /* 二叉树的最大结点数 */ typedef int Status; /* Status是函数的类型,其值是函数结
【数据结构】二叉树的介绍
WINGREZ‘S BLOG
08-31 1601
参考资料：《数据结构（C语言版）严蔚敏著》 版权说明：未经作者允许，禁止转载。如引用本文内容，需标明作者及出处。如本文侵犯了您的权益，请联系我删除并致歉。 文章说明：如文章中出现错误，请联系我更改。如您对文章的内容有任何疑问，也欢迎来与我讨论。 本文正在施工中...请稍等... 二叉树 二叉树是一种特殊的有序树，它的每个结点最多只有两棵子树。它与度为2的有序树的区别在于：度为2的树至少有3个结...
数据结构--二叉树构造模板
m0_53252742的博客
11-27 3848
包含四个头文件，需要哪个函数直接抄上就可以的 头文件：binary_tree： #pragma once #pragma once #include<iostream> #include"lk_ queue.h" #include"lk_stack.h" #include"node.h" using namespace std; template <class ElemType> struct BinTreeNode { // 数据成员: ElemType data; .
数据结构之二叉树（简单使用及知识点）
m0_61886762的博客
04-28 2583
1.1二叉树定义 二叉树是n(n>=0)个结点的有限集合，该集合或者为空集（称为空二叉树），或者由一个根结点和两颗互不相交的、分别称为根结点的左子树和右子树的二叉树组成。 结点的层次是从根开始定义的，根为第一层，根的孩子为第二层。若结点在l层则其子树就在l+1层。其双亲在同一层的结点互为堂兄弟。下图中D,E,F为堂兄弟。树中结点的最大层次称为树的深度或高度，下图树的深度为5. 左图为二叉树的表示 左图因为D结点有三个子树所以它不是二叉树 1.2 二叉树的特点 二叉树的特点有： 1）.
C++数据结构——中序遍历二叉树
05-23
中序遍历是二叉树遍历的一种，遍历顺序为左子树、根节点、右子树。以下是C++代码实现： ```c++ #include <iostream> using namespace std; struct TreeNode { int val; TreeNode* left; TreeNode* right; TreeNode(int x) : val(x), left(NULL), right(NULL) {} }; void inorderTraversal(TreeNode* root) { if(root == NULL) return; inorderTraversal(root->left); cout << root->val << " "; inorderTraversal(root->right); } int main() { TreeNode* root = new TreeNode(1); root->right = new TreeNode(2); root->right->left = new TreeNode(3); inorderTraversal(root); return 0; } ``` 输出结果为：1 3 2 这里我们只是简单地输出了遍历的结果，实际应用中可以对遍历到的节点进行其他操作。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值