Java 打印高于所有叶节点N级的所有节点

我需要打印高于所有叶节点N级的所有节点。我尝试了下面的方法，但现在我卡住了，无法继续。请帮忙。我只需要使用Java 7编写，而不需要其他版本

例如，我有这个路径

1-->2-->3-->4

，因此在这种情况下，假设

4

是我的叶节点，节点

3

比

4

高1级，节点

2

比叶节点

4

高2级，节点

1

比叶节点

4

高3级

注意：请仅使用Java 7

public class NNodeBeforeLeaf {

    static Node root;
    static class Node {
        int data;
        Node left, right;
        Node(int data){
            this.data = data;
            left=right=null;
        }
    }

    public static boolean isLeaf(Node n){
        if(n.right == null && n.left == null)
            return true;
        return false;
    }

    public static void main(String[] args) {
        int level = 2;      // level N
        root = new Node(1);
        root.left = new Node(2);
        root.right = new Node(3);
        root.left.left = new Node(4);
        root.left.right = new Node(5);
        root.right.left = new Node(8);

        print(root, 0, level);
    }

    public static void print(Node n, int currLevel, int level){
        if(n == null){
            return;
        }
        if(!isLeaf(n)){
            print(n.left, currLevel + 1, level);
            print(n.right, currLevel + 1, level);
        }
        printNode(n, currLevel, level);
    }

    public static void printNode(Node n, int currLevel, int level){}

}

---

请先阅读我的评论

由于程序中的节点只存储它们下面的节点的数据，我真的找不到一种方法来实际向上爬树'：），但我可以想到这种解决方法，基本上你可以做的是，每次你需要向上爬升n级，你可以从根向下遍历（curLevel-n）这是一个示例程序，可以执行此操作（它以高于当前级别n的级别打印所有节点，我希望这就是您的意思）：

虽然我想补充一点，如果上升是您关注的问题之一，那么不要使用这个节点结构，而是向节点添加另一个变量，一个对其正上方节点的引用，这样可以使这变得更简单和更短

上述代码的输出为：

2
2

---

要做到这一点，您的结构中有一个遗漏：一个节点知道它的子节点，但不是父节点，因此您需要构建一个结构，为您提供此链接：我的建议是：我构建一个映射，它为我提供了与节点关联的父节点，方法是buildParentMap。此函数已在一个过程中列出所有叶，以避免重复你的树，然后我使用这个地图，在我列出的每一片叶子上，按我所要求的次数向上移动，就在这里是一个片段之前

小心这段代码可以工作，但是如果您试图提高该根目录的上限，或者如果同一个节点存在于太子目录中，则没有安全性（但是具有相同数据的2个节点不会是问题）

导入java.util.array；
导入java.util.HashMap；
导入java.util.HashSet；
导入java.util.LinkedList；
公共类NNodeBeforeLeaf{
静态节点根；
静态类节点{
int数据；
左、右淋巴结；
节点（int数据）{
这个数据=数据；
左=右=空；
}
@凌驾
公共字符串toString（）{
返回“节点：”+数据；
}
}
公共静态布尔isLeaf（节点n）{
if（n.right==null&&n.left==null）
返回true；
返回false；
}
公共静态void main（字符串[]args）{
int level=2；//级别N
根=新节点（1）；
root.left=新节点（2）；
root.right=新节点（3）；
root.left.left=新节点（4）；
root.left.right=新节点（5）；
root.right.left=新节点（8）；
打印（根，0，级别）；
int levelToUp=1；
HashSet result=getUpper（levelToUp，root）；
System.out.println（Arrays.toString（result.toArray（））；
}
私有静态HashSet getUpper（int-levelToUp，Node-Node）{
HashMap parentmap=新的HashMap（）；
LinkedList leafs=新建LinkedList（）；
buildParentMap（节点、parentmap、leafs）；
HashSet result=新的HashSet（）；
用于（节点叶：叶）{
添加（getUpperLevel（leaf，levelToUp，parentMap））；
}
返回结果；
}
私有静态节点getUpperLevel（节点叶、int i、HashMap ParentMap）{
节点tmp=叶；
而（i>0）{
我--；
tmp=parenttMap.get（tmp）；
}
返回tmp；
}
私有静态void buildParentMap（节点root2、HashMap HashMap、LinkedList叶）{
if（root2==null）{
返回；
}else if（isLeaf（root2））{
添加（根2）；
}否则{
put（root2.left，root2）；
buildParentMap（root2.left，hashMap，leaf）；
put（root2.right，root2）；
buildParentMap（root2.right，hashMap，leaf）；
}
}
公共静态无效打印（节点n，整数级，整数级）{
如果（n==null）{
返回；
}
printNode（n，currLevel，level）；
如果（！isLeaf（n））{
打印（左n，当前级别+1，级别）；
打印（右侧，当前级别+1，级别）；
}
}
公共静态void printNode（节点n，int currLevel，int level）{
字符串输出=”；
对于（int i=0；i

我认为

公共静态布尔isLeaf（节点n）

的实现是错误的，它应该只检查right是否为null，否则它不是节点，也不是叶

要获取节点的当前级别，可以尝试使用以下代码

int level = 0;
while(node.right != null) {
    level++;
    node = node.right;
}
System.out.println("current level node: " + level);

---

您的结构无法确定当前节点的高度，从下到上遍历时除外。为了实现这一点，您必须首先遍历到叶

然后，每个递归（从下到上）都应该返回它的高度。正如您没有说明的，如果您的树是一个完整的二叉树，一个节点可以有多个高度，这取决于它的子节点。如果高度与所需高度匹配，则可以打印节点

import java.util.Collections;
import java.util.HashSet;
import java.util.Set;

public class NNodeBeforeLeaf {

    static Node root;

    static class Node {

        int data;
        Node left, right;

        Node(int data) {
            this.data = data;
            left = right = null;
        }
    }

    public static boolean isLeaf(Node n) {
        return n.right == null && n.left == null;
    }

    public static void main(String[] args) {
        int level = 2;      // level N
        root = new Node(1);
        root.left = new Node(2);
        root.right = new Node(3);
        root.left.left = new Node(4);
        root.left.right = new Node(5);
        root.right.left = new Node(8);

        print(root, level);
    }

    public static void print(Node n, int level) {
        traversAndPrint(n, level);
    }

    private static Set<Integer> traversAndPrint(Node n, int levelToPrint) {
        if (isLeaf(n)) return Collections.singleton(0); // We are a leaf, so we have height 0

        final Set<Integer> childrenHeights = new HashSet<>();

        // are no leaf, so we have to get the heights of our children
        if (n.right != null) childrenHeights.addAll(traversAndPrint(n.right, levelToPrint));
        if (n.left != null) childrenHeights.addAll(traversAndPrint(n.left, levelToPrint));

        assert !childrenHeights.isEmpty();

        // And increase these heights
        final Set<Integer> selfHeights = new HashSet<>();
        for (Integer childrenHeigth : childrenHeights) {
            final int selfHeight = childrenHeigth + 1;
            selfHeights.add(selfHeight);
        }

        // If we have the desired height, print
        if (selfHeights.contains(levelToPrint)) printNode(n);
        return selfHeights; // return our heights
    }

    public static void printNode(Node n) {
        // Do whatever you want
        System.out.println(n.data);
    }

}

import java.util.Collections；
导入java.util.HashSet；
导入java.util.Set；
公共类NNodeBeforeLeaf{
静态节点根；
静态类节点{
int数据；
左、右淋巴结；
节点（int数据）{
这个数据=数据；
左=右=空；
}
}
公共静态布尔isLeaf（节点n）{
返回n.right==null&&n.left==null；
}
公共静态void main（字符串[]args）{
int level=2；//级别N
根=新节点（1）；
root.left=新节点（2）；
root.right=新节点（3）；
反渗透
int level = 0;
while(node.right != null) {
    level++;
    node = node.right;
}
System.out.println("current level node: " + level);

import java.util.Collections;
import java.util.HashSet;
import java.util.Set;

public class NNodeBeforeLeaf {

    static Node root;

    static class Node {

        int data;
        Node left, right;

        Node(int data) {
            this.data = data;
            left = right = null;
        }
    }

    public static boolean isLeaf(Node n) {
        return n.right == null && n.left == null;
    }

    public static void main(String[] args) {
        int level = 2;      // level N
        root = new Node(1);
        root.left = new Node(2);
        root.right = new Node(3);
        root.left.left = new Node(4);
        root.left.right = new Node(5);
        root.right.left = new Node(8);

        print(root, level);
    }

    public static void print(Node n, int level) {
        traversAndPrint(n, level);
    }

    private static Set<Integer> traversAndPrint(Node n, int levelToPrint) {
        if (isLeaf(n)) return Collections.singleton(0); // We are a leaf, so we have height 0

        final Set<Integer> childrenHeights = new HashSet<>();

        // are no leaf, so we have to get the heights of our children
        if (n.right != null) childrenHeights.addAll(traversAndPrint(n.right, levelToPrint));
        if (n.left != null) childrenHeights.addAll(traversAndPrint(n.left, levelToPrint));

        assert !childrenHeights.isEmpty();

        // And increase these heights
        final Set<Integer> selfHeights = new HashSet<>();
        for (Integer childrenHeigth : childrenHeights) {
            final int selfHeight = childrenHeigth + 1;
            selfHeights.add(selfHeight);
        }

        // If we have the desired height, print
        if (selfHeights.contains(levelToPrint)) printNode(n);
        return selfHeights; // return our heights
    }

    public static void printNode(Node n) {
        // Do whatever you want
        System.out.println(n.data);
    }

}

public class NNodeBeforeLeaf {

static Node root;

static class Node {
    int data;
    Node left, right;

    Node(int data) {
        this.data = data;
        left = right = null;
    }
}

public static boolean isLeaf(Node n) {
    if ((n.right == null) && (n.left == null)) {
        return true;
    }
    return false;
}

public static void main(String[] args) {
    int level = 2; // level N
    root = new Node(1);
    root.left = new Node(2);
    root.right = new Node(3);
    root.left.left = new Node(4);
    root.left.right = new Node(5);
    root.right.left = new Node(8);

    printNodes(getNodesNLevelAboveLeafs(root, level));
}

public static void printNodes(List<Node> nodes) {
    for (Node n : nodes) {
        System.out.println(n.data);
    }
}

public static List<Node> getNodesNLevelAboveLeafs(Node root, int level) {
    List<Node> allNodes = listAllNodes(root);
    for (int i = 0; i < level; i++) {
        allNodes.removeAll(getLeafNodes(allNodes));
    }
    return getLeafNodes(allNodes);
}

private static List<Node> getLeafNodes(List<Node> allNodes) {
    List<Node> leafs = new ArrayList<>();
    for (Node n : allNodes) {
        if (((n.left == null) || !allNodes.contains(n.left))
                && ((n.right == null) || !allNodes.contains(n.right))) {
            leafs.add(n);
        }
    }
    return leafs;
}

private static List<Node> listAllNodes(Node node) {
    List<Node> nodes = new ArrayList<>();
    nodes.add(node);
    if (node.left != null) {
        nodes.addAll(listAllNodes(node.left));
    }
    if (node.right != null) {
        nodes.addAll(listAllNodes(node.right));
    }
    return nodes;
}

}