使用深度优先搜索转换二维数组中的树答案

【问题标题】：Convert a tree in 2d array with depth first search使用深度优先搜索转换二维数组中的树
【发布时间】：2021-10-05 10:29:07
【问题描述】：

我有一棵二叉树下面的二叉树，需要转换成二维数组。

[[10,5,3,3]]
[[10,5,3,-2]]
[[10,5,2,1]]
[[10,-3,11]]

【问题讨论】：

这不是回答你的问题吗，stackoverflow.com/questions/31620277/…
你能详细说明那棵特定的树是如何变成那个特定的二维数组的吗？我无法看到连接。
请看How do I ask a good question?

标签： java arrays binary-tree depth-first-search

【解决方案1】：

    public int ConvertToArray(TreeNode root, int targetSum) {
        ArrayList<ArrayList<Integer>> paths = new ArrayList<ArrayList<Integer>>();
        ArrayList<Integer> path = new ArrayList<Integer>();
        ConvertToArray(root, paths, path);
        return 1;
    }
    
    public void ConvertToArray(TreeNode root, ArrayList<ArrayList<Integer>> paths, ArrayList<Integer> path)
    {
        if(root == null)
        {
            var currpath = new ArrayList<>(path);
            paths.add(currpath);
            return;
        }
        
        path.add(root.val);        
        
        ConvertToArray(root.left, paths, path);
        ConvertToArray(root.right, paths, path);
        path.remove(path.size()-1);
    }
}

【讨论】：

【解决方案2】：

你可以检查这个实现。

import java.util.Scanner;
import java.util.Stack;
import java.util.stream.Collectors;

public class Main {
    static class Node {
        int value;
        Node right;
        Node left;

        Node(int value) {
            this.value = value;
        }

        @Override
        public String toString() {
            return "" + value;
        }

        public boolean isLeaf() {
            return right == null && left == null;
        }
    }

    public static void main(String[] args) {
        String input = "10 5 -3 3 2 3 -2 N N N N N 1 N N N 11 N N";
        Scanner scanner = new Scanner(input);
        Node root = new Node(scanner.nextInt());
        parse(scanner, root);
        print(root);
    }

    private static void parse(Scanner scanner, Node node) {
        if (!scanner.hasNext("N")) {
            node.left = new Node(scanner.nextInt());
        } else {
            scanner.next();
        }
        if (!scanner.hasNext("N")) {
            node.right = new Node(scanner.nextInt());
        } else {
            scanner.next();
        }
        if (node.left != null) {
            parse(scanner, node.left);
        }
        if (node.right != null) {
            parse(scanner, node.right);
        }
    }

    private static void print(Node node) {
        Stack<Node> stack = new Stack<>();
        stack.push(node);
        print(node, stack);
    }

    private static void print(Node node, Stack<Node> stack) {
        if (node.isLeaf()) {
            print(stack);
        } else {
            if (node.left != null) {
                stack.push(node.left);
                print(node.left, stack);
            }
            if (node.right != null) {
                stack.push(node.right);
                print(node.right, stack);
            }
        }
        stack.pop();
    }
    
    private static void print(Stack<Node> stack) {
        String values = stack.stream().map(s -> "" + s.value).collect(Collectors.joining(","));
        System.out.println("[[" + values + "]]");
    }
}

输出

[[10,5,3,3]]
[[10,5,3,-2]]
[[10,5,2,1]]
[[10,-3,11]]

【讨论】：