双链表（c语言数据结构）

双向链表的定义:双向链表也叫双链表，是链表的一种，它的每个数据结点中都有两个指针，分别指向直接后继和直接前驱。所以，从双向链表中的任意一个结点开始，都可以很方便地访问它的前驱结点和后继结点。下图为双向链表的结构图。
双向链表特点：
1.每次在插入或删除某个节点时, 需要处理四个节点的引用, 而不是两个. 实现起来要困难一些
2.相对于单向链表, 必然占用内存空间更大一些.
3.既可以从头遍历到尾, 又可以从尾遍历到头

双向链表中各节点包含以下 3 部分信息：
  指针域：用于指向当前节点的直接前驱节点；
  数据域：用于存储数据元素。
  指针域：用于指向当前节点的直接后继节点；

老师代码如下：

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

/**
 * Double linked list of integers. The key is char.
 */
typedef struct DoubleLinkedNode{
	char data;
	struct DoubleLinkedNode *previous;
	struct DoubleLinkedNode *next;
} DLNode, *DLNodePtr;

/**
 * Initialize the list with a header.
 * @return The pointer to the header.
 */
DLNodePtr initLinkList(){
	DLNodePtr tempHeader = (DLNodePtr)malloc(sizeof(struct DoubleLinkedNode));
	tempHeader->data = '\0';
	tempHeader->previous = NULL;
	tempHeader->next = NULL;
	return tempHeader;
}// Of initLinkList

/**
 * Print the list.
 * @param paraHeader The header of the list.
 */
void printList(DLNodePtr paraHeader){
	DLNodePtr p = paraHeader->next;
	while (p != NULL) {
		printf("%c", p->data);
		p = p->next;
	}// Of while
	printf("\r\n");
}// Of printList

/**
 * Insert an element to the given position.
 * @param paraHeader The header of the list.
 * @param paraChar The given char.
 * @param paraPosition The given position.
 */
void insertElement(DLNodePtr paraHeader, char paraChar, int paraPosition){
	DLNodePtr p, q, r;

	// Step 1. Search to the position.
	p = paraHeader;
	for (int i = 0; i < paraPosition; i ++) {
		p = p->next;
		if (p == NULL) {
			printf("The position %d is beyond the scope of the list.", paraPosition);
			return;
		}// Of if
	} // Of for i

	// Step 2. Construct a new node.
	q = (DLNodePtr)malloc(sizeof(struct DoubleLinkedNode));
	q->data = paraChar;

	// Step 3. Now link.
	r = p->next;
	q->next = p->next;
	q->previous = p;
	p->next = q;
	if (r != NULL) {
		r->previous = q;
	}// Of if
}// Of insertElement

/**
 * Delete an element from the list.
 * @param paraHeader The header of the list.
 * @param paraChar The given char.
 */
void deleteElement(DLNodePtr paraHeader, char paraChar){
	DLNodePtr p, q, r;
	p = paraHeader;

	// Step 1. Locate.
	while ((p->next != NULL) && (p->next->data != paraChar)){
		p = p->next;
	}// Of while

	// Step 2. Error check.
	if (p->next == NULL) {
		printf("The char '%c' does not exist.\r\n", paraChar);
		return;
	}// Of if

	// Step 3. Change links.
	q = p->next;
	r = q->next;
	p->next = r;
	if (r != NULL) {
		r->previous = p;
	}// Of if

	// Step 4. Free the space.
	free(q);
}// Of deleteElement

/**
 * Unit test.
 */
void insertDeleteTest(){
	// Step 1. Initialize an empty list.
	DLNodePtr tempList = initLinkList();
	printList(tempList);

	// Step 2. Add some characters.
	insertElement(tempList, 'H', 0);
	insertElement(tempList, 'e', 1);
	insertElement(tempList, 'l', 2);
	insertElement(tempList, 'l', 3);
	insertElement(tempList, 'o', 4);
	insertElement(tempList, '!', 5);
	printList(tempList);

	// Step 3. Delete some characters (the first occurrence).
	deleteElement(tempList, 'e');
	deleteElement(tempList, 'a');
	deleteElement(tempList, 'o');
	printList(tempList);

	// Step 4. Insert to a given position.
	insertElement(tempList, 'o', 1);
	printList(tempList);
}// Of appendInsertDeleteTest

/**
 * Address test: beyond the book.
 */
void basicAddressTest(){
	DLNode tempNode1, tempNode2;

	tempNode1.data = 4;
	tempNode1.next = NULL;

	tempNode2.data = 6;
	tempNode2.next = NULL;

	printf("The first node: %d, %d, %d\r\n",
		&tempNode1, &tempNode1.data, &tempNode1.next);
	printf("The second node: %d, %d, %d\r\n",
		&tempNode2, &tempNode2.data, &tempNode2.next);

	tempNode1.next = &tempNode2;
}// Of basicAddressTest

/**
 * The entrance.
 */
void main(){
	insertDeleteTest();
	basicAddressTest();
}// Of main

我的代码：

双向链表的结构体

typedef struct Node{
 	int data;
 	struct Node *previous;
 	struct Node *next;
}Node;

创建双向链表结点

Node* initList()
{
 	Node* tempHeader = (Node*)malloc(sizeof(struct Node));
 	tempHeader->data = '\0';
 	tempHeader->previous = NULL;
 	tempHeader->next = NULL;
 	return tempHeader;
}

头插法

void headinsert(Node* pHeader,int data) {
 	Node* node = (Node*)malloc(sizeof(Node));
 	node->data = data;
 	if(pHeader->data == 0)
	 {
 		//链表为空
 		node->next = pHeader->next;
 		node->previous = pHeader;
 		pHeader->next = node;
 		pHeader->data++;
	 }
	else
	{
	 	node->previous = pHeader;
	 	node->next = pHeader->next;
	 	pHeader->next->previous = node;
	 	pHeader->next = node;
	 	pHeader->data++;
	 }
}

尾插法

void tailinsert(Node* pHeader,int data,int position){
	Node* node = pHeader;
	Node* n = (Node*)malloc(sizeof(Node));
	n->data = data;
	int i;
	for (i = 0; i < position; i ++) {
		pHeader = pHeader->next;
		if (pHeader == NULL) {
			printf("输入%d的位置超出链表范围！\n",data);
			return;
		}
	} 
	while(node->next)
	{
		node = node->next;
	}
	n->next = node->next;
	node->next = n;
	n->previous = node;
}

删除元素

int delete(Node* pHeader,int data){
	Node *node = pHeader,*q,*r;

	while ((pHeader->next != NULL) && (pHeader->next->data != data)){
		pHeader = pHeader->next;
	}

	if (pHeader->next == NULL) {
		printf("%d不在链表中，无法删除！\n",data);
		return;
	}

	q = pHeader->next;
	r = q->next;
	pHeader->next = r;
	if (r != NULL) {
		r->previous = pHeader;
	}
	free(q);
}

打印链表

void printList(Node* pHeader){
	Node* node = pHeader->next;
	while(node)
	{
		printf("%d ",node->data);
		node = node->next;
	}
	printf("\n");
}

测试插入元素和删除元素

void Test(){
	Node* tempList = initList();
	printList(tempList);
    
    //在首位插入元素 
	headinsert(tempList, 1);
	headinsert(tempList, 2);
	headinsert(tempList, 3);
	headinsert(tempList, 4);
	headinsert(tempList, 3);
	headinsert(tempList, 2);
	headinsert(tempList, 1);
	printList(tempList);
	
	//在尾部插入元素 
	tailinsert(tempList, 7,7);
	tailinsert(tempList, 6,7);
	tailinsert(tempList, 7,8);
	tailinsert(tempList, 9,13);
	printList(tempList);

    //删除元素 
	delete(tempList,1);
	delete(tempList,3);
	delete(tempList,6);
	delete(tempList,10);
	printList(tempList);
}

完整代码：

#include<stdio.h>
#include<stdlib.h>

#define TURE 1
#define FALSE 0

 //双向链表的结构体 
typedef struct Node{
 	int data;
 	struct Node *previous;
 	struct Node *next;
}Node;
 
 //创建双链表结点
Node* initList()
{
 	Node* tempHeader = (Node*)malloc(sizeof(struct Node));
 	tempHeader->data = '\0';
 	tempHeader->previous = NULL;
 	tempHeader->next = NULL;
 	return tempHeader;
}
 
 //头插法 
void headinsert(Node* pHeader,int data) {
 	Node* node = (Node*)malloc(sizeof(Node));
 	node->data = data;
 	if(pHeader->data == 0)
	 {
 		//链表为空
 		node->next = pHeader->next;
 		node->previous = pHeader;
 		pHeader->next = node;
 		pHeader->data++;
	 }
	else
	{
	 	node->previous = pHeader;
	 	node->next = pHeader->next;
	 	pHeader->next->previous = node;
	 	pHeader->next = node;
	 	pHeader->data++;
	 }
}

//尾插法
void tailinsert(Node* pHeader,int data,int position){
	Node* node = pHeader;
	Node* n = (Node*)malloc(sizeof(Node));
	n->data = data;
	int i;
	for (i = 0; i < position; i ++) {
		pHeader = pHeader->next;
		if (pHeader == NULL) {
			printf("输入%d的位置超出链表范围！\n",data);
			return;
		}
	} 
	while(node->next)
	{
		node = node->next;
	}
	n->next = node->next;
	node->next = n;
	n->previous = node;
}

//删除元素
int delete(Node* pHeader,int data){
	Node *node = pHeader,*q,*r;

	while ((pHeader->next != NULL) && (pHeader->next->data != data)){
		pHeader = pHeader->next;
	}

	if (pHeader->next == NULL) {
		printf("%d不在链表中，无法删除！\n",data);
		return;
	}

	q = pHeader->next;
	r = q->next;
	pHeader->next = r;
	if (r != NULL) {
		r->previous = pHeader;
	}
	free(q);
}

//打印链表 
void printList(Node* pHeader){
	Node* node = pHeader->next;
	while(node)
	{
		printf("%d ",node->data);
		node = node->next;
	}
	printf("\n");
}

//测试插入和删除元素 
void Test(){
	Node* tempList = initList();
	printList(tempList);
    
    //在首位插入元素 
	headinsert(tempList, 1);
	headinsert(tempList, 2);
	headinsert(tempList, 3);
	headinsert(tempList, 4);
	headinsert(tempList, 3);
	headinsert(tempList, 2);
	headinsert(tempList, 1);
	printList(tempList);
	
	//在尾部插入元素 
	tailinsert(tempList, 7,7);
	tailinsert(tempList, 6,7);
	tailinsert(tempList, 7,8);
	tailinsert(tempList, 9,13);
	printList(tempList);

    //删除元素 
	delete(tempList,1);
	delete(tempList,3);
	delete(tempList,6);
	delete(tempList,10);
	printList(tempList);
}

//测试地址 
void basicAddressTest(){
	Node tempNode1, tempNode2;

	tempNode1.data = 1;
	tempNode1.next = NULL;

	tempNode2.data = 6;
	tempNode2.next = NULL;

	printf("The first node: %d, %d, %d\r\n",
		&tempNode1, &tempNode1.data, &tempNode1.next);
	printf("The second node: %d, %d, %d\r\n",
		&tempNode2, &tempNode2.data, &tempNode2.next);

	tempNode1.next = &tempNode2;
}

//入口 
int main()
{
    Test();
    basicAddressTest();
    
}

运行结果：

1 2 3 4 3 2 1
输入的9位置超出链表范围！
1 2 3 4 3 2 1 7 6 7
10不在链表中，无法删除！
2 4 3 2 1 7 7
The first node: 6487504, 6487504, 6487520
The second node: 6487472, 6487472, 6487488