二叉树的简单实现--数据结构与算法纪录片第二记

　　这几天状态不好看不下去，所以停了一下。今天把二叉树的实现写了一下，把其中的原理也重新理解了一遍。

package tree.bstree;

/** * @Description: TODO * @Auther: Zhang * @Date: 2018/11/5 16:34 */public class BSTNode<T extends Comparable<T>> {    private T key;    private BSTNode<T> parentNode;    private BSTNode<T> leftChildrenNode;    private BSTNode<T> rightChildrenNode;

public BSTNode(T key) {        this.key = key;        parentNode = leftChildrenNode = rightChildrenNode = null;    }

public BSTNode(T key, BSTNode<T> parentNode, BSTNode<T> leftChildrenNode, BSTNode<T> rightChildrenNode) {        this.key = key;        this.parentNode = parentNode;        this.leftChildrenNode = leftChildrenNode;        this.rightChildrenNode = rightChildrenNode;    }

public T getKey() {        return key;    }

public void setKey(T key) {        this.key = key;    }

public BSTNode<T> getParentNode() {        return parentNode;    }

public void setParentNode(BSTNode<T> parentNode) {        this.parentNode = parentNode;    }

public BSTNode<T> getLeftChildrenNode() {        return leftChildrenNode;    }

public void setLeftChildrenNode(BSTNode<T> leftChildrenNode) {        this.leftChildrenNode = leftChildrenNode;    }

public BSTNode<T> getRightChildrenNode() {        return rightChildrenNode;    }

public void setRightChildrenNode(BSTNode<T> rightChildrenNode) {        this.rightChildrenNode = rightChildrenNode;    }}

package tree.bstree;

/** * @Description: TODO * @Auther: Zhang * @Date: 2018/11/5 16:33 */public class BSTree<T extends Comparable<T>> {

private BSTNode<T> rootNode;

public BSTree() {        rootNode = null;    }

public BSTree(BSTNode<T> node) {        rootNode = node;    }

//查找最大节点    private BSTNode<T> maxNode(BSTNode<T> bstNode) {        if (bstNode == null) {            return bstNode;        }        while (bstNode.getRightChildrenNode() != null) {            bstNode = bstNode.getRightChildrenNode();        }        return bstNode;    }

public BSTNode<T> maxNode() {        return this.maxNode(rootNode);    }

//查找最小节点    private BSTNode<T> minNode(BSTNode bstNode) {        if (bstNode == null) {            return bstNode;        }        while (bstNode.getLeftChildrenNode() != null) {            bstNode = bstNode.getLeftChildrenNode();        }        return bstNode;    }

public BSTNode<T> minNode() {        return this.minNode(rootNode);    }

//插入节点    private void insert(BSTNode<T> bstNode) {        int compareResult;        BSTNode<T> parent = null;        BSTNode<T> current = rootNode;

//如果树为空，该节点为根节点        if (rootNode == null) {            rootNode = bstNode;            return;        }

//数不为空，判断节点的位置        while (current != null) {            parent = current;            compareResult = bstNode.getKey().compareTo(current.getKey());            if (compareResult == 0) {                System.out.println("该节点已存在树中");                return;            }            if (compareResult < 0) {                current = current.getLeftChildrenNode();            } else {                current = current.getRightChildrenNode();            }        }

//将节点插入到树中        bstNode.setParentNode(parent);        compareResult = bstNode.getKey().compareTo(parent.getKey());        if (compareResult < 0) {            parent.setLeftChildrenNode(bstNode);        } else {            parent.setRightChildrenNode(bstNode);        }    }

public void insert(T key) {        BSTNode<T> bstNode = new BSTNode<>(key);        this.insert(bstNode);    }

//删除节点    private void delete(T key, BSTree<T> bsTree) {        BSTNode<T> bstNode = this.find(key);        if (bstNode == null) {            System.out.println("没有找到该节点");        }        BSTNode<T> parent = bstNode.getParentNode();        int comp = bstNode.getKey().compareTo(parent.getKey());        //如果节点没有孩子节点        if (bstNode.getLeftChildrenNode() == null && bstNode.getRightChildrenNode() == null) {            if (comp > 0) {                parent.setRightChildrenNode(null);            } else {                parent.setLeftChildrenNode(null);            }            return;        }

//如果该节点只有左子树或者该节点只有右子树        //只有左子树        if (bstNode.getLeftChildrenNode() != null && bstNode.getRightChildrenNode() == null) {            if (comp > 0) {                parent.setRightChildrenNode(bstNode.getLeftChildrenNode());            } else {                parent.setLeftChildrenNode(bstNode.getLeftChildrenNode());            }            return;        }

//只有右子树        if (bstNode.getRightChildrenNode() != null && bstNode.getLeftChildrenNode() == null) {            if (comp > 0) {                parent.setRightChildrenNode(bstNode.getRightChildrenNode());            } else {                parent.setLeftChildrenNode(bstNode.getRightChildrenNode());            }            return;        }

//既有左子树又有右子树        if (bstNode.getLeftChildrenNode() != null && bstNode.getRightChildrenNode() != null) {            BSTNode<T> newNode = minNode(bstNode.getRightChildrenNode());            if (bstNode.getRightChildrenNode() == newNode) {                newNode.setRightChildrenNode(null);            } else {                parent.setRightChildrenNode(newNode);                newNode.setLeftChildrenNode(bstNode.getLeftChildrenNode());                newNode.setRightChildrenNode(bstNode.getRightChildrenNode());            }            if (comp > 0) {                parent.setRightChildrenNode(newNode);            } else {                parent.setLeftChildrenNode(newNode);            }        }    }

public void delete(T key) {        delete(key, this);    }

//查找节点    private BSTNode<T> find(T key, BSTree<T> bsTree) {        int comp;        BSTNode<T> current = bsTree.rootNode;        comp = key.compareTo(current.getKey());        while (comp != 0) {            if (comp > 0) {                current = current.getRightChildrenNode();            } else {                current = current.getLeftChildrenNode();            }            if (current == null) {                return current;            }            comp = key.compareTo(current.getKey());        }        return current;    }

public BSTNode<T> find(T key) {        BSTNode bstNode = this.find(key, this);        if (bstNode == null) {            System.out.println("没有找到该节点");        }        return bstNode;    }

//前序遍历    private void preOrder(BSTNode<T> bstNode) {        if (bstNode != null) {            System.out.println("key is : " + bstNode.getKey());            preOrder(bstNode.getLeftChildrenNode());            preOrder(bstNode.getRightChildrenNode());        } else {            return;        }

}

public void preOrder() {        System.out.println("前序遍历: ");        this.preOrder(rootNode);    }

//中序遍历    private void midOrder(BSTNode<T> bstNode) {        if (bstNode != null) {            midOrder(bstNode.getLeftChildrenNode());            System.out.println("key is : " + bstNode.getKey());            midOrder(bstNode.getRightChildrenNode());        } else {            return;        }    }

public void midOrder() {        System.out.println("中序遍历: ");        this.midOrder(rootNode);    }

//后序遍历    private void postOrder(BSTNode<T> bstNode) {        if (bstNode != null) {            postOrder(bstNode.getLeftChildrenNode());            postOrder(bstNode.getRightChildrenNode());            System.out.println("key is : " + bstNode.getKey());        } else {            return;        }    }

public void postOrder() {        System.out.println("后序遍历: ");        this.postOrder(rootNode);    }

//前驱节点    private BSTNode<T> predecessor(BSTNode<T> bstNode) {        //如果存在左孩子，则前驱为最大左孩子        if (bstNode.getLeftChildrenNode() != null) {            return maxNode(bstNode.getLeftChildrenNode());        }        //不存在左孩子：如果该节点是其父节点的右孩子，则前驱节点为该节点的父节点        //不存在左孩子：如果该节点是其父节点的左孩子，则往上查找最低父节点，该节点必须是其父节点的左孩子        BSTNode<T> parent = bstNode.getParentNode();        while (parent != null && parent.getLeftChildrenNode() == bstNode) {            bstNode = parent;            parent = bstNode.getParentNode();        }        return parent;    }

public BSTNode<T> predecessor(T key) {        BSTNode<T> bstNode = this.find(key);        if (bstNode == null) {            return null;        }else {            return predecessor(bstNode);        }    }

//后继节点    private BSTNode<T> successor(BSTNode<T> bstNode) {        //如果存在右孩子，则为右子树中的最小值        if (bstNode.getRightChildrenNode() != null) {            return minNode(bstNode.getRightChildrenNode());        }

//不存在右孩子：该节点为父节点的右节点，则后继节点为父节点        //不存在右孩子：该节点为父节点的左节点，则往上查找最低的父节点且该节点为父节点的左节点        BSTNode<T> parent = bstNode.getParentNode();        while (parent != null && parent.getRightChildrenNode() == bstNode) {            bstNode = parent;            parent = bstNode.getParentNode();        }        return parent;    }

public BSTNode<T> successor(T key) {        BSTNode<T> node;        BSTNode<T> bstNode = find(key);        if (bstNode == null) {            return null;        }else {            return successor(bstNode);        }    }

}

package tree.bstree;

/** * @Description: TODO * @Auther: Zhang * @Date: 2018/11/5 18:15 */public class MainTest {    public static void main(String[] args) {        BSTNode<Integer> bstNode = new BSTNode<>(5);        BSTree<Integer> bsTree = new BSTree<>(bstNode);        bsTree.insert(4);        bsTree.insert(2);        bsTree.insert(9);        bsTree.find(222);        bsTree.insert(3);        bsTree.delete(2);        bsTree.insert(33);        bsTree.insert(2);        bsTree.preOrder();        bsTree.midOrder();        bsTree.postOrder();        if (bsTree.predecessor(32)!=null){            System.out.println(bsTree.predecessor(32).getKey());        }        System.out.println(bsTree.predecessor(33).getKey());        System.out.println(bsTree.successor(3).getKey());

}}

原文地址：https://www.cnblogs.com/qugemingzihaonan13/p/9914351.html