如何高效地判斷數組中是否包含某特定值


        如何檢查一個未排序的數組中是否包含某個特定值,這是一個在Java中非常實用並且頻繁使用的操作。檢查數組中是否包含特定值可以用多種不同的方式實現,但是時間復雜度差別很大。下面,將為大家展示各種方法及其需要花費的時間。

 

1.檢查數組中是否包含特定值的四種不同方法

1)使用List:

1

2

3

public static boolean useList(String[] arr, String targetValue) {

    return Arrays.asList(arr).contains(targetValue);

}

2)使用Set:

1

2

3

4

public static boolean useSet(String[] arr, String targetValue) {

    Set<String> set = new HashSet<String>(Arrays.asList(arr));

    return set.contains(targetValue);

}

3)使用一個簡單循環:

1

2

3

4

5

6

7

public static boolean useLoop(String[] arr, String targetValue) {

    for(String s: arr){

        if(s.equals(targetValue))

            return true;

    }

    return false;

}

4)使用Arrays.binarySearch():

注:下面的代碼是錯誤的,這樣寫出來僅僅為了理解方便。binarySearch()只能用於已排好序的數組中。所以,你會發現下面結果很奇怪。

1

2

3

4

5

6

7

public static boolean useArraysBinarySearch(String[] arr, String targetValue) {

    int a =  Arrays.binarySearch(arr, targetValue);

    if(a > 0)

        return true;

    else

        return false;

}

2.時間復雜度

通過下面的這段代碼可以近似比較幾個方法的時間復雜度。雖然分別搜索一個大小為5、1K、10K的數組是不夠精確的,但是思路是清晰的。

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

22

23

24

25

26

27

28

29

30

31

32

33

34

35

36

37

38

39

public static void main(String[] args) {

    String[] arr = new String[] {  "CD",  "BC", "EF", "DE", "AB"};

  

    //use list

    long startTime = System.nanoTime();

    for (int i = 0; i < 100000; i++) {

        useList(arr, "A");

    }

    long endTime = System.nanoTime();

    long duration = endTime - startTime;

    System.out.println("useList:  " + duration / 1000000);

  

    //use set

    startTime = System.nanoTime();

    for (int i = 0; i < 100000; i++) {

        useSet(arr, "A");

    }

    endTime = System.nanoTime();

    duration = endTime - startTime;

    System.out.println("useSet:  " + duration / 1000000);

  

    //use loop

    startTime = System.nanoTime();

    for (int i = 0; i < 100000; i++) {

        useLoop(arr, "A");

    }

    endTime = System.nanoTime();

    duration = endTime - startTime;

    System.out.println("useLoop:  " + duration / 1000000);

  

    //use Arrays.binarySearch()

    startTime = System.nanoTime();

    for (int i = 0; i < 100000; i++) {

        useArraysBinarySearch(arr, "A");

    }

    endTime = System.nanoTime();

    duration = endTime - startTime;

    System.out.println("useArrayBinary:  " + duration / 1000000);

}

結果:

1

2

3

4

useList:  13

useSet:  72

useLoop:  5

useArraysBinarySearch:  9

對於長度為1K的數組:

1

2

3

4

5

6

String[] arr = new String[1000];

  

Random s = new Random();

for(int i=0; i< 1000; i++){

    arr[i] = String.valueOf(s.nextInt());

}

結果:

1

2

3

4

useList:  112

useSet:  2055

useLoop:  99

useArrayBinary:  12

對於長度為10K的數組:

1

2

3

4

5

6

String[] arr = new String[10000];

  

Random s = new Random();

for(int i=0; i< 10000; i++){

    arr[i] = String.valueOf(s.nextInt());

}

結果:

1

2

3

4

useList:  1590

useSet:  23819

useLoop:  1526

useArrayBinary:  12

 

        很明顯,使用簡單循環的方法比使用其他任何集合效率更高。許多開發者會使用第一種方法,但是它並不是高效的。將數組壓入Collection類型中,需要首先將數組元素遍歷一遍,然后再使用集合類做其他操作。       

  如果使用Arrays.binarySearch()方法,數組必須是已排序的。由於上面的數組並沒有進行排序,所以該方法不可使用。實際上,如果你需要借助數組或者集合類高效地檢查數組中是否包含特定值,一個已排序的列表或樹可以做到時間復雜度為O(log(n)),hashset可以達到O(1)。

————————————————

本篇文章同步在個人公眾號:

 


免責聲明!

本站轉載的文章為個人學習借鑒使用,本站對版權不負任何法律責任。如果侵犯了您的隱私權益,請聯系本站郵箱yoyou2525@163.com刪除。



 
粵ICP備18138465號   © 2018-2025 CODEPRJ.COM