# java determines whether a single linked list is a palindrome linked list

To judge whether a linked list is a palindrome linked list, you can use the stack or the speed pointer
These are the codes sorted out according to Zuo Chengyun's algorithm course

### 1. With the help of stack structure, the feature of first in and last out

Traverse the linked list and put it on the stack at one time, then traverse the linked list again and pop up the stack for comparison in turn. If it is identical, it means it is a palindrome linked list. If it is different, it is not

```private static boolean isPalindrome(Node head){
Stack<Node> stack = new Stack<>();
//Traverse the linked list and put it on the stack
while (null != cur){
stack.push(cur);
cur = cur.next;
}

//Traverse the linked list and exit for comparison in turn
return false;
}
}
return true;
}
```

### 2. Still use the stack while using the fast and slow pointers

Use the speed pointer to get the middle position of the linked list, and put the latter half of the linked list on the stack in turn. Similarly, use the first in then out feature to traverse the linked list again and out of the stack in turn. If the stack is empty, it is the palindrome linked list.
In the java language, there is no concept of pointer. The fast and slow pointer here controls the speed of traversing the linked list. When traversing the linked list, two variables are prepared for traversal at the same time. One variable traverses one node at a time and one variable traverses two nodes at a time, as shown below:

```public static class Node{
private int value;
private Node next;

public Node(int value) {
this.value = value;
}
}

while(node2.next != null && node2.next.next != null){
node1 = node1.next;//Traverse one node at a time
node2 = node2.next.next;//Traverse 2 nodes at a time
}
}
```

When there is only one node or no node behind node2, it ends. At this time, node2 has no nodes to traverse. At this time, node1 is in the middle position, and the node behind node1 is just the second half of the whole linked list. This method of finding the middle position of the linked list is called speed pointer.
The specific implementation code for judging palindromes is as follows

```private static boolean isPalindrome(Node head){
return true;
}
Stack<Node> stack = new Stack<>();
//Using fast and slow pointers to obtain intermediate nodes
while (cur.next != null && cur.next.next != null){
right = right.next;
cur = cur.next.next;
}
//Right half node stack
while (null != right){
stack.push(right);
right = right.next;
}
//Out of the stack, compared with the original linked list traversal
while (!stack.isEmpty()){
return false;
}
}
return true;
}
```

This method mainly makes use of the characteristics of palindrome linked list. The data of the first half of the linked list is the same as that of the second half, so just flip the second half of the linked list and compare it with the first half of the linked list.

This method has one more variable than the previous linked list, but the variables on the stack are half less and the additional space is half less

### 3. Without stack, use the linked list variable to flip the linked list for judgment

```private static boolean isPalindrome3(Node head){

//Speed the pointer to get the middle position of the linked list
while (n2.next != null && n2.next.next != null){
n1 = n1.next;
n2 = n2.next.next;
}
n2 = n1.next;
n1.next = null;
Node n3;
//Take the right half of the list and flip it
while (null != n2){
n3 = n2.next;
n2.next = n1;
n1 = n2;
n2 = n3;
}
n3 = n1;
//Traverse the original linked list and the overturned linked list, and compare them in turn
while (n1 != null && n2 != null){
//If you have different values, it means that it is not a palindrome linked list
if (n1.value != n2.value){
return false;
}
n1 = n1.next;
n2 = n2.next;
}
return true;
}
```

### Summary:

The first method is the simplest and quickest, which is best understood. Using the characteristics of the stack, first in and then out, is equivalent to flipping the linked list and comparing it with the original linked list, but it requires more additional space, and the additional space to be borrowed is O(n),
The second method is slightly improved because the linked list with only half of the stack is compared with the original linked list. The extra space needed is only half that of mode 1.
The code of the third method is difficult to understand, but the idea is very simple. Take the last half of the linked list and flip it. Compare it with the original linked list. If there are different node values, it is not a palindrome linked list. This makes use of the characteristics of palindromes. Without the help of stack, it only uses a few variables. The additional space required is O(1), constant level. The code of the third method mainly needs to understand the flip of the linked list. If you understand this, you can easily understand the code of the third method.
The latter two methods are optimized. The optimization principle is based on the characteristics of palindromes. The flip of the right half is completely consistent with that of the left.

Posted by james_kirk on Wed, 13 Oct 2021 10:25:33 -0700