雙向鏈表

原創 AlbertoNo1 2018-08-27 16:00

雙向鏈表介紹

       雙向鏈表，如同其名所暗示的那樣，鏈表元素之間由兩個指針鏈接。雙向鏈表中的每一個元素都由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;
}


發表評論
所有評論
還沒有人評論，想成為第一個評論的人麼? 請在上方評論欄輸入並且點擊發布.
相關文章

這可能是最簡單的AVL二叉平衡查找樹講解

二叉平衡查找樹AVL詳解 看懂這篇文章所需的知識點 樹、二叉搜索樹、樹高、樹深、層等概念 AVL樹 概念：任意節點的左右子樹的高度差不能大於1的樹即爲AVL樹，是爲了解決在頻繁插入刪除等動態更新下出現的時間複雜度退化的問題，所以平

AD钙12138 2020-07-08 11:54:55

數據結構：AVL樹旋轉原理和簡易實現

AVL樹旋轉原理和簡易實現 二叉搜索樹雖然可以提高搜索效率，但是如果插入的數據有序時很有可能變成單支，如果變成單支樹的時候，那麼查找時效率也不高了。因此引入AVL樹。 AVL樹是當向這棵樹插入節點的時候，要保證每個節點的左右子樹的

ETalien_ 2020-07-08 12:19:01

數據結構：紅黑樹的旋轉原理和模擬實現

紅黑樹的旋轉原理和模擬實現 我們瞭解到AVL樹雖然效率很高，但是它是通過多次的旋轉纔到達一個絕對的平衡，旋轉的消耗其實也很大。因此開始引入近似平衡的一棵樹----紅黑樹（RBTree）。紅黑樹每一個節點不是紅色的就是黑色的，它保證

ETalien_ 2020-07-08 12:19:01

數據結構：大數據處理問題

1.給定100億個整數，設計算法找到只出現一次的整數？ ①方法一 100億個整數就是400億個字節，42億九千萬是4G，那麼1G就是10億字節，所以要存下100億個整數需要40G的內存空間。因此我們採用位圖100億個整數大概就是1

ETalien_ 2020-07-08 12:19:01

數據結構：布隆過濾器

布隆過濾器 假如現在有40億個ip地址（string類型），然後給你一個ip地址，讓你查找這個ip地址在不在這40億個ip地址裏？我們應該怎麼做呢？ 如果用哈希表來處理的話，這裏有40億的數據，數據量太大，因此太佔用空間 如果用

ETalien_ 2020-07-08 12:19:01

樹上剖分

————————————————18.4.18更新有時我們會遇到這樣的問題：在一棵樹上，每次詢問兩點間路徑上的和或者是最值。但我們用搜索時，時間就會到O（n），這樣根本就完不成算法。但樹上剖分就可以縮短修改的時間。樹上剖分的算法簡介我們定

蒟蒻午时已到 2020-07-08 11:59:23

2.7 封裝Request

  request作爲前後臺交換的橋樑，有重要作用。  request常用的方法有讀參數：public String getParameter(String paramName);讀取屬性public Object getAttribut

lws0888 2020-07-08 11:48:30

樹的總結（二）---非空二叉樹的高度和寬度

1.非空二叉樹的高度      1.1非遞歸算法實現求解非空二叉樹的高度  算法思想：採用層次遍歷的算法，設置變量level記錄當前結點所在的層數，設置變量last指向當前層的最右的結點，每次層次遍歷出隊的時候與last指針比較（fron

瞿颖Blog 2020-07-08 11:41:54

樹的總結（一）

考研加油！！！！！！！ 1.1樹的重要概念 1.樹是一種重要的非線性結構；在有n個結點的樹中有n-1條邊； 2.在結點個數爲n(n>1)的各棵樹中，深度最小的樹的深度是多少？它有多少葉子結點？多少分支結點？深度最大的樹的深度是多少？它有多

瞿颖Blog 2020-07-08 11:41:54

【劍指offer】題61：二叉樹序列化、反序列化

使用stringstream http://blog.csdn.net/xw20084898/article/details/21939811 stringstream 是 C++ 提供的另一個字串型的串流(stream)

xiaxzhou 2020-07-08 11:22:52

基本數據結構——線性結構（棧）

1.什麼是線性結構 線性結構是一種有序數據項的集合，其中每個數據項都有唯一的前驅和後繼（除了第一個沒有前驅，最後一個沒有後繼）。新的數據項加入到數據集中時，只會加入到原有某個數據項之前或之後。具有這種性質的數據集，就稱爲線性結構。

weixin_38324954 2020-07-08 11:06:52

Trie 前綴樹/字典樹

一、Trie的介紹：     1、主要應用場景：搜索引擎的自動補全功能：Trie樹+詞頻(概率)權重因子                                    IP路由：最長前綴匹配，Trie路由算法          

放羊的大飞 2020-07-08 10:58:58

數據結構——數組（3） 在有序數組中找出重複的次數最多的數

先總結有序數組，無序的後面再總結。。 1.以空間換時間法。 算法思想：目標數組array[length]，是一個有序數組，比如int array[]={1,1,2,2,4,4,4,4,4,5,5,6,10};總共有13個元素，

zhangying_496 2020-07-08 10:38:18

數據結構——數組（1）數組求和&打印二維數組&判斷數組是否遞增

數組求和 方法一：直接一次for循環 int GetSum1(int *a,int n) { int sum=0; for (int i=0; i<n;i++) { sum+=a[i];

zhangying_496 2020-07-08 10:38:18

藍橋杯 遞歸練習 覆蓋牆壁

題目描述 你有一個長爲N寬爲2的牆壁，給你兩種磚頭：一個長2寬1，另一個是L型覆蓋3個單元的磚頭。如下圖： 0 0 0 00 磚頭可以旋轉，兩種磚頭可以無限制提供。你的任務是計算用這兩種來覆蓋N*2的牆壁的覆蓋方法。例如一個2*3

NGU_Jq 2020-07-08 10:21:35