1. MissingInteger 最小遗失整数 Find the minimal positive integer not occurring in a given sequence....

 

package com.code;

import java.util.Arrays;

public class Test04_1 {
    public static int solution(int[] A) {
        int size = A.length;
        if(size==1){ // handle one element array
            if(A[0]==1){
                return 2;
            }else{
                return 1;
            }
        }
        Arrays.sort(A); // sort by JDK
        if(A[0]>1){ // handle all elements bigger than 1
            return 1;
        }
        if(A[size-1]<=0){ // handle all elements are negative
            return 1;
        }
        int i=0;
        for(i=0;i<size-1;i++){
            if(A[i]>=0  && (A[i+1]-A[i]>1)){ // handle no consecutive array which start with 1
                    return A[i]+1;
                }
        }
        if(i==size-1){ // handle consecutive array , handle negative elements too.
            return A[size-1]+1>0?A[size-1]+1:1;
        }
        return 1;
    }
    public static void main(String[] args) {
        int [] a = {1,1,2,3,4,5};
        System.out.println(solution(a));
        int [] b = {-4,-2,0,5};
        System.out.println(solution(b));
        int [] c = {2};
        System.out.println(solution(c));
        int [] d = {-2,0,100,102,200};
        System.out.println(solution(d));
        int [] e = {2,4,5,6};
        System.out.println(solution(e));
        
    }
}
/**
 * 
 * 1. MissingInteger
  Find the minimal positive integer not occurring in a given sequence.
 * Write a function:
 * 
 * class Solution { public int solution(int[] A); }
 * 
 * that, given a non-empty zero-indexed array A of N integers, returns the minimal positive integer (greater than 0) that does not occur in A.
 * 
 * For example, given:
 * 
 * A[0] = 1 A[1] = 3 A[2] = 6 A[3] = 4 A[4] = 1 A[5] = 2 the function should return 5.
 * 
 * Assume that:
 * 
 * N is an integer within the range [1..100,000]; each element of array A is an integer within the range [−2,147,483,648..2,147,483,647]. Complexity:
 * 
 * expected worst-case time complexity is O(N); expected worst-case space complexity is O(N), 
 * beyond input storage (not counting the storage required for input arguments). Elements of input arrays can be modified.
 * 
 */

 

  • 0
    点赞
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值