二叉树，创建，打印，层序，先，中，后序递归及非递归遍历

最新推荐文章于 2023-05-08 23:30:40 发布
最新推荐文章于 2023-05-08 23:30:40 发布
阅读量107 收藏
点赞数
分类专栏： 算法小白记录 文章标签： 二叉树
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_45790260/article/details/109953421
版权

目前只实现了这些
后面要去了解哈夫曼树，作业是编码文档并解码，需要这棵树

#include <stdio.h>
#include <stdlib.h>

#define ElementType int
#define LEN 3

/**二叉树*/
typedef struct TreeNode{
    ElementType val;
    struct TreeNode *left;
    struct TreeNode *right;
}BiNode,*BiTree;

/**栈的定义*/
#define STACK_INIT_SIZE 100 //初始分配空间
#define STACKINCREMENT 10  //分配增量
#define OK 1
#define ERROR 0
#define SElemType BiTree
typedef struct
{
    SElemType *base;
    SElemType *top;
    int stacksize;
}SqStack;
/*构造空栈*/
int InitStack(SqStack * SPtr);
/*销毁栈*/
int DestoryStack(SqStack * SPtr);
/*把栈置空*/
int ClearStack(SqStack * SPtr);
/*判空*/
int StackEmpty(SqStack S);
/*返回栈顶元素*/
int GetTop(SqStack S,SElemType * e);
/*入栈*/
int Push(SqStack * SPtr,SElemType e);
/*出栈*/
int Pop(SqStack * SPtr,SElemType * e);

/**队列定义*/
#define QElemType BiTree
#define MAXSIZE 40
typedef struct{
    QElemType *base;
    int front;
    int rear;
}Queue;
/*初始化队列*/
void InitQuene(Queue * QPtr);
/*入队*/
void EnQuene(Queue* QPtr,QElemType E);
/*出队*/
void DeQuene(Queue* QPtr,QElemType* E);
/*销毁队列*/
void DestoryQueue(Queue* QPtr);


/*创建二叉树*/
int CreateTree(BiTree* TPtr);
/*打印二叉树*/
void PrintTree(BiTree T,int i);
/*递归，前序遍历*/
void PreOrder(BiTree T);
/*非递归，先序遍历*/
void PreOrderPlus(BiTree T);
/*递归，中序遍历*/
void InOrder(BiTree T);
/*非递归，中序遍历*/
void InOrderPlus(BiTree T);
/*递归，后序遍历*/
void LaOrder(BiTree T);
/*非递归，后序遍历*/
void LaOrderPlus(BiTree T);
/*层序遍历*/
void LevelOrder(BiTree T);
/*求二叉树的深度*/
int Height(BiTree T);
/*求二叉树的节点数*/
int Count(BiTree T);

int main()
{
    BiTree T;//1 2 3 0 0 4 0 0 5 6 0 0 7 0 0
    CreateTree(&T);
    printf("创建完毕\n");
    PrintTree(T,LEN);
    printf("打印完毕\n");
    PreOrder(T);
    printf("前序递归完毕\n");
    PreOrderPlus(T);
    printf("前序非递归完毕\n");
    InOrder(T);
    printf("中序递归完毕\n");
    InOrderPlus(T);
    printf("中序非递归完毕\n");
    LaOrder(T);
    printf("后序递归完毕\n");
    LaOrderPlus(T);
    printf("后序非递归完毕\n");
    LevelOrder(T);
    printf("层序遍历完毕\n");
    int height;
    height = Height(T);
    printf("height = %d\n",height);
    int count;
    count = Count(T);
    printf("count = %d\n",count);
    return 0;
}


/*创建二叉树*/
int CreateTree(BiTree* TPtr)
{
    (*TPtr) = NULL; //初始化
    ElementType val;
    scanf("%d",&val);
    if(val == 0)
    {
        return 0;
    }
    else
    {
        (*TPtr) = (BiTree*)malloc(sizeof(BiNode));
        if(!TPtr) exit(0); //申请内存失败
        (*TPtr)->val = val;
        CreateTree(&((*TPtr)->left));
        CreateTree(&((*TPtr)->right));
    }
    return 1;
}
/*打印二叉树*/
void PrintTree(BiTree T,int i)
{
    if(T != NULL)
    {
        PrintTree(T->right,i+LEN);
        if(T->val != 0)
        {
            printf("%*d\n",i,T->val);
        }
        PrintTree(T->left,i+LEN);
        i -= LEN;
    }
}
/*递归，前序遍历*/
void PreOrder(BiTree T)
{
    if(T)
    {
        printf("%d\n",T->val);
        PreOrder(T->left);
        PreOrder(T->right);
    }
}
/*非递归，先序遍历*/
void PreOrderPlus(BiTree T)
{
    BiTree tem = T;
    /*创立及初始化栈*/
    SqStack S;
    SqStack * SPtr = &S;
    InitStack(SPtr);
    while(tem != NULL || !StackEmpty(S))//当栈空树也空，就应该结束循环了
    {
        while(tem != NULL)
        {
            printf("%d ",tem->val);
            Push(SPtr,tem);
            tem = tem->left;
        }
        if(!StackEmpty(S))
        {
            Pop(SPtr,&tem);
            tem = tem->right;
        }
    }
    DestoryStack(SPtr);
    printf("\n");
}
/*递归，中序遍历*/
void InOrder(BiTree T)
{
    if(T)
    {
        InOrder(T->left);
        printf("%d\n",T->val);
        InOrder(T->right);
    }
}
/*非递归，中序遍历*/
void InOrderPlus(BiTree T)
{
    BiTree tem = T;
    /*创立及初始化栈*/
    SqStack S;
    SqStack * SPtr = &S;
    InitStack(SPtr);
    /*栈空或树空退出*/
    while(tem != NULL || !StackEmpty(S))
    {
        /*将当前树及其左子全部入栈*/
        while(tem != NULL)
        {
            Push(SPtr,tem);
            tem = tem->left;
        }
        /*出栈一个，打印，寻找当前出栈点的右子*/
        if(!StackEmpty(S))
        {
            Pop(SPtr,&tem);
            printf("%d ",tem->val);
            tem = tem->right;
        }
    }
    DestoryStack(SPtr); //销毁栈
    printf("\n");
}
/*递归，后序遍历*/
void LaOrder(BiTree T)
{
    if(T)
    {
        LaOrder(T->left);
        LaOrder(T->right);
        printf("%d\n",T->val);
    }
}
/*非递归，后序遍历*/
void LaOrderPlus(BiTree T)
{
    if(!T) exit(0); //空，退出
    BiTree tem = T,cur = T;
    int flag;
    /*创立及初始化栈*/
    SqStack S;
    SqStack * SPtr = &S;
    InitStack(SPtr);
    Push(SPtr,tem); //根结点入栈
    /*栈空或树空退出*/
    while(!StackEmpty(S))
    {
        GetTop(S,&tem);
        /*flag是条件，当前节点是叶子或者其孩子已经遍历*/
        flag = ((tem->left == NULL && tem->right == NULL) || cur == tem->left || cur == tem->right);
        if(flag)
        {
            Pop(SPtr,&tem);
            printf("%d ",tem->val);
            cur = tem;
        }
        else
        {
            if(tem->right)
            {
                Push(SPtr,tem->right);
            }
            if(tem->left)
            {
                Push(SPtr,tem->left);
            }
        }
    }
    DestoryStack(SPtr); //销毁栈
    printf("\n");
}
/*层序遍历*/
void LevelOrder(BiTree T)
{
    if(!T) exit(-1);//空，退出
    BiTree tem = T;
    /*创建队列*/
    Queue Q;
    Queue* QPtr = &Q;
    InitQuene(QPtr);
    EnQuene(QPtr,tem);
    while(Q.front != Q.rear)//队列不空
    {
        DeQuene(QPtr,&tem);
        printf("%d ",tem->val);
        if(tem->left)
        {
            EnQuene(QPtr,tem->left);
        }
        if(tem->right)
        {
            EnQuene(QPtr,tem->right);
        }
    }
}
/*求二叉树的深度*/
int Height(BiTree T)
{
    int h_left,h_right;
    if(!T) return 0; //空，返回0，出口
    h_left = Height(T->left);
    h_right = Height(T->right);
    if(h_left>h_right)
    {
        return h_left+1;
    }
    else
    {
        return h_right+1;
    }
}
/*求二叉树的节点数*/
int Count(BiTree T)
{
    int r_count,l_count;
    if(!T) return 0; //出口
    printf("哭哭哭\n");
    r_count = Count(T->right);
    l_count = Count(T->left);
    return r_count+l_count+1;
}


















/*构造空栈*/
int InitStack(SqStack * SPtr)
{

    SPtr->base = (SElemType * )malloc(sizeof(SElemType)*STACK_INIT_SIZE);
    if(!SPtr->base) return ERROR; //申请内存失败，强制退出
    SPtr->top = SPtr->base;
    SPtr->stacksize = STACK_INIT_SIZE;//printf("函数内部SPtr->top = %p\n",SPtr->top);
    return OK;
}
/*销毁栈*/
int DestoryStack(SqStack * SPtr)
{
    if(!SPtr->base) return ERROR; //栈本来就为空
    free(SPtr->base);  //释放空间
    //printf("函数外S.top = %p,S.base = %p\n",SPtr->top,SPtr->base);
    SPtr->base = NULL;
    SPtr->top = NULL;
    SPtr->stacksize = 0;
    return OK;
}
/*把栈置空*/
int ClearStack(SqStack * SPtr)
{
    if(!SPtr->base) return ERROR; //栈空
    SPtr->top = SPtr->base;
    return OK;
}
/*判空*/
int StackEmpty(SqStack S)
{
    if(S.base == S.top)
        return OK;
    else
        return ERROR;
}
/*返回栈顶元素*/
int GetTop(SqStack S,SElemType * e)
{
    if(S.base == S.top) return ERROR; //空
    *e = *(S.top-1);
    return OK;
}
/*入栈*/
int Push(SqStack * SPtr,SElemType e)
{
    if(SPtr->top-SPtr->base >= SPtr->stacksize) //满
    {
        SPtr->base = (SElemType * )realloc(SPtr->base,(SPtr->stacksize+STACKINCREMENT)*sizeof(SElemType));
        if(!SPtr->base) return ERROR;  //申请失败，退出
        SPtr->top = SPtr->base+SPtr->stacksize; //relloc函数可能改变数据位置
        SPtr->stacksize += STACKINCREMENT;   //更新数据总数
    }
    *(SPtr->top++) = e;
    return OK;
}
/*出栈*/
int Pop(SqStack * SPtr,SElemType * e)
{
    if(SPtr->base == SPtr->top) return ERROR; //空
    *e = *(--SPtr->top);
    return OK;
}
/*初始化队列*/
void InitQuene(Queue * QPtr)
{
    QPtr->base = NULL;
    QPtr->base = (QElemType*)malloc(sizeof(QElemType)*MAXSIZE);//申请内存
    if(!(QPtr->base)) exit(0); //申请内存失败
    QPtr->front = 0;
    QPtr->rear = 0;
}
/*入队*/
void EnQuene(Queue* QPtr,QElemType E)
{
    if((QPtr->rear+1)%MAXSIZE == QPtr->front) //队满
    {
        printf("队满\n");
        exit(-1);
    }
    else
    {
        QPtr->base[QPtr->rear] = E;
        QPtr->rear = (QPtr->rear+1)%MAXSIZE;
    }
}
/*出队*/
void DeQuene(Queue* QPtr,QElemType* E)
{
    if(QPtr->front == QPtr->rear)
    {
        printf("队空\n");
        exit(-1);
    }
    else
    {
        (*E) = QPtr->base[QPtr->front];
        QPtr->front = (QPtr->front+1)%MAXSIZE;
    }
}
/*销毁队列*/
void DestoryQueue(Queue* QPtr)
{
    free(QPtr->base);
    QPtr->base = NULL;
    QPtr->front = 0;
    QPtr->rear = 0;
}
weixin_45790260
关注
专栏目录
一文彻底搞定二叉树的前序、中序、后序遍历(图解递归非递归)
bigsai
09-22 1万+
前言 大家好，我是bigsai，在数据结构与算法中，二叉树无论是考研、笔试都是非常高频的考点内容，在二叉树中，二叉树的遍历又是非常重要的知识点，今天给大家讲讲二叉树的层序遍历。 这部分很多人可能会但是需要注重一下细节。 前面介绍了二叉排序树的构造和基本方法的实现，遍历也是比较重要的一环，并且二叉树的层序遍历也是bfs的最简单情况，这里我就将二叉树的层序遍历以及常考问题给大家分享一下。 在了解二叉树的遍历之前，需要具备数据结构与算法有队列、递归、栈、二叉树，这些内容咱们前面都有讲过，有这方面知识欠缺的同学可以
二叉树的输出
罗小黑の窝
02-24 1172
头文件：函数的声明 #include #include #include #define MAXSIZE 100 typedef char ElemType; typedef struct Node { ElemType data; struct Node *lchild; struct Node *rchild; }*BitTree,BitNode; void CreateBit
二叉树的创建、前序中序后序递归遍历与非递归遍历、层序遍历以及二叉树简单应用的C语言实现
姿势水平
11-23 1979
最近几天学习了二叉树这一广泛使用的数据结构，并用C语言实现了根据前序扩展序列创建二叉树，前序遍历、中序遍历、后序遍历的递归遍历和非递归遍历，层序遍历以及打印二叉树的叶子结点，求二叉树的高度，根据前序序列、中序序列建立二叉树和根据中序序列、后序序列建立二叉树等功能。程序中用到了堆栈和队列的基本操作，复习了线性表的知识。 数据类型定义和函数声明 #include #include #de
二叉树的输出（C++版）
tongxinhaonan的专栏
05-24 9965
二叉树的打印输出方式，除了按照先序
二叉树的中序遍历、哈夫曼编码-C语言编写的
06-10
用C语言对输入二叉树节点进行中序遍历，输出遍历顺序。包括递归实现和非递归实现两种方式。还有哈夫曼编码
二叉树基本操作
weixin_30577801的博客
10-12 115
#include<stdio.h> #include<stdlib.h> #include<string.h> #include<math.h> #define OK 1 #define NO 0 #define ERROR -1 #define TRUE 1 #define FALSE 0 #define MA...
C语言 二叉树的遍历（前中后序递归与迭代遍历，层序迭代遍历）
m0_73070900的博客
05-08 3823
如图所示二叉树 先序遍历结果为：1 2 4 5 3 6中序遍历结果为：4 2 5 1 6 3后序遍历结果为：4 5 2 6 3 1层序遍历结果为：1 2 3 4 5 6递归的实现就是每一次递归调用都会把函数的局部变量、参数值和返回地址等压入调用栈中，然后递归返回的时候，从栈顶弹出上一次递归的各项参数，所以这就是递归为什么可以返回上一层位置的原因。而迭代法遍历的原理就是模拟递归。 一、先序遍历 递归遍历 迭代遍历 二、中序遍历 迭代遍历
数据结构——二叉树先序、中序、后序及层次四种遍历（C语言版）
热门推荐
正弦定理的博客
12-09 36万+
数据结构——二叉树先序、中序、后序三种遍历二叉树先序、中序、后序三种遍历三、代码展示： 二叉树先序、中序、后序三种遍历 先序遍历：3 2 2 3 8 6 5 4 中序遍历：2 2 3 3 4 5 6 8 后序遍历: 2 3 2 4 5 6 8 3 三种遍历不同之处在，输出数据放在不同之处 三、代码展示： #include<stdio.h> #include<stdlib.h> typedef struct Tree{ int
Python二叉树的遍历操作示例【前序遍历,中序遍历,后序遍历,层序遍历】
09-19
本文将深入探讨Python中的二叉树及其遍历方法，包括前序遍历、中序遍历、后序遍历以及层序遍历。通过具体的代码示例，我们将更好地理解这些遍历方法的工作原理和应用场景。 #### 二、二叉树基础知识回顾 二叉树是由...
二叉树的前中后序以及层序遍历（递归与非递归方法实现）
tensor329的博客
04-01 669
1.前序遍历 前序遍历是二叉树遍历的一种方式，也称做先序遍历。其遍历规则为：根节点→左子树→右子树。以下分别以递归和非递归的方法实现对二叉树的前序遍历。 1.1 递归方法 class Solution { List<Integer> res=new ArrayList<>(); public List<Integer> preorderTraversal(TreeNode root) { if(root!=null){
Java实现的二叉树常用操作【前序建树，前中后递归非递归遍历及层序遍历】
08-28
Java实现的二叉树常用操作是指使用Java语言来实现二叉树的各种操作，包括前序建树、前中后递归非递归遍历、层序遍历等。下面我们将详细介绍这些操作的实现方法。 一、前序建树 前序建树是指从一个数组中构建一个...
按树状打印二叉树
天之痕
02-19 1万+
代码是为了实现二叉树的横向显示问题。这种树形要求先打印右子树，再打印根，最后打印左子树，顺序恰为逆中序顺序。这种输出格式，结点的左右位置与结点的层深有关，故算法中设置了一个表示当前根节点层深的参数，以控制输出结点的左右位置。示意图：代码如下： #include stdio.h>#include stdlib.h>#define OVERFLOW -2#define INFE
数据结构与算法分析笔记与总结(java实现)--二叉树3：二叉树按层遍历打印练习
小菜鸟也想飞的博客
02-15 1614
数据结构与算法分析笔记与总结(java实现)--二叉树3：二叉树按层遍历打印练习
建立一棵用二叉树链表方式存储的二叉树，并对其进行遍历（先序，中序和后序），打印输出遍历结果
小白的Coding之旅
11-04 6万+
题目如下 代码如下 #include&amp;amp;amp;amp;lt;stdio.h&amp;amp;amp;amp;gt; #include&amp;amp;amp;amp;lt;stdlib.h&amp;amp;amp;amp;gt; #include&amp;amp;amp;amp;lt;malloc.h&amp;amp;amp;amp;gt; typedef struct Node//结构体 { char data;
二叉树 工具类 java （创建，前中后序遍历，层次打印，广度优先深度优先遍历）
许诗宇的博客
09-26 1115
树的节点类 package datastructure.binarytree; public class TreeNode { int val; public TreeNode left; public TreeNode right; public TreeNode(int x) { val = x; left=null; right=null; } } 二叉树 ...
C语言构造哈夫曼树，并打印
weixin_45790260的博客
11-22 4835
许多打印在最后没有注释掉，是debug时用的，参考了一些其他的博客，可以睡了，明天有是新的一周 #include <stdio.h> #include <stdlib.h> #define LEN 3 typedef struct Huffman{ int weight; //权重 struct Huffman* lch; struct Huffman* rch; }HuffmanNode,*HuffmanTree; /*创建Huffman树*/ Huffm
直接创建数组与malloc申请内存创建数组
weixin_45790260的博客
01-29 955
有关直接创建数组与通过malloc二级指针创建数组的区别 如果是直接创建的，那么函数引用时形式为matrix[][col], 倘若是通过指针申请的，那么函数可以直接引用(int** matrix) 至于为什么,不太明了 首先理解：直接创建的数组matrix[][]之所以需要col，是因为寻找matrix[i][j]是通过寻觅*(matrix+i*3+j)去确定数据的位置的，那么作为 晕了 1.二维数组是一个一维指针数组以及若干一维数组共同构成的 2. #include<stdio.h> #inc
最少的钱币数量问题
weixin_45790260的博客
09-12 408
题目：有 n 种不同面值的硬币，每种硬币有无限多个。为了方便购物，他希望带尽量 少的硬币，但是要能组合出 1 到 m 之间的任意值。 /**关于sum,是指1 -- sum的金额皆可以购买，那我要想继续扩大可购买的范围，就要 加钱的数量对不对，对的，那好，加多少钱合适呢，比如，现在sum = 25，那我1 -- 25 都可以购买，我最多加一个面值为26的钱，这样，1 -- 25,26,26+1 -- 26+25，这三个范围我都可以购买的吧 嗯，你说得对，但是我要是加一个面值为20的货币，1-25，（20），
CSP题解 201409-2 画图 C语言
weixin_45790260的博客
09-11 265
#include<stdio.h> #define SIZE 105 #define ROW 105 #define COL 4 /*寻找坐标集合当中对应矩形覆盖的面积*/ int rectangularAreaSum(int coordinate_set[][COL],int n,int tag_array[][SIZE]); /*过程中的一个函数，用来将矩形左下角的点对应的标记数组赋值为1*/ void assignTagArray(int tag_array[][COL],int x1,
先序非递归遍历算法遍历二叉树 ​中序非递归遍历算法遍历二叉树 ​后序非递归遍历算法遍历二叉树 ​层序遍历二叉树
最新发布
05-09
好的，我可以给您介绍一下二叉树的四种非递归遍历算法以及层序遍历。 先序非递归遍历算法： 1. 新建一个栈，将根节点入栈。 2. 当栈不为空时，取出栈顶元素并访问它。 3. 将当前节点的右子节点（如果存在）入栈，再...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值