feat: add DDA line drawing algorithm (#6616)

* feat: add DDA line drawing algorithm

* refactor: clang formatting

---------

Co-authored-by: Deniz Altunkapan <deniz.altunkapan@outlook.com>

Author: saahilmahato

src/main/java/com/thealgorithms/geometry/DDALine.java

@@ -0,0 +1,54 @@
+package com.thealgorithms.geometry;
+
+import java.awt.Point;
+import java.util.ArrayList;
+import java.util.List;
+
+/**
+ * The {@code DDALine} class implements the Digital Differential Analyzer (DDA)
+ * line drawing algorithm. It computes points along a line between two given
+ * endpoints using floating-point arithmetic.
+ *
+ * The algorithm is straightforward but less efficient compared to
+ * Bresenham’s line algorithm, since it relies on floating-point operations.
+ *
+ * For more information, please visit {@link https://en.wikipedia.org/wiki/Digital_differential_analyzer_(graphics_algorithm)}
+ */
+public final class DDALine {
+
+    private DDALine() {
+        // Prevent instantiation
+    }
+
+    /**
+     * Finds the list of points forming a line between two endpoints using DDA.
+     *
+     * @param x0 the x-coordinate of the starting point
+     * @param y0 the y-coordinate of the starting point
+     * @param x1 the x-coordinate of the ending point
+     * @param y1 the y-coordinate of the ending point
+     * @return an unmodifiable {@code List<Point>} containing all points on the line
+     */
+    public static List<Point> findLine(int x0, int y0, int x1, int y1) {
+        int dx = x1 - x0;
+        int dy = y1 - y0;
+
+        int steps = Math.max(Math.abs(dx), Math.abs(dy)); // number of steps
+
+        double xIncrement = dx / (double) steps;
+        double yIncrement = dy / (double) steps;
+
+        double x = x0;
+        double y = y0;
+
+        List<Point> line = new ArrayList<>(steps + 1);
+
+        for (int i = 0; i <= steps; i++) {
+            line.add(new Point((int) Math.round(x), (int) Math.round(y)));
+            x += xIncrement;
+            y += yIncrement;
+        }
+
+        return line;
+    }
+}

src/test/java/com/thealgorithms/geometry/DDALineTest.java

@@ -0,0 +1,29 @@
+package com.thealgorithms.geometry;
+
+import java.awt.Point;
+import java.util.List;
+import java.util.stream.Stream;
+import org.junit.jupiter.api.Assertions;
+import org.junit.jupiter.params.ParameterizedTest;
+import org.junit.jupiter.params.provider.Arguments;
+import org.junit.jupiter.params.provider.MethodSource;
+
+/**
+ * The {@code DDALineTest} class contains unit tests for the
+ * {@code DDALine} class, specifically testing the {@code findLine} method.
+ */
+class DDALineTest {
+
+    static Stream<Arguments> linePointsProvider() {
+        return Stream.of(Arguments.of(0, 0, 5, 5, List.of(new Point(0, 0), new Point(1, 1), new Point(2, 2), new Point(3, 3), new Point(4, 4), new Point(5, 5))), Arguments.of(0, 0, 5, 0, List.of(new Point(0, 0), new Point(1, 0), new Point(2, 0), new Point(3, 0), new Point(4, 0), new Point(5, 0))),
+            Arguments.of(0, 0, 0, 5, List.of(new Point(0, 0), new Point(0, 1), new Point(0, 2), new Point(0, 3), new Point(0, 4), new Point(0, 5))), Arguments.of(-2, -2, -5, -5, List.of(new Point(-2, -2), new Point(-3, -3), new Point(-4, -4), new Point(-5, -5))),
+            Arguments.of(1, 1, 1, 1, List.of(new Point(1, 1))), Arguments.of(0, 0, 1, 5, List.of(new Point(0, 0), new Point(0, 1), new Point(0, 2), new Point(1, 3), new Point(1, 4), new Point(1, 5))));
+    }
+
+    @ParameterizedTest
+    @MethodSource("linePointsProvider")
+    void testFindLine(int x0, int y0, int x1, int y1, List<Point> expected) {
+        List<Point> actual = DDALine.findLine(x0, y0, x1, y1);
+        Assertions.assertEquals(expected, actual, "The DDA algorithm should generate the expected ordered points.");
+    }
+}