时间戳

首页 > 解决方案 > 如何以螺旋形式打印不相等的行长矩阵？

java - 如何以螺旋形式打印不相等的行长矩阵？

问题描述

我有一个这样的矩阵：

{
  {4,5,6,7,8},
  {2,3,1,4},
  {1,2},
  {1,2,3,4,5}
  {5,6,7,8}
}

我想以螺旋方式打印它，所以输出应该是： 4 5 6 7 8 4 2 5 8 7 6 5 1 1 1 3 1 4 3 2

我目前对螺旋矩阵的代码是这样的：

void spiral(int a[][]) { 
    int i, k = 0, l = 0, m = a.length, n = a[0].length; 

    while (k < m && l < n) { 
        for (i = l; i < n; ++i) { 
            System.out.print(a[k][i] + " "); 
        } 
        k++; 

        for (i = k; i < m; ++i) { 
            System.out.print(a[i][n - 1] + " "); 
        } 
        n--; 

        if (k < m) { 
            for (i = n - 1; i >= l; --i) { 
                System.out.print(a[m - 1][i] + " "); 
            } 
            m--; 
        }

        if (l < n) { 
            for (i = m - 1; i >= k; --i) { 
            System.out.print(a[i][l] + " "); 
        } 
        l++; 
    } 
}

问题是我无法理解如何使它适用于不相等的数组长度行。我真的很感激在这方面的任何帮助和洞察力。

标签： javaarraysalgorithmmatrix

解决方案

这是我的解决方案。它可能更有效，但它有效：

public static void main(String [] args) throws ScriptException {
    Integer [][] input = new Integer[][] {
                                    {4,5,6,7,8},
                                    {2,3,1,4},
                                    {1,2},
                                    {1,2,3,4,5},
                                    {5,6,7,8}
                                };

   List<List<Integer>> list = listify(input);
   processSpiral(list);
}

private static <T> void processSpiral(List<List<T>> list) {
    if (!list.isEmpty()) {
        printTop(list);
        list.removeIf(l -> l.isEmpty());
        printLast(list);
        list.removeIf(l -> l.isEmpty());
        printBottom(list);
        list.removeIf(l -> l.isEmpty());
        printFirst(list);
        list.removeIf(l -> l.isEmpty());
        processSpiral(list);
    }
}

private static <T> void printFirst(List<List<T>> list) {
    if (!list.isEmpty()) {
        for (int i = list.size() -1; i >= 0; i --) {
            List<T> row = list.get(i);
            if (!row.isEmpty()) {
                System.out.print(String.format("%s ", row.get(0).toString()));
                row.remove(0);
            }
        }
    }
}

private static <T> void printBottom(List<List<T>> list) {
    if (!list.isEmpty()) {
        List<T> bottomRow = list.get(list.size() - 1);
        Collections.reverse(bottomRow);
        for (T i : bottomRow) {
            System.out.print(String.format("%s ", i.toString()));
        }
        list.remove(list.size() - 1);
    }
}
private static <T> void printLast(List<List<T>> list) {
    list.stream()
        .filter(l -> !l.isEmpty())
        .forEach(l -> {
            T i = l.get(l.size() - 1);
            System.out.print(String.format("%s ", i.toString()));
            l.remove(l.size() - 1);
        });
}
private static <T> void printTop(List<List<T>> list) {
    List<T> firstRow = list.get(0);
    list.remove(0);
    //print the first row
    for (T i : firstRow) {
        System.out.print(String.format("%s ", i.toString()));
    }
}

private static <T> List<List<T>> listify(T [][] input) {
    //convert to List of List for simplicity's sake
    List<List<T>> list = new ArrayList<>();
    for (T [] row : input) {
        //do not use Arrays.asList() as that creates an immutable List
        List<T> l = new ArrayList<>(row.length);
        for (T i : row) {
            l.add(i);
        }
        list.add(l);
    }

    return list;
}

推荐阅读