17 march Linked List questions

#include <stdio.h>
#include <stdlib.h>

typedef struct Node {
    int data;
    struct Node* next;
} Node;

void printList(Node* head) {
    Node* temp = head;
    while(temp) {
        printf("%d -> ", temp->data);
        temp = temp->next;
    }
    printf("NULL\n");
}

void insertBeforeFirst(Node** head, int data) {
    Node* newNode = (Node*)malloc(sizeof(Node));
    newNode->data = data;
    newNode->next = *head;
    *head = newNode;
}

void insertAfterFirst(Node* head, int data) {
    if (!head) return;
    Node* newNode = (Node*)malloc(sizeof(Node));
    newNode->data = data;
    newNode->next = head->next;
    head->next = newNode;
}

void insertAfterLast(Node* head, int data) {
    Node* temp = head;
    while(temp->next)
        temp = temp->next;
    
    Node* newNode = (Node*)malloc(sizeof(Node));
    newNode->data = data;
    newNode->next = NULL;
    temp->next = newNode;
}

void insertBeforeLast(Node* head, int data) {
    if (!head || !head->next) return;
    Node* temp = head;
    while(temp->next->next)
        temp = temp->next;

    Node* newNode = (Node*)malloc(sizeof(Node));
    newNode->data = data;
    newNode->next = temp->next;
    temp->next = newNode;
}

void insertAroundValue(Node** head, int searchVal, int beforeData, int afterData) {
    Node* temp = *head;
    Node* prev = NULL;
    while(temp && temp->data != searchVal) {
        prev = temp;
        temp = temp->next;
    }

    if (temp) {
        // Insert before
        Node* newBefore = (Node*)malloc(sizeof(Node));
        newBefore->data = beforeData;
        newBefore->next = temp;
        if (prev)
            prev->next = newBefore;
        else
            *head = newBefore;

        // Insert after
        Node* newAfter = (Node*)malloc(sizeof(Node));
        newAfter->data = afterData;
        newAfter->next = temp->next;
        temp->next = newAfter;
    }
}

void deleteFirst(Node** head) {
    if (*head) {
        Node* temp = *head;
        *head = (*head)->next;
        free(temp);
    }
}

void deleteLast(Node** head) {
    if (!*head) return;
    if (!(*head)->next) {
        free(*head);
        *head = NULL;
        return;
    }

    Node* temp = *head;
    while(temp->next->next)
        temp = temp->next;

    free(temp->next);
    temp->next = NULL;
}

void deleteValue(Node** head, int value) {
    Node* temp = *head;
    Node* prev = NULL;

    while(temp && temp->data != value) {
        prev = temp;
        temp = temp->next;
    }

    if (!temp) return;
    if (!prev)
        *head = temp->next;
    else
        prev->next = temp->next;

    free(temp);
}

void splitOddEven(Node* head, Node** odd, Node** even) {
    while(head) {
        Node* newNode = (Node*)malloc(sizeof(Node));
        newNode->data = head->data;
        newNode->next = NULL;

        if (head->data % 2 == 0) {
            newNode->next = *even;
            *even = newNode;
        } else {
            newNode->next = *odd;
            *odd = newNode;
        }

        head = head->next;
    }
}

void splitAtIndex(Node* head, int index, Node** first, Node** second) {
    *first = head;
    int i = 0;
    while(i < index - 1 && head) {
        head = head->next;
        i++;
    }
    if (head) {
        *second = head->next;
        head->next = NULL;
    }
}

void reverseDisplay(Node* head) {
    if (!head) return;
    reverseDisplay(head->next);
    printf("%d ", head->data);
}

void convertToCircular(Node* head) {
    if (!head) return;
    Node* temp = head;
    while(temp->next)
        temp = temp->next;
    temp->next = head;
}

int detectLoop(Node* head) {
    Node *slow = head, *fast = head;
    while(fast && fast->next) {
        slow = slow->next;
        fast = fast->next->next;
        if (slow == fast)
            return 1;
    }
    return 0;
}

void deleteOdd(Node** head) {
    while(*head && (*head)->data % 2 != 0) {
        Node* temp = *head;
        *head = (*head)->next;
        free(temp);
    }

    Node* curr = *head;
    while(curr && curr->next) {
        if (curr->next->data % 2 != 0) {
            Node* temp = curr->next;
            curr->next = curr->next->next;
            free(temp);
        } else {
            curr = curr->next;
        }
    }
}

void displayAlternate(Node* head) {
    int toggle = 1;
    while(head) {
        if (toggle) printf("%d ", head->data);
        toggle = !toggle;
        head = head->next;
    }
    printf("\n");
}

void deleteAlternate(Node* head) {
    while(head && head->next) {
        Node* temp = head->next;
        head->next = temp->next;
        free(temp);
        head = head->next;
    }
}

void printStackAsQueue(Node* top) {
    // reverse then print
    reverseDisplay(top);
}

void printQueueAsStack(Node* front) {
    reverseDisplay(front);
}

void addNodeDoublePtr(Node** head, int val) {
    Node* newNode = (Node*)malloc(sizeof(Node));
    newNode->data = val;
    newNode->next = NULL;

    if (!*head) {
        *head = newNode;
    } else {
        Node* temp = *head;
        while(temp->next)
            temp = temp->next;
        temp->next = newNode;
    }
}

void insertByRef(Node** head, int val) {
    Node* newNode = (Node*)malloc(sizeof(Node));
    newNode->data = val;
    newNode->next = *head;
    *head = newNode;
}