二叉树——JAVA实现

import java.util.Stack;

public class BinaryTree<T> {
    public static void main(String[] args){
        BinaryTree b = new BinaryTree();
        b.insert(new TreeNode(15));
        b.insert(new TreeNode(2));
        b.insert(new TreeNode(18));
        b.insert(new TreeNode(20));
        b.insert(new TreeNode(16));
        b.insert(new TreeNode(3));
        b.insert(new TreeNode(4));
        b.insert(new TreeNode(7));
        b.insert(new TreeNode(6));
        b.insert(new TreeNode(13));
        b.insert(new TreeNode(17));
        b.preOrder(b.getRoot());
        System.out.println();
        b.preOrder(b.delete(b.searchKey(b.getRoot(), 7)));
    }

    //前序遍历: 递归实现
    public void preOrder(TreeNode<T> root){
        if(root != null){
            System.out.print(root.data + " ");
            preOrder(root.leftChild);
            preOrder(root.rightChild);
        }
    }

    //栈实现
    public void preOrder2(TreeNode<T> root){
        if(root == null){
            return;
        }

        Stack<TreeNode> stack = new Stack<>();
        while(root != null || !stack.empty()){
            if(root != null){
                System.out.print(root.data + " ");
                stack.push(root);
                root = root.leftChild;
            } else{
                root = stack.pop();
                root = root.rightChild;
            }
        }
        System.out.println();
    }

    //中序遍历: 递归实现
    public void inOrder(TreeNode<T> root){
        if(root != null){
            inOrder(root.leftChild);
            System.out.print(root.data + " ");
            inOrder(root.rightChild);
        }
    }

    //非递归实现
    public void inOrder2(TreeNode<T> root){
        if(root == null){
            return;
        }

        Stack<TreeNode> stack = new Stack<>();
        while(root != null || !stack.empty()){
            if(root != null){
                stack.push(root);
                root = root.leftChild;
            } else{
                root = stack.pop();
                System.out.print(root.data + " ");
                root = root.rightChild;
            }
        }
        System.out.println();
    }

    //后序遍历: 递归实现
    public void postOrder(TreeNode<T> root){
        if(root != null){
            postOrder(root.leftChild);
            postOrder(root.rightChild);
            System.out.print(root.data + " ");
        }
    }

    //非递归实现
    public void postOrder2(TreeNode<T> root){
        if(root == null){
            return;
        }

        /**
         *  后序遍历: 输出次序: 左结点→右结点→父节点, 放入栈中时的次序
         *  从上到下就是左节点，右节点，父节点，故遍历时需先将所有结点的
         *  父节点及其孩子节点按以上次序全都压到一个栈中，最后依次出栈即
         *  实现后序遍历的效果
         */
        Stack<TreeNode> temp = new Stack<>();
        Stack<TreeNode> stack = new Stack<>();
        temp.push(root);
        while(!temp.empty()){
            TreeNode<T> node = temp.pop();
            stack.push(node);

            if(node.leftChild != null){
                temp.push(node.leftChild);
            }

            if(node.rightChild != null){
                temp.push(node.rightChild);
            }
        }

        while(!stack.empty()){
            System.out.print(stack.pop() + " ");
        }
        System.out.println();
    }

    //查找指定值: 递归实现
    public TreeNode<T> searchKey(TreeNode<T> root, int key){
        if(root != null){
            if(key == root.data){
                return root;
            } else if(key > root.data){
                return searchKey(root.rightChild, key);
            } else{
                return searchKey(root.leftChild, key);
            }
        } else{
            return null;
        }
    }

    //非递归实现
    public TreeNode<T> searchKey2(TreeNode<T> root, int key){
        while(root != null){
            if (root.data == key) {
                return root;
            } else if(root.data > key){
                root = root.leftChild;
            } else {
                root = root.rightChild;
            }
        }
        return null;
    }

    //查找最大值
    public TreeNode<T> searchMax(TreeNode<T> root){
        if(root == null){
            return null;
        }

        TreeNode<T> node = root;
        while(node.rightChild != null){
            node = node.rightChild;
        }
        return node;
    }

    //查找最小值
    public TreeNode<T> searchMin(TreeNode<T> root){
        if(root == null){
            return null;
        }

        TreeNode<T> node = root;
        while(node.leftChild != null){
            node = node.leftChild;
        }
        return node;
    }

    //查找前驱节点
    public TreeNode<T> predecessor(TreeNode<T> node){
        if(node == null){
            return null;
        }

        if(node.leftChild != null){
            return this.searchMax(node.leftChild);
        }

        TreeNode<T> parentNode = node.parent;
        while((parentNode != null) && (node == parentNode.leftChild)){
            node = parentNode;
            parentNode = node.parent;
        }
        return parentNode;
    }

    //查找后继节点
    public TreeNode<T> successor(TreeNode<T> node){
        if(node == null){
            return null;
        }

        if(node.rightChild != null){
            return this.searchMin(node.rightChild);
        }

        TreeNode<T> parentNode = node.parent;
        while((parentNode != null) && (node == parentNode.rightChild)){
            node = parentNode;
            parentNode = node.parent;
        }
        return parentNode;
    }

    //插入结点
    public TreeNode<T> insert(TreeNode<T> node){
        TreeNode<T> p = null;
        TreeNode<T> c = root;
        while(c != null){
            p = c;
            if(node.data > c.data){
                c = c.rightChild;
            } else{
                c = c.leftChild;
            }
        }

        node.parent = p;
        if(p == null){
            root = node;
        } else if(node.data > p.data){
            p.rightChild = node;
        } else{
            p.leftChild = node;
        }
        return root;
    }

    //删除结点
    public TreeNode<T> delete(TreeNode<T> node){
        TreeNode<T> x = null;
        TreeNode<T> y = null;

        if((node.leftChild == null) || (node.rightChild == null)){
            y = node;
        } else{
            y = successor(node);
        }

        if(y.leftChild != null){
            x = y.leftChild;
        } else{
            x = y.rightChild;
        }

        if(x != null){
            x.parent = y.parent;
        }

        if(y.parent == null){
            root = x;
        } else if(y == y.parent.leftChild){
            y.parent.leftChild = x;
        } else{
            y.parent.rightChild = x;
        }

        if(node != y){
            node.data = y.data;
        }

        return root;
    }

    public TreeNode<T> getRoot(){
        return root;
    }

    public static class TreeNode<T>{
        public TreeNode(int data){
            this.data = data;
        }

        public TreeNode(int data, TreeNode<T> parent, TreeNode<T> leftChild, TreeNode<T> rightChild){
            this.data = data;
            this.parent = parent;
            this.leftChild = leftChild;
            this.rightChild = rightChild;
        }

        private int data;
        private TreeNode<T> parent;
        private TreeNode<T> leftChild;
        private TreeNode<T> rightChild;
    }
    private TreeNode<T> root;
}