1. Reverse a Linked-List

 ListNode *reverseList(ListNode *head)
    {
        ListNode *temp = head;
        ListNode *prev = NULL;

        while (temp != NULL)
        {
            ListNode *front = temp->next;
            temp->next = prev;
            prev = temp;
            temp = front;
        }
        return prev;
    }
    ListNode* reverseListRecursive(ListNode* head) {
        if(head==NULL || head->next==NULL) return head;
        
        ListNode* nextNode = reverseList(head->next);

        ListNode* front = head->next;
        front->next=head;
        head->next=NULL;
        return nextNode;
    }

2. Reverse in-between

ListNode *reverseBetween(ListNode *head, int left, int right)
    {
        ListNode *dummy = new ListNode(0);
        dummy->next = head;

        ListNode *prev = dummy;

        for (int i = 1; i < left; i++)
            prev = prev->next;
        ListNode *curr = prev->next;

        for (int i = 0; i < right - left; i++)
        {
            ListNode *nextNode = curr->next;
            curr->next = nextNode->next;
            nextNode->next = prev->next;
            prev->next = nextNode;
        }
        return dummy->next;
    }

3. Reverse in K-groups

Given the head of a singly linked list containing integers, reverse the nodes of the list in groups of k and return the head of the modified list. If the number of nodes is not a multiple of k, then the remaining nodes at the end should be kept as is and not reversed.

ListNode *reverseList(ListNode *head)
    {
        ListNode *temp = head;
        ListNode *prev = NULL;

        while (temp != NULL)
        {
            ListNode *front = temp->next;
            temp->next = prev;
            prev = temp;
            temp = front;
        }
        return prev;
    }
    ListNode* getKthNode(ListNode* temp,int k){
        k--;
        while(temp && k>0){
            k--;
            temp=temp->next;
        }
        return temp;
    }
    ListNode* reverseKGroup(ListNode* head, int k) {
        ListNode* temp = head;;
        ListNode* recent = NULL;

        while(temp){
            ListNode* kThNode = getKthNode(temp,k);

            if(!kThNode){
                if(recent) recent->next = temp;
                break;
            }

            ListNode* ahead = kThNode->next;

            kThNode->next = NULL;

            reverseList(temp);

            if(temp==head) head = kThNode;
            else{
                recent->next = kThNode;
            }

            recent = temp;
            temp=ahead;

        }
        return head;
    }

4. Check if Linked List is Palindromic

 ListNode *reverseList(ListNode *head)
    {
        ListNode *temp = head;
        ListNode *prev = NULL;

        while (temp != NULL)
        {
            ListNode *front = temp->next;
            temp->next = prev;
            prev = temp;
            temp = front;
        }
        return prev;
    }
    bool isPalindrome(ListNode *head)
    {
        if (!head || !head->next)
            return true;
        ListNode *slow = head;
        ListNode *fast = head;

        while (fast && fast->next)
        {
            slow = slow->next;
            fast = fast->next->next;
        }
        ListNode *secHalf = reverseList(slow);
        ListNode *left = head;
        ListNode *ryt = secHalf;

        while (ryt)
        {
            if (ryt->val != left->val)
                return false;
            ryt = ryt->next;
            left = left->next;
        }
        reverseList(secHalf->next);
        return true;
    }