From 8bcbd6c823075bf6e70a893d5fb2b70cf1c08440 Mon Sep 17 00:00:00 2001 From: Wouter Groeneveld Date: Mon, 26 Mar 2018 17:35:42 +0200 Subject: [PATCH] linked list example (head only) --- .../be/brainbaking/lists/SomeLinkedList.java | 60 +++++++++++++++++++ .../brainbaking/lists/SomeLinkedObject.java | 29 +++++++++ .../be/brainbaking/sorting/BucketSort.java | 20 ++++--- .../brainbaking/lists/SomeLinkedListTest.java | 51 ++++++++++++++++ 4 files changed, 152 insertions(+), 8 deletions(-) create mode 100644 sorting/java/src/be/brainbaking/lists/SomeLinkedList.java create mode 100644 sorting/java/src/be/brainbaking/lists/SomeLinkedObject.java create mode 100644 sorting/java/test/be/brainbaking/lists/SomeLinkedListTest.java diff --git a/sorting/java/src/be/brainbaking/lists/SomeLinkedList.java b/sorting/java/src/be/brainbaking/lists/SomeLinkedList.java new file mode 100644 index 0000000..650c605 --- /dev/null +++ b/sorting/java/src/be/brainbaking/lists/SomeLinkedList.java @@ -0,0 +1,60 @@ +package be.brainbaking.lists; + +import java.util.ArrayList; +import java.util.List; + +public class SomeLinkedList { + + private SomeLinkedObject head; + + public SomeLinkedList() { + } + + public SomeLinkedList(T singleItem) { + add(singleItem); + } + + public List toList() { + List theList = new ArrayList<>(); + SomeLinkedObject curr = head; + for(int i = 0; i < size(); i++) { + if(curr == null) { + return theList; + } + + theList.add(curr.getKey()); + curr = curr.getNext(); + } + return theList; + } + + public int size() { + SomeLinkedObject curr = head; + int theSize = 0; + while(curr != null) { + theSize++; + curr = curr.getNext(); + } + return theSize; + } + + public T get(int index) { + SomeLinkedObject curr = head; + for (int i = 0; i < index; i++) { + if (curr == null) { + return null; + } + + curr = curr.getNext(); + } + return curr == null ? null : curr.getKey(); + } + + public void add(T key) { + if(head == null) { + head = new SomeLinkedObject<>(key); + } else { + head = new SomeLinkedObject<>(new SomeLinkedObject<>(key), head.getKey()); + } + } +} diff --git a/sorting/java/src/be/brainbaking/lists/SomeLinkedObject.java b/sorting/java/src/be/brainbaking/lists/SomeLinkedObject.java new file mode 100644 index 0000000..92dcaac --- /dev/null +++ b/sorting/java/src/be/brainbaking/lists/SomeLinkedObject.java @@ -0,0 +1,29 @@ +package be.brainbaking.lists; + +public class SomeLinkedObject { + + private final SomeLinkedObject next; + private final T key; + + public SomeLinkedObject getNext() { + return next; + } + + @Override + public String toString() { + return "[" + key + "]"; + } + + public T getKey() { + return key; + } + + public SomeLinkedObject(T key) { + this(null, key); + } + + public SomeLinkedObject(SomeLinkedObject next, T key) { + this.next = next; + this.key = key; + } +} diff --git a/sorting/java/src/be/brainbaking/sorting/BucketSort.java b/sorting/java/src/be/brainbaking/sorting/BucketSort.java index 06fa632..8d30836 100644 --- a/sorting/java/src/be/brainbaking/sorting/BucketSort.java +++ b/sorting/java/src/be/brainbaking/sorting/BucketSort.java @@ -1,5 +1,7 @@ package be.brainbaking.sorting; +import be.brainbaking.lists.SomeLinkedList; + import java.util.ArrayList; import java.util.Arrays; import java.util.List; @@ -25,14 +27,14 @@ public class BucketSort implements Sortable { @Override public List sort(List list) { int n = list.size(); - List> buckets = initializeBuckets(n); + List> buckets = initializeBuckets(n); for(int i = 1; i <= n; i++) { int x = list.get(i - 1); int bucketIndex = calculateBucketIndex(n, x); if(buckets.size() <= bucketIndex) { - buckets.add(bucketIndex, Arrays.asList(x)); + buckets.add(bucketIndex, new SomeLinkedList<>(x)); } else { buckets.get(bucketIndex).add(x); } @@ -41,20 +43,22 @@ public class BucketSort implements Sortable { return mergeSortedBuckets(buckets); } - private List mergeSortedBuckets(List> buckets) { + private List mergeSortedBuckets(List> buckets) { List sorted = new ArrayList<>(); - for (List bucket : buckets) { - sorted.addAll(insertionSorter.sort(bucket)); + for (SomeLinkedList bucket : buckets) { + // crap... I'm too lazy to rewrite insertion sort to use the linkedlist or to implement List. Convert it! + + sorted.addAll(insertionSorter.sort(bucket.toList())); } return sorted; } - private List> initializeBuckets(int n) { - List> buckets = new ArrayList<>(); + private List> initializeBuckets(int n) { + List> buckets = new ArrayList<>(); for(int i = 0; i < n; i++) { - buckets.add(new ArrayList<>()); + buckets.add(new SomeLinkedList<>()); } return buckets; diff --git a/sorting/java/test/be/brainbaking/lists/SomeLinkedListTest.java b/sorting/java/test/be/brainbaking/lists/SomeLinkedListTest.java new file mode 100644 index 0000000..064de7a --- /dev/null +++ b/sorting/java/test/be/brainbaking/lists/SomeLinkedListTest.java @@ -0,0 +1,51 @@ +package be.brainbaking.lists; + +import org.junit.jupiter.api.Test; + +import static org.junit.jupiter.api.Assertions.assertEquals; + +public class SomeLinkedListTest { + + @Test + public void size_newList_isZero() { + SomeLinkedList list = new SomeLinkedList<>(); + + assertEquals(0, list.size()); + } + + @Test + public void add_increasesSize() { + SomeLinkedList list = new SomeLinkedList<>(); + list.add(123); + list.add(456); + + assertEquals(2, list.size()); + } + + @Test + public void get_getsByIndex_WithinRange() { + SomeLinkedList list = new SomeLinkedList<>(); + list.add(123); + list.add(456); + + assertEquals(123, (int) list.get(0)); + assertEquals(456, (int) list.get(1)); + } + + @Test + public void get_indexOutOfRange_ReturnsNull_endOfRange() { + SomeLinkedList list = new SomeLinkedList<>(); + list.add(123); + list.add(456); + + assertEquals(null, list.get(2)); + } + + @Test + public void get_indexOutOfRange_ReturnsNull_emptyList() { + SomeLinkedList list = new SomeLinkedList<>(); + + assertEquals(null, list.get(0)); + } + +}