I need help with my remove method on a BST!

Question

Guys I need some help here, I have to create a remove method for a BST and below is my code:
public boolean remove(OrderedMap map, K keyOfelementToRemove) {
          boolean result = false;
          if (root == null)
               result = false;
          else {
               MapNode curr = root;
               MapNode prev = root;
               while (curr.key.equals(keyOfelementToRemove) == false) {
                    prev = curr;
                    if (keyOfelementToRemove.compareTo(curr.key) < 0)
                         curr = curr.left;
                    else if (keyOfelementToRemove.compareTo(curr.key) > 0)
                         curr = curr.right;
                    if (curr == null)
                         break;
               if (curr == null)
                    return result;
               else if (curr == root && curr.left == null)
                    root = root.right;
               else if (curr.left == null) {
                    if (curr.right == null)
                         curr = null;
                    else if (curr == prev.left)
                         prev = curr.right;
                    else if (curr == prev.right){
                         prev = curr.right;
               else if (curr.left != null) {
                    MapNode temp = curr.left;
                    while (temp.right != null)
                         temp = temp.right;
                    K change = temp.key;
                    temp = null;
                    curr.key = change;
          size--;
          return result;
     }the algorithm that my instructor provides is:
private boolean remove( BinaryTreeNode t, Comparable elementToRemove )
Set result to false
Traverse the tree t until elementToRemove is found. Use curr and prev to find the element
leaving curr referring the node you want to remove. It may be the case that curr is null indicating
that elementToRemove was not found. Now there are four cases to consider :
Case 1: Not found
return result (false)
Case 2: The root is to be removed, but it has no left child.
root = root's right subtree (assuming root refers the the root node in your BST)
Case 3: The node is further down tree with no left child. Now must adjust one of the parent's links
if curr is on the left side of prev,
move parent's left link down to down to curr's right child
else
curr is on the right side of prev, so move parent's right down to down to curr's right child
Case 4: curr has a left child.
We can no longer ignore the left subtree. So find the maximum in the left subtree and
move that object to the node referenced by curr . Then eliminate the maximum in the
left subtree, which is now being reference from the original node to remove.
however for case 3 and 4 it doesn't work, can someone please tell me why? I don't know where I made a mistake and I tried finding it but I still dont know

Answer 1

I am sorry about the double post. I'll try not to do this again. My problem here seems to be that prev and curr aren't updating the BST outside this method, which means that it only changes locally but not permanently. I will post the code of the other headings:
public class OrderedMap<K extends Comparable<K>, V> {
     private class MapNode {
          // Links to other BSTs
          private MapNode left;
          private MapNode right;
          ArrayList<V> temp1 = new ArrayList<V>();
          // The references to the key/value pair of the mapping
          private K key;
          @SuppressWarnings("unused")
          private V value;
          public MapNode(K theKey, V theValue) {
               key = theKey;
               value = theValue;
               left = null;
               right = null;
     } // end class MapNode
     private MapNode root;
     private int size;
     public OrderedMap() { // Create an empty tree
          root = null;
          size = 0;
     public int size() {
          return size;
     }