Reverse Doubly Linked List

struct Node* reverseDLL(struct Node * head)
{       if(!head || !head->next)
return head;
struct Node *temp =head;
struct Node * prev= NULL;
while(temp){
prev = temp->prev;
temp->prev = temp->next;
temp->next = prev;
temp =temp->prev;
    }
    return prev->prev;
}

Middle of linked list

If we have even number of linked list then return second one

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

Reverse of Linked List

ListNode* reverseList(ListNode* head) {
        ListNode * temp ,*current=head;
        ListNode * prev =NULL;
        while(current){
            temp= current->next;
            current->next=prev;
            prev=current;
            current=temp;
        }
        return prev;

    }

Detect a cycle in Linked List

Tortoise method (slow and fast pointer)

bool hasCycle(ListNode* head) {
        ListNode *slow = head, *fast = head;
        while (fast && fast->next) {
            slow = slow->next;
            fast = fast->next->next;
            if (slow == fast)
                return true;
        }
        return false;
    }

Detect starting point of Cycle in Linked list

ListNode *detectCycle(ListNode *head) {
        ListNode *slow = head, *fast = head;
        while (fast && fast->next) {
            slow = slow->next;
            fast = fast->next->next;
            if (slow==fast)
                break;
               
        }
        if(!fast || !fast->next)
            return NULL;
        fast = head;
        while(slow!=fast){
            slow = slow->next;
            fast=fast->next;
        }
        return slow;
    }

LL is Palindrome

bool isPalindrome(ListNode* head) {
        if(!head || !head->next )
            return true;
        ListNode * slow= head, *fast= head;

        while(fast->next&& fast->next->next){
            slow= slow->next;
            fast=fast->next->next;
        }
        ListNode * prev = NULL, *temp;
        slow =slow->next;
        // reversing linked list
        while(slow){
            ListNode *temp= slow->next;
            slow->next=prev;
            prev=slow;
            slow = temp;
        }
        temp= head;
        while(prev){
            if(temp->val!=prev->val)
                return false;
            temp=temp->next;
            prev= prev->next;
        }
        return true;

Add 1 to LL

Node* addOne(Node *head)
{
if (!head)
return new Node(1);

// Reverse the linked list
Node *temp = head, *nextNode, *prev = NULL;
while (temp) {
    nextNode = temp->next;
    temp->next = prev;
    prev = temp;
    temp = nextNode;
}
head = prev;

// Add 1 to the number represented by the linked list
int carry = 1;
temp = head;
Node *prevNode = NULL;
while (temp) {
    int val = temp->data + carry;
    if (val <= 9) {
        temp->data = val;
        carry = 0;
        break;
    } else {
        temp->data = 0;
    }
    prevNode = temp;
    temp = temp->next;
}

// Handle any remaining carry
if (carry && prevNode) {
    Node *newNode = new Node(1);
    prevNode->next = newNode;
}

// Reverse the linked list back to its original form
temp = head;
prev = NULL;
while (temp) {
    nextNode = temp->next;
    temp->next = prev;
    prev = temp;
    temp = nextNode;
}
head = prev;

return head;
}

Find all pair with given target in sorted doubly linked list