すべてのルートからリーフへのパスをバイナリツリーに出力します
javaを使用して、すべてのルートからリーフへのパスをバイナリツリーに出力しようとしています。
public void printAllRootToLeafPaths(Node node,ArrayList path)
{
if(node==null)
{
return;
}
path.add(node.data);
if(node.left==null && node.right==null)
{
System.out.println(path);
return;
}
else
{
printAllRootToLeafPaths(node.left,path);
printAllRootToLeafPaths(node.right,path);
}
}
主な方法：
bst.printAllRootToLeafPaths(root, new ArrayList());
しかし、それは間違った出力を与えます。
与えられた木：
5
/ \
/ \
1 8
\ /\
\ / \
3 6 9
期待される出力：
[5、1、3]
[5、8、6]
[5、8、9]
しかし、生成された出力：
[5、1、3]
[5、1、3、8、6]
[5、1、3、8、6、9]
誰かがそれを理解できますか...
次のコマンドで再帰メソッドを呼び出します。
_printAllRootToLeafPaths(node.left, new ArrayList(path));
printAllRootToLeafPaths(node.right, new ArrayList(path));
_pathを渡すと（new ArrayList(path)の代わりに）そこで何が起こるかというと、すべてのメソッド呼び出しで単一のオブジェクトを使用するということです。つまり、元の呼び出し元に戻ると、オブジェクトは以前と同じ状態ではありません。
新しいオブジェクトを作成し、それを元の値に初期化する必要があります。このようにして、元のオブジェクトは変更されません。
リストを再帰的に渡しますが、これは可変オブジェクトであるため、すべての呼び出しでリストが変更され（List.addを呼び出すことにより）、結果が混乱します。 path引数をすべての再帰呼び出しに複製/コピーして、各ブランチ（harhar）に独自のコンテキストを提供してみてください。
_public void PrintAllPossiblePath(Node node,List<Node> nodelist)
{
if(node != null)
{
nodelist.add(node);
if(node.left != null)
{
PrintAllPossiblePath(node.left,nodelist);
}
if(node.right != null)
{
PrintAllPossiblePath(node.right,nodelist);
}
else if(node.left == null && node.right == null)
{
for(int i=0;i<nodelist.size();i++)
{
System.out.print(nodelist.get(i)._Value);
}
System.out.println();
}
nodelist.remove(node);
}
}
_nodelist.remove(node)がキーであり、それぞれのパスを出力すると要素を削除します
この方法もできます。これが私のJavaコードです。
public void printPaths(Node r,ArrayList arr)
{
if(r==null)
{
return;
}
arr.add(r.data);
if(r.left==null && r.right==null)
{
printlnArray(arr);
}
else
{
printPaths(r.left,arr);
printPaths(r.right,arr);
}
arr.remove(arr.size()-1);
}
これが正しい実装です
public static <T extends Comparable<? super T>> List<List<T>> printAllPaths(BinaryTreeNode<T> node) {
List <List<T>> paths = new ArrayList<List<T>>();
doPrintAllPaths(node, paths, new ArrayList<T>());
return paths;
}
private static <T extends Comparable<? super T>> void doPrintAllPaths(BinaryTreeNode<T> node, List<List<T>> allPaths, List<T> path) {
if (node == null) {
return ;
}
path.add(node.getData());
if (node.isLeafNode()) {
allPaths.add(new ArrayList<T>(path));
} else {
doPrintAllPaths(node.getLeft(), allPaths, path);
doPrintAllPaths(node.getRight(), allPaths, path);
}
path.remove(node.getData());
}
これがテストケースです
@Test
public void printAllPaths() {
BinaryTreeNode<Integer> bt = BinaryTreeUtil.<Integer>fromInAndPostOrder(new Integer[]{4,2,5,6,1,7,3}, new Integer[]{4,6,5,2,7,3,1});
List <List<Integer>> paths = BinaryTreeUtil.printAllPaths(bt);
assertThat(paths.get(0).toArray(new Integer[0]), equalTo(new Integer[]{1, 2, 4}));
assertThat(paths.get(1).toArray(new Integer[0]), equalTo(new Integer[]{1, 2, 5, 6}));
assertThat(paths.get(2).toArray(new Integer[0]), equalTo(new Integer[]{1, 3, 7}));
for (List<Integer> list : paths) {
for (Integer integer : list) {
System.out.print(String.format(" %d", integer));
}
System.out.println();
}
}
これが出力です
1 2 4 1 2 5 6 1 3 7
/* Given a binary tree, print out all of its root-to-leaf
paths, one per line. Uses a recursive helper to do the work.*/
void printPaths(Node node)
{
int path[] = new int[1000];
printPathsRecur(node, path, 0);
}
/* Recursive helper function -- given a node, and an array containing
the path from the root node up to but not including this node,
print out all the root-leaf paths. */
void printPathsRecur(Node node, int path[], int pathLen)
{
if (node == null)
return;
/* append this node to the path array */
path[pathLen] = node.data;
pathLen++;
/* it's a leaf, so print the path that led to here */
if (node.left == null && node.right == null)
printArray(path, pathLen);
else
{
/* otherwise try both subtrees */
printPathsRecur(node.left, path, pathLen);
printPathsRecur(node.right, path, pathLen);
}
}
/* Utility that prints out an array on a line */
void printArray(int ints[], int len)
{
int i;
for (i = 0; i < len; i++)
System.out.print(ints[i] + " ");
System.out.println("");
}
再帰を使用してそれを実現できます。適切なデータ構造により、簡潔で効率的になります。
List<LinkedList<Tree>> printPath(Tree root){
if(root==null)return null;
List<LinkedList<Tree>> leftPath= printPath(root.left);
List<LinkedList<Tree>> rightPath= printPath(root.right);
for(LinkedList<Tree> t: leftPath){
t.addFirst(root);
}
for(LinkedList<Tree> t: rightPath){
t.addFirst(root);
}
leftPath.addAll(rightPath);
return leftPath;
}
これが私の解決策です：左または右のパスをトラバースしたら、最後の要素を削除します。
コード：
public static void printPath(TreeNode root, ArrayList list) {
if(root==null)
return;
list.add(root.data);
if(root.left==null && root.right==null) {
System.out.println(list);
return;
}
else {
printPath(root.left,list);
list.remove(list.size()-1);
printPath(root.right,list);
list.remove(list.size()-1);
}
}
次のことができます、
public static void printTreePaths(Node<Integer> node) {
int treeHeight = treeHeight(node);
int[] path = new int[treeHeight];
printTreePathsRec(node, path, 0);
}
private static void printTreePathsRec(Node<Integer> node, int[] path, int pathSize) {
if (node == null) {
return;
}
path[pathSize++] = node.data;
if (node.left == null & node.right == null) {
for (int j = 0; j < pathSize; j++ ) {
System.out.print(path[j] + " ");
}
System.out.println();
}
printTreePathsRec(node.left, path, pathSize);
printTreePathsRec(node.right, path, pathSize);
}
public static int treeHeight(Node<Integer> root) {
if (root == null) {
return 0;
}
if (root.left != null) {
treeHeight(root.left);
}
if (root.right != null) {
treeHeight(root.right);
}
return Math.max(treeHeight(root.left), treeHeight(root.right)) + 1;
}
ArrayListでこの問題を試しましたが、プログラムは同様のパスを出力しました。
そこで、内部のcountを維持することにより、ロジックが正しく機能するように変更しました。これがその方法です。
private void printPaths(BinaryNode node, List<Integer> paths, int endIndex) {
if (node == null)
return;
paths.add(endIndex, node.data);
endIndex++;
if (node.left == null && node.right == null) {
//found the leaf node, print this path
printPathList(paths, endIndex);
} else {
printPaths(node.left, paths, endIndex);
printPaths(node.right, paths, endIndex);
}
}
public void printPaths() {
List<Integer> paths = new ArrayList<>();
printPaths(root, paths, 0);
}