知识布局-数据结构-搜索二叉树

前言

数据结构是不可避免的。数据结构作为基础知识，在很多面试中都会涉及。所以掌握数据结构可能会给自己的面试成绩加分。今天我编写了一个搜索二叉树。

目录

1.树的节点
2.操作类型
3.树的实现
4.总结

1.树的节点

public class TreeNode {

    private int data;
    private TreeNode rightNode = null;
    private TreeNode leftNode = null;

    public int getData() {
        return data;
    }

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

    public TreeNode getLeftNode() {
        return leftNode;
    }

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

    public TreeNode getRightNode() {
        return rightNode;
    }

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

}

2.我们定义一个操作接口

这个操作接口就是我们二叉树支持的操作。支持插入、删除、查找。暂时不支持遍历。

/**
 * Created by impala on 2017/12/7.
 */
public interface Operator {

    public boolean insert(int data);

    public TreeNode search(int data);

    public boolean delete(int data);
}

3.树的实现

/**
 * Created by impala on 2017/12/7.
 *
 * @author forideal
 */
public class BinarySearchTree implements Operator {

    private TreeNode rootNode = null;

    public BinarySearchTree() {

    }

    @Override
    public boolean insert(int data) {
        if (rootNode == null) {
            rootNode = new TreeNode();
            rootNode.setData(data);
        } else {
            TreeNode current = rootNode;
            while (current != null) {
                if (data > current.getData()) {
                    if (current.getRightNode() == null) {
                        TreeNode rightChild = new TreeNode();
                        rightChild.setData(data);
                        current.setRightNode(rightChild);
                        return true;
                    }
                    current = current.getRightNode();
                } else if (data == current.getData()) {
                    System.out.println("The data " + data + " is exist.");
                    return false;
                } else {
                    if (current.getLeftNode() == null) {
                        TreeNode leftChild = new TreeNode();
                        leftChild.setData(data);
                        current.setLeftNode(leftChild);
                        return true;
                    }
                    current = current.getLeftNode();
                }
            }
        }
        return true;
    }

    @Override
    public TreeNode search(int data) {
        if (rootNode == null) {
            System.out.println("The tree is empty.");
            return null;
        }
        TreeNode currentNode = rootNode;
        while (currentNode != null) {
            if (data > currentNode.getData()) {
                currentNode = currentNode.getRightNode();
            } else if (data < currentNode.getData()) {
                currentNode = currentNode.getLeftNode();
            } else {
                return currentNode;
            }
        }
        return null;
    }

    @Override
    public boolean delete(int data) {
        if (rootNode == null) {
            System.out.println("The tree is empty.");
            return false;
        }

        //1.寻找需要删除的节点信息
        TreeNode currentNode = rootNode;
        TreeNode parentNode = null;
        TreeNode targetNode = null;
        boolean isParentLeftChildNode = false;

        while (currentNode != null) {
            if (data > currentNode.getData()) {
                parentNode = currentNode;
                currentNode = currentNode.getRightNode();
                isParentLeftChildNode = false;
            } else if (data < currentNode.getData()) {
                parentNode = currentNode;
                currentNode = currentNode.getLeftNode();
                isParentLeftChildNode = true;
            } else {
                targetNode = currentNode;
                break;
            }
        }

        //2.目标删除节点不存在
        if (targetNode == null) {
            System.out.println("The tree dones't has the data.");
            return false;
        }

        //3.目标删除节点是根节点
        if (parentNode == null) {
            System.out.println("we will delete root node.");
            TreeNode tmpNode = null;
            TreeNode leftNode = rootNode.getLeftNode();
            TreeNode curNode = rootNode.getRightNode();
            while (curNode != null) {
                tmpNode = curNode;
                curNode = curNode.getLeftNode();
                if (curNode == null) {
                    tmpNode.setLeftNode(leftNode);
                }
            }
            rootNode = rootNode.getRightNode();
            return true;
        }

        //4.目标删除节点不是跟节点
        //4.1.先把target节点的左子节点拼接到右子节点上面
        TreeNode leftChildNode = targetNode.getLeftNode();
        TreeNode rightChildNode = targetNode.getRightNode();
        TreeNode rightCur = rightChildNode;
        TreeNode rightParent = null;
        while (rightCur != null) {
            rightParent = rightCur;
            rightCur = rightCur.getLeftNode();
            if (rightCur == null) {
                rightParent.setLeftNode(leftChildNode);
            }
        }

        //4.2.将刚刚拼接好的节点拼接到之前的树上
        if (isParentLeftChildNode) {
            //如果相对于父节点来说是左子节点
            TreeNode tmpNode = null;
            TreeNode curNode = parentNode.getRightNode();
            while (curNode != null) {
                tmpNode = curNode;
                curNode = curNode.getLeftNode();
                if (curNode == null) {
                    tmpNode.setLeftNode(rightChildNode);
                }
            }
            parentNode.setLeftNode(null);
            return true;
        } else {
            //如果相对于父节点来说是右子节点
            parentNode.setRightNode(rightChildNode);
            return true;
        }

    }

    public static void main(String[] args) {
        BinarySearchTree binarySearchTree = new BinarySearchTree();
        binarySearchTree.insert(4);
        binarySearchTree.insert(6);
        binarySearchTree.insert(4);
        binarySearchTree.insert(3);

        for (int i = 10; i < 100000; i++) {
            binarySearchTree.insert(i);
        }

        TreeNode node = binarySearchTree.search(3);
        if (node == null) {
            System.out.println("we don't find 3.");
        } else {
            System.out.println("we find 3.");
        }

        binarySearchTree.delete(3);
        binarySearchTree.delete(4);
        binarySearchTree.delete(6);
        node = binarySearchTree.search(3);
        if (node == null) {
            System.out.println("we don't find 3.");
        } else {
            System.out.println("we find 3.");
        }

        node = binarySearchTree.search(4);
        if (node == null) {
            System.out.println("we don't find 4.");
        } else {
            System.out.println("we find 4.");
        }

        node = binarySearchTree.search(6);
        if (node == null) {
            System.out.println("we don't find 6.");
        } else {
            System.out.println("we find 6.");
        }

        binarySearchTree.delete(888);

        for (int i = 10; i < 100000; i++) {
            node = binarySearchTree.search(i);
            if (node == null) {
                System.out.println("we don't find " + i + ".");
            }
        }
    }

}

4.总结

说句真心话，学习数据结构，最好能够自己动手写一个自己的实现。这样学习的效果会好一些。