Permutations Java

Given a collection of numbers, return all possible permutations.

For example,
[1,2,3] have the following permutations:

[1,2,3], [1,3,2], [2,1,3], [2,3,1], [3,1,2], and [3,2,1].

Two Approach: 

 Solution_1: Recursion+DFS.
    Idea:
    To be clear, the permutation problem is belong to NP problem which means
    the time complexity is will not consider to be polynomial time
    Solve by method of recursion:
    1.Define a new array "visited[num.length]" to keep track the which element of
    the original array has been visited, thus to ensure only the remaining elements
    will be processed.
    Ex: array[0]=1, then set visited[0]=true, so there are only 2,3 can be
    process for array[1];
    2.remove the last elements from the array, and resume the visited flag in order
    to process next possible permutation.
    Ex: we have [1,2,3], remove element on index 2, As a result, array will be
    [1,2] and visited[2]=false => will be un-flag.

public class Solution {
    public ArrayList<ArrayList<Integer>> permute(int[] num) {
     ArrayList<ArrayList<Integer>> result=new ArrayList<ArrayList<Integer>>();
        if(num.length==0) return result;
        helperDFS(num, new boolean[num.length],result,new ArrayList<Integer>());
        return result;

    }
    private static void helperDFS(int[] num,boolean[] visited,ArrayList<ArrayList<Integer>> result, ArrayList<Integer> sub){
        //new permutation was found
        if(num.length==sub.size()){
            result.add(new ArrayList<Integer>(sub));
            return;
        }
        for(int i=0;i<num.length;i++){
            if(visited[i]==false){
                //flag num[i] has been visited
                visited[i]=true;
                sub.add(num[i]);
                helperDFS(num,visited,result,sub);
                //remove the last number after completed a permutation
                sub.remove(sub.size()-1);
                visited[i]=false;
            }
        }
    }
}