随机数啊随机数

问题：
1. 随机生成一个随机数
2. 随机生成十个不同的随机数
3. 将以上生成的随机数，随机放在一个数组中20个不同的位置
4. 找到这十个随机数在数组中最邻近的空位置
5. 将十个随机数分别移动到最邻近的空位置

PS：在生成十个不同的随机数时，判断随机数重复与否的方法，我的这个效率并不高。

欢迎各位批评指正^_^

代码:

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

#define NUM 10
#define COUNT 20
#define MAX 1000//生成的随机数均在0-（MAX-1）之间

int array[NUM];     //存放十个不同的随机数    的数组
int location[NUM];  //存放十个不同随机数的不同的随机位置(0-COUNT)    的数组
int space[COUNT];   //在space数组中随机找到10个位置，来存放10个不同的随机数

void printArray(int array[], int num) {//打印数组前num个元素
    for (int i = 0; i < num; i++)
        printf("%d\t", array[i]);
}
void initialArray(int array[], int num1, int num2) {//把数组的前num1个元素初始化为num2
    for (int i = 0; i < num1; i++)
        array[i] = num2;
}
void copyArray(int location[], int lable[], int num) {//把location数组的前num个元素复制到lable中 
    for (int i = 0; i < num; i++)
        lable[i] = location[i];
}
int randomNumber(int max) {//生成0--(max-1)的随机数;;一般来讲，随机数生成范围是0-2^15-1
    srand((unsigned)time(NULL));
    return rand() % max;
}
bool findSame(int array[], int a) {//使数组array中没有与array[a]相等的数；如果有相同的就再生成随机数，直到没有
    for (int i = 0; i < a; i++)
        if (array[i] == array[a]) {
            return false;
        }
    return true;
}
void creatRanArray(int array[], int num, int max) {//产生NUM个不同的随机数，放入array[]中，最大值为max-1，
    for (int i = 0; i < num; i++) {
        array[i] = randomNumber(max);
        bool b = !findSame(array, i);
        while (b) {//有重复 ,,没有的话，就不执行 
            array[i] = randomNumber(max);//再随机生成一个 
            b = !findSame(array, i);//检测，，，，直到没有重复 
        }
    }
}
void ranSpace(int space[], int count, int num1, int num2) {//space空间大小为count，生成num1个不同的随机数（最大为MAX-1），随机放入space[COUNT]中num2个不同的位置
                                                           //   initialArray(space, count,-1);//把space数组每个位置初始为-1，用以表示此位置为空。
                                                           //   creatRanArray(array,num1,MAX);//array数组，总数NUM，最大值MAX-1
    creatRanArray(location, num2, count);//location数组中的值最大为19，总个数为NUM
    for (int i = 0; i < num1; i++)
        space[location[i]] = array[i];
}
void nearLocation(int location[]) {//找出每个随机数最邻近的空位置
                                   //initialArray(space, -1);//把space数组每个位置初始为-1，用以表示此位置为空。
                                   //ranSpace(space, COUNT);
    int memory[NUM];//记忆每个随机数最邻近的空位置
    int step[NUM];//每个元素向左或右离最邻近的位置的距离 
    initialArray(step, NUM, 21);//将每个元素离最邻近位置的距离初始为21,因为不可能有个元素最邻近的空位置 为21 
    initialArray(memory, NUM, -1); //将每个元素最邻近位置初始为-1
    for (int i = 0; i < NUM; i++) {
        int temp = location[i];//第一个元素的位置 
                               //if((temp == 0 && space[location[i] + 1] != -1) || (temp == 19 && space[location[i] - 1] != -1))  
                               //因为找最近，当其为边界（such as 0）时，左边没有还有右边 

                               //优先左侧空位置 
        for (temp--; temp >= 0 && space[temp] != -1; temp--);//第i个元素由其位置location[i]开始，向左寻找其最邻近位置，找到就保保存 
        if (temp >= 0) {//得考虑，不然第0个元素就会出错 
            step[i] = location[i] - temp;
            memory[i] = temp;
        }
        if (step[i] > 1)//如果距离为1，就已经找到最近的位置了，没必要继续向右寻找 
        {
            temp = location[i];
            for (temp++; temp < COUNT && space[temp] != -1; temp++);
            if (temp < COUNT && temp - location[i] < step[i])//右边最近距离比左边小，就用右边的；
                memory[i] = temp;
        }
    }
    for (int i = 0; i < NUM; i++)
        printf("元素:%d,位置:%d,最邻近的空位置:%d\n", space[location[i]], location[i], memory[i]);
    //printArray(memory,NUM);
}
void paixu(int a[], int num) {//从小到大 
    int i, j, temp;
    for (i = 0; i < num - 1; i++)
    {
        for (j = i + 1; j < num; j++)
            if (a[i] > a[j])
            {
                temp = a[i];
                a[i] = a[j];
                a[j] = temp;
            }
    }

}
int findSub(int antistop, int location[], int num) {//在location数组前num个元素中寻找antistop出现的位置，找到返回下标，否则返回-1 
    for (int i = 0; i < num; i++) {
        if (antistop == location[i])
            return i;
    }
    return -1;
}

void moveLocation(int location[]) {//找出每个随机数最邻近的空位置
    int memory[NUM];//记忆每个随机数最邻近的空位置
    int step[NUM];//每个元素向左或右离最邻近的位置的距离 
    initialArray(step, NUM, 21);//将每个元素离最邻近位置的距离初始为21,因为不可能有个元素最邻近的空位置 为21 
    initialArray(memory, NUM, -1); //将每个元素最邻近位置初始为-1

    paixu(location, NUM);
    puts("对location数组排序之后");
    printArray(location, NUM);
    for (int i = 0; i < NUM; i++) {
        int temp = location[i];//第一个元素的位置 
                               //优先左侧空位置 
        for (temp--; temp >= 0 && space[temp] != -1; temp--);//第i个元素由其位置location[i]开始，向左寻找其最邻近位置，找到就保保存 
        if (temp >= 0) {//得考虑，不然第0个元素就会出错 
            step[i] = location[i] - temp;
            memory[i] = temp;
        }
        if (step[i] > 1)//如果距离为1，就已经找到最近的位置了，没必要继续向右寻找 
        {
            temp = location[i];
            for (temp++; temp < COUNT && space[temp] != -1; temp++);
            if (temp < COUNT && temp - location[i] < step[i])//右边最近距离比左边小，就用右边的；
                memory[i] = temp;
        }
        space[memory[i]] = space[location[i]];//原来数字移到新位置 
        space[location[i]] = -1; //原位置 置空 
    }
    puts("移动之后：");
    printArray(space, COUNT);
    puts("");
    puts("");

}int main()
{
    puts("生成一个随机数：");
    printf("%d\n", randomNumber(MAX));
    puts("生成NUM个不同的数放入数组中，该数组为：");
    creatRanArray(array, NUM, MAX);
    printArray(array, NUM);
    puts("initialArray函数：初始为-1");
    initialArray(space, COUNT, -1);
    printArray(space, COUNT);
    ranSpace(space, COUNT, NUM, NUM);
    puts("location的NUM个位置为：");
    printArray(location, NUM);
    puts("生成NUM个不同的数放入一个拥有COUNT个位数的数组中，-1表示该位为空，该数组为：");
    printArray(space, COUNT);
    puts("每个元素最邻近的空位置分别为(左边空位置优先)：");
    nearLocation(location);
    moveLocation(location);
    return 0;
}

第四问思路：根据location数组里存放的位置，从location[1]到最后一个遍历，先找左面的空位置，找到了就把距离记在step[i]中，位置记在memory[i]中，然后判断下距离是否大于1，如果等于于1就不用找了，因为左边紧挨着空位置；然后往右找，找到空位置后判断距离和原来的大小关系，如果大的话就用原来的，小的话就用右边的。然后最临近的空位置就找到了。

第五问思路：在上面找到一个空位置就马上移动过去，然后下一次接着找下一个位置的空位置再移动