二叉树部分的常见算法与实现

最新推荐文章于 2024-07-23 16:20:46 发布
最新推荐文章于 2024-07-23 16:20:46 发布
阅读量72 收藏 1
点赞数
文章标签： 数据结构与算法
原文链接：http://www.cnblogs.com/Manual-Linux/p/11315776.html
版权

二叉树

二叉树的遍历非常重要，一定要熟练掌握。

  • 因为二叉树的层序创建，层序遍历均用到了队列结构，二叉树的非递归遍历用到了堆栈结构，这部分的代码在后面单独给出。
  • 二叉树的后序非递归遍历有两种实现思路，在下面的代码中只实现了一种。

二叉树的链表结构为：

struct TNode
{
    int Data;  //节点的数据
    struct TNode* Left;  //指向左子树
    struct TNode* Right;  //指向右子树
};

typedef struct TNode* ElementType;

二叉树部分的算法与相关代码实现

#define _CRT_SECURE_NO_WARNINGS
#include<stdio.h>
#include"queue.h"
#include"Stack.h"
#define NoInfo 0  //用0表示没有节点

//struct TNode
//{
//  int Data;  //节点的数据
//  struct TNode* Left;  //指向左子树
//  struct TNode* Right;  //指向右子树
//};

//作用：层序生成二叉树
struct TNode* CreatBinTree()
{
    int Data;
    struct QNode* Q = CreatQueue(10);  //创建空队列
    struct TNode* T;
    struct TNode* BT;

    //建立第一个节点，即根节点
    scanf("%d",&Data);
    if (Data != NoInfo)
    {
        //动态分配一个结点单元，并存入数据，同时将该结点地址放入队列
        BT = (struct TNode *)malloc(sizeof(struct TNode));
        BT->Data = Data;
        BT->Left = NULL;
        BT->Right = NULL;
        AddQ(Q,BT);
    }
    else
    {
        return NULL;
    }

    while (!IsEmpty(Q))
    {
        T = DeleteQ(Q);  //从队列中取出一节点地址
        scanf("%d",&Data);
        if (Data != NoInfo)
        {
            //动态分配一个结点单元，并存入数据，同时将该结点地址放入队列
            T->Left = (struct TNode *)malloc(sizeof(struct TNode));
            T->Left->Data = Data;
            T->Left->Left = NULL;
            T->Left->Right = NULL;
            
            AddQ(Q, T->Left);
        }
        else
        {
            T->Left = NULL;
        }
        //读入右孩子的数据
        scanf("%d", &Data);
        if (Data != NoInfo)
        {
            //动态分配一个结点单元，并存入数据，同时将该结点地址放入队列
            T->Right = (struct TNode *)malloc(sizeof(struct TNode));
            T->Right->Data = Data;
            T->Right->Left = NULL;
            T->Right->Right = NULL;

            AddQ(Q, T->Right);
        }
        else
        {
            T->Right = NULL;
        }   
    } //end while (!IsEmpty(Q))
    return BT;
}
//作用：二叉树的递归后序遍历
void PostorderTraversal(struct TNode* BT)
{
    if (BT)
    {
        PostorderTraversal(BT->Left);
        PostorderTraversal(BT->Right);
        printf("%d. ", BT->Data);
    }
}
//作用：二叉树的递归先序遍历
void PreorderTraversal(struct TNode* BT)
{
    if (BT)
    {
        printf("%d. ", BT->Data);
        PreorderTraversal(BT->Left);
        PreorderTraversal(BT->Right);
    }
}
//作用：二叉树的递归中序遍历
void InorderTraversal(struct TNode* BT)
{
    if (BT)
    {
        InorderTraversal(BT->Left);
        printf("%d. ", BT->Data);
        InorderTraversal(BT->Right);
    }
}
//作用：二叉树的非递归中序遍历
void InorderTraversal2(struct TNode* BT)
{
    struct TNode* T;

    struct SNode* S = CreatStack(10);

    T = BT;
    
    while (T || !IsStackEmpty(S))
    {
        while (T)
        {
            Push(S, T);
            T = T->Left;
        }
        T = Pop(S);
        printf("%d. ",T->Data);
        T = T->Right;  //转向右子树
    }
}
//作用：二叉树的非递归先序遍历
void PreorderTraversal2(struct TNode* BT)
{
    struct TNode* T;

    struct SNode* S = CreatStack(10);

    T = BT;

    while (T || !IsStackEmpty(S))
    {
        while (T)
        {
            printf("%d. ", T->Data);
            Push(S, T);
            T = T->Left;
        }
        T = Pop(S);
        T = T->Right;  //转向右子树
    }
}
//作用：二叉树的非递归后序遍历
//思路1 将先序遍历的算法进行更改
void PostorderTraversal2(struct TNode* BT)
{
    struct TNode* T;

    struct SNode* S1 = CreatStack(10);
    struct SNode* S2 = CreatStack(10);

    T = BT;

    while (T || !IsStackEmpty(S1))
    {
        while (T)
        {
            //printf("%d. ", T->Data);
            Push(S2, T);  //压入根节点
            Push(S1, T);
            T = T->Right;
        }
        T = Pop(S1);
        T = T->Left;  //转向左子树
    }
    while (!IsStackEmpty(S2))
    {
        T = Pop(S2);
        printf("%d. ",T->Data);
    }
}
//作用：二叉树的非递归后序遍历
//思路2 
//ToDo: 参考博客园博客，这里有一个思路2还没有写
void PostorderTraversal3(struct TNode* BT)
{



}
//作用：层序遍历
void LevelorderTraversal(struct TNode* BT)
{
    struct QNode* Q;
    struct TNode* T;
    if (!BT)
    {
        return;  //若是空树，直接返回
    }
    Q = CreatQueue(10);
    AddQ(Q, BT);  //首先将根节点入队

    while (!IsEmpty(Q))
    {
        T = DeleteQ(Q);
        printf("%d. ", T->Data);
        if (T->Left != NULL)
        {
            AddQ(Q, T->Left);
        }
        if (T->Right != NULL)
        {
            AddQ(Q,T->Right);
        }
    }

}
//作用:输出二叉树的叶子结点
void PreorderPrintLeaves(struct TNode* BT)
{
    if (BT)
    {
        if (BT->Left == NULL && BT->Right == NULL)
        {
            printf("%d. ", BT->Data);
        }
        PreorderPrintLeaves(BT->Left);
        PreorderPrintLeaves(BT->Right);
    }
}
//作用:求二叉树的高度
int GetHeight(struct TNode* BT)
{
    int HL;
    int HR;
    int MaxH;
    if (BT)  //BT非空进行遍历
    {
        HL = GetHeight(BT->Left);
        HR = GetHeight(BT->Right);
        MaxH = HL > HR ? HL : HR;
         return MaxH + 1;
    }
    else
    {
        return 0;
    }
    
}
int main()
{
    struct TNode* BT = CreatBinTree();
    printf("中序递归遍历:\n");
    InorderTraversal(BT);
    printf("\n先序递归遍历:\n");
    PreorderTraversal(BT);
    printf("\n后序递归遍历:\n");
    PostorderTraversal(BT);

    printf("\n非递归中序遍历:\n");
    InorderTraversal2(BT);
    printf("\n非递归先序遍历:\n");
    PreorderTraversal2(BT);
    printf("\n非递归后序遍历:\n");
    PostorderTraversal2(BT);
    printf("\n层序遍历\n");
    LevelorderTraversal(BT);
    printf("\n输出二叉树中所有的叶子结点\n");
    PreorderPrintLeaves(BT);
    printf("二叉树的高度: %d.\n", GetHeight(BT));
    system("pause");
    return 0;
}

实现链表部分的代码：

queue.h

//二叉树的创建需要队列
//该文件实现队列的一系列操作
#pragma once
#include<stdio.h>
#include<stdbool.h>
#include<stdlib.h>

struct TNode
{
    int Data;  //节点的数据
    struct TNode* Left;  //指向左子树
    struct TNode* Right;  //指向右子树
};

typedef struct TNode* ElementType;

struct QNode 
{
    ElementType* Data;  //存储元素的数组
    int Front;  //队列的头指针
    int Rear;  //队列的尾指针
    int MaxSize;  //队列的最大容量
};

struct QNode* CreatQueue(int MaxSize);
bool IsFull(struct QNode* Q);
bool AddQ(struct QNode* Q, ElementType x);
bool IsEmpty(struct QNode* Q);
ElementType DeleteQ(struct QNode* Q);

queue.c

#include<stdio.h>
#include"queue.h"
//作用：创建一个队列
//参数：队列的大小
struct QNode* CreatQueue(int MaxSize)
{
    struct QNode* Q = (struct QNode *)malloc(sizeof(struct QNode));
    Q->Data = (ElementType *)malloc(MaxSize * sizeof(int));
    Q->Front = Q->Rear = 0;
    Q->MaxSize = MaxSize;
    return Q;
}
//作用：判断当前队列是否满
//参数：待判断的队列
bool IsFull(struct QNode* Q)
{
    return ((Q->Rear + 1) % Q->MaxSize == Q->Front);
}
//作用：向队列中插入元素
//参数：struct QNode* Q 待插入的队列
//      int x 待插入的元素
bool AddQ(struct QNode* Q, ElementType x)
{
    if (IsFull(Q))  //判断队列是否为空
    {
        printf("队列满，不能再插入元素\n");
        return false;
    }
    else
    {
        Q->Rear = (Q->Rear + 1) % Q->MaxSize;
        Q->Data[Q->Rear] = x;
        return true;
    }
}
//作用：判断队列是否为空
//参数：
//返回值： true   空
//         false  非空
bool IsEmpty(struct QNode* Q)
{
    return (Q->Front == Q->Rear);
}
//作用：
//参数：
ElementType DeleteQ(struct QNode* Q)
{
    if (IsEmpty(Q))
    {
        printf("队列为空\n");
        return NULL;
    }
    else
    {
        Q->Front = (Q->Front + 1) % Q->MaxSize;
        return Q->Data[Q->Front];
    }
}

实现堆栈部分的代码：

Stack.h

#pragma once
#include<stdbool.h>
#include"queue.h"

struct SNode
{
    ElementType* Data;  //存储元素的数组
    int Top;  //栈顶指针
    int MaxSize;  //堆栈的最大容量
};

struct SNode* CreatStack(int MaxSize);
bool IsStackFull(struct SNode* S);
bool Push(struct SNode* S,ElementType x);
bool IsStackEmpty(struct SNode* S);
ElementType Pop(struct SNode* S);

Stack.c

#include"Stack.h"
#include<stdlib.h>

struct SNode* CreatStack(int MaxSize)
{
    struct SNode* S = (struct SNode *)malloc(sizeof(struct SNode));
    S->Data = (ElementType *)malloc(MaxSize * sizeof(ElementType));
    S->MaxSize = MaxSize;
    S->Top = -1;
    return S;
}
//作用：判断当前堆栈是否满
//返回值： ture 当前堆栈满
//         false 当前堆栈非满
bool IsStackFull(struct SNode* S)
{
    return S->Top == S->MaxSize - 1;
}
bool Push(struct SNode* S, ElementType x)
{
    if (IsStackFull(S))
    {
        printf("当前堆栈已满.\n");
        return false;
    }
    else
    {
        S->Top = S->Top + 1;
        S->Data[S->Top] = x;
        return true;
    }

}
//作用:判断当前堆栈是否为空
//返回值：true 空
//        false 非空
bool IsStackEmpty(struct SNode* S)
{
    return S->Top == -1;

}
ElementType Pop(struct SNode* S)
{
    if (IsStackEmpty(S))
    {
        printf("堆栈为空.\n");
        return false;
    }
    else
    {
        return S->Data[(S->Top)--];
    }
}

运行结果：
1327401-20190808162545010-380964479.png

转载于:https://www.cnblogs.com/Manual-Linux/p/11315776.html

weixin_30265171
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
数据结构 - 二叉树代码实现
Hello World
03-18 815
二叉树实战和进阶 文章目录二叉树实战和进阶代码实现数据结构创建遍历计算深度应用 我们将通过代码来实现以下这个二叉树的各种操作。 代码实现 数据结构 在这个例子中，我们将字符型作为ElemType，使用链表构成二叉树数据，结点包括数据、指向左右孩子的结点指针： typedef struct Node { char data; struct Node *lchild, *rchild...
二叉树的常见算法
heima201907的博客
02-21 174
本帖最后由 小蜀哥哥 于 2019-8-1 17:40 编辑1.二叉树的遍历算法二叉树的遍历主要分为三种：先序遍历，中序遍历和后序遍历。还有一种就是按照层次遍历。 按照惯例，左孩子优先于右孩子，那么： 先序遍历指的就是先访问本节点，再访问该节点的左孩子和右孩子； 中序遍历指的就是：先访问左孩子，再访问本节点，最后访问右孩子； ...
JAVA实现二叉树(简易版--实现了二叉树的各种遍历)
weixin_33755847的博客
04-28 103
1，个人感觉二叉树的实现主要还是如何构造一颗二叉树。构造二叉树函数的设计方法多种多样，本例采用 addNode 方法实现。以下程序通过定义内部类来表示二叉树的结点，然后再实现了二叉树这种数据结构的一些基本操作。  2，说说以下程序的一些不足：  a，56行中的判断树是否为空时，依据根结点的数据域是否为空来判断。而使用不带参数的构造函数构造二叉树时，根结点的不空的，此时说明树已经有了根结点，但是...
【数据结构】之二叉树的java实现
dawuafang
10-02 525
二叉树的定义： 二叉树是树形结构的一个重要类型。许多实际问题抽象出来的数据结构往往是二叉树的形式，即使是一般的树也能简单地转换为二叉树，而且二叉树的存储结构及其算法都较为简单，因此二叉树显得特别重要。 二叉树(BinaryTree)是n(n≥0)个结点的有限集，它或者是空集(n=0)，或者由一个根结点及两棵互不相交的、分别称作这个根的左子树和右子树的二叉树组成。 这个定义是递归的。由于左...
二叉树的代码实现
学习、记录、分享
10-30 997
#!/usr/bin/env python # -*- coding: utf-8 -*- # @Time : 2018/10/29 15:11 # @Author : zhangz # @Site : # @File : erchashu.py # @Software: PyCharm # 实现二叉树 # 构建节点对象 class Node(object): d...
二叉树的简单实现及其部分面试题
weixin_34150503的博客
04-21 67
树的基本概念：树是n（n>=0）个有限个数据的元素集合，形状像一颗倒过来的树。结点：结点包含数据和指向其它结点的指针。根节点：树第一个结点称为根节点。结点的度：结点拥有的子节点个数。叶节点：没有子节点的节点(度为0)。父子节点：一个节点father指向另一个节点child，则child为孩子节点，father为父亲结点。...
java 常见排序算法的实现 包括二叉树
10-08
在编程领域，排序算法是数据结构与算法学习中的基础部分，尤其在Java中，掌握各种排序算法的实现有助于提升程序的效率和理解力。本文将详细介绍几种常见的排序算法及其Java实现，同时也会涉及二叉树的基本概念和实现...
红黑树、平衡二叉树、排序算法的java实现
11-21
本文将深入探讨"红黑树"、"平衡二叉树"、"二叉树"、"二叉搜索树"以及"排序算法"这些关键概念，并在Java环境下进行实现。 首先，我们来理解"二叉树"。二叉树是一种特殊的树形数据结构，每个节点最多有两个子节点，...
二叉树的C++算法实现的源代码
07-15
二叉树的C++算法实现源代码学习指南 二叉树是一种常见的数据结构，它广泛应用于计算机科学和信息技术领域。学习二叉树的算法实现对于编程初学者来说是非常重要的。本文将对二叉树的C++算法实现进行详细的分析和讲解...
常见的七大排序算法Java实现.zip
07-30
本压缩包"常见的七大排序算法Java实现.zip"包含了七种经典的排序算法在Java语言中的实现。尽管文件列表中并未明确列出每种排序算法的名称，但根据常规，这七大排序算法可能包括冒泡排序、插入排序、选择排序、快速...
二叉树的简单实现
weixin_34414650的博客
12-20 53
二叉树数组表示 Tree.h： #ifndef _TREE_H_ #define _TREE_H_ #include <iostream> using namespace std; typedef int ElemType; //元素类型 class CTree { public: CTree(int isize,ElemType* root); ...
【数据结构】二叉树的实现&递归遍历（完整代码）
热门推荐
ly_6699的博客
02-23 1万+
二叉树实现的功能包含以下内容： 1.按要求创建一棵树 2.计算树节点，树叶子节点的个数 3.输出树中第n层的节点个数 4.关于树前序，中序，后序的递归遍历 5.树的层序遍历 6.判断树是否为完全二叉树 7.树的前序，中序，后序的非递归遍历 >二叉树的递归遍历:直接按遍历顺序递归调用 >二叉树的层序遍历可以借用队列结构来实现 >二叉树的非递归遍历可以借用栈结构来实现 > **前序遍历: 根 -- 左 -- 右 > 中序遍历: 左 -- 根 -- 右 > 后序遍历: 左 -- 右 -- 根**
【刷题汇总 -- 爱丽丝的人偶、集合、最长回文子序列】
最新发布
m0_69455439的博客
07-23 504
今日刷题汇总day021 -- 爱丽丝的人偶、集合、最长回文子序列
【LeetCode】分隔链表
qq_26521261的博客
07-20 385
给你一个链表的头节点 head 和一个特定值 x ，请你对链表进行分隔，使得所有 小于 x 的节点都出现在 大于或等于 x 的节点之前。简单粗暴的做法：遍历原链表，当前节点新建一个，遇到小的，放到小的链表中，遇到大的，放到大的链表中，最后合并一下。输入：head = [1,4,3,2,5,2], x = 3。你应当 保留 两个分区中每个节点的初始相对位置。输入：head = [2,1], x = 2。链表中节点的数目在范围 [0, 200] 内。输出：[1,2,2,4,3,5]
代码随想录打卡第二十九天
weixin_48013375的博客
07-19 549
day 29 贪心算法第三天。
数据结构——二叉树性质
鲸落博客
07-23 296
这个性质很好记忆，观察一下图6-5-5。第一层是根结点，只有一个，所以2^(1-1)=2^0=1。第二层有两个，2^(2-1)=2=2。第三层有四个，2^(3-1)=2^2=4。第四层有八个，2^(4-1)=2^3=8。通过数据归纳法的论证，可以很容易得出在二叉树的第i层上至多有2^(i-1)个结点(i≥1)的结论。
文心一言 VS 讯飞星火 VS chatgpt （307）-- 算法导论22.2 5题
福大大架构师每日一题
07-21 760
首先，我们来证明在广度优先搜索（BFS）算法中，赋给结点 $ u $ 的 $ u.d $ 值（即结点 $ u $ 被发现的次序或距离）与结点在邻接链表中的出现次序无关。
大模型面经
weixin_43744732的博客
07-19 1222
大模型，面试，八股文
非递归遍历二叉树：优化算法与Java实现
课程教学部分强调了实践的重要性，例如48小时的理论教学和8小时的上机实践，通过《数据结构、算法与应用: java语言描述》等教材进行深入讲解。这些书籍详细介绍了数据结构的基础概念，如数据、数据元素、数据项的...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值