From d58e10c31a3aa2a33e06c750a562257f1ec0dc06 Mon Sep 17 00:00:00 2001
From: Brandon Rodriguez <brodriguez8774@gmail.com>
Date: Wed, 27 Sep 2017 16:47:39 -0400
Subject: [PATCH] Update searches to account for duplicate characters
---
a0/src/com/CS3310/a0/Controller.java | 154 ++++++++++++++++++++++++---
1 file changed, 140 insertions(+), 14 deletions(-)
diff --git a/a0/src/com/CS3310/a0/Controller.java b/a0/src/com/CS3310/a0/Controller.java
index 7a8f435..81e5d34 100644
--- a/a0/src/com/CS3310/a0/Controller.java
+++ b/a0/src/com/CS3310/a0/Controller.java
@@ -16,7 +16,9 @@ public class Controller {
private int arrayDim1;
private int arrayDim2;
private char[][] unsortedArray;
+ private char [][] unsortedFoundHolder;
private char[] sortedArray;
+ private char[] sortedFoundHolder;
private Random random = new Random();
private Scanner reader = new Scanner(System.in);
private ComputeTime computeTime = new ComputeTime();
@@ -132,14 +134,14 @@ public class Controller {
private void SortArray() {
int arrayIndex1;
int arrayIndex2;
- int tempArrayIndex = 0;
+ int index = 0;
sortedArray = new char[arrayDim1 * arrayDim2];
// Translate values into sortable 1d-Array.
for (arrayIndex1 = 0; arrayIndex1 < arrayDim1; arrayIndex1++) {
for (arrayIndex2 = 0; arrayIndex2 < arrayDim2; arrayIndex2++) {
- sortedArray[tempArrayIndex] = unsortedArray[arrayIndex1][arrayIndex2];
- tempArrayIndex++;
+ sortedArray[index] = unsortedArray[arrayIndex1][arrayIndex2];
+ index++;
}
}
@@ -155,8 +157,19 @@ public class Controller {
private void SearchNameUnsorted(String name) {
int stringLength = name.length();
int index = 0;
+ int arrayIndex1;
+ int arrayIndex2;
char tempChar;
+ unsortedFoundHolder = new char[arrayDim1][arrayDim2];
+
+ // Create array to hold found values.
+ for (arrayIndex1 = 0; arrayIndex1 < arrayDim1; arrayIndex1++) {
+ for (arrayIndex2 = 0; arrayIndex2 < arrayDim2; arrayIndex2++) {
+ unsortedFoundHolder[arrayIndex1][arrayIndex2] = 'o';
+ }
+ }
+ // Search current string values.
while (index < stringLength) {
tempChar = name.charAt(index);
LinearSearch(tempChar);
@@ -173,9 +186,22 @@ public class Controller {
private void SearchNameSorted(String name) {
int stringLength = name.length();
int index = 0;
+ int arrayIndex1;
+ int arrayIndex2;
int returnIndex;
char tempChar;
+ sortedFoundHolder = new char[(arrayDim1 * arrayDim2)];
+
+ // Create array to hold found values.
+ for (arrayIndex1 = 0; arrayIndex1 < arrayDim1; arrayIndex1++) {
+ for (arrayIndex2 = 0; arrayIndex2 < arrayDim2; arrayIndex2++) {
+ sortedFoundHolder[index] = 'o';
+ index++;
+ }
+ }
+ // Search current string values.
+ index = 0;
while (index < stringLength) {
tempChar = name.charAt(index);
returnIndex = BinarySearch(tempChar, 0, ((arrayDim1 * arrayDim2) - 1));
@@ -202,12 +228,18 @@ public class Controller {
while (arrayIndex2 < arrayDim2) {
if (unsortedArray[arrayIndex1][arrayIndex2] == searchValue) {
- // Save found values.
- index1 = arrayIndex1;
- index2 = arrayIndex2;
- // Set vars to exit loops.
- arrayIndex1 = arrayDim1;
- arrayIndex2 = arrayDim2;
+ // Match found. Check that value is unique.
+ if (unsortedFoundHolder[arrayIndex1][arrayIndex2] == 'o') {
+ // Hold value of index.
+ unsortedFoundHolder[arrayIndex1][arrayIndex2] = 'x';
+ // Save found values.
+ index1 = arrayIndex1;
+ index2 = arrayIndex2;
+ // Set vars to exit loops.
+ arrayIndex1 = arrayDim1;
+ arrayIndex2 = arrayDim2;
+ }
+
}
arrayIndex2++;
}
@@ -220,16 +252,26 @@ public class Controller {
/**
* Binary search through array for given value.
- * @param searchValue Char to search for
+ * @param searchValue Char to search for.
*/
private int BinarySearch(char searchValue, int firstIndex, int lastIndex) {
+ int tempInt;
// Check if first index is after last index.
if (firstIndex >= lastIndex) {
+
// End of search.
if (sortedArray[firstIndex] == searchValue) {
- // Match found.
- return firstIndex;
+ // Match found. Check that value is unique.
+
+ if (sortedFoundHolder[firstIndex] == 'o') {
+ // Valid value. Return index.
+ sortedFoundHolder[firstIndex] = 'x';
+ return firstIndex;
+ } else {
+ // Duplicate value. Return -1.
+ return -1;
+ }
} else {
// No match found.
return -1;
@@ -241,8 +283,28 @@ public class Controller {
int middleIndex = (firstIndex + lastIndex) / 2;
if (sortedArray[middleIndex] == searchValue) {
- // Match found.
- return middleIndex;
+ // Match found. Check that value is unique.
+ if (sortedFoundHolder[middleIndex] == 'o') {
+ sortedFoundHolder[middleIndex] = 'x';
+ return middleIndex;
+ } else {
+
+ // First try checking values directly left.
+ tempInt = BinaryCheckOneLeft(searchValue, middleIndex);
+ if (tempInt != (-1)) {
+ return tempInt;
+ } else {
+ // No match found. Attempting values directly right.
+ tempInt = BinaryCheckOneRight(searchValue, middleIndex);
+ if (tempInt != (-1)) {
+ return tempInt;
+ } else {
+ // No possible matches.
+ return -1;
+ }
+ }
+
+ }
} else {
@@ -257,7 +319,71 @@ public class Controller {
return BinarySearch(searchValue, (middleIndex + 1), lastIndex);
}
}
+
+ }
+ }
+
+
+ /**
+ * Desired char was found but value was already "used".
+ * Check values directly left for "unused" match.
+ * @param searchValue Char to search for.
+ * @param index Index that was "used".
+ * @return Valid match or -1.
+ */
+ private int BinaryCheckOneLeft(char searchValue, int index) {
+
+ try {
+ // First check if value one left is same character.
+ if (sortedArray[index - 1] == searchValue) {
+ // Match found. Check if spot is unique.
+ if (sortedFoundHolder[index - 1] == 'o') {
+ sortedFoundHolder[index - 1] = 'x';
+ return (index - 1);
+ } else {
+ // Next value was already found. Check left again.
+ return BinaryCheckOneLeft(searchValue, (index - 1));
+ }
+ } else {
+ return -1;
+ }
+ } catch(Exception e) {
+ // Handling if index is out of bounds.
+ // Obviously no match in this instance.
+ return -1;
+ }
+ }
+
+
+ /**
+ * Desired char was found but value is already "used".
+ * Check values directly right for "unused" match.
+ * @param searchValue Char to serach for.
+ * @param index Index that was "used".
+ * @return Valid match or -1;
+ */
+ private int BinaryCheckOneRight(char searchValue, int index) {
+
+ try {
+ // First check if value one right is same character.
+ if (sortedArray[index + 1] == searchValue) {
+ // Match found. Check if spot is unique.
+ if (sortedFoundHolder[index + 1] == 'o') {
+ sortedFoundHolder[index + 1] = 'x';
+ return (index + 1);
+ } else {
+ // Next value was already found. Check right again.
+ return BinaryCheckOneRight(searchValue, (index + 1));
+ }
+ } else {
+ return -1;
+ }
+ } catch(Exception e) {
+ // Handling if index is out of bounds.
+ // Obviously no match in this instance.
+ return -1;
}
+
}
//endregion Array Management Methods
--
GitLab