hi there!

i just thought with all this asking about arrays i could post a "kind of"-solution. it's a completely working (well, at least it's ansi c, didn't try it with lite-c) linked list with adding and removal &c. &c. see for yourself.

Code:

---

struct llink {
	struct llink *prev, *next;
	void *p;
};
struct llist {
	struct llink *start;
};

llist* new_llist(void)
{
	llist* list = (llist*)malloc(sizeof(llist));
	if (list == NULL) {
		return (llist*)NULL;
	}
	list->start = NULL;
	return list;
}

llink* llist_add(llist *list, void *p)
{
	llink *link;
    if (list == NULL) {
		return (llink*)NULL;
	}

	link = (llink*)malloc(sizeof(llink));
	if (link == NULL) {
		return (llink*)NULL;
	}

	link->p = p;
	
	if (list->start == NULL) {
		list->start = link->next = link->prev = link;
	} else {
		// reassign left side
		link->prev = list->start->prev;
		list->start->prev->next = link;

		// reassign right side
		link->next = list->start;
		list->start->prev = link;
	}
	
	return link;
}

size_t llist_size(llist *list)
{
	size_t i = 1;
	llink *start, *current;
    if ( (list == NULL) || (list->start == NULL) ) {
		return 0;
	}

	current = start = list->start;
	while ( (current = current->next, current) != start ) {
		i ++;
	}

	return i;
}

llink* llist_get_link(llist *list, size_t offset)
{
	size_t c_offset;
	llink *current;
    if ( (list == NULL) || (list->start == NULL) ) {
		return NULL;
	}

	c_offset = offset%llist_size(list);
	current = list->start;
	for (c_offset; c_offset > 0; c_offset --) {
		current = current->next;
	}

	return current;
}

void* llist_get(llist *list, size_t offset)
{
	llink *current = llist_get_link(list, offset);
	return (current == NULL) ? NULL : current->p;
}

bool llist_delete(llist *list, size_t offset)
{
	llink *victim;
	if ( (victim = llist_get_link(list, offset)) == NULL ) {
		return false;
	}

	if (llist_size(list) == 1) {
		free(victim);
		list->start = NULL;
		return true;
	}

	if (offset == 0) {
		list->start = victim->next;
	}

	// reclose list
	victim->prev->next = victim->next;
	victim->next->prev = victim->prev;
	free(victim);
	return true;
}

signed long int llist_index_of(llist *list, void *p)
{
	size_t i = llist_size(list);
	llink *current;
	if (i == 0) { // implies list->start == NULL
		return -1;
	}

	current = list->start;
	for (i; i > 0; i --) {
		if (current->p == p) {
			return (signed long int)i;
		}
		current = current->next;
	}

	return -1;
}

---

if you want any function added, just tell me.

greetings, joey.