检查单链表是否为回文的 Javascript 程序

给定一个单链字符列表，编写一个函数，如果给定列表是回文，则返回 true，否则返回 false。

方法 1（使用堆栈）

• 一个简单的解决方案是使用一堆列表节点。这主要涉及三个步骤。
• 从头到尾遍历给定列表，并将每个访问的节点推送到堆栈。
• 再次遍历列表。对于每个访问的节点，从堆栈中弹出一个节点，并将弹出节点的数据与当前访问的节点进行比较。
• 如果所有节点都匹配，则返回 true，否则返回 false。

下图是上述方法的试运行：

以下是上述方法的实现：

Javascript

// JavaScript program to check if
// linked list is palindrome recursively
class Node
{
    constructor(val)
    {
        this.data = val;
        this.ptr = null;
    }
}
     
var one = new Node(1);
var two = new Node(2);
var three = new Node(3);
var four = new Node(4);
var five = new Node(3);
var six = new Node(2);
var seven = new Node(1);
one.ptr = two;
two.ptr = three;
three.ptr = four;
four.ptr = five;
five.ptr = six;
six.ptr = seven;
var condition = isPalindrome(one);
document.write("isPalidrome: " + condition);
     
function isPalindrome(head)
{
    var slow = head;
    var ispalin = true;
    var stack = [];
 
    while (slow != null)
    {
        stack.push(slow.data);
        slow = slow.ptr;
    }
 
    while (head != null)
    {
        var i = stack.pop();
        if (head.data == i)
        {
            ispalin = true;
        }
        else
        {
            ispalin = false;
            break;
        }
        head = head.ptr;
    }
    return ispalin;
}
// This code is contributed by todaysgaurav

Javascript

// Javascript program to check if
// linked list is palindrome
 
// Head of list
var head;
var slow_ptr,
    fast_ptr, second_half;
 
// Linked list Node
class Node
{
    constructor(val)
    {
        this.data = val;
        this.next = null;
    }
}
 
// Function to check if given linked list
// is palindrome or not
function isPalindrome(head)
{
    slow_ptr = head;
    fast_ptr = head;
    var prev_of_slow_ptr = head;
 
    // To handle odd size list
    var midnode = null;
 
    // Initialize result
    var res = true;
 
    if (head != null &&
        head.next != null)
    {
        // Get the middle of the list.
        // Move slow_ptr by 1 and fast_ptrr
        // by 2, slow_ptr will have the middle node
        while (fast_ptr != null &&
               fast_ptr.next != null)
        {
            fast_ptr = fast_ptr.next.next;
 
            // We need previous of the slow_ptr for
            //  linked lists with odd elements
            prev_of_slow_ptr = slow_ptr;
            slow_ptr = slow_ptr.next;
        }
         
        // fast_ptr would become NULL when there are
        // even elements in the list and not NULL for
        // odd elements. We need to skip the middle
        // node for odd case and store it somewhere
        // so that we can restore the original list        
        if (fast_ptr != null)
        {
            midnode = slow_ptr;
            slow_ptr = slow_ptr.next;
        }
 
        // Now reverse the second half and
        // compare it with first half
        second_half = slow_ptr;
 
        // NULL terminate first half
        prev_of_slow_ptr.next = null;
   
        // Reverse the second half
        reverse();
 
        // compare
        res = compareLists(head, second_half);
 
        // Construct the original list back
        // Reverse the second half again
        reverse();
 
        if (midnode != null)
        {
            // If there was a mid node (odd size case)
            // which was not part of either first half
            // or second half.
            prev_of_slow_ptr.next = midnode;
            midnode.next = second_half;
         }
         else
             prev_of_slow_ptr.next = second_half;
    }
    return res;
}
 
// Function to reverse the linked list.
// Note that this function may change the
// head
function reverse()
{
    var prev = null;
    var current = second_half;
    var next;
    while (current != null)
    {
        next = current.next;
        current.next = prev;
        prev = current;
        current = next;
    }
    second_half = prev;
}
 
// Function to check if two input
// lists have same data
function compareLists(head1, head2)
{
    var temp1 = head1;
    var temp2 = head2;
 
    while (temp1 != null &&
           temp2 != null)
    {
        if (temp1.data == temp2.data)
        {
            temp1 = temp1.next;
            temp2 = temp2.next;
        }
        else
            return false;
    }
 
    // Both are empty return 1
    if (temp1 == null &&
        temp2 == null)
        return true;
 
    //Will reach here when one is NULL
    //  and other is not
    return false;
}
 
// Push a node to the linked list.
// Note that this function changes the head
function push(new_data)
{
    // Allocate the Node & Put in the data
    var new_node = new Node(new_data);
 
    // link the old list off the new one
    new_node.next = head;
 
    // Move the head to point to new Node
    head = new_node;
}
 
// A utility function to point a
// given linked list
function printList(ptr)
{
    while (ptr != null)
    {
        document.write(ptr.data + "->");
        ptr = ptr.next;
    }
        document.write("NULL<br/>");
}
 
// Driver code
 
// Start with the empty list
var str = ['a', 'b', 'a',
           'c', 'a', 'b', 'a'];
var string = str.toString();
         
for (i = 0; i < 7; i++)
{
    push(str[i]);
    printList(head);
    if (isPalindrome(head) != false)
    {
        document.write("Is Palindrome");
        document.write("<br/>");
    }
    else
    {
        document.write("Not Palindrome");
        document.write("<br/>");
    }
}
// This code is contributed by gauravrajput1

Javascript

// Javascript program to implement
// the above approach
 
// Head of the list
var head;
var left;
 
class Node
{
    constructor(val)
    {
        this.data = val;
        this.next = null;
    }
}
 
// Initial parameters to this function
// are &head and head
function isPalindromeUtil(right)
{
    left = head;
 
    // Stop recursion when right
    // becomes null
    if (right == null)
        return true;
 
    // If sub-list is not palindrome then
    // no need to check for the current
    // left and right, return false
    var isp = isPalindromeUtil(right.next);
    if (isp == false)
        return false;
 
    // Check values at current left and right
    var isp1 = (right.data == left.data);
 
    left = left.next;
 
    // Move left to next node;
    return isp1;
}
 
// A wrapper over isPalindrome(Node head)
function isPalindrome(head)
{
    var result = isPalindromeUtil(head);
    return result;
}
 
// Push a node to linked list.
// Note that this function changes
// the head
function push(new_data)
{
    // Allocate the node and
    //  put in the data
    var new_node = new Node(new_data);
 
    // Link the old list off the
    // the new one
    new_node.next = head;
 
    // Move the head to point to new node
    head = new_node;
}
 
// A utility function to point a
// given linked list
function printList(ptr)
{
    while (ptr != null)
    {
        document.write(ptr.data + "->");
        ptr = ptr.next;
    }
    document.write("Null ");
    document.write("<br>");
 
}
 
// Driver Code
var str = ['a', 'b', 'a',
           'c', 'a', 'b', 'a'];
for (var i = 0; i < 7; i++)
{
    push(str[i]);
    printList(head);
 
     if (isPalindrome(head))
     {
         document.write("Is Palindrome");
         document.write("<br/>");
         document.write("<br>");
     }
     else
     {
         document.write("Not Palindrome");
         document.write("<br/>");
         document.write("<br/>");
     }
}
// This code is contributed by aashish1995
/script></code></pre></div><br><hr></div><p><strong>输出：</strong> </p><div class="hcb_wrap"><pre class="prism undefined-numbers lang-js" data-lang="JavaScript"><code class="replace">isPalindrome: true</code></pre></div><p><strong>时间复杂度：</strong> O(n)。</p><p><strong>方法 2（通过反转列表）：</strong><br>此方法需要 O(n) 时间和 O(1) 额外空间。<br> <strong>1）</strong>获取链表的中间。<br> <strong>2）</strong>反转链表的后半部分。<br> <strong>3)</strong>检查前半部分和后半部分是否相同。<br> <strong>4）</strong>通过再次反转后半部分并将其附加回前半部分来构造原始链表</p><p>要将列表分成两半，使用本文的方法 2。</p><p>当多个节点是偶数时，前半部分和后半部分正好包含半个节点。这种方法的挑战在于处理节点数为奇数的情况。我们不希望中间节点作为列表的一部分，因为我们将比较它们是否相等。对于奇怪的情况，我们使用单独的变量“中间节点”。</p><div class="responsive-tabs"><h2 class="tabtitle"> Javascript </h2><div class="tabcontent"><div class="hcb_wrap"><pre class="prism undefined-numbers lang-js" data-lang="JavaScript"><code class="replace"><script>
// Javascript program to check if
// linked list is palindrome
 
// Head of list
var head;
var slow_ptr,
    fast_ptr, second_half;
 
// Linked list Node
class Node
{
    constructor(val)
    {
        this.data = val;
        this.next = null;
    }
}
 
// Function to check if given linked list
// is palindrome or not
function isPalindrome(head)
{
    slow_ptr = head;
    fast_ptr = head;
    var prev_of_slow_ptr = head;
 
    // To handle odd size list
    var midnode = null;
 
    // Initialize result
    var res = true;
 
    if (head != null &&
        head.next != null)
    {
        // Get the middle of the list.
        // Move slow_ptr by 1 and fast_ptrr
        // by 2, slow_ptr will have the middle node
        while (fast_ptr != null &&
               fast_ptr.next != null)
        {
            fast_ptr = fast_ptr.next.next;
 
            // We need previous of the slow_ptr for
            //  linked lists with odd elements
            prev_of_slow_ptr = slow_ptr;
            slow_ptr = slow_ptr.next;
        }
         
        // fast_ptr would become NULL when there are
        // even elements in the list and not NULL for
        // odd elements. We need to skip the middle
        // node for odd case and store it somewhere
        // so that we can restore the original list        
        if (fast_ptr != null)
        {
            midnode = slow_ptr;
            slow_ptr = slow_ptr.next;
        }
 
        // Now reverse the second half and
        // compare it with first half
        second_half = slow_ptr;
 
        // NULL terminate first half
        prev_of_slow_ptr.next = null;
   
        // Reverse the second half
        reverse();
 
        // compare
        res = compareLists(head, second_half);
 
        // Construct the original list back
        // Reverse the second half again
        reverse();
 
        if (midnode != null)
        {
            // If there was a mid node (odd size case)
            // which was not part of either first half
            // or second half.
            prev_of_slow_ptr.next = midnode;
            midnode.next = second_half;
         }
         else
             prev_of_slow_ptr.next = second_half;
    }
    return res;
}
 
// Function to reverse the linked list.
// Note that this function may change the
// head
function reverse()
{
    var prev = null;
    var current = second_half;
    var next;
    while (current != null)
    {
        next = current.next;
        current.next = prev;
        prev = current;
        current = next;
    }
    second_half = prev;
}
 
// Function to check if two input
// lists have same data
function compareLists(head1, head2)
{
    var temp1 = head1;
    var temp2 = head2;
 
    while (temp1 != null &&
           temp2 != null)
    {
        if (temp1.data == temp2.data)
        {
            temp1 = temp1.next;
            temp2 = temp2.next;
        }
        else
            return false;
    }
 
    // Both are empty return 1
    if (temp1 == null &&
        temp2 == null)
        return true;
 
    //Will reach here when one is NULL
    //  and other is not
    return false;
}
 
// Push a node to the linked list.
// Note that this function changes the head
function push(new_data)
{
    // Allocate the Node & Put in the data
    var new_node = new Node(new_data);
 
    // link the old list off the new one
    new_node.next = head;
 
    // Move the head to point to new Node
    head = new_node;
}
 
// A utility function to point a
// given linked list
function printList(ptr)
{
    while (ptr != null)
    {
        document.write(ptr.data + "->");
        ptr = ptr.next;
    }
        document.write("NULL<br/>");
}
 
// Driver code
 
// Start with the empty list
var str = ['a', 'b', 'a',
           'c', 'a', 'b', 'a'];
var string = str.toString();
         
for (i = 0; i < 7; i++)
{
    push(str[i]);
    printList(head);
    if (isPalindrome(head) != false)
    {
        document.write("Is Palindrome");
        document.write("<br/>");
    }
    else
    {
        document.write("Not Palindrome");
        document.write("<br/>");
    }
}
// This code is contributed by gauravrajput1

输出：

a->NULL
Is Palindrome

b->a->NULL
Not Palindrome

a->b->a->NULL
Is Palindrome

c->a->b->a->NULL
Not Palindrome

a->c->a->b->a->NULL
Not Palindrome

b->a->c->a->b->a->NULL
Not Palindrome

a->b->a->c->a->b->a->NULL
Is Palindrome

时间复杂度： O(n)
辅助空间： O(1)

方法 3（使用递归）：
使用左右两个指针。使用递归左右移动并检查每个递归调用中的跟随。
1）子列表是回文。
2）当前左右的值是匹配的。

如果上述两个条件都为真，则返回真。

这个想法是使用函数调用堆栈作为容器。递归遍历直到列表的末尾。当我们从最后一个 NULL 返回时，我们将在最后一个节点。最后一个节点将与列表的第一个节点进行比较。

为了访问列表的第一个节点，我们需要列表头在最后一次递归调用中可用。因此，我们也将 head 传递给递归函数。如果它们都匹配，我们需要比较 (2, n-2) 个节点。同样，当递归回退到 (n-2)nd 节点时，我们需要从头开始引用第二个节点。我们在前一个调用中推进头指针，以指向列表中的下一个节点。
然而，诀窍是识别双指针。传递单个指针与传递值一样好，我们将一次又一次地传递同一个指针。我们需要传递头指针的地址来反映父递归调用的变化。
感谢Sharad Chandra提出这种方法。

Javascript

// Javascript program to implement
// the above approach
 
// Head of the list
var head;
var left;
 
class Node
{
    constructor(val)
    {
        this.data = val;
        this.next = null;
    }
}
 
// Initial parameters to this function
// are &head and head
function isPalindromeUtil(right)
{
    left = head;
 
    // Stop recursion when right
    // becomes null
    if (right == null)
        return true;
 
    // If sub-list is not palindrome then
    // no need to check for the current
    // left and right, return false
    var isp = isPalindromeUtil(right.next);
    if (isp == false)
        return false;
 
    // Check values at current left and right
    var isp1 = (right.data == left.data);
 
    left = left.next;
 
    // Move left to next node;
    return isp1;
}
 
// A wrapper over isPalindrome(Node head)
function isPalindrome(head)
{
    var result = isPalindromeUtil(head);
    return result;
}
 
// Push a node to linked list.
// Note that this function changes
// the head
function push(new_data)
{
    // Allocate the node and
    //  put in the data
    var new_node = new Node(new_data);
 
    // Link the old list off the
    // the new one
    new_node.next = head;
 
    // Move the head to point to new node
    head = new_node;
}
 
// A utility function to point a
// given linked list
function printList(ptr)
{
    while (ptr != null)
    {
        document.write(ptr.data + "->");
        ptr = ptr.next;
    }
    document.write("Null ");
    document.write("<br>");
 
}
 
// Driver Code
var str = ['a', 'b', 'a',
           'c', 'a', 'b', 'a'];
for (var i = 0; i < 7; i++)
{
    push(str[i]);
    printList(head);
 
     if (isPalindrome(head))
     {
         document.write("Is Palindrome");
         document.write("<br/>");
         document.write("<br>");
     }
     else
     {
         document.write("Not Palindrome");
         document.write("<br/>");
         document.write("<br/>");
     }
}
// This code is contributed by aashish1995
/script>
</code></pre></div></div></div><p><strong>输出：</strong> </p><div class="hcb_wrap"><pre class="prism undefined-numbers lang-js" data-lang="JavaScript"><code class="replace">a->NULL
Not Palindrome

b->a->NULL
Not Palindrome

a->b->a->NULL
Is Palindrome

c->a->b->a->NULL
Not Palindrome

a->c->a->b->a->NULL
Not Palindrome

b->a->c->a->b->a->NULL
Not Palindrome

a->b->a->c->a->b->a->NULL
Is Palindrome</code></pre></div><p><strong>时间复杂度：</strong> O(n)<br><strong>辅助空间：</strong>如果考虑函数调用堆栈大小，则为 O(n)，否则为 O(1)。</p><p>请参阅完整的函数文章来检查单链表是否为回文以获取更多详细信息！<br></p><br></div></article>

                </div>

            </div>
        </div>
    </div>
</div>


  
<footer>
    <div class="bg-white text-center pb-1">
        <p class="text-body-tertiary pt-3 lh-lg text-opacity-50" id="footer-text">Copyright &copy; 2020 - 2024 版权所有
            <br>

            <a href="https://beian.miit.gov.cn/" target="_blank"
                class="text-opacity-50 text-body-tertiary mt-1 mb-1">蜀ICP备20006366号-1</a>

            <br>
            Made with ❤️ in Chengdu
        </p>
    </div>
</footer>


  <!-- 引入Bootstrap JavaScript库 -->
  <script src="https://unpkg.com/bootstrap@5.3.0-alpha1/dist/js/bootstrap.bundle.min.js"
    crossorigin="anonymous">