Find the smallest positive number missing from an unsorted array | Set 1
Last Updated :
22 Apr, 2024
Given an unsorted array arr[] with both positive and negative elements, the task is to find the smallest positive number missing from the array.
Note: You can modify the original array.
Examples:
Input: arr[] = {2, 3, 7, 6, 8, -1, -10, 15}
Output: 1
Input: arr[] = { 2, 3, -7, 6, 8, 1, -10, 15 }
Output: 4
Input: arr[] = {1, 1, 0, -1, -2}
Output: 2
Naive Approach:
A naive method to solve this problem is to search all positive integers, starting from 1 in the given array.
Time Complexity: O(N2) because we may have to search at most n+1 numbers in the given array.
Auxiliary Space: O(1)
Smallest positive number missing from an unsorted array by Marking Elements:
The idea is to mark the elements which are present in the array then traverse over the marked array and return the first element which is not marked.
Follow the steps below to solve the problem:
- Create a list full of 0’s with the size of the max value of the given array.
- Now, whenever we encounter any positive value in the original array, change the index value of the list to 1.
- After that simply iterate through the modified list, the first 0 encountered, (index value + 1) should be the answer.
Below is the implementation of the above approach.
C++
// C++ implementation of the approach
#include <bits/stdc++.h>
using namespace std;
// Function to return the first missing positive number from
// the given unsorted array
int firstMissingPos(int A[], int n)
{
// To mark the occurrence of elements
bool present[n + 1] = { false };
// Mark the occurrences
for (int i = 0; i < n; i++) {
// Only mark the required elements
// All non-positive elements and the elements
// greater n + 1 will never be the answer
// For example, the array will be {1, 2, 3} in the
// worst case and the result will be 4 which is n +
// 1
if (A[i] > 0 && A[i] <= n)
present[A[i]] = true;
}
// Find the first element which didn't appear in the
// original array
for (int i = 1; i <= n; i++)
if (!present[i])
return i;
// If the original array was of the type {1, 2, 3} in
// its sorted form
return n + 1;
}
// Driver code
int main()
{
int arr[] = { 0, 10, 2, -10, -20 };
int size = sizeof(arr) / sizeof(arr[0]);
cout << firstMissingPos(arr, size);
}
// This code is contributed by Aditya Kumar (adityakumar129)
C
// C implementation of the approach
#include <stdbool.h>
#include <stdio.h>
// Function to return the first missing positive number from
// the given unsorted array
int firstMissingPos(int A[], int n)
{
// To mark the occurrence of elements
bool present[n + 1];
for (int i = 0; i < n; i++)
present[i] = false;
// Mark the occurrences
for (int i = 0; i < n; i++) {
// Only mark the required elements
// All non-positive elements and the elements
// greater n + 1 will never be the answer
// For example, the array will be {1, 2, 3} in the
// worst case and the result will be 4 which is n +
// 1
if (A[i] > 0 && A[i] <= n)
present[A[i]] = true;
}
// Find the first element which didn't appear in the
// original array
for (int i = 1; i <= n; i++)
if (!present[i])
return i;
// If the original array was of the type {1, 2, 3} in
// its sorted form
return n + 1;
}
// Driver code
int main()
{
int arr[] = { 0, 10, 2, -10, -20 };
int size = sizeof(arr) / sizeof(arr[0]);
printf("%d", firstMissingPos(arr, size));
}
// This code is contributed by Aditya Kumar (adityakumar129)
Java
// Java Program to find the smallest positive missing number
import java.util.*;
public class GFG {
static int solution(int[] A)
{
int n = A.length;
// Let this 1e6 be the maximum element provided in
// the array;
int N = 1000010;
// To mark the occurrence of elements
boolean[] present = new boolean[N];
int maxele = Integer.MIN_VALUE;
// Mark the occurrences
for (int i = 0; i < n; i++) {
// Only mark the required elements
// All non-positive elements and the elements
// greater n + 1 will never be the answer
// For example, the array will be {1, 2, 3} in
// the worst case and the result will be 4 which
// is n + 1
if (A[i] > 0 && A[i] <= n)
present[A[i]] = true;
// find the maximum element so that if all the
// elements are in order can directly return the
// next number
maxele = Math.max(maxele, A[i]);
}
// Find the first element which didn't
// appear in the original array
for (int i = 1; i < N; i++)
if (!present[i])
return i;
// If the original array was of the
// type {1, 2, 3} in its sorted form
return maxele + 1;
}
// Driver Code
public static void main(String[] args)
{
int arr[] = { 0, 10, 2, -10, -20 };
System.out.println(solution(arr));
}
}
// This code is contributed by Aditya Kumar (adityakumar129)
Python3
# Python3 Program to find the smallest
# positive missing number
def solution(A): # Our original array
m = max(A) # Storing maximum value
if m < 1:
# In case all values in our array are negative
return 1
if len(A) == 1:
# If it contains only one element
return 2 if A[0] == 1 else 1
l = [0] * m
for i in range(len(A)):
if A[i] > 0:
if l[A[i] - 1] != 1:
# Changing the value status at the index of our list
l[A[i] - 1] = 1
for i in range(len(l)):
# Encountering first 0, i.e, the element with least value
if l[i] == 0:
return i + 1
# In case all values are filled between 1 and m
return i + 2
# Driver Code
if __name__ == '__main__':
arr = [0, 10, 2, -10, -20]
print(solution(arr))
C#
// C# Program to find the smallest
// positive missing number
using System;
using System.Linq;
class GFG {
static int solution(int[] A)
{
// Our original array
int m = A.Max(); // Storing maximum value
// In case all values in our array are negative
if (m < 1) {
return 1;
}
if (A.Length == 1) {
// If it contains only one element
if (A[0] == 1) {
return 2;
}
else {
return 1;
}
}
int i = 0;
int[] l = new int[m];
for (i = 0; i < A.Length; i++) {
if (A[i] > 0) {
// Changing the value status at the index of
// our list
if (l[A[i] - 1] != 1) {
l[A[i] - 1] = 1;
}
}
}
// Encountering first 0, i.e, the element with least
// value
for (i = 0; i < l.Length; i++) {
if (l[i] == 0) {
return i + 1;
}
}
// In case all values are filled between 1 and m
return i + 2;
}
// Driver code
public static void Main()
{
int[] arr = { 0, 10, 2, -10, -20 };
Console.WriteLine(solution(arr));
}
}
// This code is contributed by PrinciRaj1992
Javascript
// Javascript Program to find the smallest
// positive missing number
function solution(A)
{
let n = A.length;
// To mark the occurrence of elements
let present = new Array(n+1);
for(let i=0;i<n+1;i++)
{
present[i]=false;
}
// Mark the occurrences
for (let i = 0; i < n; i++)
{
// Only mark the required elements
// All non-positive elements and
// the elements greater n + 1 will never
// be the answer
// For example, the array will be {1, 2, 3}
// in the worst case and the result
// will be 4 which is n + 1
if (A[i] > 0 && A[i] <= n)
{
present[A[i]] = true;
}
}
// Find the first element which didn't
// appear in the original array
for (let i = 1; i <= n; i++)
{
if (!present[i])
{
return i;
}
}
// If the original array was of the
// type {1, 2, 3} in its sorted form
return n + 1;
}
// Driver Code
let arr = [0, 10, 2, -10, -20]
console.log(solution(arr));
PHP
<?php
// PHP Program to find the smallest
// positive missing number
function solution($A){//Our original array
$m = max($A); //Storing maximum value
if ($m < 1)
{
// In case all values in our array are negative
return 1;
}
if (sizeof($A) == 1)
{
//If it contains only one element
if ($A[0] == 1)
return 2 ;
else
return 1 ;
}
$l = array_fill(0, $m, NULL);
for($i = 0; $i < sizeof($A); $i++)
{
if( $A[$i] > 0)
{
if ($l[$A[$i] - 1] != 1)
{
//Changing the value status at the index of our list
$l[$A[$i] - 1] = 1;
}
}
}
for ($i = 0;$i < sizeof($l); $i++)
{
//Encountering first 0, i.e, the element with least value
if ($l[$i] == 0)
return $i+1;
}
//In case all values are filled between 1 and m
return $i+2;
}
// Driver Code
$arr = array(0, 10, 2, -10, -20);
echo solution($arr);
return 0;
?>
Time Complexity: O(N), Only two traversals are needed.
Auxiliary Space: O(N), using the list will require extra space
Smallest positive number missing from an unsorted Array by using array elements as Index:
The idea is to use array elements as an index. To mark the presence of an element x, change the value at the index x to negative. But this approach doesn’t work if there are non-positive (-ve and 0) numbers.
So segregate positive from negative numbers as the first step and then apply the approach.
Follow the steps below to solve the problem:
- Segregate positive numbers from others i.e., move all non-positive numbers to the left side.
- Now ignore non-positive elements and consider only the part of the array which contains all positive elements.
- Traverse the array containing all positive numbers and to mark the presence of an element x, change the sign of value at index x to negative.
- Traverse the array again and print the first index which has a positive value.
Below is the implementation of the above approach.
C++
#include <iostream>
#include <vector>
using namespace std;
// Linear time routine for partitioning step
int partition(int arr[], int n)
{
int pind = 0;
// each time we find a positive number we move it to the
// left side before the pivot
for (int i = 0; i < n; i++) {
if (arr[i] > 0) // pivot is 0
{
swap(arr[i], arr[pind]);
pind++;
}
}
// return index of the first non-positive number
return pind;
}
// Function for finding the first missing positive number
int firstMissingPositive(int arr[], int n)
{
int k = partition(arr, n);
// Traverse the positive part of the array
for (int i = 0; i < k; i++) {
// get the absolute value of the current element
int val = abs(arr[i]);
// If the absolute value is within range and the
// element at index `val-1` is positive, mark its
// presence by changing its sign to negative
if (val - 1 < k && arr[val - 1] > 0) {
arr[val - 1] = -arr[val - 1];
}
}
// Traverse the positive part of the array again to find
// the smallest missing positive number
for (int i = 0; i < k; i++) {
if (arr[i] > 0) {
return i + 1;
}
}
// If all numbers from 1 to k are present, then the
// missing number is `k + 1`
return k + 1;
}
// Driver code
int main()
{
int arr[] = { 0, 10, 2, -10, -20 };
int n = sizeof(arr) / sizeof(arr[0]);
int ans = firstMissingPositive(arr, n);
cout << ans;
return 0;
}
// This code is contributed by Susobhan Akhuli
Java
import java.util.Arrays;
public class Main {
// Linear time routine for partitioning step
static int partition(int[] arr, int n) {
int pind = 0;
// each time we find a positive number we move it to the
// left side before the pivot
for (int i = 0; i < n; i++) {
if (arr[i] > 0) { // pivot is 0
int temp = arr[i];
arr[i] = arr[pind];
arr[pind] = temp;
pind++;
}
}
// return index of the first non-positive number
return pind;
}
// Function for finding the first missing positive number
static int firstMissingPositive(int[] arr, int n) {
int k = partition(arr, n);
// Traverse the positive part of the array
for (int i = 0; i < k; i++) {
// get the absolute value of the current element
int val = Math.abs(arr[i]);
// If the absolute value is within range and the
// element at index `val-1` is positive, mark its
// presence by changing its sign to negative
if (val - 1 < k && arr[val - 1] > 0) {
arr[val - 1] = -arr[val - 1];
}
}
// Traverse the positive part of the array again to find
// the smallest missing positive number
for (int i = 0; i < k; i++) {
if (arr[i] > 0) {
return i + 1;
}
}
// If all numbers from 1 to k are present, then the
// missing number is `k + 1`
return k + 1;
}
// Driver code
public static void main(String[] args) {
int[] arr = {0, 10, 2, -10, -20};
int n = arr.length;
int ans = firstMissingPositive(arr, n);
System.out.println(ans);
}
}
Python3
# Linear time routine for partitioning step
def partition(arr):
pind = 0
# each time we find a positive number we move it to the
# left side before the pivot
for i in range(len(arr)):
if arr[i] > 0: # pivot is 0
arr[i], arr[pind] = arr[pind], arr[i]
pind += 1
# return index of the first non-positive number
return pind
# Function for finding the first missing positive number
def firstMissingPositive(arr):
k = partition(arr)
# Traverse the positive part of the array
for i in range(k):
# get the absolute value of the current element
val = abs(arr[i])
# If the absolute value is within range and the
# element at index `val-1` is positive, mark its
# presence by changing its sign to negative
if val - 1 < k and arr[val - 1] > 0:
arr[val - 1] = -arr[val - 1]
# Traverse the positive part of the array again to find
# the smallest missing positive number
for i in range(k):
if arr[i] > 0:
return i + 1
# If all numbers from 1 to k are present, then the
# missing number is `k + 1`
return k + 1
# Driver code
if __name__ == "__main__":
arr = [0, 10, 2, -10, -20]
ans = firstMissingPositive(arr)
print(ans)
JavaScript
// Linear time routine for partitioning step
function partition(arr) {
let pind = 0;
// each time we find a positive number we move it to the
// left side before the pivot
for (let i = 0; i < arr.length; i++) {
if (arr[i] > 0) { // pivot is 0
[arr[i], arr[pind]] = [arr[pind], arr[i]];
pind++;
}
}
// return index of the first non-positive number
return pind;
}
// Function for finding the first missing positive number
function firstMissingPositive(arr) {
const k = partition(arr);
// Traverse the positive part of the array
for (let i = 0; i < k; i++) {
// get the absolute value of the current element
const val = Math.abs(arr[i]);
// If the absolute value is within range and the
// element at index `val-1` is positive, mark its
// presence by changing its sign to negative
if (val - 1 < k && arr[val - 1] > 0) {
arr[val - 1] = -arr[val - 1];
}
}
// Traverse the positive part of the array again to find
// the smallest missing positive number
for (let i = 0; i < k; i++) {
if (arr[i] > 0) {
return i + 1;
}
}
// If all numbers from 1 to k are present, then the
// missing number is `k + 1`
return k + 1;
}
// Driver code
function main() {
const arr = [0, 10, 2, -10, -20];
const ans = firstMissingPositive(arr);
console.log(ans);
}
// Calling main function
main();
Time Complexity: O(N), Traversing the array of size N.
Auxiliary Space: O(1)
Smallest positive number missing from an unsorted array by changing the input Array
The idea is to mark the elements in the array which are greater than N and less than 1 with 1.
Follow the steps below to solve the problem:
- The smallest positive integer is 1. First, we will check if 1 is present in the array or not. If it is not present then 1 is the answer.
- If present then, again traverse the array. The largest possible answer is N+1 where N is the size of the array.
- When traversing the array, if we find any number less than 1 or greater than N, change it to 1.
- This will not change anything as the answer will always be between 1 to N+1. Now our array has elements from 1 to N.
- Now, for every ith number, increase arr[ (arr[i]-1) ] by N. But this will increase the value more than N. So, we will access the array by arr[(arr[i]-1)%N].
- We will find now which index has a value less than N+1. Then i+1 will be our answer.
Below is the implementation of the above approach.
C++
// C++ program for the above approach
#include <bits/stdc++.h>
using namespace std;
// Function for finding the first missing positive number
int firstMissingPositive(int arr[], int n)
{
int ptr = 0;
// Check if 1 is present in array or not
for (int i = 0; i < n; i++) {
if (arr[i] == 1) {
ptr = 1;
break;
}
}
// If 1 is not present
if (ptr == 0)
return 1;
// Changing values to 1
for (int i = 0; i < n; i++)
if (arr[i] <= 0 || arr[i] > n)
arr[i] = 1;
// Updating indices according to values
for (int i = 0; i < n; i++)
arr[(arr[i] - 1) % n] += n;
// Finding which index has value less than n
for (int i = 0; i < n; i++)
if (arr[i] <= n)
return i + 1;
// If array has values from 1 to n
return n + 1;
}
// Driver code
int main()
{
int arr[] = { 0, 10, 2, -10, -20 };
int n = sizeof(arr) / sizeof(arr[0]);
int ans = firstMissingPositive(arr, n);
cout << ans;
return 0;
}
C
// C program for the above approach
#include <stdio.h>
#include <stdlib.h>
// Function for finding the first
// missing positive number
int firstMissingPositive(int arr[], int n)
{
int ptr = 0;
// Check if 1 is present in array or not
for (int i = 0; i < n; i++) {
if (arr[i] == 1) {
ptr = 1;
break;
}
}
// If 1 is not present
if (ptr == 0)
return 1;
// Changing values to 1
for (int i = 0; i < n; i++)
if (arr[i] <= 0 || arr[i] > n)
arr[i] = 1;
// Updating indices according to values
for (int i = 0; i < n; i++)
arr[(arr[i] - 1) % n] += n;
// Finding which index has value less than n
for (int i = 0; i < n; i++)
if (arr[i] <= n)
return i + 1;
// If array has values from 1 to n
return n + 1;
}
// Driver code
int main()
{
int arr[] = { 0, 10, 2, -10, -20 };
int n = sizeof(arr) / sizeof(arr[0]);
int ans = firstMissingPositive(arr, n);
printf("%d", ans);
return 0;
}
// This code is contributed by shailjapriya
Java
// Java program for the above approach
import java.util.Arrays;
class GFG {
// Function for finding the first
// missing positive number
static int firstMissingPositive(int arr[], int n)
{
int ptr = 0;
// Check if 1 is present in array or not
for (int i = 0; i < n; i++) {
if (arr[i] == 1) {
ptr = 1;
break;
}
}
// If 1 is not present
if (ptr == 0)
return (1);
// Changing values to 1
for (int i = 0; i < n; i++)
if (arr[i] <= 0 || arr[i] > n)
arr[i] = 1;
// Updating indices according to values
for (int i = 0; i < n; i++)
arr[(arr[i] - 1) % n] += n;
// Finding which index has value less than n
for (int i = 0; i < n; i++)
if (arr[i] <= n)
return (i + 1);
// If array has values from 1 to n
return (n + 1);
}
// Driver Code
public static void main(String[] args)
{
int arr[] = { 0, 10, 2, -10, -20 };
int n = arr.length;
int ans = firstMissingPositive(arr, n);
System.out.println(ans);
}
}
// This code is contributed by shailjapriya
Python3
# Python3 program for the above approach
# Function for finding the first missing
# positive number
def firstMissingPositive(arr, n):
ptr = 0
# Check if 1 is present in array or not
for i in range(n):
if arr[i] == 1:
ptr = 1
break
# If 1 is not present
if ptr == 0:
return(1)
# Changing values to 1
for i in range(n):
if arr[i] <= 0 or arr[i] > n:
arr[i] = 1
# Updating indices according to values
for i in range(n):
arr[(arr[i] - 1) % n] += n
# Finding which index has value less than n
for i in range(n):
if arr[i] <= n:
return(i + 1)
# If array has values from 1 to n
return(n + 1)
# Driver Code
if __name__ == '__main__':
# Given array
A = [0, 10, 2, -10, -20]
# Size of the array
N = len(A)
# Function call
print(firstMissingPositive(A, N))
# This code is contributed by shailjapriya
C#
// C# program for the above approach
using System;
using System.Linq;
class GFG {
// Function for finding the first missing
// positive number
static int firstMissingPositive(int[] arr, int n)
{
int ptr = 0;
// Check if 1 is present in array or not
for (int i = 0; i < n; i++) {
if (arr[i] == 1) {
ptr = 1;
break;
}
}
// If 1 is not present
if (ptr == 0)
return 1;
// Changing values to 1
for (int i = 0; i < n; i++)
if (arr[i] <= 0 || arr[i] > n)
arr[i] = 1;
// Updating indices according to values
for (int i = 0; i < n; i++)
arr[(arr[i] - 1) % n] += n;
// Finding which index has value less than n
for (int i = 0; i < n; i++)
if (arr[i] <= n)
return i + 1;
// If array has values from 1 to n
return n + 1;
}
// Driver code
public static void Main()
{
int[] A = { 0, 10, 2, -10, -20 };
int n = A.Length;
int ans = firstMissingPositive(A, n);
Console.WriteLine(ans);
}
}
// This code is contributed by shailjapriya
Javascript
// Javascript program for the above approach
// Function for finding the first
// missing positive number
function firstMissingPositive(arr, n)
{
let ptr = 0;
// Check if 1 is present in array or not
for(let i = 0; i < n; i++)
{
if (arr[i] == 1)
{
ptr = 1;
break;
}
}
// If 1 is not present
if (ptr == 0)
return 1;
// Changing values to 1
for(let i = 0; i < n; i++)
if (arr[i] <= 0 || arr[i] > n)
arr[i] = 1;
// Updating indices according to values
for(let i = 0; i < n; i++)
arr[(arr[i] - 1) % n] += n;
// Finding which index has value less than n
for(let i = 0; i < n; i++)
if (arr[i] <= n)
return i + 1;
// If array has values from 1 to n
return n + 1;
}
// Driver code
let arr = [ 0, 10, 2, -10, -20 ];
let n = arr.length;
let ans = firstMissingPositive(arr, n);
console.log(ans);
// This code is contributed by telimayur
Time Complexity: O(N), Traversing over the array
Auxiliary Space: O(1)
Smallest positive number missing from an unsorted array by Swapping:
The idea is to swap the elements which are in the range 1 to N should be placed at their respective indexes.
Follow the steps below to solve the problem:
- Traverse the array, Ignore the elements which are greater than N and less than 1.
- While traversing, check if a[i] ? a[a[i]-1] holds true or not .
- If the above condition is true then swap a[i] and a[a[i] – 1] and swap until (a[i] ? a[a[i] – 1]) condition fails.
- Traverse the array and check whether a[i] ? i + 1 then return i + 1.
- If all are equal to its index then return N+1.
Below is the implementation of the above approach.
C++
// C++ program for the above approach
#include <bits/stdc++.h>
using namespace std;
// Function for finding the first
// missing positive number
int firstMissingPositive(int arr[], int n)
{
// Loop to traverse the whole array
for (int i = 0; i < n; i++) {
// Loop to check boundary
// condition and for swapping
while (arr[i] >= 1 && arr[i] <= n
&& arr[i] != arr[arr[i] - 1]) {
swap(arr[i], arr[arr[i] - 1]);
}
}
// Checking any element which
// is not equal to i+1
for (int i = 0; i < n; i++) {
if (arr[i] != i + 1) {
return i + 1;
}
}
// Nothing is present return last index
return n + 1;
}
// Driver code
int main()
{
int arr[] = { 0, 10, 2, -10, -20 };
int n = sizeof(arr) / sizeof(arr[0]);
int ans = firstMissingPositive(arr, n);
cout << ans;
return 0;
}
// This code is contributed by Harsh kedia
Java
// Java program for the above approach
import java.util.Arrays;
class GFG {
// Function for finding the first
// missing positive number
static int firstMissingPositive(int arr[], int n)
{
// Check if 1 is present in array or not
for (int i = 0; i < n; i++) {
// Loop to check boundary
// condition and for swapping
while (arr[i] >= 1 && arr[i] <= n
&& arr[i] != arr[arr[i] - 1]) {
int temp = arr[arr[i] - 1];
arr[arr[i] - 1] = arr[i];
arr[i] = temp;
}
}
// Finding which index has value less than n
for (int i = 0; i < n; i++)
if (arr[i] != i + 1)
return (i + 1);
// If array has values from 1 to n
return (n + 1);
}
// Driver Code
public static void main(String[] args)
{
int arr[] = { 0, 10, 2, -10, -20 };
int n = arr.length;
int ans = firstMissingPositive(arr, n);
System.out.println(ans);
}
}
// This code is contributed by mohit kumar 29.
Python3
# Python program for the above approach
# Function for finding the first
# missing positive number
def firstMissingPositive(arr, n):
# Loop to traverse the whole array
for i in range(n):
# Loop to check boundary
# condition and for swapping
while (arr[i] >= 1 and arr[i] <= n
and arr[i] != arr[arr[i] - 1]):
temp = arr[i]
arr[i] = arr[arr[i] - 1]
arr[temp - 1] = temp
# Checking any element which
# is not equal to i + 1
for i in range(n):
if (arr[i] != i + 1):
return i + 1
# Nothing is present return last index
return n + 1
# Driver code
if __name__ == '__main__':
arr = [0, 10, 2, -10, -20]
n = len(arr)
ans = firstMissingPositive(arr, n)
print(ans)
# This code is contributed by shivanisinghss2110
C#
// C# program for the above approach
using System;
public class GFG {
// Function for finding the first
// missing positive number
static int firstMissingPositive(int[] arr, int n)
{
// Check if 1 is present in array or not
for (int i = 0; i < n; i++) {
// Loop to check boundary
// condition and for swapping
while (arr[i] >= 1 && arr[i] <= n
&& arr[i] != arr[arr[i] - 1]) {
int temp = arr[arr[i] - 1];
arr[arr[i] - 1] = arr[i];
arr[i] = temp;
}
}
// Finding which index has value less than n
for (int i = 0; i < n; i++)
if (arr[i] != i + 1)
return (i + 1);
// If array has values from 1 to n
return (n + 1);
}
// Driver Code
static public void Main()
{
int[] arr = { 0, 10, 2, -10, -20 };
int n = arr.Length;
int ans = firstMissingPositive(arr, n);
Console.WriteLine(ans);
}
}
// This code is contributed by ab2127
Javascript
// Javascript program for the above approach
// Function for finding the first
// missing positive number
function firstMissingPositive(arr, n)
{
// Check if 1 is present in array or not
for(let i = 0; i < n; i++)
{
// Loop to check boundary
// condition and for swapping
while (arr[i] >= 1 && arr[i] <= n
&& arr[i] != arr[arr[i] - 1]) {
let temp=arr[arr[i]-1];
arr[arr[i]-1]=arr[i];
arr[i]=temp;
}
}
// Finding which index has value less than n
for(let i = 0; i < n; i++)
if (arr[i] != i + 1)
return (i + 1);
// If array has values from 1 to n
return (n + 1);
}
// Driver Code
let arr=[ 0, 10, 2, -10, -20 ];
let n = arr.length;
let ans = firstMissingPositive(arr, n);
console.log(ans);
// This code is contributed by patel2127
Time Complexity: O(N), Only two traversals are needed.
Auxiliary Space: O(1), No extra space is needed
Smallest positive number missing from an unsorted array using Sorting:
The idea is to sort the array and then check for the smallest missing number (start from 1) if it is present then increment it.
Follow the steps below to solve the problem:
- First sort the array and the smallest positive integer is 1.
- So, take ans=1 and iterate over the array once and check whether arr[i] = ans (Checking for value from 1 up to the missing number).
- By iterating if that condition meets where arr[i] = ans then increment ans by 1 and again check for the same condition until the size of the array.
- After one scan of the array, the missing number is stored in ans variable.
- Now return that ans to the function.
Below is the implementation of the above approach:
C++
#include <bits/stdc++.h>
using namespace std;
// Function to find first positive missing number
int firstMissingPositive(vector<int>& nums)
{
sort(nums.begin(), nums.end());
int ans = 1;
for (int i = 0; i < nums.size(); i++) {
if (nums[i] == ans) {
ans++;
}
}
return ans;
}
// Driver code
int main()
{
vector<int> arr = { 0, 10, 2, -10, -20 };
// Function call
cout << firstMissingPositive(arr);
return 0;
}
Java
/*package whatever // do not write package name here */
import java.io.*;
import java.util.Arrays;
class GFG {
public static int firstMissingPositive(int[] nums,
int n)
{
Arrays.sort(nums);
int ans = 1;
for (int i = 0; i < n; i++) {
if (nums[i] == ans)
ans++;
}
return ans;
}
public static void main(String[] args)
{
int arr[] = { 0, 10, 2, -10, -20 };
int n = arr.length;
int ans = firstMissingPositive(arr, n);
System.out.println(ans);
}
}
Python3
# Python code for the same approach
from functools import cmp_to_key
def cmp(a, b):
return (a - b)
def firstMissingPositive(nums):
nums.sort(key = cmp_to_key(cmp))
ans = 1
for i in range(len(nums)):
if(nums[i] == ans):
ans += 1
return ans
# driver code
if __name__ == '__main__':
arr = [0, 10, 2, -10, -20]
print(firstMissingPositive(arr))
# This code is contributed by shinjanpatra
C#
// C# program for the above approach
using System;
public class GFG {
static public int firstMissingPositive(int[] nums,
int n)
{
Array.Sort(nums);
int ans = 1;
for (int i = 0; i < n; i++) {
if (nums[i] == ans)
ans++;
}
return ans;
}
// Driver Code
static public void Main()
{
int[] arr = { 0, 10, 2, -10, -20 };
int n = arr.Length;
int ans = firstMissingPositive(arr, n);
Console.WriteLine(ans);
}
}
// This code is contributed by kothavvsaakash
Javascript
function firstMissingPositive(nums)
{
nums.sort((a, b)=>a-b);
let ans = 1;
for(let i = 0; i < nums.length; i++)
{
if(nums[i] == ans)
ans++;
}
return ans;
}
// driver code
let arr = [0, 10, 2, -10, -20];
console.log(firstMissingPositive(arr));
// This code is contributed by shinjanpatra
Time Complexity: O(N*log(N)), Time required to sort the array
Auxiliary Space: O(1)
Share your thoughts in the comments
Please Login to comment...