可复用的静态链表

#ifndef _STATIC_LIST_H
#define _STATIC_LIST_H


typedef void StaticList;
typedef void StaticListNode;


StaticList* StaticList_Create();


void StaticList_Destroy(StaticList* list);


void StaticList_Clear(StaticList* list);


int StaticList_Length(StaticList* list);


int StaticList_Capacity(StaticList* list);


int StaticList_Insert(StaticList* list, StaticListNode* node, int pos);


StaticListNode* StaticList_Get(StaticList* list, int pos);


StaticListNode* StaticList_Delete(StaticList* list, int pos);

#endif

#include<stdio.h>
#include<malloc.h>
#include"static_list.h"


#define AVAILABLE -1//宏定义后面不需要使用分号 


typedef struct _tag_StaticListNode
{
unsigned int data;
int next;
}TStaticListNode;
//静态链表结点定义 


typedef struct _tag_StaticList
{
int capacity;
TStaticListNode header;
TStaticListNode node[];
}TStaticList;
//静态链表结构定义 


StaticList* StaticList_Create(int capacity)
{
TStaticList* ret = NULL;//定义空静态链表 
int i = 0;
if( capacity >= 0 )
{
ret = (StaticList*)malloc(sizeof(TStaticList)+sizeof(TStaticListNode)*(capacity+1));
}
if( ret != NULL )
{
ret->capacity = capacity;
ret->header.data = 0;
ret->header.next = 0;
for(i=0;i<= ret->capacity;i++)
{
ret->node[i].next = AVAILABLE ;
}
}
return ret;
} 


void StaticList_Destroy(StaticList* list)
{
free(list);//释放堆空间 
}


void StaticList_Clear(StaticList* list)
{
TStaticList* sList = (TStaticList*)list;
int i = 0;
if( sList != NULL )
{
sList->header.data = 0;
sList->header.next = 0;
for(i=0;i<=sList->capacity;i++)
{
sList->node[i].next = AVAILABLE ; 
}
}
}


int StaticList_Length(StaticList* list)
{
TStaticList* sList = (TStaticList*)list;
int ret = -1;
if( sList != NULL )
{
ret = sList->header.data;
}
return ret;
}


int StaticList_Capacity(StaticList* list)
{
TStaticList* sList = (TStaticList*)list;
int ret = -1;
if( sList != NULL )
{
ret = sList->capacity;
    }
    return ret;
}


StaticListNode* StaticList_Get(StaticList* list, int pos)
{
TStaticList* sList = (TStaticList*)list;
StaticListNode* ret = NULL;
int i = 0;
int current = 0;
int object = 0;
if((sList != NULL)&&(pos > 0)&&(pos <= sList->header.data))
{
sList->node[0] = sList->header;
for(i = 0;i<pos;i++)
{
current = sList->node[current].next;
}
object = sList->node[current].next;
ret = (StaticListNode*)(sList->node[object].data);
}
return ret;
}
 


int StaticList_Insert(StaticList* list, StaticListNode* node, int pos)  // O(n)
{
    TStaticList* sList = (TStaticList*)list;
    int ret = (sList != NULL);
    int current = 0;
    int index = 0;
    int i = 0;
    ret = ret && (sList->header.data + 1 <= sList->capacity);
    ret = ret && (pos >=0) && (node != NULL);
    if( ret )
    {
        for(i=1; i<=sList->capacity; i++)
        {
            if( sList->node[i].next == AVAILABLE )
            {
                index = i;
                break;
            }
        } 
        sList->node[index].data = (unsigned int)node;
        sList->node[0] = sList->header;
        for(i=0; (i<pos) && (sList->node[current].next != 0); i++)
        {
            current = sList->node[current].next;
        } 
        sList->node[index].next = sList->node[current].next;
        sList->node[current].next = index;
        sList->node[0].data++; 
        sList->header = sList->node[0];
}
    return ret;
}




StaticListNode* StaticList_Delete(StaticList* list, int pos)
{
    TStaticList* sList = (TStaticList*)list;
    StaticListNode* ret = NULL;
    int current = 0;
    int object = 0;
    int i = 0; 
    if( (sList != NULL) && (0 <= pos) && (pos < sList->header.data) )
    {
        sList->node[0] = sList->header;
        for(i=0; i<pos; i++)
        {
            current = sList->node[current].next;
        } 
        object = sList->node[current].next;
        sList->node[current].next = sList->node[object].next;
        sList->node[0].data--;
        sList->header = sList->node[0];
    sList->node[object].next = AVAILABLE; 
        ret = (StaticListNode*)(sList->node[object].data);
    }
    return ret;
}



#include <stdio.h>
#include <stdlib.h>
#include"static_list.h"


/* run this program using the console pauser or add your own getch, system("pause") or input loop */


int main(int argc, char *argv[]) 
{
StaticList* list = StaticList_Create(10); 
    int index = 0;
    int i = 0;
    int j = 1;
    int k = 2;
    int x = 3;
    int y = 4;
    int z = 5; 
    StaticList_Insert(list, &i, 0);
    StaticList_Insert(list, &j, 0);
    StaticList_Insert(list, &k, 0);
    for(index=0; index<StaticList_Length(list); index++)
    {
        int* p = (int*)StaticList_Get(list, index);
        
        printf("%d\n", *p);
    }
    printf("\n");
    while( StaticList_Length(list) > 0 )
    {
        int* p = (int*)StaticList_Delete(list, 0);
        
        printf("%d\n", *p);
    }
return 0;
printf("\n");
    StaticList_Insert(list, &x, 0);
    StaticList_Insert(list, &y, 0);
    StaticList_Insert(list, &z, 0);
    printf("Capacity: %d Length: %d\n", StaticList_Capacity(list), StaticList_Length(list)); 
    for(index=0; index<StaticList_Length(list); index++)
    {
        int* p = (int*)StaticList_Get(list, index);
        
        printf("%d\n", *p);
    }  
    StaticList_Destroy(list);
}