Java数据结构--树

于 2023-12-24 12:27:53 发布
阅读量1k 收藏 21
点赞数 25
分类专栏： Java数据结构 文章标签： java 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/xd__xy/article/details/134872383
版权

文章目录

一、二叉树

「二叉树 binary tree」是一种非线性数据结构，代表“祖先”与“后代”之间的派生关系，体现了“一分为二”的分治逻辑。与链表类似，二叉树的基本单元是节点，每个节点包含值、左子节点引用和右子节点引用。

/* 二叉树节点类 */
class TreeNode {
	int val //节点值
	TreeNode left; //左子节点引用
	TreeNode right; //右子节引用
	TreeNode(int x) {
		val = x;
	}
}

每个节点都有两个引用（指针），分别指向「左子节点 left-child node」和「右子节点 right-child node」，该节点被称为这两个子节点的「父节点 parent node」。当给定一个二叉树的节点时，我们将该节点的左子节点及其以下节点形成的树称为该节点的「左子树 left subtree」，同理可得「右子树 right subtree」。

在二叉树中，除叶节点外，其他所有节点都包含子节点和非空子树。如图所示，如果将“节点 2”视为父节点，则其左子节点和右子节点分别是“节点 4”和“节点 5”，左子树是“节点 4 及其以下节点形成的树”，右子树是“节点 5 及其以下节点形成的树”。
父节点、子节点、子树

1.1 二叉树常见术语

  • 「根节点 root node」：位于二叉树顶层的节点，没有父节点。
  • 「叶节点 leaf node」：没有子节点的节点，其两个指针均指向None。
  • 「边 edge」：连接两个节点的线段，即节点引用（指针）。
  • 节点所在的「层 level」：从顶至底递增，根节点所在层为 1 。
  • 节点的「度 degree」：节点的子节点的数量。在二叉树中，度的取值范围是 0、1、2 。
  • 二叉树的「高度 height」：从根节点到最远叶节点所经过的边的数量。
  • 节点的「深度 depth」：从根节点到该节点所经过的边的数量。
  • 节点的「高度 height」：从距离该节点最远的叶节点到该节点所经过的边的数量。
    二叉树常用术语

1.2 二叉树的基本操作

1.2.1 插入和删除节点

与链表类似，在二叉树中插入与删除节点可以通过修改指针来实现。
二叉树插入和删除节点

binary_tree.java

TreeNode P = new TreeNode(0);
// 在 n1 -> n2 中间插入节点 P
n1.left = P;
P.let = n2;
// 删除节点 P
n1.left = n2;

1.3 常见的二叉树类型

  • 完美二叉树
    「完美二叉树 perfect binary tree」(也称满二叉树)所有层的节点都被完全填满。在完美二叉树中，叶节点的度为0，其余所有节点的度都为2；若树的高度为h，则节点总数为2^(h+1) - 1，呈现标准的指数级关系，反映了自然界中常见的细胞分裂现象。
    完美二叉树
  • 完全二叉树
    「完全二叉树 complete binary tree」只有最底层的节点未被填满，且最底层节点尽量靠左填充。
    完全二叉树
  • 完满二叉树
    「完满二叉树 full binary tree」除了叶节点之外，其余所有节点都有两个子节点。
    完满二叉树
  • 平衡二叉树
    「平衡二叉树 balanced binary tree」中任意节点的左子树和右子树的高度之差的绝对值不超过 1 。
    平衡二叉树

二、二叉树遍历

从物理结构的角度来看，树是一种基于链表的数据结构，因此其遍历方式是通过指针逐个访问节点。然而，树是一种非线性数据结构，这使得遍历树比遍历链表更加复杂，需要借助搜索算法来实现。

二叉树常见的遍历方式包括层序遍历、前序遍历、中序遍历和后序遍历等。

2.1 层序遍历

层序遍历 level-order traversal」从顶部到底部逐层遍历二叉树，并在每一层按照从左到右的顺序访问节点。

层序遍历本质上属于「广度优先遍历 breadth-first traversal, BFS」，它体现了一种“一圈一圈向外扩展”的逐层遍历方式。
二叉树的层序遍历

/* 层序遍历 */
List<Integer> levelOrder(TreeNode root) {
    // 初始化队列，加入根节点
    Queue<TreeNode> queue = new LinkedList<>();
    queue.add(root);
    // 初始化一个列表，用于保存遍历序列
    List<Integer> list = new ArrayList<>();
    while (!queue.isEmpty()) {
        TreeNode node = queue.poll(); // 队列出队
        list.add(node.val);           // 保存节点值
        if (node.left != null)
            queue.offer(node.left);   // 左子节点入队
        if (node.right != null)
            queue.offer(node.right);  // 右子节点入队
    }
    return list;
}
  • 复杂度分析
    • 时间复杂度O(n)：所有节点被访问一次，使用O(n)时间，其中n为节点数量
    • 空间复杂度O(n)：在最差情况下，即满二叉树时，遍历到最底层之前，队列中最多同时存在(n+1)/2个节点，占用O(n)空间。

2.2 前序、中序、后序遍历

相应地，前序、中序和后序遍历都属于「深度优先遍历 depth-first traversal, DFS」，它体现了一种“先走到尽头，再回溯继续”的遍历方式。

图展示了对二叉树进行深度优先遍历的工作原理。深度优先遍历就像是绕着整棵二叉树的外围“走”一圈，在每个节点都会遇到三个位置，分别对应前序遍历、中序遍历和后序遍历。
二叉搜索树的前序、中序、后序遍历

/* 前序遍历 */
void preOrder(TreeNode root) {
    if (root == null)
        return;
    // 访问优先级：根节点 -> 左子树 -> 右子树
    list.add(root.val);
    preOrder(root.left);
    preOrder(root.right);
}

/* 中序遍历 */
void inOrder(TreeNode root) {
    if (root == null)
        return;
    // 访问优先级：左子树 -> 根节点 -> 右子树
    inOrder(root.left);
    list.add(root.val);
    inOrder(root.right);
}

/* 后序遍历 */
void postOrder(TreeNode root) {
    if (root == null)
        return;
    // 访问优先级：左子树 -> 右子树 -> 根节点
    postOrder(root.left);
    postOrder(root.right);
    list.add(root.val);
}
  • 复杂度分析
    • 时间复杂度O(n): 所有节点被访问一次，使用O(n)时间。
    • 空间复杂度O(n)：在最差情况下，即树退化为链表时，递归深度达到n，系统占用你O(n)栈帧空间。

三、二叉树数组表示

3.1 表示完美二叉树

根据层序遍历的特性，我们可以推导出父节点索引与子节点索引之间的“映射公式”：若某节点的索引为 i，则该节点的左子节点索引为 2i+1，右子节点索引为 2i+2。下图展示了各个节点索引之间的映射关系。
完美二叉树的表示
映射公式的角色相当于链表中的指针。给定数组中的任意一个节点，我们都可以通过映射公式来访问它的左（右）子节点。

3.2 表示任意二叉树

完美二叉树是一个特例，在二叉树的中间层通常存在许多None。由于层序遍历序列并不包含这些None，因此我们无法仅凭该序列来推测None的数量和分布位置。这意味着存在多种二叉树结构都符合该层序遍历序列。

我们可以考虑在层序遍历序列中显式地写出所有None

/* 二叉树的数组表示 */
// 使用 int 的包装类 Integer ，就可以使用 null 来标记空位
Integer[] tree = { 1, 2, 3, 4, null, 6, 7, 8, 9, null, null, 12, null, null, 15 };

任意类型二叉树的表示

/* 数组表示下的二叉树类 */
class ArrayBinaryTree {
    private List<Integer> tree;

    /* 构造方法 */
    public ArrayBinaryTree(List<Integer> arr) {
        tree = new ArrayList<>(arr);
    }

    /* 节点数量 */
    public int size() {
        return tree.size();
    }

    /* 获取索引为 i 节点的值 */
    public Integer val(int i) {
        // 若索引越界，则返回 null ，代表空位
        if (i < 0 || i >= size())
            return null;
        return tree.get(i);
    }

    /* 获取索引为 i 节点的左子节点的索引 */
    public Integer left(int i) {
        return 2 * i + 1;
    }

    /* 获取索引为 i 节点的右子节点的索引 */
    public Integer right(int i) {
        return 2 * i + 2;
    }

    /* 获取索引为 i 节点的父节点的索引 */
    public Integer parent(int i) {
        return (i - 1) / 2;
    }

    /* 层序遍历 */
    public List<Integer> levelOrder() {
        List<Integer> res = new ArrayList<>();
        // 直接遍历数组
        for (int i = 0; i < size(); i++) {
            if (val(i) != null)
                res.add(val(i));
        }
        return res;
    }

    /* 深度优先遍历 */
    private void dfs(Integer i, String order, List<Integer> res) {
        // 若为空位，则返回
        if (val(i) == null)
            return;
        // 前序遍历
        if ("pre".equals(order))
            res.add(val(i));
        dfs(left(i), order, res);
        // 中序遍历
        if ("in".equals(order))
            res.add(val(i));
        dfs(right(i), order, res);
        // 后序遍历
        if ("post".equals(order))
            res.add(val(i));
    }

    /* 前序遍历 */
    public List<Integer> preOrder() {
        List<Integer> res = new ArrayList<>();
        dfs(0, "pre", res);
        return res;
    }

    /* 中序遍历 */
    public List<Integer> inOrder() {
        List<Integer> res = new ArrayList<>();
        dfs(0, "in", res);
        return res;
    }

    /* 后序遍历 */
    public List<Integer> postOrder() {
        List<Integer> res = new ArrayList<>();
        dfs(0, "post", res);
        return res;
    }
}

3.3 优点与局限性

二叉树的数组表示主要有以下优点。

  • 数组存储在连续的内存空间中，对缓存友好，访问与遍历速度较快。
  • 不需要存储指针，比较节省空间。
  • 允许随机访问节点。

然而，数组表示也存在一些局限性。

  • 数组存储需要连续内存空间，因此不适合存储数据量过大的树。
  • 增删节点需要通过数组插入与删除操作实现，效率较低。
  • 当二叉树中存在大量None时，数组中包含的节点数据比重较低，空间利用率较低。

四、二叉搜索树

「二叉搜索树 binary search tree」满足以下条件。

  • 对于根节点，左子树中所有节点的值<根节点的值<右子树中所有节点的值。
  • 任意节点的左、右子树也是二叉搜索树，即同样满足条件 1. 。

4.1 二叉搜索树的操作

我们将二叉搜索树封装为一个类 BinarySearchTree ，并声明一个成员变量 root ，指向树的根节点。

  • 查找节点
    给定目标节点值 num ，可以根据二叉搜索树的性质来查找。如图所示，我们声明一个节点 cur ，从二叉树的根节点 root 出发，循环比较节点值 cur.val 和 num 之间的大小关系。

    • 若 cur.val < num ，说明目标节点在 cur 的右子树中，因此执行 cur = cur.right 。
    • 若 cur.val > num ，说明目标节点在 cur 的左子树中，因此执行 cur = cur.left 。
    • 若 cur.val = num ，说明找到目标节点，跳出循环并返回该节点。
      二叉搜索树查找节点示例

    二叉搜索树的查找操作与二分查找算法的工作原理一致，都是每轮排除一半情况。循环次数最多为二叉树的高度，当二叉树平衡时，使用O(log n)时间。示例代码如下：

/* 查找节点 */
TreeNode search(int num) {
    TreeNode cur = root;
    // 循环查找，越过叶节点后跳出
    while (cur != null) {
        // 目标节点在 cur 的右子树中
        if (cur.val < num)
            cur = cur.right;
        // 目标节点在 cur 的左子树中
        else if (cur.val > num)
            cur = cur.left;
        // 找到目标节点，跳出循环
        else
            break;
    }
    // 返回目标节点
    return cur;
}
  • 插入节点
    给定一个待插入元素 num ，为了保持二叉搜索树“左子树 < 根节点 < 右子树”的性质，插入操作流程如图所示
    • 查找插入位置：与查找操作相似，从根节点出发，根据当前节点值和 num 的大小关系循环向下搜索，直到越过叶节点（遍历至None）时跳出循环。
    • 在该位置插入节点：初始化节点 num ，将该节点置于None的位置。
      在二叉搜索树中插入节点
  • 在代码实现中，需要注意以下两点。
    • 二叉搜索树不允许存在重复节点，否则将违反其定义。因此，若待插入节点在树中已存在，则不执行插入，直接返回。
    • 为了实现插入节点，我们需要借助节点 pre 保存上一轮循环的节点。这样在遍历至None时，我们可以获取到其父节点，从而完成节点插入操作。
/* 插入节点 */
void insert(int num) {
    // 若树为空，则初始化根节点
    if (root == null) {
        root = new TreeNode(num);
        return;
    }
    TreeNode cur = root, pre = null;
    // 循环查找，越过叶节点后跳出
    while (cur != null) {
        // 找到重复节点，直接返回
        if (cur.val == num)
            return;
        pre = cur;
        // 插入位置在 cur 的右子树中
        if (cur.val < num)
            cur = cur.right;
        // 插入位置在 cur 的左子树中
        else
            cur = cur.left;
    }
    // 插入节点
    TreeNode node = new TreeNode(num);
    if (pre.val < num)
        pre.right = node;
    else
        pre.left = node;
}

  • 删除节点
    先在二叉树中查找到目标节点，再将其删除。

    与插入节点类似，我们需要保证在删除操作完成后，二叉搜索树的“左子树 < 根节点 < 右子树”的性质仍然满足。

    因此，我们根据目标节点的子节点数量，分 0、1 和 2 三种情况，执行对应的删除节点操作。

    • 如图所示，当待删除节点的度为0时，表示该节点是叶节点，可以直接删除。
      在二叉搜索树中删除节点（度为0）
    • 如图所示，当待删除节点的度为
      时，将待删除节点替换为其子节点即可。
      在二叉搜索树中删除节点（度为1）
    • 当待删除节点的度为2时，我们无法直接删除它，而需要使用一个节点替换该节点。由于要保持二叉搜索树“左子树<根节点<右子树”的性质，因此这个节点可以是右子树的最小节点或左子树的最大节点。
    • 假设我们选择右子树的最小节点（中序遍历的下一个节点），则删除操作流程如图所示。
      • 找到待删除节点在“中序遍历序列”中的下一个节点，记为 tmp 。
      • 用 tmp 的值覆盖待删除节点的值，并在树中递归删除节点 tmp 。
        在二叉搜索树中删除节点（度为2）
        删除节点操作同样使用O(log n)时间，其中查找待删除节点需要O(log n时间，获取中序遍历后继节点需要O(log n)时间
/* 删除节点 */
void remove(int num) {
    // 若树为空，直接提前返回
    if (root == null)
        return;
    TreeNode cur = root, pre = null;
    // 循环查找，越过叶节点后跳出
    while (cur != null) {
        // 找到待删除节点，跳出循环
        if (cur.val == num)
            break;
        pre = cur;
        // 待删除节点在 cur 的右子树中
        if (cur.val < num)
            cur = cur.right;
        // 待删除节点在 cur 的左子树中
        else
            cur = cur.left;
    }
    // 若无待删除节点，则直接返回
    if (cur == null)
        return;
    // 子节点数量 = 0 or 1
    if (cur.left == null || cur.right == null) {
        // 当子节点数量 = 0 / 1 时， child = null / 该子节点
        TreeNode child = cur.left != null ? cur.left : cur.right;
        // 删除节点 cur
        if (cur != root) {
            if (pre.left == cur)
                pre.left = child;
            else
                pre.right = child;
        } else {
            // 若删除节点为根节点，则重新指定根节点
            root = child;
        }
    }
    // 子节点数量 = 2
    else {
        // 获取中序遍历中 cur 的下一个节点
        TreeNode tmp = cur.right;
        while (tmp.left != null) {
            tmp = tmp.left;
        }
        // 递归删除节点 tmp
        remove(tmp.val);
        // 用 tmp 覆盖 cur
        cur.val = tmp.val;
    }
}

4.2 二叉搜索树的效率

无序数组二次搜索树
查找元素O(n)O(log n)
插入元素O(1)O(log n)
删除元素O(n)O(log n)

五、AVL树 *

在多次插入和删除操作后，二叉搜索树可能退化为链表。在这种情况下，所有操作的时间复杂度将从O(log n)恶化为O(n)。
AVL树在删除节点后发生退化

5.1 AVL树常见术语

AVL 树既是二叉搜索树也是平衡二叉树，同时满足这两类二叉树的所有性质，因此也被称为「平衡二叉搜索树 balanced binary search tree」。

  • 节点高度
    由于 AVL 树的相关操作需要获取节点高度，因此我们需要为节点类添加 height 变量：
/* AVL 树节点类 */
class TreeNode {
    public int val;        // 节点值
    public int height;     // 节点高度
    public TreeNode left;  // 左子节点
    public TreeNode right; // 右子节点
    public TreeNode(int x) { val = x; }
}

“节点高度”是指从该节点到其最远叶节点的距离，即所经过的“边”的数量。需要特别注意的是，叶节点的高度为0，而空节点的高度为-1。我们将创建两个工具函数，分别用于获取和更新节点的高度：

/* 获取节点高度 */
int height(TreeNode node) {
    // 空节点高度为 -1 ，叶节点高度为 0
    return node == null ? -1 : node.height;
}

/* 更新节点高度 */
void updateHeight(TreeNode node) {
    // 节点高度等于最高子树高度 + 1
    node.height = Math.max(height(node.left), height(node.right)) + 1;
}
  • 节点平衡因子
    节点的「平衡因子 balance factor」定义为节点左子树的高度减去右子树的高度，同时规定空节点的平衡因子为0。我们同样将获取节点平衡因子的功能封装成函数。
/* 获取平衡因子 */
int balanceFactor(TreeNode node) {
    // 空节点平衡因子为 0
    if (node == null)
        return 0;
    // 节点平衡因子 = 左子树高度 - 右子树高度
    return height(node.left) - height(node.right);
}

5.2 AVL树旋转

AVL 树的特点在于“旋转”操作，它能够在不影响二叉树的中序遍历序列的前提下，使失衡节点重新恢复平衡。换句话说，旋转操作既能保持“二叉搜索树”的性质，也能使树重新变为“平衡二叉树”。

我们将平衡因子绝对值 >1 的节点称为“失衡节点”。根据节点失衡情况的不同，旋转操作分为四种：右旋、左旋、先右旋后左旋、先左旋后右旋。

  • 右旋
    如图所示，节点下方为平衡因子。从底至顶看，二叉树中首个失衡节点是“节点 5”。我们关注以该失衡节点为根节点，将该节点记为 node ，其左子节点记为 child ，当节点 child 有右子节点（记为 grandChild ）时，需要在右旋中添加一步：将 grandChild 作为 node 的左子节点。执行“右旋”操作。完成右旋后，子树恢复平衡，并且仍然保持二叉搜索树的性质。
    有grandChild的右旋操作
    “向右旋转”是一种形象化的说法，实际上需要通过修改节点指针来实现，代码如下所示：
/* 右旋操作 */
TreeNode rightRotate(TreeNode node) {
    TreeNode child = node.left;
    TreeNode grandChild = child.right;
    // 以 child 为原点，将 node 向右旋转
    child.right = node;
    node.left = grandChild;
    // 更新节点高度
    updateHeight(node);
    updateHeight(child);
    // 返回旋转后子树的根节点
    return child;
}
  • 左旋
    相应地，如果考虑上述失衡二叉树的“镜像”，则需要执行“左旋”操作。同理，如图所示，当节点 child 有左子节点（记为 grandChild ）时，需要在左旋中添加一步：将 grandChild 作为 node 的右子节点。
    有grandChild的左旋操作
    可以观察到，右旋和左旋操作在逻辑上是镜像对称的，它们分别解决的两种失衡情况也是对称的。基于对称性，我们只需将右旋的实现代码中的所有的 left 替换为 right ，将所有的 right 替换为 left ，即可得到左旋的实现代码：
/* 左旋操作 */
TreeNode leftRotate(TreeNode node) {
    TreeNode child = node.right;
    TreeNode grandChild = child.left;
    // 以 child 为原点，将 node 向左旋转
    child.left = node;
    node.right = grandChild;
    // 更新节点高度
    updateHeight(node);
    updateHeight(child);
    // 返回旋转后子树的根节点
    return child;
}
  • 先左旋后右旋
    对于图中的失衡节点 3 ，仅使用左旋或右旋都无法使子树恢复平衡。此时需要先对 child 执行“左旋”，再对 node 执行“右旋”。
    先左旋后右旋
  • 先右旋后左旋
    如图所示，对于上述失衡二叉树的镜像情况，需要先对 child 执行“右旋”，再对 node 执行“左旋”。
    先右旋后左旋
失衡节点的平衡因子子节点的平衡因子应采用的旋转方法
> 1 （左偏树）>= 0右旋
> 1（左偏树）< 0先左旋后右旋
< -1（右偏树）<= 0左旋
< -1 （右偏树）> 0先右旋后左旋

为了便于使用，我们将旋转操作封装成一个函数。有了这个函数，我们就能对各种失衡情况进行旋转，使失衡节点重新恢复平衡。

/* 执行旋转操作，使该子树重新恢复平衡 */
TreeNode rotate(TreeNode node) {
    // 获取节点 node 的平衡因子
    int balanceFactor = balanceFactor(node);
    // 左偏树
    if (balanceFactor > 1) {
        if (balanceFactor(node.left) >= 0) {
            // 右旋
            return rightRotate(node);
        } else {
            // 先左旋后右旋
            node.left = leftRotate(node.left);
            return rightRotate(node);
        }
    }
    // 右偏树
    if (balanceFactor < -1) {
        if (balanceFactor(node.right) <= 0) {
            // 左旋
            return leftRotate(node);
        } else {
            // 先右旋后左旋
            node.right = rightRotate(node.right);
            return leftRotate(node);
        }
    }
    // 平衡树，无须旋转，直接返回
    return node;
}

5.3 AVL树常用操作

  • 插入节点
    AVL 树的节点插入操作与二叉搜索树在主体上类似。唯一的区别在于，在 AVL 树中插入节点后，从该节点到根节点的路径上可能会出现一系列失衡节点。因此，我们需要从这个节点开始，自底向上执行旋转操作，使所有失衡节点恢复平衡。代码如下所示：
/* 插入节点 */
void insert(int val) {
    root = insertHelper(root, val);
}

/* 递归插入节点（辅助方法） */
TreeNode insertHelper(TreeNode node, int val) {
    if (node == null)
        return new TreeNode(val);
    /* 1. 查找插入位置，并插入节点 */
    if (val < node.val)
        node.left = insertHelper(node.left, val);
    else if (val > node.val)
        node.right = insertHelper(node.right, val);
    else
        return node; // 重复节点不插入，直接返回
    updateHeight(node); // 更新节点高度
    /* 2. 执行旋转操作，使该子树重新恢复平衡 */
    node = rotate(node);
    // 返回子树的根节点
    return node;
}
  • 删除操作
    类似地，在二叉搜索树的删除节点方法的基础上，需要从底至顶执行旋转操作，使所有失衡节点恢复平衡。
/* 删除节点 */
void remove(int val) {
    root = removeHelper(root, val);
}

/* 递归删除节点（辅助方法） */
TreeNode removeHelper(TreeNode node, int val) {
    if (node == null)
        return null;
    /* 1. 查找节点，并删除之 */
    if (val < node.val)
        node.left = removeHelper(node.left, val);
    else if (val > node.val)
        node.right = removeHelper(node.right, val);
    else {
        if (node.left == null || node.right == null) {
            TreeNode child = node.left != null ? node.left : node.right;
            // 子节点数量 = 0 ，直接删除 node 并返回
            if (child == null)
                return null;
            // 子节点数量 = 1 ，直接删除 node
            else
                node = child;
        } else {
            // 子节点数量 = 2 ，则将中序遍历的下个节点删除，并用该节点替换当前节点
            TreeNode temp = node.right;
            while (temp.left != null) {
                temp = temp.left;
            }
            node.right = removeHelper(node.right, temp.val);
            node.val = temp.val;
        }
    }
    updateHeight(node); // 更新节点高度
    /* 2. 执行旋转操作，使该子树重新恢复平衡 */
    node = rotate(node);
    // 返回子树的根节点
    return node;
}
泛黄的咖啡店
关注
  • 25
    点赞
  • 踩
  • 21
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
Java 数据结构与算法之树（BST）
AS011x的博客
09-21 362
Binary Search Tree历史。二叉搜索树算法是由包括 PF Windley、Andrew Donald Booth、Andrew Colin、Thomas N. Hibbard 在内的几位研究人员独立发现的。该算法归功于 Conway Berners-Lee 和 David Wheeler ，他们在 1960 年使用它在磁带中存储标记数据。最早和流行的二叉搜索树算法之一是 Hibbard 算法。用于组成一颗树的节点，则需要包括；值和与之关联的三角结构，一个父节点、两个孩子节点。
Java数据结构—树
Green_756的博客
09-05 3908
java、数据结构、树
数据结构-树
m0_46804568的博客
01-28 295
树 文章目录树1、二叉树1.1、二叉树的操作1.1.1、二叉树的遍历1.1.2、二叉树的查找1.1.3、二叉树的删除1.2、顺序存储二叉树1.3、线索化二叉树1.3.1、问题提出1.3.2、定义1.3.3、案列2、堆排序2.1、基本介绍2.2、基本思想2.3、步骤图解2.4、思路总结2.5、代码实现3、赫夫曼树3.1、基本介绍3.2、赫夫曼树几个重要概念3.3、赫夫曼树创建思路图解3.4、代码实现4、赫夫曼编码4.1、基本介绍4.2、原理剖析4.3、代码实现5、二叉排序树5.1、背景5.2、基本介绍5.3、
Java 数据结构_树
Luzhuo 的博客
11-07 435
Java 数据结构_树
java版数据结构-树结构
07-16
java版数据结构-树结构；java版数据结构-树结构；java版数据结构-树结构；java版数据结构-树结构；java版数据结构-树结构；java版数据结构-树结构；
Java-Java数据结构二十讲
10-25
本文将深入探讨Java数据结构的二十个核心主题，包括数组、简单排序算法、栈与队列、链表、递归、树以及图。这些概念不仅在日常编程中常见，也是面试和技术评估的重要内容。 首先，我们从基础的数组开始。数组是存储...
红黑树-基于Java实现的红黑树数据结构.zip
最新发布
03-21
红黑树是一种自平衡二叉查找树，由计算机科学家...总的来说，红黑树是数据结构中的重要组成部分，尤其在需要高效存储和检索大量有序数据的场合。通过理解和掌握红黑树的原理和实现，能提升编程能力，优化程序性能。
数据结构-Java
02-14
在Java编程语言中，数据结构的实现尤为重要，因为Java提供了丰富的库和工具来支持各种数据结构的创建和操作。在这个"数据结构-Java"的主题中，我们将深入探讨几个关键的数据结构及其在Java中的实现。 首先，我们来...
数据结构练习--树.docx
03-06
在这个文档中，主要探讨了与树相关的数据结构及其性质，特别是在Java编程语言中的应用。树是一种非线性的数据结构，由节点（也称为结点）和边构成，每个节点可以有零个或多个子节点，而根节点没有父节点。以下是根据...
Java数据结构 ：树
ioioio44的博客
02-26 285
度为0的结点称之为叶子结点或终端结点，度不为0的结点称之为分支结点或非终端结点。**层次与深度：**根结点所处的层次为第1层，其子女所属的层次为第2层。**祖先结点：**从根结点到目标结点所经历的所有结点称为目标结点的祖先结点，如图中E的祖先结点为A、B。**子女节点：**若结点x存在子树，则子树的根结点称之为结点x的子女结点。**子孙结点：**某一结点的子女，以及这些子女的子女均为该节点的子孙结点。**兄弟结点：**同一父结点的子女互称兄弟。**父结点：**若结点x有子女结点，则它为其子女结点的父结点。
java数据结构树
02-02
学习JAVA数据结构最好的教程。让你一次学会，终生受用
java基础数据结构-树
12-26
java基础笔记数据结构-树，详细描述了树的原理及其实现方式，基础数据结构。
JAVA数据结构和算法：第六章（树）
春水上行的博客
09-02 1270
树树是n个结点的有限集。n=0时称为空树。在任意一颗非空树中：（1）有且仅有一个特定的称为根的结点；（2）当n>1时，其余结点可分为m(m>0)个互不相交的有限集T1,T2…..Tm，其中每一个集合本身又是一棵树，并且称为根的子树。如下图 结点: 树的结点包含一个数据元素及若干指向其子树的分支。 结点的度：结点拥有的子树数称为结点的度。 叶结点：度为0的结点称为叶结点或终端结点。 分支
【Java数据结构】树
NEU_LightBulb的博客
06-15 426
【Java数据结构】树Java中的树一、树基础结构1.树定义1.1.一些花里胡哨的名词1.2.存储方式2.二叉树2.1.性质2.2.遍历方式二、树的进阶与Java1.完全二叉树1.1.定义1.2.性质1.3.优先级队列中的堆排序2.二叉查找树与平衡二叉树（小陀螺）2.1.定义3.红黑树3.1.定义3.2.性质3.3.HashMap,TreeMap中的红黑树4.B-Tree4.1.定义4.2.性质5.B+Tree（还有B*Tree不讲了）5.1.定义5.2.性质5.3.数据库中的索引5.4. HBase中的L
Java数据结构之树
君寞傲
11-02 355
java 数据结构 树
qq_46859110的博客
10-12 269
树是我们计算机中非常重要的一种数据结构，同时使用树这种数据结构，可以描述现实生活中的很多事物，例如家 谱、单位的组织架构、等等。 树是由n（n>=1）个有限结点组成一个具有层次关系的集合。把它叫做“树”是因为它看起来像一棵倒挂的树，也就 是说它是根朝上，而叶朝下的。 树具有以下特点： 1.每个结点有零个或多个子结点； 2.没有父结点的结点为根结点； 3.每一个非根结点只有一个父结点； 4.每个结点及其后代结点整体上可以看做是一棵树，称为当前结点的父结点的一个子树； 结点的度： 一个结点含有的子树的个
java数据结构树_Java数据结构之 树（Tree）
weixin_29577885的博客
02-12 244
Java数据结构之 树(Tree)1. 二叉查找树(Binary Search Tree)性质：1)若左子树不为空，则左子树上所有节点的值均小于它的根节点的值；2)若右子树不为空，则右子树上所有节点的值均大于它的跟几点的值；3)左右子树也分别为二叉查找树；4)没有键值相同的节点(因此，插入的时候一定是叶子节点)；注： 插入有序节点时，退化成单支树；查找效率最好O(nlogn),最坏O(n)；查找效...
java数据结构之树
个人学习所得
11-14 890
无论是链表，栈还是队列，它们都是线性结构，每个节点的左边最多一个节点，右边也最多一个节点，对于大量的输入数据，线性表的访问时间太慢，不宜使用。树是一种非线性的数据结构，其大部分操作的运行时间平均为O(logn)。树的标准定义：    树（tree）是包含n(n>0)个节点的有穷结合，其中： 每个元素称为节点（node）; 有一个特定的节点称为根节点或树根（root）; 除根节点之外的其余数据元素被
Java数据结构-树
等闲之辈莫等闲的博客
06-06 516
前序遍历：先输出父节点，再遍历左子树和右子树 中序遍历：先遍历左子树，再输出父节点，再遍历右子树 后序遍历：先遍历左子树，再遍历右子树，最后输出父节点 小结：看输出父节点的顺序，就确定是前序、中序还是后序 二叉树查找指定结点 二叉树删除结点 要求：..................
java数据结构-树和二叉树及其应用
03-16
Java数据结构中的树和二叉树是非常重要的数据结构，它们可以用来表示许多实际问题中的数据关系。树是一种非线性数据结构，它由节点和边组成，每个节点可以有多个子节点，但只有一个父节点。二叉树是一种特殊的树，每个节点最多只有两个子节点，分别称为左子节点和右子节点。 树和二叉树在计算机科学中有许多应用，例如在搜索算法中，树可以用来表示搜索空间，每个节点表示一个状态，边表示状态之间的转移。在编译器中，语法树可以用来表示程序的语法结构，方便进行语法分析和代码生成。在数据库中，B树和B+树可以用来实现索引，提高查询效率。 在Java中，树和二叉树可以用类和对象来表示。每个节点可以用一个类来表示，包含节点的值、左子节点和右子节点等属性。通过递归算法可以实现树和二叉树的遍历，包括前序遍历、中序遍历和后序遍历等。在实际应用中，还可以使用树和二叉树的剪枝、旋转等操作来优化算法效率。 总之，树和二叉树是Java数据结构中非常重要的部分，它们可以用来解决许多实际问题，是计算机科学中不可或缺的基础知识。
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值