Lesson 2 and minor renaming of some classes from lesson 1

Author: cutajarj

src/main/java/com/packt/datastructuresandalg/lesson1/activity/improveintersection/solution/FastIntersection.java

@@ -0,0 +1,25 @@
+package com.packt.datastructuresandalg.lesson1.activity.improveintersection.solution;
+
+import com.packt.datastructuresandalg.lesson1.binarysearch.BinarySearch;
+
+import java.util.Arrays;
+import java.util.LinkedList;
+import java.util.List;
+
+public class FastInterstectionSol1 {
+
+    private BinarySearch search = new BinarySearch();
+
+    public List<Integer> intersectionFast(int[] a, int[] b) {
+        List<Integer> result = new LinkedList<>();
+        mergeSort(b);
+        for (int x : a) {
+            if (search.binarySearch(x, b)) result.add(x);
+        }
+        return result;
+    }
+
+    private void mergeSort(int[] input) {
+        Arrays.sort(input);
+    }
+}

src/main/java/com/packt/datastructuresandalg/lesson1/activity/improveintersection/solution/FastInterstectionSol1.java

@@ -0,0 +1,28 @@
+package com.packt.datastructuresandalg.lesson1.activity.improveintersection.solution;
+
+import java.util.Arrays;
+import java.util.LinkedList;
+import java.util.List;
+
+public class FastInterstectionSol2 {
+
+    public List<Integer> intersectionFast(int[] a, int[] b) {
+        List<Integer> result = new LinkedList<>();
+        mergeSort(a);
+        mergeSort(b);
+        int ptrA = 0, ptrB = 0;
+        while (ptrA < a.length && ptrB < b.length) {
+            if (a[ptrA] == b[ptrB]) {
+                result.add(a[ptrA]);
+                ptrA++;
+                ptrB++;
+            } else if (a[ptrA] > b[ptrB]) ptrB++;
+            else ptrA++;
+        }
+        return result;
+    }
+
+    public void mergeSort(int[] input) {
+        Arrays.sort(input);
+    }
+}

src/main/java/com/packt/datastructuresandalg/lesson1/activity/improveintersection/solution/FastInterstectionSol2.java

@@ -0,0 +1,16 @@
+package com.packt.datastructuresandalg.lesson2.activity.mergesort;
+
+public class MergeSort {
+
+    private void merge(int[] array, int start, int middle, int end) {
+
+    }
+
+    private void mergeSort(int[] array, int start, int end) {
+
+    }
+
+    public void mergeSort(int[] array) {
+
+    }
+}

src/main/java/com/packt/datastructuresandalg/lesson2/activity/mergesort/MergeSort.java

@@ -0,0 +1,33 @@
+package com.packt.datastructuresandalg.lesson2.activity.mergesort.solution;
+
+public class MergeSort {
+
+    private void merge(int[] array, int start, int middle, int end) {
+        int i = start;
+        int j = middle + 1;
+        int[] arrayTemp = new int[end - start + 1];
+        for (int k = 0; k < arrayTemp.length; k++) {
+            if (i <= middle && (j > end || array[i] <= array[j])) {
+                arrayTemp[k] = array[i];
+                i++;
+            } else {
+                arrayTemp[k] = array[j];
+                j++;
+            }
+        }
+        System.arraycopy(arrayTemp, 0, array, start, arrayTemp.length);
+    }
+
+    private void mergeSort(int[] array, int start, int end) {
+        if (start < end) {
+            int middle = (end - start) / 2 + start;
+            mergeSort(array, start, middle);
+            mergeSort(array, middle + 1, end);
+            merge(array, start, middle, end);
+        }
+    }
+
+    public void mergeSort(int[] array) {
+        mergeSort(array, 0, array.length - 1);
+    }
+}

src/main/java/com/packt/datastructuresandalg/lesson2/activity/mergesort/solution/MergeSort.java

@@ -0,0 +1,8 @@
+package com.packt.datastructuresandalg.lesson2.activity.selectionsort;
+
+public class SelectionSort {
+
+    public void sort(int[] array) {
+
+    }
+}

src/main/java/com/packt/datastructuresandalg/lesson2/activity/selectionsort/SelectionSort.java

@@ -0,0 +1,19 @@
+package com.packt.datastructuresandalg.lesson2.activity.selectionsort.solution;
+
+public class SelectionSort {
+    public void sort(int[] array) {
+        for (int i = 0; i < array.length - 1; i++) {
+            int minPtr = i;
+            for (int j = i; j < array.length; j++) {
+                if (array[j] < array[minPtr]) minPtr = j;
+            }
+            swap(array, minPtr, i);
+        }
+    }
+
+    private void swap(int[] numbers, int j, int k) {
+        int temp = numbers[j];
+        numbers[j] = numbers[k];
+        numbers[k] = temp;
+    }
+}

src/main/java/com/packt/datastructuresandalg/lesson2/activity/selectionsort/solution/SelectionSort.java

@@ -0,0 +1,35 @@
+package com.packt.datastructuresandalg.lesson2.linkedlist;
+
+import java.util.Optional;
+
+public class DblLinkedListNode<V> {
+    private V value;
+    private Optional<DblLinkedListNode<V>> next;
+    private Optional<DblLinkedListNode<V>> previous;
+
+    public DblLinkedListNode(V value,
+                             Optional<DblLinkedListNode<V>> next,
+                             Optional<DblLinkedListNode<V>> previous) {
+        this.value = value;
+        this.next = next;
+        this.previous = previous;
+    }
+
+    public V getValue() {
+        return value;
+    }
+
+    public DblLinkedListNode setValue(V value) {
+        this.value = value;
+        return this;
+    }
+
+    public Optional<DblLinkedListNode<V>> getNext() {
+        return next;
+    }
+
+    public DblLinkedListNode setNext(Optional<DblLinkedListNode<V>> next) {
+        this.next = next;
+        return this;
+    }
+}

src/main/java/com/packt/datastructuresandalg/lesson2/linkedlist/DblLinkedListNode.java

@@ -0,0 +1,10 @@
+package com.packt.datastructuresandalg.lesson2.linkedlist;
+
+import java.util.Optional;
+
+public class LinkedList {
+
+    public static void main(String[] args) {
+        LinkedListNode<Integer> x = new LinkedListNode<>(5, Optional.empty());
+    }
+}

src/main/java/com/packt/datastructuresandalg/lesson2/linkedlist/LinkedList.java

@@ -0,0 +1,31 @@
+package com.packt.datastructuresandalg.lesson2.linkedlist;
+
+import java.util.Optional;
+
+public class LinkedListNode<V> {
+    private V value;
+    private Optional<LinkedListNode<V>> next;
+
+    public LinkedListNode(V value, Optional<LinkedListNode<V>> next) {
+        this.value = value;
+        this.next = next;
+    }
+
+    public V getValue() {
+        return value;
+    }
+
+    public LinkedListNode setValue(V value) {
+        this.value = value;
+        return this;
+    }
+
+    public Optional<LinkedListNode<V>> getNext() {
+        return next;
+    }
+
+    public LinkedListNode setNext(Optional<LinkedListNode<V>> next) {
+        this.next = next;
+        return this;
+    }
+}

src/main/java/com/packt/datastructuresandalg/lesson2/linkedlist/LinkedListNode.java

@@ -0,0 +1,25 @@
+package com.packt.datastructuresandalg.lesson2.sorting;
+
+
+public class BinarySearchRecursive {
+    public boolean binarySearch(int x, int[] sortedNumbers) {
+        return binarySearch(x, sortedNumbers, 0, sortedNumbers.length);
+    }
+
+    public boolean binarySearch(int x, int[] sortedNumbers, int start, int end) {
+        if (start <= end) {
+            int mid = (end - start) / 2 + start;
+            if (sortedNumbers[mid] == x) return true;
+            if (sortedNumbers[mid] > x) return binarySearch(x, sortedNumbers, start, mid - 1);
+            return binarySearch(x, sortedNumbers, mid + 1, end);
+        }
+        return false;
+    }
+
+    public static void main(String args[]) {
+        BinarySearchRecursive binarySearch = new BinarySearchRecursive();
+        System.out.println(binarySearch.binarySearch(7, new int[]{1, 2, 3, 4, 5, 6, 7, 8, 9, 10}));
+        System.out.println(binarySearch.binarySearch(0, new int[]{1, 2, 3, 4, 5, 6, 7, 8, 9, 10}));
+    }
+
+}

src/main/java/com/packt/datastructuresandalg/lesson2/sorting/BinarySearchRecursive.java

@@ -0,0 +1,62 @@
+package com.packt.datastructuresandalg.lesson2.sorting;
+
+import java.util.Arrays;
+
+public class BobbleSort {
+
+    public void sort(int[] numbers) {
+        for (int i = 1; i < numbers.length; i++) {
+            for (int j = 0; j < numbers.length - 1; j++) {
+                if (numbers[j] > numbers[j + 1]) {
+                    int temp = numbers[j];
+                    numbers[j] = numbers[j + 1];
+                    numbers[j + 1] = temp;
+                }
+            }
+        }
+    }
+
+    public void sortImprovement1(int[] numbers) {
+        for (int i = 1; i < numbers.length; i++) {
+            for (int j = 0; j < numbers.length - i; j++) {
+                if (numbers[j] > numbers[j + 1]) {
+                    swap(numbers, j, j + 1);
+                }
+            }
+        }
+    }
+
+    public void sortImprovement2(int[] numbers) {
+        int i = 0;
+        boolean swapOccured = true;
+        while (swapOccured) {
+            swapOccured = false;
+            i++;
+            for (int j = 0; j < numbers.length - i; j++) {
+                if (numbers[j] > numbers[j + 1]) {
+                    swap(numbers, j, j + 1);
+                    swapOccured = true;
+                }
+            }
+        }
+    }
+
+    private void swap(int[] numbers, int j, int k) {
+        int temp = numbers[j];
+        numbers[j] = numbers[k];
+        numbers[k] = temp;
+    }
+
+    public static void main(String[] args) {
+        BobbleSort bubbleSort = new BobbleSort();
+        int[] numbers = new int[]{2, 5, 7, 2, 4, 2, 8, 1, 0};
+        int[] numbers1 = new int[]{2, 5, 7, 2, 4, 2, 8, 1, 0};
+        int[] numbers2 = new int[]{2, 5, 7, 2, 4, 2, 8, 1, 0};
+        bubbleSort.sort(numbers);
+        bubbleSort.sortImprovement1(numbers1);
+        bubbleSort.sortImprovement2(numbers2);
+        System.out.println(Arrays.toString(numbers));
+        System.out.println(Arrays.toString(numbers1));
+        System.out.println(Arrays.toString(numbers2));
+    }
+}

src/main/java/com/packt/datastructuresandalg/lesson2/sorting/BobbleSort.java

@@ -0,0 +1,45 @@
+package com.packt.datastructuresandalg.lesson2.sorting;
+
+import java.util.Arrays;
+
+public class QuickSort {
+    public void sort(int[] numbers) {
+        sort(numbers, 0, numbers.length - 1);
+    }
+
+    private void sort(int[] numbers, int start, int end) {
+        if (start < end) {
+            int p = partition(numbers, start, end);
+            sort(numbers, start, p - 1);
+            sort(numbers, p + 1, end);
+        }
+    }
+
+    private int partition(int[] numbers, int start, int end) {
+        int pivot = numbers[end];
+        int x = start - 1;
+        for (int i = start; i < end; i++) {
+            if (numbers[i] < pivot) {
+                x++;
+                swap(numbers, x, i);
+            }
+        }
+        swap(numbers, x + 1, end);
+        return x + 1;
+    }
+
+    private void swap(int[] numbers, int j, int k) {
+        int temp = numbers[j];
+        numbers[j] = numbers[k];
+        numbers[k] = temp;
+    }
+
+
+    public static void main(String args[]) {
+        QuickSort quickSort = new QuickSort();
+        int[] numbers = new int[]{2, 5, 7, 2, 4, 2, 8, 1, 0, 9, 3, 6};
+        quickSort.sort(numbers);
+        System.out.println(Arrays.toString(numbers));
+    }
+
+}