从键盘上输入数字，螺旋三角打印 比如输入5 则打印
1   2   3   4   5
  12  13  14   6
  11  15   7
  10   8
   9

哥们，你是搞软件大赛的吗？

1. import java.io.*;
   
2. import java.util.Scanner;
   
3. public class triAn//这里改成自己的类名
   
4. {
   
5. static int [][]M=new int[30][30];//矩阵，用来保存数
   
6. static int idx=1;
   
7. public static void main(String[] args) throws IOException
   
8. {
   
9. int i,j,n = 0;
   
10. Scanner sc=new Scanner(System.in);
    
11. while(sc.hasNextInt())
    
12. {
    
13. idx=1;
    
14. n=sc.nextInt();
    
15. tri(0,0,n);//递归螺旋填充矩阵
    
16. for(i=0;i<n;i++)//打印
    
17. {
    
18. for(j=0;j<n-i;j++)
    
19. System.out.printf("%-4d",M[i][j]);//列宽为4,左对齐
    
20. System.out.println();
    
21. }
    
22. }
    
23. }
    
24. public static void tri(int r,int c,int n)//从坐标(r,c)的元素开始三角填数，每递归调用一次，填最外圈的一个三角，三角形上边长为n
    
25. {
    
26. int i;
    
27. if(n<=0)
    
28. return;
    
29. for(i=0;i<n;i++)//填充三角形上边长
    
30. {
    
31. M[r][c+i]=idx++;
    
32. }
    
33. for(i=1;i<n;i++)//填充三角形斜边长
    
34. {
    
35. M[r+i][c+n-1-i]=idx++;
    
36. }
    
37. for(i=2;i<n;i++)//填充三角形左边长
    
38. {
    
39. M[r+n-i][c]=idx++;
    
40. }
    
41. tri(r+1,c+1,n-3);//递归
    
42. }
    
43. }
    
44. 
    

复制代码

输入5和10时，结果如下：

还是华哥速度！！！
import java.util.*;
/*
思路：1这个三角形的规律没有正方形螺旋的规律好找，只好使用递归。
                   虽然这个是参考上楼华哥上次的递归打印正方形螺旋方法。但是也花了好长时间，
                   希望斑竹能给点技术分：））
          2先建立一个方形二维数组，往其中的半个三角形填充数值
          在这个过程中使用递归函数，逐圈由外向里填充数值
          另半个数组作废不用（虽然有点浪费，但可以完成任务）。
          3打印这半个有数值的三角形数组。
          4欧了。
*/
class  Helix
{
        public static void main(String[] args)
        {
                Scanner sc = new Scanner(System.in);
                while(true)
                {
                        System.out.println("please input:");
                        //循环输入
                        int n = sc.nextInt();
                        System.out.println("======");
                        //输入0，退出
                        if(n==0)
                                break;
                        //建立一个全是零的数组
                        int[][] arr = new int[n][n];
                        int i = 0 ;
                        int j = 0;
                        arr[i][j] = 1;//初始化数组的第一个值

                        //调用递归函数
                        digui(arr,i,j,n);

                        //调用打印函数
                        print(arr);
                }

        }

        //打印数组的非零值
        public static void print(int[][] arr)
        {
                for (int x=0; x<arr.length; x++)
                {
                        for (int y=0; y<arr.length; y++)
                        {
                                if(arr[x][y]==0)//等于0的不要
                                        continue;
                                System.out.print(arr[x][y]+"\t");
                        }
                        System.out.println();
                }
        }

        //使用递归函数
        public static void digui(int[][]arr,int i, int j, int n)
        {
                //递归函数的退出条件
                if(arr[i][j]==(n+1)*n/2)
                        return;
                //横向逐个填充数值
                while (j+1<n&&arr[i][j+1]==0)
                {
                                arr[i][j+1]= arr[i][j]+1;
                                j++;
                }
                //向斜下方逐个填充数值
                while ((i+1<n)&&arr[i+1][j-1]==0)
                {
                        arr[i+1][j-1]= arr[i][j]+1;
                        i++;
                        j--;
                }
                //向上逐个填充数值
                while(arr[i-1][j] ==0)
                {
                        arr[i-1][j] = arr[i][j]+1;
                        i--;
                }
                //开始递归调用自身
                digui(arr,i,j,n);
        }
}