数据结构4：静态链表

静态链表与单链表

        相同点：内部节点都由两部分组成，单链表（指针域和数据域），静态链表（游标和数据域），其中单链表的指针域和静态链表游标作用基本相同。

        不同点：静态链表是用数组（游标）实现的，是顺序的存储结构，在物理地址上是连续的，而且需要预先分配大小。动态链表是用申请内存函数（malloc函数）动态申请内存的，每个节点的物理地址不连续，要通过指针（指针域）来顺序访问。

        静态链表图解与单链表基本相同，只是用数组形式替代了指针形式，插入删除操作过程类似

静态链表操作

1.定义

//定义静态链表 
typedef struct StaticLinkedNode
{
	char data;
	int next;
} *NodePtr;

typedef struct StaticLinkedList
{
	NodePtr nodes;//存储结点 
	int* used;//存储空间使用情况，0表示空闲，1表示被占用 
} *ListPtr;

2.初始化

ListPtr initLinkedList()
{
	//指向空间的指针 
	ListPtr tempPtr = (ListPtr)malloc(sizeof(struct StaticLinkedList));
	//分配空间 
	tempPtr->nodes = (NodePtr)malloc(sizeof(struct StaticLinkedNode) * MAX_SIZE);
	tempPtr->used = (int*)malloc(sizeof(int) * MAX_SIZE);
	//头结点
	tempPtr->nodes[0].data = '\0';
	tempPtr->nodes[0].next = -1;
	//仅使用头结点
	tempPtr->used[0] = 1;
	for (int i = 1; i < MAX_SIZE; i ++)
	{
		tempPtr->used[i] = 0;
	}
	return tempPtr;
}

3.打印

void printList(ListPtr paraListPtr)
{
	int p = 0;
	while (p != -1)
	{
		printf("%c", paraListPtr->nodes[p].data);
		p = paraListPtr->nodes[p].next;
	}
	printf("\r\n");
}

4.插入

void insertElement(ListPtr paraListPtr, char paraChar, int paraPosition)
{
	int p=0, q, i;
	//寻找插入位置
	for (i = 0; i < paraPosition; i ++)
	{
		p = paraListPtr->nodes[p].next;
		if (p == -1)
		{
			printf("位置%d超出链表范围\r\n",paraPosition);
			return;
		}
	}
	//创建新结点
	for (i = 1; i < MAX_SIZE; i ++)
	{
		if (paraListPtr->used[i] == 0)
		{
			//分配空间（等同于malloc）
			printf("%d处已被分配空间\r\n",i);
			paraListPtr->used[i] = 1;
			q = i;
			break;
		}
	}
	if (i == MAX_SIZE)
	{
		printf("没有空间，不能插入%c\r\n",paraChar);
		return;
	}
	paraListPtr->nodes[q].data = paraChar;
	printf("插入%c\r\n",paraChar);
	paraListPtr->nodes[q].next = paraListPtr->nodes[p].next;
	paraListPtr->nodes[p].next = q;
}

5. 按元素删除

void deleteElement1(ListPtr paraListPtr, char paraChar)
{
	int p=0, q;
	while ((paraListPtr->nodes[p].next != -1) && (paraListPtr->nodes[paraListPtr->nodes[p].next].data != paraChar))
	{
		p = paraListPtr->nodes[p].next;
	}
	printf("删除%c\r\n",paraChar);
	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;
	//free操作
	paraListPtr->used[q] = 0;
}

6.按位置删除

int deleteElement2(ListPtr paraListPtr,int paraPosition)
{
	int p=0,q,i;
	printf("删除第%d个元素\r\n",paraPosition);
	//寻找位置
	 for(i=0;i<paraPosition-1;i++)
	{
		p=paraListPtr->nodes[p].next;
		if(p==-1)
		{
			printf("位置%d超出链表范围，无法删除\r\n",paraPosition);
			return -1;
		}
	 } 
	q=paraListPtr->nodes[p].next;
	paraListPtr->nodes[p].next=paraListPtr->nodes[paraListPtr->nodes[p].next].next;
	//free操作
	paraListPtr->used[q]=0; 
 }

静态链表功能测试

void  staticLinkedNodeText()
{
	//初始化
	ListPtr tempList = initLinkedList();
	printList(tempList);
	//插入1
	insertElement(tempList, 'B', 0);
	insertElement(tempList, 'i', 1);
	insertElement(tempList, 'r', 2);
	insertElement(tempList, 't', 3);
	insertElement(tempList, 'h', 4);
	insertElement(tempList, 'd', 5);
	insertElement(tempList, 'a', 6);
	insertElement(tempList, 'y', 7);
	printList(tempList);
	//删除1 
	deleteElement1(tempList, 't');
	printList(tempList);
	deleteElement1(tempList, 'a');
	printList(tempList);
	deleteElement1(tempList, 'f');
	printList(tempList);
	//删除2 
	deleteElement2(tempList,2); 
	printList(tempList);
	deleteElement2(tempList,9);
	//插入2
	insertElement(tempList, 'x', 2);
	printList(tempList);
}

插入测试1

1处已被分配空间
插入B
2处已被分配空间
插入i
3处已被分配空间
插入r
4处已被分配空间
插入t
5处已被分配空间
插入h
6处已被分配空间
插入d
7处已被分配空间
插入a
没有空间，不能插入y
 Birthda

删除测试1

删除t
 Birhda
删除a
 Birhd
删除f
f不存在，无法删除
 Birhd

删除测试2

删除第2个元素
 Brhd
删除第9个元素
位置9超出链表范围，无法删除

插入测试2

2处已被分配空间
插入x
 Brxhd

总代码

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

#define MAX_SIZE 8

//定义静态链表 
typedef struct StaticLinkedNode
{
	char data;
	int next;
} *NodePtr;

typedef struct StaticLinkedList
{
	NodePtr nodes;//存储结点 
	int* used;//存储空间使用情况，0表示空闲，1表示被占用 
} *ListPtr;

//初始化
ListPtr initLinkedList()
{
	//指向空间的指针 
	ListPtr tempPtr = (ListPtr)malloc(sizeof(struct StaticLinkedList));
	//分配空间 
	tempPtr->nodes = (NodePtr)malloc(sizeof(struct StaticLinkedNode) * MAX_SIZE);
	tempPtr->used = (int*)malloc(sizeof(int) * MAX_SIZE);
	//头结点
	tempPtr->nodes[0].data = '\0';
	tempPtr->nodes[0].next = -1;
	//仅使用头结点
	tempPtr->used[0] = 1;
	for (int i = 1; i < MAX_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=0, q, i;
	//寻找插入位置
	for (i = 0; i < paraPosition; i ++)
	{
		p = paraListPtr->nodes[p].next;
		if (p == -1)
		{
			printf("位置%d超出链表范围\r\n",paraPosition);
			return;
		}
	}
	//创建新结点
	for (i = 1; i < MAX_SIZE; i ++)
	{
		if (paraListPtr->used[i] == 0)
		{
			//分配空间（等同于malloc）
			printf("%d处已被分配空间\r\n",i);
			paraListPtr->used[i] = 1;
			q = i;
			break;
		}
	}
	if (i == MAX_SIZE)
	{
		printf("没有空间，不能插入%c\r\n",paraChar);
		return;
	}
	paraListPtr->nodes[q].data = paraChar;
	printf("插入%c\r\n",paraChar);
	paraListPtr->nodes[q].next = paraListPtr->nodes[p].next;
	paraListPtr->nodes[p].next = q;
}

//按元素删除
void deleteElement1(ListPtr paraListPtr, char paraChar)
{
	int p=0, q;
	while ((paraListPtr->nodes[p].next != -1) && (paraListPtr->nodes[paraListPtr->nodes[p].next].data != paraChar))
	{
		p = paraListPtr->nodes[p].next;
	}
	printf("删除%c\r\n",paraChar);
	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;
	//free操作
	paraListPtr->used[q] = 0;
}

//按位置删除
int deleteElement2(ListPtr paraListPtr,int paraPosition)
{
	int p=0,q,i;
	printf("删除第%d个元素\r\n",paraPosition);
	//寻找位置
	 for(i=0;i<paraPosition-1;i++)
	{
		p=paraListPtr->nodes[p].next;
		if(p==-1)
		{
			printf("位置%d超出链表范围，无法删除\r\n",paraPosition);
			return -1;
		}
	 } 
	q=paraListPtr->nodes[p].next;
	paraListPtr->nodes[p].next=paraListPtr->nodes[paraListPtr->nodes[p].next].next;
	//free操作
	paraListPtr->used[q]=0; 
 }
//功能测试
void  staticLinkedNodeText()
{
	//初始化
	ListPtr tempList = initLinkedList();
	printList(tempList);
	//插入1
	insertElement(tempList, 'B', 0);
	insertElement(tempList, 'i', 1);
	insertElement(tempList, 'r', 2);
	insertElement(tempList, 't', 3);
	insertElement(tempList, 'h', 4);
	insertElement(tempList, 'd', 5);
	insertElement(tempList, 'a', 6);
	insertElement(tempList, 'y', 7);
	printList(tempList);
	//删除1 
	deleteElement1(tempList, 't');
	printList(tempList);
	deleteElement1(tempList, 'a');
	printList(tempList);
	deleteElement1(tempList, 'f');
	printList(tempList);
	//删除2 
	deleteElement2(tempList,2); 
	printList(tempList);
	deleteElement2(tempList,9);
	//插入2
	insertElement(tempList, 'x', 2);
	printList(tempList);
}
void main()
{
	staticLinkedNodeText();
}