数据结构的C实现_二叉树的非递归遍历和层序遍历

最新推荐文章于 2023-12-31 18:30:06 发布
最新推荐文章于 2023-12-31 18:30:06 发布
阅读量2k 收藏 1
点赞数
分类专栏： 数据结构 文章标签： 数据结构 c null struct tree 存储
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/mpbchina/article/details/7384363
版权 
//编译环境G++
#include <iostream>
#include <stdio.h>
#include <stdlib.h>
using namespace std;

//TreeNode///
typedef struct _TreeNode
{
    char key;
    struct _TreeNode *Lc;
    struct _TreeNode *Rc;
}TreeNode;


stack//
//Record作为栈结点的一个域，存储树结点的访问信息
typedef struct _StackRecord
{
    bool leftvisit;
    bool rightvisit;
    bool currentvisit;
    TreeNode *treenode;
}StackRecord;

//初始化Record
void InitStackRecord(StackRecord &s_record)
{
    s_record.leftvisit=false;
    s_record.rightvisit=false;
    s_record.currentvisit=false;
    s_record.treenode=NULL;
}

//栈结点
typedef struct _StackNode
{
    StackRecord record;
    struct _StackNode *next;
}StackNode;

//栈
typedef struct _Stack
{
    StackNode *top;
}Stack;

void InitStack(Stack &s)
{
    s.top=NULL;
}

bool isemptyS(Stack &s)
{
    if(s.top==NULL)
    return 1;
    return 0;
}

void Push(Stack &s,StackRecord e)
{
    StackNode *node=(StackNode*)malloc(sizeof(StackNode));
    node->record=e;
    node->next=NULL;
    node->next=s.top;
    s.top=node;
}

bool Pop(Stack &s,StackRecord &e)
{
    if(isemptyS(s)) return false;
    else
    {
        StackNode *node=s.top;
        e=node->record;
        s.top=node->next;
        free(node);
        return true;
    }
}

void DestroyStack(Stack &s)
{
    StackRecord temp;InitStackRecord(temp);
    while(Pop(s,temp)){}
}
///

Queue//
//队列结点
typedef struct _QNode
{
    TreeNode *treenode;
    struct _QNode *next;
}QNode;

//队列
typedef struct _Queue
{
    QNode *front;
    QNode *rear;
}Queue;

void InitQueue(Queue &Q)
{
    Q.front=NULL;
    Q.rear=NULL;
}

bool isemptyQ(Queue &Q)
{
    if(Q.front==NULL)
    return 1;
    return 0;
}
void EnQueue(Queue &Q,TreeNode *_treenode)
{
    //printf("EnQueue: %c\n",_treenode->key);
    QNode *s=(QNode*)malloc(sizeof(QNode));
    s->treenode=_treenode;
    s->next=NULL;
    if(isemptyQ(Q))
    {
        Q.front=s;
        Q.rear=s;
        return;
    }
    else
    {
        Q.rear->next=s;
        Q.rear=s;
    }
}

bool DeQueue(Queue &Q,TreeNode *&treenode)
{
    if(isemptyQ(Q))
    return false;
    else
    {
        QNode *node=Q.front;
        treenode=node->treenode;
        Q.front=node->next;
        if(Q.front==NULL)
        {
            Q.rear=NULL;
        }
        free(node);
    }
    return true;
}

void DestroyQueue(Queue &Q)
{
    TreeNode *temp;
    while(DeQueue(Q,temp)){}
}
/
//非递归先序遍历
void NRPreOrderTravserse(TreeNode *T)
{
    Stack stack;
    InitStack(stack);
    if(T!=NULL)
    {
        StackRecord record;
        InitStackRecord(record);
        record.treenode=T;
        Push(stack,record);
        while(!isemptyS(stack))
        {
            Pop(stack,record);
            //check current
            if(!record.currentvisit)
            {
                printf("%c ",record.treenode->key);
                record.currentvisit=true;
                Push(stack,record);
                continue;
            }

            //check left
            if(!record.leftvisit)
            {
                record.leftvisit=true;
                Push(stack,record);
                if(record.treenode->Lc!=NULL)
                {
                StackRecord leftrecord;
                InitStackRecord(leftrecord);
                leftrecord.treenode=record.treenode->Lc;
                Push(stack,leftrecord);
                }
                continue;
            }
            //check right
            if(!record.rightvisit)
            {
                record.rightvisit=true;
                Push(stack,record);
                if(record.treenode->Rc!=NULL)
                {
                StackRecord rightrecord;
                InitStackRecord(rightrecord);
                rightrecord.treenode=record.treenode->Rc;
                Push(stack,rightrecord);
                }
                continue;
            }
        }
    }
    DestroyStack(stack);
}

//非递归中序遍历
void NRInOrderTravserse(TreeNode *T)
{
    Stack stack;
    InitStack(stack);
    if(T!=NULL)
    {
        StackRecord record;
        InitStackRecord(record);
        record.treenode=T;
        Push(stack,record);
        while(!isemptyS(stack))
        {
            Pop(stack,record);
            //check left
            if(!record.leftvisit)
            {
                record.leftvisit=true;
                Push(stack,record);
                if(record.treenode->Lc!=NULL)
                {
                StackRecord leftrecord;
                InitStackRecord(leftrecord);
                leftrecord.treenode=record.treenode->Lc;
                Push(stack,leftrecord);
                }
                continue;
            }
            //check current
            if(!record.currentvisit)
            {
                printf("%c ",record.treenode->key);
                record.currentvisit=true;
                Push(stack,record);
                continue;
            }
            //check right
            if(!record.rightvisit)
            {
                record.rightvisit=true;
                Push(stack,record);
                if(record.treenode->Rc!=NULL)
                {
                StackRecord rightrecord;
                InitStackRecord(rightrecord);
                rightrecord.treenode=record.treenode->Rc;
                Push(stack,rightrecord);
                }
                continue;
            }
        }
    }
    DestroyStack(stack);
}

//非递归后序遍历
void NRPostOrderTravserse(TreeNode *T)
{
    Stack stack;
    InitStack(stack);
    if(T!=NULL)
    {
        StackRecord record;
        InitStackRecord(record);
        record.treenode=T;
        Push(stack,record);
        while(!isemptyS(stack))
        {
            Pop(stack,record);
            //check left
            if(!record.leftvisit)
            {
                record.leftvisit=true;
                Push(stack,record);
                if(record.treenode->Lc!=NULL)
                {
                StackRecord leftrecord;
                InitStackRecord(leftrecord);
                leftrecord.treenode=record.treenode->Lc;
                Push(stack,leftrecord);
                }
                continue;
            }

            //check right
            if(!record.rightvisit)
            {
                record.rightvisit=true;
                Push(stack,record);
                if(record.treenode->Rc!=NULL)
                {
                StackRecord rightrecord;
                InitStackRecord(rightrecord);
                rightrecord.treenode=record.treenode->Rc;
                Push(stack,rightrecord);
                }
                continue;
            }

            //check current
            if(!record.currentvisit)
            {
                printf("%c ",record.treenode->key);
                record.currentvisit=true;
                Push(stack,record);
                continue;
            }
        }
    }
    DestroyStack(stack);
}

//层序遍历，利用队列
void LevelTravserse(TreeNode *T)
{
    Queue Q;
    InitQueue(Q);
    //EnQueue(Q,T);
    if(T!=NULL)
    {
        EnQueue(Q,T);
        while(!isemptyQ(Q))
        {
            TreeNode *currentTreeNode;
            DeQueue(Q,currentTreeNode);

            if(currentTreeNode->Lc!=NULL)
            {
                EnQueue(Q,currentTreeNode->Lc);
            }
            if(currentTreeNode->Rc!=NULL)
            {
                EnQueue(Q,currentTreeNode->Rc);
            }
            printf("%c ",currentTreeNode->key);
        }
    }
    DestroyQueue(Q);
}

int main()
{
    TreeNode *tree,*p;
    p=(TreeNode*)malloc(sizeof(TreeNode));
    p->key='A';p->Lc=NULL;p->Rc=NULL;
    tree=p;

    p=(TreeNode*)malloc(sizeof(TreeNode));
	p->key='B';
	tree->Lc=p;

	p=(TreeNode*)malloc(sizeof(TreeNode));
	p->key='C';
	p->Lc=NULL;
	p->Rc=NULL;
	tree->Lc->Lc=p;

	p=(TreeNode*)malloc(sizeof(TreeNode));
	p->key='D';
	p->Lc=NULL;
	p->Rc=NULL;
	tree->Lc->Rc=p;

	p=(TreeNode*)malloc(sizeof(TreeNode));
	p->key='E';
	p->Lc=NULL;
	tree->Rc=p;

	p=(TreeNode*)malloc(sizeof(TreeNode));
	p->key='F';
	p->Lc=NULL;
	p->Rc=NULL;
	tree->Rc->Rc=p;

	NRPreOrderTravserse(tree);printf("\n");
	NRInOrderTravserse(tree);printf("\n");
	NRPostOrderTravserse(tree);printf("\n");
	LevelTravserse(tree);

  return 0;
}


mpbchina
关注
专栏目录
C++-二叉树递归遍历与非递归遍历实现
席木木的博客
10-24 3631
-二叉树递归遍历与非递归遍历实现引言0 有关线性表结点定义-LinkNode1 栈的链式存储结构实现-LinkedStack2 队列的链式存储结构实现-LinkedQueue3 二叉树的链式存储结构实现3.1 树的结点定义-TreeNode3.2 二叉树定义3.3 前中后序遍历-递归算法实现3.4 前中后序遍历-非递归算法实现3.5 层序遍历算法实现4 代码测试5 测试结果 引言     二叉树的遍历方法有：前序遍历、中序遍历、后序遍历、层序遍历，其中前中后序遍历又有
非递归方式实现二叉树四种遍历
兔子王
11-12 1398
【问题描述】 非递归方式实现二叉树的先序遍历、中序遍历、后序遍历和层序遍历。 提示：（1）利用先序建立二叉树序列；（2）求四种遍历结果。 【输入形式】 （1）先序建立二叉树序列 （2）非递归方式遍历 【输出形式】 四种遍历结果
数据结构课程设计二叉树的非递归遍历
07-28
数据结构 课程设计二叉树的非递归遍历 对任意给定的二叉树（顶点数自定）建立它的二叉链表存贮结构，并利用栈的五种基本运算（置空栈、进栈、出栈、取栈顶元素、判栈空）实现二叉树的先序、中序、后序三种遍历，输出三种遍历的结果。画出搜索顺序示意图
<二叉树 前中后 层序 非递归遍历 c语言实现>
yz171329935的专栏
01-29 604
非递归遍历要用到stack，出栈即访问 前序遍历：（中结点->左结点->右节点）  思路：先将根节点入栈，之后进入循环，先出栈一个结点A,  之后如果存在的话，将A的右结点入栈，再将A的左结点入栈，之后继续循环。。这样一直循环到栈空为止。 中序遍历:   （左结点->中结点->右节点） 思路：扫描根节点，将其所有左孩子结点全部入栈， 之后出栈一个结点A，之后再扫描A
第三章（非递归层序遍历二叉树（c语言实现））
a13683857889的博客
02-07 556
#include&lt;stdio.h&gt; #include&lt;stdlib.h&gt; #define TURE 1 #define FALSE 0 #define OK 1 #define ERROR 0 #define INSEASIBLE -1 #define OVERFLOW -2 typedef char ElemType; typedef int Status; typ...
数据结构——使用非递归方法后序遍历二叉树
Panda23333的博客
11-03 621
使用扩展先序遍历二叉树来进行二叉树的创建，使用非递归方法遍历二叉树，并且不同于书上使用的顺序栈，这里采用链栈，与顺序栈的不同是不能将NULL压栈，因此算法较复杂一些，是一次尝试。C语言代码：#include <stdio.h> #include <malloc.h> #include <stdlib.h>//定义二叉树 typedef struct BinaryTree{ char dat
C语言-数据结构-二叉树的递归遍历和非递归遍历
406156440的博客
08-16 4433
看了大量网络相关的理论和程序,多数的C++ 写的,这里使用devC++ 编程语言 C语言; 整合王道考研答案和理论, 还有小甲鱼的数据结构, 郝斌的数据结构,各有特点吧 最值得研究的还是后序遍历的非递归算法, 当时想了使用flag, 想到了多用一个栈, 想到了很多种方式,最后都以失败告终,经过网络查找, 感谢 https://www.cnblogs.com/rain-lei/p/3...
二叉树非递归遍历算法分析
weixin_43875867的博客
05-08 1107
本文介绍了二叉树非递归遍历算法的一种实现方式，以及这种遍历算法是怎么推导出来的。
二叉树递归遍历，非递归遍历，层序遍历
qq_58855682的博客
02-10 465
二叉树递归遍历，非递归遍历，层序遍历 节点 private static class TreeNode{ private int data; private TreeNode leftChild; private TreeNode rightChild; public TreeNode(int data){ this.data = data; } } 首先要有一个二叉树，通过对输入序列
二叉树的4种非递归遍历
！
05-01 1855
二叉树的4种非递归遍历，你知道吗？
(c语言)树的层序遍历(包含测试用例源码)
执念斩长河
03-25 1098
树的层序遍历是树的遍历一种，也是使得树的线索化变得轻而易举。
C语言二叉树（先中后序遍历、层序遍历、非递归先中后序遍历）
RETURN100ERRORS的博客
12-17 376
欢迎大家交流指正 #include<stdio.h> #include<stdlib.h> #define MAXSIZE_QUEUE 1000 #define MAXSIZE_STACK 1000 typedef char TElemType; typedef int Statistics; //树的结构体 typedef struct BitNode { TElemType data; Statistics count; //非递归后续遍历使用,用于统计次数
c语言描述的二叉树的基本操作（层序遍历，递归，非递归遍历）
anv65111的博客
07-29 395
#include<stdio.h> #include<stdlib.h> #define OK 1 #define ERROR 0 #define TRUE 1 #define FALSE 0 #define OVERFLOW -1 #define STACK_INIT_SIZE 100 #define STACKINCREMENT 10 ...
二叉树三种非递归遍历
qq_52526050的博客
12-31 666
二叉树三种非递归遍历王道书思想方法实现
数据结构 树的遍历（递归遍历）
weixin_30236595的博客
08-01 150
//树的遍历--递归遍历 #include<stdio.h> #include<stdlib.h> #include<string.h> typedef struct _TreeNode{ //数据域 char data; //指针域 struct _TreeNode * leftchild;//左孩子...
数据结构 二叉树的后序，层序遍历法（递归与非递归两种实现）
jiye111的博客
09-21 221
树的生成见上一篇博客 后序遍历： 1.遍历左边节点，到左叶子节点后返回父节点，切换到右子树 2.遍历右边结点，遍历完后回到父节点 记忆：左右根 例子（注意，这里的树和我创建的树不一样！！！）： 代码实现： 后序遍历的递归实现 public static void postOrderRecursion(TreeNode T) { if (T == null) ...
数据结构-层次遍历二叉树
李棚的CSDN专栏
07-08 2260
二叉树链表存储方式： struct BiNode {    Type  data;    struct BiNode *lchild,*rchild;//左右孩子指针 }BiNode,*BiTree
C语言数据结构之二叉树的递归和非递归以及层次遍历详细解析
Feeryman_Lee的博客
09-04 2577
1.二叉树的顺序存储结构、链式存储结构 2.二叉树的递归遍历（先序、中序、后序） 3.二叉树的非递归遍历（先序、中序、后序） 4.二叉树的层次遍历
c语言实现二叉树的层序遍历非递归
最新发布
06-30
在C语言中，非递归实现二叉树的层序遍历（也称为广度优先遍历）通常使用队列数据结构。以下是一个简单的步骤描述和示例代码： 1. 定义一个结构体来表示二叉树节点，包含值和左右子节点指针。 ```c typedef struct TreeNode { int val; struct TreeNode* left; struct TreeNode* right; } TreeNode; ``` 2. 创建一个队列，并初始化根节点（如果存在）。 3. 将根节点（如果有的话）加入队列。 4. 当队列不为空时，执行以下操作： a. 弹出队首元素作为当前节点。 b. 访问当前节点（打印值或其他操作）。 c. 将当前节点的左子节点（如果存在）加入队列。 d. 将当前节点的右子节点（如果存在）加入队列。 5. 重复步骤4直到队列为空。 下面是对应的C语言代码示例： ```c #include <stdio.h> #include <stdlib.h> #include <queue> void levelOrderTraversal(TreeNode* root) { if (root == NULL) return; // 如果根节点为空，直接返回 queue<TreeNode*> q; q.push(root); // 先将根节点入队 while (!q.empty()) { TreeNode* node = q.front(); q.pop(); // 弹出队首节点 printf("%d ", node->val); // 访问节点值 if (node->left != NULL) q.push(node->left); if (node->right != NULL) q.push(node->right); } } // 示例用法 int main() { // 构建一个简单的二叉树 TreeNode* root = (TreeNode*)malloc(sizeof(TreeNode)); root->val = 1; root->left = (TreeNode*)malloc(sizeof(TreeNode)); root->left->val = 2; root->right = (TreeNode*)malloc(sizeof(TreeNode)); root->right->val = 3; root->left->left = (TreeNode*)malloc(sizeof(TreeNode)); root->left->left->val = 4; root->left->right = (TreeNode*)malloc(sizeof(TreeNode)); root->left->right->val = 5; levelOrderTraversal(root); printf("\n"); return 0; } ```
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值