【数据结构与算法】二叉树的介绍和程序实现

最新推荐文章于 2023-12-25 20:32:21 发布
最新推荐文章于 2023-12-25 20:32:21 发布
阅读量581 收藏 1
点赞数
分类专栏： # 数据结构和算法 文章标签： 二叉树 满二叉树 完全二叉树 二叉树遍历 二叉树查找指定节点
版权声明：本文为博主原创文章，遵循 CC 4.0 BY 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/yy8623977/article/details/126765667
版权

目录

1. 二叉树的介绍

树有很多种，每个节点最多只能有两个子节点的一种形式称为二叉树。二叉树的子节点分为左节点和右节点

如果该二叉树的所有叶子节点都在最后一层，并且节点总数 = 2 n − 1 2^n -1 2n−1, n为层数，则我们称为满二叉树，如下所示：

满二叉树

如果该二叉树的所有叶子节点都在最后一层或倒数第二层，而且最后一层的叶子节点在左边连续，倒数第二层的叶子节点在右边连续，我们称为完全二叉树。如果把 节点61删除，就不是完全二叉树了, 因为叶子节点不连续了。如下所示：

完全二叉树

2. 二叉树的遍历说明

前序、中序、后序是根据输出父节点的顺序确定的

前序遍历

  1. 先输出当前节点(初始的时候是root节点)
  2. 如果左子节点不为空，则递归继续前序遍历
  3. 如果右子节点不为空，则递归继续前序遍历

中序遍历

  1. 如果当前节点的左子节点不为空，则递归中序遍历
  2. 输出当前节点
  3. 如果当前节点的右子节点不为空，则递归中序遍历

后序遍历

  1. 如果当前节点的左子节点不为空，则递归后序遍历
  2. 如果当前节点的右子节点不为空，则递归后序遍历
  3. 输出当前节点

3. 二叉树查找指定节点说明

前序查找思路

  1. 先判断当前节点的id是否等于要查找的，如果相等，则返回当前节点
  2. 如果不相等。则判断当前节点的左子节点是否为空，如果不为空，则递归前序查找
  3. 如果左递归前序查找，找到节点，则返回，否则继续判断当前节点的右子节点是否为空，如果不为空，则继续向右递归前序查找
  4. 如果右递归前序查找，找到节点，则返回，否则返回null

中序查找思路

  1. 判断当前节点的左子节点是否为空，如果不为空，则递归中序查找
  2. 如果找到，则返回，如果没有找到，就和当前节点比较，如果相等则返回当前节点
  3. 如果不相等，则判断当前节点的右子节点是否为空，如果不为空，则递归中序查找
  4. 如果右递归中序查找，找到节点，则返回，否则返回null

后序查找思路

  1. 判断当前节点的左子节点是否为空，如果不为空，则递归后序查找
  2. 如果找到，就返回，如果没有找到，就判断当前节点的右子节点是否为空，如果不为空，则右递归进行后续查找，如果找到，就返回
  3. 如果右递归没找到，就和当前节点进行比较，如果相等则返回
  4. 如果不相等，则返回null

4. 二叉树删除指定节点说明

删除要求：如果删除的节点是叶子节点，则删除该节点；如果删除的节点是非叶子节点，则删除该子树

删除节点思路：

  1. 如果root节点不为空，且删除的节点是root节点，则直接将root节点置为null
  2. 如果当前节点的左子节点不为空，并且左子节点就是要删除的节点，则this.left = null，并且返回结束递归删除
  3. 如果当前节点的右子节点不为空，并且右子节点就是要删除的节点，则this.right = null，并且返回结束递归删除
  4. 如果第2步和第3步都没有删除节点，且当前节点的左子节点不为空，则向左子节点进行递归删除
  5. 如果第4步也没有删除节点，且当前节点的右子节点不为空，则向右子节点进行递归删除

5. 二叉树的添加节点、遍历节点、查找指定节点、删除指定节点程序实现

public class BinaryTreeDemo {

    public static void main(String[] args) {
        // 创建一颗二叉树
        BinaryTree binaryTree = new BinaryTree();

        // 创建需要的节点
        Node root = new Node(1, "node1");
        Node node2 = new Node(2, "node2");
        Node node3 = new Node(3, "node3");
        Node node4 = new Node(4, "node4");
        Node node5 = new Node(5, "node5");

        // 各个节点形成子树
        root.left = node2;
        root.right = node3;
        node2.left = node4;
        node2.right = node5;

        // 将root节点添加到二叉树
        binaryTree.setRoot(root);

        // 测试遍历
        System.out.println("前序遍历：");
        binaryTree.preOrder();
        System.out.println("中序遍历：");
        binaryTree.infixOrder();
        System.out.println("后序遍历：");
        binaryTree.postOrder();

        // 测试遍历查找
        int orderSearchId = 5;
        System.out.print("前序遍历查找：");
        Node resultNode = binaryTree.preOrderSearch(orderSearchId);
        if (resultNode != null) {
            System.out.println("找到的节点信息为：" + resultNode);
        } else {
            System.out.printf("没有找到id为%d的节点\n", orderSearchId);
        }
        System.out.print("中序遍历查找：");
        resultNode = binaryTree.infixOrderSearch(orderSearchId);
        if (resultNode != null) {
            System.out.println("找到的节点信息为：" + resultNode);
        } else {
            System.out.printf("没有找到id为%d的节点\n", orderSearchId);
        }
        System.out.print("后序遍历查找：");
        resultNode = binaryTree.postOrderSearch(orderSearchId);
        if (resultNode != null) {
            System.out.println("找到的节点信息为：" + resultNode);
        } else {
            System.out.printf("没有找到id为%d的节点\n", orderSearchId);
        }

        // 测试删除节点
        System.out.printf("开始进行删除操作：");
        binaryTree.deleteNode(2);
        System.out.println("删除后进行前序遍历：");
        binaryTree.preOrder();

    }

}


// 树的Node节点
class Node {
    public int id;
    public String name;
    // 默认为null
    public Node left;
    // 默认为null
    public Node right;

    public Node(int id, String name) {
        this.id = id;
        this.name = name;
    }

    @Override
    public String toString() {
        return "Node [id = " + id + ", name = " + name + "]";
    }

    // 前序遍历实现
    public void preOrder() {
        // 先输出当前节点
        System.out.println(this);
        // 递归向左子树前序遍历
        if (this.left != null) {
            this.left.preOrder();
        }
        // 递归向右子树前序遍历
        if (this.right != null) {
            this.right.preOrder();
        }
    }

    // 中序遍历实现
    public void infixOrder() {
        // 递归向左子树中序遍历
        if (this.left != null) {
            this.left.infixOrder();
        }
        // 输出当前节点
        System.out.println(this);
        // 递归向右子树中序遍历
        if (this.right != null) {
            this.right.infixOrder();
        }
    }


    // 后序遍历实现
    public void postOrder() {
        // 递归向左子树后序遍历
        if (this.left != null) {
            this.left.postOrder();
        }
        // 递归向右子树后序遍历
        if (this.right != null) {
            this.right.postOrder();
        }
        // 输出当前节点
        System.out.println(this);
    }

    // 前序遍历查找
    public Node preOrderSearch(int id) {
        // 比较当前结点是不是
        if (this.id == id) {
            return this;
        } else {
            // 判断当前节点的左子节点是否为空，如果不为空，则递归前序查找
            Node resultNode = null;
            if (this.left != null) {
                resultNode = this.left.preOrderSearch(id);
            }
            // 如果左递归前序查找，找到节点，则返回
            if (resultNode != null) {
                return resultNode;
            } else {
                // 否则继续判断当前节点的右子节点是否为空，如果不为空，则继续向右递归前序查找
                if (this.right != null) {
                    resultNode = this.right.preOrderSearch(id);
                }
                // 如果右递归前序查找，找到节点，则返回，否则返回null
                return resultNode;
            }

        }
    }

    // 中序遍历查找
    public Node infixOrderSearch(int id) {
        // 判断当前节点的左子节点是否为空，如果不为空，则递归中序查找
        Node resultNode = null;
        if (this.left != null) {
            resultNode = this.left.infixOrderSearch(id);
        }
        // 如果找到，则返回
        if (resultNode != null) {
            return resultNode;
        } else {
            // 如果没有找到，就和当前节点比较，如果相等则返回当前节点
            if (this.id == id) {
                return this;
            } else {
                // 如果不相等，则判断当前节点的右子节点是否为空，如果不为空，则递归中序查找
                if (this.right != null) {
                    resultNode = this.right.infixOrderSearch(id);
                }
                // 如果右递归中序查找，找到节点，则返回，否则返回null
                return resultNode;
            }
        }
    }

    // 后序遍历查找
    public Node postOrderSearch(int id) {

        // 判断当前节点的左子节点是否为空，如果不为空，则递归后序查找
        Node resultNode = null;
        if (this.left != null) {
            resultNode = this.left.postOrderSearch(id);
        }
        // 如果找到，就返回
        if (resultNode != null) {
            return resultNode;
        } else {
            // 如果没有找到，就判断当前节点的右子节点是否为空，如果不为空，则右递归进行后续查找
            if (this.right != null) {
                resultNode = this.right.postOrderSearch(id);
            }
            // 如果找到，就返回
            if (resultNode != null) {
                return resultNode;
            } else {
                // 如果右递归没找到，就和当前节点进行比较，如果相等则返回
                if (this.id == id) {
                    return this;
                } else {
                    // 如果不相等，则返回null
                    return resultNode;
                }
            }
        }
    }


    // 删除节点实现。返回值表示是否删除节点
    public boolean deleteNode(int id) {
        // 如果当前节点的左子节点不为空，并且左子节点就是要删除的节点，则this.left = null，并且返回结束递归删除
        if (this.left != null && this.left.id == id) {
            this.left = null;
            return true;
            // 如果当前节点的右子节点不为空，并且右子节点就是要删除的节点，则this.right = null，并且返回结束递归删除
        } else if (this.right != null && this.right.id == id) {
            this.right = null;
            return true;
            // 否则，如果当前节点的左子节点不为空，则向左子节点进行递归删除
        } else if (this.left != null) {
            boolean isDeleteNode = this.left.deleteNode(id);
            // 如果向左递归已经删除节点，就没必要进行向右递归删除了
            if (isDeleteNode) {
                return isDeleteNode;
            } else {
                // 否则，如果当前节点的右子节点不为空，则向右子节点进行递归删除
                if (this.right != null) {
                    // 直接返回向右递归删除的结果
                    return this.right.deleteNode(id);
                }
            }
        }

        // 如果当前节点的右节点为空，则表示未找到删除的节点，返回false
        return false;
    }

}


// BinaryTree二叉树
class BinaryTree {
    private Node root;

    public void setRoot(Node root) {
        this.root = root;
    }


    // 前序遍历实现
    public void preOrder() {
        if (this.root != null) {
            this.root.preOrder();
        } else {
            System.out.println("二叉树为空，无法遍历");
        }
    }

    // 中序遍历实现
    public void infixOrder() {
        if (this.root != null) {
            this.root.infixOrder();
        } else {
            System.out.println("二叉树为空，无法遍历");
        }
    }

    // 后序遍历实现
    public void postOrder() {
        if (this.root != null) {
            this.root.postOrder();
        } else {
            System.out.println("二叉树为空，无法遍历");
        }
    }

    // 前序遍历查找
    public Node preOrderSearch(int id) {
        if (root != null) {
            return root.preOrderSearch(id);
        } else {
            return null;
        }
    }

    // 中序遍历查找
    public Node infixOrderSearch(int id) {
        if (root != null) {
            return root.infixOrderSearch(id);
        } else {
            return null;
        }
    }

    //后序遍历查找
    public Node postOrderSearch(int id) {
        if (root != null) {
            return this.root.postOrderSearch(id);
        } else {
            return null;
        }
    }

    // 删除结点实现
    public void deleteNode(int id) {
        if (root != null) {
            // 如果root节点不为空，且删除的节点是root节点，则直接将root节点置为null
            if (root.id == id) {
                root = null;
                System.out.printf("id为%d的节点已删除\n", id);
            } else {
                // 递归进行删除
                boolean isDeleteNode = root.deleteNode(id);
                if (isDeleteNode) {
                    System.out.printf("id为%d的节点已删除\n", id);
                } else {
                    System.out.println("未找到删除的节点");
                }
            }
        } else {
            System.out.println("空树，不能删除");
        }
    }
}

运行程序，结果如下：

前序遍历：
Node [id = 1, name = node1]
Node [id = 2, name = node2]
Node [id = 4, name = node4]
Node [id = 5, name = node5]
Node [id = 3, name = node3]
中序遍历：
Node [id = 4, name = node4]
Node [id = 2, name = node2]
Node [id = 5, name = node5]
Node [id = 1, name = node1]
Node [id = 3, name = node3]
后序遍历：
Node [id = 4, name = node4]
Node [id = 5, name = node5]
Node [id = 2, name = node2]
Node [id = 3, name = node3]
Node [id = 1, name = node1]
前序遍历查找：找到的节点信息为：Node [id = 5, name = node5]
中序遍历查找：找到的节点信息为：Node [id = 5, name = node5]
后序遍历查找：找到的节点信息为：Node [id = 5, name = node5]
开始进行删除操作：id为2的节点已删除
删除后进行前序遍历：
Node [id = 1, name = node1]
Node [id = 3, name = node3]
Bulut0907
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
数据结构与算法--二叉树创建及遍历
weixin_45080106的博客
05-15 1293
#include using namespace std; typedef char DataType; //二叉树数据结构 struct node { DataType info ; //存放结点数据 struct node *lchild , *rchild ; //指向左右孩子的指针 }; typedef struct node *BiTree ; /创建二叉树 函数名：createBiTree 参数：无 返回值：二叉树根结点指针 / BiTree createBiTree(void) { //请在
数据结构和算法-二叉排序树
熊诗言的博客
04-29 179
感谢尚硅谷韩顺平老师深入细致的讲解 二叉排序树：BST: (Binary Sort(Search) Tree), 对于二叉排序树的任何一个非叶子节点，要求左子节点的值比当前节点的值小，右子节点的值比当前节点的值大。 特别说明：如果有相同的值，可以将该节点放在左子节点或右子节点 比如针对前面的数据 (7, 3, 10, 12, 5, 1, 9) ，对应的二叉排序树为： 如果插入2，则变为 添加节点和中序遍历 //创建二叉排序树 class BinarySortTree { private Node ro
C语言：实现二叉树各种操作程序
Aqu-蓝空的博客
08-04 2325
#include<stdio.h> #include<stdlib.h> typedef struct BiTNode { char data; struct BiTNode *lchild,*rchild; }BiTNode,*BiTree; void createbitree(BiTree *T)//先序遍历建立二叉树 { char ch; scanf("%c",&ch); if(ch=='#') *T=NULL.
C语言学习之二叉树的实现详解
分享型博主
03-27 2004
include # include // 节点结构体 struct node {int data;// 节点数据 struct node * left;// 左子树指针 struct node * right;// 右子树指针 };// 新建节点 struct node * new_node(int data) {// 为新节点分配内存空间 node -> data = data;// 设置新节点数据 node -> left = NULL;
二叉树程序
m0_62466950的博客
05-22 264
该程序使用递归算法和非递归算法实现了二叉树的先序、中序、后序遍历，以及先序遍历的非递归算法、层次遍历、求树的高度、求叶子结点个数、计算孩子兄弟链表的叶子结点个数等操作。printf("孩子兄弟链表的叶子结点个数：%d\n", getChildSiblingLeafCount(root));printf("叶子结点个数：%d\n", getLeafCount(root));printf("\n树的高度：%d\n", getHeight(root));printf("\n先序遍历（非递归算法）：");
C语言实现二叉树（纯新手向）
weixin_44606789的博客
10-16 1万+
目录 一、二叉树的基本概念 二、二叉树的初始化 三、释放二叉树 四、前中后序遍历二叉树 五、主函数和效果截图 六、拓展时间 这是我这段时间学习c语言二叉树的成果，希望对大家有所帮助，共同进步！ 一、二叉树的基本概念 二叉树（binary tree）是指树中节点的度不大于2的有序树，它是一种最简单且最重要的树。二叉树的递归定义为：二叉树是一棵空树，或者是一棵由一个根节点和两棵互不相交的，分别称作根的左子树和右子树组成的非空树；左子树和右子树又同样都是二叉树。定义结构体可以这样设计 代码
【数据结构】C语言实现链式二叉树(附完整运行代码)
C/C++领域,数据结构,linux,MySQl学习者
12-25 1288
使用C语言实现链式二叉树程序新手入门详解.包括每个函数的设计思路详解图示及程序运行的完整代码.
数据结构算法二叉树实现
03-28
本主题聚焦于“数据结构算法二叉树实现”，这是一个关于如何在编程中实际操作和管理二叉树的实践性课题。二叉树是一种特殊的数据结构，它由节点构成，每个节点最多有两个子节点，通常分为左子节点和右子节点。 ...
数据结构与算法（二叉树）
12-23
数据结构与算法（二叉树） 树型结构是一种重要的非线性结构，在我们的客观世界和现实生活中大量存在。 在计算机领域也常用到树形结构。例如编译程序中用树表示源程序语法结构，数据库系统中用树组织信息等等。 我们...
数据结构与算法演示程序
04-17
数据结构与算法演示程序，可以单步执行，便于深入理解各种数据结构执行步骤 包含顺序表、链表、栈、串、稀疏矩阵、广义表、二叉树、图、存储管理、静态查找、动态查找、内部排序、外部排序等Pascal语言和C语言描述
数据结构与算法分析--C语言描述_数据结构与算法_
10-01
C语言因其高效、底层特性，常被用于实现数据结构和算法，使得程序更接近硬件，性能更优。本资源"数据结构与算法分析--C语言描述"是针对数据结构初学者的一个优秀教材，旨在帮助读者快速掌握这一领域。 首先，数据...
数据结构与算法 全 数据结构与算法全 Java
03-04
### 数据结构与算法详解 #### 一、初识算法 **1.1 什么是算法？** 算法是指解决问题的一系列步骤或指令集。它是一种清晰、有限的指导过程，用于完成特定任务或解决特定类型的问题。一个好的算法应当具备明确性、...
二叉树的编程与实现（C语言）
热门推荐
timerring的博客
07-10 5万+
一 、目的： 掌握指针变量、动态变量的含义； 掌握二叉树的结构特征，以及各种存储结构的特点及适用范围； 掌握指针类型描述、访问和处理二叉树的运算三 、内容： 已知以二叉树表作为存储结构，写出按层次顺序遍历二叉树的算法。 算法思想：本算法采用一个队列q，先将二叉树根结点入队列，然后退队列，输出该结点，若它有左子树，便将左子树根结点入队列；若有右子树，便将右子树根结点入队列，直到队列空为止。因为队列的特点是先进先出，从而达到按层次顺序遍历二叉树的目的。 四 、要求： 实现二叉树表的层次遍历算法，并给出应用。
二叉树基本操作演示程序C语言编写
qq_59536908的博客
06-17 5305
问题描述：设计一个与二叉树基本操作相关的演示程序要求：开发工具Dev C++ c语言编写1.创建二叉树。2.将创建的二叉树，以树状形式输出。3.分别以先序、中序、后序三种遍历方式访问二叉树。4.输出二叉树中的叶子结点以及叶子结点的个数。5.输出二叉树的高度。.........
数据结构——二叉树的基本操作（C语言，完整优美实现）
明宇逸风的博客
10-28 9052
串 文章目录串前言一、树是什么？二、该如何理解树？三、各类树的存在形式四、二叉树的遍历方式深度遍历先序遍历中序遍历后序遍历层次遍历五、二叉树的实现1.二叉树的实现1.1 引入库以及设置结构体1.2初始化二叉树1.3队列的基本操作实现1.4二叉树深度遍历的三种方法1.5层次遍历1.6求子叶个数以及结点个数1.7串的输出功能1.8主函数实现上述全部功能2.运行截图总结 前言 1.本文就介绍了数据结构中二叉树的五条性质以及二叉树的存储结构 2.二叉树的基本操作的编程实现，掌握二叉树的建立、先序，中序，后序遍
【c语言数据结构】二叉树程序设计
Gorege__Hu的博客
01-01 531
2.掌握二叉树的先序遍历、中序遍历和后序遍历，并将结果序列输出。以下图所示的二叉树为例编制程序，实现实验内容中所述功能。1.掌握二叉树的定义及其链式存储结构。4.并输出叶子结点个数以及二叉树的高度。2.定义队列，进行入队，出队操作。3.树的层次、先序、中序和后序遍历。统计二叉树中的节点个数;1.先序创建二叉树。
数据结构-二叉树的代码实现（详解）
weixin_73142957的博客
07-11 3467
内容：二叉树的前、中，后序遍历，层序遍历，二叉树节点个数，叶子节点个数，二叉树高度，第k层节点的个数，查找某个节点，二叉树销毁，判断是否为完全二叉树
《数据结构C语言版》——二叉树详解(图文并茂)
青春无问西东 岁月自成芳华
05-20 1万+
C语言版本的数据结构详解，讲解树、二叉树及其对应的定义、建立、性质
聊天室、websocket、socket.io、毕业设计.zip
最新发布
07-27
聊天室、websocket、socket.io、毕业设计.zip
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值