双向链表的基本操作

双向链表的基本操作：

#ifndef _LIST_H
#define _LIST_H

typedef struct _NODE
{
int value;
struct _NODE *next;
struct _NODE *prev;
}NODE, *PNODE;

//输出结点
void Show(PNODE pHead); 
//头插
void InsertHead(PNODE* ppHead, int val);  
//尾插
void InsertTail(PNODE* ppHead, int val); 
//根据索引插入结点
void InsertByIndex(PNODE* ppHead, int index, int val);
//头删
void DeleteHead(PNODE* ppHead);//OK
//尾删
void DeleteTail(PNODE* ppHead); //用不到前驱？？//OK
//根据索引删除
void DeleteByIndex(PNODE* ppHead, int index); // question
//根据值删除
void DeleteByValue(PNODE* ppHead, int val);// question
//根据索引查找值 
PNODE FindNodeByIndex(PNODE pHead, int index); //ok
//根据结点的值查找
PNODE FindNodeByValue(PNODE pHead, int val);//ok
//根据索引修改值
void ModifyValueByIndex(PNODE pHead, int index, int val); //ok
//根据结点的值修改值
void ModifyValueByValue(PNODE pHead, int oldval, int newval);  //ok
//链表清空
void Clear(PNODE* ppHead);  
#endif
以上操作的实现：

#include <stdio.h>
#include <stdlib.h>
#include "list.h"
void Show(PNODE pHead)
{
	PNODE pPos = pHead;
	while (pPos != NULL)
	{
		printf("%d,", pPos->value);
		pPos = pPos->next;
	}
	printf("\b \n");
}

void InsertHead(PNODE *ppHead, int val)
{
	PNODE pNew = (PNODE)malloc(sizeof(NODE));
	pNew->value = val;
	pNew->prev = NULL;

	pNew->next = *ppHead;

	if (*ppHead != NULL)
	{
		(*ppHead)->prev = pNew;
	}

	*ppHead = pNew;	
}

void InsertTail(PNODE *ppHead, int val)
{
	if (NULL == *ppHead)
	{
		InsertHead(ppHead, val);
	}
	else
	{
		PNODE pPos = *ppHead;
		PNODE pNew = (PNODE)malloc(sizeof(NODE));

		pNew->value = val;
		pNew->next = NULL;

		while (pPos->next != NULL)
		{
			pPos = pPos->next;
		}
		pPos->next = pNew;
		pNew->prev = pPos;
	}
}

void DeleteHead(PNODE* ppHead)
{
	if (*ppHead != NULL)
	{
		PNODE pPos = *ppHead;
		*ppHead = pPos->next;
		pPos->prev = NULL;
		
		free(pPos);
		pPos = NULL;
	}
}

void DeleteTail(PNODE* ppHead)
{
	if (NULL == *ppHead || NULL == (*ppHead)->next)
	{
		DeleteHead(ppHead);
	}
	else
	{
		PNODE pPos = *ppHead;

		while (pPos->next != NULL)
		{
			pPos = pPos->next;
		}
		pPos->prev->next = NULL;

		free(pPos);
		pPos = NULL;
	}
}

void InsertByIndex(PNODE* ppHead, int index, int val)
{	
	int i = 0;
	PNODE pPos = *ppHead;

	if (NULL == *ppHead || 1 == index)
	{
		InsertHead(ppHead, val);
	}
	else if (index > 0 && pPos != NULL)
	{
		for ( i = 0; i < index-1 && pPos != NULL; i++)
		{
			pPos = pPos->next;
		}
		if (pPos != NULL)
		{
			PNODE pNew = (PNODE)malloc(sizeof(NODE));
			pNew->value = val;

			pNew->prev = pPos->prev;
			pPos->prev->next = pNew;
			pNew->next = pPos;
			pPos->prev = pNew;
		}
	}
	else
	{

	}
}

void DeleteByIndex(PNODE* ppHead, int index)
{
	int i = 0;
	int count = 0;
	PNODE pPos = *ppHead;

	if (1 == index)
	{
		DeleteHead(ppHead);
	}
	else if (index > 0 && pPos != NULL)
	{ 
		for (i = 0; i < index - 1 && pPos != NULL; i++)
		{
			pPos = pPos->next;
		}
		if (NULL == pPos->next)
		{
			DeleteTail(ppHead);
		}
		else if (pPos != NULL && pPos->next != NULL)
		{
			pPos->next->prev = pPos->prev;
			pPos->prev->next = pPos->next;

			free(pPos);
			pPos = NULL;
		} 
	}
}

void DeleteByValue(PNODE* ppHead, int val)
{
	int i = 0; 
	PNODE pPos = *ppHead;

	while (pPos != NULL)
	{
		while (pPos != NULL && pPos->value != val)
		{
			pPos = pPos->next;
		}

		if (NULL == pPos)
		{
			break;
		}
		if (pPos->next != NULL && pPos->prev == NULL)
		{
			DeleteHead(ppHead);
		}
		else
		{
			pPos->next->prev = pPos->prev;
			pPos->prev->next = pPos->next;

			free(pPos);
			pPos = NULL;
		}

	}
	
}

PNODE FindNodeByIndex(PNODE pHead, int index)
{
	PNODE pPos = pHead;
	int i = 0;

	if (index < 0)
	{
		return (NULL);
	}
	else
	{
		for (i = 0; i < index-1 && pPos != NULL; i++)
		{
			pPos = pPos->next;
		}

		return (pPos);
	}
}

PNODE FindNodeByValue(PNODE pHead, int val)
{
	PNODE pPos = pHead;

	for (pPos = pHead; pPos != NULL; pPos = pPos->next)
	{
		if (val == pPos->value)
		{
			return (pPos);
		}
	}

	return (NULL);

}

void ModifyValueByIndex(PNODE pHead, int index, int val)
{
	PNODE pPos = NULL;

	pPos = FindNodeByIndex(pHead, index);

	if (pPos != NULL)
	{
		pPos->value = val;
	}
}

void ModifyValueByValue(PNODE pHead, int oldval, int newval)
{
	PNODE pPos = NULL;

	pPos = FindNodeByValue(pHead, oldval);

	if (pPos != NULL)
	{
		pPos->value = newval;
	}
}

void Clear(PNODE* ppHead)
{
	while ((*ppHead) != NULL)
	{
		DeleteTail(ppHead);
	}
}




测试：


#include <stdio.h>
#include "list.h"
#include "UserType.h"

int main(void)
{
	PNODE pHead = NULL;
	PNODE pPos = NULL;

	InsertTail(&pHead, 1);
	InsertTail(&pHead, 2);
	InsertTail(&pHead, 4);
	InsertTail(&pHead, 3);
	InsertTail(&pHead, 6);
	InsertTail(&pHead, 7);
	InsertTail(&pHead, 5);
	InsertTail(&pHead, 8);

//	Clear(&pHead);
//	DeleteByValue(&pHead, 1);
//	InsertByIndex(&pHead, 1, 33);

	/*******************************/
	//pPos = FindNodeByIndex(pHead, 8);
	//if (pPos != NULL)
	//{
	//	pPos->value = 77;
	//}
	/*****************************/
	/*pPos = FindNodeByValue(pHead, 89);
	if (pPos != NULL)
	{
		pPos->value = 90;
	}*/

//	ModifyValueByIndex(pHead, 4, 89);

	ModifyValueByValue(pHead, 5, 55);

	Show(pHead);

	return 0;
}