Make linkedlists generic

[darshan2456]

refer #283

Just how queues were made generic by @RustyLegend we need to make linkedlists generic too. A generic data-structure is one which can store any datatype, not only a single one like the current linkedlist can only store integers. We need to modify it, change the struct itself, change the function definitions as well as change the places where it is called appropriately. You can refer PR #283 for guidance and to get the complete idea what you need to do and how.

This is an advanced issue and I would suggest you attempt this only after you have a thorough understanding of the C programming language as well as this project

[vedant-kawale-27]

Proposed Implementation Plan: Making Linked Lists Generic

Following the implementation of generic queues in PR #283 by @RustyLegend, we can extend this pattern to the four linked list variants in the project:

1. Singly Linked List (SLL)
2. Doubly Linked List (DLL)
3. Singly Circular Linked List (SCLL)
4. Doubly Circular Linked List (DCLL)

Making these structures generic allows them to hold any data type (using void* pointers) rather than being restricted strictly to integers. Below is the proposed design and step-by-step implementation guide.

---

1. Data Structure Refactoring (void* Data)

We will change the node structs across all four modules to store void* data instead of int data.

Example (SLL - sll.h):

 typedef struct Node
 {
-    int data;
+    void* data;
     struct Node* next;
 } Node;

Example (Circular LL - scll.h / dcll.h):

 typedef struct scll_Node
 {
-    int data;
+    void* data;
     struct scll_Node* next;
 } scll_Node;

---

2. Generic Function Signatures & Callbacks

Since linked lists support operations like Search, Delete by Value, and Display (which queues do not), we need a way to compare and print generic elements. We will introduce callback function pointers to handle this cleanly.

Updated Prototypes:

• Insertion:

  int sll_insertAtBeginning(Node** head_ref, void* value);
  int sll_insertAtEnd(Node** head_ref, void* value);

• Search / Delete by Value (requires a comparator callback):

  // The comparator returns 0 if elements are equal
  int sll_search(const Node* head, void* key, int (*compare)(const void*, const void*));
  int sll_deleteByValue(Node** head_ref, void* key, int (*compare)(const void*, const void*));

• Display / Printing (requires a printer callback):

  void sll_printlist(const Node* head, void (*print_element)(const void*));

• Destroy (optionally takes a data destructor callback to avoid memory leaks):

  void delete_sll(Node* head, void (*free_data)(void*));

---

3. Changes to the Demo Layer (sll_demo.c, dll_demo.c, etc.)

In the interactive console demos, we will allocate integers on the heap before inserting them into the list, and free them when they are deleted or when the list is destroyed.

Example (Enqueuing/Inserting in Demo):

int* val_ptr = malloc(sizeof(int));
if (val_ptr == NULL) {
    printf("Allocation failed\n");
    return;
}
*val_ptr = user_input;
sll_insertAtBeginning(&head, val_ptr);

Example (Deleting/Popping in Demo):

// We retrieve the pointer, print/use it, then free it to avoid memory leaks
void* deleted_data = sll_pop_front(&head); 
if (deleted_data != NULL) {
    printf("Deleted: %d\n", *(int*)deleted_data);
    free(deleted_data);
}

---

4. Implementation Steps

1. Header Updates: Modify sll.h, dll.h, scll.h, and dcll.h structures and function signatures.
2. Library Source Updates: Modify the corresponding .c files to adjust the pointer links and pass comparator/print callbacks.
3. Demo Adaptations: Update sll_demo.c, dll_demo.c, scll_demo.c, and dcll_demo.c to use heap-allocated integer pointers.
4. Unit Test Updates: Update unit tests in tests/data_structures/ to allocate elements, test with standard comparators, and verify memory leak safety using Valgrind.

[darshan2456]

great @vedant-kawale-27 you have understood the issue to a great extent and I think you will easily figure it out. But there are four variants of linked lists and you will make atleast 4 PRs if not more to resolve the issue entirely. Start with dll or scll if you want, then once you get the complete idea you can attempt sll. at the last because it is used at many places and needs a lot of thinking and careful work to be completed correctly.

[vedant-kawale-27]

📋 PR Roadmap

🏁 PR 1: Generic Doubly Linked List (DLL)

• Goal: Convert doubly_ll_Node data field to void* and introduce comparator/destructor callbacks.
• Scope: dll.h, dll.c, dll_demo.c, and test_dll.c.
• Why DLL first: DLL is completely self-contained within its module (no external dependencies in other data structures or graphs), making it the perfect starting point to align on the generic patterns.

🔄 PR 2: Generic Singly Circular Linked List (SCLL)

• Goal: Convert scll_Node to use void* data.
• Scope: scll.h, scll.c, scll_demo.c, and test_scll.c.
• Why SCLL next: Like DLL, it has no external dependencies, allowing us to implement circular boundary validation with generic pointers.

🔁 PR 3: Generic Doubly Circular Linked List (DCLL)

• Goal: Convert dcll_Node to use void* data.
• Scope: dcll.h, dcll.c, dcll_demo.c, and test_dcll.c.

🚀 PR 4: Generic Singly Linked List (SLL) & Downstream Refactoring

• Goal: Convert Node (sll.h) to use void* data and refactor all downstream dependencies.
• Scope:
  • sll.h, sll.c, sll_demo.c, test_sll.c.
  • Downstream Modules: Update Stack (stack.c/stack.h), Hashing, and any Graph adjacency lists/tree components that depend on sll.h node structures.
• Why SLL last: Since it is highly integrated throughout the codebase, addressing it last ensures we have polished our generic template handling in the first 3 PRs before tackling the complex downstream refactoring.

---

Let me know if this roadmap looks good to you, and I will get started with PR 1: Generic DLL!

[darshan2456]

yeah great. you can start making PRs @vedant-kawale-27