Question

我正在尝试处理一个方法，该方法将在链接列表中的当前节点之前插入传递给它的节点。它有3个条件。对于此实现，不能有任何头节点（仅对列表中的第一个节点的引用），并且我不能再添加任何变量。

如果列表为空，则将传递的节点设置为列表中的第一个节点。
如果当前节点位于列表的前面。如果是这样，请将传递的节点设置为当前节点旁边的，并将第一个节点设置为传递的节点，将其移动到前面。
如果列表不为空且当前不在前面，则迭代列表，直到本地节点等于列表的当前节点。然后我执行与2中相同的指令。

这是我的代码。

public class LinkedList 
{
private Node currentNode;
private Node firstNode;
private int nodeCount;

public static void main(String[] args)
 {
 LinkedList test;
 String dataTest;
 test = new LinkedList();
 dataTest = "abcdefghijklmnopqrstuvwxyz";
 for(int i=0; i< dataTest.length(); i++) { test.insert(new String(new char[] { dataTest.charAt(i) }));  }
 System.out.println("[1] "+ test);

  for(int i=0; i< dataTest.length(); i++) { test.deleteCurrentNode(); }
  System.out.println("[2] "+test);

  for(int i=0; i< dataTest.length(); i++)
  {
  test.insertBeforeCurrentNode(new String(new char[] { dataTest.charAt(i) }));
   if(i%2 == 0) { test.first(); } else { test.last(); }
  }

  System.out.println("[3] "+test);
 }

public LinkedList()
{
    setListPtr(null);
    setCurrent(null);
    nodeCount = 0;
}

public boolean atEnd()
{
    checkCurrent();
    return getCurrent().getNext() == null;
}

public boolean isEmpty()
{
    return getListPtr() == null;
}

public void first()
{
    setCurrent(getListPtr());
}

public void next()
{
    checkCurrent();
    if (atEnd()) {throw new InvalidPositionInListException("You are at the end of the list. There is no next node. next().");}
    setCurrent(this.currentNode.getNext());
}

public void last()
{
    if (isEmpty()) {throw new ListEmptyException("The list is currently empty! last()");}

    while (!atEnd())
    {
        setCurrent(getCurrent().getNext());
    }

}

public Object getData()
{
    return getCurrent().getData();
}

public void insertBeforeCurrentNode(Object bcNode) //beforeCurrentNode
{
    Node current;
    Node hold;
    boolean done;
    hold = allocateNode();
    hold.setData(bcNode);
    current = getListPtr();
    done = false;
    if (isEmpty())
    {
        setListPtr(hold);
        setCurrent(hold);       
    }

    else if (getCurrent() == getListPtr())
    {
        System.out.println("hi" + hold);
        hold.setNext(getCurrent());
        setListPtr(hold);
    }

    else //if (!isEmpty() && getCurrent() != getListPtr())
    {
        while (!done && current.getNext() != null)
        {
            System.out.println("in else if " + hold);
            if (current.getNext() == getCurrent())
            {
                //previous.setNext(hold);
                //System.out.println("hi"+ "yo" + " " + getListPtr());
                hold.setNext(current.getNext());
                current.setNext(hold);
                done = true; 
            }

            //previous = current;
            current = current.getNext();
        }

    }
    System.out.println(getCurrent());

}

public void insertAfterCurrentNode(Object acNode) //afterCurrentNode
{
    Node hold;
    hold = allocateNode();
    hold.setData(acNode);
    if (isEmpty())
    {
        setListPtr(hold);
        setCurrent(hold);
        //System.out.println(hold + " hi");
    }

    else 
    {
        //System.out.println(hold + " hia");
        hold.setNext(getCurrent().getNext());
        getCurrent().setNext(hold);
    }
}

public void insert(Object iNode)
{
    insertAfterCurrentNode(iNode);
}

public Object deleteCurrentNode()
{
    Object nData;
    Node previous; 
    Node current;
    previous = getListPtr();
    current = getListPtr();
    nData = getCurrent().getData();

    if (isEmpty()) {throw new ListEmptyException("The list is currently empty! last()");}

    else if (previous == getCurrent())
    {
        getListPtr().setNext(getCurrent().getNext());
        setCurrent(getCurrent().getNext());
        nodeCount = nodeCount - 1;
    }

    else 
    {
        while (previous.getNext() != getCurrent())
        {
            previous = current;
            current = current.getNext();


        }
    previous.setNext(getCurrent().getNext());
    setCurrent(getCurrent().getNext());
    nodeCount = nodeCount - 1;  
    }
    return nData;
}

public Object deleteFirstNode(boolean toDelete)
{
    if (toDelete)
    {
        setListPtr(null);
    }
    return getListPtr();
}

public Object deleteFirstNode()
{
    Object deleteFirst;
    deleteFirst = deleteFirstNode(true);
    return deleteFirst;
}

public int size()
{
    return this.nodeCount;
}

public String toString()
{
    String nodeString;
    Node sNode;
    sNode = getCurrent();
    //System.out.println(nodeCount);
    nodeString = ("List contains " + nodeCount + " nodes");
    while (sNode != null)
    {
        nodeString = nodeString + " " +sNode.getData();
        sNode = sNode.getNext();
    }   
    return nodeString;
}

private Node allocateNode()
{
    Node newNode;
    newNode = new Node();
    nodeCount = nodeCount + 1;
    return newNode;
}

private void deAllocateNode(Node dNode)
{
    dNode.setData(null);
}

private Node getListPtr()
{
    return this.firstNode;
}

private void setListPtr(Node pNode)
{
     this.firstNode = pNode;
}

private Node getCurrent()
{
    return this.currentNode;
}

private void setCurrent(Node cNode)
{
    this.currentNode = cNode;
}

private void checkCurrent()
{
    if (getCurrent() == null) {throw new InvalidPositionInListException("Current node is null and is set to an invalid position within the list! checkCurrent()");}
}

/**NODE CLASS ----------------------------------------------*/

    private class Node 
    {
        private Node next; //serves as a reference to the next node 
        private Object data;

        public Node()
        {
            this.next = null;
            this.data = null;
        }


        public Object getData()
        {
            return this.data;
        }

        public void setData(Object obj)
        {
            this.data = obj;
        }

        public Node getNext()
        {
            return this.next;
        }

        public void setNext(Node nextNode)
        {
            this.next = nextNode;
        }

        public String toString()
        {
            String nodeString;
            Node sNode;
            sNode = getCurrent();
            //System.out.println(nodeCount);
            nodeString = ("List contains " + nodeCount + " nodes");
            while (sNode != null)
            {
                nodeString = nodeString + " " +sNode.getData();
                sNode = sNode.getNext();
            }   
            return nodeString;
        }
    }

 }

我让它适用于我的[1]和[2]条件。但我的[3]（测试insertBeforeCurrentNode（））无法正常工作。我已经设置了打印语句，并且我已经确定我的电流在某个地方被重置，但我无法确定哪里可以使用某些指导或解决方案。

[1]和[2]的输出是正确的。 [3]的输出应为

[3]列表包含26个节点：z x v t r p n l j h f d b c e g m k o o s y a y a y

提前感谢您的帮助。

Answer 1

在toString方法中，您开始从 currentNode 打印节点，直到列表末尾。由于您在打印结果之前致电test.last()，因此 currentNode 将指向列表的最后一个节点，而您的toString()只会打印“a”。

在toString()方法中，您可能想要更改

sNode = getCurrent();

带

sNode = getListPtr();

打印26个节点。

Answer 2

对于[3]，您需要保持指向两个节点的指针：“当前”节点中的一个指针，您正在查找的节点，另一个指向“前一个”节点，即当前节点之前的指针。这样，当您找到正在查看“当前”位置的节点时，您可以在“上一个”之后和“当前”之前连接新节点。在伪代码中，并确保案例[1]和[2]之前已被涵盖：

Node previous = null;
Node current = first;
while (current != null && current.getValue() != searchedValue) {
    previous = current;
    current = current.getNext();
}
previous.setNext(newNode);
newNode.setNext(current);

链接列表 - 在当前节点之前插入节点

2 个答案: