算法筆記_036:預排序（Java）

目錄

1 問題描述

2 解決方案

2.1 檢驗數組中元素的唯一性

2.2 模式計算

 

---

1 問題描述

在計算機科學中，預排序是一種很古老的思想。實際上，對於排序算法的興趣很大程度上是因為這樣一個事實：如果列表是有序的，許多關於列表的問題更容易求解。顯然，對於包含了排序操作，這種算法的時間效率依賴於所選用的排序算法的效率。

對於預排序的具體思想應用請參考下文。

 

 

---

2 解決方案

2.1 檢驗數組中元素的唯一性

此問題，首先使用合並排序對數組中元素進行一次從小到大的排序，然后，依次檢查數組中的元素，看是否有重復元素，如果有這說明該元素不具有唯一性，否則說明該數組中的所有元素具有元素的唯一性。

具體代碼如下：

package com.liuzhen.chapter6;

public class PresortElementUniqueness {
    //歸並排序
    public void mergeSort(int[] A){
        if(A.length > 1){
            int[] leftA = getHalfArray(A,0);   //數組A的左半部分
            int[] rightA = getHalfArray(A,1);  //數組A的右半部分
            mergeSort(leftA);
            mergeSort(rightA);
            getMerge(A,leftA,rightA);
        }
    }
    
    /*
     * 參數A：要進行折半的數組
     * 參數judge:judge == 0表示返回數組A左上半部分，judge != 0表示返回數組A的右半部分
     * 函數功能：把數組按照長度均分為上半部分和下半部分
     */
    public int[] getHalfArray(int[] A,int judge){
        int[] result;
        if(judge == 0){
            result = new int[A.length/2];
            for(int i = 0;i < A.length/2;i++)
                result[i] = A[i];
        }
        else{
            result = new int[A.length - A.length/2];
            for(int i = 0;i < A.length - A.length/2;i++)
                result[i] = A[i+A.length/2];
        }
        return result;
    }
    /*
     *參數A：給定待排序數組
     *參數leftA:數組A的左半部分
     *參數rightA:數組的右半部分
     *函數功能：返回數組A的從小到大排序
     */
    public void getMerge(int[] A,int[] leftA,int[] rightA){
        int i = 0;       //用於計算當前遍歷leftA的元素個數
        int j = 0;       //用於計算當前遍歷rightA的元素個數
        int count = 0;   //用於計算當前得到按從小到大排序的A的元素個數
        while(i < leftA.length && j < rightA.length){
            if(leftA[i] < rightA[j]){
                A[count++] = leftA[i];
                i++;
            }
            else{
                A[count++] = rightA[j];
                j++;
            }
        }
        if(i < leftA.length){
            while(i < leftA.length)
                A[count++] = leftA[i++];
        }
        if(j < rightA.length){
            while(j < rightA.length)
                A[count++] = rightA[j++];
        }
    }
    //判斷數組A（PS:數組A已是有序數組）中元素是否具有唯一性
    public boolean judgeOnlyElement(int[] A){
        for(int i = 0;i < A.length-1;i++){
            if(A[i] == A[i+1])
                return false;
        }
        return true;
    }
    
    public static void main(String[] args){
        PresortElementUniqueness test = new PresortElementUniqueness();
        int[] A = {3,2,1,8,7,4,3,6,1,7,3,3,7,7,7,7};
        test.mergeSort(A);
        System.out.println("使用歸並排序后數組A的結果：");
        for(int i = 0;i < A.length;i++)
            System.out.print(A[i]+" ");
        if(test.judgeOnlyElement(A))
            System.out.println("\n數組A中的元素具有唯一性");
        else
            System.out.println("\n數組A中的元素不具有唯一性");
        int[] B = {9,8,7,6,5,4,3,2,1};
        test.mergeSort(B);
        System.out.println("使用歸並排序后數組B的結果：");
        for(int i = 0;i < B.length;i++)
            System.out.print(B[i]+" ");
        if(test.judgeOnlyElement(B))
            System.out.println("\n數組B中的元素具有唯一性");
        else
            System.out.println("\n數組B中的元素不具有唯一性");
    }
}

運算結果：

使用歸並排序后數組A的結果：
1 1 2 3 3 3 3 4 6 7 7 7 7 7 7 8 
數組A中的元素不具有唯一性
使用歸並排序后數組B的結果：
1 2 3 4 5 6 7 8 9 
數組B中的元素具有唯一性

 

2.2 模式計算

在給定的數組列表中最經常出現的一個數值稱為模式。例如，對於5,1,5,7,6,5,7來說，模式是5（如果若干個不同的值都是最經常出現的，它們中的任何一個都可以看作模式。）

此處，首先對給定數組中元素使用合並排序進行從小到大排序，然后，依次遍歷其中的元素，計算其中重復元素的最大個數，返回該元素的值，即為所求的模式。

具體代碼如下：

package com.liuzhen.chapter6;

public class PresortElementUniqueness {
    //歸並排序
    public void mergeSort(int[] A){
        if(A.length > 1){
            int[] leftA = getHalfArray(A,0);   //數組A的左半部分
            int[] rightA = getHalfArray(A,1);  //數組A的右半部分
            mergeSort(leftA);
            mergeSort(rightA);
            getMerge(A,leftA,rightA);
        }
    }
    
    /*
     * 參數A：要進行折半的數組
     * 參數judge:judge == 0表示返回數組A左上半部分，judge != 0表示返回數組A的右半部分
     * 函數功能：把數組按照長度均分為上半部分和下半部分
     */
    public int[] getHalfArray(int[] A,int judge){
        int[] result;
        if(judge == 0){
            result = new int[A.length/2];
            for(int i = 0;i < A.length/2;i++)
                result[i] = A[i];
        }
        else{
            result = new int[A.length - A.length/2];
            for(int i = 0;i < A.length - A.length/2;i++)
                result[i] = A[i+A.length/2];
        }
        return result;
    }
    /*
     *參數A：給定待排序數組
     *參數leftA:數組A的左半部分
     *參數rightA:數組的右半部分
     *函數功能：返回數組A的從小到大排序
     */
    public void getMerge(int[] A,int[] leftA,int[] rightA){
        int i = 0;       //用於計算當前遍歷leftA的元素個數
        int j = 0;       //用於計算當前遍歷rightA的元素個數
        int count = 0;   //用於計算當前得到按從小到大排序的A的元素個數
        while(i < leftA.length && j < rightA.length){
            if(leftA[i] < rightA[j]){
                A[count++] = leftA[i];
                i++;
            }
            else{
                A[count++] = rightA[j];
                j++;
            }
        }
        if(i < leftA.length){
            while(i < leftA.length)
                A[count++] = leftA[i++];
        }
        if(j < rightA.length){
            while(j < rightA.length)
                A[count++] = rightA[j++];
        }
    }
    
    //返回數組A（PS：數組A是有序數組）中模式
    public int presortMode(int[] A){
        int i = 0;
        int modeFrequency = 0;
        int modeValue = 0;
        while(i < A.length){
            int temp = i;
            int count = 0;
            while(temp < A.length && A[temp] == A[i]){
                count++;
                temp++;
            }
            if(count > modeFrequency){
                modeFrequency = count;
                modeValue = A[i];
            }
            i = i+count;
        }
        return modeValue;
    }
    public static void main(String[] args){
        PresortElementUniqueness test = new PresortElementUniqueness();
        int[] A = {3,2,1,8,7,4,3,6,1,7,3,3,7,7,7,7};
        test.mergeSort(A);
        System.out.println("使用歸並排序后數組A的結果：");
        for(int i = 0;i < A.length;i++)
            System.out.print(A[i]+" ");
        System.out.println("\n數組A中模式為："+test.presortMode(A));
        int[] B = {9,8,7,6,5,4,3,2,1};
        test.mergeSort(B);
        System.out.println("使用歸並排序后數組B的結果：");
        for(int i = 0;i < B.length;i++)
            System.out.print(B[i]+" ");
        System.out.println("\n數組B中模式為："+test.presortMode(B));
    }
} 

運算結果：

使用歸並排序后數組A的結果：
1 1 2 3 3 3 3 4 6 7 7 7 7 7 7 8 
數組A中模式為：7
使用歸並排序后數組B的結果：
1 2 3 4 5 6 7 8 9 
數組B中模式為：1