update fork

README.md

@@ -5,6 +5,11 @@
 
 Algorithms and data structures are amongst the most fundamental ingredients in the recipe for efficient code and good software design; knowledge of how to create and design excellent algorithms is an essential skill required in becoming an exemplary programmer. The goal of this repository is to demonstrate how to correctly implement the most common data structures and algorithms in the simplest and most elegant ways.
 
+# Contributing
+
+This repository is contribution friendly :smiley:. If you're an algorithms enthusiast and want to add or improve an algorithm your contribution is welcome! Please be sure to checkout the [Wiki](https://github.com/williamfiset/Algorithms/wiki) for instructions.
+
+
 # Data Structures
 * [:movie_camera:](https://www.youtube.com/watch?v=q4fnJZr8ztY)[Balanced Trees](https://github.com/williamfiset/algorithms/tree/master/com/williamfiset/algorithms/datastructures/balancedtree)
     * [Avl Tree (recursive)](https://github.com/williamfiset/algorithms/blob/master/com/williamfiset/algorithms/datastructures/balancedtree/AVLTreeRecursive.java)
@@ -76,7 +81,7 @@ Algorithms and data structures are amongst the most fundamental ingredients in t
 * [Convex polygon area](https://github.com/williamfiset/Algorithms/blob/master/com/williamfiset/algorithms/geometry/ConvexPolygonArea.java) **- O(n)**
 * [Convex polygon cut](https://github.com/williamfiset/Algorithms/blob/master/com/williamfiset/algorithms/geometry/ConvexPolygonCutWithLineSegment.java) **- O(n)**
 * [Convex polygon contains points](https://github.com/williamfiset/Algorithms/blob/master/com/williamfiset/algorithms/geometry/ConvexPolygonContainsPoint.java) **- O(log(n))**
-* [Coplanar points test (are four 3D points on the same plane)](https://github.com/williamfiset/Algorithms/blob/master/com/williamfiset/algorithms/geometry/CoplanarPointsTest.java) **- O(1)**
+* [Coplanar points test (are four 3D points on the same plane)](https://github.com/williamfiset/Algorithms/blob/master/com/williamfiset/algorithms/geometry/CoplanarPoints.java) **- O(1)**
 * [Line class (handy infinite line class)](https://github.com/williamfiset/Algorithms/blob/master/com/williamfiset/algorithms/geometry/Line.java) **- O(1)**
 * [Line-circle intersection point(s)](https://github.com/williamfiset/Algorithms/blob/master/com/williamfiset/algorithms/geometry/LineCircleIntersection.js) **- O(1)**
 * [Line segment-circle intersection point(s)](https://github.com/williamfiset/Algorithms/blob/master/com/williamfiset/algorithms/geometry/LineSegmentCircleIntersection.js) **- O(1)**
@@ -203,10 +208,6 @@ Algorithms and data structures are amongst the most fundamental ingredients in t
 * [Rabin-Karp algorithm (finds pattern matches in text)](https://github.com/williamfiset/Algorithms/blob/master/com/williamfiset/algorithms/strings/RabinKarp.java) **- O(n+m)**
 * [Substring verification with suffix array](https://github.com/williamfiset/Algorithms/blob/master/com/williamfiset/algorithms/strings/SubstringVerificationSuffixArray.java) **- O(nlog(n)) SA construction and O(mlog(n)) per query**
 
-# Contributing
-
-This repository is contribution friendly :smiley:. If you're an algorithms enthusiast and want to add or improve an algorithm your contribution is welcome! Please be sure to checkout the [Wiki](https://github.com/williamfiset/Algorithms/wiki) for instructions.
-
 # License
 
 This repository is released under the [MIT license](https://opensource.org/licenses/MIT). In short, this means you are free to use this software in any personal, open-source or commercial projects. Attribution is optional but appreciated.

com/williamfiset/algorithms/datastructures/linkedlist/DoublyLinkedList.java

@@ -6,15 +6,14 @@
 package com.williamfiset.algorithms.datastructures.linkedlist;
 
 public class DoublyLinkedList<T> implements Iterable<T> {
-
   private int size = 0;
   private Node<T> head = null;
   private Node<T> tail = null;
 
   // Internal node class to represent data
-  private class Node<T> {
-    T data;
-    Node<T> prev, next;
+  private static class Node<T> {
+    private T data;
+    private Node<T> prev, next;
 
     public Node(T data, Node<T> prev, Node<T> next) {
       this.data = data;
@@ -58,8 +57,6 @@ public void add(T elem) {
 
   // Add a node to the tail of the linked list, O(1)
   public void addLast(T elem) {
-
-    // The linked list is empty
     if (isEmpty()) {
       head = tail = new Node<T>(elem, null, null);
     } else {
@@ -71,15 +68,12 @@ public void addLast(T elem) {
 
   // Add an element to the beginning of this linked list, O(1)
   public void addFirst(T elem) {
-
-    // The linked list is empty
     if (isEmpty()) {
       head = tail = new Node<T>(elem, null, null);
     } else {
       head.prev = new Node<T>(elem, null, head);
       head = head.prev;
     }
-
     size++;
   }
 
@@ -97,8 +91,7 @@ public T peekLast() {
 
   // Remove the first value at the head of the linked list, O(1)
   public T removeFirst() {
-
-    // Can't remove data from an empty list -_-
+    // Can't remove data from an empty list
     if (isEmpty()) throw new RuntimeException("Empty list");
 
     // Extract the data at the head and move
@@ -119,8 +112,7 @@ public T removeFirst() {
 
   // Remove the last value at the tail of the linked list, O(1)
   public T removeLast() {
-
-    // Can't remove data from an empty list -_-
+    // Can't remove data from an empty list
     if (isEmpty()) throw new RuntimeException("Empty list");
 
     // Extract the data at the tail and move
@@ -141,7 +133,6 @@ public T removeLast() {
 
   // Remove an arbitrary node from the linked list, O(1)
   private T remove(Node<T> node) {
-
     // If the node to remove is somewhere either at the
     // head or the tail handle those independently
     if (node.prev == null) return removeFirst();
@@ -166,26 +157,30 @@ private T remove(Node<T> node) {
 
   // Remove a node at a particular index, O(n)
   public T removeAt(int index) {
-
-    // Make sure the index provided is valid -_-
-    if (index < 0 || index >= size) throw new IllegalArgumentException();
+    // Make sure the index provided is valid
+    if (index < 0 || index >= size) {
+      throw new IllegalArgumentException();
+    }
 
     int i;
     Node<T> trav;
 
     // Search from the front of the list
     if (index < size / 2) {
-      for (i = 0, trav = head; i != index; i++) trav = trav.next;
-
+      for (i = 0, trav = head; i != index; i++) {
+        trav = trav.next;
+      }
       // Search from the back of the list
-    } else for (i = size - 1, trav = tail; i != index; i--) trav = trav.prev;
+    } else
+      for (i = size - 1, trav = tail; i != index; i--) {
+        trav = trav.prev;
+      }
 
     return remove(trav);
   }
 
   // Remove a particular value in the linked list, O(n)
   public boolean remove(Object obj) {
-
     Node<T> trav = head;
 
     // Support searching for null
@@ -210,16 +205,23 @@ public boolean remove(Object obj) {
 
   // Find the index of a particular value in the linked list, O(n)
   public int indexOf(Object obj) {
-
     int index = 0;
     Node<T> trav = head;
 
     // Support searching for null
     if (obj == null) {
-      for (; trav != null; trav = trav.next, index++) if (trav.data == null) return index;
-
+      for (; trav != null; trav = trav.next, index++) {
+        if (trav.data == null) {
+          return index;
+        }
+      }
       // Search for non null object
-    } else for (; trav != null; trav = trav.next, index++) if (obj.equals(trav.data)) return index;
+    } else
+      for (; trav != null; trav = trav.next, index++) {
+        if (obj.equals(trav.data)) {
+          return index;
+        }
+      }
 
     return -1;
   }

com/williamfiset/algorithms/dp/EditDistance.java

@@ -11,7 +11,7 @@ public class EditDistance {
 
   // Computes the cost to convert a string 'a' into a string 'b' using dynamic
   // programming given the insertionCost, deletionCost and substitutionCost, O(nm)
-  static int editDistance(
+  public static int editDistance(
       String a, String b, int insertionCost, int deletionCost, int substitutionCost) {
 
     final int AL = a.length(), BL = b.length();

com/williamfiset/algorithms/geometry/AngleBetweenVectors2D.java

@@ -12,7 +12,7 @@
 public class AngleBetweenVectors2D {
 
   // Return the smaller of the two angles between two 2D vectors in radians
-  static double angleBetweenVectors(double v1x, double v1y, double v2x, double v2y) {
+  public static double angleBetweenVectors(double v1x, double v1y, double v2x, double v2y) {
 
     // To determine the angle between two vectors v1 and v2 we can use
     // the following formula: dot(v1,v2) = len(v1)*len(v2)*cosθ and solve

com/williamfiset/algorithms/geometry/AngleBetweenVectors3D.java

@@ -12,7 +12,7 @@
 public class AngleBetweenVectors3D {
 
   // Return the smaller of the two angles between two 3D vectors in radians
-  static double angleBetweenVectors(
+  public static double angleBetweenVectors(
       double v1x, double v1y, double v1z, double v2x, double v2y, double v2z) {
     // To determine the angle between two vectors v1 and v2 we can use
     // the following formula: dot(v1,v2) = len(v1)*len(v2)*cosθ and solve

com/williamfiset/algorithms/geometry/CircleCircleIntersectionArea.java

@@ -20,7 +20,7 @@ public class CircleCircleIntersectionArea {
   // Due to double rounding precision the value passed into the acos
   // function may be outside its domain of [-1, +1] which would return
   // the value Double.NaN which we do not want.
-  static double arccosSafe(double x) {
+  private static double arccosSafe(double x) {
     if (x >= +1.0) return 0;
     if (x <= -1.0) return PI;
     return acos(x);
@@ -142,7 +142,7 @@ public static Point2D[] circleCircleIntersection(Point2D c1, double r1, Point2D
   // Rotate point 'pt' a certain number of radians clockwise
   // relative to some fixed point 'fp'. Note that the angle
   // should be specified in radians, not degrees.
-  public static Point2D rotatePoint(Point2D fp, Point2D pt, double angle) {
+  private static Point2D rotatePoint(Point2D fp, Point2D pt, double angle) {
 
     double fpx = fp.getX();
     double fpy = fp.getY();

com/williamfiset/algorithms/geometry/CircularSegmentArea.java

@@ -70,7 +70,7 @@ public static double triangleArea(
   }
 
   // Return the smaller of the two angles between two 2D vectors in radians
-  static double angleBetweenVectors(double v1x, double v1y, double v2x, double v2y) {
+  private static double angleBetweenVectors(double v1x, double v1y, double v2x, double v2y) {
 
     // To determine the angle between two vectors v1 and v2 we can use
     // the following formula: dot(v1,v2) = len(v1)*len(v2)*cosθ and solve

com/williamfiset/algorithms/geometry/ClosestPairOfPoints.java

@@ -11,24 +11,23 @@
 
 import java.util.*;
 
-// Custom point class
-class PT {
-  double x, y;
+public class ClosestPairOfPoints {
 
-  public PT(double xx, double yy) {
-    x = xx;
-    y = yy;
-  }
+  private static final double EPS = 1e-9;
 
-  public double dist(PT pt) {
-    double dx = x - pt.x, dy = y - pt.y;
-    return sqrt(dx * dx + dy * dy);
-  }
-}
+  public class PT {
+    double x, y;
 
-public class ClosestPairOfPoints {
+    public PT(double xx, double yy) {
+      x = xx;
+      y = yy;
+    }
 
-  static final double EPS = 1e-9;
+    public double dist(PT pt) {
+      double dx = x - pt.x, dy = y - pt.y;
+      return sqrt(dx * dx + dy * dy);
+    }
+  }
 
   // Sorts points by X coordinate
   private static class X_Sort implements Comparator<PT> {

com/williamfiset/algorithms/geometry/ConvexHullGrahamScan.java

@@ -13,7 +13,7 @@
 public class ConvexHullGrahamScan {
 
   // Construct a convex hull and return it as a stack of points
-  static Stack<Point2D> createConvexHull(Point2D[] pts) {
+  public static Stack<Point2D> createConvexHull(Point2D[] pts) {
     int k1, k2, N = pts.length;
     Stack<Point2D> hull = new Stack<Point2D>();
     Arrays.sort(pts, new PointOrder());
@@ -43,7 +43,7 @@ static Stack<Point2D> createConvexHull(Point2D[] pts) {
   }
 
   // Compare other points relative to polar angle (between 0 and 2*PI) they make with this point
-  static class PolarOrder implements Comparator<Point2D> {
+  private static class PolarOrder implements Comparator<Point2D> {
     Point2D pt;
 
     public PolarOrder(Point2D pt) {
@@ -65,7 +65,7 @@ else if (dy1 == 0 && dy2 == 0) {
   }
 
   // Put lower Y co-ordinates first, with a lower X value in the case of ties
-  static class PointOrder implements Comparator<Point2D> {
+  private static class PointOrder implements Comparator<Point2D> {
     @Override
     public int compare(Point2D q1, Point2D q2) {
       if (q1.getY() < q2.getY()) return -1;
@@ -80,7 +80,7 @@ public int compare(Point2D q1, Point2D q2) {
 
   // Check to see whether the points are ordered clockwise or counter-clockwise (0 indicates that
   // they are collinear)
-  static int collinear(Point2D a, Point2D b, Point2D c) {
+  private static int collinear(Point2D a, Point2D b, Point2D c) {
     double area =
         (b.getX() - a.getX()) * (c.getY() - a.getY())
             - (b.getY() - a.getY()) * (c.getX() - a.getX());

com/williamfiset/algorithms/geometry/ConvexPolygonContainsPoint.java

@@ -52,7 +52,7 @@ public static boolean containsPoint(Point2D[] hull, Point2D p) {
   // it is on the line, -1 if c is to the right of the line and +1 if it's
   // to the left from the frame of reference of standing at point a
   // and facing point b.
-  public static int collinear(Point2D a, Point2D b, Point2D c) {
+  private static int collinear(Point2D a, Point2D b, Point2D c) {
     double ax = a.getX(), ay = a.getY();
     double bx = b.getX(), by = b.getY();
     double cx = c.getX(), cy = c.getY();

com/williamfiset/algorithms/geometry/ConvexPolygonCutWithLineSegment.java

@@ -14,7 +14,7 @@ public class ConvexPolygonCutWithLineSegment {
   private static final double EPS = 1e-9;
 
   // Simple 2D point class.
-  static class Pt {
+  public static class Pt {
     double x, y;
 
     public Pt(double x, double y) {
@@ -31,7 +31,7 @@ public String toString() {
   // Cuts a convex polygon by a specified line and returns one part
   // of the polygon (swapping the endpoints p1 and p2 of the line
   // will return the other part of the polygon).
-  static Pt[] cut(Pt[] poly, Pt p1, Pt p2) {
+  public static Pt[] cut(Pt[] poly, Pt p1, Pt p2) {
     int n = poly.length;
     List<Pt> res = new ArrayList<>();
     for (int i = 0, j = n - 1; i < n; j = i++) {
@@ -44,7 +44,7 @@ static Pt[] cut(Pt[] poly, Pt p1, Pt p2) {
     return res.toArray(new Pt[res.size()]);
   }
 
-  static Pt intersect(
+  private static Pt intersect(
       double x1, double y1, double x2, double y2, double x3, double y3, double x4, double y4) {
     double a1 = y2 - y1, a2 = y4 - y3, b1 = x1 - x2, b2 = x3 - x4;
     double c1 = -(x1 * y2 - x2 * y1), c2 = -(x3 * y4 - x4 * y3);
@@ -53,7 +53,7 @@ static Pt intersect(
     return new Pt(x, y);
   }
 
-  static int orientation(double ax, double ay, double bx, double by, double cx, double cy) {
+  private static int orientation(double ax, double ay, double bx, double by, double cx, double cy) {
     bx -= ax;
     by -= ay;
     cx -= ax;

com/williamfiset/algorithms/geometry/CoplanarPointsTest.java → com/williamfiset/algorithms/geometry/CoplanarPoints.java

@@ -9,12 +9,12 @@
 
 import static java.lang.Math.*;
 
-public class CoplanarPointsTest {
+public class CoplanarPoints {
 
   private static final double EPS = 1e-7;
 
   // A simple 3D vector class
-  static class Vector {
+  public static class Vector {
     double x, y, z;
 
     public Vector(double xx, double yy, double zz) {
@@ -24,19 +24,6 @@ public Vector(double xx, double yy, double zz) {
     }
   }
 
-  // Cross product of two vectors
-  static Vector cross(Vector v1, Vector v2) {
-    double v3x = v1.y * v2.z - v1.z * v2.y;
-    double v3y = v1.z * v2.x - v1.x * v2.z;
-    double v3z = v1.x * v2.y - v1.y * v2.x;
-    return new Vector(v3x, v3y, v3z);
-  }
-
-  // 3D vector dot product
-  static double dot(Vector v1, Vector v2) {
-    return (v1.x * v2.x) + (v1.y * v2.y) + (v1.z * v2.z);
-  }
-
   // Determine is four points (ax,ay,az), (bx,by,bz), (cx,cy,cz),
   // (dx,dy,dz) all lie in the same plane in 3D space
   public static boolean coplanar(
@@ -75,6 +62,19 @@ public static boolean coplanar(
     return abs(dot(v3, v4)) < EPS;
   }
 
+  // Cross product of two vectors
+  private static Vector cross(Vector v1, Vector v2) {
+    double v3x = v1.y * v2.z - v1.z * v2.y;
+    double v3y = v1.z * v2.x - v1.x * v2.z;
+    double v3z = v1.x * v2.y - v1.y * v2.x;
+    return new Vector(v3x, v3y, v3z);
+  }
+
+  // 3D vector dot product
+  private static double dot(Vector v1, Vector v2) {
+    return (v1.x * v2.x) + (v1.y * v2.y) + (v1.z * v2.z);
+  }
+
   // Examples
   public static void main(String[] args) {