Java 在按顺序排列的LinkedList节点之间添加元素

我在这个网站上查询了搜索引擎，但是我没有看到任何与我所寻找的匹配的东西，所以我希望这个问题还没有在其他地方得到回答。我正在尝试完善我的添加方法，以获得一个有序的LinkedList。程序的其余部分运行良好，当列表按照测试线束中的指定打印出来时，我希望对名称进行排序

在多次调用添加和删除线束后，我的输出如下：

Sue, Bill, Michael, Someguy, Michael, Carl, Steve, Carl, Sue
Sue, Bill, Someguy, Michael, Steve, Carl, Sue
Sue, Bill, Someguy, Michael, Steve, Carl, Sue, Sue, Bill

我想要的是： 苏，苏，比尔，迈克尔，迈克尔，卡尔，卡尔，史蒂夫等等

我的添加方法：

 public boolean add(Comparable obj)
{
    OrderedListNode newNode = new OrderedListNode(obj, null, null);
    if( tail == null) {
    tail = newNode;
    head = tail;
    modCount++;
    return true;

    }
    if(((Comparable)(head.theItem)).equals(obj)){
        tail.previous = newNode;
        modCount++;
        return true;
    }else{


    tail.previous.next = newNode;
    newNode.previous = tail.previous;
    newNode.next = tail;
    tail.previous = newNode;
    modCount++;
    return true;
    }
}

整个代码，因为它被要求：

package dataStructures;


public class OrderedLinkedList
{

/**************************************************************************
 * Constants
 *************************************************************************/

/** return value for unsuccessful searches */
private static final OrderedListNode NOT_FOUND = null;


/**************************************************************************
 * Attributes
 *************************************************************************/

/** current number of items in list */
private int theSize;

/** reference to list header node */
private OrderedListNode head;

/** reference to list tail node */
private OrderedListNode tail;

/** current number of modifications to list */
private int modCount;


/**************************************************************************
 * Constructors
 *************************************************************************/


/**
 *  Create an instance of OrderedLinkedList.
 *
 */
public OrderedLinkedList()
{
    // empty this OrderedLinkedList
    clear();
}


/**************************************************************************
 * Methods
 *************************************************************************/


/*
 *  Add the specified item to this OrderedLinkedList.
 *
 *  @param  obj     the item to be added
 */
public boolean add(Comparable obj)
{
    OrderedListNode newNode = new OrderedListNode(obj, null, null);
    if( tail == null) {
    tail = newNode;
    head = tail;
    modCount++;
    return true;

    }
    if(((Comparable)(head.theItem)).compareTo(obj) > 0){
        ////////////////////////////////////////
        //here is where my problem lies, I believe
        /////////////////////////////////////////
        modCount++;
        return true;
    }else{


    tail.previous.next = newNode;
    newNode.previous = tail.previous;
    newNode.next = tail;
    tail.previous = newNode;
    modCount++;
    return true;
    }
}

/*
 *  Remove the first occurrence of the specified item from this OrderedLinkedList.
 *
 *  @param  obj     the item to be removed
 */
public boolean remove(Comparable obj)
{
    if(head == null) return false;
    if(((Comparable)(head.theItem)).compareTo(obj) == 0) {
    if(head == tail) {
        head = tail = null;
        return true;
    }
    head = head.next;
    return true;
    }

    if(head == tail)return false;
    OrderedListNode ref = head;
    while( ref.next != tail) {
        if(((Comparable)(ref.next.theItem)).compareTo(obj) == 0) {
            ref.next = ref.next.next;
            return true;
        }
        ref = ref.next;
    }
    if(((Comparable)(tail.theItem)).compareTo(obj) == 0 ) {
        tail = ref;
        tail.next = null;
        return true;
    }

    return false;

}


/**
 *  Empty this OrderedLinkedList.
 */
public void clear()
{
    // reset header node
    head = new OrderedListNode("HEAD", null, null);

    // reset tail node
    tail = new OrderedListNode("TAIL", head, null);

    // header references tail in an empty LinkedList
    head.next = tail;

    // reset size to 0
    theSize = 0;

    // emptying list counts as a modification
    modCount++;
}


/**
 *  Return true if this OrderedLinkedList contains 0 items.
 */
public boolean isEmpty()
{
    return theSize == 0;
}


/**
 *  Return the number of items in this OrderedLinkedList.
 */
public int size()
{
    return theSize;
}


/*  
 *  Return a String representation of this OrderedLinkedList.
 *
 *  (non-Javadoc)
 *  @see java.lang.Object#toString()
 */
@Override
public String toString()
{
    String s = "";

    OrderedListNode currentNode = head.next;

    while (currentNode != tail)
    {
        s += currentNode.theItem.toString();

        if (currentNode.next != tail)
        {
            s += ", ";
        }

        currentNode = currentNode.next;
    }

    return s;
}

private static class OrderedListNode<Comparable> {

    Comparable theItem;
    OrderedListNode<Comparable> next;
    OrderedListNode<Comparable> previous;

    public OrderedListNode(Comparable theItem, OrderedListNode<Comparable> previous, OrderedListNode<Comparable> next) {
        this.theItem = theItem;
        this.next = next;
        this.previous = previous;
    }

}

包数据结构；
公共类OrderedLinkedList
{
/**************************************************************************
*常数
*************************************************************************/
/**未成功搜索的返回值*/
私有静态最终OrderedListNode未找到=null；
/**************************************************************************
*属性
*************************************************************************/
/**列表中的当前项目数*/
私人住宅；
/**对列表头节点的引用*/
私有OrderedListNode头；
/**对列表尾部节点的引用*/
私有OrderedListNode尾部；
/**对列表的当前修改次数*/
私有int modCount；
/**************************************************************************
*建设者
*************************************************************************/
/**
*创建OrderedLinkedList的实例。
*
*/
公共OrderedLinkedList（）
{
//清空此OrderedLinkedList
清除（）；
}
/**************************************************************************
*方法
*************************************************************************/
/*
*将指定的项添加到此OrderedLinkedList。
*
*@param obj要添加的项目
*/
公共布尔加法（可比obj）
{
OrderedListNode newNode=新OrderedListNode（obj，null，null）；
if（tail==null）{
tail=newNode；
头=尾；
modCount++；
返回true；
}
如果（（（可比）（总利润项目））。与（目标）相比>0）{
////////////////////////////////////////
//我相信这就是我的问题所在
/////////////////////////////////////////
modCount++；
返回true；
}否则{
tail.previous.next=newNode；
newNode.previous=tail.previous；
newNode.next=tail；
tail.previous=newNode；
modCount++；
返回true；
}
}
/*
*从此OrderedLinkedList中删除指定项的第一个匹配项。
*
*@param obj要删除的项目
*/
公共布尔删除（类似obj）
{
if（head==null）返回false；
如果（（可比）（head.item））.compareTo（obj）==0{
如果（头=尾）{
头=尾=空；
返回true；
}
head=head.next；
返回true；
}
if（head==tail）返回false；
OrderedListNode ref=头；
while（参考下一步！=尾部）{
如果（（（可比）（参考下一个ITEEM））.compareTo（obj）==0{
ref.next=ref.next.next；
返回true；
}
ref=ref.next；
}
如果（（可比）（tail.itItem））.compareTo（obj）==0{
尾=参考；
tail.next=null；
返回true；
}
返回false；
}
/**
*清空此OrderedLinkedList。
*/
公共空间清除（）
{
//重置头节点
head=新OrderedListNode（“head”，null，null）；
//重置尾部节点
tail=新OrderedListNode（“tail”，head，null）；
//标头引用空LinkedList中的尾部
head.next=tail；
//将大小重置为0
大小=0；
//清空列表视为修改
modCount++；
}
/**
*如果此OrderedLinkedList包含0项，则返回true。
*/
公共布尔值为空（）
{
返回大小==0；
}
/**
*返回此OrderedLinkedList中的项数。
*/
公共整数大小（）
{
返回大小；
}
/*  
*返回此OrderedLinkedList的字符串表示形式。
*
*（非Javadoc）
*@see java.lang.Object#toString（）
*/
@凌驾
公共字符串toString（）
{
字符串s=“”；
OrderedListNode currentNode=head.next；
while（currentNode！=尾部）
{
s+=currentNode.ItItem.toString（）；
if（currentNode.next！=tail）
{
s+=“，”；
}
currentNode=currentNode.next；
}
返回s；
}
私有静态类OrderedListNode{
可比利润；
OrderedListNode下一步；
OrderedListNode-previous；
public OrderedListNode（上一个、下一个OrderedListNode）{
this.iteem=iteem；
this.next=next；
this.previous=先前；
}
}

---

}

这句话肯定是错的

if(((Comparable)(head.theItem)).equals(obj)) {

您应该使用Comparable.compareTo，此外，您应该始终从head开始，直到找到一个大于或等于obj的元素，并在其前面插入obj，类似这样

public boolean add(Comparable obj) {
    modCount++;
    if (head == null) {
        head = new OrderedListNode(obj, null, null);
        return true;
    }
    for (OrderedListNode current = head; current != null; current = current.next) {
        if (((Comparable) (current.theItem)).compareTo(obj) >= 0) {
            current.prev = new OrderedListNode(obj, current.prev, current);
            return true;
        }
    }
    tail.next = new OrderedListNode(obj, tail, null);
    return true;
}

---

仅仅看一种方法是不可能理解的。请添加足够的代码以查看输出是如何形成的。也不清楚你的“我想把名字分类”到底是什么意思。不确定这是否有助于只打印出头部，但我会仔细研究一下。谢谢，我想获取新节点，并将其分配给比较对象后的下一个节点，如果它们相同，对吗？我看得对吗？我想做的是在添加项时对它们进行排序，所以我不应该将它们作为相等项进行比较吗？为什么要使用>0运算符？我这样问是因为我不知道，而不是因为我在和你争论。所有对象都从

Object

继承相等的值，你可以覆盖它。如果您特别使用

Comparable

界面，您应该使用它提供的方法（

compareTo

）。我认为您应该始终从头开始，直到找到一个元素w