二叉树遍历代码实现

最新推荐文章于 2024-05-18 10:53:04 发布
最新推荐文章于 2024-05-18 10:53:04 发布
阅读量2.4k 收藏 13
点赞数 2
分类专栏： 算法 数据结构 文章标签： 数据结构 算法 排序算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_46359697/article/details/122084769
版权

文章目录

1.定义

二叉树（Binary tree）是树形结构的一个重要类型。许多实际问题抽象出来的数据结构往往是二叉树形式，即使是一般的树也能简单地转换为二叉树，而且二叉树的存储结构及其算法都较为简单，因此二叉树显得特别重要。

二叉树特点是每个结点最多只能有两棵子树，且有左右之分。（有序树）

二叉树是n个有限元素的集合，该集合或者为空、或者由一个称为根（root）的元素及两个不相交的、被分别称为左子树和右子树的二叉树组成 。当集合为空时，称该二叉树为空二叉树。在二叉树中，一个元素也称作一个结点。

注意：这里的节点是逻辑结构上的表示，也就是数据元素，而不是物理结构上的表示

2.特点

我们发现，二叉树的定义好像和数组的定义几乎一样，都是n个有限元素的集合。但实际上二叉树它最明显的特点就是层次关系！

在二叉树的基本操作中，遍历操作是最重要的操作。因为它是其它许多操作的基础，同时递归是二叉树操作的特征，但是递归对我们把控栈深浅程度不够友好，并且任何递归都可以以迭代的方式实现，因此在实现二叉树的行为的时候，可以使用递归和迭代两种方式实现。

3.树的遍历

树的遍历是其它基于树这种数据结构操作的基础，因此我们在此实现多种遍历方式使我们树这种数据结构认识更加深刻。

遍历的方式有两种：递归和迭代

递归算法的优点是简洁，但一般而言，其执行效率不高，因为系统要维护一个工作栈以保证递归函数的正确执行。因此，有时需要把递归算法转化为非递归算法。

在使用迭代的方法进行树的遍历的时候，需要用到线性栈和线性队列，因此先实现这两个数据结构。

准备工作

线性栈实现
# define STACK_INIT_SIZE  100      // 顺序栈 (默认的)的初始分配最大容量
# define STACKINCREMENT  10        // (默认的)增补空间量
typedef struct {
    ElemType* stack;                  // 存储数据元素的一维数组
    int top;                         // 栈顶指针
    int stacksize;                   // 当前分配的数组容量（以ElemType为单位）
    int incrementsize;	           // 增补空间量（以ElemType为单位）
}SqStack;
void InitStack_Sq(SqStack& S, int maxsize = STACK_INIT_SIZE,
    int incresize = STACKINCREMENT)
{
    S.stack = (ElemType*)malloc(maxsize * sizeof(ElemType)); // 为顺序栈分配初始存储空间
    if (!S.stack)  exit(1);                                // 存储空间分配失败
    S.top = -1;                                            // 置栈空
    S.stacksize = maxsize;                                 // 顺序栈的当前容量
    S.incrementsize = incresize;                           // 增补空间
}// InitStack_Sq

int StackLength_Sq(SqStack S)
{
    return S.top + 1;
}// StackLength_Sq

bool Push_Sq(SqStack& S, ElemType e)
{  //在顺序栈的栈顶插入元素e
    if (S.top == S.stacksize - 1) {
        S.stack = (ElemType*)realloc(S.stack, (S.stacksize + S.
            incrementsize) * sizeof(ElemType)); // 栈满，给顺序栈增补空间
        if (!S.stack)     return false;                // 分配存储空间失败
        S.stacksize += S.incrementsize;
    }
    S.stack[++S.top] = e;                             // 栈顶指针上移，元素e进栈
    return true;
}// Push_Sq

bool Pop_Sq(SqStack& S, ElemType& e)
{   // 删除顺序栈栈顶元素，并让e返回其值
    if (S.top == -1)  return false;
    e = S.stack[S.top--];
    return true;
}// Pop_Sq

bool GetTop_Sq(SqStack S, ElemType& e)
{   //取顺序栈栈顶元素，并让e返回其值
    if (S.top == -1)  return false;
    e = S.stack[S.top];
    return true;
}// GetTop_Sq

bool StackEmpty_Sq(SqStack S)
{
    if (S.top == -1)  return true;
    else return false;
}// StackEmpty_Sq


void DestroyStack_Sq(SqStack& S)
{
    free(S.stack);
    S.stack = NULL;
    S.stacksize = 0;
    S.top = -1;
}// DestroyStack_Sq
线性队列实现
#define QUENU_INIT_SIZE 100
#define QUENUINCREMENT 10
typedef struct {
	ElemType* queue;
	int front;
	int rear;
	int queuesize;
	int incrementsize;
}SqQueue;

//初始化操作
void InitQueue_Sq(SqQueue& Q, int maxsize = QUENU_INIT_SIZE, int incresize = QUENUINCREMENT) {
	Q.queue = (ElemType*)malloc(maxsize * sizeof(ElemType));
	if (!Q.queue) exit(01);
	Q.front = Q.rear = 0;
	Q.queuesize = maxsize;
	Q.incrementsize = incresize;
}

//求队列的长度
int QueueLength_Sq(SqQueue Q) {
	return (Q.rear - Q.front + Q.queuesize) % Q.queuesize;
}

//进队操作
bool EnQueue_Sq(SqQueue& Q, ElemType e) {
	//从队尾插入元素，成功则返回true
	if ((Q.rear + 1) % Q.queuesize == Q.front) //队满给顺序队列增补空间
	{
		Q.queue = (ElemType*)realloc(Q.queue, (Q.queuesize + Q.incrementsize) * sizeof(ElemType));
		if (!Q.queue) return false;
		if (Q.front > Q.rear)   //队首指针在队尾指针后面，重新确定位置
		{
			for (int i = Q.queuesize; i >= Q.front; i--) {
				Q.queue[i + Q.incrementsize] = Q.queue[i];
			}
			Q.front += Q.incrementsize;
		}
		Q.queuesize += Q.incrementsize;
	}
	Q.queue[Q.rear] = e;
	Q.rear = (Q.rear + 1) % Q.queuesize;
	return true;
}

//出队操作
bool DeQueue_Sq(SqQueue& Q, ElemType& e) {
	if (Q.front == Q.rear) return false;
	e = Q.queue[Q.front];
	Q.front = (Q.front + 1) % Q.queuesize;
	return true;
}

//取队首元素操作
bool GetHead_Sq(SqQueue Q, ElemType& e) {
	if (Q.front == Q.rear)  return false;
	e = Q.queue[Q.front];
	return true;
}

bool QueueEmpty_Sq(SqQueue Q) {
	return Q.front == Q.rear;
}

//撤销循环队列操作
void DestroyQueue_Sq(SqQueue& Q) {
	free(Q.queue);
	Q.queuesize = 0;
	Q.front = Q.rear = 0;
}

3.1.先序遍历

遍历的终止方式：

  1. 访问根节点
  2. 先序遍历根的左子树
  3. 先序遍历根的右子树
3.1.1.迭代版本
void NRPreOrderBiTree(BiTree BT, void Visit(TElemType))
{      // 先序非递归遍历二叉树BT(利用栈)
    SqStack S;
    InitStack_Sq(S, MAX_BITREE_SIZE, 10);      // 初始化栈S
    while (BT || !StackEmpty_Sq(S))             // 当BT不空或者栈不空
    {
        if (BT)                                 // BT不空
        {
            Visit(BT->data);                     // 访问根结点
            Push_Sq(S, BT);                       //根指针进栈
            BT = BT->lchild;                       // BT指向其左孩子
        }
        else                                   // 根指针退栈，访问根结点，遍历右子树
        {
            Pop_Sq(S, BT);                        //根指针出栈
            BT = BT->rchild;                        // BT指向其右孩子
        }
    }
}// NRPreOrderBiTree
3.1.2.递归版本
void PreOrderBiTree(BiTree BT, void Visit(TElemType))
{     // 先序递归遍历二叉树BT
    if (BT)                                        // BT不空
    {
        Visit(BT->data);                            // 先访问根结点
        PreOrderBiTree(BT->lchild, Visit);           // 再先序遍历左子树
        PreOrderBiTree(BT->rchild, Visit);           // 最后先序遍历右子树
    }
}// PreOrderBiTree

3.2.中序遍历

遍历的终止方式：

  1. 中序遍历根的左子树
  2. 访问根节点
  3. 中序遍历根的右子树
3.2.1.迭代版本
void NRInOrderBiTree(BiTree BT, void Visit(TElemType))
{  // 中序非递归遍历二叉树BT(利用栈)
    SqStack S;
    InitStack_Sq(S, MAX_BITREE_SIZE, 10);        // 初始化栈S
    while (BT || !StackEmpty_Sq(S))              // 当BT不空或者栈不空
    {
        if (BT)                                  // BT不空
        {                                       // 根指针进栈，遍历左子树
            Push_Sq(S, BT);                        // 根指针进栈
            BT = BT->lchild;                        // BT指向其左孩子
        }
        else                                    // 根指针退栈，访问根结点，遍历右子树
        {
            Pop_Sq(S, BT);                         //根指针出栈
            Visit(BT->data);                      // 访问根结点
            BT = BT->rchild;                        // BT指向其右孩子
        }
    }
}// NRInOrderBiTree
3.2.2.递归版本
void InOrderBiTree(BiTree BT, void Visit(TElemType))
{    // 中序递归遍历二叉树BT
    if (BT)                                  // BT不空
    {
        InOrderBiTree(BT->lchild, Visit);      // 先中序遍历左子树
        Visit(BT->data);                      // 再访问根结点
        InOrderBiTree(BT->rchild, Visit);      // 最后中序遍历右子树
    }
}// InOrderBiTree

3.3.后序遍历

遍历的终止方式：

  1. 后序遍历根的左子树
  2. 后续遍历根的右子树
  3. 访问根节点
3.3.1.迭代版本
void NRPostOrderBiTree(BiTree BT, void Visit(TElemType))
{   // 后序非递归遍历二叉树BT(利用栈)
    SqStack S;
    InitStack_Sq(S, MAX_BITREE_SIZE, 10);            // 初始化栈S
    BiTree p, q;
    int flag;
    if (!BT)   return;
    p = BT;
    do
    {
        while (p)                                      // 为非空二叉树,向左走到尽头
        {
            Push_Sq(S, p);                              // p进栈
            p = p->lchild;                               // p指向其左孩子
        }
        q = NULL; flag = 1;
        while (!StackEmpty_Sq(S) && flag)
        {
            GetTop_Sq(S, p);                          // 取栈顶元素
            if (p->rchild == q)                        // 其右孩子不存在或已访问 
            {
                Pop_Sq(S, p);                           //栈顶元素出栈
                Visit(p->data);                        // 访问p所指结点
                q = p;                                   // q指向刚刚访问的结点
            }
            else
            {
                p = p->rchild;                            // p指向其右孩子
                flag = 0;
            }
        }
    } while (!StackEmpty_Sq(S));
}// NRPostOrderBiTree
3.3.2.递归版本
void PostOrderBiTree(BiTree BT, void Visit(TElemType))
{            // 后序递归遍历二叉树BT
    if (BT)                                       // BT不空
    {
        PostOrderBiTree(BT->lchild, Visit);         // 先后序遍历左子树
        PostOrderBiTree(BT->rchild, Visit);         // 再后序遍历右子树
        Visit(BT->data); // 最后访问根结点
    }
}// PostOrderBiTree

3.4.层序遍历

3.4.1.迭代版本
void LevelOrderBiTree(BiTree BT, void Visit(TElemType))
{ // 层序递归遍历BT(利用队列)
    SqQueue Q;
    BiTree p;
    if (BT) // BT不空
    {
        InitQueue_Sq(Q, MAX_BITREE_SIZE, 10);  // 初始化队列Q
        EnQueue_Sq(Q, BT); // 根指针入队
        while (!QueueEmpty_Sq(Q)) // 队列不空
        {
            DeQueue_Sq(Q, p); // 出队元素(指针)，赋给p
            Visit(p->data); // 访问p所指结点
            if (p->lchild != NULL) // p有左孩子
                EnQueue_Sq(Q, p->lchild); // 入队p的左孩子
            if (p->rchild != NULL) // p有右孩子
                EnQueue_Sq(Q, p->rchild); // 入队p的右孩子
        }
    }
}// LevelOrderBiTree

4.测试程序

本博客所有的数据结构的实现和测试程序代码均打包好，下载压缩文件即可直接使用。

下载工程文件

#define _CRT_SECURE_NO_WARNINGS
#include <iostream>
#include <cstdlib>
using namespace std;
typedef char TElemType;            //定义树中元素类型TElemType为字符型
TElemType Nil = '#';               //用'#'表示空
# define MAX_BITREE_SIZE 100      // 二叉树中的最大结点数
#include "BiTree.h"
void Visit(TElemType e)           // 访问函数定义为输出操作
{
	cout << e << ' ';
}
void main()
{
	int i;
	BiTree BT, p, c;
	TElemType e1, e2;
	InitBiTree(BT);                                  // 初始化二叉树BT
	cout << "构造空二叉树后，树空否？" << BiTreeEmpty(BT);
	cout << "(1：是 0：否)。树的深度=" << BiTreeDepth(BT) << endl;
	cout << "请按先序输入二叉树(用'#'表示子树为空)：" << endl;
	CreateBiTree(BT);                                 // 建立二叉树BT
	cout << "建立二叉树后，树空否？" << BiTreeEmpty(BT);
	cout << "(1：是 0：否)。树的深度=" << BiTreeDepth(BT) << endl;
	
	cout << "先序递归遍历二叉树：";
	PreOrderBiTree(BT, Visit);                          // 先序递归遍历二叉树BT
	cout << endl << "中序递归遍历二叉树：";
	InOrderBiTree(BT, Visit);                           // 中序递归遍历二叉树BT
	cout << endl << "后序递归遍历二叉树：";
	PostOrderBiTree(BT, Visit);    // 后序递归遍历二叉树BT
								
	cout << endl << "先序非递归遍历二叉树：";
	NRPreOrderBiTree(BT, Visit);                         // 先序非递归遍历二叉树BT
	cout << endl << "中序非递归遍历二叉树：";
	NRInOrderBiTree(BT, Visit);                          // 中序非递归遍历二叉树BT
	cout << endl << "后序非递归遍历二叉树：";
	NRPostOrderBiTree(BT, Visit);      	// 后序非递归遍历二叉树BT

	cout << endl << "层序遍历二叉树：";
	LevelOrderBiTree(BT, Visit);                         // 层序递归遍历二叉树BT
	cout << endl << "用凹入表的形式打印二叉树BT：" << endl;
	PrintBiTree(BT, 1);                                  // 输出二叉树BT
	system("pause");
}

程序是以先序的形式初始化，因此测试程序的输入为：

ABD#G###CE##F##

测试程序输入以上命令后就可以看到不同遍历方式结果的不同！

5.总结

之所以专门用一篇博文来讲述二叉树这些概念是因为在查找算法中数表查找涉及到很多的概念和相关代码，如果直接用代码去讲述可能还是不能够解决你的问题。

遍历算法非常简单，在这里就不做过多详细的解答，无非就是一些数据结构的组合。

先在逻辑结构把它想清楚，然后再把它映射到物理结构上。

嵌入式定制设计工坊
关注
  • 2
    点赞
  • 踩
  • 13
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
二叉树遍历的C++代码实现
Jing Sir的博客
04-25 2万+
广度优先遍历二叉树： void levelorder() //广度优先遍历二叉树 { queue<binarytreenode<T> *> nodequeue; binarytreenode<T> *pointer=root; if(pointer) nodequeue.push(pointer); while(!nodequeue.empty())
matlab实现二叉树遍历算法（源代码）
04-30
本文介绍了在MATLAB中实现二叉树算法的基本步骤。首先，定义了一个名为TreeNode的结构体，用于存储二叉树节点的数据以及指向左右子节点的...这段代码为MATLAB用户提供了一个简单的框架，用于实现和操作二叉树数据结构。
遍历二叉树的代码实现
1+1=王的博客
08-08 1614
二叉树的遍历先序遍历（根--左--右）递归法非递归法中序遍历（左--根--右）递归法非递归法后序遍历（左--右--根）递归法非递归法层序遍历 先序遍历（根–左--右） 递归法 void PreOrder(BiTree T){ if(T != NULL){ visit(T); //访问根节点 PreOrder(T->lchild); //递归遍历左子树 PreOrder(T->rchild); //递归遍历右子树 } } 非递归法 void PreOrder(BiTree
【补充】二叉树的遍历丨代码详解
最新发布
qq_74315738的博客
05-18 718
递归算法/非递归算法（堆栈、队列）遍历二叉树
二叉树4种遍历代码实现
Charming的博客
10-05 1775
二叉树4种遍历代码实现 前序遍历 中序遍历 后序遍历 层次遍历 前3种遍历空间复杂度是O(h)，h：二叉树深度 层次遍历空间复杂度是O(1)+队列 // 二叉树的代码实现 #include <stdio.h> #include <iostream> using namespace std; #define MaxSize 50 typedef struct TNode{ int data; struct TNode *lchild, *rchild; }
全网最全二叉树遍历教程含代码实现
wangmj_hdu的博客
02-24 2017
一、什么是树 树（tree）是一种经常用到的数据结构，用来模拟具有树状结构性质的数据集合。 树是n（n>=0）个结点和n-1条边的有限集。n=0时称为空树。在任意一棵非空树中： 有且仅有一个特定的称为根（root）的结点； 当n>1时，其余结点可分为m（m>0）个互不相交的有限集，其中每个集合本身又是一棵树，并且称为根的子树（subtree）。 二、什么是二叉树 二叉树（binary tree）是一种更为典型的树状结构。如它名字所描述的那样，二叉树是每个节点最多有两个子树的树结构，通常
二叉树的遍历 js实现
qq_52046856的博客
04-13 1420
二叉树主要有两种遍历方式：一是深度优先遍历，即先往二叉树底部走，遇到叶子节点再返回；二是广度优先遍历，即对二叉树的每一层逐层遍历节点。
二叉树遍历的代码总结
m0_51260846的博客
09-25 770
二叉树遍历，代码实现，深度优先，前序遍历，中序遍历，后序遍历，广度优先，层次遍历
二叉树遍历算法实现
UCAS_HMM的博客
11-01 1178
数据结构——二叉树
1、二叉树遍历的C语言实现
如是牛
02-02 903
深刻理解C语言指针后，数据结构实现起来如鱼得水！
二叉树的遍历c++代码实现
KFLING的博客
06-12 1万+
二叉树的遍历是指从根结点出发，按照某种次序依次访问二叉树中所有结点，使得每个结点被访问一次且仅被访问一次。二叉树的遍历方式常用的有四种：前序遍历、中序遍历、后序遍历和层序遍历。二叉树结点的定义代码如下：//Definition for binary tree struct TreeNode { int val; TreeNode *left; TreeNode *right...
二叉树遍历 非递归 C++实现代码
09-05
二叉树遍历是计算机科学中处理树形数据结构的基本操作，主要分为前序遍历、中序遍历和后序遍历。这三种遍历方法各有特点，递归实现时利用了树的自然递归定义，代码简洁易懂。然而，非递归实现则需要借助辅助数据结构...
二叉树遍历问题二叉树遍历问题
10-20
- C代码实现中，`preOrderTraversal`函数实现了先序遍历。它首先检查节点是否为空，如果非空，则打印节点值，然后递归地遍历左子树和右子树。 2. **中序遍历（Inorder Traversal）**： - 访问顺序：左子树 -> 根...
二叉树遍历，c语言 实现数据结构二叉树遍历
04-19
在C语言中实现二叉树遍历涉及到对指针的熟练操作和递归理解。下面将详细介绍二叉树的三种基本遍历方法：前序遍历、中序遍历和后序遍历，以及如何用C语言来实现它们。 1. 前序遍历（根-左-右） 前序遍历的顺序是先...
二叉树遍历问题-二叉树遍历问题
11-12
二叉树遍历的实现通常使用递归和迭代两种方式。递归方法直观且易于理解，但当树的深度很大时可能导致栈溢出。迭代方法则通过使用栈或队列来避免这个问题，例如 Morris 遍历和层序遍历。 - **Morris 遍历**： - ...
共用体详解
热门推荐
qq_46359697的博客
09-19 1万+
共用体详解1.含义2.一般类型3.关键知识点3.13.23.33.43.53.63.73.83.94.总结 1.含义 在进行某些算法的C语言编程的时候，需要使几种不同类型的变量存放到同一段内存单元中。也就是使用覆盖技术，几个变量互相覆盖。这种几个不同的变量共同占用一段内存的结构，在C语言中，被称作“共用体”类型结构，简称共用体，也叫联合体。 2.一般类型 定义共用体类型变量的一般形式为： union 共用体名 { 成员表列 }变量表列; 3.关键知识点 例如： union Data { int
哈希算法原理和实现
qq_46359697的博客
09-13 1万+
哈希算法原理和实现 前言 当我们在编程过程中，往往需要对线性表进行查找操作。在顺序表中查找时，需要从表头开始，依次遍历比较a[i]与key的值是否相等，直到相等才返回索引i；在有序表中查找时，我们经常使用的是二分查找，通过比较key与a[i]的大小来折半查找，直到相等时才返回索引i。最终通过索引找到我们要找的元素。 　　　但是，这两种方法的效率都依赖于查找中比较的次数。我们有一种想法，能不能不经过比较，而是直接通过关键字key一次得到所要的结果呢？这时，就有了散列表查找（哈希表）。 1、什么是哈希表 要说哈
十大排序之归并排序
qq_46359697的博客
11-30 1万+
归并排序1.算法步骤1.1.递归法1.2.迭代法2.动图演示3.代码实现3.1.递归实现3.1.1.算法实现3.1.2.测试程序3.1.3.疑问3.1.4.现象3.1.5.解释3.1.6.验证3.1.6.1.左递归先开始3.1.6.1.右递归先开始3.1.7.总结3.2.迭代法3.2.1.算法实现3.2.2.测试程序3.2.3.理解4.总结 归并排序（Merge sort）是建立在归并操作上的一种有效的排序算法。该算法是采用分治法（Divide and Conquer）的一个非常典型的应用。 作为一种典型的
二叉树的遍历代码实现
11-21
以下是二叉树的三种遍历方式的代码实现： 1. 先序遍历（递归） ```c void PreOrderTraverse(BiTree T){ if(T){ displayElem(T); PreOrderTraverse(T->lchild); PreOrderTraverse(T->rchild); } return; } ``` ...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值