2.3: Tìm phần tử trùng lặp

 

- Tìm phần tử trùng lặp trong mảng

- Đếm số lần

- Phần tử lặp nhiều nhất và nhiều thứ 2 

- Xóa bỏ các phần tử lặp ( xóa hết)

- Xóa bỏ các phần tử lặp (giữ lại mỗi phần tử một lần)

Dưới đây là mã java để thực hiện các yêu cầu :

import java.util.*;

public class ArrayDuplicateElements {
    // Phương thức tìm phần tử trùng lặp trong mảng
    public static Map<Integer, Integer> findDuplicates(int[] array) {
        Map<Integer, Integer> frequencyMap = new HashMap<>();
        for (int num : array) {
            frequencyMap.put(num, frequencyMap.getOrDefault(num, 0) + 1);
        }
        return frequencyMap;
    }

    // Phương thức đếm số lần xuất hiện của phần tử lặp nhiều nhất
    public static int maxFrequency(Map<Integer, Integer> frequencyMap) {
        int maxFrequency = 0;
        for (int frequency : frequencyMap.values()) {
            if (frequency > maxFrequency) {
                maxFrequency = frequency;
            }
        }
        return maxFrequency;
    }

    // Phương thức tìm phần tử lặp nhiều nhất
    public static List<Integer> mostFrequentElements(Map<Integer, Integer> frequencyMap) {
        List<Integer> mostFrequentElements = new ArrayList<>();
        int maxFrequency = maxFrequency(frequencyMap);
        for (Map.Entry<Integer, Integer> entry : frequencyMap.entrySet()) {
            if (entry.getValue() == maxFrequency) {
                mostFrequentElements.add(entry.getKey());
            }
        }
        return mostFrequentElements;
    }

    // Phương thức tìm phần tử lặp thứ hai nhiều nhất
    public static int secondMostFrequency(Map<Integer, Integer> frequencyMap) {
        int maxFrequency = maxFrequency(frequencyMap);
        int secondMaxFrequency = 0;
        for (int frequency : frequencyMap.values()) {
            if (frequency < maxFrequency && frequency > secondMaxFrequency) {
                secondMaxFrequency = frequency;
            }
        }
        return secondMaxFrequency;
    }

    // Phương thức xóa bỏ các phần tử lặp (xóa hết)
    public static int[] removeDuplicates(int[] array) {
        Map<Integer, Integer> frequencyMap = findDuplicates(array);
        List<Integer> nonDuplicates = new ArrayList<>();
        for (int num : array) {
            if (frequencyMap.get(num) == 1) {
                nonDuplicates.add(num);
            }
        }
        int[] result = new int[nonDuplicates.size()];
        for (int i = 0; i < nonDuplicates.size(); i++) {
            result[i] = nonDuplicates.get(i);
        }
        return result;
    }

    // Phương thức xóa bỏ các phần tử trùng lặp và giữ lại mỗi phần tử chỉ một lần
    public static int[] removeDuplicatesWithSet(int[] array) {
        Set<Integer> set = new HashSet<>();
        List<Integer> resultList = new ArrayList<>();
        
        for (int num : array) {
            if (!set.contains(num)) {
                resultList.add(num);
                set.add(num);
            }
        }
        
        // Chuyển đổi kết quả từ danh sách thành mảng
        int[] resultArray = new int[resultList.size()];
        for (int i = 0; i < resultList.size(); i++) {
            resultArray[i] = resultList.get(i);
        }
        
        return resultArray;
    }

    public static void main(String[] args) {
        int[] array = {1, 2, 3, 2, 4, 5, 3, 6, 7, 2, 3, 8, 9, 5, 2, 2};

        // Tìm phần tử trùng lặp trong mảng và đếm số lần xuất hiện
        Map<Integer, Integer> frequencyMap = findDuplicates(array);
        System.out.println("Phần tử trùng lặp và số lần xuất hiện:");
        for (Map.Entry<Integer, Integer> entry : frequencyMap.entrySet()) {
            System.out.println(entry.getKey() + ": " + entry.getValue() + " lần");
        }

        // Phần tử lặp nhiều nhất và số lần xuất hiện
        int maxFrequency = maxFrequency(frequencyMap);
        System.out.println("\nPhần tử lặp nhiều nhất:");
        for (Map.Entry<Integer, Integer> entry : frequencyMap.entrySet()) {
            if (entry.getValue() == maxFrequency) {
                System.out.println(entry.getKey() + " xuất hiện " + entry.getValue() + " lần");
            }
        }

        // Phần tử lặp thứ hai nhiều nhất
        int secondMaxFrequency = secondMostFrequency(frequencyMap);
        System.out.println("\nPhần tử lặp thứ hai nhiều nhất:");
        for (Map.Entry<Integer, Integer> entry : frequencyMap.entrySet()) {
            if (entry.getValue() == secondMaxFrequency) {
                System.out.println(entry.getKey() + " xuất hiện " + entry.getValue() + " lần");
            }
        }

        // Xóa bỏ các phần tử lặp (xóa hết)
        int[] nonDuplicates = removeDuplicates(array);
        System.out.println("\nMảng sau khi xóa bỏ các phần tử lặp:");
        System.out.println(Arrays.toString(nonDuplicates));

        // Xóa bỏ các phần tử trùng lặp và giữ lại mỗi phần tử chỉ một lần
        int[] nonDuplicates2 = removeDuplicatesWithSet(array);
        System.out.println("\nMảng sau khi xóa bỏ các phần tử trùng lặp và giữ lại mỗi phần tử chỉ một lần:");
        System.out.println(Arrays.toString(nonDuplicates2));
    }
}
}

.