单向链表的删除、清空、销毁及长度返回的实现【加强版】

单向链表的删除、清空、销毁及长度返回的实现【加强版】

节点结构体的定义如下

struct LinkNode{
	void *data;
	struct LinkNode *next;
};

链表结构体的定义如下

struct LList{
	struct LinkNode pHeader;
	int m_size;
};

泛型指针的重定义如下

typedef void * LinkList;

1.单向链表的节点删除实现 1.1按位置删除

• 函数设计为void removeByPosLinkList(LinkList list,int pos);
• 参数1list为泛型链表，需要还原
• 参数2pos为待删除的节点序号
• 删除指定位置的节点前，需找到该节点的前驱节点（序号为pos-1的节点）
• 删除节点成功后，记得及时更新链表的长度

void removeByPosLinkList(LinkList list,int pos)
{
	if(list == NULL || pos < 0)
		return;
		
	struct LList *myList = list;
	if(pos > myList->m_size - 1)
		return;

	strcut LinkNode *pCurrentNode = &myList->pHeader;
	for(int i = 0; i < pos; i++)//
		pCurrentNode = pCurrentNode->next;

	struct LinkNode *pDelNode = pCurrentNode->next;//记录待删除节点
	pCurrentNode->next = pDelNode->next;//重新建立关系，断开pDelNode指向的节点
	free(pDelNode);//释放内存空间.
	pDelNode = NULL;
	
	//更新下链表的长度
	myList->m_size--;
	
}

1.2按值删除

• 函数设计为void removeByValueLinkList(LinkList list,void *data,int(*myCompare)(void*,void*));
• 参数1list为泛型链表
• 参数2data为泛型数据，可接收用户任何类型的数据
• 参数3myCompare为函数指针，用于接收用户的回调函数

void removeByValueLinkList(LinkList list,void *data,int(*myCompare)(void*,void*))
{
	if(list == NULL || data == NULL)
		return;
	
	struct LList *myList = list;
	
	struct LinkNode *pCurrentNode = &myList->pHeader;
	struct LinkNode *pPreviousNode = NULL;
	for(int i = 0; i < myList->m_size; i++)
	{
		pPreviousNode = pCurrentNode;
		pCurrentNode = pCurrentNode->next;
		if(myCompare(pCurrentNode->data,data))
		{
			pPreviousNode->next = pCurrentNode->next;
			free(pCurrentNode);
			pCurrentNode = NULL;

			myList->m_size--;//更新链表的长度
			break;
		}
	}
}

回调函数的设计：

struct Person{
	char name[64];
	int age;
};

int myComparePerson(void *data1,void *data2)
{
	struct Person *p1 = data1;
	struct Person *p2 = data2;

	if(strcmp(p1->name,p2->name) == 0 && p1->age == p2->age)
		return 1;
	else
		return 0;
}

2.单向链表的节点清空实现

• 函数设计为clearLinkList(LinkList list)
• list为泛型，需还原
• 循环遍历到每个节点，free每个节点前还需用一个辅助节点指针指向待删除节点的后继节点

void clearLinkList(LinkList list)
{
	if(list == NULL)
		return;
	struct LList *myList = list;
	struct LinkNode *pCurrentNode = &myList->pHeader;
	struct LinkNode *pNextNode = NULL;

	for(int i = 0; i < myList->m_size; i++)
	{
		pCurrentNode = pCurrentNode->next;//
		pNextNode = pCurrent->next;//后继节点
		free(pCurrentNode);
		pCurrentNode = pNextNode;
	}

	myList->next = NULL;
	myList->m_size = 0;
}

3.单向链表的销毁实现

• 函数设计为void destoryLinkList(LinkList list);
• 链表的销毁是在清空链表的基础上释放头节点的内存空间
• 参数1list，泛型，这里不需要还原，因为free函数的形参也是泛型void *

void destoryLinkList(LinkList list)
{
	if(list == NULL)
		return;
	clearLinkList(list);
	free(list);
	list = NULL;
}

4.单向链表的长度返回实现

• 函数设计为int sizeLinkList(LinkList list);
• 为了访问m_size，需将泛型list还原

int sizeLinkList(LinkList list)
{
	if(list == NULL)
		return;
		
	struct LList *myList = list;
	return myList->m_size;	
}