Java实现螺旋矩阵：根据用户输入生成指定大小斐波那契填充矩阵

嘿，我明白你需要的是一个根据输入n生成n×n螺旋矩阵的Java程序，填充的数值是从1、2开始的斐波那契数列，而且螺旋的路径和常规的不太一样——看你给的3×3例子，我先把填充逻辑理清楚，再给你完整的实现代码。

首先明确核心规则：

• 输入整数n，生成n×n的矩阵
• 填充序列：1, 2, 3(1+2), 5(2+3), 8(3+5), ... 每个数是前两个数的和
• 螺旋填充路径（以n=3为例）：
  1. 顶部行从右往左填充（对应数值1→2→3，打印出来就是第一行3 2 1）
  2. 左侧列从上往下填充（跳过已填充的顶部行位置，对应数值5→8）
  3. 底部行从左往右填充（跳过已填充的左侧列位置，对应数值13→21）
  4. 右侧列从下往上填充（跳过已填充的底部行和顶部行位置，对应数值34）
  5. 最后填充中心位置（对应数值55）

接下来是完整的Java代码，包含了数列生成、螺旋填充和格式化打印：

import java.util.Scanner;

public class FibonacciSpiralMatrix {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        System.out.print("请输入矩阵规模n: ");
        int n = scanner.nextInt();
        scanner.close();

        // 生成对应长度的斐波那契数列，起始为1、2
        long[] fibSequence = generateFibonacci(n * n);

        // 初始化n×n矩阵
        long[][] matrix = new long[n][n];

        // 定义螺旋填充的边界：top(上边界行), bottom(下边界行), left(左边界列), right(右边界列)
        int top = 0, bottom = n - 1;
        int left = 0, right = n - 1;
        int currentIndex = 0; // 当前要填充的斐波那契数的索引

        while (currentIndex < n * n) {
            // 1. 填充顶部行：从右到左
            for (int col = right; col >= left; col--) {
                matrix[top][col] = fibSequence[currentIndex++];
            }
            top++; // 上边界下移，避免重复填充

            // 2. 填充左侧列：从上到下（从新的上边界到下边界）
            for (int row = top; row <= bottom; row++) {
                matrix[row][left] = fibSequence[currentIndex++];
            }
            left++; // 左边界右移

            // 3. 填充底部行：从左到右（从新的左边界到右边界），需判断是否还有未填充的行
            if (top <= bottom) {
                for (int col = left; col <= right; col++) {
                    matrix[bottom][col] = fibSequence[currentIndex++];
                }
                bottom--; // 下边界上移
            }

            // 4. 填充右侧列：从下到上（从新的下边界到上边界），需判断是否还有未填充的列
            if (left <= right) {
                for (int row = bottom; row >= top; row--) {
                    matrix[row][right] = fibSequence[currentIndex++];
                }
                right--; // 右边界左移
            }
        }

        // 打印生成的矩阵
        System.out.println("生成的" + n + "×" + n + "螺旋矩阵：");
        printFormattedMatrix(matrix);
    }

    /**
     * 生成指定长度的斐波那契数列，起始值为1、2
     */
    private static long[] generateFibonacci(int length) {
        long[] sequence = new long[length];
        if (length >= 1) {
            sequence[0] = 1;
        }
        if (length >= 2) {
            sequence[1] = 2;
        }
        for (int i = 2; i < length; i++) {
            sequence[i] = sequence[i - 1] + sequence[i - 2];
        }
        return sequence;
    }

    /**
     * 格式化打印矩阵，让所有数值对齐
     */
    private static void printFormattedMatrix(long[][] matrix) {
        int n = matrix.length;
        // 找到矩阵中最大数值的位数，用于格式化输出
        long maxNum = matrix[n/2][n/2]; // 中心位置的数通常是最大的
        int maxDigits = String.valueOf(maxNum).length();
        String formatPattern = "%" + maxDigits + "d ";

        for (long[] row : matrix) {
            for (long num : row) {
                System.out.printf(formatPattern, num);
            }
            System.out.println();
        }
    }
}

代码说明： #

1. 斐波那契数列生成：generateFibonacci方法生成长度为n×n的数列，用long类型是因为斐波那契数增长很快，int会很快溢出。
2. 螺旋填充逻辑：通过四个边界变量控制填充范围，按照你需要的路径依次填充每一行和列，每完成一个边界的填充就收缩对应的边界，确保不会重复填充。
3. 格式化打印：printFormattedMatrix方法会自动计算最大数值的位数，用格式化字符串让矩阵的每一列对齐，看起来更整齐。

测试n=3的情况： #

运行程序输入3，输出结果和你给出的例子完全一致：

3  2  1 
5 55 34 
8 13 21 

对于n=4的情况，程序会自动生成4×4的矩阵，填充路径遵循同样的规则：先填充顶部行从右到左，再左侧列从上到下，接着底部行从左到右，然后右侧列从下到上，之后收缩边界，重复这个过程直到所有16个斐波那契数填充完毕。

内容的提问来源于stack exchange，提问作者Gaurav