0

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

  1. 如果列表为空，则将传递的节点设置为列表中的第一个节点。
  2. 如果当前节点在列表的前面。如果是，则将传递的节点的 next 设置为当前节点，并将第一个节点设置为传递的节点以将其移动到前面。
  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 个节点：zxvtrpnljhfdbcegikmoq suwya

感谢您提前提供任何帮助。

4

2 回答 2

2

在您的toString方法中，您开始打印从currentNode到列表末尾的节点。因为您test.last()在打印结果之前调用，currentNode将指向列表的最后一个节点，并且您toString()只会打印“a”。

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

sNode = getCurrent();

和

sNode = getListPtr();

打印您的 26 个节点。

于 2011-11-07T16:07:54.953 回答
0

对于 [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);
于 2011-11-07T16:10:27.000 回答