数据结构之静态链表

学习数据结构已经很久了，一直没有用上，最近时间有点空闲，所以翻出来炒一炒。子曰：温故而知新。当初学习数据结构的时候，买的是国嵌唐老师的视频，所以这些代码很唐老师写的几乎一模一样，若转载请注明出自国嵌唐老师数据结构教程。

首先来看第三个例子，静态链表：

头文件

#ifndef _STATICLIST_H_
#define _STATICLIST_H_

typedef void StaticList;
typedef void StaticListNode;

StaticList* StaticList_Create(int capacity);

void StaticList_Destroy(StaticList* list);

int 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 "StaticList.h"
#include <malloc.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 = (TStaticList*)malloc(sizeof(TStaticList) + sizeof(TStaticListNode) * (capacity + 1));
        
		if (ret)
        {
  		    ret->capacity = capacity;
  		    ret->header.next = 0;
  		    ret->header.data = 0;
  		    
  		    for (i = 1; i <= capacity; i++)
  		    {
 			 	ret->node[i].next = AVAILABLE;
  			}
  		}
    }
    
    return ret;
}

void StaticList_Destroy(StaticList* list)
{
 	 free(list);
}

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

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;
}

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

StaticListNode* StaticList_Delete(StaticList* list, int pos)
{
    TStaticList* sList = (TStaticList*)list;
 	StaticListNode* ret = NULL;
 	int i = 0;
 	int index = 0;
 	int current = 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;
 		}
 		
 		index = sList->node[current].next;
  	    
  	    sList->node[current].next = sList->node[index].next;
  	    
  	    sList->node[0].data--;
  	    
  	    sList->node[index].next = AVAILABLE;
  	    
  	    sList->header = sList->node[0];
  	    
  	    ret = (StaticListNode*)(sList->node[index].data);
	}
	
 	return ret;
}

测试文件

<pre name="code" class="cpp">#include <stdio.h>
#include <stdlib.h>
#include "StaticList.h"

int main(int argc, char *argv[])
{
 	StaticList* list = StaticList_Create(10);
 	
 	int a = 1;
 	int b = 2;
 	int c = 3;
 	int d = 4;
 	int e = 5;
 	
 	int i = 0;
 	
 	StaticList_Insert(list, &a, 0);
 	StaticList_Insert(list, &b, 0);
 	StaticList_Insert(list, &c, 0);
 	StaticList_Insert(list, &d, 0);
 	StaticList_Insert(list, &e, 0);

 	printf("capacity = %d\n", StaticList_Capacity(list));
 	
 	for (i = 0; i < StaticList_Length(list); i++)
 	{
	 	int* p = (int*)StaticList_Get(list, i);
	 	printf("%d\n", *p);
  	}
  	
  	printf("length = %d\n", StaticList_Length(list));
  	
  	StaticList_Clear(list);
  	
  	StaticList_Insert(list, &a, StaticList_Length(list));
 	StaticList_Insert(list, &b, StaticList_Length(list));
 	StaticList_Insert(list, &c, StaticList_Length(list));
 	StaticList_Insert(list, &d, StaticList_Length(list));
 	StaticList_Insert(list, &e, StaticList_Length(list));
 	
 	for (i = 0; i < StaticList_Length(list); i++)
 	{
	 	int* p = (int*)StaticList_Get(list, i);
	 	printf("%d\n", *p);
  	}
  	
  	printf("length = %d\n", StaticList_Length(list));
  	
  	while (StaticList_Length(list) > 0)
  	{
	 	int* p = (int*)StaticList_Delete(list, 0);
	 	printf("%d\n", *p);  
    }
    
    printf("length = %d\n", StaticList_Length(list));

    StaticList_Destroy(list);
  
    system("PAUSE");	
    return 0;
}

静态链表用到了C语言中的柔性数组，不了解的可以去百度下。还有就是静态链表的主要用处是在那些不适合用指针的场合，这样可以避免指针操作的同时实现链表。