update from forks

CONTRIBUTING.md

@@ -1,2 +1,27 @@
-## Contribution Guidelines
-Read our [Contribution Guidelines](CONTRIBUTING.md) before you contribute.
+:+1::tada: Before guiding you through the contribution process TheAlgorithms/Java thank you for being one of us! :+1::tada:
+
+## How to contribute?
+
+#### **Did you find a bug?**
+
+* **Ensure the bug was not already reported** by searching on GitHub under [Project Issues](https://github.com/TheAlgorithms/Java/issues).
+
+* Please avoid opening issues asking to be "assigned” to a particular algorithm.  This merely creates unnecessary noise for maintainers.  Instead, please submit your implementation in a pull request and it will be evaluated by project maintainers.
+
+* If you are unable to find an open issue refering to the same problem, depending on the type of issue follow the appropriate steps:
+
+#### **Do you want to contribute to the documentation?**
+
+* Please read the documentation in here [Contributing to the Documentation]() ,[open a new one issue](https://github.com/TheAlgorithms/Java/issues/new), make changes and then create a pull request, it will be put under review and accepted if it is approprite.
+
+#### **Do you want to add a new feature?**
+* [Open a new one issue](https://github.com/TheAlgorithms/Java/issues/new). Be sure to include a **title and a clear description** and a **test case** demonstrating the new feature that you want to add to the project.
+
+#### **Do you want to fix a bug?**
+* [Open a new one issue](https://github.com/TheAlgorithms/Java/issues/new).Be sure to include a **title and a clear description** and a **test case** demonstrating the expected behaviour that is not occuring.
+
+#### **Do you have questions about the source code?**
+
+* Ask any question about how to use the repository in the [TheAlgorithms room in GITTER](https://gitter.im/TheAlgorithms/community?source=orgpage#) or [open a new one issue](https://github.com/TheAlgorithms/Java/issues/new)
+
+:+1::tada: That's all you need to know about the process now it's your turn to help us improve the repository, thank you again! :+1::tada:

Conversions/DecimalToBinary.java

@@ -27,7 +27,7 @@ public static void main(String args[]) {
     public static void conventionalConversion() {
         int n, b = 0, c = 0, d;
         Scanner input = new Scanner(System.in);
-        System.out.printf("Conventional conversion.\n\tEnter the decimal number: ");
+        System.out.printf("Conventional conversion.%n Enter the decimal number: ");
         n = input.nextInt();
         while (n != 0) {
             d = n % 2;
@@ -46,7 +46,7 @@ public static void conventionalConversion() {
     public static void bitwiseConversion() {
         int n, b = 0, c = 0, d;
         Scanner input = new Scanner(System.in);
-        System.out.printf("Bitwise conversion.\n\tEnter the decimal number: ");
+        System.out.printf("Bitwise conversion.%n Enter the decimal number: ");
         n = input.nextInt();
         while (n != 0) {
             d = (n & 1);

Conversions/OctalToHexadecimal.java

@@ -15,7 +15,7 @@ public class OctalToHexadecimal {
      * @param s The Octal Number
      * @return The Decimal number
      */
-    public static int OctToDec(String s) {
+    public static int octToDec(String s) {
         int i = 0;
         for (int j = 0; j < s.length(); j++) {
             char num = s.charAt(j);
@@ -32,7 +32,7 @@ public static int OctToDec(String s) {
      * @param d The Decimal Number
      * @return The Hexadecimal number
      */
-    public static String DecimalToHex(int d) {
+    public static String decimalToHex(int d) {
         String digits = "0123456789ABCDEF";
         if (d <= 0)
             return "0";
@@ -54,10 +54,10 @@ public static void main(String args[]) {
         String oct = input.next();
 
         // Pass the octal number to function and get converted deciaml form
-        int decimal = OctToDec(oct);
+        int decimal = octToDec(oct);
 
         // Pass the decimla number to function and get converted Hex form of the number
-        String hex = DecimalToHex(decimal);
+        String hex = decimalToHex(decimal);
         System.out.println("The Hexadecimal equivalant is: " + hex);
         input.close();
     }

DIRECTORY.md

@@ -35,19 +35,19 @@
   * DynamicArray
     * [DynamicArray](https://github.com/TheAlgorithms/Java/blob/master/DataStructures/DynamicArray/DynamicArray.java)
   * Graphs
+    * [A Star](https://github.com/TheAlgorithms/Java/blob/master/DataStructures/Graphs/A_Star.java)
     * [BellmanFord](https://github.com/TheAlgorithms/Java/blob/master/DataStructures/Graphs/BellmanFord.java)
     * [ConnectedComponent](https://github.com/TheAlgorithms/Java/blob/master/DataStructures/Graphs/ConnectedComponent.java)
     * [Cycles](https://github.com/TheAlgorithms/Java/blob/master/DataStructures/Graphs/Cycles.java)
     * [FloydWarshall](https://github.com/TheAlgorithms/Java/blob/master/DataStructures/Graphs/FloydWarshall.java)
     * [Graphs](https://github.com/TheAlgorithms/Java/blob/master/DataStructures/Graphs/Graphs.java)
+    * [Kruskal](https://github.com/TheAlgorithms/Java/blob/master/DataStructures/Graphs/Kruskal.java)
     * [MatrixGraphs](https://github.com/TheAlgorithms/Java/blob/master/DataStructures/Graphs/MatrixGraphs.java)
     * [PrimMST](https://github.com/TheAlgorithms/Java/blob/master/DataStructures/Graphs/PrimMST.java)
   * HashMap
     * Hashing
       * [HashMap](https://github.com/TheAlgorithms/Java/blob/master/DataStructures/HashMap/Hashing/HashMap.java)
-      * [LinkedList](https://github.com/TheAlgorithms/Java/blob/master/DataStructures/HashMap/Hashing/LinkedList.java)
       * [Main](https://github.com/TheAlgorithms/Java/blob/master/DataStructures/HashMap/Hashing/Main.java)
-      * [Node](https://github.com/TheAlgorithms/Java/blob/master/DataStructures/HashMap/Hashing/Node.java)
   * Heaps
     * [EmptyHeapException](https://github.com/TheAlgorithms/Java/blob/master/DataStructures/Heaps/EmptyHeapException.java)
     * [Heap](https://github.com/TheAlgorithms/Java/blob/master/DataStructures/Heaps/Heap.java)
@@ -139,6 +139,7 @@
   * [PalindromePrime](https://github.com/TheAlgorithms/Java/blob/master/Misc/PalindromePrime.java)
 
 ## Others
+  * [3 sum](https://github.com/TheAlgorithms/Java/blob/master/Others/3%20sum.java)
   * [Abecedarian](https://github.com/TheAlgorithms/Java/blob/master/Others/Abecedarian.java)
   * [Armstrong](https://github.com/TheAlgorithms/Java/blob/master/Others/Armstrong.java)
   * [BestFit](https://github.com/TheAlgorithms/Java/blob/master/Others/BestFit.java)
@@ -169,6 +170,7 @@
   * [ReverseStackUsingRecursion](https://github.com/TheAlgorithms/Java/blob/master/Others/ReverseStackUsingRecursion.java)
   * [ReverseString](https://github.com/TheAlgorithms/Java/blob/master/Others/ReverseString.java)
   * [RootPrecision](https://github.com/TheAlgorithms/Java/blob/master/Others/RootPrecision.java)
+  * [Rotation of array without using extra space](https://github.com/TheAlgorithms/Java/blob/master/Others/Rotation%20of%20array%20without%20using%20extra%20space.java)
   * [SieveOfEratosthenes](https://github.com/TheAlgorithms/Java/blob/master/Others/SieveOfEratosthenes.java)
   * [SJF](https://github.com/TheAlgorithms/Java/blob/master/Others/SJF.java)
   * [SkylineProblem](https://github.com/TheAlgorithms/Java/blob/master/Others/SkylineProblem.java)
@@ -193,6 +195,7 @@
   * [BitonicSort](https://github.com/TheAlgorithms/Java/blob/master/Sorts/BitonicSort.java)
   * [BogoSort](https://github.com/TheAlgorithms/Java/blob/master/Sorts/BogoSort.java)
   * [BubbleSort](https://github.com/TheAlgorithms/Java/blob/master/Sorts/BubbleSort.java)
+  * [BucketSort](https://github.com/TheAlgorithms/Java/blob/master/Sorts/BucketSort.java)
   * [CocktailShakerSort](https://github.com/TheAlgorithms/Java/blob/master/Sorts/CocktailShakerSort.java)
   * [CombSort](https://github.com/TheAlgorithms/Java/blob/master/Sorts/CombSort.java)
   * [CountingSort](https://github.com/TheAlgorithms/Java/blob/master/Sorts/CountingSort.java)

DataStructures/DynamicArray/DynamicArray.java

@@ -41,7 +41,7 @@ public void add(final E element) {
     }
 
     public void put(final int index, E element) {
-        Objects.checkIndex(index, this.size);
+//        Objects.checkIndex(index, this.size);
 
         this.elements[index] = element;
     }
@@ -79,7 +79,7 @@ private void fastRemove(final Object[] elements, final int index) {
     }
 
     private E getElement(final int index) {
-        Objects.checkIndex(index, this.size);
+//        Objects.checkIndex(index, this.size);
         return (E) this.elements[index];
     }
 

DataStructures/Graphs/A_Star.java

@@ -0,0 +1,159 @@
+/*
+	Time Complexity = O(E), where E is equal to the number of edges
+*/
+
+package A_Star;
+
+import java.util.*;
+
+public class A_Star {
+
+    private static class Graph {
+        //Graph's structure can be changed only applying changes to this class.
+        private ArrayList<Edge> [] graph;
+
+        //Initialise ArrayLists in Constructor
+        public Graph(int size) {
+            this.graph = new ArrayList[size];
+            for (int i = 0; i < size; i++) {
+                this.graph[i] = new ArrayList<>();
+            }
+        }
+
+        private ArrayList<Edge> getNeighbours(int from) { return this.graph[from]; }
+
+        //Graph is bidirectional, for just one direction remove second instruction of this method.
+        private void addEdge (Edge edge) {
+            this.graph[edge.getFrom()].add(new Edge(edge.getFrom(), edge.getTo(), edge.getWeight()));
+            this.graph[edge.getTo()].add(new Edge(edge.getTo(), edge.getFrom(), edge.getWeight()));
+        }
+    }
+
+    private static class Edge {
+        private int from;
+        private int to;
+        private int weight;
+
+        public Edge(int from, int to, int weight) {
+            this.from = from;
+            this.to = to;
+            this.weight = weight;
+        }
+
+        public int getFrom() { return from; }
+
+        public int getTo() { return to; }
+
+        public int getWeight() { return weight; }
+    }
+
+    //class to iterate during the algorithm execution, and also used to return the solution.
+    private static class PathAndDistance {
+        private int distance; //distance advanced so far.
+        private ArrayList<Integer> path; //list of visited nodes in this path.
+        private int estimated; //heuristic value associated to the last node od the path (current node).
+
+        public PathAndDistance(int distance, ArrayList<Integer> path, int estimated) {
+            this.distance = distance;
+            this.path = path;
+            this.estimated = estimated;
+        }
+
+        public int getDistance() { return distance; }
+
+        public ArrayList<Integer> getPath() { return path; }
+
+        public int getEstimated() { return estimated; }
+
+        private void printSolution () {
+            if (this.path != null)
+                System.out.println("Optimal path: " + this.path.toString() +
+                        ", distance: " + this.distance);
+            else
+                System.out.println("There is no path available to connect the points");
+        }
+    }
+
+    private static void initializeGraph(Graph graph, ArrayList<Integer> data) {
+        for (int i = 0; i < data.size(); i+=4) {
+            graph.addEdge(new Edge(data.get(i), data.get(i + 1), data.get(i + 2)));
+        }
+        /*
+        .x. node
+        (y) cost
+        - or | or / bidirectional connection
+
+                              ( 98)- .7. -(86)- .4.
+                                |
+                        ( 85)- .17. -(142)- .18. -(92)- .8. -(87)- .11.
+                          |
+                         . 1. -------------------- (160)
+                          |  \                       |
+                        (211) \                     .6.
+                          |    \                     |
+                         . 5.  (101)-.13. -(138)   (115)
+                          |           |     |     /
+                        ( 99)       ( 97)   |    /
+                          |           |     |   /
+            .12. -(151)- .15. -(80)- .14.   |  /
+             |            |           |     | /
+           ( 71)        (140)       (146)- .2. -(120)
+             |            |                       |
+            .19. -( 75)- . 0.        .10. -(75)- .3.
+                          |            |
+                        (118)        ( 70)
+                          |            |
+                         .16. -(111)- .9.
+         */
+    }
+
+    public static void main(String[] args) {
+        //heuristic function optimistic values
+        int[] heuristic = {366, 0, 160, 242, 161, 178, 77, 151, 226,
+                244, 241, 234, 380, 98, 193, 253, 329, 80, 199, 374};
+
+        Graph graph = new Graph(20);
+        ArrayList<Integer> graphData = new ArrayList<>(Arrays.asList(0, 19, 75, null,
+                0, 15, 140, null, 0, 16, 118, null, 19, 12, 71, null, 12, 15, 151, null,
+                16, 9, 111, null, 9, 10, 70, null, 10, 3, 75, null, 3, 2, 120, null,
+                2, 14, 146, null, 2, 13, 138, null, 2, 6, 115, null, 15, 14, 80, null,
+                15, 5, 99, null, 14, 13, 97, null, 5, 1, 211, null, 13, 1, 101, null,
+                6, 1, 160, null, 1, 17, 85, null, 17, 7, 98, null, 7, 4, 86, null,
+                17, 18, 142, null, 18, 8, 92, null, 8, 11, 87));
+        initializeGraph(graph, graphData);
+
+        PathAndDistance solution = aStar(3, 1, graph, heuristic);
+        solution.printSolution();
+
+    }
+
+    public static PathAndDistance aStar(int from, int to, Graph graph, int[] heuristic) {
+        //nodes are prioritised by the less value of the current distance of their paths, and the estimated value
+        //given by the heuristic function to reach the destination point from the current point.
+        PriorityQueue<PathAndDistance> queue = new PriorityQueue<>
+                (Comparator.comparingInt(a -> (a.getDistance() + a.getEstimated())));
+
+        //dummy data to start the algorithm from the beginning point
+        queue.add(new PathAndDistance(0, new ArrayList<>(Arrays.asList(from)), 0));
+
+        boolean solutionFound = false;
+        PathAndDistance currentData = new PathAndDistance(-1, null, -1);
+        while (!queue.isEmpty() && !solutionFound) {
+            currentData = queue.poll(); //first in the queue, best node so keep exploring.
+            int currentPosition = currentData.getPath().get(currentData.getPath().size() - 1); //current node.
+            if (currentPosition == to)
+                solutionFound = true;
+            else
+                for (Edge edge : graph.getNeighbours(currentPosition))
+                    if (!currentData.getPath().contains(edge.getTo())) { //Avoid Cycles
+                        ArrayList<Integer> updatedPath = new ArrayList<>(currentData.getPath());
+                        updatedPath.add(edge.getTo()); //Add the new node to the path, update the distance,
+                        // and the heuristic function value associated to that path.
+                        queue.add(new PathAndDistance(currentData.getDistance() + edge.getWeight(),
+                                updatedPath, heuristic[edge.getTo()]));
+                    }
+        }
+        return (solutionFound) ? currentData : new PathAndDistance(-1, null, -1);
+        //Out of while loop, if there is a solution, the current Data stores the optimal path, and its distance
+    }
+}

DataStructures/Graphs/BellmanFord.java

@@ -23,7 +23,7 @@ class Edge
         * @param v End vertex
         * @param c Weight
         */
-        Edge(int a,int b,int c)
+        public Edge(int a,int b,int c)
         {
             u=a;
             v=b;