42sh/src/utils/lists/lists.c

#include "lists.h"

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

struct list *list_prepend(struct list *list, void *value)
{
    struct list *new_elt = malloc(sizeof(struct list));
    if (new_elt == NULL)
    {
        return NULL;
    }
    new_elt->next = list;
    new_elt->data = value;

    return new_elt;
}

size_t list_length(struct list *list)
{
    size_t len = 0;
    while (list != NULL)
    {
        len++;
        list = list->next;
    }
    return len;
}

void list_print(struct list *list)
{
    if (list == NULL)
    {
        return;
    }

    while (list != NULL)
    {
        if (list->next != NULL)
        {
            printf("%p ", list->data);
        }
        else
        {
            printf("%p\n", list->data);
        }
        list = list->next;
    }
}

void list_destroy(struct list *list)
{
    struct list *elt = list;
    struct list *next_elt;
    while (elt != NULL)
    {
        next_elt = elt->next;
        free(elt);
        elt = next_elt;
    }
}

struct list *list_append(struct list *list, void *value)
{
    if (list == NULL)
    {
        struct list *new_elt = malloc(sizeof(struct list));
        new_elt->data = value;
        new_elt->next = NULL;
        return new_elt;
    }

    struct list *elt = list;

    while (elt->next != NULL)
    {
        elt = elt->next;
    }

    struct list *new_elt = malloc(sizeof(struct list));
    new_elt->data = value;
    new_elt->next = NULL;
    elt->next = new_elt;

    return list;
}

/*
 *
 *******************
 *    Advanced     *
 *******************
 *
 */

struct list *list_insert(struct list *list, void *value, size_t index)
{
    if (list == NULL || index == 0)
    {
        struct list *new_elt = malloc(sizeof(struct list));
        new_elt->data = value;
        new_elt->next = list;
        return new_elt;
    }

    struct list *elt = list;

    for (size_t i = 0; i < index - 1; i++)
    {
        if (elt->next == NULL)
        {
            break;
        }
        elt = elt->next;
    }

    struct list *new_elt = malloc(sizeof(struct list));
    new_elt->data = value;
    new_elt->next = elt->next;
    elt->next = new_elt;

    return list;
}

struct list *list_remove(struct list *list, size_t index)
{
    struct list *elt = list;
    struct list *prev_elt;

    if (index == 0)
    {
        struct list *res = elt->next;
        free(elt);
        return res;
    }

    for (size_t i = 0; i < index; i++)
    {
        if (elt == NULL)
        {
            return list;
        }
        prev_elt = elt;
        elt = elt->next;
    }
    if (elt == NULL)
    {
        return list;
    }

    prev_elt->next = elt->next;
    free(elt);

    return list;
}

int list_find(struct list *list, void *value)
{
    if (list == NULL)
    {
        return -1;
    }

    int res = 0;
    while (list->data != value)
    {
        list = list->next;
        res++;
        if (list == NULL)
        {
            return -1;
        }
    }
    return res;
}

struct list *list_concat(struct list *list, struct list *list2)
{
    if (list == NULL)
    {
        return list2;
    }
    struct list *elt = list;
    while (elt->next != NULL)
    {
        elt = elt->next;
    }
    elt->next = list2;
    return list;
}

/*
 *
 ******************
 *    Ultimate    *
 ******************
 *
 */

static void swap_next(struct list *elt)
{
    void *c = elt->next->data;
    elt->next->data = elt->data;
    elt->data = c;
}
struct list *list_sort(struct list *list)
{
    // Bubble sort go !
    if (list == NULL)
    {
        return list;
    }
    struct list *elt = list;
    int len = 0;
    while (elt->next != NULL)
    {
        if (elt->data > elt->next->data)
        {
            swap_next(elt);
        }
        elt = elt->next;
        len++;
    }

    for (int i = 1; i < len; i++)
    {
        elt = list;
        while (elt->next != NULL)
        {
            if (elt->data > elt->next->data)
            {
                swap_next(elt);
            }
            elt = elt->next;
        }
    }

    return list;
}

// Old proto
// WARNING no malloc/free allowed (moulinette issue)
struct list *list_reverse(struct list *list)
{
    if (list == NULL)
    {
        return list;
    }

    // Get len
    struct list *elt = list;
    int len = 0;
    while (elt->next != NULL)
    {
        len++;
        elt = elt->next;
    }
    elt = list;

    // Bring each elt to end
    for (int i = 0; i < len; i++)
    {
        elt = list;
        for (int j = 0; j < len - i; j++)
        {
            swap_next(elt);
            elt = elt->next;
        }
    }

    return list;
}

struct list *list_split(struct list *list, size_t index)
{
    struct list *elt = list;
    for (size_t i = 0; i < index; i++)
    {
        if (elt == NULL)
        {
            return NULL;
        }
        elt = elt->next;
    }
    if (elt == NULL)
    {
        return NULL;
    }
    struct list *res = elt->next;
    elt->next = NULL;
    return res;
}

void list_deep_destroy(struct list *l)
{
    struct list *elt = l;
    struct list *next_elt;
    while (elt != NULL)
    {
        next_elt = elt->next;
        free(elt->data);
        free(elt);
        elt = next_elt;
    }
}