BST的基本操作

本文总结一下关于BST的基本操作的Java代码实现：
首先节点的定义：

class BiNode{
        int val;
        BiNode left;
        BiNode right;

        public BiNode(int val) {
            this.val=val;
            this.left=null;
            this.right=null;
        }
    }

插入操作：创建BST时，可循环调用insert构造

public BiNode insert (int val) {  
        // 新增节点  
        BiNode newNode = new BiNode(val);  
        // 当前节点  
        BiNode current = root;  
        // 上个节点  
        BiNode parent  = null;  
        // 如果根节点为空  
        if (current == null) {  
            root = newNode;  
            return newNode;  
        }  
        while (true) {  
            parent = current;  
            if (val< current.val) {  //插入到左子树
                current = current.left;  
                if (current == null) {  
                    parent.left = newNode;  
                    return newNode;  
                }  
            } else {  //插入到右子树
                current = current.right;  
                if (current == null) {  
                    parent.right = newNode;  
                    return newNode;  
                }  
            }  
        }  
    }  

查找操作：类似于线性结构的二分查找

public BiNode search (int val) {  
        BiNode current = root;  
        while (current != null  
                && val!= current.val) {  
            if (val< current.val )  
                current = current.left;  
            else  
                current = current.right;  
        }  
        return current;  //如果查找失败,返回空值
    }  

删除操作：

public BiNode delete (int val) {  
        BiNode parent  = root;  
        BiNode current = root;  
        boolean isLeftChild = false;  //是否在左子树的标志
        // 找到删除节点 
        while (current.val != val) {  
            parent = current;  
            if (current.val > val) {  
                isLeftChild = true;  
                current = current.left;  
            } else {  
                isLeftChild = false;  
                current = current.right;  
            }  
            if (current == null) {  
                return current;  
            }  
        }  
        // 如果删除节点左节点为空 , 右节点也为空  
        if (current.left == null && 
                current.right == null) {  
            if (current == root) {  
                root = null;  
            }  
            // 在左子树  
            if (isLeftChild) {  
                parent.left = null;  
            } else {  
                parent.right = null;  
            }  
        }  
        // 如果删除节点只有一个子节点右节点或者左节点  
        else if (current.right == null) {  
            if (current == root) {  
                root = current.left;  
            } else if (isLeftChild) {  
                parent.left = current.left;
                current=null;
            } else {  
                parent.right = current.left;  
                current=null;
            }  

        }  
        else if (current.left == null) {  
            if (current == root) {  
                root = current.right;  
            } else if (isLeftChild) {  
                parent.left = current.right;  
                current=null;
            } else {  
                parent.right = current.right;
                current=null;
            }  
        }  
        // 如果删除节点左右子节点都不为空  
        else if (current.left != null && 
            current.right != null) {  
            // 找到删除节点的后继者  
            BiNode successor = getDeleteSuccessor(current);  
            if (current == root) {  
                root = successor;  
            } else if (isLeftChild) {  
                parent.left = successor;  
            } else {  
                parent.right = successor;  
            }  
            successor.left = current.left;  
        }  
        return current;  
   }
   public BiNode getDeleteSuccessor(BiNode deleteNode) {  
        // 后继者  
        BiNode successor = null;  
        BiNode successorParent = null;  
        BiNode current = deleteNode.right;  

        while (current != null) {  
            successorParent = successor;  
            successor = current;  
            current = current.left;  
        }  

        // 检查后继者(不可能有左节点树)是否有右节点树  
        // 如果它有右节点树,则替换后继者位置,加到后继者父亲节点的左节点
        if (successor != deleteNode.right) {  
            successorParent.left = successor.right;  
            successor.right = deleteNode.right;  
        }  

        return successor;  
  }  

前序、中序、后序遍历的非递归：

public static void preOrderTraverse(BiNode root) {
        if(root == null) {
            return;
        }
        Stack<BiNode> s=new Stack<BiNode>();
        s.push(root);
        while(!s.isEmpty()) {
            BiNode cur=s.pop();
            System.out.print(cur.val+" ");
            if(cur.right!=null) {
                s.push(cur.right);
            }
            if(cur.left!=null) {
                s.push(cur.left);
            }
        }
    }

    public static void inOrderTraverse(BiNode root) {
        if(root == null) {
            return;
        }
        Stack<BiNode> s=new Stack<BiNode>();
        BiNode cur=root;
        while(!s.isEmpty() || cur!=null) {
            if(cur!=null) {
                s.push(cur);
                cur=cur.left;
            }else {
                cur=s.pop();
                System.out.print(cur.val+" ");
                cur=cur.right;
            }
        }
    }

    public static void postOrderTraverse(BiNode root) {
        if(root == null) {
            return;
        }
        Stack<BiNode> s1=new Stack<BiNode>();
        Stack<BiNode> s2=new Stack<BiNode>();
        s1.push(root);
        BiNode cur=root;
        while(!s1.isEmpty()) {
            cur=s1.pop();
            s2.push(cur);
            if(cur.left!=null) {
                s1.push(cur.left);
            }
            if(cur.right!=null) {
                s1.push(cur.right);
            }
        }

        while(!s2.isEmpty()) {
            cur=s2.pop();
            System.out.print(cur.val+" ");
        }
    }