125 lines
2.7 KiB
C
125 lines
2.7 KiB
C
#include <stdio.h>
|
|
#include <stdlib.h>
|
|
#include <string.h>
|
|
#define TYPE int
|
|
//A list is one of:
|
|
// - (make-note element next)
|
|
// - '() -> NULL
|
|
|
|
struct node {
|
|
TYPE element;
|
|
struct node* prev;
|
|
struct node* next;
|
|
};
|
|
|
|
typedef struct node node_t;
|
|
|
|
typedef struct {
|
|
node* first;
|
|
} list_t;
|
|
|
|
size_t list_length(const list_t* self) {
|
|
size_t length = 0;
|
|
node_t* i = self->first;
|
|
|
|
while (i != NULL) {
|
|
length++;
|
|
i = self->next;
|
|
}
|
|
|
|
return length;
|
|
}
|
|
|
|
node_t* list_ith(const list_t* self, const size_t position) {
|
|
size_t found;
|
|
node_t* elem = list_ith_or_last(self, position, &found);
|
|
return found != position ? NULL : elem;
|
|
}
|
|
|
|
node_t* list_ith_or_last(const list_t* self, const size_t position,
|
|
const size_t* returned) {
|
|
node_t* to_reach = self->first;
|
|
size_t i;
|
|
for (i = 0; i < position && to_reach->next != NULL; i++) {
|
|
to_reach = to_reach->next;
|
|
}
|
|
*returned = i;
|
|
return to_reach;
|
|
}
|
|
|
|
node_t* make_node(TYPE element) {
|
|
node_t* node = malloc(sizeof(node));
|
|
node->element = element;
|
|
node->next = NULL;
|
|
node->prev = NULL;
|
|
}
|
|
|
|
void free_list(const list_t* list) {
|
|
while(list->first != NULL) {
|
|
free(list_remove(self, 0));
|
|
}
|
|
}
|
|
|
|
size_t list_copy_slice(const list_t* self, const list_t* destination,
|
|
const size_t from, const size_t to) {
|
|
if (from >= to) {
|
|
return 0;
|
|
}
|
|
free_list(destination);
|
|
size_t start, i;
|
|
node_t* to_copy = list_ith_or_last(self, to, &start);
|
|
if (to_copy == NULL) {
|
|
return 0;
|
|
}
|
|
|
|
for(i = start; i > from; i--) {
|
|
node_t* copied = malloc(sizeof(node_t));
|
|
memcpy(copied, src, sizeof(node_t));
|
|
list_insert(destination, 0, copied);
|
|
}
|
|
|
|
return start - from;
|
|
}
|
|
|
|
int list_insert(const list_t* self, const size_t position, const node_t* node) {
|
|
if (self->first == NULL) {
|
|
return 1;
|
|
}
|
|
|
|
if (position == 0) {
|
|
node->next = self->first;
|
|
node->prev = NULL;
|
|
self->first = node;
|
|
return 0;
|
|
}
|
|
|
|
node_t* to_reach = list_ith(self, position - 1);
|
|
|
|
if (to_reach == NULL) {
|
|
return 2;
|
|
}
|
|
|
|
to_reach->next->prev = node;
|
|
node->next = to_reach->next;
|
|
node->prev = to_reach;
|
|
to_reach->next = node;
|
|
return 0;
|
|
}
|
|
|
|
node_t* list_remove(const list_t* self, const size_t position) {
|
|
if(position == 0) {
|
|
node_t* to_remove = self->first;
|
|
self->first = to_remove->next;
|
|
return to_remove;
|
|
}
|
|
|
|
node_t* to_reach = list_ith(self, position - 1);
|
|
if (to_reach == NULL || to_reach->next == NULL) {
|
|
return NULL;
|
|
}
|
|
|
|
node_t* to_remove = to_reach->next;
|
|
to_reach->next = to_reach->next->next;
|
|
to_reach->next->prev = to_reach;
|
|
return to_remove;
|
|
}
|