数据结构之双向链表

lxzlife

已于 2023-06-04 20:41:41 修改

阅读量97

点赞数

分类专栏：数据结构文章标签：数据结构链表 c语言 list

于 2022-05-08 20:08:52 首次发布

本文链接：https://blog.csdn.net/weixin_45050132/article/details/124653588

版权

数据结构专栏收录该内容

6 篇文章 0 订阅

订阅专栏

源码

1 Linklist2.h

// 双向链表
//头节点无数据域只有指针域

#ifndef _LINKLIST2_H

	#define _LINKLIST2_H
	
	#include <malloc.h>
	#include <stdio.h>

	struct LinkNode
	{
		void *pData;
		struct LinkNode *pFront;
		struct LinkNode *pNext;
	};

	struct LinkList
	{
		struct LinkNode head;
		int length;
	};

	//创建链表
	struct LinkList* CreatLinkList(void);

	//按位置往链表插入节点
	void InsertToLinlkListByPos(struct LinkList*pLinkList, int position, void* pData);

	//往链表头插入节点
	void InsertToLinkListHead(struct LinkList*pLinkList, void* pData);

	//往链表尾插入节点
	void InsertToLinkListTail(struct LinkList*pLinkList, void* pData);

	//顺序遍历链表
	void TraverseLinkListInOder(struct LinkList* pLinkList, void(*printCallback)(void*));

	//逆序遍历链表
	void TraverseLinkListAntiOder(struct LinkList* pLinkList, void(*printCallback)(void*));

	//按位置获取链表节点的数据指针
	void *GetDataPointerOfNodeInLinkListByPos(struct LinkList* pLinkList,int pos);

	//获取链表第一个节点的数据指针
	void *GetDataPointerOfFirstNodeInLinkList(struct LinkList* pLinkList);

	//获取链表最后一个节点的数据指针
	void *GetDataPointerOfLastNodeInLinkList(struct LinkList* pLinkList);

	//按位置删除链表的节点
	void DeleteNodeOFLinkListByPosition(struct LinkList* pLinkList, int position);

	//删除链表的第一个节点
	void DeleteFirstNodeOfLinkList(struct LinkList* pLinkList);

	//删除链表的最后一个节点
	void DeleteLastNodeOfLinkList(struct LinkList* pLinkList);

	//按数据指针删除链表内节点
	void DeleteNodeOFLinkListByValue(struct LinkList* pLinkList, void* data, int(*comparecallback)(void* data1, void* data2));

	//清空链表
	void ClearLinkList(struct LinkList* pLinkList);

	//摧毁链表
	void DestroyLinkList(struct LinkList* linklistpointer);

	//链表去重(删除数据域相同的节点)
	void QuCHongLiskList(struct LinkList*pLinkList,int(*CompareCallBack)(void*,void*));

	//链表逆序
	void ReverseLinkList(struct LinkList*pLinkList);

#endif

2 Linklist2.c

#include "Linklist2.h"

struct LinkList* CreatLinkList(void)
{
	struct LinkList *pLinkList;
	
	pLinkList = (struct LinkList*)malloc(sizeof(struct LinkList));
	
	if (pLinkList == NULL)
	{
		return(NULL);
	}
	
	pLinkList->head.pData = NULL;

	pLinkList->head.pFront = NULL;
	
	pLinkList->head.pNext = NULL;
	
	pLinkList->length = 0;
	
	return(pLinkList);
}

void InsertToLinlkListByPos(struct LinkList*pLinkList,int position,void*pData)
{
	if (pLinkList == NULL)
	{
		return;
	}
	if (pData == NULL)
	{
		return;
	}
	
	if (position < 0 || position > pLinkList->length)
	{
		return;
	}
	
	struct LinkNode* pFrontNode = &pLinkList->head;
	
	for (int i = 0; i < position; i ++)
	{
		pFrontNode = pFrontNode->pNext;
	}
	
	struct LinkNode* pNewNode = (struct LinkNode*)malloc(sizeof(struct LinkNode));
	pNewNode->pData = pData;
	pNewNode->pFront = NULL;
	pNewNode->pNext = NULL;
	
	if (pLinkList->length == 0)
	{
		pNewNode->pFront = &pLinkList->head;
		pLinkList->head.pNext = pNewNode;
	}
	else if (pLinkList->length > 0)
	{
		//尾部新插入
		if (position == pLinkList->length)
		{
			pNewNode->pFront = pFrontNode;
			pFrontNode->pNext = pNewNode;
		}
		//头部新插入
		else if (position == 0)
		{
			pNewNode->pNext = pLinkList->head.pNext;
			pLinkList->head.pNext->pFront = pNewNode;
			pLinkList->head.pNext = pNewNode;
			pNewNode->pFront = &pLinkList->head;
		}
		//中间新插入
		else if ((position > 0) && (position < pLinkList->length))
		{
			pNewNode->pNext = pFrontNode->pNext;
			pFrontNode->pNext->pFront = pNewNode;
			pFrontNode->pNext = pNewNode;
			pNewNode->pFront = pFrontNode;
		}
	}
	
	pLinkList->length++;
}

void InsertToLinkListHead(struct LinkList*pLinkList, void* pData)
{
	if (pLinkList == NULL)
	{
		return;
	}
	if (pData == NULL)
	{
		return;
	}
	InsertToLinlkListByPos(pLinkList,0,pData);
}

void InsertToLinkListTail(struct LinkList*pLinkList, void* pData)
{
	if (pLinkList == NULL)
	{
		return;
	}
	if (pData == NULL)
	{
		return;
	}
	InsertToLinlkListByPos(pLinkList,pLinkList->length,pData);
}

void TraverseLinkListInOder(struct LinkList*pLinkList,void(*printCallback)(void*))
{
	if (pLinkList == NULL)
	{
		return;
	}
	struct LinkNode* pCurNode = &pLinkList->head;
	for (int i = 0; i < pLinkList->length; i++)
	{
		pCurNode = pCurNode->pNext;
		printCallback(pCurNode->pData);
	}
}

//逆序遍历链表
void TraverseLinkListAntiOder(struct LinkList* pLinkList, void(*printCallback)(void*))
{
	if (pLinkList == NULL)
	{
		return;
	}
	struct LinkNode* pCurNode = &pLinkList->head;

	//定位到最后一个节点
	for (int i = 0; i < pLinkList->length; i++)
	{
		pCurNode = pCurNode->pNext;
	}

	//逆序打印
	for (int i = 0; i < pLinkList->length; i++)
	{
		printCallback(pCurNode->pData);
		pCurNode = pCurNode->pFront;
	}
}

void *GetDataPointerOfNodeInLinkListByPos(struct LinkList* pLinkList,int pos)
{
	if (pLinkList == NULL)
	{
		return(NULL);
	}
	if (pos < 0)
	{
		return(NULL);
	}
	if (pos >= pLinkList->length)
	{
		return(NULL);
	}
	struct LinkNode *pNode = &pLinkList->head;
	for (int i = 0; i <= pos; i ++)
	{
		pNode = pNode->pNext;
	}
	return(pNode->pData);
}

//获取链表第一个节点的数据指针
void *GetDataPointerOfFirstNodeInLinkList(struct LinkList* pLinkList)
{
	if (pLinkList == NULL)
	{
		return(NULL);
	}
	if (pLinkList->length < 1)
	{
		return(NULL);
	}
	void *pData;
	pData = GetDataPointerOfNodeInLinkListByPos(pLinkList,0);
	return(pData);
}

//获取链表最后一个节点的数据指针
void *GetDataPointerOfLastNodeInLinkList(struct LinkList* pLinkList)
{
	if (pLinkList == NULL)
	{
		return(NULL);
	}
	if (pLinkList->length < 1)
	{
		return(NULL);
	}
	void *pData;
	pData = GetDataPointerOfNodeInLinkListByPos(pLinkList,pLinkList->length - 1);
	return(pData);
}

void DeleteNodeOFLinkListByPosition(struct LinkList*pLinkList,int position)
{
	if (pLinkList == NULL)
	{
		return;
	}
	if (position < 0 || position >= pLinkList->length)
	{
		return;
	}
	
	struct LinkNode* pFrontNode;
	pFrontNode = &pLinkList->head;
	for (int i = 0; i < position; i++)
	{
		pFrontNode = pFrontNode->pNext;
	}
	
	struct LinkNode* pDeleteNode;
	pDeleteNode = pFrontNode->pNext;

	if (position < (pLinkList->length -1))
	{
		pFrontNode->pNext = pDeleteNode->pNext;
		pDeleteNode->pNext->pFront = pFrontNode;
	}

	free(pDeleteNode);
	
	pLinkList->length--;
}

void DeleteFirstNodeOfLinkList(struct LinkList* pLinkList)
{
	if (pLinkList == NULL)
	{
		return;
	}
	DeleteNodeOFLinkListByPosition(pLinkList,0);
}

void DeleteLastNodeOfLinkList(struct LinkList* pLinkList)
{
	if (pLinkList == NULL)
	{
		return;
	}
	DeleteNodeOFLinkListByPosition(pLinkList,pLinkList->length - 1);
}

void DeleteNodeOFLinkListByValue(struct LinkList* pLinkList, void* pDataIn, int(*comparecallback)(void* data1, void* data2))
{
	if (pLinkList == NULL)
	{
		return;
	}
	if (pDataIn == NULL)
	{
		return;
	}

	for (int i = 0; i < pLinkList->length; i ++)
	{
		void *pData;
		pData = GetDataPointerOfNodeInLinkListByPos(pLinkList,i);
		if (comparecallback(pData,pDataIn) == 0)
		{
			DeleteNodeOFLinkListByPosition(pLinkList,i);
			i --;
		}
	}
}

void ClearLinkList(struct LinkList* pLinkList)
{
	if (pLinkList == NULL)
	{
		return;
	}
	if (pLinkList->length < 1)
	{
		return;
	}
	int length = pLinkList->length;
	for (int i = 0; i < length; i++)
	{
		//用尾删函数删除链表节点
		DeleteLastNodeOfLinkList(pLinkList);
	}
}

void DestroyLinkList(struct LinkList* pLinkList)
{
	if (pLinkList == NULL)
	{
		return;
	}
	ClearLinkList(pLinkList);
	free(pLinkList);
}

void QuCHongLiskList(struct LinkList*pLinkList,int(*compareCallBack)(void*,void*))
{
	if (pLinkList == NULL)
	{
		return;
	}

	int length = pLinkList->length;
	if (length < 2)
	{
		return;
	}

	if (compareCallBack == NULL)
	{
		return;
	}

	void **ppData = (void **)malloc(sizeof(void *) * length);
	int sameCount = 0;

	void *pDataI;
	void *pDataJ;
	
	for (int i = 0; i < pLinkList->length; i ++)
	{
		pDataI = GetDataPointerOfNodeInLinkListByPos(pLinkList,i);
		for (int j = i + 1; j < pLinkList->length; j ++)
		{
			pDataJ = GetDataPointerOfNodeInLinkListByPos(pLinkList,j);
			if (compareCallBack(pDataI,pDataJ) == 0)
			{
				*(ppData + sameCount) = pDataJ;
				sameCount ++;
			}
		}
	}

	for (int i = 0; i < sameCount; i ++)
	{
		DeleteNodeOFLinkListByValue(pLinkList,*(ppData + i),compareCallBack);
	}

	free(ppData);
}

void ReverseLinkList(struct LinkList*pLinkList)
{
	//思路：顺序删除，逆序插入
	if (pLinkList == NULL)
	{
		return;
	}

	if (pLinkList->length < 2)
	{
		return;
	}

	int num = pLinkList->length;
	void **ppData = (void *)malloc(sizeof(void *) * num);

	for (int i = 0; i < num; i ++)
	{
		*(ppData + i) = GetDataPointerOfNodeInLinkListByPos(pLinkList,i);
	}

	for (int i = 0; i < num; i ++)
	{
		DeleteLastNodeOfLinkList(pLinkList);
	}

	for (int i = 0; i < num; i ++)
	{
		InsertToLinkListTail(pLinkList,*(ppData + num - i - 1));
	}
}

3 main.c(测试用)

#include "Linklist2.h"
#include <string.h>

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

void PrintCallback(void* data)
{
	struct person* Person_Pointer;
	Person_Pointer = (struct person*)data;
	printf("name:%s,age:%d\n", Person_Pointer->name, Person_Pointer->age);
}

int CompareCallback(void* data1, void* data2)
{
	struct person* p1, * p2;
	p1 = (struct person*)data1;
	p2 = (struct person*)data2;
	if (p1->age == p2->age)
	{
		if (strcmp(p1->name, p2->name) == 0)
		{
			return(0);
		}
		else
		{
			return(1);
		}
	}
	else
	{
		return(1);
	}
}

//插入及正逆序遍历测试
void Test0(void)
{
	struct LinkList* pLinkList;
	
	pLinkList=CreatLinkList();
	
	struct person team[] = { "qqq",20,"www",19,"eee",18,"rrr",17,"qqq",20 };
	
	for (int i = 0; i < 5; i ++)
	{
		InsertToLinlkListByPos(pLinkList,i,&team[i]);
	}

	printf("in order below:\n");

	TraverseLinkListInOder(pLinkList,PrintCallback);

	printf("anti order below:\n");

	TraverseLinkListAntiOder(pLinkList,PrintCallback);

	struct person p = {"sss",20};

	InsertToLinlkListByPos(pLinkList,0,&p);

	InsertToLinlkListByPos(pLinkList,3,&p);

	printf("in order below:\n");

	TraverseLinkListInOder(pLinkList,PrintCallback);

}

void Test1(void)
{
	struct LinkList* pLinkList;
	
	pLinkList=CreatLinkList();
	
	struct person team[] = { "qqq",20,"www",19,"eee",18,"rrr",17,"qqq",20 };
	
	for (int i = 0; i < 5; i ++)
	{
		InsertToLinlkListByPos(pLinkList,i,&team[i]);
	}

	DeleteNodeOFLinkListByPosition(pLinkList,3);

	printf("delete postion = 3\n");

	TraverseLinkListInOder(pLinkList,PrintCallback);

	DeleteNodeOFLinkListByPosition(pLinkList,0);

	printf("delete postion = first\n");

	TraverseLinkListInOder(pLinkList,PrintCallback);

	DeleteNodeOFLinkListByPosition(pLinkList,pLinkList->length - 1);

	printf("delete postion = last\n");

	TraverseLinkListInOder(pLinkList,PrintCallback);
}

void Test2(void)
{
	struct LinkList* pLinkList;
	
	pLinkList=CreatLinkList();
	
	struct person team[] = { "qqq",20,"www",19,"eee",18,"rrr",17,"qqq",20 };
	
	for (int i = 0; i < 5; i ++)
	{
		InsertToLinlkListByPos(pLinkList,i,&team[i]);
	}

	QuCHongLiskList(pLinkList,CompareCallback);

	TraverseLinkListInOder(pLinkList,PrintCallback);

}

void Test3(void)
{
	struct LinkList* pLinkList;
	
	pLinkList=CreatLinkList();
	
	struct person team[] = { "qqq",20,"www",19,"eee",18,"rrr",17,"ttt",16 };
	
	for (int i = 0; i < 5; i ++)
	{
		InsertToLinlkListByPos(pLinkList,i,&team[i]);
	}

	ReverseLinkList(pLinkList);

	TraverseLinkListInOder(pLinkList,PrintCallback);
}


int main()
{
	Test3();

	return (0);
}