Add project files.

+ Sorting algorithms:
- insertion sort
- selection sort
- bubble sort
- quick sort

+ Searching algorithms:
- linear search
- binary search

+ Java linked list class

Author: gperretta

datastructures/.vscode/settings.json

@@ -0,0 +1,7 @@
+{
+    "java.project.sourcePaths": ["src"],
+    "java.project.outputPath": "bin",
+    "java.project.referencedLibraries": [
+        "lib/**/*.jar"
+    ]
+}

datastructures/src/LinkedListApp.java

@@ -0,0 +1,36 @@
+import java.util.LinkedList;
+
+public class LinkedListApp {
+    public static void main(String[] args) {
+
+        LinkedList<String> linkedList = new LinkedList<String>();
+
+        // Adding elements to the linked list
+        linkedList.add("A");
+        linkedList.add("B");
+        linkedList.addLast("C");
+        linkedList.addFirst("D");
+        linkedList.add(2, "E");
+
+        System.out.println(linkedList);
+        System.out.println("\n");
+
+        // Changing one element of the linked list
+        linkedList.set(0, "Z");
+
+        // Using get methods and loops
+        for (int i = 0; i < linkedList.size(); i++) {
+
+            System.out.print(linkedList.get(i) + " ");
+        }
+        System.out.println("\n");
+
+        // Removing elements from the linked list
+        linkedList.remove("B");
+        linkedList.remove(3);
+        linkedList.removeFirst();
+        linkedList.removeLast();
+
+        System.out.println(linkedList);
+    }
+}

searchalgorithms/.vscode/launch.json

@@ -0,0 +1,21 @@
+{
+    // Use IntelliSense to learn about possible attributes.
+    // Hover to view descriptions of existing attributes.
+    // For more information, visit: https://go.microsoft.com/fwlink/?linkid=830387
+    "version": "0.2.0",
+    "configurations": [
+        {
+            "type": "java",
+            "name": "Current File",
+            "request": "launch",
+            "mainClass": "${file}"
+        },
+        {
+            "type": "java",
+            "name": "BinarySearch",
+            "request": "launch",
+            "mainClass": "BinarySearch",
+            "projectName": "searchalghoritms_26a79ed7"
+        }
+    ]
+}

searchalgorithms/.vscode/settings.json

@@ -0,0 +1,7 @@
+{
+    "java.project.sourcePaths": ["src"],
+    "java.project.outputPath": "bin",
+    "java.project.referencedLibraries": [
+        "lib/**/*.jar"
+    ]
+}

searchalgorithms/src/BinarySearch.java

@@ -0,0 +1,102 @@
+import java.util.Scanner;
+
+/*
+Binary Search is defined as a searching algorithm used in a sorted array; 
+it works by repeatedly dividing the search interval in half. 
+The idea of binary search is to use the information that the array is sorted 
+and reduce the time complexity to O(logN). 
+*/
+
+public class BinarySearch {
+
+    /**
+     * "Binary Search" function - Recursive variant
+     *
+     * @param sortedArray - array of int values, sorted - type: int
+     * @param firstIndex  - first index of the array - type: int
+     * @param lastIndex   - last index of the array - type: int
+     * @param item        - item to be found - type: int
+     * @return item index, if found, else (-1) - type: int
+     **/
+    public int recursiveBinarySearch(int[] sortedArray, int firstIndex, int lastIndex, int item) {
+
+        // If the item is not found in the array, throws an exception
+        if (firstIndex >= lastIndex)
+            return -1;
+        else {
+
+            // Finding the middle element index in the array
+            // to eventually split the sorted array in n sub-arrays
+            int middle = (firstIndex + lastIndex) / 2;
+
+            // Check if the searched item is in the middle of the array
+            if (sortedArray[middle] == item)
+                return middle;
+            // If the middle element of the array is smaller than the searched item
+            // then search again in the sub-array starting from middle+1 index
+            else if (sortedArray[middle] < item)
+                return recursiveBinarySearch(sortedArray, middle + 1, lastIndex, item);
+            // If the middle element of the array is bigger than the searched item
+            // then search again in the sub-array ending to middle index
+            return recursiveBinarySearch(sortedArray, firstIndex, middle - 1, item);
+        }
+    }
+
+    /**
+     * "Binary Search" function - Iterative variant
+     *
+     * @param sortedArray - array of int values, sorted - type: int
+     * @param item        - item to be found - type: int
+     * @return item index, if found, else (-1) - type: int
+     **/
+    public int iterativeBinarySearch(int[] sortedArray, int item) {
+
+        // Define the first and last index of the sorted array
+        int firstIndex = 0;
+        int lastIndex = sortedArray.length - 1;
+        // Define the middle index of the sorted array
+        int middle = (firstIndex + lastIndex) / 2;
+
+        while (firstIndex < lastIndex) {
+
+            // Check if the searched item is in the middle of the array
+            if (sortedArray[middle] == item)
+                return middle;
+            // If the middle element of the array is smaller than the searched item
+            // then ignore the first half of the array
+            if (sortedArray[middle] < item)
+                firstIndex = middle + 1;
+            // If the middle element of the array is bigger than the searched item
+            // then ignore the first half of the array
+            if (sortedArray[middle] > item)
+                lastIndex = middle - 1;
+        }
+
+        return -1;
+    }
+
+    // Driver for testing
+    /**
+     * @param args
+     */
+    public static void main(String args[]) {
+        BinarySearch testObjBinarySearch = new BinarySearch();
+        // Sorted array example
+        int vector[] = { 1, 4, 11, 18, 23, 44 };
+        int size = vector.length;
+
+        try (Scanner scanObj = new Scanner(System.in)) {
+            // Read user input
+            System.out.println("Insert an int value to search: ");
+            int key = scanObj.nextInt();
+
+            int result = testObjBinarySearch.recursiveBinarySearch(vector, 0, size, key);
+
+            if (result == -1)
+                System.out.println("Element not found in array!");
+            else
+                System.out.println("Element found at index: " + result);
+        }
+    }
+
+}

searchalgorithms/src/LinearSearch.java

@@ -0,0 +1,78 @@
+import java.util.Scanner;
+
+/*
+ A Linear Search is defined as searching algorithm for finding an element within a list; 
+ it works by sequentially checking each element of the list until a match is found 
+ or the whole list has been searched, with a time complexity of O(N).
+*/
+
+public class LinearSearch {
+
+    /**
+     * "Linear Search" - Recursive variant
+     * 
+     * @param array - list to be searched within - type: int
+     * @param size  - array lenght - type: int
+     * @param item  - item to be found - type: int
+     * @return item index, if found, else (-1) - type: int
+     */
+    int recursiveLinearSearch(int array[], int size, int item) {
+        // If the element was not found in the whole array
+        // then return -1
+        if (size == 0) {
+            return -1;
+        } else if (array[size - 1] == item) {
+            // else return the index of the found item
+            return size - 1;
+        } else {
+            // Recursion
+            return recursiveLinearSearch(array, size - 1, item);
+        }
+    }
+
+    /**
+     * "Linear Search" - Iterative variant
+     * 
+     * @param array - list to be searched within - type: int
+     * @param item  - item to be found - type: int
+     * @return item index, if found, else (-1) - type: int
+     */
+    int iterativeLinearSearch(int array[], int item) {
+
+        int size = array.length;
+        // Loop on the array
+        for (int i = 0; i < size; i++) {
+            // If the item was found, then return its index
+            if (array[i] == item)
+                return i;
+        }
+        // else return -1
+        return -1;
+    }
+
+    // Driver for testing
+    /**
+     * @param args
+     */
+    public static void main(String[] args) {
+        LinearSearch testObjLinearSearch = new LinearSearch();
+        // Sorted array example
+        int vector[] = { 15, 5, 19, 27, 3 };
+        int size = vector.length;
+
+        try (Scanner scanObj = new Scanner(System.in)) {
+            // Read user input
+            System.out.println("Insert an int value to search: ");
+            int key = scanObj.nextInt();
+
+            int result = testObjLinearSearch.recursiveLinearSearch(vector, size, key);
+            // int result = testObjLinearSearch.iterativeLinearSearch(vector, key);
+
+            if (result == -1)
+                System.out.println("Element not found in array!");
+            else
+                System.out.println("Element found at index: " + result);
+        }
+    }
+
+}

sortingalgorithms/.vscode/settings.json

@@ -0,0 +1,7 @@
+{
+    "java.project.sourcePaths": ["src"],
+    "java.project.outputPath": "bin",
+    "java.project.referencedLibraries": [
+        "lib/**/*.jar"
+    ]
+}

sortingalgorithms/src/BubbleSort.java

@@ -0,0 +1,57 @@
+/*
+Bubble Sort is a simple sorting algorithm that works by repeatedly stepping through the list, 
+comparing each pair of adjacent elements and swapping them if they are in the wrong order.
+*/
+
+public class BubbleSort {
+
+    /**
+     * "Bubble Sort" function
+     * 
+     * @param array - array to be sorted - type: int
+     */
+    void bubbleSort(int array[]) {
+
+        int size = array.length;
+        int temp;
+
+        for (int i = 0; i < size - 1; i++) {
+            for (int j = 0; j < size - i - 1; j++) {
+                // If two consecutive elements are not sorted
+                if (array[j] > array[j + 1]) {
+                    // then swap the two of them
+                    // by using a temp variable
+                    temp = array[j];
+                    array[j] = array[j + 1];
+                    array[j + 1] = temp;
+                }
+            }
+        }
+    }
+
+    // Utility function
+    void printArray(int array[]) {
+
+        for (int i = 0; i < array.length; i++)
+            System.out.print(array[i] + " ");
+        System.out.println("\n");
+    }
+
+    // Driver for testing
+    /**
+     * @param args
+     */
+    public static void main(String args[]) {
+
+        BubbleSort testObjBubbleSort = new BubbleSort();
+
+        int vector[] = { 64, 34, 25, 12, 22, 11, 90 };
+
+        System.out.println("Original array: ");
+        testObjBubbleSort.printArray(vector);
+        System.out.println("Sorting array...\n");
+        testObjBubbleSort.bubbleSort(vector);
+        System.out.println("Array sorted: ");
+        testObjBubbleSort.printArray(vector);
+    }
+}

sortingalgorithms/src/InsertionSort.java

@@ -0,0 +1,57 @@
+/*
+Insertion Sort is a simple sorting algorithm that works by repeatedly comparing pair
+of elements and virtually splitting the array in a sorted sub-array and ad unsorted one.
+It is appropriate for data sets which are already partially sorted.
+*/
+
+public class InsertionSort {
+
+    /**
+     * "Insertion Sort" function
+     * 
+     * @param array - array to be sorted - type: int
+     */
+    public void insertionSort(int array[]) {
+
+        int size = array.length;
+
+        for (int i = 0; i < size; i++) {
+            // Define a temp variable
+            int temp = array[i];
+            int j = i - 1;
+            // Move elements that are bigger than temp
+            // one position ahead of their current one
+            while (j >= 0 && array[j] > temp) {
+                array[j + 1] = array[j];
+                j = j - 1;
+            }
+            array[j + 1] = temp;
+        }
+    }
+
+    // Utility function
+    void printArray(int array[]) {
+
+        for (int i = 0; i < array.length; i++)
+            System.out.print(array[i] + " ");
+        System.out.println("\n");
+    }
+
+    // Driver for testing
+    /**
+     * @param args
+     */
+    public static void main(String args[]) {
+
+        InsertionSort testObjInsertionSort = new InsertionSort();
+
+        int vector[] = { 10, 7, 8, 9, 1, 23, 11 };
+
+        System.out.println("Original array: ");
+        testObjInsertionSort.printArray(vector);
+        System.out.println("Sorting array...\n");
+        testObjInsertionSort.insertionSort(vector);
+        System.out.println("Array sorted: ");
+        testObjInsertionSort.printArray(vector);
+    }
+}