线性表链式存储

#include<stdio.h>
#include<stdlib.h>
#include <time.h>

typedef  int ElemType;
typedef int Status;

#define ERROR 0
#define OK 1

Status visit(ElemType e)
{
	printf("%d ",e);
	return OK;
}

typedef struct Node{
	ElemType data;
	struct Node *Next;//Node *Next;错误
}Node,*LinkList;//LinkList为*Node，指向结构体Node的指针，代表一个节点

/* 初始化顺序线性表 */
Status InitList(LinkList *l)
{
	*l=(LinkList)malloc(sizeof(Node));
	if(!(*l))
		return ERROR;
	(*l)->Next=NULL;
	return OK;
}

/* 初始条件：顺序线性表L已存在。操作结果：返回L中数据元素个数 */
Status ListLength(LinkList l)
{
	int n=0;//需要初始化
	LinkList p;
	p=l->Next;
	while(p!=NULL)//while(p)
	{
		p=p->Next;
		n++;
	}
	return n;
}

//Status ListInsert(LinkList *l,int i,ElemType e)
//{
//	int j=1;
//	LinkList p,s;
//	if(i<1 || i>ListLength(*l)+1)
//		return ERROR;
//	p=(*l)->Next;
//	while(p->Next && j<i)//这句有错，当*l为空链表时，p为NULL
//	{
//		p=p->Next;
//		j++;
//	}
//	s=(LinkList)malloc(sizeof(Node));
//	s->data=e;
//	s->Next=p->Next;
//	p->Next=s;
//	return OK;
//}

//OK
//Status ListInsert(LinkList *l,int i,ElemType e)
//{
//	int j=1;
//	LinkList p,s;
//	if(i<1 || i>ListLength(*l)+1)
//		return ERROR;
//	p=*l;
//	while(p->Next && j<i)
//	{
//		p=p->Next;
//		j++;
//	}
//	s=(LinkList)malloc(sizeof(Node));
//	s->data=e;
//	s->Next=p->Next;
//	p->Next=s;
//	return OK;
//}

/* 初始条件：顺序线性表L已存在,1≤i≤ListLength(L)， */
/* 操作结果：在L中第i个位置之前插入新的数据元素e，L的长度加1 */
Status ListInsert(LinkList *L,int i,ElemType e)
{
	LinkList p,s;
	int j=1;
	p=*L;
	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已存在 */
/* 操作结果：依次对L的每个数据元素输出 */
Status ListTraverse(LinkList L)
{
	LinkList p;
	p=L->Next;
	while(p)
	{
		visit(p->data);
		p=p->Next;
	}
	printf("\n");
	return OK;
}

/* 初始条件：顺序线性表L已存在。操作结果：若L为空表，则返回TRUE，否则返回FALSE */
Status ListEmpty(LinkList L)
{
	LinkList p=L->Next;
	if(!p)
		return 1;
	else
		return 0;
}

/* 初始条件：顺序线性表L已存在。操作结果：将L重置为空表 */
Status ClearList(LinkList *L)
{
	LinkList p,s;
	if(!(*L)->Next)
		return OK;
	p=(*L)->Next;
	while(p)
	{
		s=p->Next;
		free(p);
		p=s;
	}
	(*L)->Next=NULL;//漏了这句，出错
	return OK;
}

/* 初始条件：顺序线性表L已存在，1≤i≤ListLength(L) */
/* 操作结果：用e返回L中第i个数据元素的值 */
Status GetElem(LinkList L,int i,int *data)
{
	int j;
	LinkList p;
	if(i<1 || i>ListLength(L))
		return ERROR;
	p=L->Next;
	j=1;
	while(p && j<i)
	{
		p=p->Next;
		j++;
	}
	//	if ( !p || j>i ) 
	//		return ERROR;  /*  第i个元素不存在 */
	*data=p->data;
	return OK;
}

/* 初始条件：顺序线性表L已存在 */
/* 操作结果：返回L中第1个与e满足关系的数据元素的位序。 */
/* 若这样的数据元素不存在，则返回值为0 */
int LocateElem(LinkList L,int i)
{
	LinkList p;
	int j=1;
	p=L->Next;
	while(i!=p->data)
	{
		p=p->Next;
		j++;
	}
	return j;
}
//int LocateElem(LinkList L,ElemType e)
//{
//    int i=0;
//    LinkList p=L->next;
//    while(p)
//    {
//        i++;
//        if(p->data==e) /* 找到这样的数据元素 */
//                return i;
//        p=p->next;
//    }
//
//    return 0;
//}

/* 初始条件：顺序线性表L已存在，1≤i≤ListLength(L) */
/* 操作结果：删除L的第i个数据元素，并用e返回其值，L的长度减1 */
Status ListDelete(LinkList *L,int i,int *e)
{
	LinkList p,s;
	int j=1;
	p=*L;
	while(p->Next && j<i)
	{
		p=p->Next;
		j++;
	}
	if(!(p->Next) || j>i)
		return ERROR;
	s=p->Next;
	*e=s->data;
	p->Next=s->Next;
	free(s);

	return OK;
}

/* 随机产生n个元素的值，建立带表头结点的单链线性表L（头插法）*/
Status CreateListHead(LinkList *L,int n)
{
	LinkList p,s;
	int i;
	srand(time(0)); /* 初始化随机数种子 */
	InitList(L);
	p=*L;
	for(i=1;i<=n;i++)
	{
		s=(LinkList)malloc(sizeof(Node));
		s->data=rand()%100+1;
		s->Next=p->Next;
		p->Next=s;
	}
	return OK;
}

/*随机产生n个元素的值，建立带表头结点的单链线性表L（尾插法）*/
Status CreateListTail(LinkList *L,int n)
{
	LinkList p,s;
	int i;
	srand(time(0)); /* 初始化随机数种子 */
	InitList(L);
	p=*L;
	for(i=1;i<=n;i++)
	{
		s=(LinkList)malloc(sizeof(Node));
		s->data=rand()%100+1;
		p->Next=s;
		p=s;
	}
	p->Next=NULL;//链表最后元素需要指向NULL，没有这句报错
	return OK;
}

int main()
{        
    LinkList L;
    ElemType e;
    Status i;
    int j,k;
    i=InitList(&L);
    printf("初始化L后：ListLength(L)=%d\n",ListLength(L));
    for(j=1;j<=5;j++)
		i=ListInsert(&L,1,j);
    printf("在L的表头依次插入1～5后：L.data=");
    ListTraverse(L); 

    printf("ListLength(L)=%d \n",ListLength(L));
    i=ListEmpty(L);
    printf("L是否空：i=%d(1:是 0:否)\n",i);

    i=ClearList(&L);
    printf("清空L后：ListLength(L)=%d\n",ListLength(L));
    i=ListEmpty(L);
    printf("L是否空：i=%d(1:是 0:否)\n",i);

    for(j=1;j<=10;j++)
            ListInsert(&L,j,j);
    printf("在L的表尾依次插入1～10后：L.data=");
    ListTraverse(L); 

    printf("ListLength(L)=%d \n",ListLength(L));

    ListInsert(&L,1,0);
    printf("在L的表头插入0后：L.data=");
    ListTraverse(L); 
    printf("ListLength(L)=%d \n",ListLength(L));

    GetElem(L,5,&e);
    printf("第5个元素的值为：%d\n",e);

    for(j=3;j<=4;j++)
    {
        k=LocateElem(L,j);
        if(k)
                printf("第%d个元素的值为%d\n",k,j);
        else
                printf("没有值为%d的元素\n",j);
    }

    k=ListLength(L); /* k为表长 */
    for(j=k+1;j>=k;j--)
    {
        i=ListDelete(&L,j,&e); /* 删除第j个数据 */
        if(i==ERROR)
                printf("删除第%d个数据失败\n",j);
        else
                printf("删除第%d个的元素值为：%d\n",j,e);
    }
    printf("依次输出L的元素：");
    ListTraverse(L); 

    j=5;
    ListDelete(&L,j,&e); /* 删除第5个数据 */
    printf("删除第%d个的元素值为：%d\n",j,e);

    printf("依次输出L的元素：");
    ListTraverse(L); 

    i=ClearList(&L);
    printf("\n清空L后：ListLength(L)=%d\n",ListLength(L));
    CreateListHead(&L,20);
    printf("整体创建L的元素(头插法)：");
    ListTraverse(L); 
    
    i=ClearList(&L);
    printf("\n删除L后：ListLength(L)=%d\n",ListLength(L));
    CreateListTail(&L,20);
    printf("整体创建L的元素(尾插法)：");
    ListTraverse(L); 

	system("pause");
    return 0;
}

运行结果：