二叉搜索树的中序遍历排序

二叉搜索树的中序遍历也可以实现排序

package org.exam.ch8;

/**
 * Created by xin on 15.10.14.
 */
class Node{
    public int iData;
    public double dData;
    public Node leftChild;
    public Node rightChild;
    @Override
    public String toString() {
        return "Node{" +
                "iData=" + iData +
                ", dData=" + dData +
                '}';
    }
}
class Tree{
    private Node root;
    public Node find(int key){
        Node current=root;
        while (current.iData!=key){
            if (key<current.iData){
                current=current.leftChild;
            }else{
                current=current.rightChild;
            }
        }
        if (current==null){
            return null;
        }
        return current;
    }
    public void insert(int iData,double dData){
        Node newNode=new Node();
        newNode.iData=iData;
        newNode.dData=dData;
        if (root==null){
            root=newNode;
        }else{
            Node current=root;
            Node parent=null;
            while (true){
                parent=current;
                if (iData<current.iData){
                    current=current.leftChild;
                    if (current==null){
                        parent.leftChild=newNode;
                        return;
                    }
                }else{
                    current=current.rightChild;
                    if (current==null){
                        parent.rightChild=newNode;
                        return;
                    }
                }
            }
        }
    }
    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();
    }
    private void preOrder(Node localRoot){
        if (localRoot!=null){
            System.out.print(localRoot.iData + " ");
            inOrder(localRoot.leftChild);
            inOrder(localRoot.rightChild);
        }
    }
    private void inOrder(Node localRoot){
        if (localRoot!=null){
            inOrder(localRoot.leftChild);
            System.out.print(localRoot.iData+" ");
            inOrder(localRoot.rightChild);
        }
    }
    private void postOrder(Node localRoot){
        if (localRoot!=null){
            inOrder(localRoot.leftChild);
            inOrder(localRoot.rightChild);
            System.out.print(localRoot.iData+" ");
        }
    }
    public Node minimum(){
        Node current=root;
        while (current!=null){
            if (current.leftChild==null){
                return current;
            }else{
                current=current.leftChild;
            }
        }
        return current;
    }
    public Node maximum(){
        Node current=root;
        while (current!=null){
            if (current.rightChild==null){
                return current;
            }else{
                current=current.rightChild;
            }
        }
        return current;
    }
    public boolean delete(int key){
        Node current=root;
        Node parent=null;
        boolean isLeftChild=false;//找到的节点不是根时(所以初如化时真假亦可),isLeftChild指的是current是不是parent的左子节点.
        while (current.iData!=key){
            parent=current;
            if (key<current.iData){
                isLeftChild=true;
                current=current.leftChild;
            }else{
                isLeftChild=false;
                current=current.rightChild;
            }
            if (current==null){//没有找到要删除的节点
                return false;
            }
        }
        //走到这里表明已找到的节点正是current所指向的节点
        if (current.leftChild==null&¤t.rightChild==null){//是叶节点,即没有左右子节点
            if (current==root){//如果找到的是根,设为null即可,
                root=null;
            }else if (isLeftChild){//如果找到的是一个节点的左子节点,那么将这个节点的左子节点设为null
                parent.leftChild=null;
            }else {//同理,如果找到的是一个节点的右子节点，那么将这个节点的右子节点设为null即可.
                parent.rightChild=null;
            }
        }else if (current.rightChild==null){//左子节点不存在,右子节点存在
            if (current==root){
                root=current.leftChild;
            }else if (isLeftChild){
                parent.leftChild=current.leftChild;
            }else{
                parent.rightChild=current.leftChild;
            }
        }else if (current.leftChild==null){//左子节点存在,右子节点不存在
            if (current==root){
                root=current.rightChild;
            }else if (isLeftChild){
                parent.leftChild=current.rightChild;
            }else{
                parent.rightChild=current.rightChild;
            }
        }else{//左右子节点都存在
            Node successor=getSuccessor(current);//找一个比删除节点大得最少的一个节点(当然我认为找一个比删除节点小得最少的一个节点也可以)作为后继节点
            if (current==root){
                root=successor;
            }else if (isLeftChild){
                parent.leftChild=successor;
            }else{
                parent.rightChild=successor;
            }
            successor.leftChild=current.leftChild;//后继节点左子节点连接原删除节点的左子节点;后继节点右子节点连接在getSuccessor已处理(删除后,当然后继节点的右子节点也可能不存在)
        }
        return true;
    }
    private Node getSuccessor(Node delNode) {
        Node successorParent=delNode;
        Node successor=null;
        Node current=delNode.rightChild;//从删除节点的右子节点开始找
        while (current!=null){
            successorParent=successor;//将successor的父节点使用successorParent缓存下来
            successor=current;//先将最后找到的节点缓存下来
            current=current.leftChild;//往左子节点找,直到左子点为null时,停止查找
        }
        //此时的current一定为null,successor就是后继节点.如果后继节点正是删除节点的右子节点，就返回处理即可;否则,先处理好这个断掉的后继节点
        if (successor!=delNode.rightChild){
            successorParent.leftChild=successor.rightChild;
            successor.rightChild=delNode.rightChild;
        }
        return successor;
    }
}
public class TreeApp {
    public static void main(String[] args) {
        Tree tree=new Tree();
        tree.insert(50,1.5);
        tree.insert(25,1.7);
        tree.insert(75,1.9);
        tree.insert(15,1.3);
        tree.insert(17,1.1);
        tree.insert(35,2.9);
        tree.insert(54,3.2);

        /*
        Node found=tree.find(25);
        if (found != null) {
            System.out.println("Found the node with key 25");
        }else{
            System.out.println("Couldn't find node with key 25");
        }
        System.out.println("maximum = " + tree.maximum());
        System.out.println("minimum = " + tree.minimum());
        */
        tree.traverse(2);

    }
}