链表（单链表、双链表、内核链表）

以下内容源于朱有鹏嵌入式课程的学习，如有侵权，请告知删除。

一、链表的引入

1、从数组的缺陷说起

• 数组有2个缺陷，一个是数组中所有元素的类型必须一致；第二个是数组的元素个数必须事先制定并且一旦指定之后不能更改。
• 数组的第一个缺陷靠结构体去解决。结构体允许其中的元素的类型不相同，因此解决了数组的第一个缺陷。所以说结构体是因为数组不能解决某些问题所以才发明的。
• 数组的第二个缺陷靠链表去解决。

2、链表

• 链表是由若干个节点组成的（链表的各个节点结构是完全类似的），节点是由有效数据和指针组成的。
• 有效数据区域用来存储信息完成任务的，指针区域用于指向链表的下一个节点从而构成链表。

二、单链表

1、头指针

• 头指针并不是节点，而是一个普通指针，只占4字节。头指针的类型是struct node *类型的，所以它才能指向链表的节点。
• 一个典型的链表的实现就是：头指针指向链表的第1个节点，然后第1个节点中的指针指向下一个节点，然后依次类推一直到最后一个节点。

2、头结点

（1）问题

• 如果程序中直接定义了头指针后就直接insert_tail就会报段错误。我们不得不在定义头指针之后先创建一个新节点给头指针初始化，否则不能避免这个错误；但是这样解决让程序看起来逻辑有点不太顺，因为看起来第一个节点和后面的节点的创建、添加方式有点不同。

（2）头结点特点

• 把头指针指向的第一个节点作为头节点使用。
• 头节点的特点是：紧跟在头指针后面，头节点的数据部分是空的（有时候存储整个链表的节点数），头结点的指针部分指向下一个节点，即第一个节点。
• 在创建头指针时一并创建头结点，并且和头指针关联起来。

（3）有无头结点区别

• 链表有没有头节点是不同的，体现在链表的插入节点、删除节点、遍历节点、解析链表的各个算法函数都不同。
• 所以如果一个链表设计的时候就有头节点那么后面的所有算法都应该这样来处理；如果设计时就没有头节点，那么后面的所有算法都应该按照没有头节点来做。
• 实际编程中两种链表都有人用，所以大家在看别人写的代码时一定要注意看它有没有头节点。

2、插入节点

参考博客：http://blog.csdn.net/oqqhutu12345678/article/details/52628769（无头结点）

（1）从链表头部插入新节点

（3）从链表尾部插入新节点

• 尾部插入简单点，因为前面已经建立好的链表不用动，直接动最后一个就可以。

（3）链表即可以从头部插入，也可以从尾部插入，还可以两头插入。

• 对链表本身无差别，但是有时候对业务逻辑有差别。

3、遍历节点

4、删除节点

（1）删除节点的2个步骤

• 第一步：找到要删除的节点；第二步：删除这个节点。

（2）如何删除一个节点

• 待删除的节点是否尾节点
  

5、逆序

（1）什么是链表的逆序？

• 链表的逆序又叫反向，意思就是把链表中所有的有效节点在链表中的顺序给反过来。

（2）单链表逆序算法分析

• 首先遍历原链表，然后将原链表中的头指针和头节点作为新链表的头指针和头节点，原链表中的有效节点挨个依次取出来，采用头插入的方法插入新链表中即可。
• 链表逆序 = 遍历 + 头插入。

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



struct node
{
	int data;				
	struct node *pNext;		
};

// 作用：创建一个链表节点
// 返回值：指针，指针指向我们本函数新创建的一个节点的首地址
struct node * create_node(int data)
{
	struct node *p = (struct node *)malloc(sizeof(struct node));
	if (NULL == p)
	{
		printf("malloc error.\n");
		return NULL;
	}
	// 清理申请到的堆内存
	bzero(p, sizeof(struct node));
	// 填充节点
	p->data = data;
	p->pNext = NULL;	
	
	return p;
}

void insert_tail(struct node *pH, struct node *new)
{
	int cnt = 0;
	// 分两步来完成插入
	// 第一步，先找到链表中最后一个节点
	struct node *p = pH;
	while (NULL != p->pNext)
	{
		p = p->pNext;				// 往后走一个节点
		cnt++;
	}
	
	// 第二步，将新节点插入到最后一个节点尾部
	p->pNext = new;
	pH->data = cnt + 1;
}


void insert_head(struct node *pH, struct node *new)//第一个参数是头指针，第二个参数是指向新建节点的指针
{
	// 第1步： 新节点的next指向原来的第一个节点
	new->pNext = pH->pNext;//????是因为创建了一个头结点，我们的插入，是在头结点和第一个节点间插入
	//new->pNext = pH;这才对吧？待验证。无头结点时的用法
	
	// 第2步： 头节点的next指向新节点的地址
	pH->pNext = new;
	
	// 第3步： 头节点中的计数要加1
	pH->data += 1;
}

// 遍历单链表，pH为指向单链表的头指针，遍历的节点数据打印出来
void bianli(struct node*pH)
{
	struct node *p = pH->pNext;	// p直接走到第一个节点

	printf("-----------开始遍历-----------\n");
	while (NULL != p->pNext)		// 是不是最后一个节点
	{
		printf("node data: %d.\n", p->data);
		p = p->pNext;				// 走到下一个节点，也就是循环增量
	}
	printf("node data: %d.\n", p->data);//这打印最后一个节点的数据。破坏了统一性。
	printf("-------------完了-------------\n");
}


void bianli2(struct node*pH)
{
	struct node *p = pH;		// 头指针后面是头节点

	printf("-----------开始遍历-----------\n");
	while (NULL != p->pNext)		// 是不是最后一个节点
	{
		p = p->pNext;				// 走到下一个节点，也就是循环增量
		printf("node data: %d.\n", p->data);
	}

	printf("-------------完了-------------\n");
}


// 从链表pH中删除节点，待删除的节点的特征是数据区等于data
// 返回值：当找到并且成功删除了节点则返回0，当未找到节点时返回-1
int delete_node(struct node*pH, int data)
{
	// 找到这个待删除的节点，通过遍历链表来查找
	struct node *p = pH;			// 用来指向当前节点
	struct node *pPrev = NULL;		// 用来指向当前节点的前一个节点

	while (NULL != p->pNext)		// 是不是最后一个节点
	{
		pPrev = p;					// 在p走向下一个节点前先将其保存
		p = p->pNext;				// 走到下一个节点，也就是循环增量
		// 判断这个节点是不是我们要找的那个节点
		if (p->data == data)
		{
			// 找到了节点，处理这个节点
			// 分为2种情况，一个是找到的是普通节点，另一个是找到的是尾节点
			// 删除节点的困难点在于：通过链表的遍历依次访问各个节点，找到这个节点
			// 后p指向了这个节点，但是要删除这个节点关键要操作前一个节点，但是这
			// 时候已经没有指针指向前一个节点了，所以没法操作。解决方案就是增加
			// 一个指针指向当前节点的前一个节点
			if (NULL == p->pNext)
			{
				// 尾节点
				pPrev->pNext = NULL;		// 原来尾节点的前一个节点变成新尾节点
				free(p);					// 释放原来的尾节点的内存
			}
			else
			{
				// 普通节点
				pPrev->pNext = p->pNext;	// 要删除的节点的前一个节点和它的后一个节点相连，这样就把要删除的节点给摘出来了
				free(p);
			}
			// 处理完成之后退出程序
			return 0;
		}
	}
	// 到这里还没找到，说明链表中没有我们想要的节点
	printf("没找到这个节点.\n");
	return -1;
}

// 将pH指向的链表逆序
void reverse_linkedlist(struct node *pH)
{
	struct node *p = pH->pNext;		// pH指向头节点，p指向第1个有效节点
	struct node *pBack;				// 保存当前节点的后一个节点地址
	
	// 当链表没有有效节点或者只有一个有效节点时，逆序不用做任何操作
	if ((NULL ==p) || (NULL == p->pNext))
		return;
	
	// 当链表有2个及2个以上节点时才需要真正进行逆序操作
	while (NULL != p->pNext)		// 是不是最后一个节点
	{
		// 原链表中第一个有效节点将是逆序后新链表的尾节点，尾节点的pNext指向NULL
		pBack = p->pNext;			// 保存p节点后面一个节点地址
		if (p == pH->pNext)
		{
			// 原链表第一个有效节点
			p->pNext = NULL;
		}
		else
		{
			// 原链表的非第1个有效节点
			p->pNext = pH->pNext;
		}
		pH->pNext = p;
		
		//p = p->pNext;		// 这样已经不行了，因为p->pNext已经被改过了
		p = pBack;			// 走到下一个节点
	}
	// 循环结束后，最后一个节点仍然缺失
	insert_head(pH, p);
}

int main(void)
{
	// 定义头指针，创建头结点，并把头指针指向头结点
	struct node *pHeader = create_node(0);//创建头结点
	
	insert_head(pHeader, create_node(11));//11，12，13是所创建的节点数据，这里采用头插法。
	insert_head(pHeader, create_node(12));
	insert_head(pHeader, create_node(13));

	bianli2(pHeader);
	
	return 0;
}

三、双链表

1、单链表的局限性

• 局限性主要体现在单链表只能经由指针单向移动。
• 一旦指针移动过某个节点就无法再回来，如果要再次操作这个节点除非从头指针开始再次遍历一次。
• 因此单链表的某些操作就比较麻烦（算法比较有局限）。

2、双链表

• 双向链表的节点 = 有效数据 + 2个指针（一个指向后一个节点，另一个指向前一个节点）。

3、插入节点

（1）尾部插入

（2）头部插入

4、遍历节点

• 双链表中如果无视pPrev指针，则双链表就变成了单链表。这就决定了双链表的正向遍历（后向遍历）和单链表是完全相同的。
• 前向遍历的意义并不大，主要是因为很少有当前当了尾节点需要前向遍历的情况。
• 双链表是对单链表的一种有成本的扩展，因此在实践用途中要根据业务要求选择适合的链表。

5、删除节点

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


// 双链表的节点
struct node 
{
	int data;					// 有效数据
	struct node *pPrev;			// 前向指针，指向前一个节点
	struct node *pNext;			// 后向指针，指向后一个节点
};

struct node *create_node(int data)
{
	struct node *p = (struct node *)malloc(sizeof(struct node));
	if (NULL == p)
	{
		printf("malloc error.\n");
		return NULL;
	}
	p->data = data;
	p->pPrev = NULL;
	p->pNext = NULL;		// 默认创建的节点前向后向指针都指向NULL
	
	return p;
}

// 将新节点new插入到链表pH的尾部
void insert_tail(struct node *pH, struct node *new)
{
	// 第一步先走到链表的尾节点
	struct node *p = pH;
	while (NULL != p->pNext)
	{
		p = p->pNext;			// 第一次循环走过了头节点
	}
	// 循环结束后p就指向了原来的最后一个节点
	// 第二步：将新节点插入到原来的尾节点的后面
	p->pNext = new;				// 后向指针关联好了。新节点的地址和前节点的next
	new->pPrev = p;				// 前向指针关联好了。新节点的prev和前节点的地址
								// 前节点的prev和新节点的next指针未变动
}

// 将新节点new前插入链表pH中。
// 算法参照图示进行连接，一共有4个指针需要赋值。注意的是顺序。
void insert_head(struct node *pH, struct node *new)
{
	// 新节点的next指针指向原来的第1个有效节点的地址
	new->pNext = pH->pNext;
	
	// 原来第1个有效节点的prev指针指向新节点的地址
	if (NULL != pH->pNext)
		pH->pNext->pPrev = new;
	
	// 头节点的next指针指向新节点地址
	pH->pNext = new;
	
	// 新节点的prev指针指向头节点的地址
	new->pPrev = pH;
}

// 后向遍历一个双链表
void bianli(struct node *pH)
{
	struct node *p = pH;
	
	if (NULL == p)
	{
		return;
	}
	
	while (NULL != p->pNext)
	{
		p = p->pNext;
		
		printf("data = %d.\n", p->data);
	}
}

// 前向遍历一个双遍历，参数pTail要指向链表末尾
void qianxiang_bianli(struct node *pTail)
{
	struct node *p = pTail;
	
	while (NULL != p->pPrev)
	{
		printf("data = %d.\n", p->data);
		
		p = p->pPrev;
	}
}

// 从链表pH中删除一个节点，节点中的数据是data
int delete_node(struct node *pH, int data)
{
	struct node *p = pH;
	
	if (NULL == p)
	{
		return -1;
	}
	
	while (NULL != p->pNext)
	{
		p = p->pNext;
		
		// 在这里先判断当前节点是不是我们要删除的那个节点
		if (p->data == data)
		{
			// 找到了，删除之。当前上下文是：当前节点为p
			if (NULL == p->pNext)
			{
				// 尾节点
// p表示当前节点地址，p->pNext表示后一个节点地址，p->pPrev表示前一个节点的地址
				p->pPrev->pNext = NULL;
				//p->pPrev = NULL;			可以省略，因为后面整个都被销毁了
				// 销毁p节点
				//free(p);
			}
			else
			{
				// 不是尾节点，普通节点
				
				// 前一个节点的next指针指向后一个节点的首地址
				p->pPrev->pNext = p->pNext;
				
				// 当前节点的prev和next指针都不用管，因为后面会整体销毁整个节点
				
				// 后一个节点的prev指针指向前一个节点的首地址
				p->pNext->pPrev = p->pPrev;
				
				//free(p);
			}
			free(p);
			
			return 0;
		}
	}
	
	printf("未找到目标节点.\n");
	return -1;
}



int main(void)
{
	//struct node *pHeader = create_node(0);		// 头指针
	struct node *pHeader = NULL;
	
	//insert_head(pHeader, create_node(11));
	//insert_head(pHeader, create_node(12));
	//insert_head(pHeader, create_node(13));
	
	
	/*
	// 遍历
	printf("node 1 data: %d.\n", pHeader->pNext->data);
	printf("node 2 data: %d.\n", pHeader->pNext->pNext->data);
	printf("node 3 data: %d.\n", pHeader->pNext->pNext->pNext->data);

	struct node *p = pHeader->pNext->pNext->pNext;		// p指向了最后一个节点
	printf("node 3 data: %d.\n", p->data);
	printf("node 2 data: %d.\n", p->pPrev->data);
	printf("node 1 data: %d.\n", p->pPrev->pPrev->data);
	*/
	
	//bianli(pHeader);
	
	//struct node *p = pHeader->pNext->pNext->pNext;
	//qianxiang_bianli(p);
	
	
	bianli(pHeader);
	delete_node(pHeader, 11);
	printf("after delete node------------------\n");
	bianli(pHeader);
	
	return 0;
}

四、linux内核链表

见博客http://blog.csdn.net/oqqhutu12345678/article/details/78521640