Doubly Linked List in C++

doublyLinkedList.cpp

// rudimentary implementation of a doubly linked list using raw pointers (should be fairly safe though)
#include <iostream>
struct node {
    int data;
    struct node *prev;
    struct node *next;
};

    //node* head_node = new node();
    // head_node->data = 5;
    // head_node->prev = NULL;

    // node* second_node = new node();
    // second_node->data = 4;
    // second_node->prev = head_node;
    // second_node->next = NULL;

    // head_node->next = second_node;
    // while(head_node != NULL) {
    //     std::cout << head_node->data << ' ';
    //     head_node = head_node->next;
    // }
    
void add_node_to_beginning(node** head, int data) {
    node* new_node = new node();
    new_node->data = data;
    new_node->prev = NULL;
    new_node->next = (*head);
    if((*head) != NULL) {
        (*head)->prev = new_node;
    }
    (*head) = new_node;

    return;
}

void add_node_to_end(node** head, int data) {
    node* new_node = new node();
    new_node->data = data;
    node* end = (*head);
        
    if((*head) == NULL){
        // this is the only node in the list
        new_node->prev = NULL;
    }
    if(end->next != NULL) {
        end = end->next;
    }
    end->next = new_node;

    new_node->prev = end;

    return;
}
void insert_after_given_node(node* given_node, int data) {
    
    // create a new node with given data
    node* new_node = new node();
    new_node->data = data;
    
    // assign next pointer to next of given node
    new_node->next = given_node->next;
    
    // assign next pointer of given node to the new node
    given_node->next = new_node;
    
    // assign previous pointer of new node to the given node
    new_node->prev = given_node;
    
    // assign the next pointer of the node before the given node to new node
    if(new_node->next != NULL){
        new_node->next->prev = new_node;
    }
    
    return;
    
}
void insert_before_given_node(node* given_node, int data){
    
    // edge case
    if(given_node == NULL){
        return;
    }
    
    // create a new node with given data
    node* new_node = new node();
    new_node->data = data;
    
    // set the previous of the new node to the previous of given node
    new_node->prev = given_node->prev;
    
    // set the previous of given node to new node
    given_node->prev = new_node;
    
    // set the next pointer of new node to given node
    new_node->next = given_node;
    
    // if the node before the given node is not null
    if(new_node->prev != NULL){
    // set next of that node to the new node
        new_node->prev->next = new_node;
    }
    else{
    // the new node is at the front of the list
        new_node->prev = NULL;
    }

    return;
    
}
    
void delete_given_node(node** head, node* given_node){
    
// if the given node is head node
    if(given_node == (*head)){
    // change head to next node
        (*head) = given_node->next;
    }
    
    // set the node before given node to point to node after given node
    given_node->prev->next = given_node->next;
    
    // given node was last node
    if(given_node->next == NULL){
        return;
    }
    
    // set the node after the given node to point to node before given node
    given_node->next->prev = given_node->prev;
    
    return;
}

void add_node_to_index(node** head, int data, uint32_t index) {
    node* new_node = new node();
    new_node->data = data;
    node* current = (*head);
    node* end = NULL;
    int size = -1;
    while(current != NULL) {
        end = current;
        current = current->next;
        size++;
    }
    current = (*head);
    if(size < index) { 
        for(uint32_t i = 0; i < index - 1 ; i++) {
            if(current->next != NULL)
                current = current->next;
            else if(current->next == NULL) {
                node* new_empty_node = new node();
                new_empty_node->data = 0;
                new_empty_node->prev = current;
                new_empty_node->next = NULL;
                current->next = new_empty_node;
                current = current->next;
            }
        }
        current->next = new_node;
        new_node->prev = current;
        new_node->next = NULL;
        return;
    }
    else if(size > index) {
        for(uint32_t i = 0; i < index - 1; i++) {
            current = current->next;
        }
        insert_after_given_node(current, data);
        return;
    }
}
int main() {


    node* head = new node();
    node* end = new node();
    node* current = NULL;
    

    head->data = 5;

    head->prev = NULL;
    head->next = end;
    end->prev = head;
    end->next = NULL;
    end->data = 60;

    current = head;

    add_node_to_beginning(&head, 42);
    add_node_to_end(&end, 51);
    insert_before_given_node(current, 40);
    insert_after_given_node(current, 21);
    delete_given_node(&head, current->prev);
    add_node_to_index(&head, 100, 3);
    current = head;
    while(current != NULL) {
        end = current;
        std::cout << current->data << ' ';
        current = current->next;
    }
    // std::cout << head->data << ' ' << end->data;
    // while(head != NULL) {
    //     end = head;
    //     std::cout << head->data << ' ';
    //     head = head->next;
    // }

    return 0;
}