数据结构-静态链表

#include <iostream>
using namespace std;
#define MAX 100

typedef struct
{
	int date;
	int cur;
}component, slink[100];

void init(slink L)
{
	int i;
	L[MAX - 1].cur = 0;//最后一个节点，相当于是一个头节点，然后，将他指向下一个的下标设为0，也就类似于头指针的初始化

	for (i = 0; i < MAX - 2; i++)//将这个备用的节点进行这个初始化，然后并进行初始化形成一条链
	{
		L[i].cur = i + 1;//当前的下标指向的是下一个节点的索引
	}
	L[MAX - 2].cur = 0;//将最后一个的下一个设置成为零，作为后面判断这个备用的链表是不是空的一个条件
}



void destroy(slink L)
{
	int i = L[MAX - 1].cur;//指向头指针的下一个索引，也就是第一个节点
	L[MAX - 1].cur = 0;//将头节点设置为空

	int k = L[0].cur;//得到备用链表的第一个节点的下标
	L[0].cur = i;//将我们实际的链表的下标给L[0].cur,这样我们的链表我们就又连上了

	int j; // 临时节点的下标,这个就是为了，获得我们实际链表的最后一个节点的下标，然后便于连接上
	while (i)
	{
		j = i;//一直顺序的存下来
		i = L[i].cur;
	}
	L[j].cur = k;//这样我们就连接上了
}

bool isEmpty(slink L)
{
	return L[MAX - 1].cur ? false : true;//如果我们的头节点有指向的索引，那么这个头指针就不是一个空的
}

int len(slink L)
{
	int i = 0;//这个为计数的变量
	int j = MAX - 1;//这个当做我们头结点
	while (L[j].cur)//判断这个达到了最后一个
	{
		i++;
		j = L[j].cur;

	}
	return i;
}

bool getitem(slink L, int index,int & item)
{
	if (index < 1 && len(L))//这个判断这个是不是输入不规范
	{
		return false;
	}
	int i = 0;//这个当做我们的计数的一个变量
	int j = MAX - 1;//这个当做是我们的一个头节点的一个指针
	while (L[j].cur&&i < index)//找到这个节点
	{
		i++;
		j = L[j].cur;
	}
	if (!L[j].cur || i>index)//如果发生了，这个预想不到的错误的时候，就返回这个错误的
	{
		return false;
	}
	item = L[i].date;
	return true;

}


bool locateitem(slink L, int index, int item)
{
	if (index<1 && index>len(L))
	{
		return false;
	}
	int i = 0;
	int j = MAX - 1;
	while (L[j].cur&&i < index)
	{
		i++;
		j = L[j].cur;
	}
	if (!L[j].cur || i > index)
	{
		return false;
	}
	return item == L[j].date ? true : false;
}

bool pre(slink L, int cur, int & pre)
{
	int i = L[MAX - 1].cur;//取第一个的下标
	int j;
	while (i)
	{
		j = L[i].cur;//得到我们当前节点的下一个下标
		if (j&&L[j].date == cur)//判断条件
		{
			pre = L[i].date;//将这个值，来进行赋值
			return true;
		}
		i = j;
	}
	return false;

}

bool next(slink L, int cur, int & next)
{
	int i = L[MAX - 1].cur;
	int j;
	while (i)
	{
		j = L[i].cur;
		if (j&&L[i].date == cur)//就是判断条件，类似于这个前驱这个判断的条件
		{
			next = L[j].date;
			return true;
		}
		i = j;
	}
	return false;

}


int malloc_item(slink L)
{
	int i = L[0].cur;//取到备用节点的下标
	if (i != 0)
	{
		L[0].cur = L[L[0].cur].cur;
		return i;
	}
	else
	{
		return -1;
	}

}

void free(slink L, int i)
{
	L[i].cur = L[0].cur;//取到我们的第一个节点的这个下标
	L[0].cur = i;//然后我们就连接上了
}

bool  insert(slink L, int index, int item)
{
	if (index<1 && index>len(L))
	{
		return false;
	}
	int i=MAX-1;
	int num = 0;
	while (i && num < index - 1)
	{
		num++;
		i = L[i].cur;
	}
	if (!i || num>index - 1)
	{
		return false;
	}
	int j = malloc_item(L);
	L[j].date = item;
	L[j].cur = L[i].cur;
	L[i].cur = j;
	return true;
}


bool delete_item(slink L, int index, int&item)
{
	if (index<1 && index>len(L))
	{
		return false;
	}
	int i = MAX - 1;
	int j = 0;
	while (L[i].cur&&j < index - 1)
	{
		i = L[i].cur;
		j++;
	}
	if (!L[i].cur || j>index - 1)
	{
		return false;
	}
	item = L[L[i].cur].date;
	L[i].cur = L[L[i].cur].cur;
	return true;
}