Lista jednokierunkowa

Mam zadanie żeby dodać do listy jednokierunkowej i znaleźć rekurencyjnie największy element ale nie mam pomysłu. Funkcja dobrze dodaje elementy i je wyświetla. Ewentualnie macie jakieś strony gdzie jest rozpisana rekurencja na listach?

#include <stdio.h>
#include <stdlib.h>
#include <stdbool.h>
#include <time.h>
struct sll_node
{
    int data;
    struct sll_node *next;
};

bool insert_before(struct sll_node **pointer, int data)
{
    struct sll_node *new_node = (struct sll_node*)malloc(sizeof(struct sll_node));
    if (new_node != NULL)
    {
        new_node -> data = data;
        new_node -> next = *pointer;
        *pointer = new_node;
        return true;
    }
    return false;
}

bool insert_back(struct sll_node **poinetr, int data)
{
    *poinetr = (struct sll_node*)malloc(sizeof(struct sll_node));
    if (*poinetr != NULL)
    {
        (*poinetr) -> data = data;
        (*poinetr) -> next = NULL;
        return true;
    }
    return false;
}

bool insert_node(struct sll_node **pointer, int data)
{
    if (*pointer != NULL)
    {
        if ((*pointer) -> data <= data)
            return insert_before(pointer, data);
            else
                return insert_node(&(*pointer) -> next, data);
    }
    else
        return insert_back(pointer, data);
}

void delete_node(struct sll_node **pointer, int data)
{
    if (*pointer != NULL)
    {
        if ((*pointer) -> data == data)
        {
            struct sll_node *next = (*pointer) -> next;
            free(*pointer);
            *pointer = next;
        }
        else
            delete_node(&(*pointer) -> next, data);
    }
}

void print_list(struct sll_node *pointer)
{
    if (pointer != NULL)
    {
        printf("%d ", pointer -> data);
        print_list(pointer -> next);
    }
    else
        printf("\n");
}

void print_list_backwards(struct sll_node *pointer)
{
    if (pointer != NULL)
    {
        print_list_backwards(pointer -> next);
        printf("%d ", pointer -> next);
    }
}

void remove_list(struct sll_node **pointer)
{
    if(*pointer != NULL)
    {
        remove_list(&(*pointer) -> next);
        free(*pointer);
    }
}

int find_Max(struct sll_node **pointer, int data)
{
   if (data == 1)
    return pointer->data=NULL;
   else
   return find_Max(pointer->next, find_Max(pointer->next,pointer-> data));
}

int main()
{
    struct sll_node *front = NULL;
    int i,data;
    srand(time(NULL));
    printf("Podaj ile liczb ma znalezc sie na liscie: ");
    scanf("%d", &i);
    if (i>0)
        {
            for (int a=0; a<i; a++)
            insert_node(&front, rand()%10);
        }
    else printf("Podaj ilosc liczb wieksza od zera");
    puts("Zawartosc listy: ");
    print_list(front);
    printf("najwieksza wartosc: %d", find_Max(&front,data));
    remove_list(&front);
    front = NULL;
    return 0;
}

Jak już dobrze dodajesz to pół zadania zrobione.

Teraz tylko musisz rekurencyjnie wyszukać¹, czy jest z tym jakiś problem?

¹rekurencyjna obsługa listy (albo jakiejkolwiek kolekcji ciągłej) to wtf, ale jako ćwiczenie ok