演算法 陣列中出現次數最多的數字

目錄

陣列中出現次數最多的數字

給定一個int陣列，找出出現次數最多的數字（出現次數超過陣列長度的一半）

方式一：快速排序

先對這個陣列進行排序，在已排序的陣列中，位於中間位置的數字就是超過陣列長度一半的那個數。

public class Test {

    public static void main(String[] args) throws Exception {
        int[] array = { 1, 1, 1, 1, 5, 1, 5, 1, 5, 5, 5 };
        qsort(array);
        System.out.println(Arrays.toString(array));
    }

    public static void qsort(int[] arr) {
        qsort(arr, 0, arr.length - 1);
    }

    public static void qsort(int[] arr, int low, int high) {
        if (low < high) {
            int pivot = partition(arr, low, high);//將表一分為二
            qsort(arr, low, pivot);//對低子表【遞迴】排序
            qsort(arr, pivot + 1, high);//遞迴對高子表遞迴排序
        }
    }

    private static int partition(int[] arr, int low, int high) {
        int pivotkey = arr[low];//選擇一個【基準元素】，通常選擇第一個元素或者最後一個元素
        while (low < high) {//從表的兩端【交替】地向中間掃描
            //將比基準元素小的交換到低端
            while (low < high && arr[high] >= pivotkey) {
                high--;
            }
            swap(arr, low, high);
            //將比基準元素大的交換到高階
            while (low < high && arr[low] <= pivotkey) {
                low++;
            }
            swap(arr, low, high);
        }
        return low;//此時基準元素在其排好序後的正確位置
    }

    public static void swap(int[] arr, int i, int j) {
        if (i == j) return;
        int temp = arr[i];
        arr[i] = arr[j];
        arr[j] = temp;
    }
}
 

時間複雜度為 O(n*lgN)
空間複雜度為 O(n*lgN)

方式二：兩次迴圈

第一次迴圈是為了記錄各個數字出現的次數
第二次迴圈是為了比較各個數字出現的次數
這種方式沒有利用出現次數超過陣列長度的一半這個特殊條件，可以在任何陣列中找出出現次數最多的數字。

public class Test {

    public static void main(String[] args) throws Exception {
        int[] array = { 1, 1, 1, 1, 5, 1, 5, 1, 5, 5, 5 };
        System.out.println(mostNum(array));
    }

    public static int mostNum(int[] array) {
        HashMap<Integer, Integer> map = new HashMap<Integer, Integer>();
        for (int i = 0; i < array.length; i++) {
            int key = array[i];
            if (map.containsKey(key)) {
                map.replace(key, map.get(key) + 1);
            } else {
                map.put(key, 1);
            }
        }

        int key = array[0];
        for (Entry<Integer, Integer> entry : map.entrySet()) {
            if (entry.getValue() > map.get(key)) {
                key = entry.getKey();
            }
        }
        return key;
    }
}
 

時間複雜度為O(n)
空間複雜度為O(n)

方式三：一次迴圈

取巧的做法，僅當出現次數超過陣列長度的一半這種條件下才保證正確。

public class Test {

    public static void main(String[] args) throws Exception {
        int[] array = { 1, 1, 1, 1, 5, 1, 5, 1, 5, 5, 5 };
        System.out.println(mostNum(array));
    }

    public static int mostNum(int[] array) {
        int count = 1, value = array[0];

        for (int i = 1; i < array.length; i++) {
            if (array[i] == value) {
                count++; //如果下一個數字與之前儲存的數字相同，則次數加1
            } else {
                count--; //如果不同，則次數減1
            }
            if (count == 0) {
                value = array[i]; //如果次數為0，則需要儲存下一個數字，並把次數設定為1
                count = 1;
            }
        }
        return value;
    }
}

時間複雜度為O(n)
空間複雜度為O(1)

2018-12-8