TreeNode无法转换为java.lang.Compariable？

我试图编写一个方法，返回指定节点（BST）的父节点，我一直得到以下内容：

TreeNode cannot be cast to java.lang.Comparable

有没有关于如何解决这个问题的建议？谢谢

下面是方法（几乎位于末尾！）-（整个代码）：

import java.util.ArrayList；
导入第27章：抽象树；
公开课考试
扩展抽象树{
保护树根；
受保护的整数大小=0；
/**创建默认的二叉树*/
公开考试（）{
}
/**从对象数组创建二叉树*/
公共测试（E[]对象）{
for（int i=0；i0）{
current=current.right；
}
else//元素与当前的.element匹配
返回true；//找到元素
}
返回false；
}
@Override/**将元素o插入二叉树
*如果成功插入元素，则返回true*/
公共布尔插入（E）{
if（root==null）
root=createNewNode（e）；//创建一个新根
否则{
//找到父节点
TreeNode父节点=null；
TreeNode电流=根；
while（当前！=null）
如果（例如，比较器（当前元素）<0）{
父项=当前；
current=current.left；
}
如果（例如，比较到（当前元素）>0）{
父项=当前；
current=current.right；
}
其他的
返回false；//未插入重复节点
//创建新节点并将其附加到父节点
如果（例如，比较到（父元素）<0）
parent.left=createNewNode（e）；
其他的
parent.right=createNewNode（e）；
}
大小++；
返回true；//插入的元素
}
受保护的TreeNode createNewNode（E）{
返回新的TreeNode（e）；
}
@重写/**以从根进行顺序遍历*/
公共无效序（）{
顺序（根）；
}
/**按顺序从子树进行遍历*/
受保护的空索引（树节点根）{
if（root==null）返回；
顺序（根。左）；
System.out.print（root.element+“”）；
顺序（root.right）；
}
@从根目录重写/**后序遍历*/
公众邮购无效（）{
后序（根）；
}
/**子树的后序遍历*/
受保护的无效邮政订单（TreeNode根目录）{
if（root==null）返回；
后序（根，左）；
postorder（root.right）；
System.out.print（root.element+“”）；
}
@覆盖/**从根目录开始的前序遍历*/
公共无效预订单（）{
前序（根）；
}
/**子树的前序遍历*/
受保护的空预订单（树节点根）{
if（root==null）返回；
System.out.print（root.element+“”）；
前序（根，左）；
前序（root.right）；
}
/**这个内部类是静态的，因为它不访问
在其外部类中定义的任何实例成员*/
公共静态类树节点{
公共电子元素；
公共树节点左；
公共树节点权；
公共树节点父节点；
公共树节点（E）{
元素=e；
}
}
@Override/**获取树中的节点数*/
公共int getSize（）{
返回大小；
}
/**返回树的根*/
公共树节点getRoot（）{
返回根；
}
/**返回从根到指定元素的路径*/
公共java.util.ArrayList路径（E）{
java.util.ArrayList列表=
新的java.util.ArrayList（）；
TreeNode current=root；//从根开始
while（当前！=null）{
list.add（当前）；//将节点添加到列表中
如果（例如，比较器（当前元素）<0）{
current=current.left；
}
如果（例如，比较到（当前元素）>0）{
current=current.right；
}
其他的
打破
}
return list；//返回节点数组
}
@Override/**从二叉树中删除元素。
*如果成功删除元素，则返回true
*如果元素不在树中，则返回false*/
公共布尔删除（E）{
//找到要删除的节点，并找到其父节点
TreeNode父节点=null；
TreeNode电流=根；
while（当前！=null）{
如果（例如，比较器（当前元素）<0）{
父项=当前；
current=current.left；
}
如果（例如，比较到（当前元素）>0）{
父项=当前；
current=current.right；
}
其他的
break；//元素位于当前指向的树中
}
如果（当前==null）
return false；//元素不在树中
//案例1：current没有剩余子级
if（current.left==null）{
//将父节点连接到当前节点的右子节点
如果（父项==null）{
root=current.right；
}
否则{
如果（例如，比较到（父元素）<0）
parent.left=current.right；
其他的
parent.right=current.right；
}
}
否则{
//案例2：当前节点有一个左子节点
//在的左子树中找到最右边的节点
//当前节点及其父节点
最右边的树节点父节点=当前；
TreeNode最右侧=当前。左侧；
while（最右边的.right！=null）{
最右边的父项=最右边的父项；
rightmest=rightmest.right；//继续向右走
}
//用最右边的元件替换当前的元件
current.element=最右边的.element；
//消除最右边的节点
if（最右边的parentOfRight==最右边的）
parentofright.right=最右边的.left；
其他的
//特殊情况：parentOfRightst==当前
parentOfRights.left=最右边的.left；
}
大小--；
返回true；//插入的元素
}
@Override/**获取迭代器。按顺序使用*/
public java.util.Iterator迭代器（）{
返回新的索引编写器（）；
}
//内部类序器
私有类InorderIterator实现java.util.Iterator{
//将元素存储在列表中
私有java.util.ArrayList列表=
新的java.util.ArrayList（）；
private int current=0；//指向列表中的当前元素
公共索引编写器（）{
inoorder（）；//遍历二叉树并将元素存储在列表中
}
/**伊诺
import java.util.ArrayList;
import chapter27.AbstractTree;

public class Test<E extends Comparable<E>> 
extends AbstractTree<E> {
protected TreeNode<E> root;
protected int size = 0;

/** Create a default binary tree */
public Test() {
}

/** Create a binary tree from an array of objects */
public Test(E[] objects) {
for (int i = 0; i < objects.length; i++)
  insert(objects[i]);
}

@Override /** Returns true if the element is in the tree */
public boolean search(E e) {
TreeNode<E> current = root; // Start from the root

while (current != null) {
  if (e.compareTo(current.element) < 0) {
    current = current.left;
  }
  else if (e.compareTo(current.element) > 0) {
    current = current.right;
  }
  else // element matches current.element
    return true; // Element is found
}

return false;
}

@Override /** Insert element o into the binary tree
* Return true if the element is inserted successfully */
public boolean insert(E e) {
if (root == null)
  root = createNewNode(e); // Create a new root
else {
  // Locate the parent node
  TreeNode<E> parent = null;
  TreeNode<E> current = root;
  while (current != null)
    if (e.compareTo(current.element) < 0) {
      parent = current;
      current = current.left;
    }
    else if (e.compareTo(current.element) > 0) {
      parent = current;
      current = current.right;
    }
    else
      return false; // Duplicate node not inserted

  // Create the new node and attach it to the parent node
  if (e.compareTo(parent.element) < 0)
    parent.left = createNewNode(e);
  else
    parent.right = createNewNode(e);
}

size++;
return true; // Element inserted
}

protected TreeNode<E> createNewNode(E e) {
return new TreeNode<E>(e);
}

@Override /** Inorder traversal from the root*/
public void inorder() {
inorder(root);
}

/** Inorder traversal from a subtree */
protected void inorder(TreeNode<E> root) {
if (root == null) return;
inorder(root.left);
System.out.print(root.element + " ");
inorder(root.right);
}

@Override /** Postorder traversal from the root */
public void postorder() {
postorder(root);
}

/** Postorder traversal from a subtree */
protected void postorder(TreeNode<E> root) {
if (root == null) return;
postorder(root.left);
postorder(root.right);
System.out.print(root.element + " ");
}

@Override /** Preorder traversal from the root */
public void preorder() {
preorder(root);
}

/** Preorder traversal from a subtree */
protected void preorder(TreeNode<E> root) {
if (root == null) return;
System.out.print(root.element + " ");
preorder(root.left);
preorder(root.right);
}

/** This inner class is static, because it does not access 
  any instance members defined in its outer class */
    public static class TreeNode<E extends Comparable<E>> {
        public E element;
        public TreeNode<E> left;
        public TreeNode<E> right;
        public TreeNode<E> parent;

        public TreeNode(E e) {
            element = e;
        }
    }

@Override /** Get the number of nodes in the tree */
public int getSize() {
return size;
}

/** Returns the root of the tree */
public TreeNode<E> getRoot() {
return root;
}

/** Returns a path from the root leading to the specified element */
public java.util.ArrayList<TreeNode<E>> path(E e) {
java.util.ArrayList<TreeNode<E>> list =
  new java.util.ArrayList<TreeNode<E>>();
TreeNode<E> current = root; // Start from the root

while (current != null) {
  list.add(current); // Add the node to the list
  if (e.compareTo(current.element) < 0) {
    current = current.left;
  }
  else if (e.compareTo(current.element) > 0) {
    current = current.right;
  }
  else
    break;
}

return list; // Return an array of nodes
}

@Override /** Delete an element from the binary tree.
* Return true if the element is deleted successfully
* Return false if the element is not in the tree */
public boolean delete(E e) {
// Locate the node to be deleted and also locate its parent node
TreeNode<E> parent = null;
TreeNode<E> current = root;
while (current != null) {
  if (e.compareTo(current.element) < 0) {
    parent = current;
    current = current.left;
  }
  else if (e.compareTo(current.element) > 0) {
    parent = current;
    current = current.right;
  }
  else
    break; // Element is in the tree pointed at by current
}

if (current == null)
  return false; // Element is not in the tree

// Case 1: current has no left children
if (current.left == null) {
  // Connect the parent with the right child of the current node
  if (parent == null) {
    root = current.right;
  }
  else {
    if (e.compareTo(parent.element) < 0)
      parent.left = current.right;
    else
      parent.right = current.right;
  }
}
else {
  // Case 2: The current node has a left child
  // Locate the rightmost node in the left subtree of
  // the current node and also its parent
  TreeNode<E> parentOfRightMost = current;
  TreeNode<E> rightMost = current.left;

  while (rightMost.right != null) {
    parentOfRightMost = rightMost;
    rightMost = rightMost.right; // Keep going to the right
  }

  // Replace the element in current by the element in rightMost
  current.element = rightMost.element;

  // Eliminate rightmost node
  if (parentOfRightMost.right == rightMost)
    parentOfRightMost.right = rightMost.left;
  else
    // Special case: parentOfRightMost == current
    parentOfRightMost.left = rightMost.left;     
}

size--;
return true; // Element inserted
}

@Override /** Obtain an iterator. Use inorder. */
public java.util.Iterator<E> iterator() {
return new InorderIterator();
}

// Inner class InorderIterator
private class InorderIterator implements java.util.Iterator<E> {
// Store the elements in a list
private java.util.ArrayList<E> list =
  new java.util.ArrayList<E>();
private int current = 0; // Point to the current element in list

public InorderIterator() {
  inorder(); // Traverse binary tree and store elements in list
}

/** Inorder traversal from the root*/
private void inorder() {
  inorder(root);
}

/** Inorder traversal from a subtree */
private void inorder(TreeNode<E> root) {
  if (root == null)return;
  inorder(root.left);
  list.add(root.element);
  inorder(root.right);
}

@Override /** More elements for traversing? */
public boolean hasNext() {
  if (current < list.size())
    return true;

  return false;
}

@Override /** Get the current element and move to the next */
public E next() {
  return list.get(current++);
}

@Override /** Remove the current element */
public void remove() {
  delete(list.get(current)); // Delete the current element
  list.clear(); // Clear the list
  inorder(); // Rebuild the list
}
}

/** Remove all elements from the tree */
public void clear() {
root = null;
size = 0;
}


public TreeNode<E> getParent(TreeNode<E> node) {
    TreeNode<E> parent = null;
    TreeNode<E> current = root;

    while (current != null) {
        if (((Comparable<E>)node.element).compareTo((E)current.element) < 0) {
            parent = current;
            current = current.left;
        } else if (((Comparable<E>) node.element).compareTo((E)current.element) > 0) {
            parent = current;
            current = current.right;
        } else {
            break;
        }
     }

    size++;
    return parent;

}

public ArrayList<TreeNode<E>> getPath(TreeNode<E> node) {

    return null;

}

    public static void main(String[] args) {

        Integer[] numbers = {2, 4, 3, 1, 8, 5, 6, 7};
        Test<Integer> list = new Test<Integer>(numbers);

        System.out.print("Inorder (sorted): ");
        list.inorder();
        System.out.print("\nPostorder: ");
        list.postorder();
        System.out.print("\nPreorder: ");
        list.preorder();
        System.out.print("\nThe number of nodes is " + list.getSize());
        System.out.print("\nIs 1 in the tree? " + 
                  list.search(1));

        System.out.print("\nA path from the root to 5 is: ");
        java.util.ArrayList<Test.TreeNode<Integer>>  path 
          = list.path(5);
        for (int i = 0; path != null && i < path.size(); i++)
          System.out.print(path.get(i).element + " ");


        TreeNode<Integer> node = new TreeNode<Integer>(5); 
        System.out.print("\nThe parent of " + 5 + ": " + list.getParent(node));

    }
}

       if (((Comparable<E>)node.element).compareTo((E)current) < 0) {

if (((Comparable<E>)node.element).compareTo(current.element) < 0) {

public static class TreeNode<E extends Comparable<E>> {

public static class TreeNode<E extends Comparable<E>> implements Comparable<TreeNode<E>> {

public static class TreeNode<E> implements Comparable<TreeNode<E>> {