From fe3f27ccd497c6bbb774ec05cf379a7a94283ac5 Mon Sep 17 00:00:00 2001 From: "mr.Blue" Date: Sun, 23 Feb 2020 11:19:20 +0300 Subject: [PATCH 1/8] gitignore added --- Lesson3/Algorithms/sort/insertion/.gitignore | 76 ++++++++++++++++++++ 1 file changed, 76 insertions(+) create mode 100644 Lesson3/Algorithms/sort/insertion/.gitignore diff --git a/Lesson3/Algorithms/sort/insertion/.gitignore b/Lesson3/Algorithms/sort/insertion/.gitignore new file mode 100644 index 0000000..8281022 --- /dev/null +++ b/Lesson3/Algorithms/sort/insertion/.gitignore @@ -0,0 +1,76 @@ +############################## +## Java +############################## +.mtj.tmp/ +*.class +*.jar +*.war +*.ear +*.nar +hs_err_pid* + +############################## +## Maven +############################## +target/ +pom.xml.tag +pom.xml.releaseBackup +pom.xml.versionsBackup +pom.xml.next +pom.xml.bak +release.properties +dependency-reduced-pom.xml +buildNumber.properties +.mvn/timing.properties +.mvn/wrapper/maven-wrapper.jar + +############################## +## Gradle +############################## +bin/ +build/ +.gradle +.gradletasknamecache +gradle-app.setting +!gradle-wrapper.jar + +############################## +## IntelliJ +############################## +out/ +.idea/ +.idea_modules/ +*.iml +*.ipr +*.iws + +############################## +## Eclipse +############################## +.settings/ +tmp/ +.metadata +.classpath +.project +*.tmp +*.bak +*.swp +*~.nib +local.properties +.loadpath +.factorypath + +############################## +## NetBeans +############################## +nbproject/private/ +nbbuild/ +dist/ +nbdist/ +nbactions.xml +nb-configuration.xml + +############################## +## OS X +############################## +.DS_Store From f8e9d59e3e237024dba3470e0f573e85afb91d4e Mon Sep 17 00:00:00 2001 From: "mr.Blue" Date: Sun, 23 Feb 2020 11:23:10 +0300 Subject: [PATCH 2/8] added insertion sort algorithm --- .../sort/insertion/src/algorithms/main.java | 33 +++++++++++++++++++ .../insertion/src/algorithms/sort/Sort.java | 15 +++++++++ 2 files changed, 48 insertions(+) create mode 100644 Lesson3/Algorithms/sort/insertion/src/algorithms/main.java create mode 100644 Lesson3/Algorithms/sort/insertion/src/algorithms/sort/Sort.java diff --git a/Lesson3/Algorithms/sort/insertion/src/algorithms/main.java b/Lesson3/Algorithms/sort/insertion/src/algorithms/main.java new file mode 100644 index 0000000..5b7ebec --- /dev/null +++ b/Lesson3/Algorithms/sort/insertion/src/algorithms/main.java @@ -0,0 +1,33 @@ +package algorithms; + +import algorithms.sort.Sort; + +public class main { + public static void main(String[] args) { + checkSortAlgorithm(); + } + + private static void checkSortAlgorithm() { + int[] array = new int[10]; + Sort sort = new Sort(); + + fillArray(array); + printArray(array); + + sort.insertionSort(array); + printArray(array); + } + + private static void fillArray(int[] array) { + for (int i = 0; i < array.length; i++) { + array[i] = (int) Math.round(Math.random() * 100); + } + } + + private static void printArray(int[] array) { + System.out.println(); + for (int i = 0; i < array.length; i++) { + System.out.print(array[i] + " "); + } + } +} diff --git a/Lesson3/Algorithms/sort/insertion/src/algorithms/sort/Sort.java b/Lesson3/Algorithms/sort/insertion/src/algorithms/sort/Sort.java new file mode 100644 index 0000000..cf9cfb8 --- /dev/null +++ b/Lesson3/Algorithms/sort/insertion/src/algorithms/sort/Sort.java @@ -0,0 +1,15 @@ +package algorithms.sort; + +public class Sort { + + public void insertionSort(int[] arr) { + int j, temp; + for (int i = 0; i < arr.length; i++) { + temp = arr[i]; + for (j = i-1; j >= 0 && arr[j] > temp; j--) { + arr[j+1] = arr[j]; + } + arr[j+1] = temp; + } + } +} From ea60528a766d3a2805a61dc6dcfc7178a284fee2 Mon Sep 17 00:00:00 2001 From: "mr.Blue" Date: Sun, 23 Feb 2020 11:40:13 +0300 Subject: [PATCH 3/8] added calculating fibonacci numbers algorithm --- .../algorithms/fibonacci/FibonacciSequence.java | 14 ++++++++++++++ .../sort/insertion/src/algorithms/main.java | 14 ++++++++++++-- 2 files changed, 26 insertions(+), 2 deletions(-) create mode 100644 Lesson3/Algorithms/sort/insertion/src/algorithms/fibonacci/FibonacciSequence.java diff --git a/Lesson3/Algorithms/sort/insertion/src/algorithms/fibonacci/FibonacciSequence.java b/Lesson3/Algorithms/sort/insertion/src/algorithms/fibonacci/FibonacciSequence.java new file mode 100644 index 0000000..57fd016 --- /dev/null +++ b/Lesson3/Algorithms/sort/insertion/src/algorithms/fibonacci/FibonacciSequence.java @@ -0,0 +1,14 @@ +package algorithms.fibonacci; + +public class FibonacciSequence { + + public int[] calculatingFibonacciNumbers(int quantity) { + int[] fib = new int[quantity]; + fib[0] = 0; + fib[1] = 1; + for (int i = 2; i < quantity; ++i) { + fib[i] = fib[i - 1] + fib[i - 2]; + } + return fib; + } +} diff --git a/Lesson3/Algorithms/sort/insertion/src/algorithms/main.java b/Lesson3/Algorithms/sort/insertion/src/algorithms/main.java index 5b7ebec..670b4ce 100644 --- a/Lesson3/Algorithms/sort/insertion/src/algorithms/main.java +++ b/Lesson3/Algorithms/sort/insertion/src/algorithms/main.java @@ -1,16 +1,26 @@ package algorithms; +import algorithms.fibonacci.FibonacciSequence; import algorithms.sort.Sort; public class main { public static void main(String[] args) { + System.out.println("Сортировка методом вставки:"); checkSortAlgorithm(); + + System.out.println("Последовательность фибоначи:"); + checkFibonacciSequenceAlgorithm(); + + } + + private static void checkFibonacciSequenceAlgorithm() { + FibonacciSequence fibonacci = new FibonacciSequence(); + printArray(fibonacci.calculatingFibonacciNumbers(20)); } private static void checkSortAlgorithm() { int[] array = new int[10]; Sort sort = new Sort(); - fillArray(array); printArray(array); @@ -25,9 +35,9 @@ private static void fillArray(int[] array) { } private static void printArray(int[] array) { - System.out.println(); for (int i = 0; i < array.length; i++) { System.out.print(array[i] + " "); } + System.out.println(); } } From a9ff52268f49c55a08cce9613f9f8a698207d26a Mon Sep 17 00:00:00 2001 From: "mr.Blue" Date: Sun, 23 Feb 2020 11:46:57 +0300 Subject: [PATCH 4/8] added vectorlist from lesson --- .../src/algorithms/vectorlist/VectorList.java | 73 +++++++++++++++++++ 1 file changed, 73 insertions(+) create mode 100644 Lesson3/Algorithms/sort/insertion/src/algorithms/vectorlist/VectorList.java diff --git a/Lesson3/Algorithms/sort/insertion/src/algorithms/vectorlist/VectorList.java b/Lesson3/Algorithms/sort/insertion/src/algorithms/vectorlist/VectorList.java new file mode 100644 index 0000000..09ed451 --- /dev/null +++ b/Lesson3/Algorithms/sort/insertion/src/algorithms/vectorlist/VectorList.java @@ -0,0 +1,73 @@ +package algorithms.vectorlist; +import java.util.Iterator; +public class VectorList implements Iterable { + private Node node = null; + private int counter = 0; + + public VectorList(){ + node = new Node<>(); + } + + public int size(){ + return counter; + } + public void add(E element){ + if (counter == 0){ // первый узел надо обработать отдельно, иначе в первом узле элемент будет балластом + node.set(element); + } + else{ + node.add(element); + } + counter++; // увеличим счетчик элементов + } + @Override + public Iterator iterator() { + return new VectorIterator(node); + } +// Узел с элементом, сделан внутренним, чтобы не светить его наружу + private class Node{ + private E element; + private Node next = null; + + Node(){} + Node(E element){ + set(element); + } + void set(E element){ + this.element = element; + } + void add(E element){ + if (isNext()){ // если существует следующий узел, передадим ему эстафету + next.add(element); + } + else{ // иначе создадим следующий узел + next = new Node<>(element); + } + } + E get(){ + return element; + } + boolean isNext(){ + return next != null; + } + } +// Итератор, светить наружу его тоже не хочется, он слишком специфичный. + private class VectorIterator implements Iterator{ + private Node current; + private boolean isFirst = true; // первый узел надо обработать отдельно + VectorIterator(Node node){ + current = node; + } + @Override + public boolean hasNext() { + if (counter == 1 && isFirst) return true; // отдельно обработать один элемент (потому как у него нет next) + return current.isNext(); + } + @Override + public E next() { + if (isFirst) isFirst = false; + else current = current.next; + return current.get(); + } + } +} From 0500225d359fb1f1922e5e4289c4afe0b3477d9b Mon Sep 17 00:00:00 2001 From: "mr.Blue" Date: Sun, 23 Feb 2020 13:39:47 +0300 Subject: [PATCH 5/8] removed unnecessary class --- .../src/algorithms/vectorlist/VectorList.java | 73 ------------------- 1 file changed, 73 deletions(-) delete mode 100644 Lesson3/Algorithms/sort/insertion/src/algorithms/vectorlist/VectorList.java diff --git a/Lesson3/Algorithms/sort/insertion/src/algorithms/vectorlist/VectorList.java b/Lesson3/Algorithms/sort/insertion/src/algorithms/vectorlist/VectorList.java deleted file mode 100644 index 09ed451..0000000 --- a/Lesson3/Algorithms/sort/insertion/src/algorithms/vectorlist/VectorList.java +++ /dev/null @@ -1,73 +0,0 @@ -package algorithms.vectorlist; -import java.util.Iterator; -public class VectorList implements Iterable { - private Node node = null; - private int counter = 0; - - public VectorList(){ - node = new Node<>(); - } - - public int size(){ - return counter; - } - public void add(E element){ - if (counter == 0){ // первый узел надо обработать отдельно, иначе в первом узле элемент будет балластом - node.set(element); - } - else{ - node.add(element); - } - counter++; // увеличим счетчик элементов - } - @Override - public Iterator iterator() { - return new VectorIterator(node); - } -// Узел с элементом, сделан внутренним, чтобы не светить его наружу - private class Node{ - private E element; - private Node next = null; - - Node(){} - Node(E element){ - set(element); - } - void set(E element){ - this.element = element; - } - void add(E element){ - if (isNext()){ // если существует следующий узел, передадим ему эстафету - next.add(element); - } - else{ // иначе создадим следующий узел - next = new Node<>(element); - } - } - E get(){ - return element; - } - boolean isNext(){ - return next != null; - } - } -// Итератор, светить наружу его тоже не хочется, он слишком специфичный. - private class VectorIterator implements Iterator{ - private Node current; - private boolean isFirst = true; // первый узел надо обработать отдельно - VectorIterator(Node node){ - current = node; - } - @Override - public boolean hasNext() { - if (counter == 1 && isFirst) return true; // отдельно обработать один элемент (потому как у него нет next) - return current.isNext(); - } - @Override - public E next() { - if (isFirst) isFirst = false; - else current = current.next; - return current.get(); - } - } -} From ed0c480c504c749f8365f0c93c65877154946b61 Mon Sep 17 00:00:00 2001 From: "mr.Blue" Date: Sun, 23 Feb 2020 13:44:27 +0300 Subject: [PATCH 6/8] added implementation of liked lists (one and two ways) --- .../sort/insertion/src/algorithms/main.java | 31 ++++ .../algorithms/mylinkedlist/MyIterator.java | 9 + .../algorithms/mylinkedlist/MyLinkedList.java | 21 +++ .../mylinkedlist/MySimpleLinkedListImpl.java | 167 ++++++++++++++++++ 4 files changed, 228 insertions(+) create mode 100644 Lesson3/Algorithms/sort/insertion/src/algorithms/mylinkedlist/MyIterator.java create mode 100644 Lesson3/Algorithms/sort/insertion/src/algorithms/mylinkedlist/MyLinkedList.java create mode 100644 Lesson3/Algorithms/sort/insertion/src/algorithms/mylinkedlist/MySimpleLinkedListImpl.java diff --git a/Lesson3/Algorithms/sort/insertion/src/algorithms/main.java b/Lesson3/Algorithms/sort/insertion/src/algorithms/main.java index 670b4ce..153f895 100644 --- a/Lesson3/Algorithms/sort/insertion/src/algorithms/main.java +++ b/Lesson3/Algorithms/sort/insertion/src/algorithms/main.java @@ -1,6 +1,8 @@ package algorithms; import algorithms.fibonacci.FibonacciSequence; +import algorithms.mylinkedlist.twowaylinkedlist.MyTwoWayLinkedList; +import algorithms.mylinkedlist.twowaylinkedlist.MyTwoWayLinkedListImpl; import algorithms.sort.Sort; public class main { @@ -11,6 +13,35 @@ public static void main(String[] args) { System.out.println("Последовательность фибоначи:"); checkFibonacciSequenceAlgorithm(); + TwoSideMyLinkedListImplTest(); + + } + + private static void TwoSideMyLinkedListImplTest() { + MyTwoWayLinkedList myLinkedList = new MyTwoWayLinkedListImpl<>(); + + myLinkedList.insertFirst(18); + myLinkedList.insertFirst(457); + myLinkedList.insertFirst(12); + myLinkedList.insertFirst(54); + myLinkedList.insertLast(6); + + myLinkedList.insertLast(584); + + myLinkedList.display(); + + System.out.println("Contains 18: " + myLinkedList.contains(18)); + System.out.println("Contains 7: " + myLinkedList.contains(7)); + System.out.println("Contains 457: " + myLinkedList.contains(457)); + System.out.println("Contains 24: " + myLinkedList.contains(24)); + System.out.println("Contains 584: " + myLinkedList.contains(584)); + + myLinkedList.display(); + + myLinkedList.removeFirst(); + myLinkedList.remove(6); + + myLinkedList.display(); } private static void checkFibonacciSequenceAlgorithm() { diff --git a/Lesson3/Algorithms/sort/insertion/src/algorithms/mylinkedlist/MyIterator.java b/Lesson3/Algorithms/sort/insertion/src/algorithms/mylinkedlist/MyIterator.java new file mode 100644 index 0000000..71b0663 --- /dev/null +++ b/Lesson3/Algorithms/sort/insertion/src/algorithms/mylinkedlist/MyIterator.java @@ -0,0 +1,9 @@ +package algorithms.mylinkedlist; + +import java.util.Iterator; + +public interface MyIterator extends Iterator { + void reset(); + void insertBefore(E value); + void insertAfter(E value); +} diff --git a/Lesson3/Algorithms/sort/insertion/src/algorithms/mylinkedlist/MyLinkedList.java b/Lesson3/Algorithms/sort/insertion/src/algorithms/mylinkedlist/MyLinkedList.java new file mode 100644 index 0000000..e7b19b4 --- /dev/null +++ b/Lesson3/Algorithms/sort/insertion/src/algorithms/mylinkedlist/MyLinkedList.java @@ -0,0 +1,21 @@ +package algorithms.mylinkedlist; + + +public interface MyLinkedList extends Iterable { + void insertFirst(E value); + E removeFirst(); + boolean remove(E value); + boolean contains(E value); + boolean isEmpty(); + int size(); + void display(); + E getFirstElement(); + Entry getFirst(); + static class Entry { + public final E value; + public Entry next; + public Entry(E value) { + this.value = value; + } + } +} diff --git a/Lesson3/Algorithms/sort/insertion/src/algorithms/mylinkedlist/MySimpleLinkedListImpl.java b/Lesson3/Algorithms/sort/insertion/src/algorithms/mylinkedlist/MySimpleLinkedListImpl.java new file mode 100644 index 0000000..855a63e --- /dev/null +++ b/Lesson3/Algorithms/sort/insertion/src/algorithms/mylinkedlist/MySimpleLinkedListImpl.java @@ -0,0 +1,167 @@ +package algorithms.mylinkedlist; + +import java.util.Iterator; + +public class MySimpleLinkedListImpl implements MyLinkedList { + + protected Entry firstElement; + protected int size; + + @Override + public void insertFirst(E value) { + Entry entry = new Entry<>(value); + entry.next = firstElement; + firstElement = entry; + size++; + } + + @Override + public E removeFirst() { + if (isEmpty()){ return null; } + E removedElement = this.firstElement.value; + firstElement = firstElement.next; + size--; + return removedElement; + } + + @Override + public boolean remove(E value) { + Entry previous = null; + Entry current = firstElement; + while (current != null){ + if (current.value.equals(value)){ break; } + previous = current; + current = current.next; + } + if (current == null) { return false; } + if (current == firstElement){ + firstElement = firstElement.next; + } else { + previous.next = current.next; + } + size--; + return true; + } + + @Override + public boolean contains(E value) { + Entry current = firstElement; + while (current != null) { + if (current.value.equals(value)){ return true; } + current = current.next; + } + return false; + } + + @Override + public boolean isEmpty() { + return size == 0; + } + + @Override + public int size() { + return size; + } + + @Override + public void display() { + System.out.println("-----------"); + Entry current = firstElement; + while (current != null) { + System.out.println(current.value); + current = current.next; + } + System.out.println("-----------"); + } + + @Override + public E getFirstElement() { + return firstElement.value; + } + + @Override + public Entry getFirst() { + return firstElement; + } + + @Override + public Iterator iterator() { + return new LinkedListIterator(this); + } + + @SuppressWarnings("unchecked") + private static class LinkedListIterator implements MyIterator { + + private MySimpleLinkedListImpl list; + + private Entry current; + private Entry previous; + + public LinkedListIterator(MySimpleLinkedListImpl list) { + this.list = list; + reset(); + } + + @Override + public boolean hasNext() { + return current != null; + } + + @Override + public E next() { + E nextValue = current.value; + previous = current; + current = current.next; + return nextValue; + } + + @Override + public void remove() { + if (previous == null){ + list.firstElement = current.next; + reset(); + } else { + previous.next = current.next; + if ( !hasNext() ) { + reset(); + } else { + current = current.next; + } + } + } + + @Override + public void reset() { + current = list.firstElement; + previous = null; + } + + @Override + public void insertBefore(E value) { + Entry newItem = new Entry(value); + if(previous == null) { + newItem.next = list.firstElement; + list.firstElement = newItem; + reset(); + } + else { + newItem.next = previous.next; + previous.next = newItem; + current = newItem; + } + + } + @Override + public void insertAfter(E value) { + Entry newItem = new Entry(value); + if (list.isEmpty()){ + list.firstElement = newItem; + current = newItem; + } else { + newItem.next = current.next; + current.next = newItem; + next(); + } + } + } +} From 183d837e14f9fb94bc1c2777c409dafbcc25d057 Mon Sep 17 00:00:00 2001 From: "mr.Blue" Date: Sun, 23 Feb 2020 13:44:35 +0300 Subject: [PATCH 7/8] added implementation of liked lists (one and two ways) --- .../twowaylinkedlist/MyTwoWayLinkedList.java | 7 +++ .../MyTwoWayLinkedListImpl.java | 53 +++++++++++++++++++ 2 files changed, 60 insertions(+) create mode 100644 Lesson3/Algorithms/sort/insertion/src/algorithms/mylinkedlist/twowaylinkedlist/MyTwoWayLinkedList.java create mode 100644 Lesson3/Algorithms/sort/insertion/src/algorithms/mylinkedlist/twowaylinkedlist/MyTwoWayLinkedListImpl.java diff --git a/Lesson3/Algorithms/sort/insertion/src/algorithms/mylinkedlist/twowaylinkedlist/MyTwoWayLinkedList.java b/Lesson3/Algorithms/sort/insertion/src/algorithms/mylinkedlist/twowaylinkedlist/MyTwoWayLinkedList.java new file mode 100644 index 0000000..2b60d90 --- /dev/null +++ b/Lesson3/Algorithms/sort/insertion/src/algorithms/mylinkedlist/twowaylinkedlist/MyTwoWayLinkedList.java @@ -0,0 +1,7 @@ +package algorithms.mylinkedlist.twowaylinkedlist; + +import algorithms.mylinkedlist.MyLinkedList; + +public interface MyTwoWayLinkedList extends MyLinkedList { + void insertLast(E value); +} diff --git a/Lesson3/Algorithms/sort/insertion/src/algorithms/mylinkedlist/twowaylinkedlist/MyTwoWayLinkedListImpl.java b/Lesson3/Algorithms/sort/insertion/src/algorithms/mylinkedlist/twowaylinkedlist/MyTwoWayLinkedListImpl.java new file mode 100644 index 0000000..17a20f8 --- /dev/null +++ b/Lesson3/Algorithms/sort/insertion/src/algorithms/mylinkedlist/twowaylinkedlist/MyTwoWayLinkedListImpl.java @@ -0,0 +1,53 @@ +package algorithms.mylinkedlist.twowaylinkedlist; + +import algorithms.mylinkedlist.MySimpleLinkedListImpl; + +public class MyTwoWayLinkedListImpl extends MySimpleLinkedListImpl implements MyTwoWayLinkedList { + + private Entry lastElement; + + @Override + public void insertLast(E value) { + Entry entry = new Entry<>(value); + if (isEmpty()) { firstElement = entry; + } else { lastElement.next = entry; } + lastElement = entry; + size++; + } + + @Override + public void insertFirst(E value) { + super.insertFirst(value); + if (size() == 1) { lastElement = firstElement; } + } + + @Override + public E removeFirst() { + E removedElement = super.removeFirst(); + if (isEmpty()) { lastElement = null; } + return removedElement; + } + + @Override + public boolean remove(E value) { + Entry previous = null; + Entry current = firstElement; + while (current != null){ + if (current.value.equals(value)){ break; } + previous = current; + current = current.next; + } + + if (current == null) { return false; } + if (current == firstElement){ + firstElement = firstElement.next; + } else if(current == lastElement) { + lastElement = previous; + previous.next = null; + } else { + previous.next = current.next; + } + size--; + return true; + } +} From fa51f9833c689a9e0c89b57ed6b5c8041ceea20a Mon Sep 17 00:00:00 2001 From: "mr.Blue" Date: Sun, 23 Feb 2020 14:09:01 +0300 Subject: [PATCH 8/8] added prime algorithm --- .../src/algorithms/eratosfen/Eratosfen.java | 36 +++++++++++++++++++ .../sort/insertion/src/algorithms/main.java | 4 +++ 2 files changed, 40 insertions(+) create mode 100644 Lesson3/Algorithms/sort/insertion/src/algorithms/eratosfen/Eratosfen.java diff --git a/Lesson3/Algorithms/sort/insertion/src/algorithms/eratosfen/Eratosfen.java b/Lesson3/Algorithms/sort/insertion/src/algorithms/eratosfen/Eratosfen.java new file mode 100644 index 0000000..4fa0831 --- /dev/null +++ b/Lesson3/Algorithms/sort/insertion/src/algorithms/eratosfen/Eratosfen.java @@ -0,0 +1,36 @@ +package algorithms.eratosfen; + +import java.util.Arrays; + +public class Eratosfen { + + public boolean[] primes; + + public Eratosfen(int range) { + primes = new boolean[range + 1]; + } + + public void fillSieve() { + Arrays.fill(primes, true); + + primes[0] = false; + primes[1] = false; + + for (int i = 2; i < primes.length; ++i) { + if (primes[i]) { + for (int j = 2; i * j < primes.length; ++j) { + primes[i * j] = false; + } + } + } + } + + public void displayAllNumbers() { + fillSieve(); + for (int i = 0; i < primes.length; i++) { + if (primes[i]) { + System.out.print(i + " "); + } + } + } +} diff --git a/Lesson3/Algorithms/sort/insertion/src/algorithms/main.java b/Lesson3/Algorithms/sort/insertion/src/algorithms/main.java index 153f895..53e8522 100644 --- a/Lesson3/Algorithms/sort/insertion/src/algorithms/main.java +++ b/Lesson3/Algorithms/sort/insertion/src/algorithms/main.java @@ -1,5 +1,6 @@ package algorithms; +import algorithms.eratosfen.Eratosfen; import algorithms.fibonacci.FibonacciSequence; import algorithms.mylinkedlist.twowaylinkedlist.MyTwoWayLinkedList; import algorithms.mylinkedlist.twowaylinkedlist.MyTwoWayLinkedListImpl; @@ -15,6 +16,9 @@ public static void main(String[] args) { TwoSideMyLinkedListImplTest(); + Eratosfen eratosfen = new Eratosfen(100); + eratosfen.displayAllNumbers(); + } private static void TwoSideMyLinkedListImplTest() {