线性表的定义与实现

线性表（List）

**数据对象集：**线性表是n个元素构成的有序序列，其中a1是表的第一个元素（表头），an是最后一个元素（表尾）；ai+1是ai的直接后继，ai-1是ai的直接前驱
**操作集：**线性表L∈List，i表示位序，一个元素X∈ElementType

1. List MakeEmpty():初始化一个新的空线性表
2. ElementType FindKth(List L,int i):根据指定位序i返回L相应元素ai
3. Position Find（List L,ElementType X）：已知要查找的元素X，返回线性表L中与X相同的第一个元素的位置
4. bool Insert(List L,ElementType X,int i):在L的指定序列i前插入一个新元素X
5. bool Delete(List L,int i):从L中删除指定位序i的元素
6. int Length(List L):返回线性表L的长度

定义顺序表的结构类型：
typedef int Position;
typedef struct LNode * PtrToLNode;
struct LNode{
ElementType Data[MAXSIZE];
Position Last;
};
typedef PtrToLNode List;

初始化
List MakeEmpty()
{
List L;
L=(List)malloc(sizeof(struct LNode));
L->Last=-1;
return L;
}

查找
顺序线性表，查找主要是指在线性表中查找与给定X相等的数据元素
#define ERROR -1
Position Find(List L,ElementType X)
{
Position i=0;
while(i<=L->Last&&L->Data[i]!=X)
{
i++;
}
if(i>L->Last)
return ERROR;
else
return i;
}

插入
顺序表的插入是在表的第i个位置插入一个X的新元素
（1）ai~an顺序向后移
（2）将X放入第i个位置
（3）修改Last指针，指向最后

bool Insert(List L,ElementType X,int i)
Position j;
if(L->Last==MAXSIZE-1)
{
	printf("表满");
	return false;
}
if(i<1||i>L->Last+2)
{
printf("不合法");
return false;
}
for(j=L->Last;j>=i-1;j--)
{
	L->Data[j+1]=L->Data[j];
}
L->Data[i-1]=X;
L->Last++;
return true;
}

删除
（1）将ai+1~an顺序前移ai元素被ai+1覆盖
（2） 修改Last指针指向最后元素

bool Delete(List L,int i)
{
	Position j;
	if(i<1||i->Last+1)
	{
		return false;
	}
	for(j=i;j<=L->Last;j++)
	L->Data[j-1]=L->Data[j];
	L->Last--;
	return true;
}

插入判断位序的合法性是L->Last+2，因为可以插入末尾，所以Last+2之后是非法的，删除是要判断Last+1位置，因为Last已经是最后一个元素了，之后就没有元素了，不可能再删除了

线性表的链式存储实现
定义
typedef struct LNode * PtrToLNode;
struct LNode{
ELementType Data;
PtrToLNode Next;
};
typedef PtrToLNOde Position;
typedef PtrToLNode List;

求表长
从头到尾遍历一次，设一个移动指针p和计数器cnt，初始化后p从表的第一个结点逐步往后移，同时计数器cnt+1，当后面不再有结点时表长就是cnt的长度

int Length(List L)
{
	Position p;
	int cnt=0;
	p=L;//p指向第一个结点
	while(p)
	{
		p=p->Next;
		cnt++;
	}
	return cnt;
}

查找
链式存储跟求表长类似，从链表的第一个元素结点开始，判断当前结点是否是第k个

#define ERROR -1
ElementType FindKth(List L,int K)
{
	Position p;
	int cnt=1;//位序从1开始
	p=L;
	while(p&&cnt<K)//从第一个元素开始，并不超过第k个元素
	{
		p=p->Next;
		cnt++;
	}
	if((cnt==K)>&&p)
	return p->Data;
	else
	return ERROR;
}
	

按值查找
从链表的第一个结点开始，判断当前结点其值是否等于X，若是则返回结点位置

#define ERROR NULL
Position Find(List L,ELementType X)
{
	Position p=L;
	while(p&&p->Data!=X)
	p=p->Next;
	if(p)
	return p;
	else
	return ERROR;
}

插入

#define ERROR NULL
List Insert(List L,ElementType X,int i)
{
	Position tmp,pre;
	tmp=(Position)malloc(sizeof(struct LNode));
	tmp->Data=X;
	if(i==1)
	{
		tmp->Next=L;
		return tmp;
	}

else
{
	int cnt=1;
	pre=L;
	while(pre&&cnt<i-1)
	{
		pre=pre->Next;
		cnt++;
	}
	if(pre==NULL||cnt!=i-1)
	{
	free(tmp);
	return ERROR;
	}
else
{
	tmp->Next=pre->next;
	pre->Next=tmp;
	return L;
}
}
}

删除

bool Delete(List L,int i)
{
	Position tmp,pre;
	int cnt=0;
	pre=L;
	while(pre&&cnt<i-1)
	{
		pre=pre->Next;
		cnt++;
	}
	if(pre==NULL||cnt!=i-1||pre->Next==NULL)
	{
	//指针指向空或者不是指向i-1位置
	return ERROR;
	}
	else
	{
		tmp=pre->Next;
		pre->Next=tmp->Next;
		free(tmp);
		return true;
	}
}