algorithm/Java
1
0
Fork 0
mirror of https://github.com/TheAlgorithms/Java.git synced 2025-07-07 01:35:16 +08:00
Code Issues Packages Projects Releases Wiki Activity

style: enable MemberName in checkstyle (#5193)

Browse Source 
* style: enable MemberName in checkstyle

* style: simply uncomment `MemberName`

---------

Co-authored-by: Piotr Idzik <65706193+vil02@users.noreply.github.com>
This commit is contained in:
S. Utkarsh
2024-05-30 02:14:14 +05:30
committed by GitHub
parent d2bfb100b2
commit a6e873deef
17 changed files with 168 additions and 168 deletions
Download Patch File Download Diff File Expand all files Collapse all files

2
checkstyle.xml
View File

@ -111,7 +111,7 @@
<module name="ConstantName"/> <module name="ConstantName"/>
<module name="LocalFinalVariableName"/> <module name="LocalFinalVariableName"/>
<module name="LocalVariableName"/> <module name="LocalVariableName"/>
<!-- TODO <module name="MemberName"/> --> <module name="MemberName"/>
<module name="MethodName"/> <module name="MethodName"/>
<module name="PackageName"/> <module name="PackageName"/>
<!-- TODO <module name="ParameterName"/> --> <!-- TODO <module name="ParameterName"/> -->

20
src/main/java/com/thealgorithms/ciphers/Blowfish.java
View File

@ -11,7 +11,7 @@ package com.thealgorithms.ciphers;
public class Blowfish { public class Blowfish {
// Initializing substitution boxes // Initializing substitution boxes
String[][] S = { String[][] sBox = {
{ {
"d1310ba6", "d1310ba6",
"98dfb5ac", "98dfb5ac",
@ -1047,7 +1047,7 @@ public class Blowfish {
}; };
// Initializing subkeys with digits of pi // Initializing subkeys with digits of pi
String[] P = { String[] subKeys = {
"243f6a88", "243f6a88",
"85a308d3", "85a308d3",
"13198a2e", "13198a2e",
@ -1154,7 +1154,7 @@ public class Blowfish {
for (int i = 0; i < 8; i += 2) { for (int i = 0; i < 8; i += 2) {
// column number for S-box is a 8-bit value // column number for S-box is a 8-bit value
long col = Long.parseUnsignedLong(hexToBin(plainText.substring(i, i + 2)), 2); long col = Long.parseUnsignedLong(hexToBin(plainText.substring(i, i + 2)), 2);
a[i / 2] = S[i / 2][(int) col]; a[i / 2] = sBox[i / 2][(int) col];
} }
ans = addBin(a[0], a[1]); ans = addBin(a[0], a[1]);
ans = xor(ans, a[2]); ans = xor(ans, a[2]);
@ -1165,9 +1165,9 @@ public class Blowfish {
// generate subkeys // generate subkeys
private void keyGenerate(String key) { private void keyGenerate(String key) {
int j = 0; int j = 0;
for (int i = 0; i < P.length; i++) { for (int i = 0; i < subKeys.length; i++) {
// XOR-ing 32-bit parts of the key with initial subkeys // XOR-ing 32-bit parts of the key with initial subkeys
P[i] = xor(P[i], key.substring(j, j + 8)); subKeys[i] = xor(subKeys[i], key.substring(j, j + 8));
j = (j + 8) % key.length(); j = (j + 8) % key.length();
} }
@ -1179,7 +1179,7 @@ public class Blowfish {
String right; String right;
left = plainText.substring(0, 8); left = plainText.substring(0, 8);
right = plainText.substring(8, 16); right = plainText.substring(8, 16);
left = xor(left, P[time]); left = xor(left, subKeys[time]);
// output from F function // output from F function
String fOut = f(left); String fOut = f(left);
@ -1207,8 +1207,8 @@ public class Blowfish {
// postprocessing // postprocessing
String right = plainText.substring(0, 8); String right = plainText.substring(0, 8);
String left = plainText.substring(8, 16); String left = plainText.substring(8, 16);
right = xor(right, P[16]); right = xor(right, subKeys[16]);
left = xor(left, P[17]); left = xor(left, subKeys[17]);
return left + right; return left + right;
} }
@ -1229,8 +1229,8 @@ public class Blowfish {
// postprocessing // postprocessing
String right = cipherText.substring(0, 8); String right = cipherText.substring(0, 8);
String left = cipherText.substring(8, 16); String left = cipherText.substring(8, 16);
right = xor(right, P[1]); right = xor(right, subKeys[1]);
left = xor(left, P[0]); left = xor(left, subKeys[0]);
return left + right; return left + right;
} }
} }

4
src/main/java/com/thealgorithms/conversions/HexaDecimalToBinary.java
View File

@ -3,7 +3,7 @@ package com.thealgorithms.conversions;
// Hex [0-9],[A-F] -> Binary [0,1] // Hex [0-9],[A-F] -> Binary [0,1]
public class HexaDecimalToBinary { public class HexaDecimalToBinary {
private final int LONG_BITS = 8; private final int longBits = 8;
public String convert(String numHex) { public String convert(String numHex) {
// String a HexaDecimal: // String a HexaDecimal:
@ -15,7 +15,7 @@ public class HexaDecimalToBinary {
} }
public String completeDigits(String binNum) { public String completeDigits(String binNum) {
for (int i = binNum.length(); i < LONG_BITS; i++) { for (int i = binNum.length(); i < longBits; i++) {
binNum = "0" + binNum; binNum = "0" + binNum;
} }
return binNum; return binNum;

14
src/main/java/com/thealgorithms/datastructures/crdt/GCounter.java
View File

@ -17,7 +17,7 @@ import java.util.Map;
*/ */
class GCounter { class GCounter {
private final Map<Integer, Integer> P; private final Map<Integer, Integer> counterMap;
private final int myId; private final int myId;
private final int n; private final int n;
@ -29,10 +29,10 @@ class GCounter {
GCounter(int myId, int n) { GCounter(int myId, int n) {
this.myId = myId; this.myId = myId;
this.n = n; this.n = n;
this.P = new HashMap<>(); this.counterMap = new HashMap<>();
for (int i = 0; i < n; i++) { for (int i = 0; i < n; i++) {
P.put(i, 0); counterMap.put(i, 0);
} }
} }
@ -40,7 +40,7 @@ class GCounter {
* Increments the counter for the current node. * Increments the counter for the current node.
*/ */
public void increment() { public void increment() {
P.put(myId, P.get(myId) + 1); counterMap.put(myId, counterMap.get(myId) + 1);
} }
/** /**
@ -50,7 +50,7 @@ class GCounter {
*/ */
public int value() { public int value() {
int sum = 0; int sum = 0;
for (int v : P.values()) { for (int v : counterMap.values()) {
sum += v; sum += v;
} }
return sum; return sum;
@ -64,7 +64,7 @@ class GCounter {
*/ */
public boolean compare(GCounter other) { public boolean compare(GCounter other) {
for (int i = 0; i < n; i++) { for (int i = 0; i < n; i++) {
if (this.P.get(i) > other.P.get(i)) { if (this.counterMap.get(i) > other.counterMap.get(i)) {
return false; return false;
} }
} }
@ -78,7 +78,7 @@ class GCounter {
*/ */
public void merge(GCounter other) { public void merge(GCounter other) {
for (int i = 0; i < n; i++) { for (int i = 0; i < n; i++) {
this.P.put(i, Math.max(this.P.get(i), other.P.get(i))); this.counterMap.put(i, Math.max(this.counterMap.get(i), other.counterMap.get(i)));
} }
} }
} }

26
src/main/java/com/thealgorithms/datastructures/crdt/PNCounter.java
View File

@ -17,8 +17,8 @@ import java.util.Map;
*/ */
class PNCounter { class PNCounter {
private final Map<Integer, Integer> P; private final Map<Integer, Integer> pCounter;
private final Map<Integer, Integer> N; private final Map<Integer, Integer> nCounter;
private final int myId; private final int myId;
private final int n; private final int n;
@ -31,12 +31,12 @@ class PNCounter {
PNCounter(int myId, int n) { PNCounter(int myId, int n) {
this.myId = myId; this.myId = myId;
this.n = n; this.n = n;
this.P = new HashMap<>(); this.pCounter = new HashMap<>();
this.N = new HashMap<>(); this.nCounter = new HashMap<>();
for (int i = 0; i < n; i++) { for (int i = 0; i < n; i++) {
P.put(i, 0); pCounter.put(i, 0);
N.put(i, 0); nCounter.put(i, 0);
} }
} }
@ -44,14 +44,14 @@ class PNCounter {
* Increments the increment counter for the current node. * Increments the increment counter for the current node.
*/ */
public void increment() { public void increment() {
P.put(myId, P.get(myId) + 1); pCounter.put(myId, pCounter.get(myId) + 1);
} }
/** /**
* Increments the decrement counter for the current node. * Increments the decrement counter for the current node.
*/ */
public void decrement() { public void decrement() {
N.put(myId, N.get(myId) + 1); nCounter.put(myId, nCounter.get(myId) + 1);
} }
/** /**
@ -60,8 +60,8 @@ class PNCounter {
* @return The total value of the counter. * @return The total value of the counter.
*/ */
public int value() { public int value() {
int sumP = P.values().stream().mapToInt(Integer::intValue).sum(); int sumP = pCounter.values().stream().mapToInt(Integer::intValue).sum();
int sumN = N.values().stream().mapToInt(Integer::intValue).sum(); int sumN = nCounter.values().stream().mapToInt(Integer::intValue).sum();
return sumP - sumN; return sumP - sumN;
} }
@ -76,7 +76,7 @@ class PNCounter {
throw new IllegalArgumentException("Cannot compare PN-Counters with different number of nodes"); throw new IllegalArgumentException("Cannot compare PN-Counters with different number of nodes");
} }
for (int i = 0; i < n; i++) { for (int i = 0; i < n; i++) {
if (this.P.get(i) > other.P.get(i) && this.N.get(i) > other.N.get(i)) { if (this.pCounter.get(i) > other.pCounter.get(i) && this.nCounter.get(i) > other.nCounter.get(i)) {
return false; return false;
} }
} }
@ -93,8 +93,8 @@ class PNCounter {
throw new IllegalArgumentException("Cannot merge PN-Counters with different number of nodes"); throw new IllegalArgumentException("Cannot merge PN-Counters with different number of nodes");
} }
for (int i = 0; i < n; i++) { for (int i = 0; i < n; i++) {
this.P.put(i, Math.max(this.P.get(i), other.P.get(i))); this.pCounter.put(i, Math.max(this.pCounter.get(i), other.pCounter.get(i)));
this.N.put(i, Math.max(this.N.get(i), other.N.get(i))); this.nCounter.put(i, Math.max(this.nCounter.get(i), other.nCounter.get(i)));
} }
} }
} }

12
src/main/java/com/thealgorithms/datastructures/graphs/FloydWarshall.java
View File

@ -4,12 +4,12 @@ import java.util.Scanner;
public class FloydWarshall { public class FloydWarshall {
private int[][] DistanceMatrix; private int[][] distanceMatrix;
private int numberofvertices; // number of vertices in the graph private int numberofvertices; // number of vertices in the graph
public static final int INFINITY = 999; public static final int INFINITY = 999;
public FloydWarshall(int numberofvertices) { public FloydWarshall(int numberofvertices) {
DistanceMatrix = new int[numberofvertices + 1][numberofvertices + 1]; // stores the value of distance from all the possible path form the source distanceMatrix = new int[numberofvertices + 1][numberofvertices + 1]; // stores the value of distance from all the possible path form the source
// vertex to destination vertex // vertex to destination vertex
// The matrix is initialized with 0's by default // The matrix is initialized with 0's by default
this.numberofvertices = numberofvertices; this.numberofvertices = numberofvertices;
@ -18,17 +18,17 @@ public class FloydWarshall {
public void floydwarshall(int[][] AdjacencyMatrix) { // calculates all the distances from source to destination vertex public void floydwarshall(int[][] AdjacencyMatrix) { // calculates all the distances from source to destination vertex
for (int source = 1; source <= numberofvertices; source++) { for (int source = 1; source <= numberofvertices; source++) {
for (int destination = 1; destination <= numberofvertices; destination++) { for (int destination = 1; destination <= numberofvertices; destination++) {
DistanceMatrix[source][destination] = AdjacencyMatrix[source][destination]; distanceMatrix[source][destination] = AdjacencyMatrix[source][destination];
} }
} }
for (int intermediate = 1; intermediate <= numberofvertices; intermediate++) { for (int intermediate = 1; intermediate <= numberofvertices; intermediate++) {
for (int source = 1; source <= numberofvertices; source++) { for (int source = 1; source <= numberofvertices; source++) {
for (int destination = 1; destination <= numberofvertices; destination++) { for (int destination = 1; destination <= numberofvertices; destination++) {
if (DistanceMatrix[source][intermediate] + DistanceMatrix[intermediate][destination] < DistanceMatrix[source][destination]) { // calculated distance it get replaced as if (distanceMatrix[source][intermediate] + distanceMatrix[intermediate][destination] < distanceMatrix[source][destination]) { // calculated distance it get replaced as
// new shortest distance // if the new // new shortest distance // if the new
// distance calculated is less then the // distance calculated is less then the
// earlier shortest // earlier shortest
DistanceMatrix[source][destination] = DistanceMatrix[source][intermediate] + DistanceMatrix[intermediate][destination]; distanceMatrix[source][destination] = distanceMatrix[source][intermediate] + distanceMatrix[intermediate][destination];
} }
} }
} }
@ -40,7 +40,7 @@ public class FloydWarshall {
for (int source = 1; source <= numberofvertices; source++) { for (int source = 1; source <= numberofvertices; source++) {
System.out.print(source + "\t"); System.out.print(source + "\t");
for (int destination = 1; destination <= numberofvertices; destination++) { for (int destination = 1; destination <= numberofvertices; destination++) {
System.out.print(DistanceMatrix[source][destination] + "\t"); System.out.print(distanceMatrix[source][destination] + "\t");
} }
System.out.println(); System.out.println();
} }

12
src/main/java/com/thealgorithms/datastructures/graphs/HamiltonianCycle.java
View File

@ -8,7 +8,7 @@ package com.thealgorithms.datastructures.graphs;
*/ */
public class HamiltonianCycle { public class HamiltonianCycle {
private int V; private int vertex;
private int pathCount; private int pathCount;
private int[] cycle; private int[] cycle;
private int[][] graph; private int[][] graph;
@ -22,8 +22,8 @@ public class HamiltonianCycle {
* else returns 1D array with value -1. * else returns 1D array with value -1.
*/ */
public int[] findHamiltonianCycle(int[][] graph) { public int[] findHamiltonianCycle(int[][] graph) {
this.V = graph.length; this.vertex = graph.length;
this.cycle = new int[this.V + 1]; this.cycle = new int[this.vertex + 1];
// Initialize path array with -1 value // Initialize path array with -1 value
for (int i = 0; i < this.cycle.length; i++) { for (int i = 0; i < this.cycle.length; i++) {
@ -53,17 +53,17 @@ public class HamiltonianCycle {
* @returns true if path is found false otherwise * @returns true if path is found false otherwise
*/ */
public boolean isPathFound(int vertex) { public boolean isPathFound(int vertex) {
boolean isLastVertexConnectedToStart = this.graph[vertex][0] == 1 && this.pathCount == this.V; boolean isLastVertexConnectedToStart = this.graph[vertex][0] == 1 && this.pathCount == this.vertex;
if (isLastVertexConnectedToStart) { if (isLastVertexConnectedToStart) {
return true; return true;
} }
/** all vertices selected but last vertex not linked to 0 **/ /** all vertices selected but last vertex not linked to 0 **/
if (this.pathCount == this.V) { if (this.pathCount == this.vertex) {
return false; return false;
} }
for (int v = 0; v < this.V; v++) { for (int v = 0; v < this.vertex; v++) {
/** if connected **/ /** if connected **/
if (this.graph[vertex][v] == 1) { if (this.graph[vertex][v] == 1) {
/** add to path **/ /** add to path **/

36
src/main/java/com/thealgorithms/datastructures/graphs/MatrixGraphs.java
View File

@ -48,17 +48,17 @@ class AdjacencyMatrixGraph {
/** /**
* The number of vertices in the graph * The number of vertices in the graph
*/ */
private int _numberOfVertices; private int vertexCount;
/** /**
* The number of edges in the graph * The number of edges in the graph
*/ */
private int _numberOfEdges; private int edgeCount;
/** /**
* The adjacency matrix for the graph * The adjacency matrix for the graph
*/ */
private int[][] _adjacency; private int[][] adjMatrix;
/** /**
* Static variables to define whether or not an edge exists in the adjacency * Static variables to define whether or not an edge exists in the adjacency
@ -87,16 +87,16 @@ class AdjacencyMatrixGraph {
* @param newNumberOfVertices the new number of vertices * @param newNumberOfVertices the new number of vertices
*/ */
private void setNumberOfVertices(int newNumberOfVertices) { private void setNumberOfVertices(int newNumberOfVertices) {
this._numberOfVertices = newNumberOfVertices; this.vertexCount = newNumberOfVertices;
} }
/** /**
* Getter for `this._numberOfVertices` * Getter for `this.vertexCount`
* *
* @return the number of vertices in the graph * @return the number of vertices in the graph
*/ */
public int numberOfVertices() { public int numberOfVertices() {
return this._numberOfVertices; return this.vertexCount;
} }
/** /**
@ -106,16 +106,16 @@ class AdjacencyMatrixGraph {
* *
*/ */
private void setNumberOfEdges(int newNumberOfEdges) { private void setNumberOfEdges(int newNumberOfEdges) {
this._numberOfEdges = newNumberOfEdges; this.edgeCount = newNumberOfEdges;
} }
/** /**
* Getter for `this._numberOfEdges` * Getter for `this.edgeCount`
* *
* @return the number of edges * @return the number of edges
*/ */
public int numberOfEdges() { public int numberOfEdges() {
return this._numberOfEdges; return this.edgeCount;
} }
/** /**
@ -124,7 +124,7 @@ class AdjacencyMatrixGraph {
* @param newAdjacency the new adjaceny matrix * @param newAdjacency the new adjaceny matrix
*/ */
private void setAdjacency(int[][] newAdjacency) { private void setAdjacency(int[][] newAdjacency) {
this._adjacency = newAdjacency; this.adjMatrix = newAdjacency;
} }
/** /**
@ -133,7 +133,7 @@ class AdjacencyMatrixGraph {
* @return the adjacency matrix * @return the adjacency matrix
*/ */
private int[][] adjacency() { private int[][] adjacency() {
return this._adjacency; return this.adjMatrix;
} }
/** /**
@ -222,12 +222,12 @@ class AdjacencyMatrixGraph {
*/ */
public List<Integer> depthFirstOrder(int startVertex) { public List<Integer> depthFirstOrder(int startVertex) {
// If the startVertex is invalid, return an empty list // If the startVertex is invalid, return an empty list
if (startVertex >= _numberOfVertices || startVertex < 0) { if (startVertex >= vertexCount || startVertex < 0) {
return new ArrayList<Integer>(); return new ArrayList<Integer>();
} }
// Create an array to track the visited vertices // Create an array to track the visited vertices
boolean[] visited = new boolean[_numberOfVertices]; boolean[] visited = new boolean[vertexCount];
// Create a list to keep track of the order of our traversal // Create a list to keep track of the order of our traversal
ArrayList<Integer> orderList = new ArrayList<Integer>(); ArrayList<Integer> orderList = new ArrayList<Integer>();
@ -259,7 +259,7 @@ class AdjacencyMatrixGraph {
orderList.add(currentVertex); orderList.add(currentVertex);
// Get the adjacency array for this vertex // Get the adjacency array for this vertex
int[] adjacent = _adjacency[currentVertex]; int[] adjacent = adjMatrix[currentVertex];
for (int i = 0; i < adjacent.length; i++) { // we are considering exploring, recurse on it // If an edge exists between the for (int i = 0; i < adjacent.length; i++) { // we are considering exploring, recurse on it // If an edge exists between the
// currentVertex and the vertex // currentVertex and the vertex
if (adjacent[i] == AdjacencyMatrixGraph.EDGE_EXIST) { if (adjacent[i] == AdjacencyMatrixGraph.EDGE_EXIST) {
@ -277,12 +277,12 @@ class AdjacencyMatrixGraph {
*/ */
public List<Integer> breadthFirstOrder(int startVertex) { public List<Integer> breadthFirstOrder(int startVertex) {
// If the specified startVertex is invalid, return an empty list // If the specified startVertex is invalid, return an empty list
if (startVertex >= _numberOfVertices || startVertex < 0) { if (startVertex >= vertexCount || startVertex < 0) {
return new ArrayList<Integer>(); return new ArrayList<Integer>();
} }
// Create an array to keep track of the visited vertices // Create an array to keep track of the visited vertices
boolean[] visited = new boolean[_numberOfVertices]; boolean[] visited = new boolean[vertexCount];
// Create a list to keep track of the ordered vertices // Create a list to keep track of the ordered vertices
ArrayList<Integer> orderList = new ArrayList<Integer>(); ArrayList<Integer> orderList = new ArrayList<Integer>();
@ -309,7 +309,7 @@ class AdjacencyMatrixGraph {
// Get the adjacency array for the currentVertex and // Get the adjacency array for the currentVertex and
// check each node // check each node
int[] adjacent = _adjacency[currentVertex]; int[] adjacent = adjMatrix[currentVertex];
for (int vertex = 0; vertex < adjacent.length; vertex++) { // vertex we are considering exploring, we add it to the queue // If an for (int vertex = 0; vertex < adjacent.length; vertex++) { // vertex we are considering exploring, we add it to the queue // If an
// edge exists between the current vertex and the // edge exists between the current vertex and the
if (adjacent[vertex] == AdjacencyMatrixGraph.EDGE_EXIST) { if (adjacent[vertex] == AdjacencyMatrixGraph.EDGE_EXIST) {
@ -336,7 +336,7 @@ class AdjacencyMatrixGraph {
for (int i = 0; i < this.numberOfVertices(); i++) { for (int i = 0; i < this.numberOfVertices(); i++) {
s = s + i + " : "; s = s + i + " : ";
for (int j = 0; j < this.numberOfVertices(); j++) { for (int j = 0; j < this.numberOfVertices(); j++) {
s = s + this._adjacency[i][j] + " "; s = s + this.adjMatrix[i][j] + " ";
} }
s = s + "\n"; s = s + "\n";
} }

14
src/main/java/com/thealgorithms/datastructures/graphs/TarjansAlgorithm.java
View File

@ -56,9 +56,9 @@ import java.util.Stack;
public class TarjansAlgorithm { public class TarjansAlgorithm {
// Timer for tracking lowtime and insertion time // Timer for tracking lowtime and insertion time
private int Time; private int time;
private List<List<Integer>> SCClist = new ArrayList<List<Integer>>(); private List<List<Integer>> sccList = new ArrayList<List<Integer>>();
public List<List<Integer>> stronglyConnectedComponents(int V, List<List<Integer>> graph) { public List<List<Integer>> stronglyConnectedComponents(int V, List<List<Integer>> graph) {
@ -85,15 +85,15 @@ public class TarjansAlgorithm {
if (insertionTime[i] == -1) stronglyConnCompsUtil(i, lowTime, insertionTime, isInStack, st, graph); if (insertionTime[i] == -1) stronglyConnCompsUtil(i, lowTime, insertionTime, isInStack, st, graph);
} }
return SCClist; return sccList;
} }
private void stronglyConnCompsUtil(int u, int[] lowTime, int[] insertionTime, boolean[] isInStack, Stack<Integer> st, List<List<Integer>> graph) { private void stronglyConnCompsUtil(int u, int[] lowTime, int[] insertionTime, boolean[] isInStack, Stack<Integer> st, List<List<Integer>> graph) {
// Initialize insertion time and lowTime value of current node // Initialize insertion time and lowTime value of current node
insertionTime[u] = Time; insertionTime[u] = time;
lowTime[u] = Time; lowTime[u] = time;
Time += 1; time += 1;
// Push current node into stack // Push current node into stack
isInStack[u] = true; isInStack[u] = true;
@ -123,7 +123,7 @@ public class TarjansAlgorithm {
scc.add(w); scc.add(w);
isInStack[w] = false; isInStack[w] = false;
} }
SCClist.add(scc); sccList.add(scc);
} }
} }
} }

20
src/main/java/com/thealgorithms/datastructures/hashmap/hashing/HashMapCuckooHashing.java
View File

@ -12,21 +12,21 @@ public class HashMapCuckooHashing {
private int tableSize; // size of the hash table private int tableSize; // size of the hash table
private Integer[] buckets; // array representing the table private Integer[] buckets; // array representing the table
private final Integer AVAILABLE; private final Integer emptySlot;
private int size; // number of elements in the hash table private int size; // number of elements in the hash table
private int thresh; // threshold for infinite loop checking private int thresh; // threshold for infinite loop checking
/** /**
* Constructor initializes buckets array, hsize, and creates dummy object * Constructor initializes buckets array, hsize, and creates dummy object
* for AVAILABLE * for emptySlot
* *
* @param tableSize the desired size of the hash map * @param tableSize the desired size of the hash map
*/ */
public HashMapCuckooHashing(int tableSize) { public HashMapCuckooHashing(int tableSize) {
this.buckets = new Integer[tableSize]; this.buckets = new Integer[tableSize];
this.tableSize = tableSize; this.tableSize = tableSize;
this.AVAILABLE = Integer.MIN_VALUE; this.emptySlot = Integer.MIN_VALUE;
this.size = 0; this.size = 0;
this.thresh = (int) (Math.log(tableSize) / Math.log(2)) + 2; this.thresh = (int) (Math.log(tableSize) / Math.log(2)) + 2;
} }
@ -84,7 +84,7 @@ public class HashMapCuckooHashing {
loopCounter++; loopCounter++;
hash = hashFunction1(key); hash = hashFunction1(key);
if ((buckets[hash] == null) || Objects.equals(buckets[hash], AVAILABLE)) { if ((buckets[hash] == null) || Objects.equals(buckets[hash], emptySlot)) {
buckets[hash] = wrappedInt; buckets[hash] = wrappedInt;
size++; size++;
checkLoadFactor(); checkLoadFactor();
@ -95,7 +95,7 @@ public class HashMapCuckooHashing {
buckets[hash] = wrappedInt; buckets[hash] = wrappedInt;
wrappedInt = temp; wrappedInt = temp;
hash = hashFunction2(temp); hash = hashFunction2(temp);
if (Objects.equals(buckets[hash], AVAILABLE)) { if (Objects.equals(buckets[hash], emptySlot)) {
buckets[hash] = wrappedInt; buckets[hash] = wrappedInt;
size++; size++;
checkLoadFactor(); checkLoadFactor();
@ -124,7 +124,7 @@ public class HashMapCuckooHashing {
public void reHashTableIncreasesTableSize() { public void reHashTableIncreasesTableSize() {
HashMapCuckooHashing newT = new HashMapCuckooHashing(tableSize * 2); HashMapCuckooHashing newT = new HashMapCuckooHashing(tableSize * 2);
for (int i = 0; i < tableSize; i++) { for (int i = 0; i < tableSize; i++) {
if (buckets[i] != null && !Objects.equals(buckets[i], AVAILABLE)) { if (buckets[i] != null && !Objects.equals(buckets[i], emptySlot)) {
newT.insertKey2HashTable(this.buckets[i]); newT.insertKey2HashTable(this.buckets[i]);
} }
} }
@ -146,14 +146,14 @@ public class HashMapCuckooHashing {
} }
if (Objects.equals(buckets[hash], wrappedInt)) { if (Objects.equals(buckets[hash], wrappedInt)) {
buckets[hash] = AVAILABLE; buckets[hash] = emptySlot;
size--; size--;
return; return;
} }
hash = hashFunction2(key); hash = hashFunction2(key);
if (Objects.equals(buckets[hash], wrappedInt)) { if (Objects.equals(buckets[hash], wrappedInt)) {
buckets[hash] = AVAILABLE; buckets[hash] = emptySlot;
size--; size--;
return; return;
} }
@ -165,7 +165,7 @@ public class HashMapCuckooHashing {
*/ */
public void displayHashtable() { public void displayHashtable() {
for (int i = 0; i < tableSize; i++) { for (int i = 0; i < tableSize; i++) {
if ((buckets[i] == null) || Objects.equals(buckets[i], AVAILABLE)) { if ((buckets[i] == null) || Objects.equals(buckets[i], emptySlot)) {
System.out.println("Bucket " + i + ": Empty"); System.out.println("Bucket " + i + ": Empty");
} else { } else {
System.out.println("Bucket " + i + ": " + buckets[i].toString()); System.out.println("Bucket " + i + ": " + buckets[i].toString());
@ -229,7 +229,7 @@ public class HashMapCuckooHashing {
public boolean isFull() { public boolean isFull() {
boolean response = true; boolean response = true;
for (int i = 0; i < tableSize; i++) { for (int i = 0; i < tableSize; i++) {
if (buckets[i] == null || Objects.equals(buckets[i], AVAILABLE)) { if (buckets[i] == null || Objects.equals(buckets[i], emptySlot)) {
return false; return false;
} }
} }

10
src/main/java/com/thealgorithms/datastructures/queues/GenericArrayListQueue.java
View File

@ -15,7 +15,7 @@ public class GenericArrayListQueue<T> {
/** /**
* The generic ArrayList for the queue T is the generic element * The generic ArrayList for the queue T is the generic element
*/ */
ArrayList<T> _queue = new ArrayList<>(); ArrayList<T> elementList = new ArrayList<>();
/** /**
* Checks if the queue has elements (not empty). * Checks if the queue has elements (not empty).
@ -23,7 +23,7 @@ public class GenericArrayListQueue<T> {
* @return True if the queue has elements. False otherwise. * @return True if the queue has elements. False otherwise.
*/ */
private boolean hasElements() { private boolean hasElements() {
return !_queue.isEmpty(); return !elementList.isEmpty();
} }
/** /**
@ -35,7 +35,7 @@ public class GenericArrayListQueue<T> {
public T peek() { public T peek() {
T result = null; T result = null;
if (this.hasElements()) { if (this.hasElements()) {
result = _queue.get(0); result = elementList.get(0);
} }
return result; return result;
} }
@ -47,7 +47,7 @@ public class GenericArrayListQueue<T> {
* @return True if the element was added successfully * @return True if the element was added successfully
*/ */
public boolean add(T element) { public boolean add(T element) {
return _queue.add(element); return elementList.add(element);
} }
/** /**
@ -58,7 +58,7 @@ public class GenericArrayListQueue<T> {
public T pull() { public T pull() {
T result = null; T result = null;
if (this.hasElements()) { if (this.hasElements()) {
result = _queue.remove(0); result = elementList.remove(0);
} }
return result; return result;
} }

8
src/main/java/com/thealgorithms/datastructures/trees/FenwickTree.java
View File

@ -3,12 +3,12 @@ package com.thealgorithms.datastructures.trees;
public class FenwickTree { public class FenwickTree {
private int n; private int n;
private int[] fen_t; private int[] fenTree;
/* Constructor which takes the size of the array as a parameter */ /* Constructor which takes the size of the array as a parameter */
public FenwickTree(int n) { public FenwickTree(int n) {
this.n = n; this.n = n;
this.fen_t = new int[n + 1]; this.fenTree = new int[n + 1];
} }
/* A function which will add the element val at index i*/ /* A function which will add the element val at index i*/
@ -16,7 +16,7 @@ public class FenwickTree {
// As index starts from 0, increment the index by 1 // As index starts from 0, increment the index by 1
i += 1; i += 1;
while (i <= n) { while (i <= n) {
fen_t[i] += val; fenTree[i] += val;
i += i & (-i); i += i & (-i);
} }
} }
@ -27,7 +27,7 @@ public class FenwickTree {
i += 1; i += 1;
int cumSum = 0; int cumSum = 0;
while (i > 0) { while (i > 0) {
cumSum += fen_t[i]; cumSum += fenTree[i];
i -= i & (-i); i -= i & (-i);
} }
return cumSum; return cumSum;

92
src/main/java/com/thealgorithms/datastructures/trees/RedBlackBST.java
View File

@ -7,13 +7,13 @@ import java.util.Scanner;
*/ */
public class RedBlackBST { public class RedBlackBST {
private final int R = 0; private final int red = 0;
private final int B = 1; private final int black = 1;
private class Node { private class Node {
int key = -1; int key = -1;
int color = B; int color = black;
Node left = nil; Node left = nil;
Node right = nil; Node right = nil;
Node p = nil; Node p = nil;
@ -31,7 +31,7 @@ public class RedBlackBST {
return; return;
} }
printTree(node.left); printTree(node.left);
System.out.print(((node.color == R) ? " R " : " B ") + "Key: " + node.key + " Parent: " + node.p.key + "\n"); System.out.print(((node.color == red) ? " R " : " B ") + "Key: " + node.key + " Parent: " + node.p.key + "\n");
printTree(node.right); printTree(node.right);
} }
@ -39,7 +39,7 @@ public class RedBlackBST {
if (node == nil) { if (node == nil) {
return; return;
} }
System.out.print(((node.color == R) ? " R " : " B ") + "Key: " + node.key + " Parent: " + node.p.key + "\n"); System.out.print(((node.color == red) ? " R " : " B ") + "Key: " + node.key + " Parent: " + node.p.key + "\n");
printTreepre(node.left); printTreepre(node.left);
printTreepre(node.right); printTreepre(node.right);
} }
@ -66,10 +66,10 @@ public class RedBlackBST {
Node temp = root; Node temp = root;
if (root == nil) { if (root == nil) {
root = node; root = node;
node.color = B; node.color = black;
node.p = nil; node.p = nil;
} else { } else {
node.color = R; node.color = red;
while (true) { while (true) {
if (node.key < temp.key) { if (node.key < temp.key) {
if (temp.left == nil) { if (temp.left == nil) {
@ -94,15 +94,15 @@ public class RedBlackBST {
} }
private void fixTree(Node node) { private void fixTree(Node node) {
while (node.p.color == R) { while (node.p.color == red) {
Node y = nil; Node y = nil;
if (node.p == node.p.p.left) { if (node.p == node.p.p.left) {
y = node.p.p.right; y = node.p.p.right;
if (y != nil && y.color == R) { if (y != nil && y.color == red) {
node.p.color = B; node.p.color = black;
y.color = B; y.color = black;
node.p.p.color = R; node.p.p.color = red;
node = node.p.p; node = node.p.p;
continue; continue;
} }
@ -110,15 +110,15 @@ public class RedBlackBST {
node = node.p; node = node.p;
rotateLeft(node); rotateLeft(node);
} }
node.p.color = B; node.p.color = black;
node.p.p.color = R; node.p.p.color = red;
rotateRight(node.p.p); rotateRight(node.p.p);
} else { } else {
y = node.p.p.left; y = node.p.p.left;
if (y != nil && y.color == R) { if (y != nil && y.color == red) {
node.p.color = B; node.p.color = black;
y.color = B; y.color = black;
node.p.p.color = R; node.p.p.color = red;
node = node.p.p; node = node.p.p;
continue; continue;
} }
@ -126,12 +126,12 @@ public class RedBlackBST {
node = node.p; node = node.p;
rotateRight(node); rotateRight(node);
} }
node.p.color = B; node.p.color = black;
node.p.p.color = R; node.p.p.color = red;
rotateLeft(node.p.p); rotateLeft(node.p.p);
} }
} }
root.color = B; root.color = black;
} }
void rotateLeft(Node node) { void rotateLeft(Node node) {
@ -234,67 +234,67 @@ public class RedBlackBST {
y.left.p = y; y.left.p = y;
y.color = z.color; y.color = z.color;
} }
if (yorigcolor == B) { if (yorigcolor == black) {
deleteFixup(x); deleteFixup(x);
} }
return true; return true;
} }
void deleteFixup(Node x) { void deleteFixup(Node x) {
while (x != root && x.color == B) { while (x != root && x.color == black) {
if (x == x.p.left) { if (x == x.p.left) {
Node w = x.p.right; Node w = x.p.right;
if (w.color == R) { if (w.color == red) {
w.color = B; w.color = black;
x.p.color = R; x.p.color = red;
rotateLeft(x.p); rotateLeft(x.p);
w = x.p.right; w = x.p.right;
} }
if (w.left.color == B && w.right.color == B) { if (w.left.color == black && w.right.color == black) {
w.color = R; w.color = red;
x = x.p; x = x.p;
continue; continue;
} else if (w.right.color == B) { } else if (w.right.color == black) {
w.left.color = B; w.left.color = black;
w.color = R; w.color = red;
rotateRight(w); rotateRight(w);
w = x.p.right; w = x.p.right;
} }
if (w.right.color == R) { if (w.right.color == red) {
w.color = x.p.color; w.color = x.p.color;
x.p.color = B; x.p.color = black;
w.right.color = B; w.right.color = black;
rotateLeft(x.p); rotateLeft(x.p);
x = root; x = root;
} }
} else { } else {
Node w = x.p.left; Node w = x.p.left;
if (w.color == R) { if (w.color == red) {
w.color = B; w.color = black;
x.p.color = R; x.p.color = red;
rotateRight(x.p); rotateRight(x.p);
w = x.p.left; w = x.p.left;
} }
if (w.right.color == B && w.left.color == B) { if (w.right.color == black && w.left.color == black) {
w.color = R; w.color = red;
x = x.p; x = x.p;
continue; continue;
} else if (w.left.color == B) { } else if (w.left.color == black) {
w.right.color = B; w.right.color = black;
w.color = R; w.color = red;
rotateLeft(w); rotateLeft(w);
w = x.p.left; w = x.p.left;
} }
if (w.left.color == R) { if (w.left.color == red) {
w.color = x.p.color; w.color = x.p.color;
x.p.color = B; x.p.color = black;
w.left.color = B; w.left.color = black;
rotateRight(x.p); rotateRight(x.p);
x = root; x = root;
} }
} }
} }
x.color = B; x.color = black;
} }
public void insertDemo() { public void insertDemo() {

14
src/main/java/com/thealgorithms/datastructures/trees/SegmentTree.java
View File

@ -2,7 +2,7 @@ package com.thealgorithms.datastructures.trees;
public class SegmentTree { public class SegmentTree {
private int[] seg_t; private int[] segTree;
private int n; private int n;
private int[] arr; private int[] arr;
@ -12,7 +12,7 @@ public class SegmentTree {
int x = (int) (Math.ceil(Math.log(n) / Math.log(2))); int x = (int) (Math.ceil(Math.log(n) / Math.log(2)));
int segSize = 2 * (int) Math.pow(2, x) - 1; int segSize = 2 * (int) Math.pow(2, x) - 1;
this.seg_t = new int[segSize]; this.segTree = new int[segSize];
this.arr = arr; this.arr = arr;
this.n = n; this.n = n;
constructTree(arr, 0, n - 1, 0); constructTree(arr, 0, n - 1, 0);
@ -21,13 +21,13 @@ public class SegmentTree {
/* A function which will create the segment tree*/ /* A function which will create the segment tree*/
public final int constructTree(int[] arr, int start, int end, int index) { public final int constructTree(int[] arr, int start, int end, int index) {
if (start == end) { if (start == end) {
this.seg_t[index] = arr[start]; this.segTree[index] = arr[start];
return arr[start]; return arr[start];
} }
int mid = start + (end - start) / 2; int mid = start + (end - start) / 2;
this.seg_t[index] = constructTree(arr, start, mid, index * 2 + 1) + constructTree(arr, mid + 1, end, index * 2 + 2); this.segTree[index] = constructTree(arr, start, mid, index * 2 + 1) + constructTree(arr, mid + 1, end, index * 2 + 2);
return this.seg_t[index]; return this.segTree[index];
} }
/* A function which will update the value at a index i. This will be called by the /* A function which will update the value at a index i. This will be called by the
@ -37,7 +37,7 @@ public class SegmentTree {
return; return;
} }
this.seg_t[seg_index] += diff; this.segTree[seg_index] += diff;
if (start != end) { if (start != end) {
int mid = start + (end - start) / 2; int mid = start + (end - start) / 2;
updateTree(start, mid, index, diff, seg_index * 2 + 1); updateTree(start, mid, index, diff, seg_index * 2 + 1);
@ -60,7 +60,7 @@ public class SegmentTree {
* internally*/ * internally*/
private int getSumTree(int start, int end, int q_start, int q_end, int seg_index) { private int getSumTree(int start, int end, int q_start, int q_end, int seg_index) {
if (q_start <= start && q_end >= end) { if (q_start <= start && q_end >= end) {
return this.seg_t[seg_index]; return this.segTree[seg_index];
} }
if (q_start > end || q_end < start) { if (q_start > end || q_end < start) {

38
src/main/java/com/thealgorithms/dynamicprogramming/OptimalJobScheduling.java
View File

@ -13,24 +13,24 @@ public class OptimalJobScheduling {
private final int numberProcesses; private final int numberProcesses;
private final int numberMachines; private final int numberMachines;
private final int[][] Run; private final int[][] run;
private final int[][] Transfer; private final int[][] transfer;
private final int[][] Cost; private final int[][] cost;
/** /**
* Constructor of the class. * Constructor of the class.
* @param numberProcesses ,refers to the number of precedent processes(N) * @param numberProcesses ,refers to the number of precedent processes(N)
* @param numberMachines ,refers to the number of different machines in our disposal(M) * @param numberMachines ,refers to the number of different machines in our disposal(M)
* @param Run , N*M matrix refers to the cost of running each process to each machine * @param run , N*M matrix refers to the cost of running each process to each machine
* @param Transfer ,M*M symmetric matrix refers to the transportation delay for each pair of * @param transfer ,M*M symmetric matrix refers to the transportation delay for each pair of
* machines * machines
*/ */
public OptimalJobScheduling(int numberProcesses, int numberMachines, int[][] Run, int[][] Transfer) { public OptimalJobScheduling(int numberProcesses, int numberMachines, int[][] run, int[][] transfer) {
this.numberProcesses = numberProcesses; this.numberProcesses = numberProcesses;
this.numberMachines = numberMachines; this.numberMachines = numberMachines;
this.Run = Run; this.run = run;
this.Transfer = Transfer; this.transfer = transfer;
this.Cost = new int[numberProcesses][numberMachines]; this.cost = new int[numberProcesses][numberMachines];
} }
/** /**
@ -50,7 +50,7 @@ public class OptimalJobScheduling {
for (int j = 0; j < numberMachines; j++) { // for each Machine for (int j = 0; j < numberMachines; j++) { // for each Machine
Cost[i][j] = runningCost(i, j); cost[i][j] = runningCost(i, j);
} }
} }
} }
@ -71,7 +71,7 @@ public class OptimalJobScheduling {
if (process == 0) // refers to the first process,which does not require for a previous one if (process == 0) // refers to the first process,which does not require for a previous one
// to have been executed // to have been executed
return Run[process][machine]; return run[process][machine];
else { else {
int[] runningCosts = new int[numberMachines]; // stores the costs of executing our Process depending on int[] runningCosts = new int[numberMachines]; // stores the costs of executing our Process depending on
@ -79,7 +79,7 @@ public class OptimalJobScheduling {
for (int k = 0; k < numberMachines; k++) // computes the cost of executing the previous for (int k = 0; k < numberMachines; k++) // computes the cost of executing the previous
// process to each and every Machine // process to each and every Machine
runningCosts[k] = Cost[process - 1][k] + Transfer[k][machine] + Run[process][machine]; // transferring the result to our Machine and executing runningCosts[k] = cost[process - 1][k] + transfer[k][machine] + run[process][machine]; // transferring the result to our Machine and executing
// the Process to our Machine // the Process to our Machine
return findMin(runningCosts); // returns the minimum running cost return findMin(runningCosts); // returns the minimum running cost
@ -88,19 +88,19 @@ public class OptimalJobScheduling {
/** /**
* Function used in order to return the minimum Cost. * Function used in order to return the minimum Cost.
* @param cost ,an Array of size M which refers to the costs of executing a Process to each * @param costArr ,an Array of size M which refers to the costs of executing a Process to each
* Machine * Machine
* @return the minimum cost * @return the minimum cost
*/ */
private int findMin(int[] cost) { private int findMin(int[] costArr) {
int min = 0; int min = 0;
for (int i = 1; i < cost.length; i++) { for (int i = 1; i < costArr.length; i++) {
if (cost[i] < cost[min]) min = i; if (costArr[i] < costArr[min]) min = i;
} }
return cost[min]; return costArr[min];
} }
/** /**
@ -111,7 +111,7 @@ public class OptimalJobScheduling {
for (int i = 0; i < numberProcesses; i++) { for (int i = 0; i < numberProcesses; i++) {
for (int j = 0; j < numberMachines; j++) { for (int j = 0; j < numberMachines; j++) {
System.out.print(Cost[i][j]); System.out.print(cost[i][j]);
System.out.print(" "); System.out.print(" ");
} }
@ -124,6 +124,6 @@ public class OptimalJobScheduling {
* Getter for the running Cost of i process on j machine. * Getter for the running Cost of i process on j machine.
*/ */
public int getCost(int process, int machine) { public int getCost(int process, int machine) {
return Cost[process][machine]; return cost[process][machine];
} }
} }

8
src/test/java/com/thealgorithms/divideandconquer/StrassenMatrixMultiplicationTest.java
View File

@ -6,7 +6,7 @@ import org.junit.jupiter.api.Test;
class StrassenMatrixMultiplicationTest { class StrassenMatrixMultiplicationTest {
StrassenMatrixMultiplication SMM = new StrassenMatrixMultiplication(); StrassenMatrixMultiplication smm = new StrassenMatrixMultiplication();
// Strassen Matrix Multiplication can only be allplied to matrices of size 2^n // Strassen Matrix Multiplication can only be allplied to matrices of size 2^n
// and has to be a Square Matrix // and has to be a Square Matrix
@ -16,7 +16,7 @@ class StrassenMatrixMultiplicationTest {
int[][] a = {{1, 2}, {3, 4}}; int[][] a = {{1, 2}, {3, 4}};
int[][] b = {{5, 6}, {7, 8}}; int[][] b = {{5, 6}, {7, 8}};
int[][] expResult = {{19, 22}, {43, 50}}; int[][] expResult = {{19, 22}, {43, 50}};
int[][] actResult = SMM.multiply(a, b); int[][] actResult = smm.multiply(a, b);
assertArrayEquals(expResult, actResult); assertArrayEquals(expResult, actResult);
} }
@ -25,7 +25,7 @@ class StrassenMatrixMultiplicationTest {
int[][] a = {{1, 2, 5, 4}, {9, 3, 0, 6}, {4, 6, 3, 1}, {0, 2, 0, 6}}; int[][] a = {{1, 2, 5, 4}, {9, 3, 0, 6}, {4, 6, 3, 1}, {0, 2, 0, 6}};
int[][] b = {{1, 0, 4, 1}, {1, 2, 0, 2}, {0, 3, 1, 3}, {1, 8, 1, 2}}; int[][] b = {{1, 0, 4, 1}, {1, 2, 0, 2}, {0, 3, 1, 3}, {1, 8, 1, 2}};
int[][] expResult = {{7, 51, 13, 28}, {18, 54, 42, 27}, {11, 29, 20, 27}, {8, 52, 6, 16}}; int[][] expResult = {{7, 51, 13, 28}, {18, 54, 42, 27}, {11, 29, 20, 27}, {8, 52, 6, 16}};
int[][] actResult = SMM.multiply(a, b); int[][] actResult = smm.multiply(a, b);
assertArrayEquals(expResult, actResult); assertArrayEquals(expResult, actResult);
} }
@ -35,7 +35,7 @@ class StrassenMatrixMultiplicationTest {
int[][] a = {{1, 2, 3, 4}, {5, 6, 7, 8}, {9, 10, 11, 12}, {13, 14, 15, 16}}; int[][] a = {{1, 2, 3, 4}, {5, 6, 7, 8}, {9, 10, 11, 12}, {13, 14, 15, 16}};
int[][] b = {{1, -2, -3, 4}, {4, -3, -2, 1}, {5, -6, -7, 8}, {8, -7, -6, -5}}; int[][] b = {{1, -2, -3, 4}, {4, -3, -2, 1}, {5, -6, -7, 8}, {8, -7, -6, -5}};
int[][] expResult = {{56, -54, -52, 10}, {128, -126, -124, 42}, {200, -198, -196, 74}, {272, -270, -268, 106}}; int[][] expResult = {{56, -54, -52, 10}, {128, -126, -124, 42}, {200, -198, -196, 74}, {272, -270, -268, 106}};
int[][] actResult = SMM.multiply(a, b); int[][] actResult = smm.multiply(a, b);
assertArrayEquals(expResult, actResult); assertArrayEquals(expResult, actResult);
} }
} }

6
src/test/java/com/thealgorithms/sorts/BinaryInsertionSortTest.java
View File

@ -6,14 +6,14 @@ import org.junit.jupiter.api.Test;
class BinaryInsertionSortTest { class BinaryInsertionSortTest {
BinaryInsertionSort BIS = new BinaryInsertionSort(); BinaryInsertionSort bis = new BinaryInsertionSort();
@Test @Test
// valid test case // valid test case
public void binaryInsertionSortTestNonDuplicate() { public void binaryInsertionSortTestNonDuplicate() {
int[] array = {1, 0, 2, 5, 3, 4, 9, 8, 10, 6, 7}; int[] array = {1, 0, 2, 5, 3, 4, 9, 8, 10, 6, 7};
int[] expResult = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10}; int[] expResult = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10};
int[] actResult = BIS.binaryInsertSort(array); int[] actResult = bis.binaryInsertSort(array);
assertArrayEquals(expResult, actResult); assertArrayEquals(expResult, actResult);
} }
@ -21,7 +21,7 @@ class BinaryInsertionSortTest {
public void binaryInsertionSortTestDuplicate() { public void binaryInsertionSortTestDuplicate() {
int[] array = {1, 1, 1, 5, 9, 8, 7, 2, 6}; int[] array = {1, 1, 1, 5, 9, 8, 7, 2, 6};
int[] expResult = {1, 1, 1, 2, 5, 6, 7, 8, 9}; int[] expResult = {1, 1, 1, 2, 5, 6, 7, 8, 9};
int[] actResult = BIS.binaryInsertSort(array); int[] actResult = bis.binaryInsertSort(array);
assertArrayEquals(expResult, actResult); assertArrayEquals(expResult, actResult);
} }
} }