刚才转论坛看到两个题一个是打印这个
1 1 1 1 1
1 2 2 2 1
1 2 3 2 1
1 2 2 2 1
1 1 1 1 1
第二道题是打印这个：
1  2 3 4
9 10 5
8  6
7

第一个可以定义一个二维数组来 , 第二个写一个嵌套的for就可以了啊 , 不用递归

没看仔细 , 楼主容我想想在 !

递归   比较难理解、、、、、、、、、、、

中国好熊猫 发表于 2014-12-1 22:22
第一个可以定义一个二维数组来 , 第二个写一个嵌套的for就可以了啊 , 不用递归 ...

不是只打印这个，是可以变数的

public class PrintNumber {
/*
第一个矩形的
*/
        public static void main(String[] args) {
                int max = 7;
                int size = max * 2 - 1;
                int arr[][] = new int[size][size];
                PrintNumber pn = new PrintNumber();
                pn.f(arr, max);
                pn.print(arr);
        }

        private void fun(int[][] arr, int x, int y, int n) {
                if (n == 0)
                        return;
                if (arr[x][y] < n + 1) {
                        int i, j;
                        arr[x][y] = n;
                        for (i = x - 1; i <= x + 1; i++)
                                for (j = y - 1; j <= y + 1; j++)
                                        fun(arr, i, j, n - 1);
                }
        }

        private void f(int[][] arr, int max) {
                fun(arr, max - 1, max - 1, max);
        }

        private void print(int[][] arr) {
                int i, j;
                for (i = 0; i < arr.length; i++) {
                        for (j = 0; j < arr[i].length; j++) {
                                System.out.print(arr[i][j] + " ");
                        }
                        System.out.println();
                }
        }
}

怎么格式这么难看 ..

中国好熊猫 发表于 2014-12-2 14:32
public class PrintNumber {
/*
第一个矩形的

来点注释吧。有点看不懂

ok , 明天加注释啊 ,

1. 闲话少说 , 代码才是干货
   
2. 
   
3. public class PrintNumber2 {
   
4. 
   
5.         // 9 以内 , 看着比较好看
   
6.         private static int num = 9;
   
7.        
   
8.         public static void main(String[] args) {
   
9.                 int[][] arr = new int[num][num];
   
10.                 f(arr);
    
11.                 print(arr);
    
12.         }
    
13. 
    
14.         static void fun(int[][] arr, int x, int y, int n, int flag) {
    
15.                 if (arr[y][x] == 0)
    
16.                         arr[y][x] = n++;
    
17.                 else
    
18.                         return;
    
19.                 //flag 0 从左往右 1 右上到左下 2 从下往上
    
20.                 switch (flag) {
    
21.                 case 0:
    
22.                         if (x < num - 1 && arr[y][x + 1] == 0)
    
23.                                 fun(arr, x + 1, y, n, flag);
    
24.                         else {
    
25.                                 flag = 1;
    
26.                                 fun(arr, x - 1, y + 1, n, flag);
    
27.                         }
    
28.                         break;
    
29.                 case 1:
    
30.                         if (y < num - 1 && arr[y + 1][x - 1] == 0)
    
31. 
    
32.                                 fun(arr, x - 1, y + 1, n, flag);
    
33.                         else {
    
34.                                 flag = 2;
    
35.                                 fun(arr, x, y - 1, n, flag);
    
36.                         }
    
37.                         break;
    
38.                 case 2:
    
39.                         if (arr[y - 1][x] == 0)
    
40.                                 fun(arr, x, y - 1, n, flag);
    
41.                         else {
    
42.                                 flag = 0;
    
43.                                 fun(arr, x + 1, y, n, flag);
    
44.                         }
    
45.                         break;
    
46.                 }
    
47.         }
    
48. 
    
49.         static void f(int[][] arr) {
    
50.                 fun(arr, 0, 0, 1, 0);
    
51.         }
    
52. 
    
53.         static void print(int[][] arr) {
    
54.                 int i, j;
    
55.                 for (i = 0; i < num; i++) {
    
56.                         for (j = 0; j < num; j++) {
    
57.                                 if (arr[i][j] == 0)
    
58.                                         continue;
    
59.                                 System.out.print(arr[i][j] + " ");
    
60.                                 if (arr[i][j] < 10) {
    
61.                                         System.out.print(" ");
    
62.                                 }
    
63.                         }
    
64.                         System.out.println();
    
65.                 }
    
66.         }
    
67. }

复制代码

这个就是按照画圈的顺序计算的 , 还是放二维数组里

我写注释的功夫实在是不咋地 ,

1. public class PrintNumber {
   
2. 
   
3.         public static void main(String[] args) {
   
4.                 //选定最大数字
   
5.                 int max = 7;
   
6.                 //数组的长度
   
7.                 int size = max * 2 - 1;
   
8.                 int arr[][] = new int[size][size];
   
9.                 PrintNumber pn = new PrintNumber();
   
10.                 pn.f(arr, max);
    
11.                 pn.print(arr);
    
12.         }
    
13. 
    
14.         private void fun(int[][] arr, int x, int y, int n) {
    
15.                 if (n == 0)
    
16.                         return;
    
17.                 /*
    
18.                  * 从最中间的最大的数字开始, 每次都计算包括它和它周围一共9个数字
    
19.                  */
    
20.                 if (arr[x][y] < n + 1) {
    
21.                         int i, j;
    
22.                         arr[x][y] = n;
    
23.                         for (i = x - 1; i <= x + 1; i++)
    
24.                                 for (j = y - 1; j <= y + 1; j++)
    
25.                                         fun(arr, i, j, n - 1);
    
26.                 }
    
27.         }
    
28. 
    
29.         private void f(int[][] arr, int max) {
    
30.                 fun(arr, max - 1, max - 1, max);
    
31.         }
    
32. 
    
33.         private void print(int[][] arr) {
    
34.                 int i, j;
    
35.                 for (i = 0; i < arr.length; i++) {
    
36.                         for (j = 0; j < arr[i].length; j++) {
    
37.                                 System.out.print(arr[i][j] + " ");
    
38.                         }
    
39.                         System.out.println();
    
40.                 }
    
41.         }
    
42. }

复制代码

学习学习！

学到了，谢谢大神

第一个是：杨辉三角变形。第二个是：将n个数打印成一个圈？先打印最外圈，然后递归打印直至最里面一圈。有没有大神来实现一下？

学习学习！

学习下……

学习下……

递归是一种思想，可以简单理解为自己调用自己。比如说:一个函数被传入的值为6，返回的值为3，则下次就把3传入这个函数，然后再一步一步运行前几步没有完成的操作。这个是我的理解！递归可以应用于找出一个目录下的所有扩展名为xxx的文件！至于你所说的按圈打印，我想用递归可以实现！