数据结构与算法分析Java版练习2.8

package ch02;import java.util.Arrays;import java.util.Random;/** * 练习2.8 假设需要生成前N个整数的一个随机转换。例如{4，3，1，5，2}和{3，1，4，2，5}就是合法的转换，但 * {5，4，1，2，1}则不是，因为数1出现两次而数3却没有。这个程序常常用于模拟一些算法。我们假设存在一个随机数 * 生成器r,它有方法randInt(i, j),它以相同的概率生成i和j之间的整数。下面是三个算法： * 1. 如下填入从a[0]到a[n-1]的数组a;为了填入a[i],生成随机数直到它不同于已经生成的a[0],a[1],...,a[i-1]时 *    再将其填入a[i]。 * 2. 同算法（1），但是要保存一个附加的数组，称之为used数组。当一个随机数ran最初被放入数组a的时候，置used[ran]=true。 *     这就是说，当用一个随机数填入a[i]时，可以用一步来测试是否该随机数已经被使用，而不是像第一个算法那样（可能）用 *   i步测试。 * 3. 填写该数组使得a[i] = i + 1。然后 *    for (i = 1; i < n; i++) *       swapReference(a[i], a[randInt(0, i)]); * a. 证明这三个算法都生成合法的置换，并且所有的置换都是可能的。 *    （证明略。） * b. 对每一个算法给出你能够得到的尽可能准确的期望运行时间分析（用大O)。 * c. 分别写出程序来执行每个算法10次，得出一个好的平均值。对N=250, 500, 1000, 2000运行程序（1）； *    对N=25 000, 50 000, 100 000, 200 000, 400 000, 800 000运行程序（2）；对N=100 000, 200 000, 400 000, 800 000, *    1600 000, 3 200 000, 6 400 000运行程序（3）； * d. 将实际的运行时间与你的分析进行比较。 * e. 每个算法的最坏情形的运行时间是什么？ * */public class EX08 {static final Random rand = new Random(47);private static int randInt(int i, int j) {return rand.nextInt(j-i+1) + i;}/** * 如下填入从a[0]到a[n-1]的数组a;为了填入a[i],生成随机数直到它不同于已经生成的a[0],a[1],...,a[i-1]时 * 再将其填入a[i]. * 下面算法1和算法2的时间复杂度是从标准答案中参考的，因为涉及概率问题，本人不太肯定。 * 期望运行时间 O(N^2 * logN)。 * 最坏运行时间 O(N^2 * logN)。 */public static int[] algorithm1(int N) {int []a = new int[N];for (int i = 0; i < a.length; ++i) {  while (true) {a[i] = randInt(1, N);        boolean foundDup = false;     for (int j = 0; j < i; ++j) {  if (a[i] == a[j]) {foundDup = true;break;}}if (!foundDup) {break;}}}return a;}/** * 同算法（1），但是要保存一个附加的数组，称之为used数组。当一个随机数ran最初被放入数组a的时候，置used[ran]=true。  * 这就是说，当用一个随机数填入a[i]时，可以用一步来测试是否该随机数已经被使用，而不是像第一个算法那样（可能）用     * i步测试。     * 期望运行时间O(N * logN)。     * 最坏运行时间O(N * logN)。 */public static int[] algorithm2(int N) {int[] a = new int[N];boolean[] used = new boolean[N+1];for (int i = 0; i < a.length; ++i) {do {a[i] = randInt(1, N);} while (used[a[i]]);used[a[i]] = true;}return a;}/** * 填写该数组使得a[i] = i + 1。然后 *    for (i = 1; i < n; i++) *       swapReference(a[i], a[randInt(0, i)]); * 期望运行时间O(N)。 * 最坏运行时间O(N)。 */public static int[] algorithm3(int N) {int[] a = new int[N];for (int i = 0; i < N; ++i) {a[i] = i + 1;}for (int i = 1; i < N; ++i) {swapReferences(a, i, randInt(0, i));}return a;}private static void swapReferences(int a[], int i, int j) {int temp = a[i];a[i] = a[j]; a[j] = temp;}public static void main(String[] args) {/*System.out.println(Arrays.toString(algorithm1(10)));System.out.println(Arrays.toString(algorithm2(10)));System.out.println(Arrays.toString(algorithm3(10)));*/int []N1 = new int[] {250, 500, 1000, 2000};int []N2 = new int[] {25000, 50000, 100000, 200000, 400000, 800000};int []N3 = new int[] {100000, 200000, 400000, 800000, 1600000, 3200000, 6400000};System.out.println("算法1:");for (int i = 0; i < N1.length; ++i) {System.out.println(N1[i] + ": " + testN(1, N1[i]) + " ms");}System.out.println("算法2:");for (int i = 0; i < N2.length; ++i) {System.out.println(N2[i] + ": " + testN(2, N2[i]) + " ms");}System.out.println("算法3:");for (int i = 0; i < N3.length; ++i) {System.out.println(N3[i] + ": " + testN(3, N3[i]) + " ms");}}private static long testN(int algorithmNum, int N) {long startTime = System.currentTimeMillis();switch (algorithmNum) {case 1:for (int i = 0; i < 10; ++i)algorithm1(N);break;case 2:for (int i = 0; i < 10; ++i)algorithm2(N);break;default:for (int i = 0; i < 10; ++i)algorithm3(N);break;}long endTime = System.currentTimeMillis();return endTime - startTime;}}/* * 算法时间分析 * 如果算法的复杂度为O(N^k), k>1, 如果输入分别为 N1, N2,且N1的运行时间为T1,则 * T2 = T1 * ((N2/N1)^k) * (logN2/logN1)。可以验证下面的执行时间是否大致符合此规律。 * 下面的算法1和算法2的时间，不太肯定，大概正确。 * 算法1: O(N^2 * logN) *     N     实际时间(ms)     预估时间(ms) *    250       4              -- *    500       11              *   1000       48              *   2000       206             *    * 算法2: O(N*logN) *     N     实际时间(ms)     预估时间(ms) *    25k       75              -- *    50k       140              *   100k       298              *   200k       601              *   400k       1325             *   800k       3052             *    * 算法3: O(N) *     N     实际时间(ms)     预估时间(ms) *   100k       26             --- *   200k       51             52 *   400k       107            102 *   800k       245            214 *   160m       754            490 *   320m       1927           1508 *   640m       4587           3854 *    * 总结：因为忽略了常数系数，所以复杂度都是正确的。 * */