数据结构二叉树的java实现，包括二叉树的创建、搜索、删除和遍历

根据自己的学习体会并参考了一些网上的资料，以java写出了二叉树的创建、搜索、删除和遍历等操作，尚未实现的功能有：根据先序和中序遍历，得到后序遍历以及根据后序和中序遍历，得到先序遍历，以及获取栈的深度和其它的一些方法等完成了再继续更新：

二叉树的java实现：

package com.peter.java.dsa.common;

import java.util.ArrayList;

public class BinaryTree {
    private TreeNode root;
    private int size = 0;

    public BinaryTree() {
        // TODO Auto-generated constructor stub
    }

    public BinaryTree(int value) {
        // TODO Auto-generated constructor stub
        this.root = new TreeNode(value);
        this.size = 1;
    }

    public TreeNode getRoot() {
        return root;
    }

    public int getMax() {
        TreeNode node = root;
        while (node.rightChildNode != null) {
            node = node.rightChildNode;
        }
        return node.value;
    }

    public int getMin() {
        TreeNode node = root;
        while (node.leftChildNode != null) {
            node = node.leftChildNode;
        }
        return node.value;
    }

    public void preOrderTreeWalk(TreeNode node, ArrayList<Integer> container) {
        if (node != null) {
            container.add(node.value);
            preOrderTreeWalk(node.leftChildNode, container);
            preOrderTreeWalk(node.rightChildNode, container);
        }
    }

    public void midOrderTreeWalk(TreeNode node, ArrayList<Integer> container) {
        if (node != null) {
            midOrderTreeWalk(node.leftChildNode, container);
            container.add(node.value);
            midOrderTreeWalk(node.rightChildNode, container);
        }
    }

    public void postOrderTreeWalk(TreeNode node, ArrayList<Integer> container) {
        if (node != null) {
            postOrderTreeWalk(node.leftChildNode, container);
            postOrderTreeWalk(node.rightChildNode, container);
            container.add(node.value);
        }
    }

    public TreeNode search(int value) {
        TreeNode node = root;
        while (node.value != value) {
            if (value < node.value) {
                node = node.leftChildNode;
            } else {
                node = node.rightChildNode;
            }
            if (node == null) {
                node = null;
            }
        }
        return node;
    }

    private TreeNode findParentNode(int value) {
        TreeNode parent = null;
        TreeNode node = root;
        while (node.value != value) {
            parent = node;
            if (value < node.value) {
                node = node.leftChildNode;
            } else {
                node = node.rightChildNode;
            }
            if (node == null) {
                node = null;
                parent = null;
            }
        }
        return parent;
    }

    public void createBinaryTree(int[] data) {
        if (data != null) {
            for (int i : data) {
                insert(i);
            }
        }
    }

    public void insert(int value) {
        if (root == null) {
            root = new TreeNode(value);
        } else {
            TreeNode curNode = root;
            TreeNode parentNode;
            while (true) {
                parentNode = curNode;
                if (value < curNode.value) {
                    curNode = curNode.leftChildNode;
                    if (curNode == null) {
                        parentNode.leftChildNode = new TreeNode(value);
                        parentNode.leftChildNode.leftOrRight = -1;
                        break;
                    }
                } else {
                    curNode = curNode.rightChildNode;
                    if (curNode == null) {
                        parentNode.rightChildNode = new TreeNode(value);
                        parentNode.rightChildNode.leftOrRight = 1;
                        break;
                    }
                }
            }
        }
        ++size;
    }

    public boolean delete(int value) {
        boolean flag = false;
        TreeNode node = search(value);
        TreeNode parent = findParentNode(value);
        if (node != null) {
            if (node.equals(root)) {
                root = null;
            }
            if (node.leftChildNode == null && node.rightChildNode == null) {
                if (node.leftOrRight == 1) {
                    node = null;
                    parent.rightChildNode = null;
                }
                if (node.leftOrRight == -1) {
                    node = null;
                    parent.leftChildNode = null;
                }
            } else if (node.leftChildNode != null
                    && node.rightChildNode != null) {
                TreeNode successor = findSuccessor(node);
                if (node.leftOrRight == -1) {
                    parent.leftChildNode = successor;
                    parent.leftChildNode.leftOrRight = -1;
                }
                if (node.leftOrRight == 1) {
                    parent.rightChildNode = successor;
                    parent.rightChildNode.leftOrRight = 1;
                }
                successor.leftChildNode = node.leftChildNode;
            } else {
                if (node.leftChildNode != null) {
                    if (node.leftOrRight == 1) {
                        parent.rightChildNode = node.leftChildNode;
                    }
                    if (node.leftOrRight == -1) {
                        parent.leftChildNode = node.leftChildNode;
                    }
                }
                if (node.rightChildNode != null) {
                    if (node.leftOrRight == 1) {
                        parent.rightChildNode = node.rightChildNode;
                    }
                    if (node.leftOrRight == -1) {
                        parent.leftChildNode = node.rightChildNode;
                    }
                }
                node = null;
            }
            flag = true;
            --size;
        }
        return flag;
    }

    private TreeNode findSuccessor(TreeNode delNode) {
        TreeNode parent = delNode;
        TreeNode successor = delNode;
        TreeNode curNode = delNode.rightChildNode;

        while (curNode != null) {
            parent = successor;
            successor = curNode;
            curNode = curNode.leftChildNode;
        }
        if (!successor.equals(delNode.rightChildNode)) {
            parent.leftChildNode = successor.rightChildNode;
            successor.rightChildNode = delNode.rightChildNode;
        }
        return successor;
    }

    public int size() {
        return this.size;
    }

    public boolean isEmpty() {
        // TODO Auto-generated method stub
        return size == 0;
    }

    public class TreeNode {
        int leftOrRight = 0;// 0: root;-1:left child node;1, right childe node;
        Integer value;
        TreeNode leftChildNode;
        TreeNode rightChildNode;

        public TreeNode(Integer value) {
            // TODO Auto-generated constructor stub
            this.value = value;
        }

        @Override
        public boolean equals(Object obj) {
            // TODO Auto-generated method stub
            if (obj instanceof TreeNode) {
                TreeNode node = (TreeNode) obj;
                return node.value == this.value;
            }
            return false;
        }

        @Override
        public String toString() {
            return "TreeNode [leftOrRight="
                    + leftOrRight
                    + ", value="
                    + value
                    + (leftChildNode != null ? ", leftChildNode="
                            + leftChildNode : "")
                    + (rightChildNode != null ? ", rightChildNode="
                            + rightChildNode : "") + "]";
        }
    }
}

测试代码如下：

package com.peter.java.dsa.test;

import java.util.ArrayList;
import java.util.Arrays;

import com.peter.java.dsa.common.BinaryTree;
import com.peter.java.dsa.common.BinaryTree.TreeNode;

public class Test {

    /**
     * @param args
     */
    public static void main(String[] args) {
        // TODO Auto-generated method stub
        int[] data = { 21, 25, 16, 32, 22, 19, 13, 20 };
        System.out.println("input: " + Arrays.toString(data));
        BinaryTree bTree = new BinaryTree();
        System.out.println(bTree.isEmpty() + "--" + bTree.size());
        bTree.createBinaryTree(data);
        System.out.println(bTree.isEmpty() + "--" + bTree.size());
        ArrayList<Integer> container = new ArrayList<Integer>();
        TreeNode root = bTree.getRoot();
        container.clear();
        bTree.preOrderTreeWalk(root, container);
        System.out.println("pre Order Binary Tree Walk: "
                + container.toString());
        container.clear();
        bTree.midOrderTreeWalk(root, container);
        System.out.println("mid Order Binary Tree Walk: "
                + container.toString());
        container.clear();
        bTree.postOrderTreeWalk(root, container);
        System.out.println("post Order Binary Tree Walk: "
                + container.toString());
        System.out.println("Max Value: " + bTree.getMax());
        System.out.println("Max Value: " + bTree.getMin());
        // change the function findParentNode() to be private
        // TreeNode parent = bTree.findParentNode(25);
        // if (parent != null) {
        // System.out.println("Parent Value: " + parent.toString());
        // }
        // delete a node which has no child nodes, successfully
        // bTree.delete(13);
        // container.clear();
        // bTree.midOrderTreeWalk(root, container);
        // System.out.println("mid Order Binary Tree Walk: "
        // + container.toString());
        // container.clear();
        // bTree.postOrderTreeWalk(root, container);
        // System.out.println("post Order Binary Tree Walk: "
        // + container.toString());
        // delete a node which has a right child node, successfully
        // bTree.delete(19);
        // container.clear();
        // bTree.preOrderTreeWalk(root, container);
        // System.out.println("pre Order Binary Tree Walk: "
        // + container.toString());
        // container.clear();
        // bTree.midOrderTreeWalk(root, container);
        // System.out.println("mid Order Binary Tree Walk: "
        // + container.toString());

        // delete a node which has a right child node, successfully
        bTree.delete(16);
        container.clear();
        bTree.preOrderTreeWalk(root, container);
        System.out.println("pre Order Binary Tree Walk: "
                + container.toString());
        container.clear();
        bTree.midOrderTreeWalk(root, container);
        System.out.println("mid Order Binary Tree Walk: "
                + container.toString());
    }
}