Check if two arrays are permutations of each other

// A Java program to find one array is permutation of other array
import java.util.HashMap;

class Permutations
{
    // Returns true if arr1[] and arr2[] are permutations of each other
    static Boolean arePermutations(int arr1[], int arr2[])
    {
        // Arrays cannot be permutations of one another unless they are 
        // of the same length
        if (arr1.length != arr2.length)
            return false;
      
        // Creates an empty hashMap hM
        HashMap<Integer, Integer> hM = new HashMap<Integer, Integer>();

        // Traverse through the first array and add elements to hash map
        for (int i = 0; i < arr1.length; i++)
        {
            int x = arr1[i];
            if (hM.get(x) == null)
                hM.put(x, 1);
            else
            {
                int k = hM.get(x);
                hM.put(x, k+1);
            }
        }

        // Traverse through second array and check if every element is
        // present in hash map
        for (int i = 0; i < arr2.length; i++)
        {
            int x = arr2[i];

            // If element is not present in hash map or element
            // is not present less number of times
            if (hM.get(x) == null || hM.get(x) == 0)
                return false;

            int k = hM.get(x);
            hM.put(x, k-1);
        }
        return true;
    }

    // Driver function to test above function
    public static void main(String arg[])
    {
        int arr1[] = {2, 1, 3, 5, 4, 3, 2};
        int arr2[] = {3, 2, 2, 4, 5, 3, 1};
        if (arePermutations(arr1, arr2))
            System.out.println("Arrays are permutations of each other");
        else
            System.out.println("Arrays are NOT permutations of each other");
    }
}

import java.util.Arrays;

public class PermutationChecker {
    public static boolean arePermutations(int[] arr1, int[] arr2, int n, int m) {
        // Arrays cannot be permutations of one another unless they are
        // of the same length
        if (n != m) {
            return false;
        }

        // Sort both arrays
        Arrays.sort(arr1);
        Arrays.sort(arr2);

        // Compare each element of both arrays
        for (int i = 0; i < n; i++) {
            if (arr1[i] != arr2[i]) {
                return false;
            }
        }

        return true;
    }

    public static void main(String[] args) {
        int[] arr1 = {2, 1, 3, 5, 4, 3, 2};
        int[] arr2 = {3, 2, 2, 4, 5, 3, 1};
        int n = arr1.length;
        int m = arr2.length;

        if (arePermutations(arr1, arr2, n, m)) {
            System.out.println("Arrays are permutations of each other");
        } else {
            System.out.println("Arrays are NOT permutations of each other");
        }
    }
}

import java.util.ArrayList;
import java.util.List;

public class GFG {

    // Helper function to perform DFS
    private static boolean dfs(List<Integer> arr1, List<Integer> arr2, 
                               boolean[] visited, int index) {
        // Base case: All elements have been visited
        if (index == arr1.size()) {
            return true;
        }

        // Check if the current element in arr1 has a 
       // corresponding element in arr2
        int num = arr1.get(index);
        for (int i = 0; i < arr2.size(); i++) {
            if (!visited[i] && arr2.get(i) == num) {
                visited[i] = true;
                if (dfs(arr1, arr2, visited, index + 1)) {
                    return true;
                }
                visited[i] = false; // Backtrack
            }
        }

        return false;
    }

    // Returns true if arr1[] and arr2[] are permutations of 
   // each other
    private static boolean arePermutations(List<Integer> arr1, 
                                           List<Integer> arr2) {
        int n = arr1.size();
        int m = arr2.size();

        // Arrays cannot be permutations of one another 
       // unless they are of the same length
        if (n != m) {
            return false;
        }

        // Initialize a visited array to keep track of used 
       // elements in arr2
        boolean[] visited = new boolean[m];

        // Perform DFS to check for permutations
        return dfs(arr1, arr2, visited, 0);
    }

    // Driver function to test above function
    public static void main(String[] args) {
        List<Integer> arr1 = new ArrayList<>();
        arr1.add(2);
        arr1.add(1);
        arr1.add(3);
        arr1.add(5);
        arr1.add(4);
        arr1.add(3);
        arr1.add(2);

        List<Integer> arr2 = new ArrayList<>();
        arr2.add(3);
        arr2.add(2);
        arr2.add(2);
        arr2.add(4);
        arr2.add(5);
        arr2.add(3);
        arr2.add(1);

        if (arePermutations(arr1, arr2)) {
            System.out.println("Arrays are permutations of each other");
        } else {
            System.out.println("Arrays are NOT permutations of each other");
        }
    }
}