链表存储结构及操作

1.顺序表
（1）顺序表的存储结构

//--------顺序表的存储结构-----------
#define MAXSIZE 100
enum 
{
 int,
 float,
 char
}ElemType;
 
typedef struct
{
  ElemType *elem;
  int length;
}SqList;

（2）顺序表初始化

//-------顺序表初始化--------------
Status InitLIst(SqList &L)
{
	L.elem = new ElemType[MAXSIZE];
	if(!L.elem) exit(OVERFLOW);
	L.length = 0;
	return OK;
}

（3）顺序表的取值

Status GetElem(SqList &L,int i,ElemType &e)
{
	if((i < 1) || (i > L.length)) return ERROR;
	e = L.elem[i-1];
	return OK;
}

（4）顺序表的查找

//-------顺序表的查找--------
int LocateElem(SqList &L, ElemType e)
{
	for(i = 0; i < L.length, i++)
		if(L.elem [i] == e) return i+1;
	return 0;
}

（5）顺序表的插入

//-------顺序表的插入----------
Status ListInsert(SqList &L, int i, ElemType e)
{
	if((i<1) || (i > L.length +1)) return ERROR;
	if(L.length == MAXSIZE) return ERROR;
	for(j = L.length -1; j>= i-1; j--)
		L.elem[j+1] = L.elem[j];
	L.elem[i-1] = e;
	L.length++;
	return OK;
}

（6）顺序表的删除

//-----顺序表的删除-----------
Status ListDelete(SqList &L, int i)
{
	if((i<1) || (i > L.length +1)) return ERROR;
	for(j = i; j <= L.length -1; j++)
		L.elem[j - 1] = L.elem[j];
	L.length--;
	return OK;
}

2.单链表
（1）单链表的存储结构

//--------单链表的存储结构------------
typedef struct Node
{
	ElemType data;
	struct LNode *next;
}LNode,*LinkList;

（2）初始化

//-------单链表初始化--------------
Status IintList(LinkList L)
{
	L = new LNode;
	L->next = NULL;
	return OK;
}

（3）取值

//------单链表的取值----------
Status GetElem(LinkList L, int i, ElemType &e)
{
    LNode *p;
	p = L->next;
	int j = 1;
	while(p && j<i)
	{
		p = p->next;
		j++;
	}
	if(!p || j>1) return ERROR;
	e = p->data;
	return OK;
}

（4）查找

//--------单链表的按值查找-----------
LNode *LocateElem(LinkList L, ElemType e)
{
	LNode *p;
	p = L->next;
	while(p != NULL && p->data != e)
		p = p->next;
	return p;
}

（5）插入

//----------单链表的插入--------------
Status ListInsert(LinkList L,int i, ElemType e)
{
	//在带头节点的单链表L中第i个位置插入值e的新节点
	LNode *p, s;
	p = L;
	int j = 0;
	while(p &&(j<i-1))
		{
		p = p->next;
		j++;
	}
	if(!p || j > i-1) return ERROR;
	s = (LNode *)malloc(sizeof(struct Node));
	s->data = e;
	s->next = p->next;
	p->next = s;
	return OK;
	
}

（6）删除

//---------单链表的删除-------------
Status ListDelete(LinkList L, int i)
{
	//在带头节点的单链表L中，删除第i个元素
	LNode *p,tmp;//???
	p = L;
	int j = 0;
	while((p->next)&&(j<i-1))
		{
		p = p->next;
		j++;
	}
	if(!(p->next) || (j > i-1)) return ERROR;
	tmp = p->next;
	p->next = tmp->next;
	free(tmp);
	return OK;
	
}

（7）前插法创建单链表

//------前插法创建单链表-------------
void CreateList_H(LinkList L, int n)
{	//逆位序输入n个元素的值,建立带表头结点的单链表L
	LNode *L;
	L = (LNode *)malloc(sizeof(struct Node));
	L->next = NULL;
	for(i=0;i<n;++i)
		{
		LNode *p = (LNode *)malloc(sizeof(struct Node));
		scanf("%d",&p->data);//???
		p ->next = L->next;
		L->next = p;
	}
}

（8）后插法创建单链表

//-------后插法创建单链表-----------------
void CreateList_R(LinkList L, int n)
{	//正位序输入n个元素的值,建立带表头结点的单链表L
	LNode *L;
	LNode *r;
	L = (LNode *)malloc(sizeof(struct Node));
	L->next = NULL;
	r = L;
	for(i=0;i<n;++i)
		{
		LNode *p = (LNode *)malloc(sizeof(struct Node));
		scanf("%d",&p->data);//???
		p->next = NULL;
		r->next = p;
		r = p;
	}
}

3.双链表
（1）双链表存储结构

//-------双向链表的存储结构-----------
typedef struct DuLNode
{
	ElemType data;
	struct DuLNode *prior;
	struct DuLNode *next;
}DuLNode,*DuLinkList;