C语言之链表

链表的观念：
链表是一种物理存储上非连续，数据元素的逻辑顺序通过链表中的指针链接次序，实现的一种线性存储结构。
特点：链表由一系列节点（链表中每一个元素就称为节点）组成，节点在运行时动态生成（malloc），每个节点包括两部分：一个是存储数据元素的数据域；一个是存储下一个节点地址的指针域

定义一个链表：

typedef struct student
{
//数据域
	int num;
	int score;
	char name[20];
//指针域	
	struct student *next;
}STU;

接下来就是创建链表：

/*
链表的创建
参数：
	p_head：链表的头结点
	p_new：需要添加的新节点
返回值：无
*/
void link_creat_head(STU **p_head,STU *p_new)//可能链表最初是空，会改变头结点，因此p_head为指针的指针
{
	STU *p_mov=*p_head;
	if(*p_head==NULL)//第一次加入链表为空时，p_head直接将p_new加入到链表中
	{
		*p_head=p_new;
		p_new->next=NULL;
	}
	else//第二次及以后加入链表时，先要找到链表尾部，然后再加入p_new到尾部
	{
		while(p_mov->next!=NULL)
		{
			p_mov=p_mov->next;//找到原链表的最后一个节点
		}
		p_mov->next=p_new;//将新申请的节点加入链表
		p_new->next=NULL;
	}
}

接下来就是链表的遍历：

/*
链表的遍历
参数：
	head：头结点
返回值：无
*/
void link_print(STU *head)//遍历不会改变头指针的指向，因此定义为指针即可
{
	STU *p_mov=head;
	while(p_mov!=NULL)
	{
		printf("学号=%d、分数=%d、名字=%s\n",p_mov->num,p_mov->score,p_mov->name);
		p_mov=p_mov->next;
	}
}

有了这两个函数就可以进行测试了：

int main()
{
	STU *head = NULL,*p_new = NULL;
	int num ,i;
	printf("请输入加入链表的学生的个数：\n");
	scanf("%d",&num);
	for(i = 0;i < num;i++)
	{
		p_new = (STU *)malloc(sizeof(STU));//为一个节点申请空间
		printf("请输入学生的学号，成绩，姓名：\n");
		scanf("%d %d %s",&p_new->num,&p_new->score,p_new->name);
		link_creat_head(&head,p_new);//将节点添加到链表操作
	}
	link_print(head);
	return 0;
}

但是有了这两个函数还是不够的，链表申请了空间，那但我们要删除链表的时候应该怎么实现呢？

/*
链表的释放，即删除所有节点
参数：
	head：头结点
返回值：无
*/
void link_free(STU **head)
{
	STU *p_mov=*head;
	while(*head!=NULL)
	{
		p_mov=*head;
		*head=(*head)->next;
		free(p_mov);//要记得将所申请的空间释放
	}
}

这里将所有的节点都释放了，那么释放指定节点呢？根据学号或者姓名来进行释放是有所区别的，这里分别用两个函数进行说明：

/*
删除链表指定节点，根据学号
参数：
	p_head：头结点
	num：学生的学号
返回值：无
*/
void link_delete_num(STU **p_head,int num)
{
	STU *pb,*pf;
	pb=pf=*p_head;
	if(*p_head==NULL)//链表为空，不用删
	{
		printf("链表为空，没有您要删的节点\n");
		return;
	}
	while(pb->num!=num&&pb->next!=NULL)//循环找要删除的节点
	{
		pf=pb;
		pb=pb->next;
	}
	if (pb->num==num)//找到了节点
	{
		if (pb==*p_head)//要删除的就是头节点
		{
			*p_head=pb->next;
		}
		else
		{
			pf->next=pb->next;
		}
		free(pb);//记得释放所申请的空间
	}
	else
	{
		printf("没有找到您要删的节点\n");
	}
}

下面是根据姓名进行释放：

/*
删除链表指定节点，根据姓名
参数：
	p_head：头结点
	name：学生的姓名
返回值：无
*/
void link_delete_name(STU **p_head,char *name)
{
	STU *pb,*pf;
	pb=pf=*p_head;
	if(*p_head==NULL)//链表为空，不用删
	{
		printf("链表为空，没有您要删的节点\n");
		return;
	}
	while((strcmp(pb->name,name)!=0)&&pb->next!=NULL)//循环找要删除的节点
	{
		pf=pb;
		pb=pb->next;
	}
	if ((strcmp(pb->name,name)==0))//找到了节点
	{
		if (pb==*p_head)//要删除的就是头节点
		{
			*p_head=pb->next;
		}
		else
		{
			pf->next=pb->next;
		}
		free(pb);
	}
	else
	{
		printf("没有找到您要删的节点\n");
	}
}

当我们需要查找节点的时候，应该怎么实现呢？同删除操作一样，查找的时候根据姓名或者学号是有区别的：

/*
链表的查找，根据学号查找
参数：
	head：头结点
	num：学号
返回值：所找到的节点，没有找到就返回空
*/
STU * link_search_num(STU *head,int num)
{
	STU *p_mov=head;
	while(p_mov!=NULL)
	{
		if(p_mov->num==num)//找到了
		{
			return p_mov;
		}
		p_mov=p_mov->next;
	}
	return NULL;//没有找到
}

接下来是根据姓名查找：

/*
链表的查找，根据学生姓名查找
参数：
	head：头结点
	name：学生姓名
返回值：所找到的节点，没有找到就返回空
*/
STU * link_search_name(STU *head,char *name)
{
	STU *p_mov=head;
	while(p_mov!=NULL)
	{
		if(strcmp(p_mov->name,name)==0)//找到了，由于名字是字符串，所以要用字符串比较函数，不能直接使用等号
		{
			return p_mov;
		}
		p_mov=p_mov->next;
	}
	return NULL;//没有找到
}

接下来就是链表的排序了，这里采用冒泡排序法思想：

/*
链表的排序
参数：
	p_head：头结点
返回值：无
*/
void link_order(STU **p_head)
{
	STU *pb,*pf,temp;
	pb=pf=*p_head;
	if(*p_head==NULL)//链表为空，无需排序，提示
	{
		printf("链表为空，无需排序\n");
		return;
	}
	if((*p_head)->next==NULL)//链表只有一个节点，也无需排序，提示
	{
		printf("只有一个节点，无需排序\n");
		return;
	}
	while(pf->next!=NULL)//以pf指向的节点为基准节点
	{
		pb=pf->next;
		while(pb!=NULL)
		{
			if(pf->num>pb->num)
			{
				temp=*pb;
				*pb=*pf;
				*pf=temp;//交换了数据域
				temp.next=pb->next;
				pb->next=pf->next;
				pf->next=temp.next;//交换指针域
			}
			pb=pb->next;
		}
		pf=pf->next;
	}
}

接下来就是最后的，也是很多公司喜欢出的面试题—链表的逆序，这个逆序是通过改变指针域的指向来实现，而不是将前置数据域和后置数据域进行交换得到，废话不多说：

/*
链表的逆序
参数：
	head：头结点
返回值：
	结果修改之后的头结点，这个时候的头结点为变化之前的尾节点
*/
STU *link_reverse(STU *head)
{
	STU *pf,*pb,*r;
	pf=head;
	pb=pf->next;
	while(pb!=NULL)
	{
		r=pb->next; 
		pb->next=pf;
		pf=pb;
		pb=r;
	}
	head->next=NULL;
	head=pf;
	return head;
}