Linked Lists and Pointer Manipulation Questions

import heapq

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

def mergeKLists(lists):
    """
    Merge k sorted linked lists using a min-heap.
    lists: List[ListNode]
    Returns head of merged sorted linked list.
    """
    heap = []
    # Use a counter to avoid comparing ListNode objects when values tie
    counter = 0
    for node in lists:
        if node:
            heapq.heappush(heap, (node.val, counter, node))
            counter += 1

    dummy = ListNode(0)
    tail = dummy

    while heap:
        val, _, node = heapq.heappop(heap)
        tail.next = node
        tail = tail.next
        if node.next:
            heapq.heappush(heap, (node.next.val, counter, node.next))
            counter += 1

    return dummy.next

#include <stdlib.h>

typedef struct Node {
    struct Node *next;
    int state; /* 0 = unvisited, 1 = visiting, 2 = done */
    /* other payload */
} Node;

/* nodes: array of pointers to all N nodes (collection may be disjoint).
   N: number of nodes.
   After call, all cycles are broken (one pointer removed per cycle). */
void break_all_cycles(Node **nodes, int N) {
    for (int i = 0; i < N; ++i) {
        Node *start = nodes[i];
        if (!start || start->state != 0) continue;

        Node *p = start;
        /* Walk marking visiting until NULL / visiting / done */
        while (p && p->state == 0) {
            p->state = 1;
            p = p->next;
        }

        if (p == NULL) {
            /* no cycle in this walk; mark path as done */
            Node *q = start;
            while (q && q->state == 1) {
                q->state = 2;
                q = q->next;
            }
        } else if (p->state == 1) {
            /* cycle detected; p is entry (some node on current path).
               Find node in path whose next == p and break it. */
            Node *q = start;
            /* advance until q->next == p (guaranteed to be found before hitting a done node) */
            while (q && q->state == 1 && q->next != p) {
                q = q->next;
            }
            if (q && q->next == p) {
                q->next = NULL; /* break the cycle */
            }
            /* now mark whole path as done */
            q = start;
            while (q && q->state == 1) {
                q->state = 2;
                q = q->next;
            }
        } else {
            /* p->state == 2 (we reached an already-processed chain). Just mark this path done */
            Node *q = start;
            while (q && q->state == 1) {
                q->state = 2;
                q = q->next;
            }
        }
    }
}

#include <stdint.h>
#include <stddef.h>

#define ALIGN 16
#define MIN_BLK (sizeof(free_block_t))
#define HDR_SIZE sizeof(size_t)

typedef struct free_block {
    size_t size;               // lower bit used as allocated flag
    struct free_block *prev;
    struct free_block *next;
} free_block_t;

#define IS_ALLOC(s) ((s) & 1)
#define MARK_ALLOC(s) ((s) | 1)
#define MARK_FREE(s) ((s) & ~1UL)
#define ALIGN_UP(x) (((x) + (ALIGN-1)) & ~(ALIGN-1))

// Example: compute class index (power-of-two)
static inline int class_index(size_t sz){
    int idx = 0;
    sz = ALIGN_UP(sz);
    size_t v = ALIGN;
    while(v < sz){ v <<= 1; idx++; }
    return idx; // map to array of lists
}

// remove block from free list (constant time)
static inline void remove_block(free_block_t **head, free_block_t *b){
    if(b->prev) b->prev->next = b->next;
    else *head = b->next;
    if(b->next) b->next->prev = b->prev;
    b->prev = b->next = NULL;
}

// insert block at head
static inline void insert_block(free_block_t **head, free_block_t *b){
    b->next = *head;
    if(*head) (*head)->prev = b;
    b->prev = NULL;
    *head = b;
}

// splitting: reduce large block into allocated part + remainder free block
static void split_block(free_block_t *b, size_t want){
    size_t sz = MARK_FREE(b->size);
    if(sz >= want + MIN_BLK + HDR_SIZE){
        size_t rem = sz - want;
        b->size = MARK_FREE(want);
        free_block_t *nb = (free_block_t*)((char*)b + want);
        nb->size = MARK_FREE(rem);
        // insert nb into appropriate class...
    }
}

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

typedef struct Node {
    int value;
    struct Node *prev;
    struct Node *next;
} Node;

/* Insert new_node after `node`. If node is NULL, insert at head.
   head and tail are pointers-to-pointers so we can update them. */
void insert_after(Node **head, Node **tail, Node *node, Node *new_node) {
    if (!new_node) return;
    new_node->prev = new_node->next = NULL;

    if (node == NULL) {
        // insert at head
        new_node->next = *head;
        if (*head) (*head)->prev = new_node;
        *head = new_node;
        if (*tail == NULL) *tail = new_node; // list was empty
        return;
    }

    // normal insert after node
    new_node->prev = node;
    new_node->next = node->next;
    if (node->next) node->next->prev = new_node;
    node->next = new_node;

    if (*tail == node) *tail = new_node; // update tail if appended
}

/* Remove `node` from list and free it. head/tail may be updated. */
void remove_node(Node **head, Node **tail, Node *node) {
    if (!node) return;

    if (node->prev) node->prev->next = node->next;
    else *head = node->next; // node was head

    if (node->next) node->next->prev = node->prev;
    else *tail = node->prev; // node was tail

    // Clear links (optional) then free
    node->prev = node->next = NULL;
    free(node);
}