带头指针的单链表

/*
	主题：带头指针的单链表的基本操作
	作者：nixindong
	开发环境：Visual Studio
	开发语言：C
*/
//头文件
#include <stdio.h>
#include <stdlib.h>

typedef int ElemType;
//链表结点
typedef struct node
{
	ElemType data;
	struct node *pNext;
}NODE, *LinkList;

typedef enum {TRUE = 1, FALSE = 0}boolean;

//函数声明
boolean initList(NODE **L);
int listLength(NODE *pHead);
boolean listInsert(register NODE **pHead, int i, ElemType value);
void listTraverse(NODE *pHead);
boolean listEmpty(NODE *pHead);
boolean clearList(NODE *pHead);
boolean destroyList(NODE **pHead);
boolean getItem(NODE * pHead, int i, ElemType *value);
boolean priorElem(NODE *pHead, int i, ElemType *value);
boolean listDelete(NODE *pHead, int i, ElemType *value);
//主函数
int main(void)
{
	LinkList L;
	boolean index;
	ElemType value;
	int i = 0;

	index = initList(&L);
	if (index)
	{
		puts("初始化成功！");
	}
	else
	{
		puts("初始化失败！");
	}
	//测试插入函数
	for (i = 1; i < 10; i++)
	{
		listInsert(&L, i, i);
	}
	
	getItem(L, 4, &value);

	printf("value = %d\n", value);

	priorElem(L, 4, &value);
	printf("value = %d\n", value);
	listDelete(L, 4, &value);
	printf("value = %d\n", value);
	listTraverse(L);
	
	clearList(L);

	listTraverse(L);

	destroyList(&L);
	
 	return 0;
}
/*
	单链表的操作函数
*/
/*
	函数名：  InitList
	功能：    构造一个空线性表
	输入参数：L (表名）   
	返回值：  类型（boolean)
			  返回TRUE表示空表构建成功；
			 返回FALSE表示空表分配内存失败
	修改记录:
*/
boolean initList(NODE **L)
{
	*L = (NODE *) malloc(sizeof(NODE));

	if (NULL == *L)
	{
		return FALSE;
	}

	(*L)->pNext = NULL;
	return TRUE;
}
/*
	函数名：  listInsert
	功能：    构造一个空线性表
	输入参数：pHead (链表），
				i(数据插入位置)
				value(待插入数据)
	返回值：  类型（boolean)
			  返回TRUE表示数据插入成功；
			 返回FALSE表示数据插入失败
	修改记录:
*/
boolean listInsert(register NODE **pHead, int i, ElemType value)
{
	register NODE *pCurrent = NULL;
	register NODE *pNew = NULL;
	int j = 0;

	if (i < 0 || i > listLength(*pHead) + 1)
	{
		return FALSE;
	}

	pCurrent = *pHead;
	//让pCurrent指针指向插入位置的前一个结点
	while(pCurrent->pNext != NULL && j++ < i - 1)
	{
		pCurrent = pCurrent->pNext;
	}
	//为插入结点分配空间
	pNew = (NODE *) malloc(sizeof(NODE));
	if (NULL == pNew)
	{
		return FALSE;
	}
	//插入结点
	pNew->data = value;
	pNew->pNext = pCurrent->pNext;
	pCurrent->pNext = pNew;
	
	return TRUE;
}
/*
	函数名：  listLength
	功能：    返回一个线性表的长度
	输入参数：pHead (链表），
	返回值：  类型（int)
					链表长度
	修改记录:
*/
int listLength(NODE *pHead)
{
	int len = 0;
	/*
		这里新创建一个指针的目的是为了不改变pHead指针
	*/
	NODE *p = pHead->pNext;

	while(p != NULL)
	{
		len++;
		p = p->pNext;
	}

	return (len);
}
/*
	函数名：  listTraverse
	功能：    遍历线性表
	输入参数：pHead (链表），
	返回值：  类型（void)
	修改记录:
*/
void listTraverse(NODE *pHead)
{
	while(pHead->pNext != NULL)
	{
		printf("%d\n", pHead->pNext->data);
		pHead = pHead->pNext;
	}
}
/*
	函数名：  listEmpty
	功能：    判断一个线性链表是否为空
	输入参数：pHead (链表），
	返回值：  类型（boolean)
				TRUE:是
				FALSE：否
	修改记录:
*/
boolean listEmpty(NODE *pHead)
{
	if (NULL == pHead->pNext)
	{
		return TRUE;
	}
	else
	{
		return FALSE;
	}
}
/*
	函数名：  clearList
	功能：    将一个线性链表置为空表
	输入参数：pHead (链表），
	返回值：  类型（boolean)
				TRUE:设置成功
				FALSE：失败
	修改记录:
*/
boolean clearList(NODE *pHead)
{
	NODE *pDelete = NULL;
	NODE *pSave = NULL;
	pDelete = pHead->pNext;			//使pDelete指向第一个结点

	while(pDelete)
	{
		pSave = pDelete->pNext;
		//释放结点
		free(pDelete);
		pDelete = NULL;
		pDelete = pSave;
	}

	pHead->pNext = NULL;

	return TRUE;
}
/*
	函数名：  destroyList
	功能：    销毁一个线性表
	输入参数：pHead (链表），
	返回值：  类型（boolean)
				TRUE:成功
				FALSE：失败
	修改记录:
*/
boolean destroyList(NODE **pHead)
{
	NODE *pDelete = NULL;

	while (*pHead)
	{
		pDelete = (*pHead)->pNext;
		free(*pHead);
		*pHead = NULL;
		*pHead = pDelete;
	}
	return TRUE;
}
/*
	函数名：  getItem
	功能：   返回第i个位置的值，并将这个值存放在value里
	输入参数：pHead (链表），
				i(位置)
				value(数据存放区域）
	返回值：  类型（boolean)
				TRUE:第i个数据存在
				FALSE：失败
	修改记录:
*/
boolean getItem(NODE * pHead, int i, ElemType *value)
{
	int j = 0;
	NODE *pCurrent = NULL;
	//参数有效性判断
	if (i < 1 || i > listLength(pHead) || NULL == pHead)
	{
		return FALSE;
	}

	pCurrent = pHead->pNext;

	while(pCurrent != NULL && j < i -1)
	{
		pCurrent = pCurrent->pNext;
		j++;
	}

	*value = pCurrent->data;
	return TRUE;
}
/*
	函数名： priorElem
	功能：   返回第i个位置的前驱，并将这个值存放在value里
	输入参数：pHead (链表），
				i(位置)
				value(数据存放区域）
	返回值：  类型（boolean)
				TRUE:第i个数据存在，并且它不是第一个数据
				FALSE：失败
	修改记录:
*/
boolean priorElem(NODE *pHead, int i, ElemType *value)
{
	int j = 0;
	NODE *pCurrent = NULL;

	if (i <= 1 || i > listLength(pHead) || NULL == pHead)
	{
		return FALSE;
	}

	pCurrent = pHead->pNext;

	while(pCurrent != NULL && j < i -2)
	{
		pCurrent = pCurrent->pNext;
		j++;
	}

	*value = pCurrent->data;

	return TRUE;
}
/*
	函数名： listDelete
	功能：   删除第i个位置的数据，并将这个值存放在value里
	输入参数：pHead (链表），
				i(位置)
				value(数据存放区域）
	返回值：  类型（boolean)
				TRUE:第i个数据存在
				FALSE：失败
	修改记录:
*/
boolean listDelete(NODE *pHead, int i, ElemType *value)
{
	int j = 0;
	NODE *pCurrent = NULL;
	NODE *pDelete = NULL;

	if (NULL == pHead || i < 1 || i > listLength(pHead))
	{
		return FALSE;
	}

	pCurrent = pHead;
	//寻找第i个结点，使pCurrent指向它的前驱
	while(pCurrent != NULL && j < i - 1)
	{
		pCurrent = pCurrent->pNext;
		j++;
	}

	if (pCurrent->pNext == NULL)
	{
		return FALSE;
	}
	//删除并释放结点
	pDelete = pCurrent->pNext;
	pCurrent->pNext = pDelete->pNext;
	*value = pDelete->data;
	free(pDelete);
	pDelete = NULL;

	return TRUE;
}