Java 检查LinkedList中的回文-比较LinkedList和反向LinkedList。是否得到错误答案？ public类CheckPalindromeLL{ 公共静态void main（字符串参数[]） { 链接头=空； 链路l1=createLinkList1（头）； 链路l2=l1； System.out.println（“第一个链接列表”）； 显示器（l1）； System.out.println（“重新设置链接列表”）； 连杆转速=反向（l1）； 链接rev2=rev； 显示器（rev2）； System.out.println（“是回文”）； 比较（l1，rev）； } 专用静态链路反向（链路l11）{ 链路l12=l11； //TODO自动生成的方法存根 链接nextp； 链路电流=l12； 链接prevp=null； while（curr！=null） { nextp=当前下一个； 当前下一个=上一个； prevp=当前值； curr=nextp； } 返回prevp； } 专用静态布尔比较（链接d1、链接d2）{ 布尔标志=真； while（（d1！=null）&&（d2！=null）&&flag） { 如果（d1.num！=d2.num） {System.out.println（“不一样”）； flag=false； 打破 } 其他的 { System.out.println（“列表：+d1.num”）； System.out.println（“版本：+d2.num”）； 系统输出打印项次（“相同”）； d1=d1.next； d2=d2.1； } } System.out.println（“打印标志”+标志）； 返回标志； } 专用静态链接createLinkList1（链接头）{ //TODO自动生成的方法存根 Link firstlink=头； Link newLink=null； 扫描仪阅读器=新扫描仪（System.in）； System.out.println（“输入一个数字：”）； int x[]={1,2,3,1}； 对于（int i=0；i

，这里有一个ASCII艺术描述，描述了您的列表（单数）在每个步骤中的外观。我省略了多余的语句和打印语句：

public class CheckPalindromeLL {

    public static void main(String args[])
    {
        Link head=null;

        Link l1=createLinkList1(head);
        Link l2=l1;
        System.out.println("first linklist");
        display(l1);

        System.out.println("reveresed linklist");
        Link rev=reverse(l1);
        Link rev2=rev;
        display(rev2);
        System.out.println("IS PALINDROME");
        compare(l1,rev);
    }

    private static  Link reverse(Link l11) {
        Link l12=l11;
        // TODO Auto-generated method stub
        Link nextp;
        Link curr=l12;
        Link prevp=null;
        while(curr!=null)
        {
            nextp=curr.next;
            curr.next=prevp;
            prevp=curr;
            curr=nextp;
        }

        return prevp;
    }

    private static  boolean compare(Link d1, Link d2) {

        boolean flag=true;
        while((d1!=null) && (d2!=null)&& flag)
        {
            if(d1.num!=d2.num)
            { System.out.println("not same ");
                flag=false;
                break;
            } 
            else
            {
                System.out.println("list:"+d1.num);
                System.out.println("rev:"+d2.num);
                System.out.println(" same");
                d1=d1.next;
                d2=d2.next;
            }
        }

        System.out.println("printing flag"+flag);
        return flag;
    }

    private static  Link createLinkList1(Link head) {
        // TODO Auto-generated method stub
        Link firstlink=head;
        Link newLink = null;

        Scanner reader = new Scanner(System.in); 
        System.out.println("Enter a number: ");
        int x[]={1,2,3,1};
        for(int i=0;i<x.length;i++)
        {
            newLink=new Link(x[i]);
            newLink.next=firstlink;
            firstlink=newLink;
        }
        head= firstlink;
        return newLink;
    }

    public static  void display(Link start)
    { 
        Link s1=start;
        while(s1!=null)
        {
            System.out.println(s1.num);
            s1=s1.next;
        }
    }
}

linkl1=createLinkList1（head）；
l1-+
|
v
1->2->3->1->null
连杆转速=反向（l1）；
修订版------------------+
|
l1-+|
|              |
V V
null您需要创建原始列表的完整副本-顺序相反。这应该可以做到：

正如添加：如果您有一个双链接列表（如果您愿意调整实现…），您可以轻松检查回文，而无需创建反向副本：

编辑
只是一个噱头：检查回文而不复制列表（递归）：

要检查LinkedList是否为回文，可以使用以下代码：

请注意，这是一个双重链接列表

private static boolean isPalindrome(Link head)
{
    return head == null ? true : isPalindrome(new Link[] { head }, head);
}
private static boolean isPalindrome(Link[] head, Link tail)
{
    if(tail.next != null)
    {
        if(!isPalindrome(head, tail.next))
        {
            return false;
        }
        head[0] = head[0].next;
    }
    return head[0].value == tail.value;
}

公共类回文{
公共布尔值isAlindrome（链接列表）{
迭代器迭代器=list.Iterator（）；
迭代器reverseIterator=list.DegendingIterator（）；
while（迭代器.hasNext（）&&reverseIterator.hasNext（））{
如果（！iterator.next（）.equals（reverseIterator.next（）））{
返回false；
}
}
返回true；
}
}
只创建一个
链接
（即，对同一链接有两个引用）。
private static Link reverse(Link l)
{
    Link result = null;
    while(l != null)
    {
        Link ll = new Link(l.value);
        ll.next = result;
        result = ll;
        l = l.next;
    }
    return result;
}

private static boolean isPalindrome(Link head, Link tail)
{
    if(head == null)
    {
        return true; // arguable, if empty list is palindrome or not...
    }
    while(head != tail)
    {
        if(head.value != tail.value)
        {
            return false;
        }
        head = head.next;
        if(head == tail) // need this for even number of list elements
        {
            break;
        }
        tail = tail.previous;
    }
    return true;
}

private static boolean isPalindrome(Link head)
{
    return head == null ? true : isPalindrome(new Link[] { head }, head);
}
private static boolean isPalindrome(Link[] head, Link tail)
{
    if(tail.next != null)
    {
        if(!isPalindrome(head, tail.next))
        {
            return false;
        }
        head[0] = head[0].next;
    }
    return head[0].value == tail.value;
}

public class Palindrome<T extends Comparable>{
    public boolean isPalindrome(LinkedList<T> list){
        Iterator<T> iterator = list.iterator();
        Iterator<T> reverseIterator = list.descendingIterator();
        while(iterator.hasNext()&&reverseIterator.hasNext()){
            if(!iterator.next().equals(reverseIterator.next())){
                return false;
            }
        }
        return true;
    }
}