Arrays.sort不填充陣列，並覆蓋已經陣列

我需要生成的隨機數，沒有重複的陣列int[] randomNumbers中值。要做到這一點，我列出了所有可以進入randomNumbers的值，然後使用隨機數生成器從列表中選取一個，檢查它是否已在randomNumbers中，如果不是，則將其放入randomNumbers。Arrays.sort不填充陣列，並覆蓋已經陣列

（我想數字1和max，而不是0和max-1之間）

爲了能夠使用Arrays.sort（INT []），列表中需要進行排序。所以，我使用的是第三組，與作爲randomNumbers稱爲sortedNumbers相同的值，並在每次迭代對其進行排序：

public int[] uniqueRandom(int max, int numRequired) { 
    if (max < numRequired) { 
     numRequired = max; 
    } 
    int[] randomNumbers = new int[numRequired]; 
    int[] sortedNumbers = new int[numRequired]; 
    int[] sequentialNumbers = new int[max]; 
    for (int i = 1; i < max; i++) { 
     sequentialNumbers[i] = i; 
      System.out.println(sequentialNumbers[i]); 
    } 

    int p = 0; 
    while (p < numRequired) { 
     int j = r.nextInt(max) + 1; 
     System.out.println("J:" + j); 
     if (Arrays.binarySearch(sortedNumbers, j) >= 0) { 
      System.out.println("Number Found:" + Arrays.binarySearch(randomNumbers, j)); 
     } else { 
      randomNumbers[p] = j; 
      sortedNumbers[p] = j; 
      Arrays.sort(sortedNumbers); 
      for (int i = 0; i < randomNumbers.length; i++) { 
       System.out.println("rNum[" + i + "]:" + randomNumbers[i]); 
      } 
      System.out.println("\n"); 
      for (int i = 0; i < randomNumbers.length; i++) { 
       System.out.println("sNum[" + i + "]:" + sortedNumbers[i]); 
      } 
      p++; 
     } 

    } 

    return randomNumbers; 
}

我的問題是，我得到的輸出，其中sortedNumbers被改寫值。對於uniqueRandom（5，5），輸出爲：

J:2 
rNum[0]:2 
rNum[1]:0 
rNum[2]:0 
rNum[3]:0 
rNum[4]:0 

sNum[0]:0 
sNum[1]:0 
sNum[2]:0 
sNum[3]:0 
sNum[4]:2 


J:2 // 2 already in the list, try again 


J:2 


J:4 
rNum[0]:2 
rNum[1]:4 
rNum[2]:0 
rNum[3]:0 
rNum[4]:0 

sNum[0]:0 
sNum[1]:0 
sNum[2]:0 
sNum[3]:2 
sNum[4]:4 


J:5 
rNum[0]:2 
rNum[1]:4 
rNum[2]:5 
rNum[3]:0 
rNum[4]:0 

sNum[0]:0 
sNum[1]:0 
sNum[2]:2 
sNum[3]:4 
sNum[4]:5 


J:2 


J:3 
rNum[0]:2 
rNum[1]:4 
rNum[2]:5 
rNum[3]:3 
rNum[4]:0 

sNum[0]:0 // Should be: 
sNum[1]:0 // 2 
sNum[2]:2 // 3 
sNum[3]:3 // 4 
sNum[4]:5 // 5 


J:4 
rNum[0]:2 
rNum[1]:4 
rNum[2]:5 
rNum[3]:3 
rNum[4]:4 

sNum[0]:0 
sNum[1]:0 
sNum[2]:2 
sNum[3]:3 
sNum[4]:4

所以你可以看到這個問題。我使用java 1.7，不知道爲什麼它這樣做！

來源

2012-10-25 GrumpyTechDude

@halex：不認爲這是必要的，因爲他不使用陣列的任何地方... –

解決你的問題，我會用一集，這保證我們有獨特的效果。

下面snipest將生成所需數量的唯一整數數組。

Set<Integer> uniqueNumbers = new HashSet<Integer>(); 
Random r = new Random(); 
while(uniqueNumbers.size() < numRequired) { 
    uniqueNumbers.add(r.nextInt(maxRandom) + 1); 
} 
return uniqueNumbers.toArray(new Integer[0]);

來源

2012-10-25 12:55:55

+1我冒昧地縮短了代碼。 ;） –

沒問題。 ;-)。 –

你把新的號碼到使用同一指數雙雙陣列。你的rNum數組是從上到下填充的，但排序後的數組不是：每次對它進行排序時，新值在數組中向下移動，零始終位於頂部。我想你可以通過始終把在排序數組的第一個位置上的新號碼修復：

sortedNumbers[0] = j;

來源

2012-10-25 12:53:56 jalynn2

是的，這將解決這個問題，因爲只有OP生成肯定的隨機數，並且沒有負數。 – jlordo

我預計排序後的數組也會自上而下填充，這就是爲什麼索引是相同的，謝謝！ – GrumpyTechDude

當輸入J = 5

的sortedNUm []是

sNum[0]:0 
sNum[1]:0 
sNum[2]:2 
sNum[3]:4 
sNum[4]:5

下，當你輸入J = 3（您的P = 3）後

sortedNumbers[p] = j;

您SNUM [3]，這是4由3 代替分類後因此變得

sNum[0]:0 // Should be: 
sNum[1]:0 // 2 
sNum[2]:2 // 3 
sNum[3]:3 // 4 
sNum[4]:5 // 5

通知4不存在

我建議你數組初始化爲-1或0，並在陣列開始添加變量，如

sortedNumbers[0]=j;

和Arrays.sort後（）;第一個位置將永遠爲空添加更多數字

來源

2012-10-25 12:59:19

儘管它沒有回答這個問題，但這裏有一個替代方案，即O(n)，並且提供的工作良好max並不大。

public static void main(String[] args) { 
    System.out.println(Arrays.toString(uniqueRandom(20, 10))); 
} 

public static int[] uniqueRandom(int max, int numRequired) { 
    int[] possible = new int[max]; 
    int[] ret = new int[numRequired]; 
    for (int i = 0; i < max; i++) 
     possible[i] = i + 1; 
    Random r = new Random(); 
    int numLeft = max; 
    for (int i = 0; i < numRequired; i++) { 
     int idx = r.nextInt(numLeft); 
     ret[i] = possible[idx]; 
     if (idx < --numLeft) 
      possible[idx] = possible[numLeft]; 
    } 
    return ret; 
}

打印

[4, 10, 12, 19, 8, 3, 15, 1, 14, 7]

我想說的是，也許你可以使它更簡單。

來源

2012-10-25 13:11:23

有你的代碼的幾個問題：

因爲你只當新的號j不已經在陣列中存在，即，結合你排序sortedArray的事實增加p首先導致實際上被置於有時在現有值的值（移動位置，由於排序）
我不明白什麼用的sequentialNumbers陣列的......

這裏是應該的示例：

private static Random r = new Random(); 

public static void main(String[] args) { 
    System.out.println(Arrays.toString(uniqueRandom(10, 10))); 
} 

public static int[] uniqueRandom(int max, int numRequired) { 
    if (max < numRequired) { 
     numRequired = max; 
    } 
    int[] randomNumbers = new int[numRequired]; 
    int[] sortedNumbers = new int[numRequired]; 
    Arrays.sort(sortedNumbers); 

    int p = 0; 

    while (p < numRequired) { 
     int j = r.nextInt(max) + 1;   
     if(Arrays.binarySearch(sortedNumbers, j)<0) { 
      randomNumbers[p] = j; 
      System.arraycopy(randomNumbers, 0, sortedNumbers, 0, randomNumbers.length); 
      Arrays.sort(sortedNumbers); 
      p++; 
     }   
    } 

    return randomNumbers; 
}

來源

2012-10-25 13:18:10

Arrays.sort不填充陣列，並覆蓋已經陣列

回答

相關問題