Den Rest hast du auch gelesen?Du hast das falsch gelesen,
mihe lag richtig...
Den Rest hast du auch gelesen?Du hast das falsch gelesen,
mihe lag richtig...
Du hast das falsch gelesen,
mihe lag richtig...
class LinkedSetIterator implements Iterator<T> {
Cell current;
LinkedSetIterator() {
current = anchor;
}
@Override
public boolean hasNext() {
return (current.succ != anchor);
}
public T next() {
if (hasNext()) {
T next = (T) current.value;
current = current.succ;
return next;
}
throw new IllegalStateException("No more elements");
}
public boolean remove(Object x) {
while(hasNext()) {
Object next = next();
if(x.equals(next)) {
this.next();
this.remove();
return true;
}
}
return false;
}
public void remove() {
current.pred.pred.succ = current;
current.pred = current.pred.pred;
}
}
Nein, noch nicht....Wäre dort die remove(Object) Methode nun richtig
Ne, ein Iterator braucht nur remove(). Die sieht aber passend aus.Wäre dort die remove(Object) Methode nun richtig?
Ja, das ist richtig. Und sorry - hatte nicht gesehen, dass da ja noch mehr Antworten auf einer weiteren Seite waren. Das Thema war ja bereits soweit abgehandelt...Aber jetzt müsst ihr mir mal helfen, eine binäre Suche ist aufgrund der Verlinkungen nicht möglich oder? Man bleibt also so oder so bei O(n) beim Entfernen oder?
next und hasNext und der initialwert von current passen einfach nicht zusammen.wieso ist hasNext() Falsch? ich Frage doch ab ob der current.zeiger != anchor ist. Wie sollte er sonst aussehen?
Und bei Next() was ist dort Falsch?
public Iterator<T> iterator() {
return new Iterator<T>() {
Cell a = anchor;
boolean b = true;
@Override
public boolean hasNext() {
if (b && a.succ == anchor) {
b = false;
return a.value != null;
}
return b && a.value != null;
}
@Override
public T next() {
T t = (T) a.value;
a = a.succ;
return t;
}
@Override
public void remove() {
a.pred.pred.succ = a;
a.pred = a.pred.pred;
}
};
}
Das „aktuelle“ Element ist dabei nicht a, sondern a.predBei der Implementation, die Tobias jetzt eben noch mal gebracht hat, scheint das remove aber nicht korrekt zu sein. Das remove() der Iterator-Implementation soll das current Element löschen. Das bedeutet, dass danach das aktuelle Element (da "a" genannt) nicht mehr referenziert ist.
Ohh, stimmt. Hatte ich jetzt übersehen. Wenn man selbst eine andere Implementierung vor sich hat, dann vertut man sich da leicht ... (Ein Grund für sprechende Namen, so dass man weiß, was man vor sich hat.)Das „aktuelle“ Element ist dabei nicht a, sondern a.pred
import java.lang.reflect.Array;
import java.util.Collection;
import java.util.Comparator;
import java.util.Iterator;
import java.util.SortedSet;
import java.util.StringJoiner;
public class LinkedSet<T extends Comparable<T>> implements SortedSet<T> {
public static void main(String[] args) {
LinkedSet<Integer> s = new LinkedSet<>();
System.out.println(iterToString(s.iterator()));
for (int i = 0; i < 10; i++) {
s.add((int) (Math.random() * 5.0));
System.out.println(iterToString(s.iterator()));
}
s.clear();
System.out.println(iterToString(s.iterator()));
for (int i = 0; i < 10; i++) {
s.add((int) (Math.random() * 5.0));
System.out.println(iterToString(s.iterator()));
}
}
public static String iterToString(Iterator<?> i) {
StringJoiner j = new StringJoiner("; ");
j.setEmptyValue("");
while (i.hasNext())
j.add(i.next().toString());
return j.toString();
}
private class Cell {
Object value;
Cell pred, succ;
}
private Cell anchor;
public LinkedSet() {
anchor = new Cell();
anchor.pred = anchor;
anchor.succ = anchor;
}
public Iterator<T> iterator() {
return new Iterator<T>() {
Cell a = anchor;
boolean b = true;
@Override
public boolean hasNext() {
if (b && a.succ == anchor) {
b = false;
return a.value != null;
}
return b && a.value != null;
}
@Override
public T next() {
@SuppressWarnings("unchecked")
T t = (T) a.value;
a = a.succ;
return t;
}
@Override
public void remove() {
if (size() == 1) {
a.value = null;
a.pred = a;
a.succ = a;
} else if (a == anchor) {
anchor = a.succ;
a.pred.pred.succ = a;
a.pred = a.pred.pred;
} else {
a.pred.pred.succ = a;
a.pred = a.pred.pred;
}
}
};
}
@SuppressWarnings("unchecked")
public boolean add(T e) {
if (e == null) {
throw new NullPointerException();
}
if (isEmpty()) {
anchor.value = e;
} else if (contains(e)) {
return false;
} else if (((Comparable<T>) e).compareTo((T) anchor.value) < 0) {
anchor = insertBefore(anchor, e);
} else {
Cell current = anchor.succ;
while (current != anchor && ((Comparable<T>) current.value).compareTo(e) < 0) {
current = current.succ;
}
insertBefore(current, e);
}
return true;
}
private Cell insertBefore(Cell cell, T e) {
Cell result = new Cell();
result.value = e;
result.pred = cell.pred;
result.succ = cell;
cell.pred.succ = result;
cell.pred = result;
return result;
}
@Override
public boolean addAll(Collection<? extends T> c) {
for (T t : c) {
add(t);
}
return true;
}
@Override
public void clear() {
anchor.pred = anchor;
anchor.succ = anchor;
anchor.value = null;
}
@Override
public boolean contains(Object o) {
Iterator<T> i = iterator();
while (i.hasNext())
if (i.next().equals(o))
return true;
return false;
}
@Override
public boolean containsAll(Collection<?> c) {
for (Object o : c) {
if (!contains(o))
return false;
}
return true;
}
@Override
public boolean isEmpty() {
return anchor.value == null;
}
@SuppressWarnings("unchecked")
@Override
public boolean remove(Object o) {
Iterator<T> i = iterator();
while (i.hasNext())
if (i.next().compareTo((T) o) == 0) {
i.remove();
return true;
}
return false;
}
@Override
public boolean removeAll(Collection<?> c) {
for (Object o : c) {
if (!remove(o)) {
return false;
}
}
return true;
}
@Override
public boolean retainAll(Collection<?> c) {
// TODO Auto-generated method stub
return false;
}
@Override
public int size() {
if (isEmpty())
return 0;
int s = 0;
Iterator<?> i = iterator();
while (i.hasNext()) {
s++;
i.next();
}
return s;
}
@Override
public Object[] toArray() {
Object[] a = new Object[size()];
int j = 0;
Iterator<T> i = iterator();
while (i.hasNext())
a[j++] = i.next();
return a;
}
@SuppressWarnings({ "hiding", "unchecked" })
@Override
public <T> T[] toArray(T[] a) {
T[] b = (T[]) Array.newInstance(a.getClass().getComponentType(), size());
int j = 0;
Iterator<T> i = (Iterator<T>) iterator();
while (i.hasNext())
b[j++] = i.next();
return b;
}
@Override
public Comparator<? super T> comparator() {
return (T a, T b) -> a.compareTo(b);
}
@SuppressWarnings("unchecked")
@Override
public T first() {
return (T) anchor.value;
}
@Override
public SortedSet<T> headSet(T arg0) {
// TODO Auto-generated method stub
return null;
}
@SuppressWarnings("unchecked")
@Override
public T last() {
return (T) anchor.pred.value;
}
@Override
public SortedSet<T> subSet(T fromElement, T toElement) {
// TODO Auto-generated method stub
return null;
}
@Override
public SortedSet<T> tailSet(T fromElement) {
// TODO Auto-generated method stub
return null;
}
}
import static org.junit.jupiter.api.Assertions.*;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;
import java.util.Comparator;
import java.util.Iterator;
import java.util.Random;
import org.junit.jupiter.api.AfterEach;
import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.Test;
class LinkedSetTest {
LinkedSet<Integer> set = null;
@BeforeEach
void setUp() throws Exception {
set = new LinkedSet<Integer>();
}
@AfterEach
void tearDown() throws Exception {
set.clear();
set = null;
}
@Test
void testMain() {
LinkedSet.main(null);
}
@Test
void testIterToString() {
testAdd();
Iterator<Integer> i = set.iterator();
assertNotNull(i);
String s = LinkedSet.iterToString(i);
assertNotNull(s);
System.out.println(s);
}
@Test
void testLinkedSet() {
assertNotNull(set);
}
@Test
void testIterator() {
Iterator<Integer> i = set.iterator();
assertNotNull(i);
assertFalse(i.hasNext());
assertTrue(set.add(new Random().nextInt(5)));
i = set.iterator();
assertNotNull(i);
assertTrue(i.hasNext());
}
@Test
void testAdd() {
ArrayList<Integer> l = new ArrayList<>();
for (int i = 0; i < 12; i++) {
l.add(i);
}
for (int j = 0; j < 12; j++) {
set.clear();
assertTrue(set.isEmpty());
Collections.shuffle(l);
for (int i = 0; i < 12; i++) {
assertTrue(set.add(l.get(i)));
assertFalse(set.isEmpty());
}
}
}
@Test
void testAddAll() {
assertTrue(set.addAll(Arrays.asList(4, 2, 3)));
assertEquals("2; 3; 4", LinkedSet.iterToString(set.iterator()));
}
@Test
void testClear() {
set.clear();
assertTrue(set.isEmpty());
}
@Test
void testContains() {
assertTrue(set.add(2));
assertTrue(set.contains(2));
}
@Test
void testContainsAll() {
assertTrue(set.addAll(Arrays.asList(4, 2, 3)));
assertTrue(set.containsAll(Arrays.asList(2, 3, 4)));
assertEquals("2; 3; 4", LinkedSet.iterToString(set.iterator()));
}
@Test
void testIsEmpty() {
assertTrue(set.isEmpty());
assertTrue(set.add(1));
assertFalse(set.isEmpty());
}
@Test
void testRemove() {
assertFalse(set.remove(2));
assertTrue(set.add(2));
assertTrue(set.remove(2));
assertFalse(set.remove(3));
}
@Test
void testRemoveAll() {
assertTrue(set.addAll(Arrays.asList(4, 2, 3)));
assertEquals("2; 3; 4", LinkedSet.iterToString(set.iterator()));
assertTrue(set.removeAll(Arrays.asList(2, 3, 4)));
assertEquals("", LinkedSet.iterToString(set.iterator()));
}
@Test
void testRetainAll() {
fail("Not yet implemented");
}
@Test
void testSize() {
assertTrue(set.addAll(Arrays.asList(4, 2, 3)));
assertEquals(3, set.size());
assertEquals("2; 3; 4", LinkedSet.iterToString(set.iterator()));
}
@Test
void testToArray() {
assertNotNull(set.toArray());
assertTrue(set.addAll(Arrays.asList(4, 2, 3)));
assertNotNull(set.toArray());
assertEquals("2; 3; 4", LinkedSet.iterToString(set.iterator()));
}
@Test
void testToArrayTArray() {
assertNotNull(set.toArray(new Integer[0]));
assertTrue(set.addAll(Arrays.asList(4, 2, 3)));
assertEquals(3, set.toArray(new Integer[0]).length);
assertEquals(Integer[].class, set.toArray(new Integer[0]).getClass());
assertEquals("2; 3; 4", LinkedSet.iterToString(set.iterator()));
}
@Test
void testComparator() {
assertTrue(set.comparator() instanceof Comparator<?>);
}
@Test
void testFirst() {
assertTrue(set.addAll(Arrays.asList(4, 2, 3)));
assertEquals(2, set.first());
assertEquals("2; 3; 4", LinkedSet.iterToString(set.iterator()));
}
@Test
void testHeadSet() {
fail("Not yet implemented");
}
@Test
void testLast() {
assertTrue(set.addAll(Arrays.asList(4, 2, 3)));
assertEquals(4, set.last());
assertEquals("2; 3; 4", LinkedSet.iterToString(set.iterator()));
}
@Test
void testSubSet() {
fail("Not yet implemented");
}
@Test
void testTailSet() {
fail("Not yet implemented");
}
}
Das widerspricht sich doch....die Tests werden grün, aber die Methoden removeAll() und iterToString() halten nicht mehr an
Mindestens der nicht-anhaltende Test sollte nicht grün werden?UNd glaub mir, das ist Eclipse... und das kann auch nicht anhalten, wenngleich alle Tests "grün" werden.
@Override
public void remove() {
if (size() == 1) {
a.value = null;
a.pred = a;
a.succ = a;
} else {
if (a.pred == anchor) {
anchor = a;
}
a.pred.pred.succ = a;
a.pred = a.pred.pred;
}
}
import java.lang.reflect.Array;
import java.util.Collection;
import java.util.Comparator;
import java.util.Iterator;
import java.util.SortedSet;
import java.util.StringJoiner;
public class LinkedSet<T extends Comparable<T>> implements SortedSet<T> {
public static void main(String[] args) {
LinkedSet<Integer> s = new LinkedSet<>();
System.out.println(iterToString(s.iterator()));
for (int i = 0; i < 10; i++) {
s.add((int) (Math.random() * 5.0));
System.out.println(iterToString(s.iterator()));
}
s.clear();
System.out.println(iterToString(s.iterator()));
for (int i = 0; i < 10; i++) {
s.add((int) (Math.random() * 5.0));
System.out.println(iterToString(s.iterator()));
}
}
public static String iterToString(Iterator<?> i) {
StringJoiner j = new StringJoiner("; ");
j.setEmptyValue("");
while (i.hasNext())
j.add(i.next().toString());
return j.toString();
}
private class Cell {
Object value;
Cell pred, succ;
}
private Cell anchor;
public LinkedSet() {
anchor = new Cell();
anchor.pred = anchor;
anchor.succ = anchor;
}
public Iterator<T> iterator() {
return new Iterator<T>() {
Cell a = anchor;
boolean b = true;
@Override
public boolean hasNext() {
if (b && a.succ == anchor) {
b = false;
return a.value != null;
}
return b && a.value != null;
}
@SuppressWarnings("unchecked")
@Override
public T next() {
T t = (T) a.value;
a = a.succ;
return t;
}
@Override
public void remove() {
if (size() == 1) {
a.value = null;
a.pred = a;
a.succ = a;
} else {
if (a.pred == anchor) {
anchor = a;
}
a.pred.pred.succ = a;
a.pred = a.pred.pred;
}
}
};
}
@SuppressWarnings("unchecked")
public boolean add(T e) {
if (e == null) {
throw new NullPointerException();
}
if (isEmpty()) {
anchor.value = e;
} else if (contains(e)) {
return false;
} else if (((Comparable<T>) e).compareTo((T) anchor.value) < 0) {
anchor = insertBefore(anchor, e);
} else {
Cell current = anchor.succ;
while (current != anchor && ((Comparable<T>) current.value).compareTo(e) < 0) {
current = current.succ;
}
insertBefore(current, e);
}
return true;
}
private Cell insertBefore(Cell cell, T e) {
Cell result = new Cell();
result.value = e;
result.pred = cell.pred;
result.succ = cell;
cell.pred.succ = result;
cell.pred = result;
return result;
}
@Override
public boolean addAll(Collection<? extends T> c) {
for (T t : c) {
add(t);
}
return true;
}
@Override
public void clear() {
anchor.pred = anchor;
anchor.succ = anchor;
anchor.value = null;
}
@Override
public boolean contains(Object o) {
Iterator<T> i = iterator();
while (i.hasNext())
if (i.next().equals(o))
return true;
return false;
}
@Override
public boolean containsAll(Collection<?> c) {
for (Object o : c) {
if (!contains(o))
return false;
}
return true;
}
@Override
public boolean isEmpty() {
return anchor.value == null;
}
@SuppressWarnings("unchecked")
@Override
public boolean remove(Object o) {
Iterator<T> i = iterator();
while (i.hasNext())
if (i.next().compareTo((T) o) == 0) {
i.remove();
return true;
}
return false;
}
@Override
public boolean removeAll(Collection<?> c) {
for (Object o : c) {
if (!remove(o)) {
return false;
}
}
return true;
}
@Override
public boolean retainAll(Collection<?> c) {
// TODO Auto-generated method stub
return false;
}
@Override
public int size() {
if (isEmpty())
return 0;
int s = 0;
Iterator<?> i = iterator();
while (i.hasNext()) {
s++;
i.next();
}
return s;
}
@Override
public Object[] toArray() {
Object[] a = new Object[size()];
int j = 0;
Iterator<T> i = iterator();
while (i.hasNext())
a[j++] = i.next();
return a;
}
@SuppressWarnings({ "hiding", "unchecked" })
@Override
public <T> T[] toArray(T[] a) {
T[] b = (T[]) Array.newInstance(a.getClass().getComponentType(), size());
int j = 0;
Iterator<T> i = (Iterator<T>) iterator();
while (i.hasNext())
b[j++] = i.next();
return b;
}
@Override
public Comparator<? super T> comparator() {
return (T a, T b) -> a.compareTo(b);
}
@SuppressWarnings("unchecked")
@Override
public T first() {
return (T) anchor.value;
}
@Override
public SortedSet<T> headSet(T arg0) {
// TODO Auto-generated method stub
return null;
}
@SuppressWarnings("unchecked")
@Override
public T last() {
return (T) anchor.pred.value;
}
@Override
public SortedSet<T> subSet(T fromElement, T toElement) {
// TODO Auto-generated method stub
return null;
}
@Override
public SortedSet<T> tailSet(T fromElement) {
// TODO Auto-generated method stub
return null;
}
}
import static org.junit.jupiter.api.Assertions.*;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;
import java.util.Comparator;
import java.util.Iterator;
import java.util.Random;
import org.junit.jupiter.api.AfterEach;
import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.Test;
class LinkedSetTest {
LinkedSet<Integer> set = null;
@BeforeEach
void setUp() throws Exception {
set = new LinkedSet<Integer>();
}
@AfterEach
void tearDown() throws Exception {
set.clear();
set = null;
}
@Test
void testMain() {
LinkedSet.main(null);
}
@Test
void testIterToString() {
testAdd();
Iterator<Integer> i = set.iterator();
assertNotNull(i);
String s = LinkedSet.iterToString(i);
assertNotNull(s);
System.out.println(s);
}
@Test
void testLinkedSet() {
assertNotNull(set);
}
@Test
void testIterator() {
Iterator<Integer> i = set.iterator();
assertNotNull(i);
assertFalse(i.hasNext());
assertTrue(set.add(new Random().nextInt(5)));
i = set.iterator();
assertNotNull(i);
assertTrue(i.hasNext());
}
@Test
void testAdd() {
ArrayList<Integer> l = new ArrayList<>();
for (int i = 0; i < 12; i++) {
l.add(i);
}
for (int j = 0; j < 12; j++) {
set.clear();
assertTrue(set.isEmpty());
Collections.shuffle(l);
for (int i = 0; i < 12; i++) {
assertTrue(set.add(l.get(i)));
assertFalse(set.isEmpty());
}
}
}
@Test
void testAddAll() {
assertTrue(set.addAll(Arrays.asList(4, 2, 3)));
assertEquals("2; 3; 4", LinkedSet.iterToString(set.iterator()));
}
@Test
void testClear() {
set.clear();
assertTrue(set.isEmpty());
}
@Test
void testContains() {
assertTrue(set.add(2));
assertTrue(set.contains(2));
}
@Test
void testContainsAll() {
assertTrue(set.addAll(Arrays.asList(4, 2, 3)));
assertTrue(set.containsAll(Arrays.asList(2, 3, 4)));
assertEquals("2; 3; 4", LinkedSet.iterToString(set.iterator()));
}
@Test
void testIsEmpty() {
assertTrue(set.isEmpty());
assertTrue(set.add(1));
assertFalse(set.isEmpty());
}
@Test
void testRemove() {
assertFalse(set.remove(2));
assertTrue(set.add(2));
assertTrue(set.remove(2));
assertFalse(set.remove(3));
}
@Test
void testRemoveAll() {
assertTrue(set.addAll(Arrays.asList(4, 2, 3)));
assertEquals("2; 3; 4", LinkedSet.iterToString(set.iterator()));
assertTrue(set.removeAll(Arrays.asList(2, 3, 4)));
assertEquals("", LinkedSet.iterToString(set.iterator()));
}
@Test
void testRetainAll() {
fail("Not yet implemented");
}
@Test
void testSize() {
assertTrue(set.addAll(Arrays.asList(4, 2, 3)));
assertEquals(3, set.size());
assertEquals("2; 3; 4", LinkedSet.iterToString(set.iterator()));
}
@Test
void testToArray() {
assertNotNull(set.toArray());
assertTrue(set.addAll(Arrays.asList(4, 2, 3)));
assertNotNull(set.toArray());
assertEquals("2; 3; 4", LinkedSet.iterToString(set.iterator()));
}
@Test
void testToArrayTArray() {
assertNotNull(set.toArray(new Integer[0]));
assertTrue(set.addAll(Arrays.asList(4, 2, 3)));
assertEquals(3, set.toArray(new Integer[0]).length);
assertEquals(Integer[].class, set.toArray(new Integer[0]).getClass());
assertEquals("2; 3; 4", LinkedSet.iterToString(set.iterator()));
}
@Test
void testComparator() {
assertTrue(set.comparator() instanceof Comparator<?>);
}
@Test
void testFirst() {
assertTrue(set.addAll(Arrays.asList(4, 2, 3)));
assertEquals(2, set.first());
assertEquals("2; 3; 4", LinkedSet.iterToString(set.iterator()));
}
@Test
void testHeadSet() {
fail("Not yet implemented");
}
@Test
void testLast() {
assertTrue(set.addAll(Arrays.asList(4, 2, 3)));
assertEquals(4, set.last());
assertEquals("2; 3; 4", LinkedSet.iterToString(set.iterator()));
}
@Test
void testSubSet() {
fail("Not yet implemented");
}
@Test
void testTailSet() {
fail("Not yet implemented");
}
}
Zu Anfang ist current=anchor
hasNext prüft dann, ob es noch einen Nachfolger gibt, next gibt dann aber den aktuellen Wert von current (also im ersten Aufruf anchor) zurück.
Bitte nicht (und bitte auch nicht meine Variante...)Dann nehme ich einfach alles von @Tobias-nrw
Naja, "ein paar" Verstöße gegen das Interface gibts aber schon nochGeschafft!
Bitte nicht (und bitte auch nicht meine Variante...)
Nop.Variablen heißen jetzt xXge93nd = a, current = za2g9dna Besser?
Wenn du das wieder einbaust, wird man dir wieder sagen, dass es da nicht hingehört ¯\_(ツ)_/¯remove(object o) im Iterator ist also eh Sinnfrei! Doch wenn ich Ihn einbauen würde könnte ich das von mir nehmen oder :O
import java.lang.reflect.Array;
import java.util.Collection;
import java.util.Comparator;
import java.util.Iterator;
import java.util.SortedSet;
import java.util.StringJoiner;
public class LinkedSet<T extends Comparable<T>> implements SortedSet<T> {
public static void main(String[] args) {
LinkedSet<Integer> s = new LinkedSet<>();
System.out.println(iterToString(s.iterator()));
for (int i = 0; i < 10; i++) {
s.add((int) (Math.random() * 5.0));
System.out.println(iterToString(s.iterator()));
}
s.clear();
System.out.println(iterToString(s.iterator()));
for (int i = 0; i < 10; i++) {
s.add((int) (Math.random() * 5.0));
System.out.println(iterToString(s.iterator()));
}
}
public static String iterToString(Iterator<?> i) {
StringJoiner j = new StringJoiner("; ");
j.setEmptyValue("");
while (i.hasNext())
j.add(i.next().toString());
return j.toString();
}
private class Cell {
Object value;
Cell pred, succ;
}
private Cell anchor;
public LinkedSet() {
anchor = new Cell();
anchor.pred = anchor;
anchor.succ = anchor;
}
public Iterator<T> iterator() {
return new Iterator<T>() {
Cell a = anchor;
boolean b = true;
@Override
public boolean hasNext() {
if (b && a.succ == anchor) {
b = false;
return a.value != null;
}
return b && a.value != null;
}
@SuppressWarnings("unchecked")
@Override
public T next() {
T t = (T) a.value;
a = a.succ;
return t;
}
@Override
public void remove() {
LinkedSet.this.remove(a.pred);
}
};
}
@SuppressWarnings("unchecked")
public boolean add(T e) {
if (e == null) {
throw new NullPointerException();
}
if (isEmpty()) {
anchor.value = e;
} else if (contains(e)) {
return false;
} else if (((Comparable<T>) e).compareTo((T) anchor.value) < 0) {
anchor = insertBefore(anchor, e);
} else {
Cell current = anchor.succ;
while (current != anchor && ((Comparable<T>) current.value).compareTo(e) < 0) {
current = current.succ;
}
insertBefore(current, e);
}
return true;
}
private Cell insertBefore(Cell cell, T e) {
Cell result = new Cell();
result.value = e;
result.pred = cell.pred;
result.succ = cell;
cell.pred.succ = result;
cell.pred = result;
return result;
}
@Override
public boolean addAll(Collection<? extends T> c) {
for (T t : c) {
add(t);
}
return true;
}
@Override
public void clear() {
anchor.pred = anchor;
anchor.succ = anchor;
anchor.value = null;
}
@Override
public boolean contains(Object o) {
Iterator<T> i = iterator();
while (i.hasNext())
if (i.next().equals(o))
return true;
return false;
}
@Override
public boolean containsAll(Collection<?> c) {
for (Object o : c) {
if (!contains(o))
return false;
}
return true;
}
@Override
public boolean isEmpty() {
return anchor.value == null;
}
@SuppressWarnings("unchecked")
@Override
public boolean remove(Object o) {
Iterator<T> i = iterator();
while (i.hasNext())
if (i.next().compareTo((T) o) == 0) {
i.remove();
return true;
}
return false;
}
private void remove(Cell c) {
Cell a = c.succ;
if (size() == 1) {
a.value = null;
} else {
if (a.pred == anchor) {
anchor = a;
}
a.pred.pred.succ = a;
a.pred = a.pred.pred;
}
}
@Override
public boolean removeAll(Collection<?> c) {
boolean b = true;
for (Object o : c) {
if (!remove(o)) {
b = false;
}
}
return b;
}
@Override
public boolean retainAll(Collection<?> c) {
// TODO Auto-generated method stub
return false;
}
@Override
public int size() {
if (isEmpty())
return 0;
int s = 0;
Iterator<?> i = iterator();
while (i.hasNext()) {
s++;
i.next();
}
return s;
}
@Override
public Object[] toArray() {
Object[] a = new Object[size()];
int j = 0;
Iterator<T> i = iterator();
while (i.hasNext())
a[j++] = i.next();
return a;
}
@SuppressWarnings({ "hiding", "unchecked" })
@Override
public <T> T[] toArray(T[] a) {
T[] b = (T[]) Array.newInstance(a.getClass().getComponentType(), size());
int j = 0;
Iterator<T> i = (Iterator<T>) iterator();
while (i.hasNext())
b[j++] = i.next();
return b;
}
@Override
public Comparator<? super T> comparator() {
return (T a, T b) -> a.compareTo(b);
}
@SuppressWarnings("unchecked")
@Override
public T first() {
return (T) anchor.value;
}
@Override
public SortedSet<T> headSet(T arg0) {
// TODO Auto-generated method stub
return null;
}
@SuppressWarnings("unchecked")
@Override
public T last() {
return (T) anchor.pred.value;
}
@Override
public SortedSet<T> subSet(T fromElement, T toElement) {
// TODO Auto-generated method stub
return null;
}
@Override
public SortedSet<T> tailSet(T fromElement) {
// TODO Auto-generated method stub
return null;
}
}
Na da war die vorherige Lösung aber schöner@mrBrown Habe mal folgendes geändert:
1. remove nicht vollständig im Iterator,
2. eigene Methode für remove im LinkedSet,
3. nach wie vor wird bei remove (noch) der Iterator verwendet.
Keine Ahnung, das müsstest du dann den hypothetische Aufgabensteller fragenWenn die Aufgabenstellung so wäre das man einen Iterator mit der Methode remove(Object) Implementieren müsste wäre dann meine Okay?
Wenn du die Lösung frei erklären kannst gerne - aber dann wäre es doch sicher auch kein Problem, das selbst zu schreibenund die anderen Methoden hasNext und Next() könne ich ja auch von dir nehmen okay
Eine andere Lösung fällt mir dort jetzt nicht ein.
Ich würde sagen „ja“Ich hätte aber noch eine Ähnliche Aufgabe wie diese hier und eine Frage vor ab. Darf ich wenn eine Klasse implements Collection im Iterator die Methoden bentuzen also wie z. B. to Array und isEmpty? Bestimmt oder
Okay dann lasse ich das raus! Ist ja normalerweise auch nicht drinKeine Ahnung, das müsstest du dann den hypothetische Aufgabensteller fragen
Das hört sich gut an denn dann könnte man ja auch mit der toArray Methode sich ein Array im Iterator anlegen und über das Iterieren oder wäre das auch wieder FALSCH ??Ich würde sagen „ja“
Ich glaube das ich das nicht kann dann lasse ich das alles wegWenn du die Lösung frei erklären kannst gerne - aber dann wäre es doch sicher auch kein Problem, das selbst zu schreiben
Von meiner Seite aus stünde nix dagegen. Ich kann aber Fehler, trotz der Tests, nicht ganz ausschließen.und die anderen Methoden hasNext und Next() könne ich ja auch von dir nehmen okay
Kläre das am besten mit dem hypothetischen Aufgabensteller ab, wenn es nicht schon in der Aufgabe stünde...Darf ich wenn eine Klasse implements Collection im Iterator die Methoden bentuzen also wie z. B. to Array und isEmpty? Bestimmt oder
Das wäre zumindest sehr abenteuerlich, aber generell müsste das Möglich sein - dürfte aber mehr Aufwand werden.Das hört sich gut an denn dann könnte man ja auch mit der toArray Methode sich ein Array im Iterator anlegen und über das Iterieren oder wäre das auch wieder FALSCH ??