Question

我正在尝试使用以下代码，但结果始终为true;

public boolean isPallindrome(Link link, Link right) {
    if (right == null)
        return true;

    if (!isPallindrome(link, right.getNext())) {
        return false;
    }
    boolean isP1 = right.getData() == link.getData();
    link = link.getNext();
    return isP1;
}

致电： -

System.out.println(link1.isPallindrome(link1.getFirst(), link1.getFirst()));

我认为罪魁祸首是从right对null进行检查的回报。它总是可以返回true。有人可以建议如何解决这个问题。

Answer 1

这是您的算法的样子

boolean flag=true;
public boolean checkPalindrome(List nodeList,boolean flag)
{
    if(flag==false)
        return false;
    if(nodeList.right==null)
        return flag;
    else{
        Node n;//reference for travelling till last node
        //traverse till last node

        //check first and last node

        if(same){
            //delete both nodes;
        }
        else{
            flag=false;
        }
        return checkPalindrome(nodeList,flag)

    }
}

这只是你需要前进的指针。

如果您需要再次返回原始列表，则可能需要复制其他对象中的列表内容并在此方法中使用该对象

希望这有帮助！

祝你好运！

Answer 2

我可以进入你的方法。你希望link.getNext()应该对之前的电话有效。你能行的。只需更改函数原型。

public boolean isPallindrome（Link &link，Link right）;

确保您的初始通话没有受到影响。

Answer 3

老实说，我不遵循你的方法的一般逻辑。我想提出一个完全不同的建议，加上一些假设。

有问题的列表是否有双重联系？如果是这样，那么你可以从两端进行遍历，在假想的回文的两端从外部进行操作。如果两端不匹配，则列表显然不是回文。

Answer 4

您应该使用Java实用程序类（或者至少实现接口），并且明确地为api添加书签。如果你有一个双重链接列表，那么寻找一个pallindrome是最快的，Java称之为Deque。不幸的是，这种方法破坏了原始方法。

public static boolean <E> isPallindrome(Deque<E> deque) {
    if ( deque.size() <= 1 ) {
        return true;
    }
    E first = deque.removeFirst();
    E last = deque.removeLast();
    if ( deque.size() == 0 ) {
        return first.equals(last);
    }
    return isPallindrome(deque)
}

如果你想获得更好的，你可以使用迭代器，并跳过递归。

如果您只有一个链接列表，那么您将需要一种方法来到列表的末尾。一种方法是跟踪列表的大小。由于所有O(n^2) ting，这最终都是get。

public static boolean isPallindrome(List<?> list, int size) {
    if ( size <= 1 ) {
        return true;
    }
    if ( ! list.get(0).equals(list.get(size-1)) ) {
        return false;
    }
    return isPallindrome(list.subList(1,size-1));
}

Answer 5

问题在于：
link = link.getNext（）; 你的意图是让更改反映在所有递归的向后调用中，但你最终做的是仅在当前堆栈中本地更改引用，发布左链接未在后续调用中反映。

如果它是C，C ++，你可以将参数作为Link **，Link *吧但是有了引用，你需要让Left Link在外面静止。

Answer 6

    public class PalindromeList {
    static Node left;
    public static void main(String[] args) {
        Node node = new Node(5);
        Node node1 = new Node(4, node);
        Node node2 = new Node(7, node1);
        Node node4 = new Node(6, node2);
        Node node5 = new Node(5, node4);
        left = node5;
        System.out.println(isPalindrome(node));
    }


    static boolean isPalindrome(Node right) {
        if (right == null)
            return true;
        boolean isp = isPalindrome(right.next);
        if (isp == false)
            return false;
        boolean isp1 = (right.value == left.value);
        left = left.next;
        return isp1;
    }
}

Answer 7

问题在于左指针移动。你需要使用一些容器覆盖左指针来激发Java中的双指针（或通过引用调用它）（总是通过值传递）。让我们使用大小为1的数组作为容器，它将起作用。我在这里使用不同的名字。

public class LinkedListS<T> {

    protected Node head;
    public boolean isPalindrome()
    {
        Node storeHead = head;
        boolean result = isPalindromeUtil(new Node[]{head},head); //have to stimulate pass by reference
        head = storeHead;
        return result;
    }

    private boolean isPalindromeUtil(Node[] left,Node right)
    {
        if(right==null)
            return  true;

        boolean subResult = isPalindromeUtil(left,right.next);
        if (subResult==false)
            return false;

        boolean dataCompareResultForCurrentPosition = false;
        if(left[0].data == right.data)
            dataCompareResultForCurrentPosition = true;

        left[0]=left[0].next; //critical

        return dataCompareResultForCurrentPosition;
    }
}

Answer 8

实际上不断缩小列表。在下面的代码中，第一个调用将head保留为first，将null保留为last。在后续调用中，第一个将成为first.next，last将成为列表中的最后一个节点的地址字段值。

boolean palindromeCheck(List first, List last)
{
    //For even size of List
    if(first == last)
        return true;
    //For odd size of List.
    if(first.next == last)
        return true;
    List newLast = first.next;
    //Traverse till last element.
    while(newLast.next != last)
        newLast = newLast.next;
    //If value is not same, return false.
    if(first.val != newLast.val)
        return false;
    return palindromCheck( first.next, newLast );
}

检查链表是否是回文（递归）

8 个答案: