Finding the smallest missing positive number in an array Any suggestions to improve?    

public class FindSmallestMissingPositive {
    public static void main(String args[]){
        int a[] = {3,5,4,-1,1,-1,0};
        System.out.println("Smallest Missing positive : "+ findSmPositive(a));
    }

    public static int findSmPositive(int input[]){
        int min = input[0];
        int max= input[0];

        HashSet&lt;Integer&gt; set = new HashSet&lt;Integer&gt;();

        for(int i=0;i&lt;input.length;i++){
            set.add(input[i]);

            if(input[i]&lt;min){
                min = input[i];
            }
            if(input[i]&gt;max){
                max = input[i];
            }
        }

        for(int i=min;i&lt;=max;i++){
            if(i&gt;0 &amp;&amp; !set.contains(i)){
                return i;
            }
            else continue;

        }
        return -1;
    }
}
Bugs

The implementation incorrectly gives -1 for all these input:


[0] should return 1
[1] should return 2
[2] should return 1
[0,2,2,1,1] should return 3
[1,2,2,1,3,1,0,4,0] should return 5


Improving the algorithm

The algorithm you used is \$O(n)\$ time and \$O(n)\$ space.
If you don't mind modifying the input array,
then you could reuse it as the storage,
making the algorithm \$O(1)\$ space.

Consider this alternative algorithm:


If the array is empty, return 1
Loop over the array indexes


While input[i] - 1 is a valid array index and not in the correct position, and input[input[i] - 1] is not in the correct position, then swap the elements i and input[i] - 1.

Loop over the array indexes again, and when you find a value not in the correct position, then return i + 1.
Return the last value + 1.


The logic behind this algorithm:


Swap elements into the correct position to get a sequence of positive integers 1, 2, 3, ...
Ignore values that cannot be in this array (&lt;= 0 or too high index)
The beginning of the array will be filled with correct sequence values, gaps will be filled with junk, and the second looping pass will short-circuit on the first incorrect value


Strange coding style

Although these type declarations compile, they are not recommended:


public static void main(String args[]) {

public static int findSmPositive(int input[]) {



The recommended writing style:

public static void main(String[] args) {

public static int findSmPositive(int[] input) {


Also,
the code formatting style is not great, at many places it's too compact.
I suggest to copy paste into an IDE like IntelliJ or Eclipse and use the auto-formatting function to reformat nicely.

Testing your improvements

The problem description seems to match this one on leetcode.
After you implement your improvements,
I suggest posting there to verify the correctness of your implementation.

https://leetcode.com/problems/first-missing-positive/