数据结构系列　二叉树的遍历（顺序存储）

最新推荐文章于 2023-10-26 23:23:57 发布
最新推荐文章于 2023-10-26 23:23:57 发布
阅读量4.9k 收藏 38
点赞数 7
分类专栏： 数据结构 & 算法 文章标签： 二叉树 二叉树顺序存储
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/lin20044140410/article/details/103889660
版权

https://blog.csdn.net/lin20044140410/article/details/89436835 二叉树链式存储

数据结构-树

树是一种一对多的数据结构，是n(n>=0)个结点的有限集。N=0时为空树。在任意一棵非空树中：1，有且只有一个特定的称为根root的结点，2，当n>1时，其余结点可分为m (m>0)个互不相交的有限集T1,T2,,,,Tm，其中每一个集合本身又是一棵树，并且称为根的子树。

 

一些概念：

  1. 结点拥有的子树数称为阶段的度，度为0的结点称为叶结点Leaf，度不为0的结点称为分支结点。树的度是树内个结点的度的最大值。
  2. 结点的层次，从根开始，根为第一层，根的孩子为第二层，树中结点的最大层次称为树的深度，或者高度。

 

二叉树

二叉树是一种特殊结构的树，是n个结点的有限集合，或者为空树，或者由一个根结点和两棵互不相交的、分别称为左子树和右子树的二叉树组成。

二叉树的特点：

  1. 每个结点最多两棵子树，
  2. 左子树、右子树是有顺序的，次序不能颠倒，
  3. 即使树中某结点只有一棵子树，也要区分它是左子树还是右子树。

 

特殊的二叉树

斜树，所有的结点都只有左子树的二叉树叫左斜树，所有结点都只有右子树的二叉树叫右斜树。斜树，其实就是线性表结构。

 

满二叉树，在一棵二叉树中，如果所有分支结点都存在左子树和右子树，并且所有叶子都在同一层上，这样的二叉树称为满二叉树。

满二叉树特点：

  1. 叶子只能出现在最下一层，
  2. 非叶子结点的度一定是2
  3. 在同样深度的二叉树中，满二叉树的结点个数最多，叶子最多。

 

完全二叉树

对一棵具有n个结点的二叉树按层序编号，如果编号为i(1<=i<=n)的结点与同样深度的满二叉树中编号为i的结点在二叉树中位置完全相同，则这棵二叉树称为完全二叉树。

满二叉树一定是一棵完全二叉树，但是完全二叉树不一定是满的。

完全二叉树的所有结点与同样深度的满二叉树，它们按层序编号相同的结点，是一一对应的。

上图是一棵完全二叉树。

图中树1，树2，树3因为编号不连续，都不是完全二叉树，

完全二叉树特点：

  1. 叶子结点只能出现在最下两层。
  2. 最下层叶子结点一定集中在左部连续位置。
  3. 倒数第二层，如有叶子结点，一定都在右部连续位置。
  4. 如果结点度为1，则该节点只有左孩子，不存在只有右子树的情况。
  5. 同样结点数的二叉树，完全二叉树深度最小。

 

判断一棵二叉树是不是完全二叉树，就是给每个结点按照满二叉树的结构逐层编号，如果编号出现空挡，就不是完全二叉树。

 

二叉树的性质

  1. 在二叉树的第i层，至多有2(i-1) (i>=1)
  2. 深度是k的二叉树，最多有2k -1 个结点 k>=1.

以上两点都可以通过数据归纳法来得出结论。

  1. 任意一棵二叉树，如果终端结点数为n0，度为2的结点数为n2，则n0 = n2 +1，
  2. 具有n个结点的完全二叉树的深度为log2n +1
  3. 如果对一棵有n个结点的完全二叉树（深度为log2n +1）的结点，按层序编号（从第1层到第log2n +1 层，每层从左到右），对于任一结点i(1<=I <=n)：

如果i = 1，结点i就是二叉树的根，无双亲，如果i>1,则其双亲是结点 i/2 (向下取整)。

如果2i >n，则结点i无左孩子，结点i为叶子结点；否则其左孩子是结点2i。

如果2i + 1 > n，则结点i无右孩子，否则其右孩子是结点2i + 1。

 

依据以上性质，来定义二叉树的存储结构，先说顺序存储。

二叉树的顺序存储结构就是用一维数组存储二叉树中的结点，结点的存储位置，就是数组的下标，相应位置不存在的结点设置为null。这种存储结构，适用于完全二叉树，因为对于极端的右斜树，它有k个结点，却要分配2k -1个存储空间，这是对存储空间的浪费。

 

二叉树的链式存储结构，每个结点最多两个孩子，所以这种存储结构，一个数据域，两个指针域，两个指针域存放指向左孩子和右孩子的指针，称这样的存储结构为二叉链表。

 

二叉树的遍历

对二叉树的遍历，就是把树中的结点变成某种意义的线性序列。

遍历算法就是递归。

  1. 前序遍历，若二叉树为null，则空操作返回，否则先访问根结点，然后前序遍历左子树，在前序遍历右子树。
  2. 中序遍历，若树为null，则空操作返回，否则从根结点开始，中序遍历左子树，然后访问根结点，最后中序遍历右子树。
  3. 后序遍历，若树为null，则空操作返回，否则从左到右，先叶子后结点的方式，先遍历访问左子树，再同样从左到右，先叶子后结点的方式，遍历右子树，最后访问根结点。
  4. 层序遍历，若树为null，则空操作返回，否则从树的第一层根结点开始访问，从上到下逐层遍历，在同一层中，按从左到右的顺序对结点逐个访问。

 

从遍历操作可以得出，

已知前序遍历序列和中序遍历序列，可以唯一确定一棵二叉树；

已知后序遍历序列和中序遍历序列，可以唯一确定一棵二叉树；

这两种情况都可以确定根结点，并且可以确定左子树或者右子树。

但是，已知前序和后序序列，是不能确定一棵二叉树的，因为虽然根结点可以确定，但是无法确定那个结点是左子树，那个结点是右子树。

二叉树顺序存储代码实现：

#ifndef DATA_STRUCTURE_BINARY_TREE_CLASS_H
#define DATA_STRUCTURE_BINARY_TREE_CLASS_H 

#define OK 1
#define ERROR 0
#define TRUE 1
#define FALSE 0
#define MAXSIZE 100 //存储空间初始分配量
#define MAX_TREE_SIZE 100 //二叉树最大结点树

typedef int Status; //表示函数结果的状态码
typedef int TElemType; //树节点的数据类型，暂定int
typedef TElemType SqBiTree[MAX_TREE_SIZE]; //顺序存储结构数组

typedef struct {
    int level;//节点的层
    int order;//本层的序号，按满二叉树计算
}Position;

TElemType Nil = 0; //表示空元素

#endif

 

#include "binaryTree.h"

#include "iostream"
#include "cstdlib"
#include "cmath"
using namespace std;
Status visit(TElemType c) {
   cout << "node:" << c <<endl;
}

//构造空二叉树
Status InitBiTree(SqBiTree T) {
	int i;
	for (i = 0; i< MAX_TREE_SIZE; i++) {
		T[i] = Nil;//空值
	}

	return OK;
}

Status CreateBiTree(SqBiTree T) {
	int i=0;
	cout<< "按层序输入结点的值，整形数，0表示空结点，结点数 <=" <<
		MAX_TREE_SIZE <<endl;
	//对前10个结点赋值
	while (i < 10) {
		T[i] = i+1;
		cout << "结点：" << i <<",值:"<<    T[i] << endl;
		//对于非根结点，一定有双亲，如果没有就出错了
		if (i != 0 && T[(i+1)/2 -1] == Nil && T[i] != Nil) {
			cout << "无双亲的非根结点：" <<         T[i] << endl;
			exit(ERROR);
		}
		i++;
	}

	//其余结点赋值空
	while(i < MAX_TREE_SIZE) {
		T[i] = Nil;
		i++;
	}	
	return OK;
}

//判空树
Status BiTreeEmpty(SqBiTree T) {
    //如果根结点为空，即空树
	if (T[0] == Nil) {
		return TRUE;
	} else {
		return FALSE;
	}
}

//获取树的深度
int BiTreeDepth(SqBiTree T) {
	int i,j=-1;
	for (i = MAX_TREE_SIZE-1; i>=0; i--) {
		if (T[i] != Nil) {//找到最后一个不为空的结点
			break;
		}
	}
	//因为在找到最后一个非空结点后，for又做了一次i--，所以要在加回去
	i++;
	//根据前面的性质，深度为k二叉树，最多有2k（2的k次幂） -1 个结点，
	//现在知道结点数，反推深度
	do{
	    j++;
	}while (i>=powl(2,j));

	return j;
}

//获取根结点
Status Root(SqBiTree T, TElemType *e) {
	if (BiTreeEmpty(T)) {
		return ERROR;
	} else {
		*e = T[0];
		return OK;
	}
}

//获取指定位置的结点,参数e包含结点所在的层，及本层的序号。
TElemType Value(SqBiTree T, Position e) {
	return T[(int)powl(2, e.level -1) + e.order -2];
}

//给指定位置的结点赋值
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;
}

//返回结点的双亲
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) {
			return T[(i+1)/2-1];
		}
	}
	return Nil;
}

//返回左孩子
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) {
			return T[i*2 +1];
		}
	}
	return Nil;
}

//返回右孩子
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) {
			return T[i*2 +2];
		}
	}
	return Nil;
}

//前序遍历
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);
	}
}

Status PreOrderTraverse(SqBiTree T) {
	cout << "前序遍历。。。" << endl;
	if (!BiTreeEmpty(T)) {
		PreTraverse(T, 0);
	}
	return OK;
}

//中序遍历
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);
	}
}

Status InOrderTraverse(SqBiTree T) {
	cout << "中序遍历。。。" << endl;
	if (!BiTreeEmpty(T)) {
		InTraverse(T, 0);
	}
	return OK;
}

//后序遍历
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]);	
}

Status PostOrderTraverse(SqBiTree T) {
	cout << "后序遍历。。。" << endl;
	if (!BiTreeEmpty(T)) {
		PostTraverse(T, 0);
	}
	return OK;
}

//层序遍历
void LevelOrderTraverse(SqBiTree T) {
	int i = MAX_TREE_SIZE -1;
	cout << "层序遍历。。。" << endl;
	while (T[i] == Nil) {
		i--;//查找最后一个非空结点
	}
	cout << "最后一个非空结点(数组小标从0开始)：" << i << endl;
	for (int j=0; j<=i; j++) {
		if(T[j] != Nil) {
			visit(T[j]);
		}
	}
	cout << endl;
}

//按层输出结点
void LevelOrderVisist(SqBiTree T) {
	int j,k;
	Position p;
	TElemType e;
	cout << "按层输出结点。。。" << endl;
	for (j=1;j<=BiTreeDepth(T);j++) {
		cout <<"第 "<<j <<"层：" <<endl;
		for (k=1;k<=powl(2,j-1);k++) {
			p.level = j;
			p.order =k;
			e= Value(T,p);
			if (e != Nil) {
				cout << k << ":" << e << endl;
			}
		}
		cout <<endl;
	}
}

int main() {
	Status i;
	Position p;
	TElemType e;
	SqBiTree T;
	InitBiTree(T);
	CreateBiTree(T);
	cout << "新建的二叉树，深度：" << BiTreeDepth(T) << endl;

	i = Root(T, &e);
	cout << "二叉树的根：" << e << endl;
	LevelOrderVisist(T);
	LevelOrderTraverse(T);
	PreOrderTraverse(T);
	InOrderTraverse(T);
	PostOrderTraverse(T);
	
	p.level = 3;
	p.order = 2;
	e = Value(T, p);
	cout << "修改第3层第2个结点的值，原值："<< e << "新值为50." << endl;
	e = 50;
	Assign(T, p, e);
	e = Value(T, p);
	cout << "修改后的第3层第2个结点的值："<< e  << endl;
	PreOrderTraverse(T);

	return 0;
}

/**output/

$ g++ -g BinaryTree.cpp -o BiTree
$ ./BiTree

按层序输入结点的值，整形数，0表示空结点，结点数 <=100
结点：0,值:1
结点：1,值:2
结点：2,值:3
结点：3,值:4
结点：4,值:5
结点：5,值:6
结点：6,值:7
结点：7,值:8
结点：8,值:9
结点：9,值:10
新建的二叉树，深度：4
二叉树的根：1
按层输出结点。。。
第 1层：
1:1

第 2层：
1:2
2:3

第 3层：
1:4
2:5
3:6
4:7

第 4层：
1:8
2:9
3:10

层序遍历。。。
最后一个非空结点(数组小标从0开始)：9
node:1
node:2
node:3
node:4
node:5
node:6
node:7
node:8
node:9
node:10

前序遍历。。。
node:1
node:2
node:4
node:8
node:9
node:5
node:10
node:3
node:6
node:7
中序遍历。。。
node:8
node:4
node:9
node:2
node:10
node:5
node:1
node:6
node:3
node:7
后序遍历。。。
node:8
node:9
node:4
node:10
node:5
node:2
node:6
node:7
node:3
node:1
修改第3层第2个结点的值，原值：5新值为50.
修改后的第3层第2个结点的值：50
前序遍历。。。
node:1
node:2
node:4
node:8
node:9
node:50
node:10
node:3
node:6
node:7

 

lin-0410
关注
  • 7
    点赞
  • 踩
  • 38
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
C语言数据结构——二叉树的顺序存储和二叉树的遍历
我想让你也是一个开心果！
11-18 2566
在学习顺序存储结构之前要知道： 二叉树的结构是非线性的； 每一个结点可有两个后继。 对于这种一对多的层次结构，我们应该怎么样合理的存储下来呢？ 二叉树既有顺序存储又有链式存储，今天先学顺序存储。 方法: 使用一组连续的存储单元来存放二叉树的数据元素。 使用结点之间的相对位置表示结点之间的关系。 对于满二叉树和完全二叉树来说，可以按照对满二叉树结点连续编号，将各结点数据存放到一组连续的存储单元中，将二叉树中编号为i的结点存放在数组的第i号元素中。 编号规则： 根结点的编号为1；对于编号为i的结点， 左孩子如果
二叉树遍历问题二叉树遍历问题
10-20
二叉树遍历是计算机科学中处理树结构数据时的一项基本操作，主要应用于数据的检索、存储和操作。在二叉树中，每个节点最多有两个子节点，分别称为左子节点和右子节点。二叉树遍历有四种常见的方法：先序遍历、中序...
数据结构-顺序存储二叉树
weixin_73869209的博客
10-06 1855
大家好,今天给大家讲一下顺序存储二叉树顺序存储二叉树是一种将二叉树的节点按照从上到下、从左到右的顺序存储在数组中的方法。具体来说，顺序存储二叉树将二叉树的根节点存储在数组的第一个位置，然后按照从上到下、从左到右的顺序将二叉树的其他节点依次存储在数组中。对于任意一个节点的索引为i（i从1开始),其左子节点的索引为2i右子节点的索引为2i+1。这样，通过数组的索引关系，可以方便地找到节点的父节点、左子节点和右子节点。顺序存储二叉树的优点是可以使用数组的随机访问特性快速找到节点，不需要通过指针进行遍历。
【数据结构】 二叉树及其三种遍历
热门推荐
Hello World!
02-21 21万+
二叉树（Binary Tree）一种重要的树形结构，其每个节点最多只能有两棵子树，通常称为左子树和右子树，且子树有左右之分，其次序不能颠倒。二叉树是n个有限元素的集合，该集合或者为空（称为空二叉树），或者由一个称为根（root）的元素及两个不相交的、被分别称为左子树和右子树的二叉树组成。
数据结构二叉树的遍历
qq_48639334的博客
08-02 1229
数据结构二叉树的遍历，包括创建二叉树、先序遍历、中序遍历、后序遍历、层次遍历
二叉树遍历方法——前、中、后序遍历（图解）
在夜里行走的博客
11-04 14万+
二叉树的前、中、后序遍历的递归与非递归算法
【数据结构】二叉树遍历的实现（超详细解析，小白必看系列）
weixin_45031801的博客
10-10 1534
二叉树的遍历（前序、中序、后序），和二叉树的一些经典问题求解
Java数据结构——二叉树的遍历
chenchenchencl的博客
10-03 9266
一文速学二叉树的遍历
数据结构实验：二叉树遍历
qq_53216148的博客
12-03 9255
1、实验要求 实现功能：建立二叉树存储结构、求二叉树的先序遍历、求二叉树的中序遍历、求二叉树的后序遍历、求二叉树的层次遍历、求根到给定结点的路径。主控菜单： 1．建立二叉树存储结构 2．求二叉树的先序遍历 3．求二叉树的中序遍历 4．求二叉树的后序遍历 5．求二叉树的层次遍历 6．求根到给定结点的路径 0．退出系统 此外还要实现容错处理，检测任何不...
数据结构与算法-二叉树的遍历
最新发布
qq_73121173的博客
10-26 582
数据结构与算法-二叉树的遍历
数据结构_二叉树遍历_
09-29
二叉树作为一种重要的数据结构，其遍历算法是理解和应用二叉树的基础。本程序聚焦于二叉树的三种基本遍历方法：先序遍历、中序遍历和后序遍历。 **一、先序遍历** 先序遍历的顺序是：根节点 -> 左子树 -> 右子树。...
头歌数据结构二叉树的顺序存储及基本操作
05-18
总的来说，顺序存储的二叉树是一种简化了内存管理的数据结构，适用于静态二叉树或已知结构的二叉树，它可以简化存储和遍历操作，但灵活性较低。在实际应用中，我们还需要考虑其他存储方式，如链式存储，以适应更复杂...
二叉树的遍历实验报告.pdf
11-11
二叉树是一种重要的数据结构，它由有限个节点组成，每个节点最多有两个子节点，分别称为左子节点和右子节点。在计算机科学中，二叉树被广泛应用于搜索、排序、表达式求解等多种场景。本实验报告将探讨二叉树的遍历...
易语言二叉树遍历
07-21
二叉树遍历是理解数据结构和算法的基础，它包括前序遍历、中序遍历和后序遍历三种主要方法。 1. **二叉树的基本概念**： - 二叉树是一种特殊的树结构，每个节点最多有两个子节点，通常称为左子节点和右子节点。 -...
数据结构系列－队列的基本操作
lin20080410的专栏
03-19 7万+
队列(Queue)是只允许在一端进行插入操作，而在另一端进行删除操作的线性表。允许插入的端是队尾，允许删除的端是队头。所以说队列是一个先进先出的线性表，相应的也有顺序存储和链式存储两种方式。顺序存储就是用数组实现，比如有一个ｎ个元素的队列，数组下标0的一端是队头，入队操作就是通过数组下标一个个顺序追加，不需要移动元素，但是如果删除队头元素，后面的元素就要往前移动，对应的时间复杂度就是O(n)，性能...
数据结构系列，二叉平衡树的构建
lin20080410的专栏
01-12 4883
平衡二叉树 平衡二叉树，首先要是一种二叉排序树， 然后，其中每一个结点的左子树，右子树的高度差（左子树的高度 – 右子树的高度）至多等于1，二叉树的高度就是这棵树有几层。 将二叉树上结点的左子树深度减去右子树深度的值称为平衡因子BF，所有结点的平衡因子的值，只可能是-1, 0, 1。只要二叉树上有一个结点的平衡因子绝对值大于1，则该二叉树就是不平衡的。 距离插入结点最近的，且平衡因子...
数据结构系列－顺序栈的基本操作
lin20080410的专栏
03-15 2340
栈(Stack)是限定只能在表尾部进行插入、删除的线性表。也称后进先出的线性表。允许执行插入、删除的那一端成为栈顶，另一端就是栈底，因为只能在栈顶执行操作，所以他是一种特殊的线性表。既然栈是特殊的线性表，也会有顺序存储和链式存储。对于栈的顺序存储，就是用数组来实现，将下标０的一端作为栈底，因为首元素都在栈底，变化最小。顺序栈的数据结构及基本操作：如果需要改变栈的内容，函数的参数类型为指针，否则是普...
数据结构系列，二叉排序树的结点删除、重排
lin20080410的专栏
01-11 2103
二叉排序树 又称二叉查找树，它或者是一棵空树，或者是具有下列性质的二叉树： 若它的左子树不为空，则左子树上所有结点的值均小于它的根结点的值。 若它的右子树不空，则右子树上所有结点的值均大于它的根结点的值。 它的左右子树，也分别为二叉排序树。 构造一棵二叉排序树的目的，不是为了排序，而是为了提高查找、插入删除关键字的速度。 二叉树的删除，需要保证一点，不能因为删除了结点，而让这棵树变得不满...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值