java 算法题

Question

编写一方法printInt(int n)使printInt(5)打印如下结果1  2  3  4  5  
16 17 18 19 6  
15 24 25 20 7  
14 23 22 21 8  
13 12 11 10 9 printInt(6)打印如下结果
1  2  3  4  5  6  
20 21 22 23 24 7  
19 32 33 34 25 8  
18 31 36 35 26 9  
17 30 29 28 27 10 
16 15 14 13 12 11 

Answer 1

贪吃蛇玩过?? 设定4个方向标志. 拿你的6*6矩阵来说把,初始化方向向右,从第一行向右填数据,当到达边界的时候,方向改成向下,碰到下边界,方向改向左,以此类推.都右规律的,记住转向条件是(当前填写位置小于等于6&&当前位置小于等于已填写数据的行或列)  不知道说明白没,没明白,就要上代码了.

Answer 2

这个题目都快是月经贴了
实在忍不住写了个 
3楼的思路很好
与别人的想法不太一样 我这里不用3楼的那种思路public static void printInt(int num){
int start = - (num - 1) / 2;
int end = num / 2;
int max;
int maxNum;
for(int i = start; i <= end; i++){
for(int j = start; j <= end; j++){
max = Math.max(Math.abs(i), Math.abs(j));
maxNum = (2 * max + 1) * (2 * max + 1);
if(i == - max){
System.out.print(num * num - maxNum + max + j + 1);
}else if(j ==  max){
System.out.print(num * num - maxNum + 3*max + i + 1);
}else if(i == max){
System.out.print(num * num - maxNum + 5*max - j + 1);
}else{
System.out.print(num * num - maxNum + 7*max - i + 1);
}
System.out.print("\t");
}
System.out.println();
System.out.println();
}
}

Answer 3

public class Rollt { public static int[][] printInt(int args){

if(args == 0 || args > 200){
System.out.println("error");
System.exit(0);
}
int rows = args;
int cols = args;

int row = 0;
int col = 0;

int[][] ints = new int[rows][cols];

int derection = 0;

for(int i = 1,max = args*args;i <= max;i ++){
ints[row][col] = i;
switch(derection){
case 0:
if(col+1 >= cols || ints[row][col+1] > 0){
derection += 1;
derection %= 4;
row += 1;
}else{
col += 1;
}
break;
case 1:
if(row+1 >= rows || ints[row+1][col] > 0){
derection += 1;
derection %= 4;
col -= 1;
}else{
row += 1;
}
break;
case 2:
if(col-1 < 0 || ints[row][col-1] > 0){
derection += 1;
derection %= 4;
row -= 1;
}else{
col -= 1;
}
break;
case 3:
if(row-1 < 0 || ints[row-1][col] > 0){
derection += 1;
derection %= 4;
col += 1;
}else{
row -= 1;
}
break;
default:System.out.println("error");
}
}
return ints;

}

public static void main(String[] args) {
int[][] ints = Rollt.printInt(9);
for(int[] i:ints){
for(int j:i){
if(j<10){
System.out.print(" 0"+j);
}else{
System.out.print(" "+j);
}
}
System.out.println();
}
}
}

Answer 4

public static void test(int n) {
int[][] res = new int[n][n];
int[][] director = { { 0, 1 }, { 1, 0 }, { 0, -1 }, { -1, 0 } };
int nCount = 0, x = 0, y = 0, d = 0;
while (++nCount <= n * n) {
res[y][x] = nCount;
while (nCount < n * n
&& (y + director[d][0] < 0 || y + director[d][0] >= n
|| x + director[d][1] < 0
|| x + director[d][1] >= n || res[y
+ director[d][0]][x + director[d][1]] > 0))
d = (d + 1) % 4;
y = y + director[d][0];
x = x + director[d][1];
}
for (int[] a : res) {
for (int i : a) {
System.out.print(i);
System.out.print(' ');
}
System.out.println();
}
}

Answer 5

貌似奇数都是好的 偶数秩序需要调整下 public static void printInt(int num){
int start = - (num - 1) / 2;
int end = num / 2;
int max;
int maxNum;
for(int i = start; i <= end; i++){
for(int j = -end; j <= -start; j++){
max = Math.max(Math.abs(i), Math.abs(j));
maxNum = (2 * max + 1) * (2 * max + 1);
if(i == - max){
System.out.print(num * num - maxNum + max + j + 1);
}else if(j ==  max){
System.out.print(num * num - maxNum + 3*max + i + 1);
}else if(i == max){
System.out.print(num * num - maxNum + 5*max - j + 1);
}else{
System.out.print(num * num - maxNum + 7*max - i + 1);
}
System.out.print("\t");
}
System.out.println();
System.out.println();
}
}

Answer 6

很无趣的增加几个变量，换一种简单一点的判断方式……
public static void test(int n) {
int[][] res = new int[n][n];
int[][] director = { { 0, 1 }, { 1, 0 }, { 0, -1 }, { -1, 0 } };
int curr = 0, d = 0, x = -director[d][1], y = -director[d][0], c = n * 2;
while (c / 2 > 0) {
for (int j = 0; j < c / 2; j++) {
x = x + director[d][1];
y = y + director[d][0];
res[y][x] = ++curr;
}
c--;
d = (d + 1) % 4;
}
for (int[] a : res) {
for (int i : a) {
System.out.print(i);
System.out.print(' ');
}
System.out.println();
}
}

Answer 7

其实楼主的这个问题是个螺旋方阵。很经典的问题，更多算法参考：http://fevernova.bokee.com/1428170.html

Answer 8

引错标签了，
http://fevernova.bokee.com/1428170.html

Answer 9

。这样你测试了？
int start = - (num - 1) / 2;
int end = num / 2;
如果num = 5; start和end岂不是==了。

Answer 10

这个上次不是写过了么？public class SpiralMatrix {    public final static int DOWN_FIRST = 0;
    public final static int RIGHT_FIRST = 1;    public static void main(String[] args) {        final int N = 5;
        final int DIRECT = DOWN_FIRST;        int[][] spiralMatrix = new int[N][N];
        int[] rc = { 0, 0 };
        int t = (N << 1) - 1;
        int c = 0;
        int num = 1;
        while(c < t) {
            int p = (c + 1) >> 1;
            while(p++ < N) {
                spiralMatrix[rc[0]][rc[1]] = num++;
                if(p == N) {
                    c++;
                }
                rc[(c & 1) ^ DIRECT] += 1 - (c & 2);
            }
        }
        output(spiralMatrix);
    }    private static void output(int[][] matrix) {
        for(int i = 0; i < matrix.length; i++) {
            for(int j = 0; j < matrix[i].length; j++) {
                if(j > 0) {
                    System.out.print(' ');
                }
                System.out.printf("%2d", matrix[i][j]);
            }
            System.out.println();
        }
    }
}

Answer 11

问题解决，自己写的，用二维数组的初始化，先初始化最外面的大圈的4个边，然后再逐渐向内，直到最里面的圈public class PrintlInt {
public static void printInt(int m){
int [][] arr = new int [m][m];
int n = m;
int index = 0;
int value = 1;
while(n>0){
for(int k=0;k<n;k++){
arr[0+index][k+index]= k+value;
if(k>0&&k<n-1)arr[k+index][n+index-1]= k+value+n-1;
arr[n-1+index][k+index]= 3*n-3-k+value;
if(k>0&&k<n-1)arr[k+index][0+index]= 4*n-4-k+value;
}
value = value + 4*n-4;
n = n-2;
index ++;
}

for(int[]ar:arr){
for(int g:ar){
System.out.printf("%-3d",g);
}
System.out.println();
}
}

public static void main(String[] args) {
printInt(6);
                System.out.println();
printInt(5);
                System.out.println();
printInt(4); }
}运行结果：
1  2  3  4  5  6  
20 21 22 23 24 7  
19 32 33 34 25 8  
18 31 36 35 26 9  
17 30 29 28 27 10 
16 15 14 13 12 11 1  2  3  4  5  
16 17 18 19 6  
15 24 25 20 7  
14 23 22 21 8  
13 12 11 10 9  1  2  3  4  
12 13 14 5  
11 16 15 6  
10 9  8  7

Answer 12

问题解决，自己写的，用二维数组的初始化，先初始化最外面的大圈的4个边，然后再逐渐向内，直到最里面的圈public class PrintlInt {

public static void printInt(int n){

int [][] arr = new int [n][n];

int index = 0;
int value = 1;

while(n>0){
for(int k=0;k<n;k++){
arr[0+index][k+index]= k+value;
if(k>0&&k<n-1)arr[k+index][n+index-1]= k+value+n-1;
arr[n-1+index][k+index]= 3*n-3-k+value;
if(k>0&&k<n-1)arr[k+index][0+index]= 4*n-4-k+value;
}
value = value + 4*n-4;
n = n-2;
index ++;
}

for(int[]ar:arr){
for(int g:ar){
System.out.printf("%-3d",g);
}
System.out.println();
}
}

public static void main(String[] args) {
printInt(6);
System.out.println();
printInt(5);
System.out.println();
printInt(4); }
}运行结果：
1 2 3 4 5 6   
20 21 22 23 24 7   
19 32 33 34 25 8   
18 31 36 35 26 9   
17 30 29 28 27 10  
16 15 14 13 12 11  1 2 3 4 5   
16 17 18 19 6   
15 24 25 20 7   
14 23 22 21 8   
13 12 11 10 9   1 2 3 4   
12 13 14 5   
11 16 15 6   
10 9 8 7

Answer 13

J2EE的算法不是很重要！不是时间少的人学习的重点！

Answer 14

public class Test {
public static void change(int n) {
int start = 0, end = n;
int tag = 1;
int[][] a =new int[n][n];
for(int i = 0; i <= n/2; i++) {
for(int j = start; j < end; j++) {
a[start][j] = tag++;
}
for(int j = start; j < end - 1; j ++) {
a[j + 1][end-1] = tag++;
}
for(int j = end - 1; j > start; j--) {
a[end-1][j-1] = tag ++;
}
for(int j = end - 2; j > start; j--) {
a[j][start] = tag++;
}
start ++;
end --;
}

int  c = 0;
for(int[] i : a){
for(int j : i) {
System.out.print(" "+j);
c ++;
if(c%n == 0) {
System.out.println();
}
}
}
}
public static void main(String[] args) {
change(6);

}}
通俗易懂，呵呵

Answer 15

我自己想了一个：向东打印N个后，向下打印N-1个，再向左打印N-1个，再向上打印N-2个……5个的旋转序列是5 44332211 
6个的旋转序列是6 5544332211
7个的旋转序列是7 665544332211
N个的旋转序列是N N，N-1，N-1，N-2,N-2……1，1应该包含一个构造旋转序列的方法，和递归的方法。一 每次旋转打印一列，这个递归方法应该有三个输入：
1，当前数组，递归方法返回数组本身，这样才能调用自己。
2，方向，约定1234为上下左右四个方向。
3，当前递归的执行深度，这个执行深度就是取得旋转序列的索引。二 递归方法的开头应该是一个方向的控制，初始化的时候方向为正向。
三 递归方法包含一个方向的判断
四 递归方法应该包含一个循环打印当前列的方法，这个循环的次数就是通过执行深度取得旋转序列的值的大小。
五 递归方法应该包含递归最里层的判断。代码随后附上。

Answer 16

/**
 * @author 相濡以沫
 *
 */
public class FilterList {    private Integer[] seq;
    private Integer[][] map;
    private Integer x;
    private Integer y;    /**
     * @return the x
     */
    public Integer getX() {
        return x;
    }    /**
     * @return the y
     */
    public Integer getY() {
        return y;
    }    /**
     * @param pX the x to set
     */
    public void setX(Integer pX) {
        x = pX;
    }    /**
     * @param pY the y to set
     */
    public void setY(Integer pY) {
        y = pY;
    }    /**
     * @param n
     */
    public void setSeq(Integer n) {
        Integer length = 2 * n - 1;
        seq = new Integer[length];
        for (int i = 0; i < seq.length; i++) {
            if (i % 2 == 1) {
                n--;
            }
            seq[i] = n;
        }
    }    /**
     * @return the map
     */
    public Integer[][] getMap() {
        return map;
    }    /**
     * @param dir 1→2↓3←4上
     * @param deep
     * @param value
     */
    public void setMap(Integer dir, Integer deep, Integer value) {
        Integer n = seq[deep];     
        if(dir==1){
            for (int i = 0; i < n; i++) {
                setY(getY() + 1);   
                map[x][y] = value;
                value++;
            }
            dir = 2;
        }else if(dir==2){
            for (int i = 0; i < n; i++) {
                setX(getX() + 1);
                map[x][y] = value;
                value++;
            }
            dir = 3;
        }else if(dir==3){
            for (int i = 0; i < n; i++) {
                setY(getY() - 1);
                map[x][y] = value;
                value++;
            }
            dir = 4;
        }else if(dir==4){
            for (int i = 0; i < n; i++) {
                setX(getX() - 1);
                map[x][y] = value;
                value++;
            }
            dir = 1;
        }
        deep++;
        if (deep != seq.length) {
            setMap(dir, deep, value);
        }
    }    public void doWrite(Integer n) {
        map=new Integer[n][n];
        setSeq(n);
        setX(0);
        setY(-1);
        setMap(1, 0, 1);
    }    public static void main(String args[]) {
        FilterList l = new FilterList();
        l.doWrite(6);
        Integer[][] map = l.getMap();
        for (int i = 0; i < map.length; i++) {
            for (int j = 0; j < map[i].length; j++) {
                System.out.print(map[i][j].toString()+" ");
            }
            System.out.println("");
        }
    }
}

Answer 17

调整
    public void doWrite(Integer n) {
        map=new Integer[n][n];
        setSeq(n);
        setX(n-1);
        setY(n);
        setMap(3, 0, 10);
    }
可以得到
18 19 20 21 22 
17 30 31 32 23 
16 29 34 33 24 
15 28 27 26 25 
14 13 12 11 10 修改if块中的dir，还能画逆时针

Answer 18

回旋数
http://blog.csdn.net/bluejoy345/archive/2010/07/19/5745920.aspx