我正在编写一个程序，它将接收一组数据，处理它并在链表中对其进行排序。我的问题是，当我查看输出时，当我的myList。检索(0,20));方法第一次调用时，它会打印双倍的内容。第二次删除2个元素后，输出正确
public class Lab9Tester {
public static void main(String args[]){
int testData[] = {5, 2, 7, 8, 3, 6, 10, 2, 6};
int numberOfElementsDeleted = 0;
SortedListOfInt myList = new SortedListOfInt();
for (int i = 0; i < testData.length; i++){
myList.addElement(testData[i]);
}
System.out.println("The values in the sorted list are given below");
System.out.println(myList.retrieve(0, 20));
System.out.println("The values in the sorted list between 4 and 7 are given below");
System.out.println(myList.retrieve(4, 7));
numberOfElementsDeleted = myList.deleteElement(6);
System.out.println("Number of deleted elements is " + numberOfElementsDeleted);
System.out.println("The values in the sorted list after deleting all elements with value 6 are given below");
System.out.println(myList.retrieve(0, 20));
}
}
我的测试程序，当运行时，我期望输出:
The values in the sorted list are given below
2 2 3 5 6 6 7 8 10
The values in the sorted list between 4 and 7 are given below
5 6 6 7
Number of deleted elements is 2
The values in the sorted list after deleting all elements with value 6 are given below
2 2 3 5 7 8 10
然而，第一行值被打印两次作为
2 2 3 5 6 6 7 8 10 2 2 3 5 6 6 7 8 10
我的其他类如下:
public class SortedListOfInt {
ListGeneral myList = new ListGeneral();
private boolean needToRestart = true;
private boolean restartFlag = false;
public void addElement(int x){
if(myList.listIsEmpty())
{
myList.addAfterCurrent(x);
return;
}
if (myList.endOfList())
{
myList.addBeforeCurrent(x);
myList.restart();
return;
}
if (myList.currentValue() != null){
int currentValue = (int) (myList.currentValue());
if(currentValue >= x)
{
myList.addBeforeCurrent(x);
myList.restart();
}
else if(currentValue < x)
{
myList.getNextNode();
addElement(x);
}
}
}
public String retrieve(int lowerLimit, int upperLimit)
{
if(myList.listIsEmpty())
{
return "";
}
if(myList.endOfList() && needToRestart)
{
myList.restart();
needToRestart = false;
return "" + retrieve(lowerLimit, upperLimit);
}
if(myList.endOfList())
{
needToRestart = true;
return "";
}
int currentValue = (int) (myList.currentValue());
if(currentValue >= lowerLimit && currentValue <= upperLimit)
{
String result =currentValue + " " ;
myList.getNextNode();
return result + retrieve(lowerLimit,upperLimit);
}
else
{
myList.getNextNode();
return retrieve(lowerLimit,upperLimit);
}
}
public int deleteElement(int x)
{
repointToStart();
int currentValue;
if(myList.endOfList())
{
restartFlag = false;
return 0;
}
else
{
currentValue = (int) myList.currentValue();
if(currentValue == x)
{
myList.removeCurrent();
return deleteElement(x) + 1;
}
else
{
myList.getNextNode();
return deleteElement(x);
}
}
}
private void repointToStart()
{
if(restartFlag == false)
{
myList.restart();
restartFlag = true;
}
}
}
由教授给出:
public class ListGeneral {
protected Node firstNode; // firstNode can be used by this
// class and any of its subclass.
private Node currentNode, previousNode; // These are usable only
// within this class.
public ListGeneral(){ // Constructor creates an
// empty list.
currentNode = null;
firstNode = null;
previousNode = null;
}
/*
* The method addAfterCurrent adds a new node with value x
* after the current node.
*/
public void addAfterCurrent(Object x){
if (firstNode == null){
firstNode = new Node(x, null);
currentNode = firstNode;
}
else{
Node newNode = new Node(x, currentNode.getNext());
currentNode.setNext(newNode);
previousNode = currentNode;
currentNode = newNode;
}
}
/*
* The method addBeforeCurrent adds a new node with value x
* before the current node.
*/
public void addBeforeCurrent(Object x){
if (firstNode == null){
firstNode = new Node(x, null);
currentNode = firstNode;
}
else {
Node newNode = new Node(x, currentNode);
if (previousNode != null) {
previousNode.setNext(newNode);
}
else{
firstNode = newNode;
}
currentNode = newNode;
}
}
/*
* removeCurrent() deletes the current node. This is defined
* only if the list is not empty.
*/
public void removeCurrent(){
Node temp;
if (listIsEmpty() || endOfList()) return;
temp = currentNode.getNext();
/*
* if previousNode is null, firstNode is currentNode.
*/
if (previousNode == null) {
firstNode = temp;
}
else {
previousNode.setNext(temp);
}
currentNode = currentNode.getNext();
}
/*
* listIsEmpty() is true if list is empty.
* current() returns the current node.
* restart() makes the the first node the current node.
*/
public boolean listIsEmpty(){
return firstNode == null;
}
public Object currentValue(){
return currentNode.getValue();
}
public void restart(){
currentNode = firstNode;
previousNode = null;
}
/* endOfList() is true if current is not pointing to
* any node.
*/
public boolean endOfList(){
return currentNode == null;
}
/* getNextNode makes the next node the current node.
* The method returns true if the operation was successful
* otherwise it returns false.
*/
public boolean getNextNode(){
if (currentNode == null) {
return false;
}
else {
previousNode = currentNode;
currentNode = currentNode.getNext();
return true;
}
}
/*
* method toString() returns the result of invoking toString()
* on all successive elements of the list.
*/
public String toString(){
String s = "";
for(restart(); !endOfList(); getNextNode()){
s += currentValue() + "n";
}
return s;
}
}
As also given:
public class Node {
private Object value; // self-referential link.
private Node next;
public Node(Object value, Node nextNode) // The constructor inserts the
{ // arguments in the new object.
this.value = value;
this.next = nextNode;
}
public Object getValue(){
return value;
}
public Node getNext(){
return next;
}
public void setValue(Object value){
this.value = value;
}
public void setNext(Node next){
this.next = next;
}
}
问题是您在SortedListofInt类中设置needToRestart = true。所以当你做初始检索时，它调用它两次，但是设置needToRestart = false。下次调用检索时，它只打印一次。最初设置needToRestart = false对我来说是有效的，并打印出正确的输出。
这是为我工作
public class SortedListOfInt {
ListGeneral myList = new ListGeneral();
private boolean needToRestart = false;
private boolean restartFlag = false; //the only change
...
}