链表的相关函数

链表函数

#include<stdio.h>
#include<stdlib.h>
typedef int Status;   //定义status为整型
#define ERROR 0       //宏定义
#define OK 1
#define TURE 1
#define FALSE 0
typedef struct student   //定义学生类型
{
	char no[10];
	char name[8];
}student;
typedef student ElemType;   
typedef struct LNode    //定义结点类型
{
	ElemType       data;
	struct LNode  *next;
}*Link,*Position;


typedef struct LinkList   //定义链表类型
{
	Link head,tail;    //头结点和最后一个结点
	int len;           //元素个数
}LinkList;


typedef LinkList L;
Status MakeNode(Link &p,ElemType e)   //分配p指向的值为e，返回OK，否则，返回ERROR
{
	p=(LNode *)malloc(sizeof(ElemType));
	if(!p)
	{
		return ERROR;
	}
    else
	{
		p->data=e;
	    p->next=NULL;
	    return OK;
	}
}
void FreeNode(LinkList &L,Link &p)      //释放P所指向的结点
{
	int i;
	LNode *temp;                      //temp为临时指针

    temp=L.head;             
	for(i=0;i<=L.len;i++)
	{
		if(temp->next!=p)
		{
			temp=temp->next;
		}
		else
		{
			temp->next=p->next;
		}
	}
    free(p);
}
Status InitList(LinkList &L)   //构造一个空的线性链表L
{
	L.head=(LNode *)malloc(sizeof(ElemType));
	L.head->next=NULL;
	if(!L.head)
	{
		return OK;
	}
	else
	{
		return ERROR;
	}
}
Status DestroyList(LinkList &L) //销毁一个链表
{
	L.head=NULL;
	if(!L.head)
	{
	  return OK;
	}
	else
	{
		return ERROR;
	}
}
Status ClearList(LinkList &L)  //将线性链表L重置为空表，并释放原链表的结点空间
{
	int i;
	LNode *p,*q;
	p=L.head->next;
	q=p->next;
	for(i=0;i<=L.len+1;i++)
	{
		free(p);
		p=q;
		q=q->next;
	}
	L.head=NULL;
    if(!L.head)
	{
   	  return OK;
	}
	else
	{
		return ERROR;
	}
}
Status InsFirst(Link h,Link s)//已知h指向线性链表的头结点，将s所指结点插入在第一个结点之前
{
	s->next=h->next;
	h->next=s;
	return OK;
}
Status DelFirst(Link h,Link &q)//已知h指向线性链表的头结点，删除链表中的第一个结点并以q返回
{
	q->next=h->next->next;
	free(h->next);
	h->next=q;
    return OK;
}
Status Append(LinkList &L,Link s)//将指针s所指（彼此以指针相链）的一串结点链接在线性链表L的最后一个结点之后，并改变链表L的尾指针指向新的尾结点
{
	L.tail->next=s;
	s->next=NULL;	
		return OK;	
}
Status Remove(LinkList &L,Link &q)//删除线性链表L中的尾结点并以q返回，改变链表L的尾指针指向新的尾结点
{
	Link p;
	p=L.head;
	int i;
	for(i=1;i<L.len;i++)
	{
		p=p->next;
	}
	free(L.tail);
	p->next=q;
	q->next=NULL;
	return OK;
}
Status InsBefore(LinkList &L,Link &p,Link s)  //已知p指向线性链表L中的一个结点，将s所指结点插入在p所指结点之前，并修改指针p指向新插入的结点
{
	Link q;
	q=L.head;
    while(q->next!=p)
	{
		q=q->next;
	}	
	s->next=q->next->next;
	q->next=s;				
    return OK;
}
Status InsAfter(LinkList &L,Link &p,Link s) //已知p指向线性链表L中的一个结点，将s所指结点插入在p所指结点之后，并修改指针p指向新插入的结点
{
	 s->next=p->next;
	 p->next=s;
	return OK;
}
Status SetCurElem(Link &p,ElemType e) //已知p指向线性链表中的一个节点，用e更新p所指结点中元素的值
{
	p->data=e;
	return OK;
}
ElemType GetCurElem(Link p)//已知p指向线性链表中的一个结点，返回p所指结点中数据元素的值
{
	return p->data;
}
Status ListEmpty(LinkList L)//  若线性链表L为空表，则返回TRUE,否则返回FLASE
{
	if(!L.head)
	{
		return TURE;
	}
	else
	{
		return FALSE;
	}
}
int ListLength(LinkList L)//返回线性链表L中元素个数
{
	int i=0;
	Link p;
	p=L.head;
	while(p->next!=NULL)
	{
		p=p->next;
		i++;
	}
	return i;
}
Position GetHead(LinkList L)//返回线性链表L中头结点的位置
{
	return L.head;
}
Position GetLast(LinkList L)//返回线性链表L中最后一个结点的位置
{
	return L.tail;
}
Position PriorPos(LinkList L,Link p)//已知p指向线性链表L中的一个结点，返回p所指结点的直接前驱的位置，若无前驱，则返回NULL
{
	Link q;
	q=L.head;
	if(L.head=p)
	{
		return NULL;
	}
	while(q->next!=p)
	{
		q=q->next;
	}
	return q;
}
Position NextPos(LinkList L,Link p)//已知p指向线性链表L中的一个结点，返回p所指结点的直接后继的位置，若无后继，则返回NULL
{
	if(p->next=NULL)
	{
		return NULL;
	}
	else
	{
		return p->next;
	}
}
Status LocatePos(LinkList L,int i,Link &p)//返回p指示线性链表L中第i个结点的位置并返回OK，i值不合法时返回ERROR
{
	int j;
	Link q;
	q=L.head;
	if(i<=0||i>L.len)
	{
		return ERROR;
	}
	else
	{
		for(j=1;j<=i;j++)
		{
			q=q->next;
		}
	p=q;
	return OK;
	}
}
Position LocateElem(LinkList L,ElemType e,Status(*compare)(ElemType,ElemType))
//返回线性链表L中第1个与e满足函数compare()判定关系的元素的位置，若不存在这样的元素，则返回NULL
{
	Link p;
	p=L.head;
	int i;
	for(i=1;i<=L.len;i++)
	{
		if((*compare)(p,e))
		{
			return p->next;
		}
		else
		{
			if(p->next=NULL)
			{
				return NULL;
			}
			else
			{
				p=p->next;
			}
		}
	}


}
Status ListTraverse(LinkList L,Status (*vist)())
//依次对L的每个元素调用函数visit(),一旦visit()失败，则操作失败
{
	Link p;
	p=L.head;
	while((*vist)())
	{
		p=p->next;		
	}
	return ERROR;
}
void main()
{
	LinkList L;
    InitList(L);
	DestroyList(L);
    ClearList(L);
}

双向循环链表

#include<stdio.h>
#include<stdlib.h>
typedef struct Student
{
	char no[10];
	char name[8];
}Student;
typedef Student ElemType;
typedef struct LNode
{
	LNode *front;
	ElemType data;
	LNode *next;
}LNode;
typedef struct LinkList
{
	LNode *head;//头结点
	int len;//结点个数
}LinkList;
int main()
{
	LNode *p,*q;
	LinkList L;
	L.head=(LNode *)malloc(sizeof(LNode));
	if(!L.head)
	{
		return 0;
	}
	else
	{
		p=L.head;
		p->front=NULL;
		p->next=NULL;
	}
	printf("正向输入三个结点的Student的数据\n");
	for(int i=1;i<=3;i++)//创建有三个元素的链表
	{
		p->next=(LNode *)malloc(sizeof(LNode));
		p->next->front=p;
		scanf("%s%s",p->next->data.no,p->next->data.name);
		p->next->next=NULL;
		p=p->next;
	}
	p->next=L.head->next;
	L.head->next->front=p;
    q=L.head->next;
	printf("正向输出\n");
	for(i=1;i<=3;i++)//正顺序输出
	{
		printf("%s,%s\n",q->data.no,q->data.name);
		q=q->next;
	}
	q=q->front;
	printf("反向输出\n");
	for(i=1;i<=3;i++)//反顺序输出
	{
		printf("%s,%s\n",q->data.no,q->data.name);
		q=q->front;
	}
    return 0;
}

单链表首尾颠倒

/*构建链表，并且输入元素
 *显示链表元素
 *链表收尾颠倒
 *显示链表元素
*/
#include<stdio.h>
#include<stdlib.h>
#define STACK_INIT_SIZE 100
#define STACKINCREMENT 10
#define OK 1
#define ERROR 0
typedef int Status;
typedef int ElemType;
typedef struct LNode /*结点*/
{
	ElemType data;
	LNode *next;
}LNode;
typedef struct LinkList/*链表*/
{
	LNode *head;
	int len;
}LinkList;
Status InitList(LinkList &L)   //构造一个空的线性链表L
{
	L.head=(LNode *)malloc(sizeof(ElemType));
	L.head->next=NULL;
	if(!L.head)
	{
		return OK;
	}
	else
	{
		return ERROR;
	}
}
Status SetList(LinkList &L) //建立有n个元素的链表
{
	int i,m;
	LNode *p,*q;
	p=L.head;
	printf("输入元素个数：");
	scanf("%d",&m);
	printf("输入元素：");
	for(i=1;i<=m;i++)
	{
		q=(LNode *)malloc(sizeof(LNode));
		scanf("%d",&(q->data));
		p->next=q;
		q->next=NULL;
		p=q;
	}
	return OK;
}
Status ShowLinkList(LinkList &L)//显示链表
{
	LNode *p;
	p=L.head->next;
	printf("\n显示链表:");
    while(p!=NULL)
	{
		printf("%d  ",p->data);
		p=p->next;
	}
    return OK;
}
Status BottomUp(LinkList &L)//单链表的收尾颠倒，插入法
{
	LNode *p,*q;
	q=L.head;
	while(q->next->next!=NULL)
	{
		p=q;
		while(p->next->next!=NULL)
		{
			p=p->next;
		}
			p->next->next=q->next;
			q->next=p->next;
			p->next=NULL;
			q=q->next;	
	}
	printf("颠倒过后：\n");
	return OK;
}
void main()
{
	LinkList L;
	InitList(L);
	SetList(L);
	ShowLinkList(L);
	BottomUp(L);
	ShowLinkList(L);   
}