randnumber_mn.c 生成一个数组，包括k个不重复的整数，并且要求这些整数范围为[m,n)，生成的结果中不能包含inum中的数字，size表示inum的长度

#include <stdlib.h>
#include <memory.h>
#include <time.h>

//---------------------------------------------------------
//位操作
enum { BITSPERWORD = 32, SHIFT = 5, MASK = 0x1F };

struct tagBitOption;
typedef struct tagBitOption BitOption;

struct tagBitOption {
int (*init)(BitOption * bit, int m, int n, int k);
void (*destroy)(BitOption ** bit);

void (*set)(BitOption * bit, int i);
void (*clr)(BitOption * bit, int i);
int (*test)(BitOption * bit, int i);

int m, n, k, *x;
};

static void set(BitOption * bit, int i)
{
int t;
if (bit && (i >= bit->m) && (i < bit->n)) {
t = i - bit->m;
bit->x[t>>SHIFT] |= (1 << (t & MASK));
}
}

static void clr(BitOption * bit, int i)
{
int t;
if (bit && (i >= bit->m) && (i < bit->n)) {
t = i - bit->m;
bit->x[t>>SHIFT] &= ~(1 << (t & MASK));
}
}

static int test(BitOption * bit, int i)
{
int t;
if (bit && (i >= bit->m) && (i < bit->n)) {
t = i - bit->m;
return bit->x[t>>SHIFT] & (1 << (t & MASK));
}
return 1;//若i不在范围[m,n)，则认为i存在的，外面需要继续产生随机数
}

static int init(BitOption * bit, int m, int n, int k)
{
int s;
int ret = 0;
if (bit) {
bit->m = m;
bit->n = n;
bit->k = k;
s = (1 + (n - m)/BITSPERWORD) * sizeof(int);
bit->x = (int *)malloc(s);
if (bit->x) {
memset(bit->x, 0, s);
ret = 1;//成功
}
}
return ret;
}

static void destroy(BitOption ** bit)
{
if (bit) {
if (*bit) {
if ((*bit)->x)
free((*bit)->x);
free(*bit);
*bit = NULL;
}
}
}

//某些数字不能出现在随机数结果中，这里设置一下
static void setInvalidNumber(BitOption * bit, int * inum, int size)
{
if (bit && inum && size > 0) {
int i;
for (i = 0; i < size; i++) {
bit->set(bit, inum[i]);
}
}
}

static BitOption * createBitOption(int m, int n, int k)
{
BitOption * b = NULL;
b = (BitOption *)malloc(sizeof(BitOption));
if (b) {
memset(b, 0, sizeof(BitOption));
b->init = init;
b->destroy = destroy;
b->set = set;
b->clr = clr;
b->test = test;
if (!b->init(b, m, n, k))
b->destroy(&b);
}
return b;
}

//---------------------------------------------------------

//生成一个数组，包括k个不重复的整数，并且要求这些整数范围为[m,n)
//生成的结果中不能包含inum中的数字，size表示inum的长度
//m < n, k < n - m
int * RandNumberMN(int m, int n, int k, int * inum, int size)
{
int i,t;
int * result = NULL;
BitOption * bit = NULL;
int ok = 0;

do {
srand((int)time(NULL));
if (m >= n || k > n - m)
break;
bit = createBitOption(m, n, k);
if (NULL == bit)
break;
setInvalidNumber(bit, inum, size);
result = malloc(k * sizeof(int));
if (NULL == result)
break;
for (i = 0; i < k; i++) {
while(bit->test(bit, t = rand()%(n-m+1)+m));
result[i] = t;
bit->set(bit, t);
}
ok = 1;
} while (0);
if (bit)
bit->destroy(&bit);
if (1 != ok) {
if (result) {
free(result);
result = NULL;
}
}
return result;
}

//////////////////////////////////////////////////////////////////////////
//测试
#include <stdio.h>

void testRandMN(void)
{
time_t start, end;
int * result = NULL;
int m = 490, n = 540, k = 10;
int inum[] = {3, 90, 200, 305, 487, 503, 500, 501,502, 504};

printf("m = %d, n = %d, k = %d\n", m, n, k);

start = time(NULL);
result = RandNumberMN(m, n, k, inum, sizeof(inum)/sizeof(inum[0]));
end = time(NULL);
printf("time = %d\n\n", end - start);

if (result) {
printf("RandNumber success!\n");
if (k < 200) {//数量较小时，查看结果是否符合要求
int i;
for (i = 0; i < k; i++) {
printf("%d, ", result[i]);
}
printf("\n");
}
free(result);
result = NULL;
} else {
printf("RandNumber failed!\n\n");
}
}