数据结构与算法-第12章二叉树和其他树-005用迭代方法遍历二叉树

The root is the first node to be visited in preorder. After we visit this node we must traverse the left subtree and then return to traverse the right subtree. To enable the return to the right subtree, we save a pointer to the root of this right subtree on a stack provided the right subtree is not empty. When we are traversing the left subtree of the root, its root is visited a pointer to its nonempty right subtree is saved on the stack, and we proceed to traverse its left subtree. When we are done with the traversal of the left subtree, we move into its right subtree (if it is nonempty) or into the right subtree of the nearest ancestor that has a nonempty right subtree. This is done by removing the right subtree root pointer from the top of the stack. 

The stack never contains two pairs that correspond to nodes on the same level. When we reach a leaf the stack contains pointers to nonempty right subtrees of nodes on the path from the root to that leaf. So the stack space needed as well as the overall space needed by the traversal is O(h) where his the height of the binary tree that is being traversed. Notice that when a left-skewed binary tree is traversed nothing is added to the stack.

1.

package chapter12Tree;

import dataStructures.ArrayStack;
import dataStructures.BinaryTreeNode;

public class IterativePreorderTraversal
{
   /** visit method that prints the element in the node */ 
   public static void visit(BinaryTreeNode t)
      {System.out.print(t.element + " ");}

   /** preorder traversal */
   public static void preOrder(BinaryTreeNode t)
   {
      ArrayStack stack = new ArrayStack(10);
      BinaryTreeNode currentNode = t;
      while (true)
      {// traverse subtree rooted at currentNode in preorder

         // is subtree empty
         if (currentNode == null)
            // yes it is, get a subtree to traverse from the stack
            try
            {
               currentNode = (BinaryTreeNode) stack.pop();
            }
            catch (Exception e)
            {// no untraversed subtrees left
               return;
            }
   
         // first visit the root of the subtree
         visit(currentNode);
   
         // save pointer to right subtree for future traversal
         if (currentNode.rightChild != null)
            stack.push(currentNode.rightChild);
   
         // move into left subtree
         currentNode = currentNode.leftChild;
      }
   }
}

2.

/** a stack class that uses a one-dimensional array */

package dataStructures;

import java.util.EmptyStackException;
import utilities.*;

public class ArrayStack implements Stack
{
   // data members
   int top;          // current top of stack
   Object [] stack;  // element array

   // constructors
   /** create a stack with the given initial capacity
     * @throws IllegalArgumentException when initialCapacity < 1 */
   public ArrayStack(int initialCapacity)
   {
      if (initialCapacity < 1)
         throw new IllegalArgumentException
               ("initialCapacity must be >= 1");
      stack = new Object [initialCapacity];
      top = -1;
   }

   /** create a stack with initial capacity 10 */
   public ArrayStack()
      {this(10);}

   // methods
   /** @return true iff stack is empty */
   public boolean empty()
      {return top == -1;}


   /** @return top element of stack
     * @throws EmptyStackException when the stack is empty */
   public Object peek()
   {
      if (empty())
         throw new EmptyStackException();
      return stack[top];
   }

   /** add theElement to the top of the stack */
   public void push(Object theElement)
   {
      // increase array size if necessary
      if (top == stack.length - 1)
         stack = ChangeArrayLength.changeLength1D(stack, 2 * stack.length);
         
      // put theElement at the top of the stack
      stack[++top] = theElement;
   }

   /** remove top element of stack and return it
     * @throws EmptyStackException when the stack is empty */
   public Object pop()
   {
      if (empty())
         throw new EmptyStackException();
      Object topElement = stack[top];
      stack[top--] = null;   // enable garbage collection
      return topElement;
   }
   
   /** test program */
   public static void main(String [] args)
   {  
      int x;
      ArrayStack s = new ArrayStack(3);
      // add a few elements
      s.push(new Integer(1));
      s.push(new Integer(2));
      s.push(new Integer(3));
      s.push(new Integer(4));


      // delete all elements
      while (!s.empty())
      {
         System.out.println("Top element is " + s.peek());
         System.out.println("Removed the element " + s.pop());
      }
   }  
}

3.

/** class for nodes used in a binary tree */

package dataStructures;

public class BinaryTreeNode
{
   // package visible data members
   public Object element;
   public BinaryTreeNode leftChild;    // left subtree
   public BinaryTreeNode rightChild;   // right subtree
   
   // constructors
   public BinaryTreeNode() {}
        
   public BinaryTreeNode(Object theElement)
      {element = theElement;}
        
   public BinaryTreeNode(Object theElement,
                         BinaryTreeNode theleftChild,
                         BinaryTreeNode therightChild)
   {
       element = theElement;
       leftChild = theleftChild;
       rightChild = therightChild;
   }

   // accessor methods
   public BinaryTreeNode getLeftChild() {return leftChild;}
   public BinaryTreeNode getRightChild() {return rightChild;}
   public Object getElement() {return element;}

   // mutator methods
   public void setLeftChild(BinaryTreeNode theLeftChild)
      {leftChild = theLeftChild;}
   public void setRightChild(BinaryTreeNode theRightChild)
      {rightChild = theRightChild;}
   public void setElement(Object theElement)
      {element = theElement;}

   // output method
   public String toString()
      {return element.toString();}
}

4.

/** Change the length of an array by creating
  * a new array of the desired length and copying
  * elements from the old array to the new one. */
package utilities;

import wrappers.*;
import java.lang.reflect.*;

public class ChangeArrayLength 
{
   /** Change the length of the 1D array a.
     * @param n number of elements in a
     * @param newLength new length of array
     * @return array of length newLength with a[0:n-1] copied into it */
   public static Object [] changeLength1D(Object [] a,
                                 int n, int newLength)
   {
      // make sure new length is adequate
      if (n > newLength)
         throw new IllegalArgumentException
                   ("new length is too small");
   
      // allocate a new array of desired length and same type
      Object [] newArray = (Object []) Array.newInstance
                (a.getClass().getComponentType(), newLength);
   
      // copy from old space to new space
      System.arraycopy(a, 0, newArray, 0, n);
   
      return newArray;
   }

   /* Change the length of a 1D array with a.length elements */
   public static Object [] changeLength1D(Object [] a, int newLength)
      {return changeLength1D(a, a.length, newLength);}

   /** test program */
   public static void main(String [] args)
   {
      // create an array of length 4
      MyInteger [] x = {new MyInteger(10),
                        new MyInteger(11),
                        new MyInteger(12),
                        new MyInteger(13)};

      // output
      System.out.println("Array length is " + x.length);
      System.out.print("The elements are ");
      for (int i = 0; i < 4; i++)
         System.out.print(x[i] + " ");
      System.out.println();
   
      // increase array length to 8
      x = (MyInteger []) changeLength1D(x, 8);
   
      // add two elements to x
      for (int i = 4; i < 6; i++)
         x[i] = new MyInteger(10 + i);
   
      // output
      System.out.println("Array length is " + x.length);
      System.out.print("The elements are ");
      for (int i = 0; i < 6; i++)
         System.out.print(x[i] + " ");
      System.out.println();

      // increase length to 10
      x = (MyInteger []) changeLength1D(x, 6, 10);
   
      // add four elements to x
      for (int i = 6; i < 10; i++)
         x[i] = new MyInteger(10 + i);
   
      // output
      System.out.println("Array length is " + x.length);
      System.out.print("The elements are ");
      for (int i = 0; i < 10; i++)
         System.out.print(x[i] + " ");
      System.out.println();

      // reduce length to 5 retaining only first 3 elements
      x = (MyInteger []) changeLength1D(x, 3, 5);
   
      // output
      System.out.println("Array length is " + x.length);
      System.out.print("The elements are ");
      for (int i = 0; i < 4; i++)
         System.out.print(x[i] + " ");
      System.out.println();
   }
}