数据结构第09节：二叉树

最新推荐文章于 2024-08-28 20:07:23 发布
最新推荐文章于 2024-08-28 20:07:23 发布
阅读量1.1k 收藏 7
点赞数 26
文章标签： 数据结构 python 算法 java 二叉树 java-ee spring boot
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/hummhumm/article/details/140205457
版权

树是一种非线性的数据结构，它由节点和边组成。每个节点可以有零个或多个子节点。在树中，没有循环，并且所有的节点都是通过边连接的。

  1. 树的基本概念：

    • 根节点：没有父节点的唯一节点。
    • 子节点：一个节点可以直接拥有零个或多个子节点。
    • 父节点：每个子节点都有一个父节点，除了根节点。
    • 叶子节点：没有任何子节点的节点。
    • 兄弟节点：具有相同父节点的节点。
    • 路径：从一个节点到另一个节点的一系列连续的边。
    • 深度：从根节点到特定节点的路径长度。
    • 高度：树中任何节点的最大深度。

  2. Java中的树实现：

下面是一个简单的二叉树的例子：

public class TreeNode {
    int val;
    TreeNode left;
    TreeNode right;

    TreeNode(int x) {
        val = x;
    }
}

public class BinaryTree {
    TreeNode root;

    public BinaryTree() {
        root = null;
    }

    public void add(int value) {
        root = addRecursive(root, value);
    }

    private TreeNode addRecursive(TreeNode current, int value) {
        if (current == null) {
            return new TreeNode(value);
        }

        if (value < current.val) {
            current.left = addRecursive(current.left, value);
        } else if (value > current.val) {
            current.right = addRecursive(current.right, value);
        }

        return current;
    }
}

在这个例子中，我们创建了一个二叉树，其中每个节点最多有两个子节点：左子节点和右子节点。我们还实现了一个添加新节点的方法，该方法会根据新值与当前节点值的大小关系，将新节点添加到左子树或右子树。

  1. 使用案例：

假设我们要创建一个学生信息的二叉搜索树，我们可以使用上面定义的二叉树类，但是我们需要修改节点类以存储学生的姓名和年龄，如下所示：

public class StudentNode {
    String name;
    int age;
    StudentNode left;
    StudentNode right;

    StudentNode(String name, int age) {
        this.name = name;
        this.age = age;
    }
}

然后，我们可以创建一个新的二叉树，并添加学生信息：

public class StudentTree {
    StudentNode root;

    public StudentTree() {
        root = null;
    }

    public void addStudent(String name, int age) {
        root = addStudentRecursive(root, name, age);
    }

    private StudentNode addStudentRecursive(StudentNode current, String name, int age) {
        if (current == null) {
            return new StudentNode(name, age);
        }

        if (age < current.age) {
            current.left = addStudentRecursive(current.left, name, age);
        } else if (age > current.age) {
            current.right = addStudentRecursive(current.right, name, age);
        }

        return current;
    }
}

在这个例子中，我们创建了一个新的二叉树，用于存储学生的信息。我们使用学生的年龄作为比较标准，将学生信息添加到树中。

让我们继续扩展上述的学生信息二叉搜索树的案例，这次我们将添加查找学生信息的功能。

首先，我们需要在StudentNode类中添加一个toString()方法，以便我们可以打印出学生的信息：

public class StudentNode {
    String name;
    int age;
    StudentNode left;
    StudentNode right;

    StudentNode(String name, int age) {
        this.name = name;
        this.age = age;
    }

    @Override
    public String toString() {
        return "StudentNode{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }
}

然后，在StudentTree类中，我们可以添加一个查找学生信息的方法：

public class StudentTree {
    // ...

    public StudentNode findStudent(int age) {
        return findStudentRecursive(root, age);
    }

    private StudentNode findStudentRecursive(StudentNode current, int age) {
        if (current == null) {
            return null;
        }

        if (age == current.age) {
            return current;
        }

        if (age < current.age) {
            return findStudentRecursive(current.left, age);
        } else {
            return findStudentRecursive(current.right, age);
        }
    }
}

这个findStudent()方法会返回指定年龄的学生信息，如果找不到，则返回null。

现在，我们可以创建一个main()方法来测试我们的二叉搜索树：

public class Main {
    public static void main(String[] args) {
        StudentTree tree = new StudentTree();
        tree.addStudent("Alice", 20);
        tree.addStudent("Bob", 22);
        tree.addStudent("Charlie", 18);

        System.out.println(tree.findStudent(20)); // 输出: StudentNode{name='Alice', age=20}
        System.out.println(tree.findStudent(22)); // 输出: StudentNode{name='Bob', age=22}
        System.out.println(tree.findStudent(18)); // 输出: StudentNode{name='Charlie', age=18}
        System.out.println(tree.findStudent(25)); // 输出: null
    }
}

在这个例子中，我们首先创建了一个学生信息的二叉搜索树，并添加了三个学生的信息。然后，我们使用findStudent()方法查找并打印出学生的信息。

接下来，我们可以在StudentTree类中添加删除学生信息的功能。

首先，我们创建一个删除学生信息的方法，这可能比添加和查找更复杂，因为我们需要处理三种情况：删除的节点是叶子节点、删除的节点有一个子节点、删除的节点有两个子节点。

public class StudentTree {
    // ...

    public void deleteStudent(int age) {
        root = deleteStudentRecursive(root, age);
    }

    private StudentNode deleteStudentRecursive(StudentNode current, int age) {
        if (current == null) {
            return null;
        }

        if (age == current.age) {
            if (current.left == null && current.right == null) {
                return null;
            }

            if (current.right == null) {
                return current.left;
            }

            if (current.left == null) {
                return current.right;
            }

            int smallestValue = findMin(current.right);
            current.age = smallestValue;
            current.right = deleteStudentRecursive(current.right, smallestValue);
            return current;
        }

        if (age < current.age) {
            current.left = deleteStudentRecursive(current.left, age);
            return current;
        }

        current.right = deleteStudentRecursive(current.right, age);
        return current;
    }

    private int findMin(StudentNode node) {
        return node.left == null ? node.age : findMin(node.left);
    }
}

在这个例子中，deleteStudent()方法会删除指定年龄的学生信息。如果要删除的节点是叶子节点或者只有一个子节点，那么我们直接删除该节点即可。如果要删除的节点有两个子节点，我们找到其右子树中的最小节点（即下一个最大的节点），用它替换要删除的节点，然后删除这个最小节点。

最后，我们可以在Main类中测试一下删除功能：

public class Main {
    public static void main(String[] args) {
        StudentTree tree = new StudentTree();
        tree.addStudent("Alice", 20);
        tree.addStudent("Bob", 22);
        tree.addStudent("Charlie", 18);

        System.out.println(tree.findStudent(20)); // 输出: StudentNode{name='Alice', age=20}
        tree.deleteStudent(20);
        System.out.println(tree.findStudent(20)); // 输出: null

        System.out.println(tree.findStudent(22)); // 输出: StudentNode{name='Bob', age=22}
        tree.deleteStudent(22);
        System.out.println(tree.findStudent(22)); // 输出: null

        System.out.println(tree.findStudent(18)); // 输出: StudentNode{name='Charlie', age=18}
        tree.deleteStudent(18);
        System.out.println(tree.findStudent(18)); // 输出: null
    }
}

在这个例子中，我们首先创建了一个学生信息的二叉搜索树，并添加了三个学生的信息。然后，我们使用deleteStudent()方法删除学生信息，再使用findStudent()方法验证是否删除成功。

在上一节中，我们已经实现了二叉搜索树的添加、查找和删除操作。接下来，我们将实现遍历操作。二叉树的遍历主要有三种方式：前序遍历、中序遍历和后序遍历。

前序遍历的顺序是：先访问根节点，然后递归地进行左子树的前序遍历，最后递归地进行右子树的前序遍历。

中序遍历的顺序是：先递归地进行左子树的中序遍历，然后访问根节点，最后递归地进行右子树的中序遍历。

后序遍历的顺序是：先递归地进行左子树的后序遍历，然后递归地进行右子树的后序遍历，最后访问根节点。

我们将在StudentTree类中添加这些遍历方法：

public class StudentTree {
    // ...

    public void preOrderTraversal() {
        preOrderTraversalRecursive(root);
    }

    private void preOrderTraversalRecursive(StudentNode node) {
        if (node != null) {
            System.out.print(node + " ");
            preOrderTraversalRecursive(node.left);
            preOrderTraversalRecursive(node.right);
        }
    }

    public void inOrderTraversal() {
        inOrderTraversalRecursive(root);
    }

    private void inOrderTraversalRecursive(StudentNode node) {
        if (node != null) {
            inOrderTraversalRecursive(node.left);
            System.out.print(node + " ");
            inOrderTraversalRecursive(node.right);
        }
    }

    public void postOrderTraversal() {
        postOrderTraversalRecursive(root);
    }

    private void postOrderTraversalRecursive(StudentNode node) {
        if (node != null) {
            postOrderTraversalRecursive(node.left);
            postOrderTraversalRecursive(node.right);
            System.out.print(node + " ");
        }
    }
}

然后，我们可以在Main类中测试一下遍历功能：

public class Main {
    public static void main(String[] args) {
        StudentTree tree = new StudentTree();
        tree.addStudent("Alice", 20);
        tree.addStudent("Bob", 22);
        tree.addStudent("Charlie", 18);

        System.out.println("Pre-order traversal:");
        tree.preOrderTraversal(); // 输出: StudentNode{name='Charlie', age=18} StudentNode{name='Alice', age=20} StudentNode{name='Bob', age=22}

        System.out.println("\nIn-order traversal:");
        tree.inOrderTraversal(); // 输出: StudentNode{name='Charlie', age=18} StudentNode{name='Alice', age=20} StudentNode{name='Bob', age=22}

        System.out.println("\nPost-order traversal:");
        tree.postOrderTraversal(); // 输出: StudentNode{name='Charlie', age=18} StudentNode{name='Bob', age=22} StudentNode{name='Alice', age=20}
    }
}

在这个例子中，我们首先创建了一个学生信息的二叉搜索树，并添加了三个学生的信息。然后，我们分别进行了前序遍历、中序遍历和后序遍历，并打印出了遍历结果。

hummhumm
关注
  • 26
    点赞
  • 踩
  • 7
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
【Java学习】第47节：基础数据结构（九）：二叉树
m0_46013789的博客
05-26 1268
Java是一种广泛使用的编程语言，由Sun Microsystems（现在是Oracle Corporation）首次推出。它是一种跨平台的编程语言，意味着您可以编写一次代码，然后在多个不同的计算机系统上运行，而无需对其进行修改。Java被广泛用于开发各种类型的应用程序，包括企业级应用、移动应用、Web应用、游戏等。
数据结构第九讲：二叉树
2301_79761834的博客
08-03 872
数据结构第九讲：二叉树
【数据结构】实验九：二叉树
m0_65787507的博客
07-27 1144
数据结构实验
数据结构与算法09：二叉树
浮尘笔记
05-31 458
要存储一棵二叉树，可以选择基于指针的二叉链式存储法，也可以选择基于数组的顺序存储法。二叉树又分为：普通二叉树、满二叉树、完全二叉树、非完全二叉树等。完全二叉树的叶子节点都在最底下两层，最后一层的叶子节点都靠左排列。遍历二叉树的三种方法：前序遍历、中序遍历、后序遍历，这里的“序”指的是根节点的遍历顺序。二叉搜索树中序遍历后，可以输出一个从小到大的有序数据队列，时间复杂度是 O(n)，非常高效。
速通数据结构（七）：二叉树
lxy2977262881的博客
07-24 226
本文我们讲二叉树的另一种实现方式：链式。但是实际上，普通二叉树链式存储没有啥意义，用链表也行，真正有用是加点规则变成搜索二叉树红黑树等等，当然这是后话了。先学学基本链式结构吧。
【数据结构】——二叉树详解
热门推荐
atwdy的博客
07-28 5万+
二叉树(Binary Tree)是由n个结点构成的有限集(n≥0)，n=0时为空树，n>0时为非空树。对于非空树TTT有且仅有一个根结点；除根结点外的其余结点又可分为两个不相交的子集TLT_LTL​和TRT_RTR​，分别称为TTT的左子树和右子树，且TLT_LTL​和TRT_RTR​本身又都是二叉树。很明显该定义属于递归定义，所以有关二叉树的操作使用递归往往更容易理解和实现。从定义也可以看出二叉树与一般树的区别主要是两点，一是每个结点的度最多为2；
数据结构:二叉树基础
weixin_57418095的博客
11-18 416
关于数据结构中二叉树的一些基本概念和性质
数据结构：二叉树经典例题（单选题）--＞你真的掌握二叉树了吗？（第一弹）
Yikefore的博客
06-23 2281
关于二叉树的基本经典单选例题，对二叉树性质的巩固，相信你做完这些例题就可以对二叉树轻松拿捏（第一弹）你也快来试试吧！
能带你起飞的【数据结构】成王第九篇:二叉树2
m0_64397675的博客
06-23 91
目录前言二叉树的基本基本操作获取树中节点的个数获取叶子节点的个数 获取第K层节点的个数获取二叉树的高度 检测值为val的元素是否存在 判断一棵树是不是完全二叉树
头歌数据结构二叉树的二叉链表存储及基本操作
05-18
在IT领域，数据结构是计算机科学的基础，而二叉树是一种重要的抽象数据类型。本题主要涉及二叉树的链式存储方式以及基于链表的二叉树的基本操作，包括先序遍历、计算二叉树的高度、节点总数、叶子节点数、层次遍历...
头歌数据结构二叉树的顺序存储及基本操作
05-18
在计算机科学中，二叉树是一种重要的数据结构，它的每个节点最多有两个子节点，分别称为左子树和右子树。这种特殊的树形结构在很多领域都有应用，特别是在文件系统和数据库系统中，利用二叉树可以实现高效的排序和...
数据结构历年真题，关于二叉树的
03-21
数据结构历年真题，关于二叉树的知识点 一、完全二叉树的高度 在计算机专业基础综合数据结构中，完全二叉树的高度是一个重要的概念。根据题目1，我们可以看到，设一棵完全二叉树叶子结点数为k，最后一层结点数>2，...
js数据结构第九弹：二叉树和二叉查找树
weixin_43187545的博客
04-15 130
树是一种非线性的数据结构， 以分层的方式存储数据。 树被用来存储具有层级关系的数据， 比如文件系统中的文件； 树还被用来存储有序列表。 优点：在二叉树上进行查找非常快（而在链表上查找则不是这样）， 为二叉树添加或删除元素也非常快（而对数组执行添加或删除操作则不是这样）。 1 树的定义 树由一组以边连接的节点组成。 每个方框都是一个节点， 连接方框的线叫做边。 一棵树最上面的节点称为根节点， 如果一...
数据结构之单向、双线链表
最新发布
2301_78503818的博客
08-28 753
首先我们先定义链表节点的类型，以及里面包含的数据和存储下一个节点地址的指针，然后通过定义变量，使用malloc函数来申请一个头结点的空间，而后进行赋值操作即可完成对头结点的创建。链表大体可以分成有头链表（有头节点）和无头链表，今天主要记录一下单向链表和双线链表的一些基本操作。3.单向链表的遍历，寻找，删除，更改。6.链表的复杂操作（读者可酌情观看）链表空间的释放（链表的销毁）2.头插法插入链表节点。
【数据结构】—— 树和二叉树
mist的博客
08-26 1121
树和二叉树、堆（顺序结构）、二叉树链式结构
数据结构：用栈实现队列（232）LeetCode
2303_81073778的博客
08-26 545
你 只能 使用标准的栈操作 —— 也就是只有 push to top, peek/pop from top, size, 和 is empty 操作是合法的。你能否实现每个操作均摊时间复杂度为 O(1) 的队列？换句话说，执行 n 个操作的总时间复杂度为 O(n) ，即使其中一个操作可能花费较长时间。你所使用的语言也许不支持栈。你可以使用 list 或者 deque（双端队列）来模拟一个栈，只要是标准的栈操作即可。假设所有操作都是有效的 （例如，一个空的队列不会调用 pop 或者 peek 操作）
数据结构-时间、空间复杂度-详解
2401_86587256的博客
08-23 1385
数据结构-时间、空间复杂度-详解
浅谈【数据结构】树与二叉树之哈夫曼树
weixin_67526434的博客
08-26 776
浅谈【数据结构】树与二叉树之哈夫曼树
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值