Question

我正在编写一个单链列表，当将对象输入列表时，该列表可以按特定字段对对象进行排序。它不是先添加所有内容，然后进行排序，而是在实际添加之前检查要添加的位置。这样，我为三种不同类型的排序列表开发了一个正则表达式。我的问题特别是关于在添加对象时按变量自动对它们进行排序。

private void addDescending(E item)
{
     if(head == null)
     {
          head = new Node<E>(item, null);
          size++;
     }
     else
     {
          Node<E> p = head;
          while(p.next != null)
          {
               if(p.data.compareTo(item) > 0)
               {
                    Node<E> n = findPrev(p);
                    if(n == null)
                    {
                         Node<E> p1 = head;
                         head = new Node<E>(item, p1);
                         size++;
                         break;
                    }
                    n.next = new Node<E>(item, p);
                    size++;
                    break;
               }
          }
     }
}

public int compareTo(Object o)
{
     if(init == ((Person)(o)).getAge())
     {
          return 0;
     }
     else if(init > ((Person)(o)).getAge())
     {
          return 1;
     }
     else
     {
          return -1;
     }
}

compareTo(Object o)方法在Person类中。 findPrev(Node<E> currentNode)类似于双链表中的node.previous。对于我的项目，单链接列表更易于实现。

该访问在该类中是私有的，但是有一个public add(E item)。首先，它检查head是否为null，如果不存在则创建一个。如果头部存在，则与头部进行比较。比较代码在Person类中。

它将检查作为p.data检查的Person，以获取它并将其与要添加的Person对象的年龄进行比较。如果更大，则先行。如果较小，则继续执行。如果介于两者之间，则在较大数字之前和较小数字之前。这意味着磁头可能小于添加的数字，因此，新磁头变成较大的数字，而旧磁头变成下一个。

我主要要添加四个Person对象。他们的年龄分别为3、10、9和6。由于名称不重要，因此它们只是Test1至Test4。由于某种原因，它仅添加第一个对象。在某些情况下，我让它添加了四个对象，但是添加了四个相同的对象，即使这四个对象都不相同。为什么会重复地只添加相同的对象或仅添加单个对象？

编辑：我刚刚重做并更新了代码。现在是addDescending(E item)方法。

private boolean addDescending(E item)
{
    if(head == null)
    {
        head = new Node<E>(item, null);
        size++;
    }
    else
    {
        Node<E> p = head;       
        if(head.next == null && p.data.compareTo(item) > 0)
        {
            p.next = new Node<E>(item, null);
            head = p;
            size++;
            return true;
        }
        else if(head.next == null && p.data.compareTo(item) < 0)
        {
            head.next = new Node<E>(item, null);
            size++;
            return true;
        }

        while(p.next != null && p.data.compareTo(item) < 0)
        {                                       
            if(p.data.compareTo(item) > 0)
            {
                Node<E> n = findPrev(p);
                Node<E> p1 = p.next;
                p.next = new Node<E>(item, p1);
                size++;
                return true;
            }
        p = p.next;
        }
    }
    return false;
}

此代码根据输入的年龄检查每个节点的对象的年龄。如果当前节点对象的年龄大于输入的年龄，它将转到下一个节点，直到找到小于该对象的年龄。然后，它获取上一个和下一个节点，创建一个新节点并将其放置在这两个节点之间。

但是，我的输入仍然是四个Person对象。我要依次添加3、10、9和6岁。

预期结果是最初创建一个对象的age为3的头部，然后加10时10大于3，因此将其添加到头部之前，成为新的头部。将添加6，检查10，由于10大于6，请移至下一个节点。下一个节点3小于6，因此它将在10到3之间添加自己。与9相似，但在10到6之间。

问题是我不太确定的问题。如我所说，我有四个输入。我现在有两个对象，但是它们都是相同的。具有name = "Test1";和age = 3;的对象。除了这两个对象，我看不到其他任何对象，并且可以保证每个对象只能输入一次。

Edit2：这是创建Person对象，列表构造函数的正则表达式，get，get的结果和输出的代码。

构造函数和正则表达式：

public LList(String regex) throws IllegalArgumentException
{
    size = 0;
    this.regex = regex;
    head = null;
    if(!(regex.equals("A") || regex.equals("D") || regex.equals("U")))
    {
        throw new IllegalArgumentException("Unexpected Regex");
    }
}

public void add(E item)
{
    if(regex.equals("D"))
    {
        addDescending(item);
    }
    else if(regex.equals("A"))
    {
        addAscending(item);
    }
    else if(regex.equals("U"))
    {
        addUnsorted(item);
    }
}

获取：

public E get(int index)
{
    int i = 0;
    Node<E> p = head;
    if(index == 0 && head != null)
    {
        return head.data;
    }
    else
    {
        while(p.next != null)
        {
            if(i == index)
            {
                return p.data;
            }
            p = p.next;
            i++;
        }
    }
    return null;
}

主要：

Person ch0 = new Person("Test1", 3);
Person ch1 = new Person("Test2", 10);
Person ch2 = new Person("Test3", 9);
Person ch3 = new Person("Test4", 6);

// Create Descending Order List
System.out.printf("Descending List%n%n");
System.out.printf("%-10s %-4s%n", "Name", "Age");
System.out.printf("%-10s %-4s%n", "----------", "---");

LList<Person> dList = new LList<Person>("D");
dList.add(ch0);
dList.add(ch1);
dList.add(ch2);
dList.add(ch3);


dList.get(0).print();
dList.get(1).print();
dList.get(2).print();
dList.get(3).print();

人员打印方法：

System.out.printf("%-10s %-4d%n", name, age);

感谢所有帮助！

Answer 1

我的2克拉：

private boolean addDescending(E item){
    if(head == null){ //case new list
        head = new Node<E>(item, null);
        size++;
        return true;
    } else if(head.data.compareTo(item)>0){ // case insert befor head
        head = new Node<E>(item, head);
        size++;
        return true; 
    } else {
        Node<E> p; 
        for(p = head;p.next!=null; p=p.next){//compare all except head
           if(p.next.data.compareTo(item) > 0){
              p.next = new Node<E>(item, p.next);
              size++;
              return true;
           }
         }
         //not found: insert at the end
         p.next = new Node<E>(item, null);
         size++;
         return true;
     }
}

在添加到“单个链接列表”时是否按字段自动对对象进行排序？

1 个答案: