【Java数据结构】03-二叉树，树和森林

已于 2024-01-15 19:55:35 修改
阅读量1.1k 收藏 23
点赞数 19
分类专栏： 课程期末复习经验 数据结构 java 文章标签： java 数据结构 开发语言 笔记
于 2024-01-15 19:37:41 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_73569204/article/details/135609132
版权

4 二叉树、树和森林

重点章节，在选择，填空，综合中都有考察到。

4.1 掌握二叉树、树和森林的定义以及它们之间的异同点

1. 二叉树（Binary Tree）

定义： 二叉树是一种特殊的树结构，其中每个节点最多有两个子节点，通常称为左子节点和右子节点。这两个子节点的位置是有序的，左子节点的值小于或等于父节点的值，右子节点的值大于父节点的值。

特点：

  • 每个节点最多有两个子节点。
  • 子节点的位置有序，左子节点值 <= 父节点值，右子节点值 > 父节点值。

性质：

  • 在二叉树的第i层上至多有2^(i-1)个结点（i>=1）。
  • 深度为k的二叉树至多有2^k-1个结点（k>=1）。
  • 对于任何一颗二叉树T，如果其终端结点数为n0，度为2的结点数为n2，则n0=n2+1。
  • 具有n个节点的完全二叉树深为log2x+1（其中x表示不大于n的最大整数）。
  • 如果对一颗有n个结点的完全二叉树（其深度为[log2n]+1）的结点按层序编号（从第一层到[log2n]+1层，每层从左到右），对任一结点i（1<=i<=n）:
    （1）如果i=1，则结点i是二叉树的根，无双亲，如果i>1,则其双亲结点是结点[i/2]
    （2）如果2i>n，则结点i无左孩子（结点i为叶子结点）否则左孩子是结点2i。
    （3）如果2i+1>n,则结点i无右孩子，否则其右孩子是结点2i+1.
2. 树（Tree）

定义： 树是一种层次结构的数据结构，由节点和连接这些节点的边组成。树中有一个特殊的节点称为根节点，除了根节点之外，每个节点有且只有一个父节点，但可以有多个子节点。

特点：

  • 每个节点有且只有一个父节点，除了根节点。
  • 节点之间通过边相连，形成层次结构。
3. 森林（Forest）

定义： 森林是多个独立的树组成的集合。每个树都是独立的，没有公共的根节点。换句话说，森林是多个树的集合。

特点：

  • 由多个独立的树组成。
  • 每个树都是独立的，没有公共的根节点。
异同点

  1. 节点数量：

    • 二叉树：每个节点最多有两个子节点。
    • 树：每个节点有且只有一个父节点。
    • 森林：由多个独立的树组成。

  2. 连接关系：

    • 二叉树：每个节点有左子节点和右子节点。
    • 树：除了根节点，每个节点有一个父节点。
    • 森林：独立的树结构，没有公共的根节点。

  3. 结构关系：

    • 二叉树和树是单一的结构。
    • 森林是由多个独立的树组成的集合。

总体上，可以看出树是一种更一般的结构，而二叉树是树的一种特殊情况。森林是由多个树组成的结构。

4.2 掌握二叉树的四种遍历，并具有能够依赖遍历完成对二叉树进行操作的能力

期末试卷中填空题考到了根据给出的先序遍历和中序遍历字符串写出后序遍历的字符串。

二叉树的四种遍历方式包括前序遍历、中序遍历、后序遍历和层序遍历。可视化网站：Binary Tree Traversal

1. 前序遍历（Preorder Traversal）：

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

根 -> 左子树 -> 右子树

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

    public TreeNode(int val) {
        this.val = val;
    }
}

public class BinaryTreeTraversal {
    public static void preorderTraversal(TreeNode root) {
        if (root != null) {
            System.out.print(root.val + " ");
            preorderTraversal(root.left);
            preorderTraversal(root.right);
        }
    }

    public static void main(String[] args) {
        // 构建一棵二叉树
        TreeNode root = new TreeNode(1);
        root.left = new TreeNode(2);
        root.right = new TreeNode(3);
        root.left.left = new TreeNode(4);
        root.left.right = new TreeNode(5);

        // 前序遍历
        System.out.println("Preorder Traversal:");
        preorderTraversal(root);
    }
}

在这里插入图片描述

2. 中序遍历（Inorder Traversal）

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

左子树 -> 根 -> 右子树

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

    public TreeNode(int val) {
        this.val = val;
    }
}

public class BinaryTreeTraversal {
    public static void inorderTraversal(TreeNode root) {
        if (root != null) {
            inorderTraversal(root.left);
            System.out.print(root.val + " ");
            inorderTraversal(root.right);
        }
    }

    public static void main(String[] args) {
        // 构建一棵二叉树
        TreeNode root = new TreeNode(1);
        root.left = new TreeNode(2);
        root.right = new TreeNode(3);
        root.left.left = new TreeNode(4);
        root.left.right = new TreeNode(5);

        // 中序遍历
        System.out.println("Inorder Traversal:");
        inorderTraversal(root);
    }
}

在这里插入图片描述

3. 后序遍历（Postorder Traversal）

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

左子树 -> 右子树 -> 根

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

    public TreeNode(int val) {
        this.val = val;
    }
}

public class BinaryTreeTraversal {
    public static void postorderTraversal(TreeNode root) {
        if (root != null) {
            postorderTraversal(root.left);
            postorderTraversal(root.right);
            System.out.print(root.val + " ");
        }
    }

    public static void main(String[] args) {
        // 构建一棵二叉树
        TreeNode root = new TreeNode(1);
        root.left = new TreeNode(2);
        root.right = new TreeNode(3);
        root.left.left = new TreeNode(4);
        root.left.right = new TreeNode(5);

        // 后序遍历
        System.out.println("Postorder Traversal:");
        postorderTraversal(root);
    }
}

在这里插入图片描述

4. 层序遍历（Level Order Traversal）

层序遍历按照层次逐层遍历二叉树，从根节点开始，每一层按照从左到右的顺序访问节点。

import java.util.LinkedList;
import java.util.Queue;

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

    public TreeNode(int val) {
        this.val = val;
    }
}

public class BinaryTreeTraversal {
    public static void levelOrderTraversal(TreeNode root) {
        if (root == null) {
            return;
        }

        Queue<TreeNode> queue = new LinkedList<>();
        queue.offer(root);

        while (!queue.isEmpty()) {
            TreeNode current = queue.poll();
            System.out.print(current.val + " ");

            if (current.left != null) {
                queue.offer(current.left);
            }

            if (current.right != null) {
                queue.offer(current.right);
            }
        }
    }

    public static void main(String[] args) {
        // 构建一棵二叉树
        TreeNode root = new TreeNode(1);
        root.left = new TreeNode(2);
        root.right = new TreeNode(3);
        root.left.left = new TreeNode(4);
        root.left.right = new TreeNode(5);

        // 层序遍历
        System.out.println("Level Order Traversal:");
        levelOrderTraversal(root);
    }
}

这些遍历方式可以用于对二叉树进行不同类型的操作，例如查找节点、计算树的深度等。

4.3 理解二叉树采用顺序存储结构和链式存储结构的差异性

二叉树可以使用两种不同的存储结构：顺序存储结构和链式存储结构。

1. 顺序存储结构

在顺序存储结构中，使用数组来表示二叉树的节点。二叉树的节点按照某种顺序存储在数组中，可以根据节点在数组中的位置快速找到其父节点、左子节点和右子节点。

特点：

  • 使用数组作为存储结构。
  • 通过数组下标关系表示节点之间的层次和父子关系。
  • 不需要额外的指针，节省存储空间。

缺点：

  • 对于非完全二叉树，可能浪费一些数组空间。
  • 插入和删除节点操作可能需要移动其他节点，效率较低。
2. 链式存储结构

在链式存储结构中，通过使用节点对象和指针，将节点按照树的层次关系连接在一起。每个节点包含数据和指向左右子节点的指针。

特点：

  • 使用节点对象和指针来表示节点之间的关系。
  • 可以方便地插入和删除节点，不需要移动其他节点。
  • 适用于不规则的树结构，不会浪费空间。

缺点：

  • 每个节点需要额外的指针空间，占用更多的存储空间。
  • 对于大规模数据的二叉树，可能存在指针的空间开销。

差异性比较

  1. 存储结构：

    • 顺序存储结构使用数组。
    • 链式存储结构使用节点对象和指针。

  2. 存储方式：

    • 顺序存储结构通过数组下标表示节点关系。
    • 链式存储结构通过指针连接节点。

  3. 空间效率：

    • 顺序存储结构可能浪费一些空间，特别是对于非完全二叉树。
    • 链式存储结构对于不规则的树结构更灵活，不会浪费空间。

  4. 时间效率：

    • 顺序存储结构的插入和删除操作可能需要移动其他节点，效率较低。
    • 链式存储结构对于插入和删除操作更灵活，效率较高。

选择使用哪种存储结构取决于具体应用场景和需求。如果二叉树的结构较规则且不频繁发生变化，顺序存储结构可能更为合适。如果二叉树结构较为灵活且需要频繁插入和删除操作，链式存储结构可能更适用。

4.4 掌握二叉检索树、Huffman编码以及堆的实现

1. 二叉搜索树（Binary Search Tree，BST）

定义： 二叉搜索树是一种二叉树，其中每个节点的值大于其左子树中的所有节点的值，且小于其右子树中的所有节点的值。

实现要点：

  1. 节点的左子树的所有节点值都小于节点的值。
  2. 节点的右子树的所有节点值都大于节点的值。
  3. 左右子树也分别是二叉搜索树。

Java 代码示例：

class TreeNode {
    int val;
    TreeNode left, right;

    public TreeNode(int val) {
        this.val = val;
        this.left = this.right = null;
    }
}

public class BinarySearchTree {
    private TreeNode root;

    // 插入节点
    public void insert(int key) {
        root = insertRec(root, key);
    }

    private TreeNode insertRec(TreeNode root, int key) {
        if (root == null) {
            root = new TreeNode(key);
            return root;
        }

        if (key < root.val) {
            root.left = insertRec(root.left, key);
        } else if (key > root.val) {
            root.right = insertRec(root.right, key);
        }

        return root;
    }

    // 中序遍历
    public void inorder() {
        inorderRec(root);
    }

    private void inorderRec(TreeNode root) {
        if (root != null) {
            inorderRec(root.left);
            System.out.print(root.val + " ");
            inorderRec(root.right);
        }
    }

    public static void main(String[] args) {
        BinarySearchTree bst = new BinarySearchTree();
        int[] keys = {50, 30, 20, 40, 70, 60, 80};

        for (int key : keys) {
            bst.insert(key);
        }

        System.out.println("Inorder traversal:");
        bst.inorder();
    }
}
2. Huffman 编码

定义： Huffman 编码是一种压缩算法，通过构建最优二叉树（Huffman 树）来实现对数据的压缩。频率越高的字符对应的编码越短，频率越低的字符对应的编码越长。

实现要点：

  1. 构建 Huffman 树。
  2. 通过 Huffman 树生成字符的编码。

Java 代码示例：

import java.util.PriorityQueue;

class HuffmanNode implements Comparable<HuffmanNode> {
    char data;
    int frequency;
    HuffmanNode left, right;

    public HuffmanNode(char data, int frequency) {
        this.data = data;
        this.frequency = frequency;
        this.left = this.right = null;
    }

    @Override
    public int compareTo(HuffmanNode node) {
        return this.frequency - node.frequency;
    }
}

public class HuffmanCoding {
    public static void main(String[] args) {
        String input = "hello world";

        // 构建 Huffman 树
        HuffmanNode root = buildHuffmanTree(input);

        // 生成 Huffman 编码
        System.out.println("Huffman Codes:");
        printHuffmanCodes(root, new StringBuilder());
    }

    private static HuffmanNode buildHuffmanTree(String input) {
        // 统计字符频率
        int[] frequency = new int[256];
        for (char ch : input.toCharArray()) {
            frequency[ch]++;
        }

        // 构建最小堆（PriorityQueue）
        PriorityQueue<HuffmanNode> minHeap = new PriorityQueue<>();
        for (char i = 0; i < 256; i++) {
            if (frequency[i] > 0) {
                minHeap.offer(new HuffmanNode(i, frequency[i]));
            }
        }

        // 构建 Huffman 树
        while (minHeap.size() > 1) {
            HuffmanNode left = minHeap.poll();
            HuffmanNode right = minHeap.poll();

            HuffmanNode internalNode = new HuffmanNode('$', left.frequency + right.frequency);
            internalNode.left = left;
            internalNode.right = right;

            minHeap.offer(internalNode);
        }

        return minHeap.poll();  // 返回 Huffman 树的根节点
    }

    private static void printHuffmanCodes(HuffmanNode root, StringBuilder code) {
        if (root == null) {
            return;
        }

        // 叶子节点表示一个字符，打印字符和对应的 Huffman 编码
        if (root.data != '$') {
            System.out.println(root.data + ": " + code);
        }

        // 递归处理左子树
        code.append('0');
        printHuffmanCodes(root.left, code);
        code.deleteCharAt(code.length() - 1);

        // 递归处理右子树
        code.append('1');
        printHuffmanCodes(root.right, code);
        code.deleteCharAt(code.length() - 1);
    }
}

3. 堆的实现

期末试卷中填空题考到了构建二叉检索树，涉及筛选法构建最小堆

定义： 堆是一种特殊的树状数据结构，其中每个节点的值都小于或等于其子节点的值。堆分为最大堆和最小堆。

实现要点：

  1. 最大堆：每个节点的值都大于或等于其子节点的值。
  2. 最小堆：每个节点的值都小于或等于其子节点的值。
  3. 堆的常见操作：插入节点、删除节点、堆化（维护堆的性质）。

Java 代码示例：

public class MaxHeap {
    private int[] heap;
    private int size;
    private int capacity;

    public MaxHeap(int capacity) {
        this.capacity = capacity;
        this.size = 0;
        this.heap = new int[capacity + 1];
    }

    public void insert(int value) {
        if (size == capacity) {
            System.out.println("Heap is full. Cannot insert " + value);
            return;
        }

        size++;
        heap[size] = value;
        int current = size;

        // 上移操作，维护堆的性质
        while (current > 1 && heap[current] > heap[parent(current)]) {
            swap(current, parent(current));
            current = parent(current);
        }

4.5 掌握树、森林采用的各种存储方式的差异性

期末试卷中综合题考察了树和森林的转换，要求用双亲表示法。

树的存储方式

  1. 双亲表示法：

    在双亲表示法中，每个节点包含一个指向其父节点的指针，以及一个指向其第一个子节点的指针。通过这种方式，可以方便地找到父节点和第一个子节点。

    class TreeNode {
    int data;
    int parent; // 父节点的索引
}

// 示例：树的双亲表示法
TreeNode[] tree = new TreeNode[10];

  2. 孩子表示法：

    在孩子表示法中，每个节点包含一个指向其第一个子节点的指针，以及一个指向其右兄弟节点的指针。这种表示法适用于节点的子节点数量不固定的情况。

    class TreeNode {
    int data;
    TreeNode firstChild; // 指向第一个子节点
    TreeNode nextSibling; // 指向右兄弟节点
}

// 示例：树的孩子表示法
TreeNode root = new TreeNode();
森林的存储方式

森林是多棵树的集合。存储森林可以采用上述树的存储方式，每个树用一个独立的数据结构表示。

class ForestNode {
    int data;
    ForestNode firstChild; // 指向第一个子节点
    ForestNode nextSibling; // 指向右兄弟节点
}

// 示例：森林的存储
ForestNode tree1 = new ForestNode();
ForestNode tree2 = new ForestNode();

这里的 ForestNode 类似于树的孩子表示法，每个树用一个节点表示，节点的 firstChild 指向树的根节点，nextSibling 指向其他树的根节点。

4.6 掌握树和森林与二叉树的转换

1.树转换为二叉树

树到二叉树的转换可以通过以下步骤完成：

  1. 每个节点添加右兄弟指针： 对树的每个节点，将它的所有子节点按照从左到右的顺序连接起来，形成右兄弟链。

  2. 去除父节点指针： 去掉树的每个节点中指向父节点的指针。

  3. 添加二叉树的左右孩子指针： 对树的每个节点，将其第一个子节点作为二叉树的左孩子，将其右兄弟节点作为二叉树的右孩子。

class TreeNode {
    int data;
    TreeNode firstChild; // 指向第一个子节点
    TreeNode nextSibling; // 指向右兄弟节点
}

class BinaryTreeNode {
    int data;
    BinaryTreeNode leftChild; // 左孩子
    BinaryTreeNode rightChild; // 右孩子
}

public class TreeToBinaryTreeConverter {
    public static BinaryTreeNode convertTreeToBinaryTree(TreeNode root) {
        if (root == null) {
            return null;
        }

        BinaryTreeNode binaryRoot = new BinaryTreeNode();
        binaryRoot.data = root.data;

        // 将树的子节点转换为二叉树的左孩子
        binaryRoot.leftChild = convertTreeToBinaryTree(root.firstChild);

        // 将树的右兄弟节点转换为二叉树的右孩子
        binaryRoot.rightChild = convertTreeToBinaryTree(root.nextSibling);

        return binaryRoot;
    }
}

二叉树转换为树：

二叉树到树的转换相对简单，只需将二叉树的右孩子链表还原为树的右兄弟链。

class BinaryTreeNode {
    int data;
    BinaryTreeNode leftChild; // 左孩子
    BinaryTreeNode rightChild; // 右孩子
}

class TreeNode {
    int data;
    TreeNode firstChild; // 指向第一个子节点
    TreeNode nextSibling; // 指向右兄弟节点
}

public class BinaryTreeToTreeConverter {
    public static TreeNode convertBinaryTreeToTree(BinaryTreeNode binaryRoot) {
        if (binaryRoot == null) {
            return null;
        }

        TreeNode root = new TreeNode();
        root.data = binaryRoot.data;

        // 将二叉树的左孩子转换为树的第一个子节点
        root.firstChild = convertBinaryTreeToTree(binaryRoot.leftChild);

        // 将二叉树的右孩子转换为树的右兄弟节点
        root.nextSibling = convertBinaryTreeToTree(binaryRoot.rightChild);

        return root;
    }
}

4.7 掌握树、森林在遍历方面和二叉树的不同以及相关性

树的遍历

  1. 先序遍历（Preorder Traversal）： 先访问根节点，然后递归地对每个子树进行先序遍历。

  2. 后序遍历（Postorder Traversal）： 先递归地对每个子树进行后序遍历，然后访问根节点。

  3. 层次遍历： 从树的根节点开始，按层次逐层遍历。

森林的遍历

森林是多棵树的集合，因此森林的遍历就是对每棵树进行遍历。可以采用树的遍历方式。

二叉树的遍历

在二叉树中，有以下三种常见的遍历方式：

  1. 先序遍历（Preorder Traversal）： 先访问根节点，然后递归地对左子树和右子树进行先序遍历。

  2. 中序遍历（Inorder Traversal）： 先递归地对左子树进行中序遍历，然后访问根节点，最后递归地对右子树进行中序遍历。

  3. 后序遍历（Postorder Traversal）： 先递归地对左子树和右子树进行后序遍历，然后访问根节点。

这三种遍历方式对于树、森林和二叉树都是适用的，但在树和森林的情况下，可能需要对每棵树分别进行遍历。

相关性和不同点

  1. 共同点： 树、森林和二叉树都可以使用先序、中序和后序等遍历方式。

  2. 不同点： 在树和森林中，节点的子节点数量不一定是固定的，因此在遍历时可能需要通过指向第一个子节点和右兄弟节点的方式进行遍历。而在二叉树中，每个节点最多有两个子节点，可以采用左孩子和右孩子的方式进行遍历。

下面是一个简单的 Java 代码示例，演示了树的先序遍历：

class TreeNode {
    int data;
    TreeNode firstChild; // 指向第一个子节点
    TreeNode nextSibling; // 指向右兄弟节点
}

public class TreeTraversal {
    // 先序遍历树
    public static void preOrderTraversal(TreeNode root) {
        if (root == null) {
            return;
        }

        // 访问根节点
        System.out.print(root.data + " ");

        // 递归遍历子树
        preOrderTraversal(root.firstChild);

        // 递归遍历右兄弟节点
        preOrderTraversal(root.nextSibling);
    }

    public static void main(String[] args) {
        TreeNode root = new TreeNode();
        root.data = 1;

        TreeNode child1 = new TreeNode();
        child1.data = 2;

        TreeNode child2 = new TreeNode();
        child2.data = 3;

        root.firstChild = child1;
        child1.nextSibling = child2;

        preOrderTraversal(root);
    }
}

4.8 理解并查集的意义，掌握并查集两个基本操作的实现并掌握重量权衡平衡原则和路径压缩

并查集（Disjoint Set Union，简称并查集）是一种用于处理不相交集合的数据结构，主要用于解决一些集合合并与查询问题。它支持两个主要操作：查找（Find）和合并（Union）。

并查集的基本操作

  1. 查找（Find）： 查找一个元素所属的集合，通常通过找到该集合的代表元素来实现。

  2. 合并（Union）： 合并两个集合，通常将其中一个集合的代表元素作为另一个集合的子集。

实现并查集的两种基本方法

  1. 数组表示法： 将每个元素用数组表示，数组的值表示该元素所属的集合。parent[i] 表示元素 i 的父节点，根节点的父节点为自身。

    int[] parent = new int[n];

// 初始化，每个元素独立成集合，父节点为自身
for (int i = 0; i < n; i++) {
    parent[i] = i;
}

// 查找操作
int find(int x) {
    if (parent[x] != x) {
        parent[x] = find(parent[x]);  // 路径压缩
    }
    return parent[x];
}

// 合并操作
void union(int x, int y) {
    int rootX = find(x);
    int rootY = find(y);
    if (rootX != rootY) {
        parent[rootX] = rootY;  // 合并时可以考虑根据集合大小进行重量权衡
    }
}

  2. 树表示法： 将每个集合表示为一棵树，其中树的根节点为代表元素。

    class TreeNode {
    int val;
    TreeNode parent;
}

// 查找操作
TreeNode find(TreeNode x) {
    if (x.parent != null) {
        x.parent = find(x.parent);  // 路径压缩
        return x.parent;
    }
    return x;
}

// 合并操作
void union(TreeNode x, TreeNode y) {
    TreeNode rootX = find(x);
    TreeNode rootY = find(y);
    if (rootX != rootY) {
        rootX.parent = rootY;  // 合并时可以考虑根据集合大小进行重量权衡
    }
}
重量权衡平衡原则

在合并操作时，可以考虑根据集合的大小进行重量权衡，即将元素较少的集合合并到元素较多的集合中，从而降低树的深度，提高效率。

路径压缩

在查找操作时，通过路径压缩可以将树的深度降低，使得后续查找操作更加高效。路径压缩的思想是在查找的同时，将查找路径上的节点直接连接到根节点，使得路径更短。
快乐星球居民13号
关注
  • 19
    点赞
  • 踩
  • 23
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
【数据结构（Java）】树 - 二叉树
qq_45640831的博客
11-26 291
整理的笔记 【有错请见谅且指出，无错以后自己看的时候有新见解再添】 目录资源树树的基本定义树的相关术语二叉树二叉树的基本定义二叉树查找树的实现【链表】二叉查找树其他便捷方法查找二叉树中最小的键查找二叉树中最大的键二叉树的基础遍历【深度优先】前序遍历中序遍历【遍历从小到大，有序的】后序遍历二叉树的层序遍历【数据结构算法中的遍历思想：广度优先】二叉树的最大深度问题折纸问题【层序遍历构建树，中序遍历输出树】 资源 视频：https://www.bilibili.com/video/BV1iJ411E7xW?p=7
Java基础复习笔记08数据结构-二叉树和二叉树的遍历
05-08
Java基础复习笔记08数据结构-二叉树和二叉树的遍历。
数据结构 Java数据结构 --- 二叉树
wwzzzzzzzzzzzzz的博客
12-11 5069
二叉树 1. 树形结构 1.1 概念 树是一种非线性的数据结构，它是由n（n>=0）个有限结点组成一个具有层次关系的集合。把它叫做树是因为它看起来像一棵倒挂的树，也就是说它是根朝上，而叶朝下的。它具有以下的特点： 有一个特殊的节点，称为根节点，根节点没有前驱节点 除根节点外，其余节点被分成M(M > 0)个互不相交的集合T1、T2、…Tm，其中每一个集合 Ti (1 <= i<= m) 又是一棵与树类似的子树。每棵子树的根节点有且只有一个前驱，可以有0个或多个后继 树是递归定义的。
Java数据结构--树、森林和二叉树
书香水墨
07-11 922
一、树、森林和二叉树之间的转换 树或森林与二叉树之间存在一一对应的关系。任何一棵树或一个森林可唯一地对应到一棵二叉树；反之，任何一棵二叉树也能唯一地对应到一个森林或一棵树。 2.1 将树转化为二叉树 树中每个结点最多只有一个最左边的孩子（长子）和一个右邻的兄弟。按照这种关系很自然地就能将树转换成相应的二叉树，具体步骤是： 1）在所有兄弟结点之间加一连线； 2）对每个结点，除了保留与其长子的连线外，去掉该结点与其他孩子的连线。 示例：将图2.1.1所示的树转换为二叉树。 根据树转二叉树的规则：第一
【Java 数据结构】树和二叉树
热门推荐
书生-w的博客
04-17 1万+
树是一种非线性的数据结构，它是由n个(n>=0)个有限节点组成一个具有层次关系的集合。它的形状像一颗倒挂的树，根在上，叶在下。 特点： · 有一个特殊的结点称为根节点，根节点没有前驱结点 除根节点外，其余结点被分成M(M>0)个互不相交的集合T1,T2,.....,Tm，其中每一个集合又是一颗与树类似的字树。每棵子树的根节点有且只有一个前驱，可以没有或者多个后继 · 树是递归定义的 注意：在树形结构中，子树不能有交集，否则就不是树形结构
java 森林_Java数据结构--树、森林和二叉树
weixin_39703468的博客
02-22 348
一、树、森林和二叉树之间的转换树或森林与二叉树之间存在一一对应的关系。任何一棵树或一个森林可唯一地对应到一棵二叉树；反之，任何一棵二叉树也能唯一地对应到一个森林或一棵树。1.1 将树转化为二叉树树中每个结点最多只有一个最左边的孩子(长子)和一个右邻的兄弟。按照这种关系很自然地就能将树转换成相应的二叉树，具体步骤是：1)在所有兄弟结点之间加一连线；2)对每个结点，除了保留与其长子的连线外，去掉该结点...
Java数据结构---树-二叉树
BEYONDmonster的博客
10-12 188
存储数据的方式：数组存储、链式存储、树结构存储。 数组存储方式分析： 优点：通过下标方式访问元素，速度快。对于有序数组，还可以使用二分查找提高检索速度。 缺点：如果检索具体某个值，或者插入值(按一定顺序)会整体移动，效率较低。 链式存储方式分析： 优点：在一定程度上对数组存储方式有优化(例如：插入一个结点，只需要将插入的结点链接到链表中即可，删除效率也很好)。 缺点：在进行检索时，效率任然较低，检...
【Java】数据结构---二叉树 详解
xqs196301的博客
01-19 658
数据结构---二叉树
【数据结构】树-二叉树、树和森林的还原（图解、c++、java）
扑腾的江鱼复习仓库
03-05 2100
URLeisure的二叉树、树和森林的还原“完美”复习资料。
Java数据结构--二叉树
pf_1308108803的博客
12-28 185
树: 1、树(Tree)是n（n≥0）个节点的有限集。 2、n = 0 时称为空树。 3、在任意一颗非空树中: （1）有且仅有一个特定的称为根（Root）节点 （2）当n > 1 时，其余节点可分为 m （m > 0）个互不相交的有限集T1,T2...Tm,其中每一个集合本身又是一棵树，并且称为根的子树。 节点的度 结点拥有的子树数称为结点的度。度为0的结点称为叶子结点或终
java数据结构面试题-数据结构试题.docx
07-11
java数据结构面试题-数据结构...设F是由T1、T2和T3三棵树组成的森林，与F对应的二叉树为B，T1、T2和T3的结点数分别为N1、N2和N3，则二叉树B的根结点的左子树的结点数为( )。 (A) N1-1 (B) N2-1 (C) N2+N3 (D) N1+N3 4.
数据结构（C语言版）\Java数据结构和算
12-19
第1章 基本概念 1.1 概观：系统生命周期 1.2 指针和动态存储分配 1.3 算法形式规范 ...12. 2 二路Trie树和Patricia树 12.3 多路Trie树 12.4 后缀树 12.5 Trie树和互联网的包转发 12.6 参考文献和选读材料
Java数据结构和算法.
10-24
java语言基础知识 数据结构与算法基础 线性表 List、单链表、双链表、迭代器 栈和队列 递归 树 二叉树、树和森林、Huffman树 图 查找 排序
java算法与数据结构
04-14
（1）数据、数据对象和数据结构 （2）抽象数据类型 （3）算法的特征及评价的标准 （4）数据的存储结构类型 2．线形结构 （1）顺序表的特点及存储结构 （2）链表的特点及存储结构 （3）栈的特点及基本操作 （4）队列...
jar包增量更新分析
最新发布
junlaiyan的专栏
05-16 276
借助jdeps分析出jar包的增量文件
Spring-Cloud 微服务
weixin_65127444的博客
05-15 907
先来思考一个问题*通过上一章的操作，我们已经可以实现微服务之间的调用。但是我们把服务提供者的网络地址（ip，端口）等硬编码到了代码中，这种做法存在许多问题：1.一旦服务提供者地址变化，就需要手工修改代码2. 一旦是多个服务提供者，无法实现负载均衡功能3.一旦服务变得越来越多，人工维护调用关系困难那么应该怎么解决呢，这时候就需要通过注册中心动态的实现。
java实现拼图小游戏
monkey108的博客
05-16 637
本文主要提供用java实现的拼图小游戏源代码。
命令执行漏洞（二）
XLbb的博客
05-15 911
POST方法，S2-045-bypass-2漏洞存在！,程序更改为S2-045-bypass-2漏洞测试模式, 响应码: 200。POST方法，S2-046-bypass漏洞存在！POST方法，S2-045-bypass漏洞存在！POST方法，S2-046-1漏洞存在！POST方法，S2-046-2漏洞存在！POST方法，S2-046-3漏洞存在！POST方法，S2-045-1漏洞存在！POST方法，S2-045-3漏洞存在！POST方法，S2-045-2漏洞存在！POST方法，S2-045-4漏洞存在！
java数据结构-树和二叉树及其应用
03-16
Java数据结构中的树和二叉树是非常重要的数据结构，它们可以用来表示许多实际问题中的数据关系。树是一种非线性数据结构，它由节点和边组成，每个节点可以有多个子节点，但只有一个父节点。二叉树是一种特殊的树，每...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值