From c0020903e2fc0993a8450f0e23fc242d94786191 Mon Sep 17 00:00:00 2001 From: nik Date: Fri, 13 Apr 2018 09:36:44 +0300 Subject: [PATCH 1/3] Added a iterative version of ternary search algorithm and some minor changes in documentation --- .../src/search/IterativeTernarySearch.java | 76 +++++++++++++++++++ Sorts/src/sort/SortAlgorithm.java | 2 +- 2 files changed, 77 insertions(+), 1 deletion(-) create mode 100644 Searches/src/search/IterativeTernarySearch.java diff --git a/Searches/src/search/IterativeTernarySearch.java b/Searches/src/search/IterativeTernarySearch.java new file mode 100644 index 000000000..74ef850ae --- /dev/null +++ b/Searches/src/search/IterativeTernarySearch.java @@ -0,0 +1,76 @@ +package search; + +import java.util.Arrays; +import java.util.Random; +import java.util.stream.Stream; + +import static java.lang.String.format; + +/** + * + * A iterative version of a ternary search algorithm + * This is better way to implement the ternary search, because a recursive version adds some overhead to a stack. + * But in java the compile can transform the recursive version to iterative implicitly, + * so there are no much differences between these two algorithms + * + * Worst-case performance Θ(log3(N)) + * Best-case performance O(1) + * Average performance Θ(log3(N)) + * Worst-case space complexity O(1) + * + * + * @author Podshivalov Nikita (https://github.com/nikitap492) + * @since 2018-04-13 + * + * @see SearchAlgorithm + * @see TernarySearch + * + */ + +public class IterativeTernarySearch implements SearchAlgorithm { + + + @Override + public > int find(T[] array, T key) { + int left = 0; + int right = array.length - 1; + while (true) { + int leftCmp = array[left].compareTo(key); + int rightCmp = array[right].compareTo(key); + if (leftCmp == 0) return left; + if (rightCmp == 0) return right; + + int leftThird = left + (right - left) / 3; + int rightThird = right - (right - left) /3; + + if (array[leftThird].compareTo(key) <= 0) left = leftThird; + else right = rightThird; + } + + } + + + public static void main(String[] args) { + //just generate data + Random r = new Random(); + int size = 100; + int maxElement = 100000; + Integer[] integers = Stream.generate(() -> r.nextInt(maxElement)).limit(size).sorted().toArray(Integer[]::new); + + + //the element that should be found + Integer shouldBeFound = integers[r.nextInt(size - 1)]; + + IterativeTernarySearch search = new IterativeTernarySearch(); + int atIndex = search.find(integers, shouldBeFound); + + System.out.println(format("Should be found: %d. Found %d at index %d. An array length %d" + , shouldBeFound, integers[atIndex], atIndex, size)); + + int toCheck = Arrays.binarySearch(integers, shouldBeFound); + System.out.println(format("Found by system method at an index: %d. Is equal: %b", toCheck, toCheck == atIndex)); + + } + + +} diff --git a/Sorts/src/sort/SortAlgorithm.java b/Sorts/src/sort/SortAlgorithm.java index 1a9f0437e..46b1f58e1 100644 --- a/Sorts/src/sort/SortAlgorithm.java +++ b/Sorts/src/sort/SortAlgorithm.java @@ -4,7 +4,7 @@ import java.util.Arrays; import java.util.List; /** - * The common interface of most algorithms + * The common interface of most sorting algorithms * * @author Podshivalov Nikita (https://github.com/nikitap492) * From 014bfda4f906e3dd76311310e34db586aa0f7793 Mon Sep 17 00:00:00 2001 From: nik Date: Thu, 19 Apr 2018 09:44:48 +0300 Subject: [PATCH 2/3] Fixed bug with an infinite loop when an array doesn't contain a key Fulfilled the code style request --- .../src/search/IterativeTernarySearch.java | 24 ++++++++++++------- 1 file changed, 16 insertions(+), 8 deletions(-) diff --git a/Searches/src/search/IterativeTernarySearch.java b/Searches/src/search/IterativeTernarySearch.java index 74ef850ae..684d48c16 100644 --- a/Searches/src/search/IterativeTernarySearch.java +++ b/Searches/src/search/IterativeTernarySearch.java @@ -34,19 +34,26 @@ public class IterativeTernarySearch implements SearchAlgorithm { public > int find(T[] array, T key) { int left = 0; int right = array.length - 1; - while (true) { + + while (right > left) { + int leftCmp = array[left].compareTo(key); int rightCmp = array[right].compareTo(key); if (leftCmp == 0) return left; if (rightCmp == 0) return right; - int leftThird = left + (right - left) / 3; - int rightThird = right - (right - left) /3; + int leftThird = left + (right - left) / 3 + 1; + int rightThird = right - (right - left) / 3 - 1; - if (array[leftThird].compareTo(key) <= 0) left = leftThird; - else right = rightThird; + + if (array[leftThird].compareTo(key) <= 0) { + left = leftThird; + } else { + right = rightThird; + } } + return -1; } @@ -64,11 +71,12 @@ public class IterativeTernarySearch implements SearchAlgorithm { IterativeTernarySearch search = new IterativeTernarySearch(); int atIndex = search.find(integers, shouldBeFound); - System.out.println(format("Should be found: %d. Found %d at index %d. An array length %d" - , shouldBeFound, integers[atIndex], atIndex, size)); + System.out.println(format("Should be found: %d. Found %d at index %d. An array length %d", + shouldBeFound, integers[atIndex], atIndex, size)); int toCheck = Arrays.binarySearch(integers, shouldBeFound); - System.out.println(format("Found by system method at an index: %d. Is equal: %b", toCheck, toCheck == atIndex)); + System.out.println(format("Found by system method at an index: %d. Is equal: %b", + toCheck, toCheck == atIndex)); } From ecfd0f0d72e108cbdeb1db1f3213a5de33cd62bc Mon Sep 17 00:00:00 2001 From: nik Date: Thu, 19 Apr 2018 09:47:11 +0300 Subject: [PATCH 3/3] Changed code style --- Searches/src/search/IterativeTernarySearch.java | 5 ++++- 1 file changed, 4 insertions(+), 1 deletion(-) diff --git a/Searches/src/search/IterativeTernarySearch.java b/Searches/src/search/IterativeTernarySearch.java index 684d48c16..c3538e69f 100644 --- a/Searches/src/search/IterativeTernarySearch.java +++ b/Searches/src/search/IterativeTernarySearch.java @@ -62,7 +62,10 @@ public class IterativeTernarySearch implements SearchAlgorithm { Random r = new Random(); int size = 100; int maxElement = 100000; - Integer[] integers = Stream.generate(() -> r.nextInt(maxElement)).limit(size).sorted().toArray(Integer[]::new); + Integer[] integers = Stream.generate(() -> r.nextInt(maxElement)) + .limit(size) + .sorted() + .toArray(Integer[]::new); //the element that should be found