Question

我正在做关于二叉树的作业，但我不能打印它的长枝。这是我的主要内容。

    Arbol arbol = new Arbol();
    arbol.Inserta(45);
    arbol.Inserta(20);
    arbol.Inserta(30);
    arbol.Inserta(25);
    arbol.Inserta(61);
    arbol.Inserta(90);
    arbol.Inserta(33);
    arbol.Inserta(82);
    arbol.Inserta(18);
    arbol.Inserta(50);
    arbol.Inserta(35);
    arbol.Inserta(32);
    arbol.imprimeRamaLarga();

然后是方法。

 public void imprimeRamaLarga() {
    if (Raiz != null) {
        cont = 0;
        cont2 = 0;
        imprimeRamaLargaRec(Raiz);
    } else {
        System.out.println("El arbol esta vacio.");
    }
}
private void imprimeRamaLargaRec(Nodo n) {
    if (n != null) {
        if (cont >= cont2) {
            cont++;                               
            imprimeRamaLargaRec(n.getHijoIzq());       
            imprimeRamaLargaRec(n.getHijoDer());                
            cont--;                 
            cont2++;   
            if (cont <= cont2) {
            System.out.println(n.getId());                   
            }             
        } 
    }
}

它可以打印分支的所有其他元素，但是我无法打印最后一个元素＆＃34; 32＆＃34;其余的它打印正确。

这是我的插入方法。

private Nodo Raiz;
public void Inserta(int num) {
    if (Raiz == null) {
        Raiz = new Nodo(num);
    } else {
        InsertaRec(Raiz, num);
    }
}

private void InsertaRec(Nodo n, int num) {
    if (num <= n.getId()) {
        if (n.getHijoIzq() == null) {
            n.setHijoIzq(new Nodo(num));
        } else {
            InsertaRec(n.getHijoIzq(), num);
        }
    } else {
        if (n.getHijoDer() == null) {
            n.setHijoDer(new Nodo(num));
        } else {
            InsertaRec(n.getHijoDer(), num);
        }
    }
}

如果你想知道这是Nodo课，那就是它。

public class Nodo {


private int id;


private Nodo HijoIzq;



private Nodo HijoDer;

public Nodo(int id) {
    this.id = id;
}

public int getId() {
    return id;
}

public void setId(int id) {
    this.id = id;
}

public Nodo getHijoIzq() {
    return HijoIzq;
}

public void setHijoIzq(Nodo HijoIzq) {
    this.HijoIzq = HijoIzq;
}

public Nodo getHijoDer() {
    return HijoDer;
}

public void setHijoDer(Nodo HijoDer) {
    this.HijoDer = HijoDer;
}

Answer 1

您需要在树中进行两次遍历。

首先找到最长的分支 - 将li { white-space: nowrap; font-size: 16px; border: solid 1px #def; padding: 0.5em; background: #dfefff; margin-bottom: 0.5em; display: -webkit-box; /* OLD - iOS 6-, Safari 3.1-6 */ display: -moz-box; /* OLD - Firefox 19- (buggy but mostly works) */ display: -ms-flexbox; /* TWEENER - IE 10 */ display: -webkit-flex; /* NEW - Chrome */ display: flex; } .email { color: #581; margin-left:5px; } .name, .email { max-width: 100%; }设置为max，每当count（0）更高，重置depth到max

在第二次运行时，使用变量depth（cont）和false，并在depth达到当前cont时将true设置为depth之前收集的max。然后在遍历递归时开始打印。

Answer 2

所以我从头开始写了一个快速的Tree类。我已经做了一段时间，但它似乎有效，所以这就是我所拥有的。希望它对你有所帮助！抱歉没有翻译。

Main.java

这里没什么不寻常的。

public class Main {
    public static void main(String[] args) {
        BinaryTree tree = new BinaryTree();

        for (int i : Arrays.asList(45, 20, 30, 25, 61, 90, 33, 82, 18, 50, 35, 32)) {
            tree.insert(i);
        }

        System.out.println("Longest Branch: ");
        tree.printLongBranch();

        System.out.println("\nPre Order: ");
        tree.printPreOrder();

        System.out.println("\nIn Order: ");
        tree.printInOrder();
    }
}

输出

最长的分支：
  45 20 30 33 32 35
  预购：
  45 20 18 30 25 33 32 35 61 50 90 82
  按顺序：
  18 20 25 30 32 33 35 45 50 61 82 90

Node.java

只是基础知识。我相信你理解递归，所以如果我的插入方法看起来很奇怪，只需手动运行它就会看到它正在做什么。底部的两个方法显示了2个不同的遍历，按顺序和预订。

public class Node {
    private int data;
    private Node left;
    private Node right;
    private int height = 1;

    public Node(int data) {
        this.data = data;
    }

    public int getData() {
        return this.data;
    }

    public int getHeight() {
        return this.height;
    }

    public Node insert(int data) {
        int leftHeight = 0;
        int rightHeight = 0;

        if (data <= this.getData()) {
            if (left == null) {
                this.left = new Node(data);
            } else {
                left = left.insert(data);
            }
            leftHeight = left.getHeight();
        } else if (data > this.getData()) {
            if (right == null) {
                this.right = new Node(data);
            } else {
                this.right = right.insert(data);
            }
            rightHeight = right.getHeight();
        }

        this.height = 1 + Math.max(leftHeight, rightHeight);
        return this;
    }

    public void printLongBranch() {
        int leftHeight = left == null ? 0 : left.getHeight();
        int rightHeight = right == null ? 0 : right.getHeight();

        System.out.print(this.data + " ");

        if (rightHeight == leftHeight) {
            if (left != null) {
                left.printLongBranch();
            }
            if (right != null) {
                right.printLongBranch();
            }
        }
        else if (leftHeight > rightHeight) {
            if (left != null) {
                left.printLongBranch();
            }
        } else {
            if (right != null) {
                right.printLongBranch();
            }
        }
    }

    public void printInOrder() {
        if (this.left != null) {
            this.left.printInOrder();
        }

        System.out.print(this.data + " ");

        if (this.right != null) {
            this.right.printInOrder();
        }
    }

    public void printPreOrder() {
        System.out.print(this.data + " ");

        if (this.left != null) {
            this.left.printPreOrder();
        }

        if (this.right != null) {
            this.right.printPreOrder();
        }
    }

}

BinaryTree.java

这里也没什么复杂的。

public class BinaryTree {
    private Node root;

    public void insert(int data) {
        if (this.root == null) {
            this.root = new Node(data);
        } else {
            this.root = this.root.insert(data);
        }
    }

    public void printInOrder() {
        this.root.printInOrder();
    }

    public void printPreOrder() {
        this.root.printPreOrder();
    }

    public int getHeight() {
        return this.root.getHeight();
    }

    public void printLongBranch() {
        this.root.printLongBranch();
    }

}

Answer 3

要打印最长的分支，您可以找到分支然后打印它或打印深度最大的一侧：

我发现易于实现的是打印深度最大的一侧：首先我们需要一个函数来找到Nodo的深度。

public int getDeep(Nodo n){
    if(n == null)
        return 0;

    int dd = getDeep(n.getHijoDer() );
    int di = getDeep(n.getHijoIzq() );

    return 1 + (dd > di ? dd : di);
}

使用getDeep(Nodo n)我来到这个解决方案：

private void imprimeRamaLargaRec(Nodo n) {
    if (n != null) {
        int dd = getDeep(n.getHijoDer() );//deep for the right child
        int di = getDeep(n.getHijoIzq() );//deep for the left child

        if(dd > di){
            imprimeRamaLargaRec(n.getHijoDer() );
        }else{
            imprimeRamaLargaRec(n.getHijoIzq() );
        }
        System.out.println(n.getId());  
    }
}

二叉树无法打印长分支

3 个答案:

Main.java

输出

Node.java

BinaryTree.java