我是Java编程和实现算法的新手。我试图在Java中实现位置链表，我编写了以下方法，并在向此列表添加新方法时遇到麻烦。add between方法就是为了这个目的，它不能正常工作。你能告诉我addBetween方法有什么问题吗?我该如何完成它?
import Position;
import EmptyListException;
import IllegalValueException;
import InvalidPositionException;
import java.util.Comparator;
import java.util.Iterator;
import java.util.Spliterator;
import java.util.function.Consumer;
public final class LinkedPositionalList<E> implements PositionalList<E> {
private class Node implements Position {
private E element;
private Node next;
private Node before;
protected Node(E element, Node next, Node before) {
this.element = element;
this.next = next;
this.before = before;
}
public void setElement(E element) {
this.element = element;
}
public E getElement() throws IllegalStateException {
if (next == null)
throw new IllegalArgumentException("Position no longer valid");
return element;
}
public Node getBefore() {
return before;
}
public void setBefore(Node before) {
this.before = before;
}
public void setNext(Node next) {
this.next = next;
}
public Node getNext() {
return next;
}
@Override
public Object element() throws InvalidPositionException {
return null;
}
}
private int size = 0;
private Node header;
private Node trailer;
public LinkedPositionalList() {
header = new Node(null, null, null);
trailer = new Node(null, null, header);
header.setNext(trailer);
}
private Node validate(Position<E> p) throws IllegalArgumentException {
Node node = (Node) p;
if (node.getNext() == null)
throw new IllegalArgumentException("p is no longer in the list");
return node;
}
private Node position(Node node) {
if (node == header || node == trailer)
return null;
return node;
}
@Override
public int size() {
return size;
}
@Override
public boolean isEmpty() {
if (size == 0) {
return true;
}
return false;
}
@Override
public void clear() {
size = 0;
header = null;
trailer = null;
}
@Override
public boolean contains(E e) {
Node temp = header;
for (int i = 0; i < size; i++) {
if (temp.element == e) {
return true;
}
temp = temp.next;
}
return false;
}
@Override
public Position<E> first() throws EmptyListException {
if (isEmpty()) {
throw new EmptyListException("List is Empty");
}
System.out.println(header.element);
return (Position<E>) header.element;
}
@Override
public Position<E> last() throws EmptyListException {
if (isEmpty()) {
throw new EmptyListException("List is Empty");
}
return (Position<E>) header.getBefore();
}
@Override
public boolean isFirst(Position<E> p) throws InvalidPositionException {
if (header.getBefore() != null) {
return false;
} else {
return true;
}
}
@Override
public boolean isLast(Position<E> p) throws InvalidPositionException {
if (trailer.getNext() != null) {
return false;
} else {
return true;
}
}
@Override
public Position<E> before(Position<E> p) throws InvalidPositionException {
Node node = validate(p);
return (Position<E>) node.getBefore();
}
@Override
public Position<E> after(Position<E> p) throws InvalidPositionException {
Node node = validate(p);
return (Position<E>) node.getNext();
}
private Position<E> addBetween(E e, Node pred, Node succ) {
Node newest = new Node(e, pred, succ);
pred.setNext(newest);
succ.setBefore(newest);
size++;
return (Position<E>) (newest);
}
@Override
public Position<E> insertFirst(E e) throws IllegalValueException {
if (size > 0){
insertBefore(header,e);
}else {
Node temp = new Node(e, header, null);
header = temp;
size++;
}
return (Position<E>) header;
// return addBetween(e, header, header.getNext());
}
@Override
public Position<E> insertLast(E e) throws IllegalValueException {
Node temp = new Node(e, null, trailer);
trailer = temp;
size++;
return (Position<E>) trailer;
// return addBetween(e, trailer.getBefore(), trailer);
}
@Override
public Position<E> insertBefore(Position<E> p, E e) throws InvalidPositionException, IllegalValueException {
Node node = validate(p);
return addBetween(e, node.getBefore(), node);
}
@Override
public Position<E> insertAfter(Position<E> p, E e) throws InvalidPositionException, IllegalValueException {
Node node = validate(p);
return addBetween(e, node, node.getNext());
}
@Override
public E remove(Position<E> p) throws InvalidPositionException {
Node node = validate(p);
Node predecessor = node.getBefore();
Node successor = node.getNext();
predecessor.setNext(successor);
successor.setBefore(predecessor);
size--;
E answer = node.getElement();
node.setElement(null);
node.setBefore(null);
node.setNext(null);
return answer;
}
@Override
public E replaceElement(Position<E> p, E e) throws InvalidPositionException, IllegalValueException {
Node node = validate(p);
node.setElement(e);
return node.getElement();
}
@Override
public void swapElements(Position<E> p, Position<E> q) throws InvalidPositionException {
}
@Override
public Iterator<Position<E>> positionalIterator() {
return null;
}
@Override
public void sort(Comparator<E> comparator) {
}
@Override
public Position<E> find(E e) {
int counter = 0;
for (Node i = header; counter < size; i = i.next) {
if (e.equals(i)) {
return (Position<E>) e;
}
counter++;
return null;
}return null;
}
@Override
public Iterator<Position<E>> findAll(E e) {
return null;
}
@Override
public Iterator<E> iterator() {
return null;
}
@Override
public void forEach(Consumer<? super E> action) {
PositionalList.super.forEach(action);
}
@Override
public Spliterator<E> spliterator() {
return PositionalList.super.spliterator();
}
}
没有查看整个代码，但是Node的构造函数接收元素、next和before。当您在addBetween中构造新节点时，您发送pred作为next和succ，我假设您的意图与此相反。