From 7b08c6bf00ab026d9e3ba9510765af44d05b286c Mon Sep 17 00:00:00 2001 From: zevolution Date: Fri, 26 Feb 2021 22:05:04 -0300 Subject: [PATCH 01/20] Added Insertion Sort custom implementation Added draft of Insertion Sort Move test to specific class --- .../sorting/insertionsort/InsertionSort.java | 27 ++++++++++++ .../sorting/insertionsort/Product.java | 22 ++++++++++ .../insertionsort/InsertionSortTest.java | 43 +++++++++++++++++++ 3 files changed, 92 insertions(+) create mode 100644 src/main/java/br/com/zevolution/algorithms/sorting/insertionsort/InsertionSort.java create mode 100644 src/main/java/br/com/zevolution/algorithms/sorting/insertionsort/Product.java create mode 100644 src/test/java/br/com/zevolution/algorithms/sorting/insertionsort/InsertionSortTest.java diff --git a/src/main/java/br/com/zevolution/algorithms/sorting/insertionsort/InsertionSort.java b/src/main/java/br/com/zevolution/algorithms/sorting/insertionsort/InsertionSort.java new file mode 100644 index 0000000..05b876b --- /dev/null +++ b/src/main/java/br/com/zevolution/algorithms/sorting/insertionsort/InsertionSort.java @@ -0,0 +1,27 @@ +package br.com.zevolution.algorithms.sorting.insertionsort; + +public class InsertionSort { + + public static Product[] sortingByCheapest(Product[] products, int length) { + Product[] array = products.clone(); + for (int current = 1; current < length; current++) { + int beingAnalyzed = current; + + while (beingAnalyzed > 0) { + int previousBeingAnalyzed = beingAnalyzed - 1; + + Product currentProductBeingAnalyzed = array[beingAnalyzed]; + Product previousProductBeingAnalyzed = array[previousBeingAnalyzed]; + if (currentProductBeingAnalyzed.getPrice() < previousProductBeingAnalyzed.getPrice()) { + array[beingAnalyzed] = previousProductBeingAnalyzed; + array[previousBeingAnalyzed] = currentProductBeingAnalyzed; + + beingAnalyzed--; + } else { + break; + } + } + } + return array; + } +} \ No newline at end of file diff --git a/src/main/java/br/com/zevolution/algorithms/sorting/insertionsort/Product.java b/src/main/java/br/com/zevolution/algorithms/sorting/insertionsort/Product.java new file mode 100644 index 0000000..61c99dc --- /dev/null +++ b/src/main/java/br/com/zevolution/algorithms/sorting/insertionsort/Product.java @@ -0,0 +1,22 @@ +package br.com.zevolution.algorithms.sorting.insertionsort; + +public class Product { + + private String description; + private double price; + + public Product(String description, double price) { + this.description = description; + this.price = price; + } + + public double getPrice() { + return price; + } + + @Override + public String toString() { + return this.description; + } + +} diff --git a/src/test/java/br/com/zevolution/algorithms/sorting/insertionsort/InsertionSortTest.java b/src/test/java/br/com/zevolution/algorithms/sorting/insertionsort/InsertionSortTest.java new file mode 100644 index 0000000..ac96846 --- /dev/null +++ b/src/test/java/br/com/zevolution/algorithms/sorting/insertionsort/InsertionSortTest.java @@ -0,0 +1,43 @@ +package br.com.zevolution.algorithms.sorting.insertionsort; + +import static org.junit.Assert.*; + +import java.util.Arrays; + +import org.junit.Before; +import org.junit.Test; + +import br.com.zevolution.algorithms.sorting.insertionsort.Product; +import br.com.zevolution.algorithms.sorting.insertionsort.InsertionSort; + +public class InsertionSortTest { + + private static final double CHEAPEST_PRODUCT = 5; + private static final double MOST_EXPENSIVE_PRODUCT = 50; + private Product[] products; + + @Before + public void init() { + Product[] array = { + new Product("iMac", MOST_EXPENSIVE_PRODUCT), + new Product("iPhone", 8), + new Product("Notebook", 7), + new Product("Keyboard", 9), + new Product("Mouse", CHEAPEST_PRODUCT) + }; + this.products = array; + } + + @Test + public void should_Get_CheapestProduct() { + Product[] ordened = InsertionSort.sortingByCheapest(this.products, this.products.length); + assertEquals(CHEAPEST_PRODUCT, ordened[0].getPrice(), 0); + } + + @Test + public void should_Get_MostExpensiveProduct() { + Product[] ordened = InsertionSort.sortingByCheapest(this.products, this.products.length); + assertEquals(MOST_EXPENSIVE_PRODUCT, ordened[ordened.length - 1].getPrice(), 0); + } + +} From c7daaed805098897dec5001b4ed2dcad0b9a40d8 Mon Sep 17 00:00:00 2001 From: zevolution Date: Sat, 27 Feb 2021 20:19:21 -0300 Subject: [PATCH 02/20] Added draft of SortTester to facilitate the creation of the next tests --- .../algorithms/sorting/Product.java | 22 +++++++++++ .../zevolution/algorithms/sorting/Sort.java | 7 ++++ .../algorithms/sorting/SortTester.java | 5 +++ .../algorithms/sorting/SortingTestData.java | 37 +++++++++++++++++++ 4 files changed, 71 insertions(+) create mode 100644 src/main/java/br/com/zevolution/algorithms/sorting/Product.java create mode 100644 src/test/java/br/com/zevolution/algorithms/sorting/Sort.java create mode 100644 src/test/java/br/com/zevolution/algorithms/sorting/SortTester.java create mode 100644 src/test/java/br/com/zevolution/algorithms/sorting/SortingTestData.java diff --git a/src/main/java/br/com/zevolution/algorithms/sorting/Product.java b/src/main/java/br/com/zevolution/algorithms/sorting/Product.java new file mode 100644 index 0000000..376007f --- /dev/null +++ b/src/main/java/br/com/zevolution/algorithms/sorting/Product.java @@ -0,0 +1,22 @@ +package br.com.zevolution.algorithms.sorting; + +public class Product { + + private String description; + private double price; + + public Product(String description, double price) { + this.description = description; + this.price = price; + } + + public double getPrice() { + return price; + } + + @Override + public String toString() { + return this.description; + } + +} diff --git a/src/test/java/br/com/zevolution/algorithms/sorting/Sort.java b/src/test/java/br/com/zevolution/algorithms/sorting/Sort.java new file mode 100644 index 0000000..ff805ad --- /dev/null +++ b/src/test/java/br/com/zevolution/algorithms/sorting/Sort.java @@ -0,0 +1,7 @@ +package br.com.zevolution.algorithms.sorting; + +public interface Sort { + + Product[] sort(Product[] products, int length); + +} diff --git a/src/test/java/br/com/zevolution/algorithms/sorting/SortTester.java b/src/test/java/br/com/zevolution/algorithms/sorting/SortTester.java new file mode 100644 index 0000000..0d20791 --- /dev/null +++ b/src/test/java/br/com/zevolution/algorithms/sorting/SortTester.java @@ -0,0 +1,5 @@ +package br.com.zevolution.algorithms.sorting; + +public class SortTester { + +} diff --git a/src/test/java/br/com/zevolution/algorithms/sorting/SortingTestData.java b/src/test/java/br/com/zevolution/algorithms/sorting/SortingTestData.java new file mode 100644 index 0000000..53a15c5 --- /dev/null +++ b/src/test/java/br/com/zevolution/algorithms/sorting/SortingTestData.java @@ -0,0 +1,37 @@ +package br.com.zevolution.algorithms.sorting; + +public class SortingTestData { + + public static final Product[] SORTED_BY_LOWEST_PRICE = { + new Product("Mouse", 50), + new Product("Keyboard", 100), + new Product("Notebook", 3500), + new Product("iPhone 12 Pro Max Ultra Uou", 10000), + new Product("iMac", 30000) + }; + + public static final Product[] SORTED_BY_HIGHEST_PRICE = { + new Product("iMac", 30000), + new Product("iPhone 12 Pro Max Ultra Uou", 10000), + new Product("Notebook", 3500), + new Product("Keyboard", 100), + new Product("Mouse", 50) + }; + + public static final Product[] NOT_SORTED = { + new Product("iPhone 12 Pro Max Ultra Uou", 10000), + new Product("Keyboard", 100), + new Product("Notebook", 3500), + new Product("Mouse", 50), + new Product("iMac", 30000) + }; + + public static final Product[] SAME_PRODUCT = { + new Product("Mouse", 50), + new Product("Mouse", 50), + new Product("Mouse", 50), + new Product("Mouse", 50), + new Product("Mouse", 50) + }; + +} From 0db1359f69290e037e3b4cb62e1764d0c9f18544 Mon Sep 17 00:00:00 2001 From: zevolution Date: Sat, 27 Feb 2021 20:22:15 -0300 Subject: [PATCH 03/20] Modified java imports of class 'Product' --- .../sorting/insertionsort/InsertionSort.java | 2 ++ .../sorting/insertionsort/Product.java | 22 ------------------- .../sorting/selectionsort/Product.java | 22 ------------------- .../sorting/selectionsort/SelectionSort.java | 2 ++ .../insertionsort/InsertionSortTest.java | 7 ++---- .../selectionsort/SelectionSortTest.java | 7 +++--- 6 files changed, 10 insertions(+), 52 deletions(-) delete mode 100644 src/main/java/br/com/zevolution/algorithms/sorting/insertionsort/Product.java delete mode 100644 src/main/java/br/com/zevolution/algorithms/sorting/selectionsort/Product.java diff --git a/src/main/java/br/com/zevolution/algorithms/sorting/insertionsort/InsertionSort.java b/src/main/java/br/com/zevolution/algorithms/sorting/insertionsort/InsertionSort.java index 05b876b..7fed34e 100644 --- a/src/main/java/br/com/zevolution/algorithms/sorting/insertionsort/InsertionSort.java +++ b/src/main/java/br/com/zevolution/algorithms/sorting/insertionsort/InsertionSort.java @@ -1,5 +1,7 @@ package br.com.zevolution.algorithms.sorting.insertionsort; +import br.com.zevolution.algorithms.sorting.Product; + public class InsertionSort { public static Product[] sortingByCheapest(Product[] products, int length) { diff --git a/src/main/java/br/com/zevolution/algorithms/sorting/insertionsort/Product.java b/src/main/java/br/com/zevolution/algorithms/sorting/insertionsort/Product.java deleted file mode 100644 index 61c99dc..0000000 --- a/src/main/java/br/com/zevolution/algorithms/sorting/insertionsort/Product.java +++ /dev/null @@ -1,22 +0,0 @@ -package br.com.zevolution.algorithms.sorting.insertionsort; - -public class Product { - - private String description; - private double price; - - public Product(String description, double price) { - this.description = description; - this.price = price; - } - - public double getPrice() { - return price; - } - - @Override - public String toString() { - return this.description; - } - -} diff --git a/src/main/java/br/com/zevolution/algorithms/sorting/selectionsort/Product.java b/src/main/java/br/com/zevolution/algorithms/sorting/selectionsort/Product.java deleted file mode 100644 index 11aa4d6..0000000 --- a/src/main/java/br/com/zevolution/algorithms/sorting/selectionsort/Product.java +++ /dev/null @@ -1,22 +0,0 @@ -package br.com.zevolution.algorithms.sorting.selectionsort; - -public class Product { - - private String description; - private double price; - - public Product(String description, double price) { - this.description = description; - this.price = price; - } - - public double getPrice() { - return price; - } - - @Override - public String toString() { - return this.description; - } - -} diff --git a/src/main/java/br/com/zevolution/algorithms/sorting/selectionsort/SelectionSort.java b/src/main/java/br/com/zevolution/algorithms/sorting/selectionsort/SelectionSort.java index 1d01422..2f42a83 100644 --- a/src/main/java/br/com/zevolution/algorithms/sorting/selectionsort/SelectionSort.java +++ b/src/main/java/br/com/zevolution/algorithms/sorting/selectionsort/SelectionSort.java @@ -1,5 +1,7 @@ package br.com.zevolution.algorithms.sorting.selectionsort; +import br.com.zevolution.algorithms.sorting.Product; + public class SelectionSort { public static Product[] sortingByCheapest(Product[] products, int length) { diff --git a/src/test/java/br/com/zevolution/algorithms/sorting/insertionsort/InsertionSortTest.java b/src/test/java/br/com/zevolution/algorithms/sorting/insertionsort/InsertionSortTest.java index ac96846..ca2d032 100644 --- a/src/test/java/br/com/zevolution/algorithms/sorting/insertionsort/InsertionSortTest.java +++ b/src/test/java/br/com/zevolution/algorithms/sorting/insertionsort/InsertionSortTest.java @@ -1,14 +1,11 @@ package br.com.zevolution.algorithms.sorting.insertionsort; -import static org.junit.Assert.*; - -import java.util.Arrays; +import static org.junit.Assert.assertEquals; import org.junit.Before; import org.junit.Test; -import br.com.zevolution.algorithms.sorting.insertionsort.Product; -import br.com.zevolution.algorithms.sorting.insertionsort.InsertionSort; +import br.com.zevolution.algorithms.sorting.Product; public class InsertionSortTest { diff --git a/src/test/java/br/com/zevolution/algorithms/sorting/selectionsort/SelectionSortTest.java b/src/test/java/br/com/zevolution/algorithms/sorting/selectionsort/SelectionSortTest.java index ceceadd..3ae4722 100644 --- a/src/test/java/br/com/zevolution/algorithms/sorting/selectionsort/SelectionSortTest.java +++ b/src/test/java/br/com/zevolution/algorithms/sorting/selectionsort/SelectionSortTest.java @@ -1,10 +1,11 @@ package br.com.zevolution.algorithms.sorting.selectionsort; -import org.junit.Test; - -import static org.junit.Assert.*; +import static org.junit.Assert.assertEquals; import org.junit.Before; +import org.junit.Test; + +import br.com.zevolution.algorithms.sorting.Product; public class SelectionSortTest { From cd8fdbed9d263811df8ade51297557aaafa4e3f2 Mon Sep 17 00:00:00 2001 From: zevolution Date: Sat, 27 Feb 2021 20:25:57 -0300 Subject: [PATCH 04/20] Moved 'Sort' interface from test package to main package --- .../java/br/com/zevolution/algorithms/sorting/Sort.java | 0 1 file changed, 0 insertions(+), 0 deletions(-) rename src/{test => main}/java/br/com/zevolution/algorithms/sorting/Sort.java (100%) diff --git a/src/test/java/br/com/zevolution/algorithms/sorting/Sort.java b/src/main/java/br/com/zevolution/algorithms/sorting/Sort.java similarity index 100% rename from src/test/java/br/com/zevolution/algorithms/sorting/Sort.java rename to src/main/java/br/com/zevolution/algorithms/sorting/Sort.java From 95f3dd1c9fe543303c23b28d106acba44f116541 Mon Sep 17 00:00:00 2001 From: zevolution Date: Sat, 27 Feb 2021 22:05:44 -0300 Subject: [PATCH 05/20] Add equals() method in Product class --- .../algorithms/sorting/Product.java | 20 ++++++++++++++++++- 1 file changed, 19 insertions(+), 1 deletion(-) diff --git a/src/main/java/br/com/zevolution/algorithms/sorting/Product.java b/src/main/java/br/com/zevolution/algorithms/sorting/Product.java index 376007f..37791ef 100644 --- a/src/main/java/br/com/zevolution/algorithms/sorting/Product.java +++ b/src/main/java/br/com/zevolution/algorithms/sorting/Product.java @@ -19,4 +19,22 @@ public String toString() { return this.description; } -} + @Override + public boolean equals(Object obj) { + if (obj == null) + return false; + + if (this.getClass() != obj.getClass()) + return false; + + Product other = Product.class.cast(obj); + return other.toString().equals(this.toString()) && + other.getPrice() == this.getPrice(); + } + + @Override + public int hashCode() { + return super.hashCode(); + } + +} \ No newline at end of file From be80d091aad43d9f188cbd0e4d0ff6c934f1f869 Mon Sep 17 00:00:00 2001 From: zevolution Date: Sat, 27 Feb 2021 22:06:47 -0300 Subject: [PATCH 06/20] Add method 'testSort()' in SortTester --- .../zevolution/algorithms/sorting/SortTester.java | 12 +++++++++++- 1 file changed, 11 insertions(+), 1 deletion(-) diff --git a/src/test/java/br/com/zevolution/algorithms/sorting/SortTester.java b/src/test/java/br/com/zevolution/algorithms/sorting/SortTester.java index 0d20791..c6b8afd 100644 --- a/src/test/java/br/com/zevolution/algorithms/sorting/SortTester.java +++ b/src/test/java/br/com/zevolution/algorithms/sorting/SortTester.java @@ -1,5 +1,15 @@ package br.com.zevolution.algorithms.sorting; +import static br.com.zevolution.algorithms.sorting.SortingTestData.*; +import static org.junit.Assert.*; + public class SortTester { -} + public static void testSort(Sort sorter) { + assertArrayEquals(SORTED_BY_LOWEST_PRICE, sorter.sort(SORTED_BY_HIGHEST_PRICE, SORTED_BY_HIGHEST_PRICE.length)); + assertArrayEquals(SORTED_BY_LOWEST_PRICE, sorter.sort(SORTED_BY_LOWEST_PRICE, SORTED_BY_LOWEST_PRICE.length)); + assertArrayEquals(SORTED_BY_LOWEST_PRICE, sorter.sort(NOT_SORTED, NOT_SORTED.length)); + assertArrayEquals(SAME_PRODUCT, sorter.sort(SAME_PRODUCT, SAME_PRODUCT.length)); + } + +} \ No newline at end of file From 02a91b7084e554c0a8a7eefd71b1a675e632a29a Mon Sep 17 00:00:00 2001 From: zevolution Date: Sat, 27 Feb 2021 23:34:54 -0300 Subject: [PATCH 07/20] Implemented Sort interface in InsertionSort and SelectionSort --- .../algorithms/sorting/insertionsort/InsertionSort.java | 5 +++-- .../algorithms/sorting/selectionsort/SelectionSort.java | 7 ++++--- 2 files changed, 7 insertions(+), 5 deletions(-) diff --git a/src/main/java/br/com/zevolution/algorithms/sorting/insertionsort/InsertionSort.java b/src/main/java/br/com/zevolution/algorithms/sorting/insertionsort/InsertionSort.java index 7fed34e..86b26d6 100644 --- a/src/main/java/br/com/zevolution/algorithms/sorting/insertionsort/InsertionSort.java +++ b/src/main/java/br/com/zevolution/algorithms/sorting/insertionsort/InsertionSort.java @@ -1,10 +1,11 @@ package br.com.zevolution.algorithms.sorting.insertionsort; import br.com.zevolution.algorithms.sorting.Product; +import br.com.zevolution.algorithms.sorting.Sort; -public class InsertionSort { +public class InsertionSort implements Sort { - public static Product[] sortingByCheapest(Product[] products, int length) { + public Product[] sort(Product[] products, int length) { Product[] array = products.clone(); for (int current = 1; current < length; current++) { int beingAnalyzed = current; diff --git a/src/main/java/br/com/zevolution/algorithms/sorting/selectionsort/SelectionSort.java b/src/main/java/br/com/zevolution/algorithms/sorting/selectionsort/SelectionSort.java index 2f42a83..a6f8678 100644 --- a/src/main/java/br/com/zevolution/algorithms/sorting/selectionsort/SelectionSort.java +++ b/src/main/java/br/com/zevolution/algorithms/sorting/selectionsort/SelectionSort.java @@ -1,10 +1,11 @@ package br.com.zevolution.algorithms.sorting.selectionsort; import br.com.zevolution.algorithms.sorting.Product; +import br.com.zevolution.algorithms.sorting.Sort; -public class SelectionSort { +public class SelectionSort implements Sort { - public static Product[] sortingByCheapest(Product[] products, int length) { + public Product[] sort(Product[] products, int length) { Product[] array = products.clone(); for (int current = 0; current < length - 1; current++) { int cheapest = getCheapest(array, current, length - 1); @@ -18,7 +19,7 @@ public static Product[] sortingByCheapest(Product[] products, int length) { return array; } - private static int getCheapest(Product[] products, int beginIndex, int endIndex) { + private int getCheapest(Product[] products, int beginIndex, int endIndex) { int cheapest = beginIndex; for (int current = beginIndex; current <= endIndex; current++) { if (products[current].getPrice() < products[cheapest].getPrice()) { From b3547152bd5579fc559c56d9cc97e4b21091010f Mon Sep 17 00:00:00 2001 From: zevolution Date: Sat, 27 Feb 2021 23:38:43 -0300 Subject: [PATCH 08/20] Modified Insertion and Selection Sort test class to use SortTester --- .../insertionsort/InsertionSortTest.java | 32 ++--------------- .../selectionsort/SelectionSortTest.java | 34 +++---------------- 2 files changed, 7 insertions(+), 59 deletions(-) diff --git a/src/test/java/br/com/zevolution/algorithms/sorting/insertionsort/InsertionSortTest.java b/src/test/java/br/com/zevolution/algorithms/sorting/insertionsort/InsertionSortTest.java index ca2d032..33a50a4 100644 --- a/src/test/java/br/com/zevolution/algorithms/sorting/insertionsort/InsertionSortTest.java +++ b/src/test/java/br/com/zevolution/algorithms/sorting/insertionsort/InsertionSortTest.java @@ -1,40 +1,14 @@ package br.com.zevolution.algorithms.sorting.insertionsort; -import static org.junit.Assert.assertEquals; +import static br.com.zevolution.algorithms.sorting.SortTester.testSort; -import org.junit.Before; import org.junit.Test; -import br.com.zevolution.algorithms.sorting.Product; - public class InsertionSortTest { - private static final double CHEAPEST_PRODUCT = 5; - private static final double MOST_EXPENSIVE_PRODUCT = 50; - private Product[] products; - - @Before - public void init() { - Product[] array = { - new Product("iMac", MOST_EXPENSIVE_PRODUCT), - new Product("iPhone", 8), - new Product("Notebook", 7), - new Product("Keyboard", 9), - new Product("Mouse", CHEAPEST_PRODUCT) - }; - this.products = array; - } - - @Test - public void should_Get_CheapestProduct() { - Product[] ordened = InsertionSort.sortingByCheapest(this.products, this.products.length); - assertEquals(CHEAPEST_PRODUCT, ordened[0].getPrice(), 0); - } - @Test - public void should_Get_MostExpensiveProduct() { - Product[] ordened = InsertionSort.sortingByCheapest(this.products, this.products.length); - assertEquals(MOST_EXPENSIVE_PRODUCT, ordened[ordened.length - 1].getPrice(), 0); + public void should_Sort_Array() { + testSort(new InsertionSort()); } } diff --git a/src/test/java/br/com/zevolution/algorithms/sorting/selectionsort/SelectionSortTest.java b/src/test/java/br/com/zevolution/algorithms/sorting/selectionsort/SelectionSortTest.java index 3ae4722..754be75 100644 --- a/src/test/java/br/com/zevolution/algorithms/sorting/selectionsort/SelectionSortTest.java +++ b/src/test/java/br/com/zevolution/algorithms/sorting/selectionsort/SelectionSortTest.java @@ -1,40 +1,14 @@ package br.com.zevolution.algorithms.sorting.selectionsort; -import static org.junit.Assert.assertEquals; +import static br.com.zevolution.algorithms.sorting.SortTester.testSort; -import org.junit.Before; import org.junit.Test; -import br.com.zevolution.algorithms.sorting.Product; - public class SelectionSortTest { - private static final double CHEAPEST_PRODUCT = 5; - private static final double MOST_EXPENSIVE_PRODUCT = 50; - private Product[] products; - - @Before - public void init() { - Product[] array = { - new Product("iMac", MOST_EXPENSIVE_PRODUCT), - new Product("iPhone", 8), - new Product("Notebook", 7), - new Product("Keyboard", 9), - new Product("Mouse", CHEAPEST_PRODUCT) - }; - this.products = array; - } - @Test - public void should_Get_CheapestProduct() { - Product[] ordened = SelectionSort.sortingByCheapest(this.products, this.products.length); - assertEquals(CHEAPEST_PRODUCT, ordened[0].getPrice(), 0); + public void should_Sort_Array() { + testSort(new SelectionSort()); } - - @Test - public void should_Get_MostExpensiveProduct() { - Product[] ordened = SelectionSort.sortingByCheapest(this.products, this.products.length); - assertEquals(MOST_EXPENSIVE_PRODUCT, ordened[ordened.length - 1].getPrice(), 0); - } - + } From e13f52069a9002101eea31a630a7ee02d01888bf Mon Sep 17 00:00:00 2001 From: zevolution Date: Tue, 2 Mar 2021 01:30:31 -0300 Subject: [PATCH 09/20] Added draft of MergeSort --- .../sorting/mergesort/MergeSort.java | 50 +++++++++++++++++++ .../algorithms/sorting/mergesort/Product.java | 22 ++++++++ 2 files changed, 72 insertions(+) create mode 100644 src/main/java/br/com/zevolution/algorithms/sorting/mergesort/MergeSort.java create mode 100644 src/main/java/br/com/zevolution/algorithms/sorting/mergesort/Product.java diff --git a/src/main/java/br/com/zevolution/algorithms/sorting/mergesort/MergeSort.java b/src/main/java/br/com/zevolution/algorithms/sorting/mergesort/MergeSort.java new file mode 100644 index 0000000..cadca31 --- /dev/null +++ b/src/main/java/br/com/zevolution/algorithms/sorting/mergesort/MergeSort.java @@ -0,0 +1,50 @@ +package br.com.zevolution.algorithms.sorting.mergesort; + +import java.util.Arrays; + +public class MergeSort { + + public static void main(String[] args) { + + // Two previously ordered parts + Product[] products = { + new Product("product2", 4), + new Product("product3", 5), + new Product("product5", 8), + new Product("product6", 9), + new Product("product1", 3), + new Product("product4", 6), + new Product("product7", 9.3), + new Product("product8", 10) + }; + + Product[] array = sort(products); + + + System.out.println(Arrays.toString(array)); + + } + + private static Product[] sort(Product[] products) { + int medium = products.length / 2; + Product[] array = new Product[products.length]; + + int current = 0; + int left = 0; + int right = medium; + + while (left < medium && right < products.length) { + if (products[left].getPrice() < products[right].getPrice()) { + array[current] = products[left]; + left++; + } else { + array[current] = products[right]; + right++; + } + current++; + } + + return array; + } + +} \ No newline at end of file diff --git a/src/main/java/br/com/zevolution/algorithms/sorting/mergesort/Product.java b/src/main/java/br/com/zevolution/algorithms/sorting/mergesort/Product.java new file mode 100644 index 0000000..68fd8a3 --- /dev/null +++ b/src/main/java/br/com/zevolution/algorithms/sorting/mergesort/Product.java @@ -0,0 +1,22 @@ +package br.com.zevolution.algorithms.sorting.mergesort; + +public class Product { + + private String description; + private double price; + + public Product(String description, double price) { + this.description = description; + this.price = price; + } + + public double getPrice() { + return price; + } + + @Override + public String toString() { + return this.description; + } + +} From e9729e5ef442c07d7704bc71833d0ea4f93b2a9f Mon Sep 17 00:00:00 2001 From: zevolution Date: Tue, 2 Mar 2021 19:57:35 -0300 Subject: [PATCH 10/20] Adjusted method to sort a totally unsorted array --- .../sorting/mergesort/MergeSort.java | 48 +++++++++++++------ 1 file changed, 33 insertions(+), 15 deletions(-) diff --git a/src/main/java/br/com/zevolution/algorithms/sorting/mergesort/MergeSort.java b/src/main/java/br/com/zevolution/algorithms/sorting/mergesort/MergeSort.java index cadca31..4539669 100644 --- a/src/main/java/br/com/zevolution/algorithms/sorting/mergesort/MergeSort.java +++ b/src/main/java/br/com/zevolution/algorithms/sorting/mergesort/MergeSort.java @@ -6,34 +6,37 @@ public class MergeSort { public static void main(String[] args) { - // Two previously ordered parts + // Unsorted array Product[] products = { - new Product("product2", 4), new Product("product3", 5), - new Product("product5", 8), + new Product("product2", 4), new Product("product6", 9), - new Product("product1", 3), + new Product("product5", 8), new Product("product4", 6), - new Product("product7", 9.3), - new Product("product8", 10) + new Product("product1", 3), + new Product("product8", 10), + new Product("product7", 9.3) }; - Product[] array = sort(products); + mergeSort(products, 0, 1, 2); + mergeSort(products, 2, 3, 4); + mergeSort(products, 4, 5, 6); + mergeSort(products, 6, 7, 8); + mergeSort(products, 0, 4, 8); +// array = mergeSort(array, 0, 2, 4); - - System.out.println(Arrays.toString(array)); + System.out.println(Arrays.toString(products)); } - private static Product[] sort(Product[] products) { - int medium = products.length / 2; - Product[] array = new Product[products.length]; + private static void mergeSort(Product[] products, int low, int medium, int high) { + Product[] array = new Product[high-low]; int current = 0; - int left = 0; + int left = low; int right = medium; - while (left < medium && right < products.length) { + while (left < medium && right < high) { if (products[left].getPrice() < products[right].getPrice()) { array[current] = products[left]; left++; @@ -44,7 +47,22 @@ private static Product[] sort(Product[] products) { current++; } - return array; + while (left < medium) { + array[current] = products[left]; + left++; + current++; + } + + while (right < high) { + array[current] = products[right]; + right++; + current++; + } + + for (int i = 0; i < current; i++ ) { + products[low + i] = array[i]; + } + } } \ No newline at end of file From 42d4fd640e573328eb46bd69ec3b2f2b8eb092a7 Mon Sep 17 00:00:00 2001 From: zevolution Date: Wed, 3 Mar 2021 22:54:09 -0300 Subject: [PATCH 11/20] Implemented recursive algorithms concept in MergeSort --- .../sorting/mergesort/MergeSort.java | 44 ++++++++++++++----- 1 file changed, 33 insertions(+), 11 deletions(-) diff --git a/src/main/java/br/com/zevolution/algorithms/sorting/mergesort/MergeSort.java b/src/main/java/br/com/zevolution/algorithms/sorting/mergesort/MergeSort.java index 4539669..9e08861 100644 --- a/src/main/java/br/com/zevolution/algorithms/sorting/mergesort/MergeSort.java +++ b/src/main/java/br/com/zevolution/algorithms/sorting/mergesort/MergeSort.java @@ -2,6 +2,8 @@ import java.util.Arrays; +import br.com.zevolution.algorithms.sorting.insertionsort.Product; + public class MergeSort { public static void main(String[] args) { @@ -14,29 +16,49 @@ public static void main(String[] args) { new Product("product5", 8), new Product("product4", 6), new Product("product1", 3), - new Product("product8", 10), + new Product("product9", 10), + new Product("product8", 9.7), new Product("product7", 9.3) }; - mergeSort(products, 0, 1, 2); - mergeSort(products, 2, 3, 4); - mergeSort(products, 4, 5, 6); - mergeSort(products, 6, 7, 8); - mergeSort(products, 0, 4, 8); +// mergeSort(products, 0, 1, 2); +// mergeSort(products, 2, 3, 4); +// mergeSort(products, 4, 5, 6); +// mergeSort(products, 6, 7, 8); +// mergeSort(products, 0, 4, 8); + Product[] sorted = sort(products, products.length); // array = mergeSort(array, 0, 2, 4); - System.out.println(Arrays.toString(products)); + System.out.println(Arrays.toString(sorted)); + + } + + public static Product[] sort(Product[] products, int length) { + Product[] array = products.clone(); + mergeSort(array, 0, length); + return array; + } + + private static void mergeSort(Product[] products, int start, int end) { + int length = end - start; + if (length > 1) { + int middle = (start + end) >> 1; // as well as (start + end) / 2 + + mergeSort(products, start, middle); + mergeSort(products, middle, end); + mergeSort(products, start, middle, end); + } } - private static void mergeSort(Product[] products, int low, int medium, int high) { + private static void mergeSort(Product[] products, int low, int middle, int high) { Product[] array = new Product[high-low]; int current = 0; int left = low; - int right = medium; + int right = middle; - while (left < medium && right < high) { + while (left < middle && right < high) { if (products[left].getPrice() < products[right].getPrice()) { array[current] = products[left]; left++; @@ -47,7 +69,7 @@ private static void mergeSort(Product[] products, int low, int medium, int high) current++; } - while (left < medium) { + while (left < middle) { array[current] = products[left]; left++; current++; From 77838fb991414af22194dd9a0dd7c924574ab479 Mon Sep 17 00:00:00 2001 From: zevolution Date: Wed, 3 Mar 2021 23:25:57 -0300 Subject: [PATCH 12/20] Conclusion of the custom implementation of MergeSort --- .../sorting/mergesort/MergeSort.java | 42 ++++--------------- .../algorithms/sorting/mergesort/Product.java | 22 ---------- .../sorting/mergesort/MergeSortTest.java | 14 +++++++ 3 files changed, 21 insertions(+), 57 deletions(-) delete mode 100644 src/main/java/br/com/zevolution/algorithms/sorting/mergesort/Product.java create mode 100644 src/test/java/br/com/zevolution/algorithms/sorting/mergesort/MergeSortTest.java diff --git a/src/main/java/br/com/zevolution/algorithms/sorting/mergesort/MergeSort.java b/src/main/java/br/com/zevolution/algorithms/sorting/mergesort/MergeSort.java index 9e08861..e6998ed 100644 --- a/src/main/java/br/com/zevolution/algorithms/sorting/mergesort/MergeSort.java +++ b/src/main/java/br/com/zevolution/algorithms/sorting/mergesort/MergeSort.java @@ -1,49 +1,21 @@ package br.com.zevolution.algorithms.sorting.mergesort; -import java.util.Arrays; +import br.com.zevolution.algorithms.sorting.Product; +import br.com.zevolution.algorithms.sorting.Sort; -import br.com.zevolution.algorithms.sorting.insertionsort.Product; +public class MergeSort implements Sort { -public class MergeSort { - - public static void main(String[] args) { - - // Unsorted array - Product[] products = { - new Product("product3", 5), - new Product("product2", 4), - new Product("product6", 9), - new Product("product5", 8), - new Product("product4", 6), - new Product("product1", 3), - new Product("product9", 10), - new Product("product8", 9.7), - new Product("product7", 9.3) - }; - -// mergeSort(products, 0, 1, 2); -// mergeSort(products, 2, 3, 4); -// mergeSort(products, 4, 5, 6); -// mergeSort(products, 6, 7, 8); -// mergeSort(products, 0, 4, 8); - Product[] sorted = sort(products, products.length); -// array = mergeSort(array, 0, 2, 4); - - System.out.println(Arrays.toString(sorted)); - - } - - public static Product[] sort(Product[] products, int length) { + public Product[] sort(Product[] products, int length) { Product[] array = products.clone(); mergeSort(array, 0, length); return array; } - private static void mergeSort(Product[] products, int start, int end) { + private void mergeSort(Product[] products, int start, int end) { int length = end - start; if (length > 1) { - int middle = (start + end) >> 1; // as well as (start + end) / 2 + int middle = (start + end) >> 1; mergeSort(products, start, middle); mergeSort(products, middle, end); @@ -51,7 +23,7 @@ private static void mergeSort(Product[] products, int start, int end) { } } - private static void mergeSort(Product[] products, int low, int middle, int high) { + private void mergeSort(Product[] products, int low, int middle, int high) { Product[] array = new Product[high-low]; int current = 0; diff --git a/src/main/java/br/com/zevolution/algorithms/sorting/mergesort/Product.java b/src/main/java/br/com/zevolution/algorithms/sorting/mergesort/Product.java deleted file mode 100644 index 68fd8a3..0000000 --- a/src/main/java/br/com/zevolution/algorithms/sorting/mergesort/Product.java +++ /dev/null @@ -1,22 +0,0 @@ -package br.com.zevolution.algorithms.sorting.mergesort; - -public class Product { - - private String description; - private double price; - - public Product(String description, double price) { - this.description = description; - this.price = price; - } - - public double getPrice() { - return price; - } - - @Override - public String toString() { - return this.description; - } - -} diff --git a/src/test/java/br/com/zevolution/algorithms/sorting/mergesort/MergeSortTest.java b/src/test/java/br/com/zevolution/algorithms/sorting/mergesort/MergeSortTest.java new file mode 100644 index 0000000..22cc747 --- /dev/null +++ b/src/test/java/br/com/zevolution/algorithms/sorting/mergesort/MergeSortTest.java @@ -0,0 +1,14 @@ +package br.com.zevolution.algorithms.sorting.mergesort; + +import static br.com.zevolution.algorithms.sorting.SortTester.testSort; + +import org.junit.Test; + +public class MergeSortTest { + + @Test + public void should_Sort_Array() { + testSort(new MergeSort()); + } + +} From 76308586b1884f2c139a0e697c2efd6a115a8e90 Mon Sep 17 00:00:00 2001 From: zevolution Date: Wed, 3 Mar 2021 23:52:06 -0300 Subject: [PATCH 13/20] Added test to prevents modification in original array --- .../br/com/zevolution/algorithms/sorting/SortTester.java | 6 ++++++ 1 file changed, 6 insertions(+) diff --git a/src/test/java/br/com/zevolution/algorithms/sorting/SortTester.java b/src/test/java/br/com/zevolution/algorithms/sorting/SortTester.java index c6b8afd..ff120e5 100644 --- a/src/test/java/br/com/zevolution/algorithms/sorting/SortTester.java +++ b/src/test/java/br/com/zevolution/algorithms/sorting/SortTester.java @@ -3,6 +3,8 @@ import static br.com.zevolution.algorithms.sorting.SortingTestData.*; import static org.junit.Assert.*; +import java.util.Arrays; + public class SortTester { public static void testSort(Sort sorter) { @@ -10,6 +12,10 @@ public static void testSort(Sort sorter) { assertArrayEquals(SORTED_BY_LOWEST_PRICE, sorter.sort(SORTED_BY_LOWEST_PRICE, SORTED_BY_LOWEST_PRICE.length)); assertArrayEquals(SORTED_BY_LOWEST_PRICE, sorter.sort(NOT_SORTED, NOT_SORTED.length)); assertArrayEquals(SAME_PRODUCT, sorter.sort(SAME_PRODUCT, SAME_PRODUCT.length)); + + // Make sure which original array it's not modified + sorter.sort(NOT_SORTED, NOT_SORTED.length); + assertFalse(Arrays.equals(SORTED_BY_LOWEST_PRICE, NOT_SORTED)); } } \ No newline at end of file From 585e970b8e0e9e4257e37572e2fc8e49118766ca Mon Sep 17 00:00:00 2001 From: zevolution Date: Fri, 5 Mar 2021 00:28:53 -0300 Subject: [PATCH 14/20] Added first step of the QuickSort --- .../sorting/quicksort/QuickSort.java | 35 +++++++++++++++++++ 1 file changed, 35 insertions(+) create mode 100644 src/main/java/br/com/zevolution/algorithms/sorting/quicksort/QuickSort.java diff --git a/src/main/java/br/com/zevolution/algorithms/sorting/quicksort/QuickSort.java b/src/main/java/br/com/zevolution/algorithms/sorting/quicksort/QuickSort.java new file mode 100644 index 0000000..8e88e88 --- /dev/null +++ b/src/main/java/br/com/zevolution/algorithms/sorting/quicksort/QuickSort.java @@ -0,0 +1,35 @@ +package br.com.zevolution.algorithms.sorting.quicksort; + +import br.com.zevolution.algorithms.sorting.Product; + +public class QuickSort { + + public static void main(String[] args) { + + Product[] products = { + new Product("iMac", 30000), + new Product("Keyboard", 100), + new Product("iPhone 12 Pro Max Ultra Uou", 10000), + new Product("Mouse", 50), + new Product("Notebook", 3500) + }; + + getCheapests(products, products.length); + + } + + private static void getCheapests(Product[] products, int length) { + int cheapest = 0; + + for (int current = 0; current < length - 1; current++) { + Product currentProduct = products[current]; + if (currentProduct.getPrice() < products[length - 1].getPrice()) { + cheapest++; + } + } + + System.out.println(String.format("There are %d cheaper products.", cheapest)); + + } + +} From a7909fa603ac2ad30fa49de64ea15958fbb3cadd Mon Sep 17 00:00:00 2001 From: zevolution Date: Fri, 5 Mar 2021 00:54:42 -0300 Subject: [PATCH 15/20] Created method to swap cheapest items to the left side and most expensive to the right side of the pivot --- .../sorting/quicksort/QuickSort.java | 22 +++++++++++++++---- 1 file changed, 18 insertions(+), 4 deletions(-) diff --git a/src/main/java/br/com/zevolution/algorithms/sorting/quicksort/QuickSort.java b/src/main/java/br/com/zevolution/algorithms/sorting/quicksort/QuickSort.java index 8e88e88..d1e15f7 100644 --- a/src/main/java/br/com/zevolution/algorithms/sorting/quicksort/QuickSort.java +++ b/src/main/java/br/com/zevolution/algorithms/sorting/quicksort/QuickSort.java @@ -1,5 +1,7 @@ package br.com.zevolution.algorithms.sorting.quicksort; +import java.util.Arrays; + import br.com.zevolution.algorithms.sorting.Product; public class QuickSort { @@ -14,22 +16,34 @@ public static void main(String[] args) { new Product("Notebook", 3500) }; - getCheapests(products, products.length); + int cheapests = getCheapests(products, products.length); + System.out.println(String.format("There are %d cheaper products.", cheapests)); + System.out.println(Arrays.toString(products)); } - private static void getCheapests(Product[] products, int length) { + private static int getCheapests(Product[] products, int length) { int cheapest = 0; + Product pivotProduct = products[length - 1]; for (int current = 0; current < length - 1; current++) { Product currentProduct = products[current]; - if (currentProduct.getPrice() < products[length - 1].getPrice()) { + if (currentProduct.getPrice() < pivotProduct.getPrice()) { + swap(products, current, cheapest); cheapest++; } } - System.out.println(String.format("There are %d cheaper products.", cheapest)); + swap(products, length - 1, cheapest); + return cheapest; + } + + private static void swap(Product[] products, int from, int to) { + Product productFrom = products[from]; + Product productTo = products[to]; + products[from] = productTo; + products[to] = productFrom; } } From 7cf5ed7164505f69b73706bb99d59cd3138cd957 Mon Sep 17 00:00:00 2001 From: zevolution Date: Fri, 5 Mar 2021 01:40:43 -0300 Subject: [PATCH 16/20] Implemented recursive algorithms concept in QuickSort --- .../sorting/quicksort/QuickSort.java | 24 ++++++++++++------- 1 file changed, 16 insertions(+), 8 deletions(-) diff --git a/src/main/java/br/com/zevolution/algorithms/sorting/quicksort/QuickSort.java b/src/main/java/br/com/zevolution/algorithms/sorting/quicksort/QuickSort.java index d1e15f7..8dcdfcd 100644 --- a/src/main/java/br/com/zevolution/algorithms/sorting/quicksort/QuickSort.java +++ b/src/main/java/br/com/zevolution/algorithms/sorting/quicksort/QuickSort.java @@ -16,25 +16,33 @@ public static void main(String[] args) { new Product("Notebook", 3500) }; - int cheapests = getCheapests(products, products.length); - System.out.println(String.format("There are %d cheaper products.", cheapests)); + quickSort(products, 0, products.length); System.out.println(Arrays.toString(products)); } - private static int getCheapests(Product[] products, int length) { - int cheapest = 0; + private static void quickSort(Product[] products, int start, int end) { + int length = end - start; + if (length > 1) { + int pivot = partitionProducts(products, start, end); + quickSort(products, start, pivot); + quickSort(products, pivot + 1, end); + } + } + + private static int partitionProducts(Product[] products, int start, int end) { + int cheapest = start; - Product pivotProduct = products[length - 1]; - for (int current = 0; current < length - 1; current++) { + Product pivotProduct = products[end - 1]; + for (int current = start; current < end - 1; current++) { Product currentProduct = products[current]; - if (currentProduct.getPrice() < pivotProduct.getPrice()) { + if (currentProduct.getPrice() <= pivotProduct.getPrice()) { swap(products, current, cheapest); cheapest++; } } - swap(products, length - 1, cheapest); + swap(products, end - 1, cheapest); return cheapest; } From 2e7ac147513157194c7197ef893653b51184ea29 Mon Sep 17 00:00:00 2001 From: zevolution Date: Sat, 6 Mar 2021 20:03:21 -0300 Subject: [PATCH 17/20] Conclusion of the custom implementation of QuickSort --- .../sorting/quicksort/QuickSort.java | 50 ++++++++----------- .../sorting/quicksort/QuickSortTest.java | 15 ++++++ 2 files changed, 36 insertions(+), 29 deletions(-) create mode 100644 src/test/java/br/com/zevolution/algorithms/sorting/quicksort/QuickSortTest.java diff --git a/src/main/java/br/com/zevolution/algorithms/sorting/quicksort/QuickSort.java b/src/main/java/br/com/zevolution/algorithms/sorting/quicksort/QuickSort.java index 8dcdfcd..2dbff8f 100644 --- a/src/main/java/br/com/zevolution/algorithms/sorting/quicksort/QuickSort.java +++ b/src/main/java/br/com/zevolution/algorithms/sorting/quicksort/QuickSort.java @@ -1,57 +1,49 @@ package br.com.zevolution.algorithms.sorting.quicksort; -import java.util.Arrays; - import br.com.zevolution.algorithms.sorting.Product; +import br.com.zevolution.algorithms.sorting.Sort; + +public class QuickSort implements Sort { + + @Override + public Product[] sort(Product[] products, int length) { + Product[] array = products.clone(); + this.quickSort(array, 0, length); + return array; -public class QuickSort { - - public static void main(String[] args) { - - Product[] products = { - new Product("iMac", 30000), - new Product("Keyboard", 100), - new Product("iPhone 12 Pro Max Ultra Uou", 10000), - new Product("Mouse", 50), - new Product("Notebook", 3500) - }; - - quickSort(products, 0, products.length); - - System.out.println(Arrays.toString(products)); } - private static void quickSort(Product[] products, int start, int end) { + private void quickSort(Product[] products, int start, int end) { int length = end - start; if (length > 1) { - int pivot = partitionProducts(products, start, end); - quickSort(products, start, pivot); - quickSort(products, pivot + 1, end); + int pivot = this.partitionProducts(products, start, end); + this.quickSort(products, start, pivot); + this.quickSort(products, pivot + 1, end); } } - private static int partitionProducts(Product[] products, int start, int end) { + private int partitionProducts(Product[] products, int start, int end) { int cheapest = start; - + Product pivotProduct = products[end - 1]; for (int current = start; current < end - 1; current++) { Product currentProduct = products[current]; if (currentProduct.getPrice() <= pivotProduct.getPrice()) { - swap(products, current, cheapest); + this.swap(products, current, cheapest); cheapest++; } } - - swap(products, end - 1, cheapest); - + + this.swap(products, end - 1, cheapest); + return cheapest; } - private static void swap(Product[] products, int from, int to) { + private void swap(Product[] products, int from, int to) { Product productFrom = products[from]; Product productTo = products[to]; products[from] = productTo; products[to] = productFrom; } -} +} \ No newline at end of file diff --git a/src/test/java/br/com/zevolution/algorithms/sorting/quicksort/QuickSortTest.java b/src/test/java/br/com/zevolution/algorithms/sorting/quicksort/QuickSortTest.java new file mode 100644 index 0000000..15b096e --- /dev/null +++ b/src/test/java/br/com/zevolution/algorithms/sorting/quicksort/QuickSortTest.java @@ -0,0 +1,15 @@ +package br.com.zevolution.algorithms.sorting.quicksort; + +import static br.com.zevolution.algorithms.sorting.SortTester.testSort; +import static org.junit.Assert.*; + +import org.junit.Test; + +public class QuickSortTest { + + @Test + public void should_Sort_Array() { + testSort(new QuickSort()); + } + +} From 3a144156c5fb79f5b001a1060f5e42fac8585072 Mon Sep 17 00:00:00 2001 From: zevolution Date: Sun, 7 Mar 2021 20:57:52 -0300 Subject: [PATCH 18/20] Add pom.xml --- .gitignore | 1 + pom.xml | 24 ++++++++++++++++++++++++ 2 files changed, 25 insertions(+) create mode 100644 pom.xml diff --git a/.gitignore b/.gitignore index 1933432..149dcaf 100644 --- a/.gitignore +++ b/.gitignore @@ -1,6 +1,7 @@ .attach_pid* /src/target/ /src/.attach_pid* +/target !.mvn/wrapper/maven-wrapper.jar ### sts ### diff --git a/pom.xml b/pom.xml new file mode 100644 index 0000000..79c812b --- /dev/null +++ b/pom.xml @@ -0,0 +1,24 @@ + + + 4.0.0 + + br.com.zevolution + java-algorithms-and-datastructure + 0.0.1-SNAPSHOT + java-algorithms-and-datastructure + Algorithms and data structures implemented in Java + + + 1.8 + + + + + junit + junit + 4.12 + + + From c154319009f100df68a26f6bf392b59ccb84f674 Mon Sep 17 00:00:00 2001 From: zevolution Date: Sun, 7 Mar 2021 21:01:48 -0300 Subject: [PATCH 19/20] Add README --- README.md | 41 +++++++++++++++++++++++++++++++++++++++++ 1 file changed, 41 insertions(+) create mode 100644 README.md diff --git a/README.md b/README.md new file mode 100644 index 0000000..468117b --- /dev/null +++ b/README.md @@ -0,0 +1,41 @@ +

+AlgoAndDataStruct-Logo +

Java Algorithms and Data Structures

+ +## Table of contents +- [About the project](#about-the-project) +- [Description](#description) +- [Built with](#built-with) +- [Installation](#installation) +- [Run](#run) +- [License](#license) + +## About the project +Basically, it's about algorithms and data structure and was created for the purpose of learning, researching, and recording all the content so that I can return when necessary. + +## Description +This project contains basic implementations using Java so that anyone can learn from examples. + +## Built with +* [Java 8](https://java.com/en/download/help/java8.html) +* [JUnit 4](https://junit.org/junit4/) +* [Maven](https://maven.apache.org/) + +## Installation + +To clone and run this application, you'll need Git installed on your computer(or no, if you want to download **.zip**). From your command line: +```bash +# Git CLI +git clone https://github.com/zevolution/java-algorithms-and-datastructure.git + +# Github CLI +gh repo clone zevolution/java-algorithms-and-datastructure +``` + +## Run +```bash +mvn test +``` + +## License +[MIT](https://choosealicense.com/licenses/mit/) \ No newline at end of file From bf457b387013e625a6a94981ad7c120d575b1840 Mon Sep 17 00:00:00 2001 From: zevolution Date: Mon, 15 Mar 2021 23:16:35 -0300 Subject: [PATCH 20/20] Added 'remove' method to remove by element in CustomLinkedList --- .../linkedlist/CustomLinkedList.java | 27 +++++++++++++++++++ .../linkedlist/CustomLinkedListTest.java | 14 ++++++++++ 2 files changed, 41 insertions(+) diff --git a/src/main/java/br/com/zevolution/datastructure/linkedlist/CustomLinkedList.java b/src/main/java/br/com/zevolution/datastructure/linkedlist/CustomLinkedList.java index 3954268..997996c 100644 --- a/src/main/java/br/com/zevolution/datastructure/linkedlist/CustomLinkedList.java +++ b/src/main/java/br/com/zevolution/datastructure/linkedlist/CustomLinkedList.java @@ -58,6 +58,33 @@ public void removeFirst() { } } + public void remove(Object element) { + Node current = this.first; + Node previous = null; + + if (current.getElement() == element) { + this.first = current.getNext(); + current = null; + this.totalElements--; + return; + } + + while (current != null) { + if (current.getElement() == element) { + break; + } + + previous = current; + current = current.getNext(); + } + + if (current == null) return; + + previous.setNext(current.getNext()); + current = null; + this.totalElements--; + } + public Object get(int position) { return this.getNode(position).getElement(); } diff --git a/src/test/java/br/com/zevolution/datastructure/linkedlist/CustomLinkedListTest.java b/src/test/java/br/com/zevolution/datastructure/linkedlist/CustomLinkedListTest.java index 1166a82..e3ee958 100644 --- a/src/test/java/br/com/zevolution/datastructure/linkedlist/CustomLinkedListTest.java +++ b/src/test/java/br/com/zevolution/datastructure/linkedlist/CustomLinkedListTest.java @@ -93,4 +93,18 @@ public void should_ThrowException_When_NoSuchElement() { linkedList.removeFirst(); } + @Test + public void should_RemoveMiddleElement() { + CustomLinkedList linkedList = new CustomLinkedList(); + linkedList.add("Bia"); + linkedList.add("Lucas"); + linkedList.add("Laura"); + + linkedList.remove("Lucas"); + + assertEquals(2, linkedList.size()); + assertEquals("Bia", linkedList.get(0)); + assertEquals("Laura", linkedList.get(1)); + } + }