数据结构之静态单链表

静态链表L存储

游标 cur	5	2	3	4	0	6	7	....	1
数据 data		A	C	D	E			.....
下标	0	1	2	3	4	5	6	.....	999

L[0].cur放置空闲链表的第一个节点下标

L[MAXSIZE-1].cur放置第一个元素开始位置的下标

//静态链表结构
typedef struct  {
	int data;
	int cur;//游标
}Component, staticLinkList[MAXSIZE]；

在元素C之前插入元素B之后

游标 cur	6	5	3	4	0	2	7	....	1
数据 data		A	C	D	E	B		.....
下标	0	1	2	3	4	5	6	.....	999

void ListInsert(staticLinkList L, int i, int e) {
	int j, k, l;
	k = MAXSIZE - 1;
	if (i<1 || i>ListLength(L) + 1) {
		cout << "插入位置错误！" << endl;
	}
	j = Malloc_SLL(L);//获取链表后的第一个空位置下标
	if (j) {//准备插入操作
		L[j].data = e;
		for (l = 1; l <= i - 1; l++) {
			k = L[k].cur;
		}//循环直到找到第i个元素的前一个元素

		L[j].cur = L[k].cur;//例如在C之前插入B，则遍历到A，把A的cur赋值给B的cur
		L[k].cur = j;//把B的下标赋值给A的cur
	}
}

删除第3个元素C之后

游标 cur	2	5	6	4	0	2	7	....	1
数据 data		A		D	E	B		.....
下标	0	1	2	3	4	5	6	.....	999

void ListDelete(staticLinkList L, int i) {
	int j, k;
	k = MAXSIZE - 1;
	if (i<1 || i>ListLength(L) + 1) {
		cout << "插入位置错误！" << endl;
	}
	for (j = 1; j <= i - 1; j++) {
		k = L[k].cur;//例如删除第3个元素，循环2次，k=1，k=5
	}
	j = L[k].cur;//j=2
	L[k].cur = L[j].cur;
	Free_SLL(L, j);

}
void Free_SLL(staticLinkList L, int k) {
	L[k].cur = L[0].cur;
	L[0].cur = k;

}

----------------------总结-----------------------

优点：在插入和删除操作时，只需要修改游标，不需要移动元素，从而改进了在顺序存储结构中插入和删除操作需要移动大量元素的缺点

缺点：没有解决连续存储分配带来的表长难以确定的问题

总体源码：

#include<iostream>
#define MAXSIZE 1000
using namespace std;
typedef struct  {
	int data;
	int cur;//游标
}Component, staticLinkList[MAXSIZE];
void InitList(staticLinkList space);//初始化
int Malloc_SLL(staticLinkList space);//获取空闲分量的下标
void Free_SLL(staticLinkList L,int k);
void ListInsert(staticLinkList L,int i,int e);//在第i个位置前插入元素e
void ListDelete(staticLinkList L, int i);//删除链表第i个元素
void traversal(staticLinkList L);
int ListLength(staticLinkList L);
int main() {
	staticLinkList L;
	InitList(L);
	for (int i = 1; i <= 4; i++) {
		ListInsert(L, i, i*2);
	}
	traversal(L);
	cout << "该静态链表的长度为：" << ListLength(L) << endl;
	ListDelete(L, 2);
	cout << "----------删除第2个元素之后-------" << endl;
	traversal(L);
	cout << "该静态链表的长度为：" << ListLength(L) << endl;
	return 0;
}
void InitList(staticLinkList space) {
	for (int i = 0; i < MAXSIZE - 1; i++) {
		space[i].cur = i + 1;
	}
	space[MAXSIZE - 1].cur = 0;
}
int Malloc_SLL(staticLinkList space) {
	int i = space[0].cur;
	if (space[0].cur) {
		space[0].cur=space[i].cur;
	}
	return i;
}
void ListInsert(staticLinkList L, int i, int e) {
	int j, k, l;
	k = MAXSIZE - 1;
	if (i<1 || i>ListLength(L) + 1) {
		cout << "插入位置错误！" << endl;
	}
	j = Malloc_SLL(L);//获取链表后的第一个空位置下标
	if (j) {//准备插入操作
		L[j].data = e;
		for (l = 1; l <= i - 1; l++) {
			k = L[k].cur;
		}//循环直到找到第i个元素的前一个元素

		L[j].cur = L[k].cur;//例如在C之前插入B，则遍历到A，把A的cur赋值给B的cur
		L[k].cur = j;//把B的下标赋值给A的cur
	}
}
int ListLength(staticLinkList L) {
	int k = L[MAXSIZE - 1].cur;
	int m = 0;
	while (k!=0) {
		k = L[k].cur;
		++m;
	}
	return m;
}
void traversal(staticLinkList L) {
	int k = L[MAXSIZE - 1].cur;
	int e;
	cout << "该静态链表遍历得：";
	while (k != 0) {
		e = L[k].data;
		cout << e << "   ";
		k = L[k].cur;
	}
	cout << endl;
}
void ListDelete(staticLinkList L, int i) {
	int j, k;
	k = MAXSIZE - 1;
	if (i<1 || i>ListLength(L) + 1) {
		cout << "插入位置错误！" << endl;
	}
	for (j = 1; j <= i - 1; j++) {
		k = L[k].cur;//例如删除第3个元素，循环2次，k=1，k=5
	}
	j = L[k].cur;//j=2
	L[k].cur = L[j].cur;
	Free_SLL(L, j);

}
void Free_SLL(staticLinkList L, int k) {
	L[k].cur = L[0].cur;
	L[0].cur = k;

}