深圳同城快跑笔试题目 3 实现四则运算

package com.cici.深圳同城快跑;

import java.util.Stack;

class Node
{
public char cData;              // data item (key)
public Node leftChild;         // this node‘s left child
public Node rightChild;        // this node‘s right child

public void displayNode()      // display ourself
   {
   System.out.print(‘{‘);
   System.out.print(cData);
   System.out.print("} ");
   }
}  // end class Node
class Tree
{
public Node root;             // first node of tree
public int size;
//-------------------------------------------------------------
public Tree()                  // constructor
   { root = null; }            // no nodes in tree yet
//-------------------------------------------------------------
public Node find(char key)      // find node with given key
   {                           // (assumes non-empty tree)
   Node current = root;               // start at root
   while(current.cData != key)        // while no match,
      {
      if(key < current.cData)         // go left?
         current = current.leftChild;
      else                            // or go right?
         current = current.rightChild;
      if(current == null)             // if no child,
         return null;                 // didn‘t find it
      }
   return current;                    // found it
   }  // end find()
//-------------------------------------------------------------
public void insert(char c)
{
Node newNode = new Node();    // make new node
newNode.cData = c;           // insert data
if(root==null)                // no node in root
   root = newNode;
else                          // root occupied
   {
    //make a new node which is stands for the new node
   Node current = root;       // start at root
   Node parent;
   while(true)                // (exits internally)
      {
       //parent node is the root node
      parent = current;
      //go left ?  
      if(check(c)){
          current = current.leftChild;
          if(current == null)  // if end of the line,
             {                 // insert on left
             parent.leftChild = newNode;
             return;
             }
      } // end if go left
      else                    // or go right?
         {
         current = current.leftChild;
         if(current == null)  // if end of the line
            {                 // insert on right
            parent.rightChild = newNode;
            return;
            }
         }  // end else go right
      }  // end while
   }  // end else not root
}  // end insert()
//-------------------------------------------------------------
public boolean delete(char key) // delete node with given key
   {                           // (assumes non-empty list)
   Node current = root;
   Node parent = root;
   boolean isLeftChild = true;

   while(current.cData != key)        // search for node
      {
      parent = current;
      if(key < current.cData)         // go left?
         {
         isLeftChild = true;
         current = current.leftChild;
         }
      else                            // or go right?
         {
         isLeftChild = false;
         current = current.rightChild;
         }
      if(current == null)             // end of the line,
         return false;                // didn‘t find it
      }  // end while
   // found node to delete

   // if no children, simply delete it
   if(current.leftChild==null &&
                                current.rightChild==null)
      {
      if(current == root)             // if root,
         root = null;                 // tree is empty
      else if(isLeftChild)
         parent.leftChild = null;     // disconnect
      else                            // from parent
         parent.rightChild = null;
      }

   // if no right child, replace with left subtree
   else if(current.rightChild==null)
      if(current == root)
         root = current.leftChild;
      else if(isLeftChild)
         parent.leftChild = current.leftChild;
      else
         parent.rightChild = current.leftChild;

   // if no left child, replace with right subtree
   else if(current.leftChild==null)
      if(current == root)
         root = current.rightChild;
      else if(isLeftChild)
         parent.leftChild = current.rightChild;
      else
         parent.rightChild = current.rightChild;

   else  // two children, so replace with inorder successor
      {
      // get successor of node to delete (current)
      Node successor = getSuccessor(current);

      // connect parent of current to successor instead
      if(current == root)
         root = successor;
      else if(isLeftChild)
         parent.leftChild = successor;
      else
         parent.rightChild = successor;

      // connect successor to current‘s left child
      successor.leftChild = current.leftChild;
      }  // end else two children
   // (successor cannot have a left child)
   return true;                                // success
   }  // end delete()
//-------------------------------------------------------------
// returns node with next-highest value after delNode
// goes to right child, then right child‘s left descendents
private Node getSuccessor(Node delNode)
   {
   Node successorParent = delNode;
   Node successor = delNode;
   Node current = delNode.rightChild;   // go to right child
   while(current != null)               // until no more
      {                                 // left children,
      successorParent = successor;
      successor = current;
      current = current.leftChild;      // go to left child
      }
                                        // if successor not
   if(successor != delNode.rightChild)  // right child,
      {                                 // make connections
      successorParent.leftChild = successor.rightChild;
      successor.rightChild = delNode.rightChild;
      }
   return successor;
   }
//-------------------------------------------------------------
public void traverse(int traverseType)
   {
   switch(traverseType)
      {
      case 1: System.out.print("\nPreorder traversal: ");
              preOrder(root);
              break;
      case 2: System.out.print("\nInorder traversal:  ");
              inOrder(root);
              break;
      case 3: System.out.print("\nPostorder traversal: ");
              postOrder(root);
              break;
      }
   System.out.println();
   }
//-------------------------------------------------------------
public void preOrder(Node localRoot)
   {
   if(localRoot != null)
      {
      preOrder(localRoot.leftChild);
      System.out.print(localRoot.cData + " ");
      preOrder(localRoot.rightChild);
      }
   }
//-------------------------------------------------------------
public Node inOrder(Node localRoot)
   {
   if(localRoot != null)
      {
      inOrder(localRoot.leftChild);
      System.out.print(localRoot.cData + " ");
      inOrder(localRoot.rightChild);
      }
   return localRoot;
   }
//-------------------------------------------------------------
public void postOrder(Node localRoot)
   {
   if(localRoot != null)
      {
      postOrder(localRoot.leftChild);
      postOrder(localRoot.rightChild);
      System.out.print(localRoot.cData + " ");
      }
   }
//check the whether a node is a signal
public static boolean check(Character ch){
    if(ch.equals(new Character(‘+‘)) || ch.equals(new Character(‘-‘))
            || ch.equals(new Character(‘*‘))
            || ch.equals(new Character(‘\\‘) )
                    || ch.equals(new Character(‘^‘))        )
                      {
                return true;
    }
    return false;
}
public long calculate( ){
    long result = 0;
    result+=this.root.cData-48;
    Node localRoot= root.leftChild;
    while(localRoot!=null){
            if(localRoot.cData==‘+‘){
                if(localRoot.rightChild!=null){
                    result+=localRoot.rightChild.cData-48;
                }
            }
            if(localRoot.cData==‘-‘){
                if(localRoot.rightChild!=null){
                    result-=localRoot.rightChild.cData-48;
                }
            }
            if(localRoot.cData==‘/‘){
                if(localRoot.rightChild!=null){
                    result/=localRoot.rightChild.cData-48;
                }
            }
            if(localRoot.cData==‘*‘){
                if(localRoot.rightChild!=null){
                    result*=localRoot.rightChild.cData-48;
                }
            }
            
             /*int m = 4;
             int n = 2;
             int result = 1;
             for(int i=0;i<n;i++){
                 result*=m;
             }
             System.out.println(result);*/
            
            if(localRoot.cData==‘^‘){
                long temp = 1;
                for(int i=0;i<localRoot.rightChild.cData-48;i++){
                    temp*=result;
                }
                result= temp;
            }
            localRoot= localRoot.leftChild;
    }
    return result;
}
    //-------------------------------------------------------------
public void displayTree()
   {
   Stack globalStack = new Stack();
   globalStack.push(root);
   int nBlanks = 32;
   boolean isRowEmpty = false;
   System.out.println(
   "......................................................");
   while(isRowEmpty==false)
      {
      Stack localStack = new Stack();
      isRowEmpty = true;
      for(int j=0; j<nBlanks; j++)
         System.out.print(‘ ‘);
      while(globalStack.isEmpty()==false)
         {
         Node temp = (Node)globalStack.pop();
         if(temp != null)
            {
            System.out.print(temp.cData);
            localStack.push(temp.leftChild);
            localStack.push(temp.rightChild);
            if(temp.leftChild != null ||
                                temp.rightChild != null)
               isRowEmpty = false;
            }
         else
            {
            System.out.print("--");
            localStack.push(null);
            localStack.push(null);
            }
         for(int j=0; j<nBlanks*2-2; j++)
            System.out.print(‘ ‘);
         }  // end while globalStack not empty
      System.out.println();
      nBlanks /= 2;
      while(localStack.isEmpty()==false)
         globalStack.push( localStack.pop() );
      }  // end while isRowEmpty is false
   System.out.println(
   "......................................................");
   }  // end displayTree()
//-------------------------------------------------------------
}  // end class Tree
public class TreeApp{
    public static void main(String[] args) {
        Tree tree = new Tree();
        tree.insert(‘2‘);
        tree.insert(‘^‘);
        tree.insert(‘3‘);
        tree.insert(‘+‘);
        tree.insert(‘1‘);
        tree.insert(‘*‘);
        tree.insert(‘2‘);
         tree.displayTree();
    long result = tree.calculate();
     System.out.println("----"+result+"----");
    }
}