判断回文结构，在删除倒数第k个节点后，是否为回文结构

题目：判断一个链表是否是回文结构。在删除倒数第k个节点（从1开始）后，是否为回文结构。

(回文结构：从头到尾遍历节点的值序列结果，与从尾到头遍历的值序列结果是一样的)

示例 1:

输入: 1->2->5->8->2->1， k=4

输出: false  true

 

我的思考：

一个链表是否回文，依次比较第一个和最后一个，第二个和倒数第二······这样就可以了，

如果一个链表已经是回文，删除倒数第k个节点，再判断回文，就不要比较原来链表中已比较的节点，只需要比较变动的节点。

 

删除节点后是否为回文的判断，大致思路如下：

　　* 若原来不是回文，则从头判断
　　* 若原来是回文
　　　　1.删除节点在中间，还是回文，直接返回是true；
　　　　2.删除非中间的节点，从变动后节点开始判断是否为回文

　　对于这个删除节点k值需要分三类讨论：

1. k正好是中间节点：可以直接返回true；
2. k <  原链表长度的一半：从第k个节点开始判断回文；
3. k > 原链表长度的一半：从第size()（原链表长度）- k个节点判断回文。

　　以上三种情况可以简化为一个判断：先判断是否为中间节点，是则判断为是回文；否则从第Math.min(k - 1, list.size() - k + 1)个节点（从0开始）开始判断。

　　当然这个简化需要考虑到原链表长度是奇数还是偶数，我就不过多赘述了，以下是我写的简陋的解答：

import java.util.*;

public class Palindrome {
    private static boolean isPalindrome(List<Integer> list) {
        for (int i = 0; i < list.size() / 2; i++) {
            if (list.get(i).intValue() != list.get(list.size() - i - 1).intValue()) {
                return false;
            }
        }
        return true;
    }

    private static boolean isPalindrome(List<Integer> list, int k) {// k表示从第几位开始1 2 3··· 这里的list是被删除节点后的
        for (int i = Math.min(k - 1, list.size() - k + 1); i < list.size() / 2; i++) {
            if (list.get(i).intValue() != list.get(list.size() - i - 1).intValue()) {
                return false;
            }
        }
        return true;
    }

    // 删除链表倒数第K个元素
    private static void removNodeByNumber(List<Integer> list, int k) {
        list.remove(list.size() - k);
//        Iterator<Integer> iterator = list.iterator();
//        for (int i = 0; iterator.hasNext(); k--) {
//            iterator.next();
//            if (i == list.size() - k ) {
//                iterator.remove();
//            }
//        }
    }

    public static void main(String[] args) {
        int[] arr = { 1, 2, 5, 8, 2, 1 };
        List<Integer> list = new LinkedList<>();
        int k = 4;// 要删除的倒数第k位 从1开始
        boolean flag;
        for (int n : arr)
            list.add(n);

//        System.out.println(list.toString() + list.size());
        flag = isPalindrome(list);
        System.out.println(flag);
        /*
         * 若原来不是回文，则从头判断
         * 若原来是回文
         * 1.删除节点在中间，还是回文
         * 2.删除非中间的节点，从第i=min(k-1, size()-k)开始判断回文
         */
        if (k <= 0 || k > list.size() ) {
            throw new IllegalArgumentException("k值异常");
        }
        if (!flag) {
            removNodeByNumber(list, k);
//            System.out.println(list.toString() + list.size());
            System.out.println(isPalindrome(list));
        } else if (k == list.size()/2 + list.size() % 2 || list.size() % 2 == 0 && k == list.size()/2 + 1) {
            System.out.println(flag);
            removNodeByNumber(list, k);
//            System.out.println(list.toString() + list.size());
        } else {
            removNodeByNumber(list, k);
//            System.out.println(list.toString() + list.size());
            System.out.println(isPalindrome(list, k));
        }
    }
}