生成格雷码

算法设计与分析老师又出了个练习题：

 

利用分治策略设计一个算法，对任意的n构造相应的“格雷码”。“格雷码”(Gray code)是一个长度为2ⁿ的序列，满足

 

A) 每个元素都是长度为n比特的串。

 

B) 序列中无相同元素。

 

C) 连续的两个元素恰好只有1比特的不同。

 

例如，n=2时，格雷码为｛00，01，11，10｝。

    二进制格雷码（也被称为二进制循环码）是一种无权码，其特点是任何相邻的两个码字中仅有一位代码不同，其他代码是一样的，所以二进制格雷码又叫单位距离码。仔细观察格雷码的编码方式：如果按顺序将格雷码每四个分为一组，对于格雷码的最后一位，具有折叠反射特性，即：最后一位的顺序为 01 10,01 10,.....如果按顺序将格雷码每8个分为一组，则其倒数第2为的顺序为0011，1100，0011，1100.....同样，倒数第3为的顺序为0001111，1111000.这种特性称为反射特性。
格雷码是一种具有反射特性和循环特性的单步自补码，其循环和单步特性消除了随机取数时出现重大错误的可能，其反射和自补特性使得对其进行求反操作也非常方便，所以，格雷码属于一种可靠性编码，是一种错误最小化的编码方式，因此格雷码在通信和测量技术中得到广泛应用。

网上找了一下没看到用分治法的！

我自己写了个算法，我写出了n=1，2,3，4的所有格雷码，我发现了个规律：n每加1，那么就是将n-1的格雷码每一个都在后面添1和0，但次序变下（就是先加1和0，后面就加0和1）就是反射特性！

/*
 * To change this template, choose Tools | Templates
 * and open the template in the editor.
*/

/**
 *
 * @author Administrator
*/
import java.util.*;

public class GrayCode {

    public static int flag = 2;

    public static void main(String[] args) {
        int t, n;
        System.out.print("n=");
        Scanner reder = new Scanner(System.in);
        t = reder.nextInt();
        n = (int) Math.pow(2, (double) t);
        int[][] gray = new int[n][t];
        System.out.println("The GrayCode is: ");
        if (t == 1) {
            System.out.println("0");
            System.out.println("1");
        } else {
            gray[n / 2 - 2][0] = 0;
            gray[n / 2 - 2][1] = 0;
            gray[n / 2 - 1][0] = 0;
            gray[n / 2 - 1][1] = 1;
            gray[n / 2][0] = 1;
            gray[n / 2][1] = 1;
            gray[n / 2 + 1][0] = 1;
            gray[n / 2 + 1][1] = 0;
            if (t > 2) {
                com(gray, n / 2 - 2, n / 2 + 1);
            }

            for (int i = 0; i < gray.length; i++) {
                for (int j = 0; j < gray[i].length; j++) {
                    System.out.print(gray[i][j] + " ");

                }
                System.out.println("");
            }
        }
    }

    public static void com(int[][] gray, int up, int down) {
        int fUp = gray.length / 2 - (int) Math.pow(2, (double) flag);
        int fDown = gray.length / 2 + (int) Math.pow(2, (double) flag) - 1;
        int t = 0;
        for (int i = up; i < gray.length / 2; i++) {
            System.arraycopy(gray[i], 0, gray[fUp + t], 0, gray[i].length);
            gray[fUp + (t++)][flag] = 0;

            System.arraycopy(gray[i], 0, gray[fUp + t], 0, gray[i].length);
            gray[fUp + (t++)][flag] = 1;
            i++;
            System.arraycopy(gray[i], 0, gray[fUp + t], 0, gray[i].length);
            gray[fUp + (t++)][flag] = 1;

            System.arraycopy(gray[i], 0, gray[fUp + t], 0, gray[i].length);
            gray[fUp + (t++)][flag] = 0;
        }
        t = 0;
        for (int i = down; i > gray.length / 2; i--) {

            System.arraycopy(gray[i], 0, gray[fDown - t], 0, gray[i].length);
            gray[fDown - (t++)][flag] = 0;

            System.arraycopy(gray[i], 0, gray[fDown - t], 0, gray[i].length);
            gray[fDown - (t++)][flag] = 1;
            i--;
            System.arraycopy(gray[i], 0, gray[fDown - t], 0, gray[i].length);
            gray[fDown - (t++)][flag] = 1;

            System.arraycopy(gray[i], 0, gray[fDown - t], 0, gray[i].length);
            gray[fDown - (t++)][flag] = 0;
        }
        flag++;
        if (flag == gray[0].length) {
            return;
        } else {
            com(gray, gray.length / 2 - (int) Math.pow(2, (double) flag - 1), gray.length / 2 + (int) Math.pow(2, (double) flag - 1) - 1);
        }
        return;
    }
}