静态链表-----用数组实现的单链表。

静态链表是单链表的另外一种表现方式，具体的操作步骤的实现与单链表类似。

1、初始化

 实现代码：

include<stdio.h>
#include<malloc.h>
#define DEFAULT_SIZE 5
//宏观定义内存的大小，在静态连接节点的结构体里在设计一个静态链表的结构体 
typedef struct StaticLinkedNode
{
	char data;
	int next;
	
}*NodePtr;

typedef struct StaticLinkedList
{
	NodePtr nodes;
	int *used;
}*ListPtr;

//初始化链表并设置表头
ListPtr initLinkedList()
{
	//建立一个指向整个空间的指针.
	ListPtr tempPtr = (ListPtr)malloc(sizeof(StaticLinkedList));
	
	//分配整个空间
	tempPtr->nodes = (NodePtr)malloc(sizeof(struct StaticLinkedNode) * DEFAULT_SIZE);
	//分配的空间大小是指针大小和宏观定义的空间的乘积.
	tempPtr->used = (int*)malloc(sizeof(int) * DEFAULT_SIZE);
	//设置表头，头结点.
	tempPtr->nodes[0].data = '\0';
	tempPtr->nodes[0].next = -1;
	
	//因为头结点无法被分配，所以第一个节点是被占用的.
	tempPtr->used[0] = 1;
	for(int i=1;i<DEFAULT_SIZE;i++)
	{
		tempPtr->used[i] = 0;
		
	 } 
	 return tempPtr;
	 
	
	
 } 
 //打印链表 
 void printList(ListPtr paraListPtr)
 {
 	int p = 0;
 	while(p != -1)
 	{
 		printf("%c",paraListPtr->nodes[p].data);
 		p = paraListPtr->nodes[p].next; 
	 }
	 printf("\r\n");
	 
 }
 

2、插入元素的操作

//插入链表函数
 void insertelement(ListPtr paraListPtr,char paraChar,int paraposition)
 {
 	int p,q,i;
 	
 	//第一，查找可以插入的位置.
	 p = 0;
	 for(i=0;i<paraposition;i++)
	 {
	 	p = paraListPtr->nodes[p].next;
	 	if(p== -1)
	 	{
	 		printf("位置%d已经是最后一位了\r\n",paraposition);
	 		return ;
		 }
	  } 
	  //第二，创建新的链表节点.
	  for(i = 1;i<DEFAULT_SIZE;i++)
	  {
	  	if(paraListPtr->used[i] == 0)
	  	{
	  		//与malloc分配一致.
			  printf("在%d的空间已经被分配.\r\n",i);
			  paraListPtr->used[i] = 1;
			  q = i;
			  break; 
		  }
	   }
	   if(i == DEFAULT_SIZE)
	   {
	   	printf("没有可用空间了.\r\n");
	   	return ;
		} 
		paraListPtr->nodes[q].data = paraChar;
		//第三，插入链表.
		printf("连接！\r\n");
		paraListPtr->nodes[q].next = paraListPtr->nodes[p].next;
		paraListPtr->nodes[p].next = q; 
	  
 }

 3、删除操作

//删除链表函数
 void deleteelement(ListPtr paraListPtr, char paraChar)
 {
 	int p,q;
 	p = 0;
 	while((paraListPtr->nodes[p].next != -1) && (paraListPtr->nodes[paraListPtr->nodes[p].next].data != paraChar))
 	{
 	p = paraListPtr->nodes[p].next;	
	 }
	 
	 if(paraListPtr->nodes[p].next == -1)
	 {
	 	printf("无法删除%c\r\n",paraChar);
	 	return;
	 }
	 q = paraListPtr->nodes[p].next;
	 paraListPtr->nodes[p].next = paraListPtr->nodes[paraListPtr->nodes[p].next].next;
	 //释放被删除的链表. 
	 paraListPtr->used[q] = 0;
  } 
  

 完整代码如下：

#include<stdio.h>
#include<malloc.h>
#define DEFAULT_SIZE 5
//宏观定义内存的大小，在静态连接节点的结构体里在设计一个静态链表的结构体 
typedef struct StaticLinkedNode
{
	char data;
	int next;
	
}*NodePtr;

typedef struct StaticLinkedList
{
	NodePtr nodes;
	int *used;
}*ListPtr;

//初始化链表并设置表头
ListPtr initLinkedList()
{
	//建立一个指向整个空间的指针.
	ListPtr tempPtr = (ListPtr)malloc(sizeof(StaticLinkedList));
	
	//分配整个空间
	tempPtr->nodes = (NodePtr)malloc(sizeof(struct StaticLinkedNode) * DEFAULT_SIZE);
	//分配的空间大小是指针大小和宏观定义的空间的乘积.
	tempPtr->used = (int*)malloc(sizeof(int) * DEFAULT_SIZE);
	//设置表头，头结点.
	tempPtr->nodes[0].data = '\0';
	tempPtr->nodes[0].next = -1;
	
	//因为头结点无法被分配，所以第一个节点是被占用的.
	tempPtr->used[0] = 1;
	for(int i=1;i<DEFAULT_SIZE;i++)
	{
		tempPtr->used[i] = 0;
		
	 } 
	 return tempPtr;
	 
	
	
 } 
 //打印链表 
 void printList(ListPtr paraListPtr)
 {
 	int p = 0;
 	while(p != -1)
 	{
 		printf("%c",paraListPtr->nodes[p].data);
 		p = paraListPtr->nodes[p].next; 
	 }
	 printf("\r\n");
	 
 }
 
 //插入链表函数
 void insertelement(ListPtr paraListPtr,char paraChar,int paraposition)
 {
 	int p,q,i;
 	
 	//第一，查找可以插入的位置.
	 p = 0;
	 for(i=0;i<paraposition;i++)
	 {
	 	p = paraListPtr->nodes[p].next;
	 	if(p== -1)
	 	{
	 		printf("位置%d已经是最后一位了\r\n",paraposition);
	 		return ;
		 }
	  } 
	  //第二，创建新的链表节点.
	  for(i = 1;i<DEFAULT_SIZE;i++)
	  {
	  	if(paraListPtr->used[i] == 0)
	  	{
	  		//与malloc分配一致.
			  printf("在%d的空间已经被分配.\r\n",i);
			  paraListPtr->used[i] = 1;
			  q = i;
			  break; 
		  }
	   }
	   if(i == DEFAULT_SIZE)
	   {
	   	printf("没有可用空间了.\r\n");
	   	return ;
		} 
		paraListPtr->nodes[q].data = paraChar;
		//第三，插入链表.
		printf("连接！\r\n");
		paraListPtr->nodes[q].next = paraListPtr->nodes[p].next;
		paraListPtr->nodes[p].next = q; 
	  
 }
 
 //删除链表函数
 void deleteelement(ListPtr paraListPtr, char paraChar)
 {
 	int p,q;
 	p = 0;
 	while((paraListPtr->nodes[p].next != -1) && (paraListPtr->nodes[paraListPtr->nodes[p].next].data != paraChar))
 	{
 	p = paraListPtr->nodes[p].next;	
	 }
	 
	 if(paraListPtr->nodes[p].next == -1)
	 {
	 	printf("无法删除%c\r\n",paraChar);
	 	return;
	 }
	 q = paraListPtr->nodes[p].next;
	 paraListPtr->nodes[p].next = paraListPtr->nodes[paraListPtr->nodes[p].next].next;
	 //释放被删除的链表. 
	 paraListPtr->used[q] = 0;
  } 
  
  //插入删除测试的函数
  void insertdeletetest()
  {
  	//第一，初始化一个空链表.
	  ListPtr tempList = initLinkedList();
	  printList(tempList);
	  
	  //第二，添加一些字符测试.
	  insertelement(tempList, 'H',0);
	  insertelement(tempList, 'e',1);
	  insertelement(tempList, 'l',2);
	  insertelement(tempList, 'l',3);
	  insertelement(tempList, 'o',4);
	   printList(tempList);
	   //第三，删除链表测试.
	   printf("删除 'e'.\r\n");
	   deleteelement(tempList, 'e');
	   printf("删除 'a'. \r\n");
	   deleteelement(tempList, 'a');
	   printf("删除 'o'.\r\n");
	   deleteelement(tempList, 'o'); 
	   printList(tempList);
	   
	   insertelement(tempList, 'x',1);
	   printList(tempList);
   } 
   
   int main()
   {
   	insertdeletetest();
   }

运行结果如下：

 静态链表和单链表的区别：

1.存取的地址不同，静态链表把地址改成数组下标，下一个节点的地址改为下一个节点的下标。

2.初始化时，单链表设计了一个结构体，而静态链表则用两个结构体嵌套。

3.静态链表是通过数组实现的，单链表是通过指针实现的。

静态链表的优缺点：

优点
1.在插入和删除操作肘,只需要修改游标,不需要移动元素,从而改进了在顺序存储结构中的插入和删
除操作需要移动大量元素的缺点
缺点
没有解决连续存储带来的表长难以确定的问题。失去了顺序存储结构随机存取的特点。