双向链表

最新推荐文章于 2023-03-11 12:19:57 发布
最新推荐文章于 2023-03-11 12:19:57 发布
阅读量2.8k 收藏 1
点赞数 3
分类专栏： 数据结构 文章标签： C语言 链表 数据结构 双向链表
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/AlbertoNo1/article/details/51234019
版权

双向链表介绍

       双向链表，如同其名所暗示的那样，链表元素之间由两个指针链接。双向链表中的每一个元素都由3部分组成：除了数据域成员和next指针外，每个元素还包含一个指向其前驱元素的指针，称为prev指针。双向链表的组成是这样的：将一些元素链接在一起使得每个元素的next指针都指向其后继的元素，而每个元素的prev指针都指向其前驱元素。为了标识链表的头和尾，将第一个元素的prev指针和最后一个元素的next指针设置为NULL。

       待补图


双向链表的实现

// DList.cpp : Defines the entry point for the console application.
//

#include "stdafx.h"
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <malloc.h>


/*双链表元素结构体定义*/
typedef struct  DListElmt_
{
	unsigned int uiValueA;   /*数据域 数据成员*/
	unsigned int *puiValueB; /*数据域 数据成员，需要动态申请内存*/

	struct DListElmt_ *pNext;  /*指针域 指向后一个元素结点的指针*/
	struct DListElmt_ *pPrev;  /*指针域 指向前一个元素结点的指针*/

}DListElmt;

/*双链表结构体定义*/
typedef struct DList_
{
	int  iSize;   /*链表大小*/

	void (*destory)(void *data);  /*用于释放元素结点内动态申请的内存*/
	int (*compare)(void *key1, void *key2); /*比较函数 返回值 0 相等 1 大于 -1 小于*/

	DListElmt  *pDListElmtHead;  /*指向链表头结点的指针*/
	DListElmt  *pDListElmtTail;  /*指向链表尾结点的指针*/

}DList;

/*单链表操作宏定义*/
#define DLIST_SIZE(list)   ((list)->iSize)
#define DLIST_HEAD(list)   ((list)->pDListElmtHead)
#define DLIST_TAIL(list)   ((list)->pDListElmtTail)
#define DLIST_IS_HEAD(list, element) (((element) == (list)->pDListElmtHead) ? 1:0)
#define DLIST_IS_TAIL(list, element) (((element) == (list)->pDListElmtTail) ? 1:0)

/*函数声明*/
void MemoryFree(void *data);
int DataCompare(void *key1, void *key2);
void DList_Init(DList *dlist, void (*destory)(void *data), int (*compare)(void *key1, void *key2));
int DList_Insert_Next(DList *dlist, DListElmt *Lelement, unsigned int uiDataA, unsigned int *puiDataB);
int DList_Insert_Prev(DList *dlist, DListElmt *Lelement, unsigned int uiDataA, unsigned int *puiDataB);
int DList_Remove(DList *dlist, DListElmt *Lelement, unsigned int *puiDataA, unsigned int **puiDataB);
void DList_Sort(DList *dlist);
void DList_Swap(DListElmt *LelementKey1, DListElmt *LelementKey2);
void DList_Destory(DList *dlist);

/*
*函数名：MemoryFree
*参数：data  待释放的内存
*功能：释放动态申请的内存
*返回值：无
*作者：AlbertoNo1
*日期：2016-04-20
*/
void MemoryFree(void *data)
{
	free(data);
}

/*
*函数名：DataCompare
*参数：key1  待比较的元素1
*      key2  待比较的元素2
*功能：比较两个元素的大小（无符号整型）
*返回值：0 key1 等于 key2  1 key1 大于 key2  -1 key1 小于 key2 
*作者：AlbertoNo1
*日期：2016-04-20
*/
int DataCompare(void *key1, void *key2)
{
	unsigned int uiKey1 = 0;
	unsigned int uiKey2 = 0;

	uiKey1 = *((unsigned int*)key1);
	uiKey2 = *((unsigned int*)key2);

	if (uiKey1 < uiKey2)
	{
		return -1;
	}
	else if (uiKey1 > uiKey2)
	{
		return 1;
	}
	else
	{
		return 0;
	}
}

/*
*函数名：DList_Init
*参数：dlist  待初始化的链表
*      destory  数据域动态内存释放函数
*      compare  比较函数
*功能：双链表初始化函数
*返回值：无 
*作者：AlbertoNo1
*日期：2016-04-20
*/
void DList_Init(DList *dlist, void (*destory)(void *data), int (*compare)(void *key1, void *key2))
{
	dlist->iSize = 0;

	dlist->destory = destory;
	dlist->compare = compare;

	dlist->pDListElmtHead = NULL;
	dlist->pDListElmtTail = NULL;
}

/*
*函数名：DList_Insert_Next
*参数：dlist  链表
*      Lelment  待插入元素的前一个元素指针
*      uiDataA  数据成员值
*      puiDataB 数据成员值（动态申请内存）
*功能：双链表插入元素函数（指定元素之后）
*返回值：0 成功 -1 失败 
*作者：AlbertoNo1
*日期：2016-04-20
*/
int DList_Insert_Next(DList *dlist, DListElmt *Lelement, unsigned int uiDataA, unsigned int *puiDataB)
{
	DListElmt  *pElment = NULL;

	/*入参合法值由调用者保证*/

	/*申请内存*/
	pElment = (DListElmt*)malloc(sizeof(DListElmt));
	if (NULL == pElment)
	{
		return -1;
	}

	/*数据域赋值*/
	pElment->uiValueA = uiDataA;
	pElment->puiValueB = puiDataB;

	if (0 == DLIST_SIZE(dlist))
	{/*空链表插入元素*/
		pElment->pNext = NULL;
		pElment->pPrev = NULL;

		/*更新链表头尾结点指针*/
		dlist->pDListElmtHead = pElment;
		dlist->pDListElmtTail = pElment;
	}
	else
	{
		if (NULL == Lelement)
		{/*插入链表头*/
			pElment->pNext = dlist->pDListElmtHead;
			pElment->pPrev = NULL;

			dlist->pDListElmtHead->pPrev = pElment;
			dlist->pDListElmtHead = pElment;
		}
		else if (DLIST_IS_TAIL(dlist, Lelement))
		{/*插入链表尾*/
			pElment->pNext = NULL;
			pElment->pPrev = dlist->pDListElmtTail;

			dlist->pDListElmtTail->pNext = pElment;
			dlist->pDListElmtTail = pElment;
		}
		else
		{
			Lelement->pNext->pPrev = pElment;

			pElment->pNext = Lelement->pNext;
			pElment->pPrev = Lelement;

			Lelement->pNext = pElment;
		}
	}

	dlist->iSize++;

	return 0;
}

/*
*函数名：DList_Insert_Prev
*参数：dlist  链表
*      Lelment  待插入元素的后一个元素指针
*      uiDataA  数据成员值
*      puiDataB 数据成员值（动态申请内存）
*功能：双链表插入元素函数（指定元素之前）
*返回值：0 成功 -1 失败 
*作者：AlbertoNo1
*日期：2016-04-20
*/
int DList_Insert_Prev(DList *dlist, DListElmt *Lelement, unsigned int uiDataA, unsigned int *puiDataB)
{
	DListElmt  *pElment = NULL;

	/*入参合法值由调用者保证*/

	/*申请内存*/
	pElment = (DListElmt*)malloc(sizeof(DListElmt));
	if (NULL == pElment)
	{
		return -1;
	}

	/*数据域赋值*/
	pElment->uiValueA = uiDataA;
	pElment->puiValueB = puiDataB;

	if (0 == DLIST_SIZE(dlist))
	{/*空链表插入元素*/
		pElment->pNext = NULL;
		pElment->pPrev = NULL;

		/*更新链表头尾结点指针*/
		dlist->pDListElmtHead = pElment;
		dlist->pDListElmtTail = pElment;
	}
	else
	{
		if (NULL == Lelement)
		{/*插入链表尾*/
			pElment->pNext = NULL;
			pElment->pPrev = dlist->pDListElmtTail;

			dlist->pDListElmtTail->pNext = pElment;
			dlist->pDListElmtTail = pElment;
		}
		else if (DLIST_IS_HEAD(dlist, Lelement))
		{/*插入链表头*/
			pElment->pNext = dlist->pDListElmtHead;
			pElment->pPrev = NULL;

			dlist->pDListElmtHead->pPrev = pElment;
			dlist->pDListElmtHead = pElment;
		}
		else
		{
			Lelement->pPrev->pNext = pElment;

			pElment->pPrev = Lelement->pPrev;
			pElment->pNext = Lelement;

			Lelement->pPrev = pElment;
		}
	}

	dlist->iSize++;

	return 0;
}


/*
*函数名：DList_Remove
*参数：dlist  链表
*      Lelment  待删除元素的指针
*      puiDataA  返回数据成员值
*      puiDataB 返回数据成员值（动态申请内存）
*功能：双链表删除指定的元素
*返回值：0 成功 -1 失败 
*作者：AlbertoNo1
*日期：2016-04-20
*/
int DList_Remove(DList *dlist, DListElmt *Lelement, unsigned int *puiDataA, unsigned int **puiDataB)
{
	if (0 == DLIST_SIZE(dlist) || (NULL == Lelement))
	{
		return -1;
	}

	*puiDataA = Lelement->uiValueA;
	*puiDataB = Lelement->puiValueB;

	if (DLIST_IS_HEAD(dlist, Lelement))
	{
		dlist->pDListElmtHead = dlist->pDListElmtHead->pNext;

		if (1 == DLIST_SIZE(dlist))
		{/*最后一个元素*/
			dlist->pDListElmtHead = NULL;
			dlist->pDListElmtTail = NULL;
		}
		else
		{
			dlist->pDListElmtHead->pPrev = NULL;
		}

	}
	else if (DLIST_IS_TAIL(dlist, Lelement))
	{
		dlist->pDListElmtTail = dlist->pDListElmtTail->pPrev;

		if (1 == DLIST_SIZE(dlist))
		{/*最后一个元素*/
			dlist->pDListElmtHead = NULL;
			dlist->pDListElmtTail = NULL;
		}
		else
		{
			dlist->pDListElmtTail->pNext = NULL;
		}
	}
	else
	{
		Lelement->pNext->pPrev = Lelement->pPrev;
		Lelement->pPrev->pNext = Lelement->pNext;
	}

	free(Lelement);

	dlist->iSize--;

	return 0 ;
}

/*
*函数名：DList_Sort
*参数：dlist 链表
*功能：双链表排序
*返回值：无 
*作者：AlbertoNo1
*日期：2016-04-20
*/
void DList_Sort(DList *dlist)
{
	DListElmt  *pElmentPos = NULL;
	DListElmt  *pElmentA = NULL;
	DListElmt  *pElmentB = NULL;

	if (0 == DLIST_SIZE(dlist))
	{
		return ;
	}

	for (pElmentA = dlist->pDListElmtHead; NULL != pElmentA; pElmentA = pElmentA->pNext)
	{
		pElmentPos = pElmentA;

		for (pElmentB = pElmentA->pNext; NULL != pElmentB; pElmentB = pElmentB->pNext)
		{
			if (dlist->compare(&(pElmentB->uiValueA), &(pElmentPos->uiValueA)) < 0)
			{
				pElmentPos = pElmentB;
			}
		}

		if (pElmentPos != pElmentA)
		{
			DList_Swap(pElmentPos, pElmentA);
		}
	}
}

/*
*函数名：DList_Swap
*参数：dlist  链表
*功能：双链表交换两个结点的数据域
*返回值：无 
*作者：AlbertoNo1
*日期：2016-04-20
*/
void DList_Swap(DListElmt *LelementKey1, DListElmt *LelementKey2)
{
	unsigned int uiValueA = 0;   
	unsigned int *puiValueB = NULL; 

	uiValueA = LelementKey1->uiValueA;
	puiValueB = LelementKey1->puiValueB;

	LelementKey1->uiValueA = LelementKey2->uiValueA;
	LelementKey1->puiValueB = LelementKey2->puiValueB;

	LelementKey2->uiValueA = uiValueA;
	LelementKey2->puiValueB = puiValueB;
}


/*
*函数名：DList_Destory
*参数：dlist 链表
*功能：双链表销毁函数
*返回值：无 
*作者：AlbertoNo1
*日期：2016-04-20
*/
void DList_Destory(DList *dlist)
{
	unsigned int uiDataA = 0;
	unsigned int *puiDataB = NULL;

	while (DLIST_SIZE(dlist) > 0)
	{
		if ((0 == DList_Remove(dlist, DLIST_HEAD(dlist), &uiDataA, &puiDataB))&&(NULL != dlist->destory))
		{
			dlist->destory(puiDataB);
		}
	}
}

/*空链表插入*/
void test_func1(DList *dlist)
{
	int iRet = 0;

	unsigned int uiDataA = 0;
	unsigned int *puiDataB = NULL;

	DListElmt *element = NULL;

	/*测试*/
	uiDataA = 11;
	puiDataB = (unsigned int*)malloc(sizeof(unsigned int));
	if (NULL == puiDataB)
	{
		return;
	}

	*puiDataB = 99;

	iRet = DList_Insert_Next(dlist, NULL, uiDataA, puiDataB);
	if (-1 == iRet)
	{
		return;
	}

	printf("预期结果\n");
	printf("数据：11 99 \n");
	printf("链表大小：1 \n");

	printf("\n实际结果1（顺序）\n");
	printf("数据：");

	for(element = DLIST_HEAD(dlist); NULL != element; element = element->pNext)
	{
		printf("%u %u ", element->uiValueA, *(element->puiValueB));
	}

	printf("\n链表大小：%d \n", DLIST_SIZE(dlist));

	printf("\n实际结果2（逆序）\n");
	printf("数据：");

	for(element = DLIST_TAIL(dlist); NULL != element; element = element->pPrev)
	{
		printf("%u %u ", element->uiValueA, *(element->puiValueB));
	}

	printf("\n链表大小：%d \n", DLIST_SIZE(dlist));

}

/*非空链表插入头结点*/
void test_func2(DList *dlist)
{
	int iRet = 0;

	unsigned int uiDataA = 0;
	unsigned int *puiDataB = NULL;

	DListElmt *element = NULL;

	/*测试*/
	uiDataA = 12;
	puiDataB = (unsigned int*)malloc(sizeof(unsigned int));
	if (NULL == puiDataB)
	{
		return;
	}

	*puiDataB = 98;

	iRet = DList_Insert_Next(dlist, NULL, uiDataA, puiDataB);
	if (-1 == iRet)
	{
		return;
	}

	printf("预期结果\n");
	printf("数据：12 98 11 99 \n");
	printf("链表大小：2 \n");

	printf("\n实际结果1（顺序）\n");
	printf("数据：");

	for(element = DLIST_HEAD(dlist); NULL != element; element = element->pNext)
	{
		printf("%u %u ", element->uiValueA, *(element->puiValueB));
	}

	printf("\n链表大小：%d \n", DLIST_SIZE(dlist));

	printf("\n实际结果2（逆序）\n");
	printf("数据：");

	for(element = DLIST_TAIL(dlist); NULL != element; element = element->pPrev)
	{
		printf("%u %u ", element->uiValueA, *(element->puiValueB));
	}

	printf("\n链表大小：%d \n", DLIST_SIZE(dlist));

}

/*非空链表插入尾结点*/
void test_func3(DList *dlist)
{
	int iRet = 0;

	unsigned int uiDataA = 0;
	unsigned int *puiDataB = NULL;

	DListElmt *element = NULL;

	/*测试*/
	uiDataA = 13;
	puiDataB = (unsigned int*)malloc(sizeof(unsigned int));
	if (NULL == puiDataB)
	{
		return;
	}

	*puiDataB = 97;

	iRet = DList_Insert_Next(dlist, DLIST_TAIL(dlist), uiDataA, puiDataB);
	if (-1 == iRet)
	{
		return;
	}

	printf("预期结果\n");
	printf("数据：12 98 11 99 13 97\n");
	printf("链表大小：3 \n");

	printf("\n实际结果1（顺序）\n");
	printf("数据：");

	for(element = DLIST_HEAD(dlist); NULL != element; element = element->pNext)
	{
		printf("%u %u ", element->uiValueA, *(element->puiValueB));
	}

	printf("\n链表大小：%d \n", DLIST_SIZE(dlist));

	printf("\n实际结果2（逆序）\n");
	printf("数据：");

	for(element = DLIST_TAIL(dlist); NULL != element; element = element->pPrev)
	{
		printf("%u %u ", element->uiValueA, *(element->puiValueB));
	}

	printf("\n链表大小：%d \n", DLIST_SIZE(dlist));

}

/*非空链表插入非头尾结点*/
void test_func4(DList *dlist)
{
	int iRet = 0;

	unsigned int uiDataA = 0;
	unsigned int *puiDataB = NULL;

	DListElmt *element = NULL;

	/*测试*/
	uiDataA = 14;
	puiDataB = (unsigned int*)malloc(sizeof(unsigned int));
	if (NULL == puiDataB)
	{
		return;
	}

	*puiDataB = 96;

	iRet = DList_Insert_Next(dlist, dlist->pDListElmtHead->pNext, uiDataA, puiDataB);
	if (-1 == iRet)
	{
		return;
	}

	printf("预期结果\n");
	printf("数据：12 98 11 99 14 96 13 97\n");
	printf("链表大小：4 \n");

	printf("\n实际结果1（顺序）\n");
	printf("数据：");

	for(element = DLIST_HEAD(dlist); NULL != element; element = element->pNext)
	{
		printf("%u %u ", element->uiValueA, *(element->puiValueB));
	}

	printf("\n链表大小：%d \n", DLIST_SIZE(dlist));

	printf("\n实际结果2（逆序）\n");
	printf("数据：");

	for(element = DLIST_TAIL(dlist); NULL != element; element = element->pPrev)
	{
		printf("%u %u ", element->uiValueA, *(element->puiValueB));
	}

	printf("\n链表大小：%d \n", DLIST_SIZE(dlist));

}

/*空链表插入*/
void test_func5(DList *dlist)
{
	int iRet = 0;

	unsigned int uiDataA = 0;
	unsigned int *puiDataB = NULL;

	DListElmt *element = NULL;

	/*测试*/
	uiDataA = 11;
	puiDataB = (unsigned int*)malloc(sizeof(unsigned int));
	if (NULL == puiDataB)
	{
		return;
	}

	*puiDataB = 99;

	iRet = DList_Insert_Prev(dlist, NULL, uiDataA, puiDataB);
	if (-1 == iRet)
	{
		return;
	}

	printf("预期结果\n");
	printf("数据：11 99 \n");
	printf("链表大小：1 \n");

	printf("\n实际结果1（顺序）\n");
	printf("数据：");

	for(element = DLIST_HEAD(dlist); NULL != element; element = element->pNext)
	{
		printf("%u %u ", element->uiValueA, *(element->puiValueB));
	}

	printf("\n链表大小：%d \n", DLIST_SIZE(dlist));

	printf("\n实际结果2（逆序）\n");
	printf("数据：");

	for(element = DLIST_TAIL(dlist); NULL != element; element = element->pPrev)
	{
		printf("%u %u ", element->uiValueA, *(element->puiValueB));
	}

	printf("\n链表大小：%d \n", DLIST_SIZE(dlist));

}

/*非空链表插入头结点*/
void test_func6(DList *dlist)
{
	int iRet = 0;

	unsigned int uiDataA = 0;
	unsigned int *puiDataB = NULL;

	DListElmt *element = NULL;

	/*测试*/
	uiDataA = 12;
	puiDataB = (unsigned int*)malloc(sizeof(unsigned int));
	if (NULL == puiDataB)
	{
		return;
	}

	*puiDataB = 98;

	iRet = DList_Insert_Prev(dlist, DLIST_HEAD(dlist), uiDataA, puiDataB);
	if (-1 == iRet)
	{
		return;
	}

	printf("预期结果\n");
	printf("数据：12 98 11 99 \n");
	printf("链表大小：2 \n");

	printf("\n实际结果1（顺序）\n");
	printf("数据：");

	for(element = DLIST_HEAD(dlist); NULL != element; element = element->pNext)
	{
		printf("%u %u ", element->uiValueA, *(element->puiValueB));
	}

	printf("\n链表大小：%d \n", DLIST_SIZE(dlist));

	printf("\n实际结果2（逆序）\n");
	printf("数据：");

	for(element = DLIST_TAIL(dlist); NULL != element; element = element->pPrev)
	{
		printf("%u %u ", element->uiValueA, *(element->puiValueB));
	}

	printf("\n链表大小：%d \n", DLIST_SIZE(dlist));

}

/*非空链表插入尾结点*/
void test_func7(DList *dlist)
{
	int iRet = 0;

	unsigned int uiDataA = 0;
	unsigned int *puiDataB = NULL;

	DListElmt *element = NULL;

	/*测试*/
	uiDataA = 13;
	puiDataB = (unsigned int*)malloc(sizeof(unsigned int));
	if (NULL == puiDataB)
	{
		return;
	}

	*puiDataB = 97;

	iRet = DList_Insert_Prev(dlist, NULL, uiDataA, puiDataB);
	if (-1 == iRet)
	{
		return;
	}

	printf("预期结果\n");
	printf("数据：12 98 11 99 13 97\n");
	printf("链表大小：3 \n");

	printf("\n实际结果1（顺序）\n");
	printf("数据：");

	for(element = DLIST_HEAD(dlist); NULL != element; element = element->pNext)
	{
		printf("%u %u ", element->uiValueA, *(element->puiValueB));
	}

	printf("\n链表大小：%d \n", DLIST_SIZE(dlist));

	printf("\n实际结果2（逆序）\n");
	printf("数据：");

	for(element = DLIST_TAIL(dlist); NULL != element; element = element->pPrev)
	{
		printf("%u %u ", element->uiValueA, *(element->puiValueB));
	}

	printf("\n链表大小：%d \n", DLIST_SIZE(dlist));

}

/*非空链表插入非头尾结点*/
void test_func8(DList *dlist)
{
	int iRet = 0;

	unsigned int uiDataA = 0;
	unsigned int *puiDataB = NULL;

	DListElmt *element = NULL;

	/*测试*/
	uiDataA = 14;
	puiDataB = (unsigned int*)malloc(sizeof(unsigned int));
	if (NULL == puiDataB)
	{
		return;
	}

	*puiDataB = 96;

	iRet = DList_Insert_Prev(dlist, dlist->pDListElmtHead->pNext, uiDataA, puiDataB);
	if (-1 == iRet)
	{
		return;
	}

	printf("预期结果\n");
	printf("数据：12 98 14 96 11 99 13 97\n");
	printf("链表大小：4 \n");

	printf("\n实际结果1（顺序）\n");
	printf("数据：");

	for(element = DLIST_HEAD(dlist); NULL != element; element = element->pNext)
	{
		printf("%u %u ", element->uiValueA, *(element->puiValueB));
	}

	printf("\n链表大小：%d \n", DLIST_SIZE(dlist));

	printf("\n实际结果2（逆序）\n");
	printf("数据：");

	for(element = DLIST_TAIL(dlist); NULL != element; element = element->pPrev)
	{
		printf("%u %u ", element->uiValueA, *(element->puiValueB));
	}

	printf("\n链表大小：%d \n", DLIST_SIZE(dlist));

}

/*销毁链表*/
void test_func9(DList *dlist)
{

	DListElmt *element = NULL;

	/*测试*/


	DList_Destory(dlist);

	printf("预期结果\n");
	printf("数据：\n");
	printf("链表大小：0 \n");

	printf("\n实际结果1（顺序）\n");
	printf("数据：");

	for(element = DLIST_HEAD(dlist); NULL != element; element = element->pNext)
	{
		printf("%u %u ", element->uiValueA, *(element->puiValueB));
	}

	printf("\n链表大小：%d \n", DLIST_SIZE(dlist));

	printf("\n实际结果2（逆序）\n");
	printf("数据：");

	for(element = DLIST_TAIL(dlist); NULL != element; element = element->pPrev)
	{
		printf("%u %u ", element->uiValueA, *(element->puiValueB));
	}

	printf("\n链表大小：%d \n", DLIST_SIZE(dlist));

}

/*删除链表指定元素*/
void test_func10(DList *dlist)
{
	int iRet = 0;

	unsigned int uiDataA = 0;
	unsigned int *puiDataB = NULL;

	DListElmt *element = NULL;

	/*测试*/

	iRet = DList_Remove(dlist, DLIST_TAIL(dlist), &uiDataA, &puiDataB);
	if (-1 == iRet)
	{
		return;
	}

	printf("预期结果\n");
	printf("数据：12 98 14 96 11 99 \n");
	printf("链表大小：3 \n");

	printf("\n实际结果1（顺序）\n");
	printf("数据：");

	for(element = DLIST_HEAD(dlist); NULL != element; element = element->pNext)
	{
		printf("%u %u ", element->uiValueA, *(element->puiValueB));
	}

	printf("\n链表大小：%d \n", DLIST_SIZE(dlist));

	printf("\n实际结果2（逆序）\n");
	printf("数据：");

	for(element = DLIST_TAIL(dlist); NULL != element; element = element->pPrev)
	{
		printf("%u %u ", element->uiValueA, *(element->puiValueB));
	}

	printf("\n链表大小：%d \n", DLIST_SIZE(dlist));

}

/*删除链表指定元素*/
void test_func11(DList *dlist)
{
	int iRet = 0;

	unsigned int uiDataA = 0;
	unsigned int *puiDataB = NULL;

	DListElmt *element = NULL;

	/*测试*/

	iRet = DList_Remove(dlist, dlist->pDListElmtHead->pNext, &uiDataA, &puiDataB);
	if (-1 == iRet)
	{
		return;
	}

	printf("预期结果\n");
	printf("数据：12 98 11 99 \n");
	printf("链表大小：2 \n");

	printf("\n实际结果1（顺序）\n");
	printf("数据：");

	for(element = DLIST_HEAD(dlist); NULL != element; element = element->pNext)
	{
		printf("%u %u ", element->uiValueA, *(element->puiValueB));
	}

	printf("\n链表大小：%d \n", DLIST_SIZE(dlist));

	printf("\n实际结果2（逆序）\n");
	printf("数据：");

	for(element = DLIST_TAIL(dlist); NULL != element; element = element->pPrev)
	{
		printf("%u %u ", element->uiValueA, *(element->puiValueB));
	}

	printf("\n链表大小：%d \n", DLIST_SIZE(dlist));

}

/*双链表排序*/
void test_func12(DList *dlist)
{
	int iRet = 0;

	DListElmt *element = NULL;

	/*测试*/
	DList_Sort(dlist);

	printf("预期结果\n");
	printf("数据：11 99 12 98 13 97 14 96\n");
	printf("链表大小：4 \n");

	printf("\n实际结果1（顺序）\n");
	printf("数据：");

	for(element = DLIST_HEAD(dlist); NULL != element; element = element->pNext)
	{
		printf("%u %u ", element->uiValueA, *(element->puiValueB));
	}

	printf("\n链表大小：%d \n", DLIST_SIZE(dlist));

	printf("\n实际结果2（逆序）\n");
	printf("数据：");

	for(element = DLIST_TAIL(dlist); NULL != element; element = element->pPrev)
	{
		printf("%u %u ", element->uiValueA, *(element->puiValueB));
	}

	printf("\n链表大小：%d \n", DLIST_SIZE(dlist));

}

int _tmain(int argc, _TCHAR* argv[])
{
	int iRet = 0;
	int iLoop = 0;

	DList stDList = {0};
	DListElmt *element = NULL;

	/*链表初始化*/
	DList_Init(&stDList, MemoryFree, DataCompare);

	/*测试1*/
	test_func5(&stDList);

	printf("\n\n");

	/*测试2*/
	test_func6(&stDList);

	printf("\n\n");

	/*测试3*/
	test_func7(&stDList);

	printf("\n\n");

	/*测试4*/
	test_func8(&stDList);

	printf("\n\n");

	test_func12(&stDList);

	//test_func9(&stDList);
	//test_func10(&stDList);

	//printf("\n\n");

	//test_func9(&stDList);
	//test_func11(&stDList);

	DList_Destory(&stDList);

	getchar();
	return 0;
}


AlbertoNo1
关注
  • 3
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
创建双向链表_双向链表_
09-30
通过建立双向链表，来实现双向查找，增加和删除的功能
双向链表(1) - 基本介绍以及插入节点
热门推荐
水草的专栏
06-13 1万+
双向链表(1) - 基本介绍以及插入节点
数据结构与算法--双向链表(Double Linked List)、单向环形链表(Circular Linked List)
ZZay's
01-22 1257
此文章仅作为自己学习过程中的记录和总结，同时会有意地去用英文来做笔记，一些术语的英译不太准确，内容如有错漏也请多指教，谢谢！ 一、双向链表-概述 -双向链表的基本组成结构： Node：自定义的结点结构。 (Node) head：指向单链表头结点的“头指针”。 -自定义结点的基本组成结构： 数据域：存放具有实际意义的数据。 “指针”域(next)：存放一个指向下一结点的“指针”。 “指针”域(pre)：存放一个指向上一结点的“指针”。【与单链表的区别】 -优点： 遍历方向：单链表只能朝向一个方向
用双向链表实现超长整数加减法
helena_wang的专栏
04-11 4601
学校数据结构的课程实验之一。 用到的数据结构：双向链表 主要功能：对由用户输入的两个任意长的整数进行加减运算
IDA学习笔记1
weixin_30596343的博客
07-11 452
打开IDA，拖拽一个EXE文件进去，首先会弹出如下窗口: Kernel option1、Kernel option2、Processor option这三个选项会控制反汇编引擎的工作状态，一般按默认即可，大多数情况下，分析选项的默认值在准确性和方便性之间提供一个折中参数，如果IDA分析出有问题的代码时，把Kernel option1中的选项Make final analysis pa...
数据结构 双向链表的应用之大整数运算
阴丹士林蓝的学习笔记
04-30 2168
/ 好叫你见识见识，什么叫做又臭又长的裹脚布代码，这篇帖子也是 / 文章目录题目思路定义类输入判断计算加法减法乘法除法符号判断输出完整代码小结推荐 题目 （大数运算） long long类型一般占8个字节是C/C++中的精度最高的整数类型，取值范围在 -9223372036854775808～+9223372036854775807。在很多场景中，整数范围超出了long long的最值，例如在非对...
数据结构——双向链表
麦麦的博客
03-11 1996
数据结构——双向链表：本文对双向链表的功能实现进行了详细地讲解，并与单链表的实现进行对比，干货满满，图文并茂，过万好文，不容错过！！！
双向链表C++
alanmian的博客
11-06 3340
双向链表，顾名思义，一条可双向进行的就叫双向链表。那怎么搞？也就是有前驱跟后继，有些时候有人不明白什么是前驱跟后继啊，浅显的讲讲，前驱就是当前结点指向上一个结点的箭头，那么上一个结点就是当前结点的前驱，后继就是当前结点的前一个结点，从上一个结点指向当前结点就叫后继，也就是说上个结点作为头，那当前结点作为尾，头的后继不就是尾嘛。 然后有头尾指针，双向嘛。头指针运动，尾指针也运动，所以这里要多存个尾指针。那说了这么多，先来构造给双向链表吧。 定义结构体老掉牙的东西了 思路！： 1.刚前面说了有前驱跟后继，那么
python实现双向链表
谁家的喵
04-27 3289
写一个双向链表，实现append,pop,insert,remove,__iter__，__getitem__功能。最后将链表改造为容器和带头链表
双向链表.cpp 双向链表类定义及测试代码 c++
12-02
双向链表类定义及测试文件 对应于数据机构与算法分析（c++版）第三版或第二版 Clifford A.Shaffer 重庆大学使用教材
C语言实现双向链表
09-03
本文给大家分享的是一段使用C语言实现双向链表的代码，完全是根据自己的理解和认识来编写的，希望大家能够喜欢，文章的最后附上了一个网友写的对于双向链表删除节点、插入节点、双向输出等操作的代码，也非常不错，...
双向链表及其基本操作
10-29
C语言，实现双向链表以及其基本操作，基本操作：链表初始化、创建、查询、删除、释放，查询和删除均有两种方式，一种是按照值，另一种是按照结点的序号。
C++实现双向链表
12-17
本文实例为大家分享了C++实现动态顺序表的具体代码，供大家参考，具体内容如下 List.h #pragma once #include #include #include using namespace std; typedef int DataType; struct ListNode ... :_data
双向链表代码
04-13
一个双向链表，可以进行添加元素，查找元素，删除元素，以及排序
简单的双向链表题目（可是T哭了！！）（这个题目给自己提个醒吧）
ACMerdsb的博客
10-27 493
答案： #include &lt;iostream&gt; #include &lt;bits/stdc++.h&gt; using namespace std; struct node {     char data;     struct node *last;     struct node *next; }; char str[1000005]; int main() {     i...
Python单向链表和双向链表原理与用法实例详解
09-20
主要介绍了Python单向链表和双向链表原理与用法,结合实例形式详细分析了单向链表与双向链表的概念、原理以及创建、添加、删除等相关操作技巧,需要的朋友可以参考下
双向链表实现结点类
04-11
定义、实现并测试一个双向链表结点类DNode。 链表结点类中包含私有数据成员为两个整数x，y以及左结点指针left及右结点指针right。 包含的函数成员包括： (a)对结点的数据成员赋值setDNodeValues(int,int,DNode* ...
双向链表 频度
03-26
数据结构课程中的双向链表 频度。亲测可用
ConcurrentHashMap 双向链表
最新发布
03-22
ConcurrentHashMap是Java中的一个线程安全的哈希表实现，它是HashMap的线程安全版本。它通过使用锁分段技术来实现高效的并发访问...在Java中，并没有直接提供双向链表的实现，但可以通过自定义类来实现双向链表的功能。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值