Skip to content

Commit 7ab0cc2

Browse files
phishman3579phishman3579
committed
Added class headers and cleaned up function names
1 parent 623e561 commit 7ab0cc2

15 files changed

+189
-64
lines changed

‎src/com/jwetherell/algorithms/graph/AStar.java

Lines changed: 1 addition & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -115,6 +115,7 @@ protected int distanceBetween(Graph.Vertex<T> start, Graph.Vertex<T> next) {
115115
/**
116116
* Default heuristic: cost to each vertex is 1.
117117
*/
118+
@SuppressWarnings("unused")
118119
protected int heuristicCostEstimate(Graph.Vertex<T> start, Graph.Vertex<T> goal) {
119120
return 1;
120121
}

‎src/com/jwetherell/algorithms/search/BinarySearch.java

Lines changed: 18 additions & 4 deletions
Original file line numberDiff line numberDiff line change
@@ -1,5 +1,19 @@
11
package com.jwetherell.algorithms.search;
22

3+
/**
4+
* In computer science, binary search, also known as half-interval search or logarithmic search, is a search algorithm that finds the position of a target value within a sorted array. Binary search
5+
* compares the target value to the middle element of the array; if they are unequal, the half in which the target cannot lie is eliminated and the search continues on the remaining half until it is
6+
* successful or the remaining half is empty.
7+
* <p>
8+
* Worst-case performance O(log n)<br>
9+
* Best-case performance O(1)<br>
10+
* Average performance O(log n)<br>
11+
* Worst-case space complexity O(1)<br>
12+
* <br>
13+
* https://en.wikipedia.org/wiki/Binary_search_algorithm
14+
*
15+
* @author Justin Wetherell <phishman3579@gmail.com>
16+
*/
317
public class BinarySearch {
418

519
private static final int SWITCH_TO_BRUTE_FORCE = 200;
@@ -24,11 +38,11 @@ private static int recursiveFind(int value, int start, int end, boolean optimize
2438
return Integer.MAX_VALUE;
2539
}
2640

27-
int low = start;
28-
int high = end + 1; // zero indexed, so add one.
29-
int middle = low + ((high - low) / 2);
41+
final int low = start;
42+
final int high = end + 1; // zero indexed, so add one.
43+
final int middle = low + ((high - low) / 2);
3044

31-
int middleValue = sorted[middle];
45+
final int middleValue = sorted[middle];
3246
if (value == middleValue)
3347
return middle;
3448
if (value > middleValue) {

‎src/com/jwetherell/algorithms/search/InterpolationSearch.java

Lines changed: 12 additions & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -1,5 +1,16 @@
11
package com.jwetherell.algorithms.search;
22

3+
/**
4+
* Interpolation search is an algorithm for searching for a given key in an indexed array that has been ordered by numerical values assigned to the keys (key values). It parallels how humans search
5+
* through a telephone book for a particular name, the key value by which the book's entries are ordered.
6+
* <p>
7+
* Worst-case performance O(n)<br>
8+
* Average performance O(log(log(n)))<br>
9+
* <br>
10+
* https://en.wikipedia.org/wiki/Interpolation_search
11+
*
12+
* @author Justin Wetherell <phishman3579@gmail.com>
13+
*/
314
public class InterpolationSearch {
415

516
private static int[] sorted = null;
@@ -22,7 +33,7 @@ private static int recursiveFind(int value, int start, int end) {
2233
return Integer.MAX_VALUE;
2334
}
2435

25-
int mid = start + ((value - sorted[start]) * (end - start)) / (sorted[end] - sorted[start]);
36+
final int mid = start + ((value - sorted[start]) * (end - start)) / (sorted[end] - sorted[start]);
2637
if (mid < 0 || mid > end)
2738
return Integer.MAX_VALUE;
2839
int midValue = sorted[mid];

‎src/com/jwetherell/algorithms/search/LinearSearch.java

Lines changed: 13 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -1,5 +1,18 @@
11
package com.jwetherell.algorithms.search;
22

3+
/**
4+
* In computer science, linear search or sequential search is a method for finding a target value within a list. It sequentially checks each element of the list for the target value until a match is
5+
* found or until all the elements have been searched.
6+
* <p>
7+
* Worst-case performance O(n)<br>
8+
* Best-case performance O(1)<br>
9+
* Average performance O(n)<br>
10+
* Worst-case space complexity O(1)<br>
11+
* <br>
12+
* https://en.wikipedia.org/wiki/Linear_search
13+
*
14+
* @author Justin Wetherell <phishman3579@gmail.com>
15+
*/
316
public class LinearSearch {
417

518
public static final int find(int value, int[] array) {

‎src/com/jwetherell/algorithms/search/QuickSelect.java

Lines changed: 11 additions & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -2,6 +2,17 @@
22

33
import java.util.Random;
44

5+
/**
6+
* In computer science, quickselect is a selection algorithm to find the k-th smallest element in an unordered list. It is related to the quicksort sorting algorithm.
7+
* <p>
8+
* Worst-case performance О(n2)<br>
9+
* Best-case performance О(n)<br>
10+
* Average performance O(n)<br>
11+
* <br>
12+
* https://en.wikipedia.org/wiki/Quickselect
13+
*
14+
* @author Justin Wetherell <phishman3579@gmail.com>
15+
*/
516
public class QuickSelect {
617

718
private static final Random RANDOM = new Random();
@@ -38,5 +49,4 @@ else if (value < pivot && iValue < pivot)
3849
QuickSelect.temp = null;
3950
}
4051
}
41-
4252
}

‎src/com/jwetherell/algorithms/sequence/ArithmeticProgression.java

Lines changed: 44 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,44 @@
1+
package com.jwetherell.algorithms.sequence;
2+
3+
/**
4+
* Compute the result of adding a sequence of numbers from N (startNumber) to N+X (startNumber+numberOfNumbersToCompute)
5+
* <p>
6+
* https://en.wikipedia.org/wiki/Arithmetic_progression
7+
* <br>
8+
* @author Justin Wetherell <phishman3579@gmail.com>
9+
*/
10+
public class ArithmeticProgression {
11+
12+
/**
13+
* Compute the result of adding X (numberOfNumbersToCompute) together starting at N (startNumber).
14+
* <p>
15+
* e.g. result = N + (N+1) + (N+2) + (N+3) + ..... + (N+X)
16+
*/
17+
public static final long sequenceTotalUsingLoop(int startNumber, int numberOfNumbersToCompute) {
18+
int start = startNumber;
19+
int length = numberOfNumbersToCompute;
20+
long result = 0L;
21+
while (length > 0) {
22+
result += start++;
23+
length--;
24+
}
25+
return result;
26+
}
27+
28+
/**
29+
* Compute the result of adding X (numberOfNumbersToCompute) together starting at N (startNumber) using triangular numbers.
30+
* <p>
31+
* e.g. result = N + (N+1) + (N+2) + (N+3) + ..... + (N+X)<br>
32+
* <br>
33+
* https://en.wikipedia.org/wiki/Triangular_number
34+
*/
35+
public static final long sequenceTotalUsingTriangularNumbers(int startNumber, int numberOfNumbersToCompute) {
36+
// n*(n+1)/2
37+
final int start = startNumber;
38+
final int length = numberOfNumbersToCompute;
39+
40+
long result = length * (length + 1) / 2;
41+
result += (start - 1) * length;
42+
return result;
43+
}
44+
}

‎src/com/jwetherell/algorithms/sequence/FibonacciSequence.java

Lines changed: 12 additions & 2 deletions
Original file line numberDiff line numberDiff line change
@@ -1,11 +1,21 @@
11
package com.jwetherell.algorithms.sequence;
22

3+
/**
4+
* In mathematics, the Fibonacci numbers are the numbers in the following integer sequence, called the Fibonacci sequence, and characterized by the fact that every number after the first two is the
5+
* sum of the two preceding ones: 1, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89, 144, ...
6+
* <p>
7+
*
8+
* https://en.wikipedia.org/wiki/Fibonacci_number
9+
* <br>
10+
* @author Justin Wetherell <phishman3579@gmail.com>
11+
*/
312
public class FibonacciSequence {
413

5-
private static final double INVERSE_SQUARE_ROOT_OF_5 = 1 / Math.sqrt(5); // Inverse of the square
6-
// root of 5
14+
private static final double INVERSE_SQUARE_ROOT_OF_5 = 1 / Math.sqrt(5); // Inverse of the square root of 5
715
private static final double PHI = (1 + Math.sqrt(5)) / 2; // Golden ratio
816

17+
private FibonacciSequence() {}
18+
919
public static final long fibonacciSequenceUsingLoop(int n) {
1020
final long[] array = new long[n + 1];
1121
int counter = 0;

‎src/com/jwetherell/algorithms/sequence/LongestCommonSubsequence.java

Lines changed: 20 additions & 7 deletions
Original file line numberDiff line numberDiff line change
@@ -3,6 +3,14 @@
33
import java.util.HashSet;
44
import java.util.Set;
55

6+
/**
7+
* The longest common subsequence (LCS) problem is the problem of finding the longest subsequence common to all sequences in a set of sequences (often just two sequences). It differs from problems
8+
* of finding common substrings: unlike substrings, subsequences are not required to occupy consecutive positions within the original sequences.
9+
* <p>
10+
* https://en.wikipedia.org/wiki/Longest_common_subsequence_problem
11+
* <br>
12+
* @author Justin Wetherell <phishman3579@gmail.com>
13+
*/
614
@SuppressWarnings("unchecked")
715
public class LongestCommonSubsequence {
816

@@ -74,15 +82,20 @@ private static void distribute(char c, Set<String> set) {
7482
}
7583

7684
public static MatrixPair getLCS(char[] seq1, char[] seq2) {
77-
populateMatrix(seq1, seq2);
78-
79-
for (int i = 0; i < seq1.length; i++) {
80-
for (int j = 0; j < seq2.length; j++) {
81-
lengthMatrix[i + 1][j + 1] = longestCommonSubsequence(i, j, seq1, seq2);
85+
try {
86+
populateMatrix(seq1, seq2);
87+
88+
for (int i = 0; i < seq1.length; i++) {
89+
for (int j = 0; j < seq2.length; j++) {
90+
lengthMatrix[i + 1][j + 1] = longestCommonSubsequence(i, j, seq1, seq2);
91+
}
8292
}
93+
94+
return (new MatrixPair(lengthMatrix, sequenceMatrix));
95+
} finally {
96+
lengthMatrix = null;
97+
sequenceMatrix = null;
8398
}
84-
85-
return (new MatrixPair(lengthMatrix, sequenceMatrix));
8699
}
87100

88101
public static class MatrixPair {

‎src/com/jwetherell/algorithms/sequence/LongestIncreasingSubsequence.java

Lines changed: 7 additions & 3 deletions
Original file line numberDiff line numberDiff line change
@@ -5,24 +5,28 @@
55
import java.util.Arrays;
66

77
/**
8-
* Finding longest increasing subsequence. Dynamic programming.
8+
* In computer science, the longest increasing subsequence problem is to find a subsequence of a given sequence in which the subsequence's elements are in sorted order, lowest to highest, and in
9+
* which the subsequence is as long as possible. This subsequence is not necessarily contiguous, or unique.
910
* <p>
1011
* https://en.wikipedia.org/wiki/Longest_increasing_subsequence
11-
*
12+
* <br>
1213
* @author Bartlomiej Drozd <mail@bartlomiejdrozd.pl>
1314
* @author Justin Wetherell <phishman3579@gmail.com>
1415
*/
1516
public class LongestIncreasingSubsequence {
1617

1718
private LongestIncreasingSubsequence() { }
1819

20+
/**
21+
* Longest increasing subsequence solved using dynamic programming.
22+
*/
1923
public static int[] getLongestIncreasingSubsequence(int[] sequence) {
2024
final int[] resultSequence = new int[sequence.length];
2125

2226
int resultLength = 0;
2327
for (int i = 0; i < sequence.length; ++i) {
2428
// try to find the best place for new element in sorted result
25-
final int pos = LowerBound.lowerBound(resultSequence, resultLength, sequence[i]);//O(log n)
29+
final int pos = LowerBound.lowerBound(resultSequence, resultLength, sequence[i]); //O(log n)
2630
// if the best place is at the end increase result length
2731
if (pos >= resultLength)
2832
resultLength++;

‎src/com/jwetherell/algorithms/sequence/SubsequenceCounter.java

Lines changed: 32 additions & 14 deletions
Original file line numberDiff line numberDiff line change
@@ -1,24 +1,43 @@
11
package com.jwetherell.algorithms.sequence;
22

3+
/**
4+
* Finds the number of times a string occurs as a subsequence in a text.
5+
* <p>
6+
* http://www.geeksforgeeks.org/find-number-times-string-occurs-given-string/
7+
* <br>
8+
* @author Justin Wetherell <phishman3579@gmail.com>
9+
*/
310
public class SubsequenceCounter {
411

512
private static char[] seq = null;
613
private static char[] subseq = null;
714
private static int[][] tbl = null;
815

9-
private SubsequenceCounter() {
10-
}
16+
private SubsequenceCounter() { }
1117

18+
/**
19+
* Finds the number of times a string occurs as a subsequence in a text.
20+
*
21+
* @param sequence Text to find subsequence in.
22+
* @param subSequence subsequence to find in the text.
23+
* @return Number of times a string occurs as a subsequence in a text
24+
*/
1225
public static int getCount(char[] sequence, char[] subSequence) {
13-
seq = sequence;
14-
subseq = subSequence;
15-
tbl = new int[seq.length + 1][subseq.length + 1];
16-
17-
for (int row = 0; row < tbl.length; row++)
18-
for (int col = 0; col < tbl[row].length; col++)
19-
tbl[row][col] = countMatches(row, col);
20-
21-
return tbl[seq.length][subseq.length];
26+
try {
27+
seq = sequence;
28+
subseq = subSequence;
29+
tbl = new int[seq.length + 1][subseq.length + 1];
30+
31+
for (int row = 0; row < tbl.length; row++)
32+
for (int col = 0; col < tbl[row].length; col++)
33+
tbl[row][col] = countMatches(row, col);
34+
35+
return tbl[seq.length][subseq.length];
36+
} finally {
37+
seq = null;
38+
subseq = null;
39+
tbl = null;
40+
}
2241
}
2342

2443
private static int countMatches(int seqDigitsLeft, int subseqDigitsLeft) {
@@ -28,13 +47,12 @@ private static int countMatches(int seqDigitsLeft, int subseqDigitsLeft) {
2847
if (seqDigitsLeft == 0)
2948
return 0;
3049

31-
char currSeqDigit = seq[seq.length - seqDigitsLeft];
32-
char currSubseqDigit = subseq[subseq.length - subseqDigitsLeft];
50+
final char currSeqDigit = seq[seq.length - seqDigitsLeft];
51+
final char currSubseqDigit = subseq[subseq.length - subseqDigitsLeft];
3352

3453
int result = 0;
3554
if (currSeqDigit == currSubseqDigit)
3655
result += tbl[seqDigitsLeft - 1][subseqDigitsLeft - 1];
37-
3856
result += tbl[seqDigitsLeft - 1][subseqDigitsLeft];
3957

4058
return result;

‎src/com/jwetherell/algorithms/sequence/TotalOfSequence.java

Lines changed: 0 additions & 24 deletions
This file was deleted.

‎test/com/jwetherell/algorithms/data_structures/test/ImplicitKeyTreapTests.java

Lines changed: 1 addition & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -202,6 +202,7 @@ private static <T extends Comparable<T>> void moveToBack(MyTreap<T> t, int begin
202202
t.setRoot(n);
203203
}
204204

205+
@SuppressWarnings("unused")
205206
private static <T> String toString(Class<T> type, Object[] array) {
206207
final StringBuilder builder = new StringBuilder();
207208
for (Object a : array)

‎test/com/jwetherell/algorithms/graph/test/Graphs.java

Lines changed: 2 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -10,6 +10,7 @@
1010
import java.util.Map;
1111

1212
import com.jwetherell.algorithms.graph.*;
13+
1314
import org.junit.Assert;
1415
import org.junit.Test;
1516

@@ -983,6 +984,7 @@ public void testAStarDirected() {
983984
* Makes a zero weighted directed graph, so that there is an edge between two vertices if the difference between the
984985
* vertices values is >= K
985986
*/
987+
@SuppressWarnings("unused")
986988
private static final Graph<Integer> makeDirectedGraph(int N, int K, int[] values) {
987989
final List<Vertex<Integer>> vertices = new ArrayList<Vertex<Integer>>(values.length);
988990
for (int i=0; i<values.length; i++)

0 commit comments

Comments
 (0)