Merge pull request ByteByteGoHq#26 from Jer3myYu/java-solutions-sort-and-search

Java Chapter 17: Sort and Search

Author: Destiny-02

java/Sort and Search/DutchNationalFlag.java

@@ -0,0 +1,28 @@
+public class DutchNationalFlag {
+    public void dutchNationalFlag(int[] nums) {
+        int i = 0;
+        int left = 0;
+        int right = nums.length - 1;
+        while (i <= right) {
+            // Swap 0s with the element at the left pointer.
+            if (nums[i] == 0) {
+                swap(nums, i, left);
+                left++;
+                i++;
+            }
+            // Swap 2s with the element at the right pointer.
+            else if (nums[i] == 2) {
+                swap(nums, i, right);
+                right--;
+            } else {
+                i++;
+            }
+        }
+    }
+
+    private void swap(int[] nums, int a, int b) {
+        int tmp = nums[a];
+        nums[a] = nums[b];
+        nums[b] = tmp;
+    }
+}

java/Sort and Search/KthLargestIntegerMinHeap.java

@@ -0,0 +1,20 @@
+import java.util.PriorityQueue;
+
+public class KthLargestIntegerMinHeap {
+    public int kthLargestIntegerMinHeap(int[] nums, int k) {
+        PriorityQueue<Integer> minHeap = new PriorityQueue<>();
+        for (int num : nums) {
+            // Ensure the heap has at least 'k' integers.
+            if (minHeap.size() < k) {
+                minHeap.offer(num);
+            }
+            // If 'num' is greater than the smallest integer in the heap, pop
+            // off this smallest integer from the heap and push in 'num'.
+            else if (num > minHeap.peek()) {
+                minHeap.poll();
+                minHeap.offer(num);
+            }
+        }
+        return minHeap.peek();
+    }    
+}

java/Sort and Search/KthLargestIntegerQuickselect.java

@@ -0,0 +1,42 @@
+public class KthLargestIntegerQuickselect {
+    public int kthLargestIntegerQuickselect(int[] nums, int k) {
+        return quickselect(nums, 0, nums.length - 1, k);
+    }
+
+    private int quickselect(int[] nums, int left, int right, int k) {
+        int n = nums.length;
+        if (left >= right) return nums[left];
+        int randomIndex = left + (int)(Math.random() * (right - left + 1));
+        swap(nums, randomIndex, right);
+        int pivotIndex = partition(nums, left, right);
+        // If the pivot comes before 'n - k', the ('n - k')th smallest 
+        // integer is somewhere to its right. Perform quickselect on the 
+        // right part.
+        if (pivotIndex < n - k) return quickselect(nums, pivotIndex + 1, right, k);
+        // If the pivot comes after 'n - k', the ('n - k')th smallest integer
+        // is somewhere to its left. Perform quickselect on the left part.
+        else if (pivotIndex > n - k) return quickselect(nums, left, pivotIndex - 1, k);
+        // If the pivot is at index 'n - k', it's the ('n - k')th smallest
+        // integer.
+        else return nums[pivotIndex];
+    }
+
+    private int partition(int[] nums, int left, int right) {
+        int pivot = nums[right];
+        int lo = left;
+        for (int i = left; i < right; i++) {
+            if (nums[i] < pivot) {
+                swap(nums, lo, i);
+                lo++;
+            }
+        }
+        swap(nums, lo, right);
+        return lo;
+    }
+
+    private void swap(int[] nums, int a, int b) {
+        int tmp = nums[a];
+        nums[a] = nums[b];
+        nums[b] = tmp;
+    }
+}

java/Sort and Search/SortArrayCountingSort.java

@@ -0,0 +1,24 @@
+import java.util.Arrays;
+
+public class SortArrayCountingSort {
+    public int[] sortArrayCountingSort(int[] nums) {
+        if (nums == null || nums.length == 0) return nums;
+        int[] res = new int[nums.length];
+        int max = Arrays.stream(nums).max().getAsInt();
+        // Count occurrences of each element in 'nums'.
+        int[] counts = new int[max + 1];
+        for (int num : nums) {
+            counts[num]++;
+        }
+        // Build the sorted array by appending each index 'i' to it a total 
+        // of 'counts[i]' times.
+        int idx = 0;
+        for (int i = 0; i < counts.length; i++) {
+            for (int j = 0; j < counts[i]; j++) {
+                res[idx] = i;
+                idx++;
+            }
+        }
+        return res;
+    }
+}

java/Sort and Search/SortArrayQuicksort.java

@@ -0,0 +1,42 @@
+public class SortArrayQuicksort {
+    public int[] sortArray(int[] nums) {
+        quicksort(nums, 0, nums.length - 1);
+        return nums;
+    }
+
+    private void quicksort(int[] nums, int left, int right) {
+        // Base case: if the subarray has 0 or 1 element, it's already 
+        // sorted.
+        if (left >= right) return;
+        // Partition the array and retrieve the pivot index.
+        int pivotIndex = partition(nums, left, right);
+        // Call quicksort on the left and right parts to recursively sort
+        // them.
+        quicksort(nums, left, pivotIndex - 1);
+        quicksort(nums, pivotIndex + 1, right);
+    }
+
+    private int partition(int[] nums, int left, int right) {
+        int pivot = nums[right];
+        int lo = left;
+        // Move all numbers less than the pivot to the left, which
+        // consequently positions all numbers greater than or equal to the
+        // pivot to the right.
+        for (int i = left; i < right; i++) {
+            if (nums[i] < pivot) {
+                swap(nums, lo, i);
+                lo++;
+            }
+        }
+        // After partitioning, 'lo' will be positioned where the pivot should
+        // be. So, swap the pivot number with the number at the 'lo' pointer.
+        swap(nums, lo, right);
+        return lo;
+    }
+
+    private void swap(int[] nums, int a, int b) {
+        int tmp = nums[a];
+        nums[a] = nums[b];
+        nums[b] = tmp;
+    }
+}

java/Sort and Search/SortArrayQuicksortOptimized.java

@@ -0,0 +1,44 @@
+public class SortArrayQuicksortOptimized {
+    public int[] sortArray(int[] nums) {
+        quicksortOptimized(nums, 0, nums.length - 1);
+        return nums;
+    }
+
+    private void quicksortOptimized(int[] nums, int left, int right) {
+        if (left >= right) return;
+        // Choose a pivot at a random index.
+        // Math.random() generate a double in [0.0, 1.0)
+        // Scale the range from [0.0, 1.0) to [0, right - left + 1)
+        int randomIndex = left + (int)(Math.random() * (right - left + 1));
+        // Swap the randomly chosen pivot with the rightmost element to 
+        // position the pivot at the rightmost index.
+        swap(nums, randomIndex, right);
+        int pivotIndex = partition(nums, left, right);
+        quicksortOptimized(nums, left, pivotIndex - 1);
+        quicksortOptimized(nums, pivotIndex + 1, right);
+    }
+
+    private int partition(int[] nums, int left, int right) {
+        int pivot = nums[right];
+        int lo = left;
+        // Move all numbers less than the pivot to the left, which
+        // consequently positions all numbers greater than or equal to the
+        // pivot to the right.
+        for (int i = left; i < right; i++) {
+            if (nums[i] < pivot) {
+                swap(nums, lo, i);
+                lo++;
+            }
+        }
+        // After partitioning, 'lo' will be positioned where the pivot should
+        // be. So, swap the pivot number with the number at the 'lo' pointer.
+        swap(nums, lo, right);
+        return lo;
+    }
+
+    private void swap(int[] nums, int a, int b) {
+        int tmp = nums[a];
+        nums[a] = nums[b];
+        nums[b] = tmp;
+    }
+}

java/Sort and Search/SortLinkedList.java

@@ -0,0 +1,68 @@
+import DS.ListNode;
+
+/*
+    // Definition of ListNode:
+    class ListNode {
+        public int val;
+        public ListNode next;
+        public ListNode(int val) { this.val = val; }
+        public ListNode(int val, ListNode next) {
+            this(val);
+            this.next = next;
+        }
+    }
+ */
+
+
+public class SortLinkedList {
+    public ListNode sortLinkedList(ListNode head) {
+        // If the linked list is empty or has only one element, it's already
+        // sorted.
+        if (head == null || head.next == null) return head;
+        // Split the linked list into halves using the fast and slow pointer
+        // technique.
+        ListNode secondHead = splitList(head);
+        // Recursively sort both halves.
+        ListNode firstHalfSorted = sortLinkedList(head);
+        ListNode secondHalfSorted = sortLinkedList(secondHead);
+        // Merge the sorted sublists.
+        return merge(firstHalfSorted, secondHalfSorted);
+    }
+
+    private ListNode splitList(ListNode head) {
+        ListNode slow;
+        ListNode fast;
+        slow = fast = head;
+        while (fast.next != null && fast.next.next != null) {
+            slow = slow.next;
+            fast = fast.next.next;
+        }
+        ListNode secondHead = slow.next;
+        slow.next = null;
+        return secondHead;
+    }
+
+    private ListNode merge(ListNode l1, ListNode l2) {
+        ListNode dummy = new ListNode(0);
+        // This pointer will be used to append nodes to the tail of the 
+        // merged linked list.
+        ListNode tail = dummy;
+        // Continually append the node with the smaller value from each 
+        // linked list to the merged linked list until one of the linked 
+        // lists has no more nodes to merge.
+        while (l1 != null && l2 != null) {
+            if (l1.val < l2.val) {
+                tail.next = l1;
+                l1 = l1.next;
+            } else {
+                tail.next = l2;
+                l2 = l2.next;
+            }
+            tail = tail.next;
+        }
+        // One of the two linked lists could still have nodes remaining.
+        // Attach those nodes to the end of the merged linked list.
+        tail.next = l1 == null ? l2 : l1;
+        return dummy.next;
+    }
+}