空指针异常，不知道为什么？ [关闭]

Question

我正在尝试编写此问题的代码。

假设给定一个由 n 个节点组成的链表，每个节点存储一个整数。编写一个高效的 Java 代码，打印 n 个字符串数组中链表中奇数的所有循环移位。 例如，如果列表是 1 → 2 → 15 → 14 → 23，则输出将是一个字符串数组 str，使得

str [0] = “1, 15, 2300
, str [1] = “15, 23, 1
00, and str [2] = “23, 1, 1500.

请注意，数字之间用 ‘,’，它们之间没有空格。 您需要创建一个名为 Shifts 的类，该类具有以下方法：

public  static String[]
giveShifts (LinkedList<Integer> list)

。这里的list是一个维护整数的链表

我尝试调试我的代码，但无济于事。它遍历所有节点，一旦到达最后一个节点，该值为空。我不太清楚为什么。

import java.util.Arrays;

public class Shifts
{
    public static String[] giveShifts(LinkedList<Integer> list)
    {
        String[] result = new String[list.length()];
        StackInt odds = new StackInt(list.length());
        Node curr = list.head;

        while(curr != null)
        {
            if ((Integer)curr.getValue() % 2 == 0)
            {
                odds.push(((int)curr.getValue()));

            }
            curr = curr.next;
        }


            int[] nums = new int[list.length()];
            String numsStr = "";

            while(!odds.isEmpty())
            {
            for(int i=0; i<result.length; i++)
            {
             nums[i] = odds.pop();
            }

            numsStr = Arrays.toString(nums);

            for(int j=0; j<result.length; j++)
            {
                result[j] = numsStr;
            }
        }
        return result;
    }
}

Answer 1

我不明白您显示的输出如何在字符串数组的每个元素中将数字之一乘以 100。根据我对您问题的理解，这里有一个解决方案。

import java.util.Arrays;
import java.util.Collections;
import java.util.LinkedList;
import java.util.stream.Collectors;
import java.util.stream.IntStream;

public class Shifts {

    public static void main(String[] args) {
        LinkedList<Integer> list = Arrays.asList(1, 2, 15, 14, 23)
                .stream().filter(i -> i % 2 != 0)
                .collect(Collectors.toCollection(LinkedList::new));
        int oddCount = list.size();
        String[] results = new String[oddCount];
        IntStream.range(0, oddCount).forEach(index -> {
            Collections.rotate(list, 1);
            results[index] = list.stream()
                             .map(i -> i.toString())
                             .collect(Collectors.joining(","));
        });
        Arrays.asList(results).stream().forEach(System.out::println);
    }

}

从您的代码中提取，并且由于您可以使用队列，因此这里是改进的 giveShifts 方法

public static String[] giveShifts(LinkedList<Integer> list) {
        //since you need only odd numbers, filter out even ones
        list = list.stream().filter(i -> i % 2 != 0)
                .collect(Collectors.toCollection(LinkedList::new));
        int oddCount = list.size();
        String[] result = new String[oddCount];
        //type cast it to Queue as it will help understand the concept
        // shift is essentially, remove from head and add to tail in queue
        java.util.Queue<Integer> queue = list;
        for(int i=0;i<oddCount; i++){
            queue.add(queue.remove());
            result[i] = queue.stream()
                       .map(element -> element.toString())
                       .collect(Collectors.joining(","));
        }
        return result;
    }

Answer 2

将此行curr = curr.next 移动到循环的最后一行：

while(curr != null)
{
    if ((int)curr.getValue() % 2 == 0)
    {
        odds.enqueue(((int)curr.getValue()));
    }
    curr = curr.next;
}