数组二叉树互转:将数组转换成二叉树,二叉树转换为数组表示

本文先将数组转换成二叉树,再将二叉树转换成数组。可以将不平衡的二叉树转换为数组。

原理就是数组表示二叉树时,下标是n的左、右节点的下标分别是2n+1、2n+2。利用递归来实现。

一、设计树节点对象时候,可以引入深度depth、index(在数组中索引)两个属性,方便从树节点转换为数组。

import org.junit.Test;

import java.util.Arrays;

public class Traversal {
    /*
                 45
                / \
              34   5
             / \    \
            12  2    3
           /   / \    \
          33  76  8   44
    */
    static class MyTreeNode {
        Integer value;
        MyTreeNode left;
        MyTreeNode right;
        //有这个就很容易计算出数组大小了
        int depth;
        int index;

        MyTreeNode(Integer value) {
            this.value = value;
        }

        public int getDepth() {
            return depth;
        }
    }

    /**
     * 数组转换成树
     */
    @Test
    public void arrayToTree() {
        Integer[] arr = {45, 34, 5, 12, 2, null, 3, 33, null, 76, 8, null, null, null, 44};
        MyTreeNode root = generateTreeFromArray(arr, 0);
    }

    /**
     * 树转换成数组
     */
    @Test
    public void treeToArray() {
        //生成一棵树。数组没有元素情况,本例不考虑
        Integer[] arr = {45, 34, 5, 12, 2, null, 3, 33, null, 76, 8, null, null, null, 44};
        MyTreeNode root = generateTreeFromArray(arr, 0);
        //根据depth,计算数组size
        int arraySize = (int) Math.pow(2, root.depth) - 1;
        Integer[] dst = new Integer[arraySize];
        //再将node转换成对应的数组,根据index填充
        generateArrayFromTree(dst,root);
        System.out.println(Arrays.toString(dst)); //打印验证

    }

    private static void generateArrayFromTree(Integer[] arr,MyTreeNode node){
        if(node==null){
            return;
        }
        arr[node.index]=node.value;
        generateArrayFromTree(arr,node.left);
        generateArrayFromTree(arr,node.right);
    }

    private static MyTreeNode generateTreeFromArray(Integer[] arr, int index) {
        if (index > arr.length - 1 || arr[index] == null) {
            return null;
        }
        MyTreeNode myTreeNode = new MyTreeNode(arr[index]);
        myTreeNode.left = generateTreeFromArray(arr, 2 * index + 1);
        myTreeNode.right = generateTreeFromArray(arr, 2 * index + 2);
        int leftDepth = myTreeNode.left == null ? 0 : myTreeNode.left.depth;
        int rightDepth = myTreeNode.right == null ? 0 : myTreeNode.right.depth;
        myTreeNode.depth = Math.max(leftDepth, rightDepth) + 1;
        myTreeNode.index = index;
        return myTreeNode;
    }
}

二、可以有一点改动,不引入index变量,同样达到目标,其他和上面方法一样

package alg;

import org.junit.Test;

import java.util.Arrays;

public class Traversal2 {
    /*
                 45
                / \
              34   5
             / \    \
            12  2    3
           /   / \    \
          33  76  8   44
    */
    static class MyTreeNode {
        Integer value;
        MyTreeNode left;
        MyTreeNode right;
        //有这个就很容易计算出数组大小了
        int depth;


        MyTreeNode(Integer value) {
            this.value = value;
        }

        public int getDepth() {
            return depth;
        }
    }

    /**
     * 数组转换成树
     */
    @Test
    public void arrayToTree() {
        Integer[] arr = {45, 34, 5, 12, 2, null, 3, 33, null, 76, 8, null, null, null, 44};
        MyTreeNode root = generateTreeFromArray(arr, 0);
    }

    /**
     * 树转换成数组
     */
    @Test
    public void treeToArray() {
        //生成一棵树。数组没有元素情况,本例不考虑
        Integer[] arr = {45, 34, 5, 12, 2, null, 3, 33, null, 76, 8, null, null, null, 44};
        MyTreeNode root = generateTreeFromArray(arr, 0);
        //根据depth,计算数组size
        int arraySize = (int) Math.pow(2, root.depth) - 1;
        Integer[] dst = new Integer[arraySize];
        //再将node转换成对应的数组,根据index填充
        generateArrayFromTree(dst,root,0);
        System.out.println(Arrays.toString(dst)); //打印验证

    }

    private static void generateArrayFromTree(Integer[] arr,MyTreeNode node,int index){
        if(node==null){
            return;
        }
        arr[index]=node.value;
        generateArrayFromTree(arr,node.left,2*index+1);
        generateArrayFromTree(arr,node.right,2*index+2);
    }

    private static MyTreeNode generateTreeFromArray(Integer[] arr, int index) {
        if (index > arr.length - 1 || arr[index] == null) {
            return null;
        }
        MyTreeNode myTreeNode = new MyTreeNode(arr[index]);
        myTreeNode.left = generateTreeFromArray(arr, 2 * index + 1);
        myTreeNode.right = generateTreeFromArray(arr, 2 * index + 2);
        int leftDepth = myTreeNode.left == null ? 0 : myTreeNode.left.depth;
        int rightDepth = myTreeNode.right == null ? 0 : myTreeNode.right.depth;
        myTreeNode.depth = Math.max(leftDepth, rightDepth) + 1;
        return myTreeNode;
    }
}

 

  • 2
    点赞
  • 15
    收藏
    觉得还不错? 一键收藏
  • 2
    评论
将存放在数组中的二叉树转换为二叉链表,可以按照先序遍历的顺序逐个将节点添加到链表中。 具体步骤如下: 1. 定义一个指针p,用于遍历数组中的节点。 2. 遍历数组中的节点,对于每一个节点,创建一个新的链表节点,并将节点的值赋给链表节点。将链表节点插入到链表中,插入的位置为p的右子节点。 3. 如果节点有左子节点,递归处理左子节点,并将左子节点的链表头节点作为链表节点的左子节点。 4. 处理完左子节点后,如果节点有右子节点,递归处理右子节点,并将右子节点的链表头节点作为链表节点的右子节点。 5. 处理完右子节点后,返回链表头节点。 下面是一个示例代码,实现了将存放在数组中的二叉树转换为二叉链表: ```python class TreeNode: def __init__(self, val=0, left=None, right=None): self.val = val self.left = left self.right = right class ListNode: def __init__(self, val=0, next=None): self.val = val self.next = next self.left = None self.right = None class Solution: def sortedListToBST(self, head: ListNode) -> TreeNode: if not head: return None # 将链表转换数组 nodes = [] while head: nodes.append(head) head = head.next # 调用递归函数 return self.buildTree(nodes, 0, len(nodes) - 1) def buildTree(self, nodes, l, r): if l > r: return None # 取数组中间的节点作为根节点 mid = (l + r) // 2 root = TreeNode(nodes[mid].val) # 递归处理左子树和右子树 root.left = self.buildTree(nodes, l, mid - 1) root.right = self.buildTree(nodes, mid + 1, r) return root ``` 注意:这段代码是将链表转换为二叉搜索树的代码,但是思路和将数组中的二叉树转换为二叉链表是类似的。

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

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

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

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

抵扣说明:

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

余额充值