静态链表的实现与操作(C语言实现)

标签：静态链表   c语言实现   数据结构   链表   链表操作   

我们知道要实现单链表，必须要有指针，那么像Java这样没有指针的的语言就略显蛋疼了。

没关系，我们有静态链表，其本质就是用采用数组的方式实现单链表的功能。

头文件：

#ifndef _StaticLinkList_H_
#define _StaticLinkList_H_

typedef void StaticLinkList;
typedef void StaticLinkListNode;   


StaticLinkList * StaticLinkList_Create(int capacity);

void StaticLinkList_DesTroy(StaticLinkList * list);

void StaticLinkList_Clear(StaticLinkList* list);

int StaticLinkList_Length(StaticLinkList* list);

int StaticLinkList_Capacity(StaticLinkList* list);

int StaticLinkList_Insert(StaticLinkList* list, StaticLinkListNode* node, int pos);

StaticLinkListNode* StaticLinkList_Get(StaticLinkList* list, int pos);

StaticLinkListNode* StaticLinkList_Delete(StaticLinkList* list, int pos);

#endif 

// 静态链表.cpp : 定义控制台应用程序的入口点。
//
//静态链表的出现主要是为了弥补有些编程语言没有指针而不能创建单链表的缺憾

#include "stdafx.h"
#include <stdlib.h>
#include <malloc.h>
#include "StaticLinkList.h"
const int AVAILABLE = -1;

typedef struct    //header.data  用作存放数组的长度
{
	int data;   //数据域
	int next;   //下一个元素的下标
}TStaticLinkListNode;

typedef struct
{
	int capacity;   //链表的总长度
	TStaticLinkListNode header;  //头结点，data为数组的长度，next为第一个元素的下标
	TStaticLinkListNode node[];  //数组，存放数据
}TStaticLinkList;

int _tmain(int argc, _TCHAR* argv[])
{
	StaticLinkList* list = StaticLinkList_Create(10);   //创建一个总长度为10的静态链表
    
    int index = 0;    
    int i = 0;
    int j = 1;
    int k = 2;
    int x = 3;
    int y = 4;
    int z = 5;
    
    StaticLinkList_Insert(list, (StaticLinkListNode*)&i, 0);
    StaticLinkList_Insert(list, (StaticLinkListNode*)&j, 0);
    StaticLinkList_Insert(list, (StaticLinkListNode*)&k, 0);
    
	for(index=0; index<StaticLinkList_Length(list); index++)
    {
		int* p = (int*)StaticLinkList_Get(list, index);
        
        printf("插入了： %d\n", *p);
    }
    
    printf("\n");
    
    while( StaticLinkList_Length(list) > 0 )
    {
		int* p = (int*)StaticLinkList_Delete(list, 0);
        
        printf("删除了： %d\n", *p);
    }
    
    printf("\n");
    printf("重新插入： \n\n");
	StaticLinkList_Insert(list, (StaticLinkListNode*)&x, 0);
    StaticLinkList_Insert(list, (StaticLinkListNode*)&y, 0);
    StaticLinkList_Insert(list, (StaticLinkListNode*)&z, 0);
    
	//打印总长度和长度
	printf("Capacity: %d Length: %d\n", StaticLinkList_Capacity(list), StaticLinkList_Length(list));
    
    for(index=0; index<StaticLinkList_Length(list); index++)
    {
        int* p = (int*)StaticLinkList_Get(list, index);
        
        printf("插入了： %d\n", *p);
    }
    
	StaticLinkList_DesTroy(list);//销毁
    
	
	system("pause");
	return 0;
}

//创建
StaticLinkList * StaticLinkList_Create(int capacity)
{
	TStaticLinkList * list = NULL;
	if(capacity > 0)
	{
		list = (TStaticLinkList*)malloc(sizeof(TStaticLinkList) + sizeof(TStaticLinkListNode)*(capacity + 1));
	}
	if(NULL != list)
	{
		list->header.data = 0;
		list->header.next = 0;
		list->capacity = capacity;
	}

	for (int i = 1; i<=list->capacity; i++)
	{
		list->node[i].next = AVAILABLE;
	}

	return list;
}
//销毁
void StaticLinkList_DesTroy(StaticLinkList * list)
{
	free(list);
}

//清空
void StaticLinkList_Clear(StaticLinkList* list)
{
	TStaticLinkList* sList = (TStaticLinkList*)list;
	if(sList != NULL)
	{
		sList->capacity = 0;
		sList->header.data = 0;
		sList->header.next = 0;
	}
}

//获得长度
int StaticLinkList_Length(StaticLinkList* list)
{	
	TStaticLinkList* sList = (TStaticLinkList*)list;
	int len = -1;
	if(NULL != sList)
	{
		len = sList->header.data;
	}
	return len;
}


//获得总长度
int StaticLinkList_Capacity(StaticLinkList* list)
{
	TStaticLinkList* sList = (TStaticLinkList*)list;
	int capacity = -1;
	if(NULL != sList)
	{
		capacity = sList->capacity;
	}
	return capacity;
}

//插入
int StaticLinkList_Insert(StaticLinkList* list, StaticLinkListNode* node, int pos)
{
	TStaticLinkList* sList = (TStaticLinkList*)list;
	TStaticLinkListNode* sNode = (TStaticLinkListNode*)node;
	int current = 0;
	int index = 0;
	int i = 0;
	int bol = 0;
	for( i=1; i<=sList->capacity; i++)
	{
		if(sList->node[i].next == AVAILABLE)
		{
			index = i;
			break;
		}
	}
	if((NULL != sList) && (NULL != sNode) && (pos >= 0) && (sList->header.data+1 <= sList->capacity))
	{
		sList->node[index].data = (unsigned int)node;
		sList->node[0] = sList->header;

		for( i=0; i<pos && sList->node[i].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];
		 bol = 1;
	}
	return bol;
}

//获取结点
StaticLinkListNode* StaticLinkList_Get(StaticLinkList* list, int pos)
{
	TStaticLinkList* sList = (TStaticLinkList*)list;
	int i = 0;
	int obj = 0;
	int current = 0;
	if((NULL != sList) && (pos>=0) && (pos < sList->header.data))
	{
		sList->node[0] = sList->header;
		for( i=0; i<pos; i++)
		{
			current = sList->node[current].next;
		}
		obj = sList->node[current].next;
	}
	return (StaticLinkListNode*)sList->node[obj].data;
}

//删除
StaticLinkListNode* StaticLinkList_Delete(StaticLinkList* list, int pos)
{
	TStaticLinkList* sList = (TStaticLinkList*)list;
	int  i = 0;
	int current = 0;
	int obj = 0;
	if((NULL != sList) && (pos >= 0) && (pos < sList->header.data))
	{
		sList->node[0] = sList->header;
		for( i=0; i<pos; i++)
		{
			current = sList->node[current].next;
		}
		obj =  sList->node[current].next;
		sList->node[current].next = sList->node[obj].next;
		--(sList->node[0].data);
		sList->header = sList->node[0];
		sList->node[obj].next = AVAILABLE;
		
	}
	return (StaticLinkListNode*)sList->node[obj].data;
}

插入了： 2
插入了： 1
插入了： 0

删除了： 2
删除了： 1
删除了： 0

重新插入：

Capacity: 10 Length: 3
插入了： 5
插入了： 4
插入了： 3
请按任意键继续. . .

小结：

1,静态链表其实是单链表的另一种实现方式

2,静态链表的实现“媒介”不是指针而是数组

3,静态链表主要用于不支持指针的程序设计语言中

4,静态链表的实现是一种内存管理的简易方法

如果错误，望不吝指出。

静态链表的实现与操作(C语言实现),布布扣,bubuko.com

静态链表的实现与操作(C语言实现)

标签：静态链表   c语言实现   数据结构   链表   链表操作   

原文地址：http://blog.csdn.net/u010590318/article/details/28429887