二叉搜索树+双向链表

题目来源http://blog.csdn.net/v_JULY_v/article/details/6126406

二叉搜索树参考：http://blog.csdn.net/lcore/article/details/8889176

双向链表参考：http://www.cnblogs.com/skywang12345/p/3308807.html

package data.structure.exercise;

import java.util.LinkedList;

public class BinaryTree {
    
    private TreeNode root;
    
    public BinaryTree(int root){
        this.setRoot(new TreeNode(root));
    }
    
    public TreeNode insert(int value){
        if(this.getRoot() == null){
            return null;
        }
        return insert(this.getRoot(), value);
    }
    
    private TreeNode insert(TreeNode node, int value){
        if(node == null){
            node = new TreeNode(value, null, null);
            return node;
        }
        
        if(value < node.value){
            TreeNode lnode = insert(node.getLnode(), value);
            node.setLnode(lnode);
        }else{
            TreeNode rnode = insert(node.getRnode(), value);
            node.setRnode(rnode);
        }
        
        return node;
    }

    public boolean find(TreeNode node, int value){
        if(node == null){
            return false;
        }
        
        if(value == node.value){
            return true;
        }else if(value < node.value){
            return find(node.getLnode(), value);
        }else{
            return find(node.getRnode(), value);
        }
        
    }
    
    public TreeNode findMax(TreeNode node) {  
        if(node!=null)  {  
            while(node.getRnode()!=null)  
                node=node.getRnode();  
        }  
        return node;         
    } 
    
    public TreeNode remove(int value){
        return remove(this.getRoot(), value);
    }
    private TreeNode remove(TreeNode node, int value){
        if(node == null){
            return null;
        }
        
        if(value == node.value){
            
            if(node.getLnode() !=null && node.getRnode() !=null){
                //左子树最大节点的parent
                TreeNode parentOfMax = node.getLnode().getRnode();
                while(parentOfMax.getRnode().getRnode() !=null){
                    parentOfMax = parentOfMax.getRnode();
                }
                //左子树最大的节点
                TreeNode maxNode = parentOfMax.getRnode();
                node.setValue(maxNode.getValue());
                node.setRnode(remove(node.getRnode(), maxNode.getValue()));
            }
            else{
                if(node.getLnode() !=null){

                    node = node.getLnode();
                }else{
                    //node.getRnode() != null
                    node = node.getRnode();
                }
            }
            
        }else if(value < node.value){
            node.setLnode(remove(node.getLnode(), value));
        }else{
            node.setRnode(remove(node.getRnode(), value));
        }
        return node;
    }

    public LinkedList<TreeNode> tree2LinkedList(){
        return tree2LinkedList(this.getRoot());
    }
    
    private LinkedList<TreeNode> tree2LinkedList(TreeNode root){
        
        LinkedList<TreeNode> queue = new LinkedList<TreeNode>();
        
        dfs(root, queue);
        
        return queue;
        
    }
    
    private void dfs(TreeNode root, LinkedList<TreeNode> queue){
        
        if(root!=null){
            dfs(root.getLnode(), queue);
            queue.addLast(root);
            dfs(root.getRnode(), queue);
        }
    }
    
    
    public TreeNode getRoot() {
        return root;
    }

    public void setRoot(TreeNode root) {
        this.root = root;
    }


    public class TreeNode{
        
        private int value;
        
        private TreeNode lnode;
        
        private TreeNode rnode;
        
        public TreeNode(int value){
            this.value = value;
        }
        
        public TreeNode(int value, TreeNode lnode, TreeNode rnode){
            
            this.setValue(value);
            this.setLnode(lnode);
            this.setRnode(rnode);
        }

        public int getValue() {
            return value;
        }

        public void setValue(int value) {
            this.value = value;
        }

        public TreeNode getLnode() {
            return lnode;
        }

        public void setLnode(TreeNode lnode) {
            this.lnode = lnode;
        }

        public TreeNode getRnode() {
            return rnode;
        }

        public void setRnode(TreeNode rnode) {
            this.rnode = rnode;
        }

        @Override
        public String toString() {
            return "TreeNode [value=" + value + ", lnode=" + lnode + ", rnode=" + rnode + "]";
        }
        
    }
    
    public static void main(String[] args){
        BinaryTree tree = new BinaryTree(10);
        tree.insert(6);
        tree.insert(14);
        tree.insert(4);
        tree.insert(8);
        tree.insert(12);
        tree.insert(16);
        
        System.out.println("root.left: "+ tree.getRoot().getLnode().toString());
        System.out.println("root.right: "+ tree.getRoot().getRnode().toString());
        tree.remove(16);
        System.out.println("root.right: "+tree.getRoot().getRnode().toString());
        
        LinkedList<TreeNode> treeNodes = tree.tree2LinkedList();
        for(TreeNode node:treeNodes){
            System.out.println(node);
        }
    }
}