数据结构--线性链表

线性表的链式存储结构

顺序存储结构逻辑和物理都相邻，有随机访问的优势，也有插入删除时时间复杂度高的缺点，链式结构正是为了克服这个缺点，它不要求物理相邻，它也可以物理相邻，所以我们只关系它的逻辑结构。

线性链表

每个节点有一个数据域，也有一个指向下一个节点的指针，开头可以有一个头节点指向第一个节点，最后一个节点指针域为NULL，也就是若为空表，则头节点的指针域为空，若销毁链表，则头节点一起销毁。

typedef struct  LNode{
     ElemType  data;
     struct LNode *next;
}Lnode,*PLnode;

线性链表的特点

优点：
插入和删除的时间复杂度O（1），易扩展，节约存储空间。
缺点：
不能快速读取表中的某个位置的元素，需要花费O（n）来查找元素。需要为表中元素之间的逻辑关系增加额外的存储空间（指针域）。

抽象数据类型的实现（带头节点）

初始化线性链表，也就是创建头节点

typedef  int ElemTpye;
typedef struct  LNode {
	ElemTpye  data;
	struct LNode *next;
}LNode, *PLNode;

typedef enum MyEnum
{
	OK = 0,//操作成功
	ERROR,
	EMPTY,//空表
	NO_EMPTY,//非空
	MALL_ERR,//开辟空间失败
	OVER_FLOW,//溢出
	USE_UNDEFOP//使用未定义操作
}RESULT;
/*
@breaf  建立一个空的线性表
@param  线性表指针
@return  RESULT
*/

RESULT InitList(LNode *L)
{
	L = (LNode *)malloc(sizeof(LNode));
	if (!L)
		return MALL_ERR;
	L->next = NULL;
}

销毁线性表和清空线性表的区别在于，头节点是否释放掉。

/*
@breaf  销毁线性表
@param  L[in]线性表指针
@return  RESULT
*/
RESULT DestryList(LNode *L)
{
	LNode  *pbuff;
	while (L)
	{
		pbuff = L->next;
		free(L);
		L = pbuff;
	}
	return OK;
}

/*
@breaf  清空线性表
@param   L[in]线性表指针
@return  RESULT
*/
RESULT ClearList(LNode *L)
{
	LNode  *pbuff, *L2;
	L2 = L;
	L->next = NULL;
	while (L2->next)
	{
		pbuff = L2->next;
		free(L2);
		L2 = pbuff;
	}
	return OK;
}

判断是否是空表，获得链表长度

/*
@breaf  判断线性表是否为空
@param   L[in]线性表
@return  RESULT
*/
RESULT ListEmpty(LNode L)
{
	if (L.next)
		return NO_EMPTY;
	return OK;
}
/*
@breaf  获得线性表长度
@param   L[in]线性表
@return  线性表长度
*/
int ListLength(LNode *L)
{
	int len = 0;
	while (L->next)
	{
		L = L->next;
		len++;
	}
	return len;
}

通过位置查找数据和通过数据查找位置

/*
@breaf  将线性表L中的第i个位置元素返回给e
@param  L[in]线性表
@param  i[in]位置
@param  e[out]查找的元素
*/
RESULT GetElem(LNode *L, int i, int *e)
{
	int len = 0;
	while (L->next)
	{
		if (++len==i)
		{
			*e=L->next->data;
			return OK;
		}
		L = L->next;
	}
	return OVER_FLOW;
}


/*
@breaf  在线性表L中查找与给定值e相等的元素，如果查找成功,返回该元素在表中的序列号。
@param   L[in]线性表
@param  e[in]查找的元素
@return 序列号，-1为失败
*/
int LocateElem(LNode * L, ElemTpye e)
{
	int len = 0;
	while (L->next)
	{
		len++;
		L = L->next;
		if (L->data == e)
			return len;
	}
	return OVER_FLOW;
}

返回某个元素的前驱和后继

/*
@breaf  若cur_e是L的元素且不是第一个元素则用per_e返回它的前驱
@param   L[in]线性表
@param   cur_e[in]查找的元素
@param   pre_e[out]返回前驱的元素
@return  RESULT
*/
RESULT PriorElem(LNode *L, ElemTpye cur_e, ElemTpye *pre_e)
{
	int buff=0;
	int len= LocateElem(L, cur_e);
	if (len != 1)
	{
		while (L->next)
		{
			L = L->next;
			if (++buff==len-1)
			{
				*pre_e=L->data;
				return OK;
			}
		}
	}
	return ERROR;
}
/*
@breaf  若cur_e是L的元素且不是最后一个元素则用per_e返回它的后继
@param   L[in]线性表
@param   cur_e[in]查找的元素
@param   pre_e[out]返回后继的元素
@return  RESULT
*/
RESULT NextElem(LNode *L, ElemTpye cur_e, ElemTpye *pre_e)
{
	while (L->next)
	{
		L = L->next;
		if (L->data == cur_e)
		{
			if (L->next->next)
			{
				*pre_e = L->next->data;
				return OK;
			}
			return ERROR;
		}
	}
	return OVER_FLOW;
}

插入和删除

/*
@breaf  在线性表的第i个位置插入元素e
@param   L[in]线性表
@param   i[in]序列号
@param   e[in]插入的元素
@return  RESULT
*/
RESULT ListInsert(LNode *L, int i, ElemTpye e)
{
	int len = 0;
	LNode * p;
	while (L->next)
	{
		L = L->next;
		if (++len == i)
		{
			p = (LNode *)malloc(sizeof(LNode));
			p->data = e;
			if (!p)
				return MALL_ERR;
			p->next = L->next;
			L->next = p;
			return OK;
		}
	}
	return OVER_FLOW;
}
/*
@breaf   删除线性表L中的第i个元素，并用e返回其值
@param   L[in]线性表
@param   i[in]序列号
@param   e[out]删除的元素
@return  RESULT
*/
RESULT ListDelete(LNode *L, int  i, ElemTpye *e)
{
	int len = 0;
	LNode * p;
	while (L->next)
	{
		L = L->next;
		if (++len == i)
		{
			*e = L->next->data;
			p = L->next;
			L->next = L->next->next;
			free(p);
			return OK;
		}
	}
	return OVER_FLOW;
}

其他操作

/*
@breaf   依次对L的每个元素调用函数visit()，一旦失败则操作失败
@param   L[in]线性表
@param   visit[in]需要操作的函数指针
@return  RESULT
*/
RESULT ListTranverse(LNode * L, RESULT(*visit)(ElemTpye e))
{
	int len = 0;
	while (L->next)
	{
		len++;
		L = L->next;
		if (visit(L->data) != OK)
			return ERROR;
	}
	if (len)
		return OK;
	return EMPTY;
}