（一）静态链表

静态链表

重新学习一下数据机构算法，同时再回顾一下C的用法，以后也用C++。
用结构加数组方式模拟指针，这种数据结构不经常使用，但是个别时候可以借鉴。
关键的是链表初始化约定，第0个元素、最后一个元素的含义，以及数据最有一个元素的cur必须为0，类似链表最后一个元素p->next = NULL.。

#include <stdio.h>
#include<time.h>
#include<stdlib.h>

#define MAXSIZE 11
#define ERROR 0
#define OK  1

typedef struct 
{
	int data;
	int cur;
} StaticList;

StaticList sl[MAXSIZE];

//初始化静态链表
void InitStaticList(StaticList* list)
{
	 //下标0：cur指向备用链表的起始位置下标，备用链表是指没有存储数据的空闲单元。
	 //下标最后一个cur：cur指向第一个有数据的下标，初始为0。
	 //下标倒数第二个cur：cur为0，表示数据结束。
	 int i;
	 for (i = 0; i < MAXSIZE - 2; i++)
	 {
		 list[i].cur = i + 1;
		 list[i].data = -1;// 设为-1是为了打印的时候好看点，否则没有初始化的内存显示很长一段数据，测试用。
	 }
	 list[MAXSIZE - 1].cur = 0;
	 list[MAXSIZE - 2].cur = 0;
	 list[MAXSIZE - 1].data = -1;
	 list[MAXSIZE - 2].data = -1;
	 list[0].data = -1;
}

//获取备用链表可用位置，类似malloc
 int MallocStaticList(StaticList* list)
 {
	 int i = 0;
	 i = list[0].cur;
	 if (list[0].cur)
	 {
		 // list[0].cur = list[i].cur;
		 list->cur = (list + i)->cur; //两种写法，这种通过指针访问
	 }
	 //printf("list[0].cur=%d\n",  list[0].cur);
	 //printf("return i is %d\n",i);
	 return i;
 }

//定位
 int LocalStaticList(StaticList* list)
 {
	 int i = list[MAXSIZE - 1].cur;
	 while (!list[i].cur && i)
	 {
		 i = list[i].cur;  //类似 p = p->next
	 }
	 return i;
 }
 
 //出入元素，尾插
 void InsertStaticList(StaticList* list,int data)
 {
	// printf("list[0].cur=%d\n", list[0].cur);
	 int i,j;
	 j = 0;
	 i = MallocStaticList(list);
	 //printf("list[0].cur=%d\n", list[0].cur);
	 if (!i)
	 {
		 printf("空间申请失败。");
		 return;
	 }
	 else
	 {
		 if (!list[MAXSIZE - 1].cur)//静态链表中没有数据，第一次插入
		 {
			 list[MAXSIZE - 1].cur = i; 
			 j = i;
		 }
		 else
		 {
			 j = list[MAXSIZE - 1].cur;
			  //查找最后一个单元
			 while (j && list[j].cur)
			 {
				 j = list[j].cur;
			 }
		 }
		 
		 list[j].cur = i;
		 list[i].data = data;
		 list[i].cur = 0;
	 }

 }

//测试用，打印完整列表
 void PrintStaticListAll(StaticList* list)
 {
	 printf("cur :");
	 for (int i = 0; i < MAXSIZE; i++)
	 {
		 printf("\t%d", list[i].cur);
	 }
	 printf("\n");

	 printf("data:");
	 for (int i = 0; i < MAXSIZE; i++)
	 {
		 printf("\t%d", list[i].data);
	 }
	 printf("\n");

	 printf("[xx]:");
	 for (int i = 0; i < MAXSIZE; i++)
	 {
		 printf("\t%d", i);
	 }
	 printf("\n");
 }

//打印数据
 void PrintStaticListData(StaticList* list)
 {
	 printf("\nData:");
	 int i = list[MAXSIZE - 1].cur;
	 while (i && list[i].cur)
	 {
		 printf("\t%d", list[i].data);
		 i = list[i].cur;
	 }
	 printf("\t%d\n", list[i].data);
 }

//定位某个元素
 int LocalStaticListData(StaticList* list, int data)
 {
	 int i = list[MAXSIZE - 1].cur;
	 while (i && list[i].data != data)
	 {
		 i = list[i].cur;
	 }
	 return i;
 }

//定位某个元素的上个元素
 int LocalStaticListData_Prev(StaticList* list, int data)
 {
	 int i = list[MAXSIZE - 1].cur;
	 while (i && list[i].data != data)
	 {
		 if (list[list[i].cur].data == data)
		 {
			 return i;
		 }
		 i = list[i].cur;
	 }
	 return i;
 }

//删除元素
 int DeleteStaticListData(StaticList* list, int data)
 {
	 int i = list[MAXSIZE - 1].cur;
	 int j = LocalStaticListData(sl,data);
	 int x = 0;
	 if (!j)
	 {
		 return j;
	 }
	 else
	 {
		 if (i == j) //删除头元素
		 {
			 list[MAXSIZE - 1].cur = list[j].cur;
			 list[j].cur = list[0].cur;
			 list[0].cur = j;
		 }
		 else
		 {
			 //if (list[j].cur == 0) //删除尾元素
			 //{
				// //找到上个元素
				// x = LocalStaticListData_Prev(sl, data);
				// list[x].cur = list[j].cur;
				// list[j].cur = list[0].cur;
				// list[0].cur = j;

			 //}
			 x = LocalStaticListData_Prev(sl, data);
			 list[x].cur = list[j].cur;
			 list[j].cur = list[0].cur;
			 list[0].cur = j;
		 }
		 
		 return j;

	 }
 }
 

//测试
int main()
{
	int x = 0;
	srand((unsigned int)time(NULL));
	
	InitStaticList(sl);
	PrintStaticListAll(sl);

	InsertStaticList(sl, 2);
	InsertStaticList(sl, 3);
	InsertStaticList(sl, 4);
	InsertStaticList(sl, 5);
	InsertStaticList(sl, 6);
	InsertStaticList(sl, 8);
	PrintStaticListAll(sl);

	PrintStaticListData(sl);
	printf("\n下标是：%d\n", LocalStaticListData(sl, 6));

	x = DeleteStaticListData(sl,8);
	printf("x = %d\n", x);
	PrintStaticListAll(sl);
	PrintStaticListData(sl);

	system("pause");
}

运行结果

cur :   1       2       3       4       5       6       7       8       9       0       0
data:   -1      -1      -1      -1      -1      -1      -1      -1      -1      -1      -1
[xx]:   0       1       2       3       4       5       6       7       8       9       10

cur :   7       2       3       4       5       6       0       8       9       0       1
data:   -1      2       3       4       5       6       8       -1      -1      -1      -1
[xx]:   0       1       2       3       4       5       6       7       8       9       10

Data:   2       3       4       5       6       8

下标是：5
x = 6
cur :   6       2       3       4       5       0       7       8       9       0       1
data:   -1      2       3       4       5       6       8       -1      -1      -1      -1
[xx]:   0       1       2       3       4       5       6       7       8       9       10

Data:   2       3       4       5       6