线性表的基本操作

#include <stdio.h>
#include <stdlib.h> //malloc exit

//线性表的顺序存储结构
#define MAXSIZE 20
typedef int ElemType;
typedef struct
{
	ElemType data[MAXSIZE];
	int length;
}SqList;

#define OK 1
#define ERROR 0
#define TRUE 1
#define FALSE 0
typedef int Status

//用e返回L中第i个数据元素的值
Status GetElem(SqList L,int i,ElemType *e)
{
	if(L.length==0||i<1||i>L.length)
		return ERROR;
	*e=L.data[i-1];
	return OK;
}
//在L中第i个位置之前插入新的数据元素e,L的长度加1
Status ListInsert(SqList *L,int i,ElemType e)
{
	int k;
	if(L->length==MAXSIZE)
		return ERROR;
	if(i<1||i>L->length+1)
		return ERROR;
	if(i<=L->length) //若要插入的数据位置不在表尾
	{
		for(k=L->length-1;k>=i-1;k--)
			L->data[k+1]=L->data[k];
	}
	L->data[i-1]=e;
	L->length++;
	return OK;
}
//删除操作
Status ListDelete(SqList *L,int i,ElemType *e)
{
	int k;
	if(L->length==0)
		return ERROR;
	if(i<1||i>L->length)
		return ERROR;
	*e=L->data[i-1];
	if(i<L->length) //如果删除不是最后位置
	{
		for(k=i;k<L->length;k++)
		  L->data[k-1]=L->data[k];
	}
	L->length--;
	return OK;
}
//线性表的单链表存储结构
typedef struct Node
{
	ElemType data;
	struct Node *next;
}Node,*LinkList;
//用e返回L中第i个数据元素的值
Status GetElem(LinkList L,int i,ElemType *e)
{
	int j;
	LinkList p;
	p=L->next;
	while(p&&j<i) 
	{
		p=p->next;
		j++;
	}
	if(!p||j>i)
		return ERROR;
	*e=p->data;
	return OK;
}
//在L中第i个位置之前插入新的数据元素e,L的长度加1
Status LinkInsert(LinkList *L,int i,ElemType e)
{
	int j;
	LinkList p,s;
	p=*L;
	j=1;
	while(p&&j<i)
	{
		p=p->next;
		++j;
	}
	if(!p||j>i)
		return ERROR;
	s=(LinkList)malloc(sizeof(Node));
	s->data=e;
	s->next=p->next;
	p->next=s;
	return OK;
}
//删除L的第i个数据元素，并用e返回其值，L的长度减1
Status ListDelete(LinkList *L,int i,ElemType *e)
{
	int j;
	LinkList p,q;
	p=*L;
	j=1;
	while(p->next&&j<i) //找到第i个元素的前驱
	{
		p=p->next;
		j++;
	}
	if(!(p->next)||j>i)
		return ERROR;  //第i个元素不存在
	q=p->next;
	p->next=q->next;
	*e=q->data;
	free(q);
	return OK;
	
}
//单链表的整表创建
//逆序插入
void CreateListHead(LinkList *L,int n)
{
	LinkList p;
	int i,data;
	*L=(LinkList)malloc(sizeof(Node));
	(*L)->next=NULL;
	for(i=0;i<n;i++)
	{
		scanf("%d",&data); //1 2 3 4 5....
		p=(LinkList)malloc(sizeof(Node));
		p->data=data;
		p->next=(*L)->next;
		(*L)->next=p;
	}
}
//顺序插入
void CreateListHead(LinkList *L,int n)
{
	LinkList p,r;
	int i,data;
	*L=(LinkList)malloc(sizeof(Node));
	(*L)->next=NULL;
	r=(*L);
	for(i=0;i<n;i++)
	{
		scanf("%d",&data); //1 2 3 4 5....
		p=(LinkList)malloc(sizeof(Node));
		p->data=data;
		r->next=p;
		r=p;
	}
	r->next=NULL;
}
//单链表的整表删除
Status ClearList(LinkList *L)
{
	LinkList p,q;
	p=(*L)->next;
	while(p)
	{
		q=p->next;
		free(p);
		p=q;
	}
	(*L)->next=NULL;
	return OK;
}
//单链表的逆置
//带头结点的单链表的逆置运算
void reverse(LinkList h)
{
	LinkList p,q;
	p=h->next;
	h->next=NULL;
	while(p！=NULL)
	{
		q=p;
		p=p->next;  //依次链接
		q->next=h->next;  //将q所指结点链接到新链表中
		h->next=q;  //头结点指向新链接的结点，也就会第一个结点
	}
}

//不带头结点的单链表的逆置运算
void reverse(LinkList &L)
{
	p=null;
	q=L;
	while(q!=null)
	{
		L=L->next;  //暂存下一个结点否则执行下一步时，就被覆盖了找不到了
		q->next=p; //q是带操作结点，p是上一个结点
		p=q;  //将本结点设置为上一个结点
		q=L;  //将暂存的结点设为待操作的结点
		
	}
	L=p; //将第一个结点设置为L
}
//静态链表
#define MAXSIZE 1000
typedef struct
{
	ElemType data;
	int cur;
}Component,StaticLinkList[MAXSIZE];

//将一维数组space中各分量链成一备用链表
//对数组第一个和最后一个元素作为特殊元素处理，不存数据，通常
//把未被使用的数组元素称为备用链表
//数组第一个元素即下标为0的元素存放备用链表第一个结点的下标，而数组的最后一个元素
//则存放第一个有数值元素的下标，相当于单链表中头结点作用
//当整个链表为空时,为0
Status InitList(StaticLinkList space)
{
	int i;
	for(i=0;i<MAXSIZE-1;i++)
		space[i].cur=i+1;
	space[MAXSIZE-1].cur=0;
}
//实现malloc和free函数
//若备用空间链表非空，则返回分配的结点下标，否则返回0
int Malloc_SLL(StaticLinkList space)
{
	int i=space[0].cur;
	if(space[0].cur)
		space[0].cur=space[i].cur;
	return i;
}
void Free_SSL(StaticLinkList space,int k)
{
	space[k].cur=space[0].cur;
	space[0].cur=k;
}
//求长度
int ListLength(StaticLinkList L)
{
	int j=0;
	int i=L[MAXSIZE-1].cur;
	while(i)
	{
		i=L[i].cur;
		j++;
	}
	return j;
}
//在L中第i个元素之前插入新的数据元素
Status ListInsert(StaticLinkList L,int i,ElemType e)
{
	int j,k,l;
	k=MAXSIZE-1;  //k首先是最后一个元素的下标
	if(i<1||i>ListLength(L)+1)
		return ERROR;
	j=Malloc_SLL(L);//获得空闲分量的下标
	if(j)
	{
		L[j].data=e;
		for(l=1;l<=i-1;l++)
			k=L[k].cur;
		L[j].cur=L[k].cur;
		L[k].cur=j;
		return OK;
	}
	return ERROR;
}
//删除L中第i个数据元素e
Status LinkDelete(StaticLinkList L,int i)
{
	int j,k;
	if(i<1||i>LinkLength(L))
		return ERROR;
	k=MAXSIZE-1;
	for(j=1;j<i-1;j++)
		k=L[k].cur;
	j=L[k].cur;
	L[k].cur=L[j].cur;
	Free_SSL(L,j);
	return OK;
}
//双向链表
//将结点s插入到结点p和p->next之间的步骤
//s->prior=p;
//s->next=p->next;
//p->next->prior=s;
//p->next=s;
//删除结点p
//p->prior->next=p->next;
//p->next->prior=p->prior;
//free(p);