删除二叉树-设计建议

Question

I have written a code for deleting all elements of tree. Need suggestions for following:

1. In reverseTreeStack method, Can I design without using stack method parameter?
2. Can I design the entire code in 1 method with better design?

UPDATE : Changed return type of reverseTreeStack to void.Removed additional variable for stack.

    public class DeleteTree {

    public static void deleteTree(BinaryTreeNode root)
    {       
        Stack stack = new Stack();
        reverseTreeStack(stack, root);
        while (!stack.isEmpty())
        {
            BinaryTreeNode node = (BinaryTreeNode)stack.pop();
            System.out.println("---------Deleting----------->" + node.getData());
            node = null;
        }
    }

    public static void reverseTreeStack(Stack stack,BinaryTreeNode root)
    {
        if (root != null)
        {
            stack.push(root);   
            reverseTreeStack(stack,root.getLeft());
            reverseTreeStack(stack, root.getRight());
        }
    }
}

Answer 1

Why do you need to do this? If I recall correctly, the JVM can free resources once there are no available references to the resource, so just setting your root node to be null should free the whole tree.

Answer 2

I think, James is right, but if you want to practice the tree traversal, or if you want to implement this in a language where you need to free memory manually, then use recursion:

void deleteTree(TreeNode node)
{
    if(node==null)return;

    deleteTree(node.getLeft());
    deleteTree(node.getRight());

    System.out.printline("Deleting: "+node.getData())
    node = null;
}

Also take a look at Postorder Traversal (thats the only one, that works for deleting)

Answer 3

Well your reverseTreeStack method can potentially give you a StackOverflowError if your tree is too large, so using a loop instead of recursion there might be a better choice (unless you know for a fact that your trees will never be that large).

Also, why are you "deleting" every node? ( node = null actually just removes the reference you have just in that method...) Generally just forgetting the root ( root = null ) will delete your whole tree if you're structuring it in the classic way of Node(parent, leftChild, rightChild) and not storing pointers to nodes anywhere else.

Answer 4

1) I think you can kill the return value and make it a void method as you are directly manipulating the stack. So just do

 Stack stack = new Stack();
 reverseTreeStack(stack, root);

 // Now just use stack

2) Don't condense things into one method. Breaking things out into more methods will make your code easier to navigate and understand. The less each function is responsible for, the more sense it will make to someone reading it.