Java 反转链表时出现奇怪的 NullPointerException

Question

I'm working on a LeetCode problem called " Palindrome Linked List ", where a singly linked list is given, determine if it is a palindrome. For example, if the input is 1->2->2->1, it should output true.

I solved it by using extra space (converting the list into an ArrayList), and now I'm trying to solve it by another approach, reversing the 2nd half of list and then compare the two halves . Although I might have not implemented the idea in the best way, I expected the code to either work or output a wrong answer (then I could improve the code). However, a weird NullPointerException happened, and I couldn't figure out why.

My code is shown below, and the input list for testing is 1->2->3 . I also added some prints to help debug.

// reverse the 2nd half of list and then compare the two halves

class Solution {
    public boolean isPalindrome(ListNode head) {
        int n = 0; // list length
        ListNode p = head;
        while (p != null) { // obtain list length n 
            n++;
            p = p.next;
        }
        p = head;


        int m = 0;
        ListNode prev = null, curr = null, temp = null;
        while (p != null) { // reverse the 2nd half of list
            m++;
            if (m == n/2 + 1) {
                prev = p;
                curr = p.next;
                p = p.next;

                System.out.println(curr.val);
                System.out.println(curr);
                //System.out.println(p);
            }
            else if (m > n/2 + 1) {
                //System.out.println(p);
                System.out.println(curr);
                //System.out.println(curr.val);

                temp = curr.next;
                curr.next = prev;
                prev = curr;
                curr = temp;
                p = p.next;
            }
            else 
                p = p.next;
        }


        int k = 1;
        while (k < n/2 + 1) { // compare the two halves, prev points at the last node
            if (head.val != prev.val)
                return false;
            head = head.next;
            prev = prev.next;
            k++;
        }
        return true;
    }    
}

The output (when input 1->2->3, plus some print statements) is:

NullPointerException thrown at the line: temp = curr.next; (which is inside the else if)

the code also prints:
3
ListNode@77a567e1
ListNode@77a567e1
null 

curr is referring to the last node, so curr.val is 3. What I don't understand is why the two System.out.println(curr) give different outputs. Shouldn't curr be referring to the last node? Where does the null in the output come from? I think that is the key for why NullPointerException happened there.

I'm very confused right now, if someone could help me understand what went wrong, I'd really appreciate it. Thanks.

Edit: Since this is a LeetCode question, the ListNode class is predefined, I don't need to write it myself.

Answer 1

Perhaps, you should have implemented your isPalindrome method using LinkedList from Java common Collections using iterator and descendingIterator :

LinkedList<Integer> list = new LinkedList<>(Arrays.asList(1, 2, 3));
System.out.printf("list: %s palindrome: %s%n", list,  isPalindrome(list));
// ...

  public boolean isPalindrome(LinkedList<Integer> list) {
    Iterator<Integer> directIterator = list.iterator();
    Iterator<Integer> reverseIterator = list.descendingIterator();
    int count = list.size() / 2;
    while (directIterator.hasNext() && reverseIterator.hasNext() && count-- > 0) {
      if (directIterator.next().intValue() != reverseIterator.next().intValue()) {
        return false;
      }
    }
    return true;
  }

Update: a solution for the requested single-linked list using a reversed list:

    public boolean isPalindrome(ListNode head) {
        // empty and single element list is palindrome
        if (null == head || null == head.next) {
            return true;
        }
        // build reverse linked list
        ListNode curr = head;
        ListNode tail = new ListNode(curr.val);
        tail.next = null;
        ListNode prev = null;
        int size = 1;
        while (null != curr.next) {
            prev = tail;
            curr = curr.next;
            tail = new ListNode(curr.val);
            tail.next = prev;
            size++;
        }
        // move both from head and from tail to the middle element
        int half = size / 2;
        curr = head;
        prev = tail;
        while (null != curr && null != prev && half-- > 0) {
            if (curr.val != prev.val) {
                return false;
            }
            curr = curr.next;
            prev = prev.next;
        }
        return true;
    }

Answer 2

Your given input is 1->2->3 so your n is 3.

Before Entering the while loop you have initialized

curr = null;

Your program enters while loop

First Iteration

• m++; value of m=1

• 1 == 3/2+1 false so enter else if again false so it goes to else

values after 1st iteration

m = 1; curr=null prev=null and p=2(points to node value 2)

Second iteration

• m=2

• 2 == 3/2+1 true goes inside if

• prev = 1, curr & p = 3(node with value 3)

• Print curr.val which is 3 and curr which prints "ListNode@77a567e1"

Values after 2nd iteration

m = 2; prev=2, curr & p=3(node with value 3)

Third Iteration

• m=3

• 3>3/2+1 true so enters else if

• Print curr prints "ListNode@77a567e1"

• temp = curr.next as curr is 3 its next is null

• curr = temp; as temp = null curr is null

Forth Iteration

so as curr is null on forth iteration it prints null and throws null pointer exception.