Static linked list (subscript of array instead of pointer)

static_list.h

#ifndef _STATICLIST_H_
#define _STATICLIST_H_


#include "stdio.h"
#include "stdlib.h"


#define AVAILABLE -1
typedef struct _tag_static_list_node static_list_node;
typedef struct _tag_static_list static_list;


 struct _tag_static_list_node
{
    
    void *pdata;
    int next;
};

struct _tag_static_list
{
    
    int capacity;
	int len;
    static_list_node node[];
};



static_list* static_list_create(int capacity);

void static_list_destroy(static_list* list);

void static_list_clear(static_list* list);

int static_list_length(static_list* list);

int static_list_capacity(static_list* list);


int static_list_insert(static_list* list, void *pdata, int pos);

void *static_list_get(static_list *list,int pos);

void *static_list_delete(static_list *list, int pos);

void static_list_printf(static_list *list);




#endif

static_list.c

#include "static_list.h"


static_list* static_list_create(int capacity)
{
    
    int i;
    static_list  *result=0;
    result = malloc(sizeof(static_list)+sizeof(static_list_node)*(capacity+1));
    if (result==0)
    {
    
        printf("static_list_create error -1\n");
        return 0;
    }

    result->capacity = capacity;
    result->len = 0;
    result->node[0].next = 0;
	
    for (i=1; i<(capacity+1); i++)
    {
    
        result->node[i].next = AVAILABLE;
    }
    return result;
}

void static_destroy(static_list* list)
{
    
    free(list);
}

void static_list_clear(static_list* list)
{
    
    int i;
    list->len=0;
    list->node[0].next=0;
	
    for (i=1; i<(list->capacity+1); i++)
    {
    
        list->node[i].next = AVAILABLE;
    }
}

int static_list_length(static_list* list)
{
    
    return list->len;
}
int static_list_capacity(static_list* list)
{
    
    return list->capacity;
}

int static_list_insert(static_list* list, void *pdata, int pos)
{
    
    int i,j;
    int current = 0;

    if (list->capacity <= pos)
	{
    
        return -1;
	}


    // Find a useful one from the numbers 
    for (i=1; i<(list->capacity+1); i++)
    {
    
        if (list->node[i].next == AVAILABLE)
		{
    
			printf("available index:%d\n",i);
            break;
		}
    }
	
	if ( (list->capacity+1) == i)
	{
    
		printf("out of memory\n");
		return -2;
	}
    list->node[i].pdata = pdata;

	for (j=0; j<pos&&list->node[current].next!=0; j++)
	{
    
		current = list->node[current].next;
	}
	list->node[i].next = list->node[current].next;
	printf("%d-i:%d-current:%d\n",list->node[current].next,i,current);
	list->node[current].next = i;
	
	list->len++;
	return 0;
}

void *static_list_get(static_list *list,int pos)
{
    
	void *result = 0;
	int current = 0;
	int i;
	
	current = list->node[0].next;
	if (current!=0 && pos<list->len)
	{
    
		for (i=0; i<pos; i++)
		{
    
			current = list->node[current].next;
		}
		result = list->node[current].pdata;
	}
	
	return result;
}



void *static_list_delete(static_list *list, int pos)
{
    
	int pre_current = 0;
	int current = 0;
	int tmp;
	int i = 0;
	void *result = 0;
	
	if (list->len>0 && pos>=0 && pos<list->len)
	{
    
		pre_current = 0;
		current = list->node[0].next;
		if (current)
		{
    
			for (i=0; i<pos; i++)
			{
    
				if (list->node[current].next==0)
				{
    
					break;
				}
				pre_current = current;
				current = list->node[current].next;
			}
			tmp = list->node[current].next;
			list->node[pre_current].next = tmp;

			result = list->node[current].pdata;			
			list->node[current].next = AVAILABLE;
			list->node[current].pdata = 0;		
			list->len--;
		}
	}else
	{
    
		printf("static_list_delete error :%d-%d\n",list->len,pos);
	}
	
	return result;
}

void static_list_printf(static_list *list)
{
    
	int current = 0;
	int i = 0;
	void *pdata;
	
	current = list->node[0].next;
	printf("static_list_printf-");
	for (i=0; i<list->len; i++)
	{
    
		pdata = list->node[current].pdata;
		printf("[%d,0x%02x,value:%d]-",i,current,*((unsigned int *)pdata));
		current = list->node[current].next;
	}
	printf("\n");
}

Test code

#include "static_list.h"
#include "stdio.h"
#include "stdint.h"



int main(void)
{
    
	static_list *head=0;
	uint8_t i;
	int tmp[11];

	
	for (i=0; i<11; i++)
	{
    
		tmp[i] = i+1;
	}
    printf("hello \r\n");
	
	head = static_list_create(10);
	#if 1
	for (i=0; i<11; i++)
	{
    
		static_list_insert(head,&tmp[i],0);
	}
	#else
	for (i=0; i<9; i++)
	{
    
		static_list_insert(head,&tmp[i],0);
	}
	static_list_insert(head,&tmp[9],1);
	#endif
	
	static_list_printf(head);
	
// for (i=9; i>0; i--)
// {
    
// static_list_delete(head,i);
// static_list_printf(head); 
// }
// static_list_delete(head,0);
// static_list_printf(head); 

// static_list_delete(head,0);
// static_list_printf(head); 
	
	for (i=0; i<12; i++)
	{
    
		static_list_delete(head,0);
		static_list_printf(head);	
	}
	while(1)
	{
    
	
	}
}