Палиндром

/**
 * public class ListNode {
 *     public int val;
 *     public ListNode next;
 *     public ListNode(int val, ListNode next=null) {
 *         this.val = val;
 *         this.next = next;
 *     }
 * }
 */

public class Solution {  
    public static ListNode MiddleNode(ListNode head) {
        ListNode fast = head;
        ListNode slow = head;
        while (fast != null && fast.next != null) {
            slow = slow.next;
            fast = fast.next.next;
        }
        return slow;
    }

    public static ListNode ReverseList(ListNode head) {
        ListNode curr = head;
        ListNode prev = null;
        while (curr != null) {
            ListNode tmp = curr;
            curr = curr.next;
            tmp.next = prev;
            prev = tmp;
        }
        return prev;
    }
    
    public static bool IsPalindrome(ListNode head) {
        ListNode firstHalfEnd = MiddleNode(head);
        ListNode secondHalfBegin = ReverseList(firstHalfEnd);
        ListNode p1 = head;
        ListNode p2 = secondHalfBegin;
        while (p2 != null) {
            if (p1.val != p2.val) {
                return false;
            }
            p1 = p1.next;
            p2 = p2.next;
        }
        return true;
    }
}

#include <vector>

using namespace std;

/**
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode(int x) : val(x), next(nullptr) {}
 * };
 */

ListNode* middleNode(ListNode* head) {
    ListNode* fast = head;
    ListNode* slow = head;
    while (fast != nullptr && fast->next != nullptr) {
        slow = slow->next;
        fast = fast->next->next;
    }
    return slow;
}

ListNode* reverseList(ListNode* head) {
    ListNode* curr = head;
    ListNode* prev = nullptr;
    while (curr != nullptr) {
        ListNode* tmp = curr;
        curr = curr->next;
        tmp->next = prev;
        prev = tmp;
    }
    return prev;
}

bool isPalindrome(ListNode* head) {
    ListNode* firstHalfEnd = middleNode(head);
    ListNode* secondHalfBegin = reverseList(firstHalfEnd);
    ListNode* p1 = head;
    ListNode* p2 = secondHalfBegin;
    while (p2 != nullptr) {
        if (p1->val != p2->val) {
            return false;
        }
        p1 = p1->next;
        p2 = p2->next;
    }
    return true;
}

package main

/**
 * type ListNode struct {
 *     Val  int
 *     Next *ListNode
 * }
 */

func middleNode(head *ListNode) *ListNode {
    fast, slow := head, head
    for fast != nil && fast.Next != nil {
        slow = slow.Next
        fast = fast.Next.Next
    }
    return slow
}

func reverseList(head *ListNode) *ListNode {
    curr := head
    var prev *ListNode = nil
    for curr != nil {
        tmp := curr
        curr = curr.Next
        tmp.Next = prev
        prev = tmp
    }
    return prev
}

func isPalindrome(head *ListNode) bool {
    firstHalfEndCode := middleNode(head)
    secondHalfBeginCode := reverseList(firstHalfEndCode)
    p1 := head
    p2 := secondHalfBeginCode
    for p2 != nil {
        if p1.Val != p2.Val {
            return false
        }
        p1 = p1.Next
        p2 = p2.Next
    }
    return true
}

import java.util.*;

/**
 * class ListNode {
 *     Integer val;
 *     ListNode next;
 *     ListNode() {}
 *     ListNode(Integer val) { this.val = val; }
 *     ListNode(Integer val, ListNode next) {
 *         this.val = val;
 *         this.next = next;
 *     }
 * }
 */

public class Solution {
    public ListNode middleNode(ListNode head) {
        ListNode fast = head;
        ListNode slow = head;
        while (fast != null && fast.next != null) {
            slow = slow.next;
            fast = fast.next.next;
        }
        return slow;
    }

    public ListNode reverseList(ListNode head) {
        ListNode curr = head;
        ListNode prev = null;
        while (curr != null) {
            ListNode tmp = curr;
            curr = curr.next;
            tmp.next = prev;
            prev = tmp;
        }
        return prev;
    }

    public boolean isPalindrome(ListNode head) {
        ListNode firstHalfEnd = middleNode(head);
        ListNode secondHalfBegin = reverseList(firstHalfEnd);
        ListNode p1 = head;
        ListNode p2 = secondHalfBegin;
        while (p2 != null) {
            if (!p1.val.equals(p2.val)) {
                return false;
            }
            p1 = p1.next;
            p2 = p2.next;
        }
        return true;
    }
}

from list_node import ListNode

# class ListNode:
#     def __init__(self, val, next=None):
#         self.val = val
#         self.next = next

def middle_node(head: Optional[ListNode]) -> Optional[ListNode]:
    fast, slow = head, head
    while fast and fast.next:
        slow = slow.next
        fast = fast.next.next
    return slow

def reverse_list(head: Optional[ListNode]) -> Optional[ListNode]:
    curr = head
    prev = None
    while curr:
        tmp = curr
        curr = curr.next
        tmp.next = prev
        prev = tmp
    return prev

def is_palindrome(head: Optional[ListNode]) -> bool:
    first_half_end = middle_node(head)
    second_half_begin = reverse_list(first_half_end)
    p1, p2 = head, second_half_begin
    while p2:
        if p1.val != p2.val:
            return False
        p1 = p1.next
        p2 = p2.next
    return True

import { ListNode } from './listNode.js';

/**
 * class ListNode {
 *     constructor(val, next) {
 *         this.val = val;
 *         this.next = (next === undefined ? null : next);
 *     }
 * }
 */

/**
 * @param {ListNode} head
 * @returns {boolean}
 */
function middleNode(head) {
    let fast = head;
    let slow = head;
    while (fast && fast.next) {
        slow = slow.next;
        fast = fast.next.next;
    }
    return slow;
}

function reverseList(head) {
    let curr = head;
    let prev = null;
    while (curr) {
        const tmp = curr;
        curr = curr.next;
        tmp.next = prev;
        prev = tmp;
    }
    return prev;
}

export function isPalindrome(head) {
    const firstHalfEnd = middleNode(head);
    const secondHalfBegin = reverseList(firstHalfEnd);
    let p1 = head;
    let p2 = secondHalfBegin;
    while (p2) {
        if (p1.val !== p2.val) {
            return false;
        }
        p1 = p1.next;
        p2 = p2.next;
    }
    return true;
}