private BinaryNodeInterface<T> removeFromRoot(BinaryNodeInterface<T> rootNode) {
if (rootNode.hasLeftChild() && rootNode.hasRightChild()) { // 当待删结点即有左孩子又有右孩子时
BinaryNodeInterface<T> leftSubtreeRoot =
rootNode.getLeftChild(); // 某结点的前驱结点的值为其左子树中结点的最大值,因而先获取其左子树的根结点
BinaryNodeInterface<T> largestNode = findLargest(leftSubtreeRoot); // 寻找待删结点的前驱结点
rootNode.setData(largestNode.getData()); // 将待删结点的值替换为其前驱结点的值
rootNode.setLeftChild(removeLargest(leftSubtreeRoot)); // 删除其前驱结点
}
// 待删结点只有一个孩子时
else if (rootNode.hasRightChild()) // 待删结点只有一个右孩子时
rootNode = rootNode.getRightChild(); // 直接删除该结点，即将其右孩子覆盖它
else // 待删结点只有一个左孩子(或者没有孩子时)
rootNode = rootNode.getLeftChild();
return rootNode; // 返回的是待删除后的(子)树的根结点
}
// 插入新元素的迭代方法实现
private T addEntry(T newEntry) {
BinaryNodeInterface<T> currentNode = getRootNode();
assert currentNode != null; // 根结点为空的情况已经在add()中处理
T result = null;
boolean found = false; // 用来标记待插入的元素是否已经在树中
while (!found) {
T currentEntry = currentNode.getData();
int comparison = newEntry.compareTo(currentEntry);
if (comparison == 0) { // 待插入的元素在树中"已存在"(根据compareTo()来决定)
found = true; // 待插入的元素已经找到了位置，不需要再while循环了
result = currentEntry; // 将树中的旧元素数据域赋值给result，由result返回
currentNode.setData(newEntry); // 将新的数据域替换掉旧的数据域
} else if (comparison < 0) { // 待插入的结点值比当前结点值要小
if (currentNode.hasLeftChild()) // 判断当前结点是否有左孩子
// 在下一轮while中，需要将待插入结点与其左孩子比较
currentNode = currentNode.getLeftChild();
else { // 若没有左孩子，则说明待插入的结点的位置即为currentNode的左孩子
found = true; // 因而将found设为true，不需要再进行循环了
// 已经找到插入的位置了，下面语句即将结点插入。整个插入过程就完成了
currentNode.setLeftChild(new BinaryNode<T>(newEntry));
}
} else {
assert comparison > 0;
if (currentNode.hasRightChild()) currentNode = currentNode.getRightChild();
else {
found = true;
currentNode.setRightChild(new BinaryNode<T>(newEntry));
}
}
} // end while
return result;
}
/*
* @Task: 在指定树中删除含最大元素的结点
* @param rootNode 树的根结点
* @return 修改后的树的根结点
* 用迭代怎么来实现？？？？
*/
private BinaryNodeInterface<T> removeLargest(BinaryNodeInterface<T> rootNode) {
if (rootNode.hasLeftChild()) {
BinaryNodeInterface<T> rightChild = rootNode.getRightChild();
BinaryNodeInterface<T> root = removeLargest(rightChild);
rootNode.setRightChild(root);
} else rootNode = rootNode.getLeftChild();
return rootNode;
}
private T findEntry(BinaryNodeInterface<T> rootNode, T entry) {
T result = null;
if (rootNode != null) {
T rootEntry = rootNode.getData();
// if(entry.compareTo(rootEntry) == 0)
if (entry.equals(rootEntry)) result = rootEntry;
else if (entry.compareTo(rootEntry) < 0)
// 理解这里的递归调用的返回值，result不为空的唯一情况是equals()为真
result = findEntry(rootNode.getLeftChild(), entry);
else result = findEntry(rootNode.getRightChild(), entry);
}
return result;
}
/*由于remove()方法可以删除根结点，因此须保留一个指向树的根的引用
* 因而让removeEntry()返回删除结点后的树的根结点,该树根就可以用remove()来保存了
* 但是，remove()方法删除结点时，它需要返回待删除的结点的值，而具体执行删除操作的removeEntry()返回的是新的树根
* 因此，需要一个内部类ReturnObject来获取被删除结点的值
*/
private BinaryNodeInterface<T> removeEntry(
BinaryNodeInterface<T> rootNode, T entry, ReturnObject oldEntry) {
if (rootNode != null) {
T rootData = rootNode.getData();
int comparison = entry.compareTo(rootData);
if (comparison == 0) { // 找到了待删除的结点，它相当于"根结点"
// 将其对应的数据域放到oldEntry的entry属性中，而在remove方法中调用oldEntry的get方法会得到它
oldEntry.set(rootData);
rootNode = removeFromRoot(rootNode);
} // end if
else if (comparison < 0) { // 待删结点在当前结点的左子树中
BinaryNodeInterface<T> leftChild = rootNode.getLeftChild();
// 递归调用说明：真正删除结点的操作是从树根开始直至找到该结点(相当于找到了以待删结点为根的子树)然后调用removeFromRoot方法进行删除
BinaryNodeInterface<T> subtreeRoot = removeEntry(leftChild, entry, oldEntry);
rootNode.setLeftChild(subtreeRoot); // ???
} else { // 待删结点在当前结点的右子树中
BinaryNodeInterface<T> rightChild = rootNode.getRightChild();
BinaryNodeInterface<T> subtreeRoot = removeEntry(rightChild, entry, oldEntry);
rootNode.setRightChild(subtreeRoot); // ???
}
} // end if
return rootNode;
}
private T addEntry(BinaryNodeInterface<T> rootNode, T newEntry) {
assert rootNode != null;
T result = null;
// 将根结点和待插入的结点进行比较
int comprasion = newEntry.compareTo(rootNode.getData());
/*
* 如果将一个与树中某个元素相匹配的元素插入树时 将新元素替换旧元素，并返回旧元素。其实这样做，是为了保证插入的完整性
* 即相当于，给定一个元素，它总能插入成功。 如果待插入的元素不在树中，插入成功，并返回null
*/
if (comprasion == 0) {
result = rootNode.getData();
rootNode.setData(newEntry);
} else if (comprasion < 0) {
if (rootNode.hasLeftChild())
// 递归调用.注意调用的result的返回值
result = addEntry(rootNode.getLeftChild(), newEntry);
else rootNode.setLeftChild(new BinaryNode<T>(newEntry));
} else {
assert comprasion > 0;
if (rootNode.hasRightChild()) result = addEntry(rootNode.getRightChild(), newEntry);
else rootNode.setRightChild(new BinaryNode<T>(newEntry));
}
return result;
}