java-生成无重随机序列

最近需要做个无重随机序列，无奈小弟不给力，在网上找了半天，找到一个还是效率不高，后来我提供了算法思路——完全剩余系，无奈小弟能力有限无法实现，最终还是得自己忙里抽空自己写了一个。后来发现效率还可以，特发出来请大家指点一下~

package new2.com.other;

import java.util.ArrayList;
import java.util.Random;

/**
 * 生成一个整型无重随机序列，无参构造使用数组序列生成，有参构造使用完全剩余系定理（效率高，包含生成质数序列）
 */
public class UniqueRandom {
	int maxValue;
	ArrayList<Integer> prime_num = new ArrayList<Integer>();// 质数序列用于查找\判断质数用
	Random rd = new Random();
	boolean isPrimeModel = false;

	UniqueRandom() {
	}

	UniqueRandom(int maxValue) {
		this.maxValue = maxValue + 1;
		createPrimeList();
		isPrimeModel = true;
		// for(Integer pm:prime_num)System.out.print(pm+",");
	}

	private int sqrt(int value) {
		return (int) Math.ceil(Math.sqrt(new Integer(value).doubleValue()));
	}

	private void createPrimeList() {
		prime_num.add(2);
		prime_num.add(3);
		if (maxValue < 5)
			return;
		for (int i = 5; i < maxValue; i = i + 2) {
			int sqrt = sqrt(i);
			boolean isPrime = true;
			for (Integer pm : prime_num) {
				if (!isPrime || pm > sqrt)
					break;
				isPrime = i % pm != 0;
			}
			if (isPrime)
				prime_num.add(i);
		}
	}

	private int primeNumWith(int size) {
		while (true) {
			int pn = prime_num.get(rd.nextInt(prime_num.size()));// 随机点2
			if (pn < size && size % pn == 0)
				continue;
			return pn;
		}
	}

	public int[] randomList(int count, int size) {
		int[] result = new int[count];
		if (isPrimeModel) {
			if (size >= maxValue) {
				System.out.println("size Out of range! The maxValue is:"
						+ maxValue);
				return null;
			}
			int rdn_prm_num_for_size = primeNumWith(size);
			int initpos = (size == count) ? 0 : rd.nextInt(size - count);// 随机点1
			for (int i = 0; i < count; i++)
				result[i] = (int) ((initpos + i) * (long) rdn_prm_num_for_size % size);
		} else {
			return getRandomSequence2(size, count);
		}
		return result;
	}

	private int[] getRandomSequence2(int maxNum, int arrSize) {
		int[] sequence = new int[maxNum];
		for (int i = 0; i < maxNum; i++)
			sequence[i] = i;
		int[] output = new int[arrSize];
		int end = maxNum - 1;
		for (int i = 0; i < arrSize; i++) {
			int num = rd.nextInt(end + 1);
			output[i] = sequence[num];
			sequence[num] = sequence[end];
			end--;
		}
		return output;
	}

	
	public static void main(String[] args) {
		int rate = 1000;
		int MAX = 1000 * rate;
		int SIZE = 1000 * rate;
		int NEED = 1000 * rate;
		UniqueRandom ur = new UniqueRandom(MAX);
		long start = System.nanoTime();
		int[] result = ur.randomList(NEED, SIZE);
		System.out.println(System.nanoTime() - start);
		 for(int i:result)
			 System.out.print(i+",");
	}

}

 

其中整合了小弟在网上找的算法——利用数组，个人感觉还不错，特别一同整合进去了。

个人的算法思路就是利用完全剩余系定理。其中生成小于N的质数序列比较费时，建议使用的时候预先初始化一下~质数序列其实用处就是为了做一个互质的数而已……O(∩_∩)O~

个人算法方面其实挺弱的，还请各位大牛指点，再优化一下，多谢~~

 

可以和之前的博客比较一下：http://lfl2011.iteye.com/blog/1523862

原文:http://my.oschina.net/alvinte/blog/111225