Added more cyclic sort problems

Author: infotechprogrammer

_06_Sorting_Problems/_04_Cyclic_Sort_Problems/_06_Find_Disappeared_Numbers.java

@@ -0,0 +1,39 @@
+package com.Sorting_Problems._04_Cyclic_Sort_Problems;
+/*
+Given an array nums of n integers where nums[i] is in the range [1, n],
+return an array of all the integers in the range [1, n] that do not appear in nums.
+
+Example 1:
+Input: nums = [4,3,2,7,8,2,3,1]
+Output: [5,6]
+ */
+import java.util.ArrayList;
+public class _06_Find_Disappeared_Numbers {
+    public static void main(String[] args) {
+        int[] arr = {4,3,2,7,8,2,3,1};
+        System.out.println(findDisappearedNumbers(arr));
+    }
+    static ArrayList<Integer> findDisappearedNumbers(int[] nums) {
+        int i = 0;
+        while(i < nums.length) {
+            int correct = nums[i] -1;
+            if(nums[i] != nums[correct]) {
+                swap(nums,i,correct);
+            } else { i++; }
+        }
+
+        // just find missing numbers
+        ArrayList<Integer> ans = new ArrayList<>();
+        for (int index = 0; index < nums.length; index++) {
+            if(nums[index] != index+1) {
+                ans.add(index + 1);
+            }
+        }
+        return ans;
+    }
+    static void swap(int[] arr, int first, int second) {
+        int temp = arr[first];
+        arr[first] = arr[second];
+        arr[second] = temp;
+    }
+}

_06_Sorting_Problems/_04_Cyclic_Sort_Problems/_07_Find_Duplicate.java

@@ -0,0 +1,40 @@
+package com.Sorting_Problems._04_Cyclic_Sort_Problems;
+/*
+Given an array of integers nums containing n + 1 integers
+where each integer is in the range [1, n] inclusive.
+There is only one repeated number in nums, return this repeated number.
+You must solve the problem without modifying the array nums
+and uses only constant extra space.
+
+Example 1:
+Input: nums = [1,3,4,2,2]
+Output: 2
+ */
+public class _07_Find_Duplicate {
+    public static void main(String[] args) {
+        int[] arr = {1,3,4,2,2};
+        System.out.println("Duplicate: "+findDuplicate(arr));
+    }
+    static int findDuplicate(int[] nums) {
+        int i = 0;
+        while(i < nums.length) {
+
+            if(nums[i] != i + 1) {
+                int correct = nums[i] -1;
+                if(nums[i] != nums[correct]) {
+                    swap(nums,i,correct);
+                } else {
+                    return nums[i];
+                }
+            } else {
+                i++;
+            }
+        }
+        return -1;
+    }
+    static void swap(int[] arr, int first, int second) {
+        int temp = arr[first];
+        arr[first] = arr[second];
+        arr[second] = temp;
+    }
+}

_06_Sorting_Problems/_04_Cyclic_Sort_Problems/_08_Find_all_Duplicates_in_Array.java

@@ -0,0 +1,48 @@
+package com.Sorting_Problems._04_Cyclic_Sort_Problems;
+
+import java.util.ArrayList;
+import java.util.Arrays;
+
+/*
+Given an integer array nums of length n where all the integers of nums
+are in the range [1, n] and each integer appears once or twice,
+return an array of all the integers that appears twice.
+
+You must write an algorithm that runs in O(n) time and uses only constant extra space.
+
+Example 1:
+Input: nums = [4,3,2,7,8,2,3,1]
+Output: [2,3]
+ */
+public class _08_Find_all_Duplicates_in_Array {
+    public static void main(String[] args) {
+        int[] arr = {4,3,2,7,8,2,3,1};
+        System.out.println("Duplicate Elements: "+ findDuplicates(arr));
+    }
+    static ArrayList<Integer> findDuplicates(int[] nums) {
+        int i = 0;
+        while(i < nums.length) {
+                int correct = nums[i] - 1;
+                if (nums[i] != nums[correct]) {
+                    swap(nums, i, correct);
+                } else {
+                    i++;
+                }
+            }
+
+        // just find missing numbers
+        ArrayList<Integer> ans = new ArrayList<>();
+        for (int index = 0; index < nums.length; index++) {
+            if(nums[index] != index+1) {
+                ans.add(nums[index]);
+            }
+        }
+
+        return ans;
+    }
+    static void swap(int[] arr, int first, int second) {
+        int temp = arr[first];
+        arr[first] = arr[second];
+        arr[second] = temp;
+    }
+}

_06_Sorting_Problems/_04_Cyclic_Sort_Problems/_09_Set_Mismatch.java

@@ -0,0 +1,45 @@
+package com.Sorting_Problems._04_Cyclic_Sort_Problems;
+
+import java.util.Arrays;
+
+/*
+You have a set of integers s, which originally contains all the numbers from 1 to n.
+Unfortunately, due to some error, one of the numbers in s got duplicated to another number in the set,
+which results in repetition of one number and loss of another number.
+You are given an integer array nums representing the data status of this set after the error.
+Find the number that occurs twice and the number that is missing
+and return them in the form of an array.
+
+Example 1:
+Input: nums = [1,2,2,4]
+Output: [2,3]
+ */
+public class _09_Set_Mismatch {
+    public static void main(String[] args) {
+        int[] arr = {1,2,2,5,4};
+        System.out.println(Arrays.toString(findErrorNums(arr)));
+    }
+    static int[] findErrorNums(int[] nums) {
+        int i = 0;
+        while(i < nums.length) {
+            int correct = nums[i] - 1;
+            if(nums[i] != nums[correct]) {
+                swap(nums,i,correct);
+            } else { i++; }
+        }
+
+        //search for first missing number
+        for(int index = 0; index < nums.length; index++) {
+            if(nums[index] != index + 1) {
+                return new int[] {nums[index], index+1};
+            }
+        }
+        // case 2
+        return new int[] {-1,-1};
+    }
+    static void swap(int[] arr, int first, int second) {
+        int temp = arr[first];
+        arr[first] = arr[second];
+        arr[second] = temp;
+    }
+}

_06_Sorting_Problems/_04_Cyclic_Sort_Problems/_10_First_Missing_Positive.java

@@ -0,0 +1,42 @@
+package com.Sorting_Problems._04_Cyclic_Sort_Problems;
+/*
+Given an unsorted integer array nums, return the smallest missing positive integer.
+You must implement an algorithm that runs in O(n) time and uses constant extra space.
+
+Example 1:
+Input: nums = [1,2,0]
+Output: 3
+
+Example 2:
+Input: nums = [3,4,-1,1]
+Output: 2
+ */
+public class _10_First_Missing_Positive {
+    public static void main(String[] args) {
+        int[] arr = {1,2,0};
+        System.out.println(firstMissingPositive(arr));
+    }
+    static int firstMissingPositive(int[] nums) {
+        int i = 0;
+        while(i < nums.length) {
+            int correct = nums[i] - 1;
+            if(nums[i] > 0 && nums[i] <= nums.length && nums[i] != nums[correct]) {
+                swap(nums,i,correct);
+            } else { i++; }
+        }
+
+        //search for first missing number
+        for(int index = 0; index < nums.length; index++) {
+            if(nums[index] != index + 1) {
+                return index + 1;
+            }
+        }
+        // case 2
+        return nums.length + 1;
+    }
+    static void swap(int[] arr, int first, int second) {
+        int temp = arr[first];
+        arr[first] = arr[second];
+        arr[second] = temp;
+    }
+}