碼上快樂

相關內容    簡體    繁體

java實現 數組中兩個元素相加等於指定數的所有組合

本文轉載自   查看原文   2014-03-25 17:59   2550 
 
    1. package com.algorithm.hash;  
    2.   
    3. public class alg1 {  
    4.     public static void main(String argv[]) {  
    5.         int[] array1 = {10,2,7,4,5,6,3,8,9,1};  
    6.         int[] array2 = {1,2,3,4,5,6,7,8,9,10};  
    7.         int[] array3 = {1,2,3,4,5,6,7,8,9,10};  
    8.         alg1.execute1(array1, 8);  
    9.         alg1.execute2(array2, 8);  
    10.         alg1.execute3(array3, 8);  
    11.     }  
    12.       
    13.     //思路：使用hash表存儲數組各元素是否存在的標志，然后遍歷數組，判斷sum與當前數組元素的差值是否在hash表中,  
    14.     //若為真則打印，該算法不要求數組有序，但要求一個hash數組的額外空間，時間復雜度是O(n)  
    15.     private static void execute1(int[] array, int m) {  
    16.         int size = array.length;  
    17.         int hash[] = new int[size];  
    18.         for(int i = 0; i < size; i++) {  
    19.             hash[array[i]%size] = 1;  
    20.         }  
    21.           
    22.         for(int i = 0; i < size; i++) {  
    23.             int tmp = m - array[i];  
    24.             if((tmp > array[i]) && (hash[tmp%size] == 1)){  
    25.                 System.out.println(array[i] + " " + tmp);  
    26.             }  
    27.         }  
    28.     }  
    29.       
    30.     //思路：該方法的前提是要求數組是有序的，然后再遍歷數組，判斷sum與數組元素的差值是否在數組中，由於數組有序所以可以采用二分查找的方法  
    31.     //二分查找的時間復雜度為O(logn),排序的時間復雜度是O(nlogn),查找n次，總的時間復雜度為O(nlogn)，避免了空間的浪費  
    32.     private static void execute2(int[] array, int m) {  
    33.         for(int i = 0; i < array.length; i++) {  
    34.             int tmp = m - array[i];  
    35.             if (tmp > array[i]) {  
    36.                 if (binarySearch(array, tmp) != -1) {  
    37.                     System.out.println(array[i] + " " + tmp);  
    38.                 }  
    39.             }  
    40.         }  
    41.     }  
    42.     private static int binarySearch(int[] array, int key) {  
    43.         if (array.length == 0) {  
    44.             return -1;  
    45.         }  
    46.           
    47.         int first = 0;  
    48.         int last = array.length -1;  
    49.           
    50.         int mid;  
    51.         while(first <= last) {  
    52.             mid = (first + last) / 2;  
    53.             if (array[mid] == key) {  
    54.                 return mid;  
    55.             } else if (array[mid] < key) {  
    56.                 first = mid + 1;  
    57.             } else {  
    58.                 last = mid -1;  
    59.             }  
    60.         }  
    61.         return -1;  
    62.     }  
    63.       
    64.     //思路：該方法的前提是要求數組是有序的，使用兩個指針，分別指向最后一個元素和第一個元素，判斷它們的和是否等於sum，若等於則打印，並且first向前移動，last也向前移動  
    65.     //若它們的和小於sum，則說明first太小了，需要first向前移動，若它們的和大於sum，則說明last太大了，需要last向前移動，直到last>=first  
    66.     private static void execute3(int[] array, int m) {  
    67.         int first = 0;  
    68.         int last = array.length -1;  
    69.         int sum = 0;  
    70.         while(first < last ) {  
    71.             sum = array[first] + array[last];  
    72.             if (sum == m) {  
    73.                 System.out.println(array[first] + " " + array[last]);  
    74.                 first++;  
    75.                 last--;  
    76.             } else if (sum < m) {  
    77.                 first++;  
    78.             } else {  
    79.                 last--;  
    80.             }  
    81.         }  
    82.     }  
    83.      


免責聲明！

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



猜您在找 [面試題]設計一個算法找到數組中兩個元素相加等於指定數的所有組合 js 數組中尋找兩個值相加等於目標值， 三個值相加等於目標值 Java 集合、數組 任意個數數字相加等於一個指定的數 從數組中取出n個元素的所有組合（遞歸實現） Java中如何把兩個數組合並為一個 算法-找出數組中兩個元素之和等於給定的目標值 java 兩個數組合並 2020-07-18：給定一個無序數組和一個目標值，找出數組中兩個數之和等於目標值的所有組合，並指出其時間復雜度。 實現一個函數， // 判斷一個給定整數數組中是否存在某兩個元素之和恰好等於一個給定值 k， // 存在則返回 true，否則返回 false。 利用下標輸出指定數組中的元素
 
粵ICP備18138465號   © 2018-2025 CODEPRJ.COM