java数据结构----------二叉搜索树:

package DataStructure;

public class SearchBinaryTreeTest {
    
    public static void main(String[] args) {
        int[] arrTree = new int[] {12,56,32,48,77,98,4,55};
        SearchBinaryTree tree = new SearchBinaryTree();
        for(int i : arrTree) {
            tree.put(i).getData();
            
        }
        middOrder(tree.rootNode);
        tree.deleteNode(77);
        tree.deleteNode(55);
        
        middOrder(tree.rootNode);
        
    }
    
    public static void middOrder(SearchBinaryTreeNode rootNode) {
        if(rootNode == null) {
            return;
        }
        middOrder(rootNode.getLeftNode());
        System.out.print(rootNode.getData()+"  ");
        middOrder(rootNode.getRightNode());
    }
}

class SearchBinaryTree {
    
    public SearchBinaryTreeNode rootNode;
    
    /**
     * ?戜簩?夋?滅储鏍戜腑澧炲姞鑺傜偣**/
    public SearchBinaryTreeNode put(int data) {
        SearchBinaryTreeNode node = null;
        node = new SearchBinaryTreeNode(0,data);
        /**
         * 棣栧厛鍒ゆ柇璇ヤ簩?夋?滅储鏍戠殑鏍硅妭鐐规槸?︿负绌?*/
        if(rootNode == null) {
            
            rootNode = node;
            return rootNode;
        }
        SearchBinaryTreeNode parentNode = rootNode;
        SearchBinaryTreeNode currentParentNode = null;
        /**
         * 鍒ゆ柇put杩涙?ョ殑鑺傜偣闇€瑕?鏀惧湪鍝釜鑺傜偣鐨勪笅??--褰損arentNode鐨勫乏瀛?鑺傜偣鎴栬€呭?冲?鑺傜偣涓虹┖鏄紝閫€鍑哄惊鐜?*/
        while(parentNode != null) {
            currentParentNode = parentNode;
            if(data < parentNode.getData()) {
                parentNode = parentNode.getLeftNode();
            }else if(data > parentNode.getData()) {
                parentNode = parentNode.getRightNode();
            }else {
                return parentNode;
            }
        }
        /**
         * 鍒ゆ柇璇ユ暟?斁鍦ㄥ叾鐖惰妭鐐圭殑宸﹁妭鐐逛?缃紝杩樻槸?宠妭鐐逛?缃?*/
        node = new SearchBinaryTreeNode(0,data);
        
        if(data < currentParentNode.getData()) {
            currentParentNode.setLeftNode(node);
            node.setParentNode(currentParentNode);
        }
        if(data > currentParentNode.getData()) {
            currentParentNode.setRightNode(node);
            node.setParentNode(currentParentNode);
        }
        return node;
    }
    
    /**
     * 鍒犻櫎浜屽?夋?滅储涔︿腑鐨勬?涓妭鐐?*/
    public void deleteNode(int data) {
        SearchBinaryTreeNode searchNode = searchNode(data);
        if(searchNode == null) {
            System.out.println("the node doesn't finded !");
            return ;
        }else {
            System.out.println("finding this node is ok,waiting delete!");
            delete(searchNode);
        }
        
    }
    /**
     *鍒犻櫎鏌?涓妭鐐圭殑鍏蜂綋鏂规硶**/
    private static void delete(SearchBinaryTreeNode searchNode) {
        /**
         * 鍒嗘?琚垹闄よ妭鐐圭殑宸﹀?冲?鏍戞儏鍐?
         * 1.鏃犲乏?冲?鏍?2.鏈夊乏瀛?鏍戯紝鏃犲?冲?鏍?3.鏈夊?冲?鏍戯紝鏃犲乏瀛?鏍?4.鏃㈡湁宸﹀?鏍戯紝?堟湁?冲?鏍?*/
        if(searchNode.getLeftNode() == null && searchNode.getRightNode() == null) {
            if(searchNode.getParentNode().getLeftNode() == searchNode) {
                searchNode.getParentNode().setLeftNode(null);
            }
            if(searchNode.getParentNode().getRightNode() == searchNode) {
                searchNode.getParentNode().setRightNode(null);
            }
            searchNode.setParentNode(null);
        }else if(searchNode.getLeftNode() != null && searchNode.getRightNode() == null) {
            if(searchNode.getParentNode().getLeftNode() == searchNode) {
                searchNode.getParentNode().setLeftNode(searchNode.getLeftNode());
            }
            if(searchNode.getParentNode().getRightNode() == searchNode) {
                searchNode.getParentNode().setRightNode(searchNode.getLeftNode());    
            }
            searchNode.getLeftNode().setParentNode(searchNode.getParentNode());
        }else if(searchNode.getLeftNode() == null && searchNode.getRightNode() != null) {
            if(searchNode.getParentNode().getLeftNode() == searchNode) {
                searchNode.getParentNode().setLeftNode(searchNode.getRightNode());
            }
            if(searchNode.getParentNode().getRightNode() == searchNode) {
                searchNode.getParentNode().setRightNode(searchNode.getRightNode());
            }
            searchNode.getRightNode().setParentNode(searchNode.getParentNode());
        }else {
            /**
             * 4.鏃㈡湁宸﹀?鏍戯紝?堟湁?冲?鏍戠殑鎯呭喌涓嬶紝闇€瑕?鎵惧埌璇ヨ妭鐐圭殑鍓?椹卞拰?庣户鑺傜偣**/
            SearchBinaryTreeNode nextNode = getNextNode(searchNode);
            delete(nextNode);
            searchNode.setData(nextNode.getData());
            
        }
    }
    
    private static SearchBinaryTreeNode getNextNode(SearchBinaryTreeNode searchNode) {
        if(searchNode == null) {
            return null;
        }else {
            /**
             * 鏌ユ壘?庣户鑺傜偣鐨勮鍒欙細
             * 1.濡傛灉璇ヨ妭鐐规湁?冲?鏍戯紝閭ｄ箞璇ヨ妭鐐圭殑?庣户鑺傜偣涓猴紝?冲?鏍戜腑鐨勬渶灏?val鍊?
             * 2.**/
            if(searchNode.getRightNode() != null) {
                /**
                 * 鎵捐鑺傜偣鐨勫?冲?鏍戜腑鐨勬渶灏?鍊艰妭鐐?*/
                SearchBinaryTreeNode minNode = getMinNode(searchNode.getRightNode());
                return minNode;
            }else {
                /**
                 * 褰撹鑺傜偣娌℃湁?冲?鏍戞椂锛屽垽鏂鑺傜偣涓庡叾鐖惰妭鐐圭殑鍏崇郴**/
                if(searchNode.getParentNode().getLeftNode() == searchNode) {
                    return searchNode.getParentNode();
                }
                if(searchNode.getParentNode().getRightNode() == searchNode) {
                    while(searchNode == searchNode.getParentNode().getRightNode()) {
                        searchNode = searchNode.getParentNode();
                        searchNode.setParentNode(searchNode.getParentNode().getParentNode());
                    }
                }
            }
        }
        return searchNode.getParentNode();
    }
    /**
     * 鎵捐鑺傜偣鐨勫?冲?鏍戜腑鐨勬渶灏?鍊艰妭鐐?*/
    private static SearchBinaryTreeNode getMinNode(SearchBinaryTreeNode node) {
        if(node == null) {
            return null;
        }else {
            while(node != null) {
                node = node.getLeftNode();
            }
        }
        return node;
    }

    /**
     * 鍒犻櫎鏌?涓妭鐐逛箣鍓?锛岄渶瑕?鍏堝垽鏂簩?夋?滅储鏍戜腑鏄?︽湁璇ヨ妭鐐?*/
    private SearchBinaryTreeNode searchNode(int data) {
        SearchBinaryTreeNode currentRootNode = rootNode;
        if(currentRootNode == null) {
            System.out.println("this binaryTree is null!");
            return null;
        }else {
            while(currentRootNode != null && currentRootNode.getData() != data) {
                if(data < currentRootNode.getData()) {
                    currentRootNode = currentRootNode.getLeftNode();
                }if(data > currentRootNode.getData()) {
                    currentRootNode = currentRootNode.getRightNode();
                }
            }
            return currentRootNode;
        }
    }
}

class SearchBinaryTreeNode {
    private int index;
    
    private int data;
    
    private SearchBinaryTreeNode leftNode;
    
    private SearchBinaryTreeNode rightNode;
    
    private SearchBinaryTreeNode parentNode;
    
    
    public SearchBinaryTreeNode(int index,int data) {
        this.index = index;
        this.data = data;
        this.leftNode = null;
        this.rightNode = null;
        this.parentNode = null;
    }

    public int getIndex() {
        return index;
    }

    public void setIndex(int index) {
        this.index = index;
    }

    public int getData() {
        return data;
    }

    public void setData(int data) {
        this.data = data;
    }

    public SearchBinaryTreeNode getLeftNode() {
        return leftNode;
    }

    public void setLeftNode(SearchBinaryTreeNode leftNode) {
        this.leftNode = leftNode;
    }

    public SearchBinaryTreeNode getRightNode() {
        return rightNode;
    }

    public void setRightNode(SearchBinaryTreeNode rightNode) {
        this.rightNode = rightNode;
    }

    public SearchBinaryTreeNode getParentNode() {
        return parentNode;
    }

    public void setParentNode(SearchBinaryTreeNode parentNode) {
        this.parentNode = parentNode;
    }
}