java实现二叉树创建

二叉树是一种常见的数据结构，下面是Java实现二叉树的创建代码：

//定义二叉树节点类
class TreeNode {
    int val;
    TreeNode left;
    TreeNode right;
    TreeNode(int x) { val = x; }
}

//创建二叉树
public TreeNode createTree(int[] arr, int index) {
    TreeNode root = null;
    if (index < arr.length) {
        root = new TreeNode(arr[index]);
        root.left = createTree(arr, 2 * index + 1);
        root.right = createTree(arr, 2 * index + 2);
    }
    return root;
}

以上代码实现了一个用数组创建二叉树的方法，传入一个数组和根节点的下标，递归地创建左子树和右子树。其中，数组的下标从0开始。使用示例如下：

int[] arr = {1, 2, 3, 4, 5, 6, 7};
TreeNode root = createTree(arr, 0);

以上代码创建了一个如下图所示的二叉树：

        1
       / \
      2   3
     / \ / \
    4  5 6  7

相关问题

java创建二叉树_java实现二叉树的创建及5种遍历方法(总结)

好的，下面是Java实现二叉树的创建及5种遍历方法的总结：

1. 二叉树的创建

二叉树的创建可以通过递归的方式实现，在每个节点中创建左子树和右子树，以此递归下去。具体代码实现如下：

class TreeNode {
    int val;
    TreeNode left;
    TreeNode right;
    TreeNode(int x) { val = x; }
}

public class BinaryTree {
    public TreeNode createBinaryTree(int[] nums, int index) {
        TreeNode root = null;
        if (index < nums.length) {
            root = new TreeNode(nums[index]);
            root.left = createBinaryTree(nums, 2 * index + 1);
            root.right = createBinaryTree(nums, 2 * index + 2);
        }
        return root;
    }
}

其中，`nums`为二叉树的节点值数组，`index`为当前节点的索引。

2. 二叉树的前序遍历

二叉树的前序遍历是指先访问根节点，然后按照左子树、右子树的顺序依次遍历。代码实现如下：

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

3. 二叉树的中序遍历

二叉树的中序遍历是指先遍历左子树，然后访问根节点，最后遍历右子树。代码实现如下：

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

4. 二叉树的后序遍历

二叉树的后序遍历是指先遍历左子树，然后遍历右子树，最后访问根节点。代码实现如下：

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

5. 二叉树的层序遍历

二叉树的层序遍历是指按照从上到下、从左到右的顺序依次遍历每个节点。代码实现如下：

public void levelOrderTraversal(TreeNode root) {
    if (root == null) {
        return;
    }
    Queue<TreeNode> queue = new LinkedList<>();
    queue.offer(root);
    while (!queue.isEmpty()) {
        int levelSize = queue.size();
        for (int i = 0; i < levelSize; i++) {
            TreeNode node = queue.poll();
            System.out.print(node.val + " ");
            if (node.left != null) {
                queue.offer(node.left);
            }
            if (node.right != null) {
                queue.offer(node.right);
            }
        }
    }
}

以上就是Java实现二叉树的创建及5种遍历方法的总结，希望能对你有所帮助。

java 实现 二叉树

Java可以通过数组来实现顺序存储二叉树。在这种实现方式中，使用一个一维数组来存储二叉树中的节点数据，在数组中的位置按照特定规则与二叉树中的节点位置建立对应关系。通过这种方式，可以实现二叉树的前序遍历、中序遍历和后序遍历。

下面是一个Java的示例代码，演示了如何使用数组实现顺序存储二叉树的前序遍历：

public class ArrayBinaryTreeDemo {
    public static void main(String[] args) {
        int[] arr = {1, 2, 3, 4, 5, 6, 7};
        ArrayBinaryTree arrayBinaryTree = new ArrayBinaryTree(arr);
        arrayBinaryTree.preOrder(); // 输出结果：1, 2, 4, 5, 3, 6, 7
    }
}

class ArrayBinaryTree {
    private int[] arr; // 存储数据节点的数组

    public ArrayBinaryTree(int[] arr) {
        this.arr = arr;
    }

    // 前序遍历
    public void preOrder() {
        preOrder(0);
    }

    private void preOrder(int index) {
        if (arr == null || arr.length == 0) {
            System.out.println("数组为空，不能按照二叉树的前序遍历");
            return;
        }
        
        System.out.println(arr[index]); // 输出当前节点

        // 遍历左子树
        if ((index * 2 + 1) < arr.length) {
            preOrder(index * 2 + 1);
        }

        // 遍历右子树
        if ((index * 2 + 2) < arr.length) {
            preOrder(index * 2 + 2);
        }
    }
}

以上代码实现了二叉树的前序遍历。你可以根据需要扩展它来实现中序遍历和后序遍历。