diff --git a/README.md b/README.md index c3b9afae..2c7f7e81 100644 --- a/README.md +++ b/README.md @@ -117,8 +117,8 @@ In order to achieve greater coverage and encourage more people to contribute to - - + + @@ -233,8 +233,8 @@ In order to achieve greater coverage and encourage more people to contribute to - - + + @@ -291,8 +291,8 @@ In order to achieve greater coverage and encourage more people to contribute to - - + + @@ -1063,7 +1063,7 @@ In order to achieve greater coverage and encourage more people to contribute to - + diff --git a/src/java/BinarySearch.java b/src/java/BinarySearch.java index dc24ee34..5be77b42 100644 --- a/src/java/BinarySearch.java +++ b/src/java/BinarySearch.java @@ -1,8 +1,8 @@ -public class BuscaBinaria { +public class BinarySearch { public int posicao; - BuscaBinaria(int[] array, int Objetivo) { + BinarySearch(int[] array, int Objetivo) { this.posicao = BinarySearch(Objetivo, array); } diff --git a/src/java/BinarySearchTree.java b/src/java/BinarySearchTree.java index ca4fe4bf..82b3e405 100644 --- a/src/java/BinarySearchTree.java +++ b/src/java/BinarySearchTree.java @@ -1,7 +1,7 @@ /* * Utiliza a classe No */ -public class ArvoreDeBuscaBinaria { +public class BinarySearchTree { public static void main(String[] args) { No Arvore = new No(45); diff --git a/src/java/BinaryTree.java b/src/java/BinaryTree.java index 495c5cef..4095ed05 100644 --- a/src/java/BinaryTree.java +++ b/src/java/BinaryTree.java @@ -2,7 +2,7 @@ * Utiliza a classe No */ -public class ArvoreBinaria { +public class BinaryTree { public static void main(String[] args) { No raiz = new No(9); diff --git a/src/java/BucketSort.java b/src/java/BucketSort.java index 5f81a84a..cdfd1849 100644 --- a/src/java/BucketSort.java +++ b/src/java/BucketSort.java @@ -1,3 +1,7 @@ +import java.util.ArrayList; +import java.util.Collections; +import java.util.List; + public class BucketSort { /** diff --git a/src/java/DoublyLinkedList.java b/src/java/DoublyLinkedList.java index 3e2aa44e..d96a6c31 100644 --- a/src/java/DoublyLinkedList.java +++ b/src/java/DoublyLinkedList.java @@ -1,7 +1,7 @@ // javac ListaDuplamenteEncadeada.java // java ListaDuplamenteEncadeada -public class ListaDuplamenteEncadeada { +public class DoublyLinkedList { public static void main(String[] args) { LinkedList linkedList = new LinkedList(); diff --git a/src/java/ExponentiationRecursive.java b/src/java/ExponentiationRecursive.java index 953f0cf4..4675ec2a 100644 --- a/src/java/ExponentiationRecursive.java +++ b/src/java/ExponentiationRecursive.java @@ -1,4 +1,4 @@ -class Main { +class ExponencialRecursive { public static long exponenciacao(long base, long expoente) { // exponenciacao recursiva if (expoente == 0) return 1; diff --git a/src/java/Factorial.java b/src/java/Factorial.java index 26e4c461..21df2626 100644 --- a/src/java/Factorial.java +++ b/src/java/Factorial.java @@ -1,10 +1,10 @@ -public class Fatorial { +public class Factorial { public static void main(String[] args) { - System.out.println("Fatorial de 7 : " + Fatorial(7)); + System.out.println("Fatorial de 7 : " + Factorial(7)); } - public static int Fatorial(int x) { + public static int Factorial(int x) { int total = 1; for (int i = 2; i < x + 1; i++) { total = total * i; diff --git a/src/java/FactorialRecursive.java b/src/java/FactorialRecursive.java index ef4d6489..bc4bf458 100644 --- a/src/java/FactorialRecursive.java +++ b/src/java/FactorialRecursive.java @@ -1,14 +1,14 @@ -public class FatorialRecursiva { +public class FactorialRecursive { public static void main(String[] args) { - System.out.println("Fatorial de 0 : " + Fatorial(0)); - System.out.println("Fatorial de 1 : " + Fatorial(1)); - System.out.println("Fatorial de 3 : " + Fatorial(3)); - System.out.println("Fatorial de 7 : " + Fatorial(7)); + System.out.println("Fatorial de 0 : " + FactorialRecursive(0)); + System.out.println("Fatorial de 1 : " + FactorialRecursive(1)); + System.out.println("Fatorial de 3 : " + FactorialRecursive(3)); + System.out.println("Fatorial de 7 : " + FactorialRecursive(7)); } - public static int Fatorial(int x) { + public static int FactorialRecursive(int x) { if (x <= 1) return 1; - else return x * Fatorial(x - 1); + else return x * FactorialRecursive(x - 1); } } diff --git a/src/java/FibonacciIterative.java b/src/java/FibonacciIterative.java index aa0920b4..92d60e0f 100644 --- a/src/java/FibonacciIterative.java +++ b/src/java/FibonacciIterative.java @@ -1,10 +1,10 @@ -public class Fibonacci { +public class FibonacciIterative { public static void main(String[] args) { - System.out.println("Fib(16) : " + Fibonacci(16)); + System.out.println("Fib(16) : " + FibonacciIterative(16)); } - public static int Fibonacci(int x) { + public static int FibonacciIterative(int x) { if (x <= 1) { return 1; } else { diff --git a/src/java/FibonacciMemoization.java b/src/java/FibonacciMemorization.java similarity index 94% rename from src/java/FibonacciMemoization.java rename to src/java/FibonacciMemorization.java index fadf81e7..b353341d 100644 --- a/src/java/FibonacciMemoization.java +++ b/src/java/FibonacciMemorization.java @@ -1,6 +1,6 @@ import java.util.HashMap; -public class Fibonacci { +public class FibonacciMemorization { // Create a memoization HashMap to store computed Fibonacci values private static HashMap memo = new HashMap<>(); diff --git a/src/java/FibonacciRecursive.java b/src/java/FibonacciRecursive.java index 6d20e122..87915db5 100644 --- a/src/java/FibonacciRecursive.java +++ b/src/java/FibonacciRecursive.java @@ -1,11 +1,11 @@ -public class Fibonacci { +public class FibonacciRecursive { public static void main(String[] args) { - System.out.println("Fib(16) : " + Fibonacci(16)); + System.out.println("Fib(16) : " + FibonacciRecursive(16)); } - public static int Fibonacci(int x) { + public static int FibonacciRecursive(int x) { if (x <= 1) return 1; - else return Fibonacci(x - 1) + Fibonacci(x - 2); + else return FibonacciRecursive(x - 1) + FibonacciRecursive(x - 2); } } diff --git a/src/java/LinearSearch.java b/src/java/LinearSearch.java index f1a65408..79ad6655 100644 --- a/src/java/LinearSearch.java +++ b/src/java/LinearSearch.java @@ -1,4 +1,4 @@ -public class LinearSearchIterative { +public class LinearSearch { public static void main(String[] args) { int array[] = {1, 2, 40, 233, 78, 83, 456}; System.out.println(LinearSearch(array, 40)); diff --git a/src/java/MaxRecursive.java b/src/java/MaxRecursive.java index 8310098a..e55edf1a 100644 --- a/src/java/MaxRecursive.java +++ b/src/java/MaxRecursive.java @@ -1,4 +1,4 @@ -public class MaxMinArray { +public class MaxRecursive { public static void main(String[] args) { int vetor[] = {9, 0, 4, 2, 3, 8, 7, 1, 6, 5}; diff --git a/src/java/MinMaxIterative.java b/src/java/MinMaxIterative.java index 0f110068..f9563e97 100644 --- a/src/java/MinMaxIterative.java +++ b/src/java/MinMaxIterative.java @@ -1,4 +1,4 @@ -public class MinMaxIterativo { +public class MinMaxIterative { public static void main(String[] args) { int arr[] = {1, 5, -20, 6, 15}; int min = arr[0]; diff --git a/src/java/MinMaxRecursive.java b/src/java/MinMaxRecursive.java index dc914fdf..ee9c830c 100644 --- a/src/java/MinMaxRecursive.java +++ b/src/java/MinMaxRecursive.java @@ -1,4 +1,4 @@ -public class MinMaxRecursivo { +public class MinMaxRecursive { public static void main(String[] args) { int[] arr = {9, 8, 13, 33, 18, 20, 88, 14, 40, 77}; diff --git a/src/java/Palindrome.java b/src/java/Palindrome.java index 08d66111..cd6e70ea 100644 --- a/src/java/Palindrome.java +++ b/src/java/Palindrome.java @@ -1,4 +1,4 @@ -public class Palindromo { +public class Palindrome { public static void main(String[] args) { String palavra, palavraInvertida = ""; palavra = "A grama é amarga"; diff --git a/src/java/Queue.java b/src/java/Queue.java index 97835b7b..d5fff4d2 100644 --- a/src/java/Queue.java +++ b/src/java/Queue.java @@ -1,46 +1,29 @@ -public class fila { +public class Queue { - public processo processoAtual; - public fila proximaFila; + public T processoAtual; + public Queue proximaFila; - public fila() { + public Queue() { this.processoAtual = null; this.proximaFila = null; } - public void inserirfila(processo processoNovo) { + public void inserirfila(T processoNovo) { if (this.processoAtual == null) { this.processoAtual = processoNovo; - this.proximaFila = new fila(); + this.proximaFila = new Queue<>(); } else { this.proximaFila.inserirfila(processoNovo); } } - public processo removerfila() { - processo removido = this.processoAtual; + public T removerfila() { + T removido = this.processoAtual; this.processoAtual = this.proximaFila.processoAtual; this.proximaFila = this.proximaFila.proximaFila; return removido; } - public String checkfila(String vazia) { - if (this.proximaFila.proximaFila == null) { - vazia = - vazia + " " + this.processoAtual.getPrioridade() + " " + this.processoAtual.getTempo(); - } else { - vazia = - vazia - + " " - + this.processoAtual.getPrioridade() - + " " - + this.processoAtual.getTempo() - + " &&" - + this.proximaFila.checkfila(vazia); - } - return vazia; - } - public boolean vaziafila() { if (this.proximaFila == null) { return true; diff --git a/src/java/Stack.java b/src/java/Stack.java index 0172a61d..805a2583 100644 --- a/src/java/Stack.java +++ b/src/java/Stack.java @@ -1,25 +1,25 @@ -public class pilha { +public class Stack { - public processo processoAtual; - public pilha proximaPilha; + public T processoAtual; + public Stack proximaPilha; - public pilha() { + public Stack() { this.processoAtual = null; this.proximaPilha = null; } - public void inserirpilha(processo processoNovo) { + public void inserirpilha(T processoNovo) { if (this.processoAtual == null) { this.processoAtual = processoNovo; - this.proximaPilha = new pilha(); + this.proximaPilha = new Stack<>(); } else { this.proximaPilha.inserirpilha(processoNovo); } } - public processo removerPilha() { + public T removerPilha() { if (this.proximaPilha.proximaPilha == null) { - processo removido = this.processoAtual; + T removido = this.processoAtual; this.processoAtual = null; this.proximaPilha = null; return removido; @@ -28,31 +28,6 @@ public processo removerPilha() { } } - public String checkpilha(String vazia) { - if (this.proximaPilha.proximaPilha == null) { - vazia = - " " + this.processoAtual.getPrioridade() + " " + this.processoAtual.getTempo() + vazia; - } else { - vazia = - this.proximaPilha.checkpilha(vazia) - + " && " - + this.processoAtual.getPrioridade() - + " " - + this.processoAtual.getTempo() - + " " - + vazia; - } - return vazia; - } - public boolean vaziaPilha() { - if (this.proximaPilha == null) { - return true; - } - return false; - } - - public int tempoTrabalhado(int tempo) { - return this.processoAtual.trabalhado(tempo); - } -} + return this.proximaPilha == null; + }} diff --git a/src/java/TestMergeSort.java b/src/java/TestMergeSort.java index 6893257c..fe54b317 100644 --- a/src/java/TestMergeSort.java +++ b/src/java/TestMergeSort.java @@ -1,4 +1,4 @@ -public class teste { +public class TestMergeSort { public static void main(String[] args) { int[] arrayteste = {10, 8, 6, 4, 2, 0, 1, 3, 5, 7, 9}; MergeSort ordem = new MergeSort(); diff --git a/src/java/TowerOfHanoi.java b/src/java/TowerOfHanoi.java index aa013464..b1206d9b 100644 --- a/src/java/TowerOfHanoi.java +++ b/src/java/TowerOfHanoi.java @@ -1,4 +1,4 @@ -public class TorreDeHanoi { +public class TowerOfHanoi { public static void main(String[] args) { TorreDeHanoi(0, 2, 1, 8); diff --git a/src/kotlin/BinarySearch.kt b/src/kotlin/BinarySearch.kt new file mode 100644 index 00000000..d2663d6f --- /dev/null +++ b/src/kotlin/BinarySearch.kt @@ -0,0 +1,27 @@ +fun > binarySearch(list: List, value: T): Int { + var start = 0 + var end = list.size - 1 + var middle = end / 2 + + while (start != end) { + when { + list[middle] < value -> { + start = middle + 1 + middle = (start + end) / 2 + } + list[middle] > value -> { + end = middle + middle = (start + end) / 2 + } + list[middle] == value -> { + return middle + } + } + } + + return -1 +} + +fun main() { + print(binarySearch(listOf(1, 5, 10, 12, 18, 22, 87, 90, 112, 129), 12)) +} \ No newline at end of file diff --git a/src/kotlin/Dijkstra.kt b/src/kotlin/Dijkstra.kt new file mode 100644 index 00000000..99f31118 --- /dev/null +++ b/src/kotlin/Dijkstra.kt @@ -0,0 +1,52 @@ +import java.util.PriorityQueue + +// Uses Graph from GraphSearch.kt + +fun dijkstra(source: Vertex, target: Vertex): Int { + val distance: MutableMap = mutableMapOf() + + val queue = PriorityQueue { a, b -> + val distanceA = distance[a] ?: return@PriorityQueue 0 + val distanceB = distance[b] ?: return@PriorityQueue 0 + distanceA - distanceB + } + queue.add(source) + distance[source] = 0 + + while (queue.isNotEmpty()) { + val currentVertex = queue.poll() + val currentDistance = distance[currentVertex] ?: Int.MAX_VALUE + + if (currentVertex == target) { + return currentDistance + } + + currentVertex.neighbors.forEach { edge -> + val nextVertexDistance = distance[edge.target] ?: Int.MAX_VALUE + if (nextVertexDistance > currentDistance + edge.weight) { + queue.remove(edge.target) + distance[edge.target] = currentDistance + edge.weight + queue.add(edge.target) + } + } + } + + return distance[target] ?: -1 +} + +fun main() { + val v0 = Vertex("0") + val v1 = Vertex("1") + val v2 = Vertex("2") + val v3 = Vertex("3") + val v4 = Vertex("4") + + v0.addNeighbor(v1, 6) + v0.addNeighbor(v2, 10) + v1.addNeighbor(v3, 2) + v2.addNeighbor(v3, 1) + v2.addNeighbor(v4, 3) + v3.addNeighbor(v4, 8) + + println("Distance 0 -> 4: ${dijkstra(v0, v4)}") +} \ No newline at end of file diff --git a/src/kotlin/ExponentiationRecursive.kt b/src/kotlin/ExponentiationRecursive.kt index bb6039a5..78c18260 100644 --- a/src/kotlin/ExponentiationRecursive.kt +++ b/src/kotlin/ExponentiationRecursive.kt @@ -10,7 +10,7 @@ * @return will return the *base* number raised by the *exponent*. The function returns a value of type *Long*. */ fun exponentiationRecursive(base: Int, exponent: Int): Long { - return if (exponent === 0) { + return if (exponent == 0) { 1 }; else { base * exponentiationRecursive(base, exponent - 1) diff --git a/src/kotlin/FibonacciIterative.kt b/src/kotlin/FibonacciIterative.kt index f7408cfc..497e1486 100644 --- a/src/kotlin/FibonacciIterative.kt +++ b/src/kotlin/FibonacciIterative.kt @@ -1,5 +1,5 @@ // Function to calculate Fibonacci numbers iteratively -fun fibonacci(n: Int): Long { + fun fibonacciIteractive(n: Int): Long { if (n <= 1) { return n.toLong() } @@ -19,5 +19,5 @@ fun fibonacci(n: Int): Long { fun main() { val index = 15 - println("Fibonacci (iterative) of $index is: ${fibonacci(index)}") + println("Fibonacci (iterative) of $index is: ${fibonacciIteractive(index)}") } diff --git a/src/kotlin/FibonacciMemoization.kt b/src/kotlin/FibonacciMemoization.kt index 5382adf0..33622786 100644 --- a/src/kotlin/FibonacciMemoization.kt +++ b/src/kotlin/FibonacciMemoization.kt @@ -2,7 +2,7 @@ val memo = mutableMapOf() // Function to calculate Fibonacci numbers using memoization -fun fibonacci(n: Int): Long { +fun fibonacciMemorization(n: Int): Long { if (n <= 1) { return n.toLong() } @@ -13,7 +13,7 @@ fun fibonacci(n: Int): Long { } // Calculate Fibonacci recursively and store the result in memoization - val result = fibonacci(n - 1) + fibonacci(n - 2) + val result = fibonacciMemorization(n - 1) + fibonacciMemorization(n - 2) memo[n] = result return result @@ -21,5 +21,5 @@ fun fibonacci(n: Int): Long { fun main() { val index = 15 - println("Fibonacci (memoization) of $index is: ${fibonacci(index)}") + println("Fibonacci (memoization) of $index is: ${fibonacciMemorization(index)}") } diff --git a/src/kotlin/FibonacciRecursive.kt b/src/kotlin/FibonacciRecursive.kt index 7dc666d7..1838652d 100644 --- a/src/kotlin/FibonacciRecursive.kt +++ b/src/kotlin/FibonacciRecursive.kt @@ -8,14 +8,14 @@ * * @return will return a logical condition if *number* is less than or equal to 1, returns 1 otherwise, the sum of itself using the concept of *recursion* to execute this sum. */ -fun fibonacci(number: Int): Int { +fun fibonacciRecursive(number: Int): Int { return if (number <= 1) { 1 }; else { - fibonacci(number - 1) + fibonacci(number - 2) + fibonacciRecursive(number - 1) + fibonacciRecursive(number - 2) } } fun main() { - println(fibonacci(5)) + println(fibonacciRecursive(5)) } diff --git a/src/kotlin/GraphSearch.kt b/src/kotlin/GraphSearch.kt new file mode 100644 index 00000000..8c512ce0 --- /dev/null +++ b/src/kotlin/GraphSearch.kt @@ -0,0 +1,88 @@ +class Edge(val target: Vertex, val weight: Int = 1) + +class Vertex(val label: String, var neighbors: MutableList = mutableListOf()) { + fun addNeighbor(other: Vertex, weight: Int = 1) { + other.neighbors.add(Edge(this, weight)) + this.neighbors.add(Edge(other, weight)) + } + + override fun hashCode(): Int { + return label.hashCode() + } + + override fun equals(other: Any?): Boolean { + if (other !is Vertex) { + return false + } + return label == other.label + } +} + +// Returns the distance found, or -1 when not found +fun dfs(source: Vertex, target: Vertex): Int { + val visited: MutableMap = mutableMapOf() + + return _dfs(source, target, visited) +} + +internal fun _dfs(source: Vertex, target: Vertex, visited: MutableMap): Int { + visited[source] = true + if (source == target) return 0 + source.neighbors.forEach { edge -> + if (visited[edge.target] == true) { + return@forEach + } + _dfs(edge.target, target, visited).let { + if (it != -1) { + return it + edge.weight + } + } + } + return -1 +} + +// Returns the distance found, or -1 when not found +fun bfs(source: Vertex, target: Vertex): Int { + val distance: MutableMap = mutableMapOf() + + val queue = mutableListOf(source) + distance[source] = 0 + + while (queue.isNotEmpty()) { + val currentVertex = queue.removeFirst() + if (currentVertex == target) { + return distance[currentVertex]!! + } + currentVertex.neighbors.forEach { edge -> + if (distance[edge.target] == null) { + distance[edge.target] = distance[currentVertex]!! + edge.weight + queue.add(edge.target) + } + } + } + + return -1 +} + +fun main() { + val A = Vertex("A") + val B = Vertex("B") + val C = Vertex("C") + val D = Vertex("D") + val E = Vertex("E") + val F = Vertex("F") + + + A.addNeighbor(B) + A.addNeighbor(C) + B.addNeighbor(D) + C.addNeighbor(D) + B.addNeighbor(E) + D.addNeighbor(E) + E.addNeighbor(F) + D.addNeighbor(F) + + println("DFS A -> F: ${dfs(A, F)}") + + println("BFS A -> F: ${bfs(A, F)}") +} \ No newline at end of file