c语言之链表

最新推荐文章于 2024-10-06 12:03:03 发布
最新推荐文章于 2024-10-06 12:03:03 发布
阅读量487 收藏 1
点赞数
文章标签： 链表 c语言 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/liyaoliy/article/details/121087548
版权

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

链表的构成：链表由一个个节点构成，每个节点一般采用结构体的形式组织，例如：

typedef struct student
{
int num;
char name[20];
struct student *next;   //与结构体名字一样
}STU;

链表节点分为两个域
数据域：存放实际的数据，如：num,score;
指针域：存放下一个节点的首地址，如:next等。

链表的操作：创建（增删改查）

1.链表的创建
第一步：创建一个节点
第二步：创建第二个节点，将其放在第一个节点的后面（第一个节点的指针域保存第二个节点的地址）
第三步：再次创建节点，找到原本节点的最后一个节点，接着将最后一个节点的指针域保存新节点的地址，以此类推。
代码1：

#include<stdio.h>
#include<stdlib.h>
#pragma warning(disable:4996)

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

void link_creat_head(STU** p_head, STU *p_new)
{
	STU* p_mov = *p_head;
	if (*p_head == NULL) //当第一次加入链表为空时，head执行p_new
	{
		*p_head = p_new;
		p_new->next = NULL;
	}
	else //第二次及以后加入链表
	{
		while (p_mov->next != NULL)
		{
			p_mov = p_mov->next; //找到原有链表的最后一个节点
		}
		p_mov->next = p_new;//将新申请的节点加入链表
		p_new->next = NULL;
	}

}
int main()
{
	STU* head = NULL, * p_new = NULL;
	int num, i;
	printf("请输入链表初始个数：");
	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);  //将节点加入新的链表
	}
}

链表的遍历：
第一步：输出第一个结点的数据域，输出完毕后，让指针保存后一个结点的地址
p=p->next
第二步：输出移动地址对应的结点的数据域，输出完毕后，指针继续后移
第三步：以此类推，直到结点的指针域为NULL
代码2：

#include<stdio.h>
#include<stdlib.h>
#pragma warning(disable:4996)

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

void link_creat_head(STU** p_head, STU* p_new)
{
	STU* p_mov = *p_head;
	if (*p_head == NULL) //当第一次加入链表为空时，head执行p_new
	{
		*p_head = p_new;
		p_new->next = NULL;
	}
	else //第二次及以后加入链表
	{
		while (p_mov->next != NULL)
		{
			p_mov = p_mov->next; //找到原有链表的最后一个节点
		}
		p_mov->next = p_new;//将新申请的节点加入链表
		p_new->next = NULL;
	}

}

//链表的遍历
void link_print(STU* head)
{
	STU* p_mov;
	//定义新的指针保存链表的首地址，防止使用head改变原本链表
	p_mov = head;
	//当指针保存最后一个结点的指针域为NULL时，循环结束
	while (p_mov != NULL)
	{
		//先打印当前指针保存结点的指针域
		printf("num=%d score=%d name=%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("请输入链表初始个数：");
	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);
}

链表的释放：
重新定义一个指针q,保存p指向的地址，然后p后移保存下一个结点的地址，然后释放q对应的结点，以此类推，直到p为NULL为止。
代码3：

#include<stdio.h>
#include<stdlib.h>
#pragma warning(disable:4996)

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

void link_creat_head(STU** p_head, STU* p_new)
{
	STU* p_mov = *p_head;
	if (*p_head == NULL) //当第一次加入链表为空时，head执行p_new
	{
		*p_head = p_new;
		p_new->next = NULL;
	}
	else //第二次及以后加入链表
	{
		while (p_mov->next != NULL)
		{
			p_mov = p_mov->next; //找到原有链表的最后一个节点
		}
		p_mov->next = p_new;//将新申请的节点加入链表
		p_new->next = NULL;
	}

}

//链表的遍历
void link_print(STU* head)
{
	STU* p_mov;
	//定义新的指针保存链表的首地址，防止使用head改变原本链表
	p_mov = head;
	//当指针保存最后一个结点的指针域为NULL时，循环结束
	while (p_mov != NULL)
	{
		//先打印当前指针保存结点的指针域
		printf("num=%d score=%d name=%s \n", p_mov->num, p_mov->score, p_mov->name);

		//指针后移 保存下一个结点的地址
		p_mov = p_mov->next;
	}
}

//链表的释放
void link_free(STU** p_head)
{
//定义一个指针变量保存头指针的地址
	STU* pb = *p_head;

	while (*p_head!=NULL)
	{
		//先保存p_head指向的结点的地址
		pb = *p_head;
		//p_head保存下一个结点的地址
		*p_head = (*p_head)->next;
		//释放结点并防止野指针
		free(pb);
		pb = NULL;
	}
}

int main()
{
	STU* head = NULL, * p_new = NULL;
	int num, i;
	printf("请输入链表初始个数：");
	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);
	link_free(&head);
}

链表结点的查找
先对比第一个结点的数据域是否是想要的数据，如果是就直接返回，如果不是则继续查找下一个结点，如果到达最后一个结点就没有匹配的数据，说明要查找的数据不存在。
代码4：

#include<stdio.h>
#include<stdlib.h>
#pragma warning(disable:4996)

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

void link_creat_head(STU** p_head, STU* p_new)
{
	STU* p_mov = *p_head;
	if (*p_head == NULL) //当第一次加入链表为空时，head执行p_new
	{
		*p_head = p_new;
		p_new->next = NULL;
	}
	else //第二次及以后加入链表
	{
		while (p_mov->next != NULL)
		{
			p_mov = p_mov->next; //找到原有链表的最后一个节点
		}
		p_mov->next = p_new;//将新申请的节点加入链表
		p_new->next = NULL;
	}

}

//链表的遍历
void link_print(STU* head)
{
	STU* p_mov;
	//定义新的指针保存链表的首地址，防止使用head改变原本链表
	p_mov = head;
	//当指针保存最后一个结点的指针域为NULL时，循环结束
	while (p_mov != NULL)
	{
		//先打印当前指针保存结点的指针域
		printf("num=%d score=%d name=%s \n", p_mov->num, p_mov->score, p_mov->name);

		//指针后移 保存下一个结点的地址
		p_mov = p_mov->next;
	}
}

//链表的释放
void link_free(STU** p_head)
{
//定义一个指针变量保存头指针的地址
	STU* pb = *p_head;

	while (*p_head!=NULL)
	{
		//先保存p_head指向的结点的地址
		pb = *p_head;
		//p_head保存下一个结点的地址
		*p_head = (*p_head)->next;
		//释放结点并防止野指针
		free(pb);
		pb = NULL;
	}
}

//链表的查找
//按照学号查找
STU* link_search_num(STU* head, int num)
{
	STU* p_mov;
	//定义一个指针变量保存第一个结点的地址
	p_mov = head;
	//当没有到达最后一个结点的指针域时循环继续 
	while (p_mov != NULL)
	{
		//如果找到是当前结点的数据，则返回当前结点的地址
		if (p_mov->num == num)  //找到了
		{
			return p_mov;
		}
		//如果没有找到 则继续对比下一个结点的指针域
		p_mov = p_mov->next;
	}
	//当循环结束的时候还没有找到 说明要查找的数据不存在 返回NULL进行标识
	return NULL;  //没有找到
}

//按照姓名查找
STU* link_search_name(STU* head, char *name)
{
	STU* p_mov;
	//定义一个指针变量保存第一个结点的地址
	p_mov = head;
	//当没有到达最后一个结点的指针域时循环继续 
	while (p_mov != NULL)
	{
		//如果找到是当前结点的数据，则返回当前结点的地址
		if (strcmp(p_mov->name,name) ==0)  //找到了
		{
			return p_mov;
		}
		//如果没有找到 则继续对比下一个结点的指针域
		p_mov = p_mov->next;
	}
	//当循环结束的时候还没有找到 说明要查找的数据不存在 返回NULL进行标识
	return NULL;  //没有找到
}

int main()
{
	STU* head = NULL, * p_new = NULL, * pb=NULL;
	int num, i;
	printf("请输入链表初始个数：");
	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);
	//link_free(&head);
	//查学号
	while (1)
	{
		printf("输入您要查找的学生的学号：\n");
		scanf("%d", &num);
		pb = link_search_num(head, num);
		if (pb != NULL)
		{
			printf("找到了 num=%d score=%d name=%s", pb->num, pb->score, pb->name);
		}
		else
		{
			printf("没有找到");
		}
	}
}

链表结点的删除：
如果链表为空，不需要删除
如果删除的是第一个结点，则需要保存链表首地址的指针保存第一个结点的下一个结点的地址
如果删除的是中间结点，则找到中间结点的前一个结点，让前一个结点的指针域保存这个结点的后一个地址即可。
代码5：

#include<stdio.h>
#include<stdlib.h>
#pragma warning(disable:4996)

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

void link_creat_head(STU** p_head, STU* p_new)
{
	STU* p_mov = *p_head;
	if (*p_head == NULL) //当第一次加入链表为空时，head执行p_new
	{
		*p_head = p_new;
		p_new->next = NULL;
	}
	else //第二次及以后加入链表
	{
		while (p_mov->next != NULL)
		{
			p_mov = p_mov->next; //找到原有链表的最后一个节点
		}
		p_mov->next = p_new;//将新申请的节点加入链表
		p_new->next = NULL;
	}

}

//链表的遍历
void link_print(STU* head)
{
	STU* p_mov;
	//定义新的指针保存链表的首地址，防止使用head改变原本链表
	p_mov = head;
	//当指针保存最后一个结点的指针域为NULL时，循环结束
	while (p_mov != NULL)
	{
		//先打印当前指针保存结点的指针域
		printf("num=%d score=%d name=%s \n", p_mov->num, p_mov->score, p_mov->name);

		//指针后移 保存下一个结点的地址
		p_mov = p_mov->next;
	}
}

//链表的释放
void link_free(STU** p_head)
{
//定义一个指针变量保存头指针的地址
	STU* pb = *p_head;

	while (*p_head!=NULL)
	{
		//先保存p_head指向的结点的地址
		pb = *p_head;
		//p_head保存下一个结点的地址
		*p_head = (*p_head)->next;
		//释放结点并防止野指针
		free(pb);
		pb = NULL;
	}
}

//链表的查找
//按照学号查找
STU* link_search_num(STU* head, int num)
{
	STU* p_mov;
	//定义一个指针变量保存第一个结点的地址
	p_mov = head;
	//当没有到达最后一个结点的指针域时循环继续 
	while (p_mov != NULL)
	{
		//如果找到是当前结点的数据，则返回当前结点的地址
		if (p_mov->num == num)  //找到了
		{
			return p_mov;
		}
		//如果没有找到 则继续对比下一个结点的指针域
		p_mov = p_mov->next;
	}
	//当循环结束的时候还没有找到 说明要查找的数据不存在 返回NULL进行标识
	return NULL;  //没有找到
}

//按照姓名查找
STU* link_search_name(STU* head, char *name)
{
	STU* p_mov;
	//定义一个指针变量保存第一个结点的地址
	p_mov = head;
	//当没有到达最后一个结点的指针域时循环继续 
	while (p_mov != NULL)
	{
		//如果找到是当前结点的数据，则返回当前结点的地址
		if (strcmp(p_mov->name,name) ==0)  //找到了
		{
			return p_mov;
		}
		//如果没有找到 则继续对比下一个结点的指针域
		p_mov = p_mov->next;
	}
	//当循环结束的时候还没有找到 说明要查找的数据不存在 返回NULL进行标识
	return NULL;  //没有找到
}

//链表结点的删除
void link_detele_num(STU** p_head, int num)
{
	STU* pb, * pf;
	pb = pf = *p_head;
	if (*p_head == NULL)  //链表为空 不用删
	{
		printf("链表为空，没有您要删的结点");
		return;
	}
	while (pb->num!=num && pb->next!=NULL)  //循环找，要删除的结点
	{
		pf = pb;
		pb = pb->next;
	}
	if (pb->num == num) //找到了一个结点的num和num相同
	{
		if (pb == *p_head)  //要删除的是头结点
		{
			//让保存头结点的指针保存后一个结点的地址
			*p_head = pb->next;
		}
		else
		{
			//前一个结点的指针域保存要删除的后一个结点的地址
			pf->next = pb->next;
		}
		//释放空间
		free(pb);
		pb = NULL;
	}
	else //没有找到
	{
		printf("没有你要删除的结点\n");
	}


}

int main()
{
	STU* head = NULL, * p_new = NULL, * pb=NULL;
	int num, i;
	printf("请输入链表初始个数：");
	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);
	//link_free(&head);
	printf("请输入你要删除结点的学号:\n");
	scanf("%d", &num);
	link_detele_num(&head, num);
	link_print(head);
	link_free(&head);
}

链表中插入一个节点：
链表中插入一个结点，按照原本链表的顺序插入，找到合适的位置。（原本的链表必须有顺序）
情况：
1.如果链表没有结点，则新插入的结点就是第一个结点
2.如果新插入的结点的数值最小 则为头结点
3.如果新插入的数值在中间位置 则找到前一个 然后插入他们中间
4.如果新插入的数值最大 则插入到最后
代码6：

#include<stdio.h>
#include<stdlib.h>
#include<string.h>
#pragma warning(disable:4996)

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

void link_creat_head(STU** p_head, STU* p_new)
{
	STU* p_mov = *p_head;
	if (*p_head == NULL) //当第一次加入链表为空时，head执行p_new
	{
		*p_head = p_new;
		p_new->next = NULL;
	}
	else //第二次及以后加入链表
	{
		while (p_mov->next != NULL)
		{
			p_mov = p_mov->next; //找到原有链表的最后一个节点
		}
		p_mov->next = p_new;//将新申请的节点加入链表
		p_new->next = NULL;
	}

}

//链表的遍历
void link_print(STU* head)
{
	STU* p_mov;
	//定义新的指针保存链表的首地址，防止使用head改变原本链表
	p_mov = head;
	//当指针保存最后一个结点的指针域为NULL时，循环结束
	while (p_mov != NULL)
	{
		//先打印当前指针保存结点的指针域
		printf("num=%d score=%d name=%s \n", p_mov->num, p_mov->score, p_mov->name);

		//指针后移 保存下一个结点的地址
		p_mov = p_mov->next;
	}
}

//链表的释放
void link_free(STU** p_head)
{
	//定义一个指针变量保存头指针的地址
	STU* pb = *p_head;

	while (*p_head != NULL)
	{
		//先保存p_head指向的结点的地址
		pb = *p_head;
		//p_head保存下一个结点的地址
		*p_head = (*p_head)->next;
		//释放结点并防止野指针
		free(pb);
		pb = NULL;
	}
}

//链表的查找
//按照学号查找
STU* link_search_num(STU* head, int num)
{
	STU* p_mov;
	//定义一个指针变量保存第一个结点的地址
	p_mov = head;
	//当没有到达最后一个结点的指针域时循环继续 
	while (p_mov != NULL)
	{
		//如果找到是当前结点的数据，则返回当前结点的地址
		if (p_mov->num == num)  //找到了
		{
			return p_mov;
		}
		//如果没有找到 则继续对比下一个结点的指针域
		p_mov = p_mov->next;
	}
	//当循环结束的时候还没有找到 说明要查找的数据不存在 返回NULL进行标识
	return NULL;  //没有找到
}

//按照姓名查找
STU* link_search_name(STU* head, char* name)
{
	STU* p_mov;
	//定义一个指针变量保存第一个结点的地址
	p_mov = head;
	//当没有到达最后一个结点的指针域时循环继续 
	while (p_mov != NULL)
	{
		//如果找到是当前结点的数据，则返回当前结点的地址
		if (strcmp(p_mov->name, name) == 0)  //找到了
		{
			return p_mov;
		}
		//如果没有找到 则继续对比下一个结点的指针域
		p_mov = p_mov->next;
	}
	//当循环结束的时候还没有找到 说明要查找的数据不存在 返回NULL进行标识
	return NULL;  //没有找到
}

//链表结点的删除
void link_detele_num(STU** p_head, int num)
{
	STU* pb, * pf;
	pb = pf = *p_head;
	if (*p_head == NULL)  //链表为空 不用删
	{
		printf("链表为空，没有您要删的结点");
		return;
	}
	while (pb->num != num && pb->next != NULL)  //循环找，要删除的结点
	{
		pf = pb;
		pb = pb->next;
	}
	if (pb->num == num) //找到了一个结点的num和num相同
	{
		if (pb == *p_head)  //要删除的是头结点
		{
			//让保存头结点的指针保存后一个结点的地址
			*p_head = pb->next;
		}
		else
		{
			//前一个结点的指针域保存要删除的后一个结点的地址
			pf->next = pb->next;
		}
		//释放空间
		free(pb);
		pb = NULL;
	}
	else //没有找到
	{
		printf("没有你要删除的结点\n");
	}


}

//链表的插入:按照学号的顺序插入
void link_insert_num(STU** p_head, STU* p_new)
{
	STU* pb, * pf;
	pb = pf = *p_head;
	if (*p_head == NULL)  //链表为空
	{
		*p_head = p_new;
		p_new->next = NULL;
		return;
	}
	while ((p_new->num >= pb->num) && (pb->next != NULL))
	{
		pf = pb;
		pb = pb->next;
	}
	if (p_new->num < pb->num)  //找到一个结点的num比新来的结点大  插在pb前
	{
		if (pb == *p_head)  //找到的节点是头结点 插在最前
		{
			p_new->next = *p_head;
			*p_head = p_new;
		}
		else
		{
			pf->next = p_new;
			p_new->next = pb;
		}
	}
	else  //没有找到pb的num比p_new->num大的结点  插在最后面
	{
		pb->next = p_new;
		p_new->next = NULL;
	}

}

int main()
{
	STU* head = NULL, * p_new = NULL, * pb = NULL;
	int num, i;
	printf("请输入链表初始个数：");
	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);
	//link_free(&head);
	while (1)
	{
		printf("请输入要插入的结点num score name \n");
		p_new = (STU*)malloc(sizeof(STU));  //申请一个新节点
		scanf("%d %d %s", &p_new->num, &p_new->score, p_new->name);
		link_insert_num(&head, p_new);
		link_print(head);
	}
}

结果：

请输入链表初始个数：3
请输入学号，分数，名字：
1 56 k1
请输入学号，分数，名字：
3 78 k2
请输入学号，分数，名字：
5 98 k3
num=1 score=56 name=k1
num=3 score=78 name=k2
num=5 score=98 name=k3
请输入要插入的结点num score name
4 99 k4
num=1 score=56 name=k1
num=3 score=78 name=k2
num=4 score=99 name=k4
num=5 score=98 name=k3
请输入要插入的结点num score name

代码7:

#include<stdio.h>
#include<stdlib.h>
#include<string.h>
#pragma warning(disable:4996)

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

void link_creat_head(STU** p_head, STU* p_new)
{
	STU* p_mov = *p_head;
	if (*p_head == NULL) //当第一次加入链表为空时，head执行p_new
	{
		*p_head = p_new;
		p_new->next = NULL;
	}
	else //第二次及以后加入链表
	{
		while (p_mov->next != NULL)
		{
			p_mov = p_mov->next; //找到原有链表的最后一个节点
		}
		p_mov->next = p_new;//将新申请的节点加入链表
		p_new->next = NULL;
	}

}

//链表的遍历
void link_print(STU* head)
{
	STU* p_mov;
	//定义新的指针保存链表的首地址，防止使用head改变原本链表
	p_mov = head;
	//当指针保存最后一个结点的指针域为NULL时，循环结束
	while (p_mov != NULL)
	{
		//先打印当前指针保存结点的指针域
		printf("num=%d score=%d name=%s \n", p_mov->num, p_mov->score, p_mov->name);

		//指针后移 保存下一个结点的地址
		p_mov = p_mov->next;
	}
}

//链表的释放
void link_free(STU** p_head)
{
	//定义一个指针变量保存头指针的地址
	STU* pb = *p_head;

	while (*p_head != NULL)
	{
		//先保存p_head指向的结点的地址
		pb = *p_head;
		//p_head保存下一个结点的地址
		*p_head = (*p_head)->next;
		//释放结点并防止野指针
		free(pb);
		pb = NULL;
	}
}

//链表的查找
//按照学号查找
STU* link_search_num(STU* head, int num)
{
	STU* p_mov;
	//定义一个指针变量保存第一个结点的地址
	p_mov = head;
	//当没有到达最后一个结点的指针域时循环继续 
	while (p_mov != NULL)
	{
		//如果找到是当前结点的数据，则返回当前结点的地址
		if (p_mov->num == num)  //找到了
		{
			return p_mov;
		}
		//如果没有找到 则继续对比下一个结点的指针域
		p_mov = p_mov->next;
	}
	//当循环结束的时候还没有找到 说明要查找的数据不存在 返回NULL进行标识
	return NULL;  //没有找到
}

//按照姓名查找
STU* link_search_name(STU* head, char* name)
{
	STU* p_mov;
	//定义一个指针变量保存第一个结点的地址
	p_mov = head;
	//当没有到达最后一个结点的指针域时循环继续 
	while (p_mov != NULL)
	{
		//如果找到是当前结点的数据，则返回当前结点的地址
		if (strcmp(p_mov->name, name) == 0)  //找到了
		{
			return p_mov;
		}
		//如果没有找到 则继续对比下一个结点的指针域
		p_mov = p_mov->next;
	}
	//当循环结束的时候还没有找到 说明要查找的数据不存在 返回NULL进行标识
	return NULL;  //没有找到
}

//链表结点的删除
void link_detele_num(STU** p_head, int num)
{
	STU* pb, * pf;
	pb = pf = *p_head;
	if (*p_head == NULL)  //链表为空 不用删
	{
		printf("链表为空，没有您要删的结点");
		return;
	}
	while (pb->num != num && pb->next != NULL)  //循环找，要删除的结点
	{
		pf = pb;
		pb = pb->next;
	}
	if (pb->num == num) //找到了一个结点的num和num相同
	{
		if (pb == *p_head)  //要删除的是头结点
		{
			//让保存头结点的指针保存后一个结点的地址
			*p_head = pb->next;
		}
		else
		{
			//前一个结点的指针域保存要删除的后一个结点的地址
			pf->next = pb->next;
		}
		//释放空间
		free(pb);
		pb = NULL;
	}
	else //没有找到
	{
		printf("没有你要删除的结点\n");
	}


}

//链表排序
void link_order(STU* head)
{
	STU* pb, * pf, temp;
	pf = head;
	if (head == NULL)
	{
		printf("链表为空 不用排序\n");
		return;
	}
	if (head->next == NULL)
	{
		printf("链表为空 不用排序\n");
		return;
	}
	while (pf->next!=NULL) //以pf指向的结点为基准结点
	{
		pb = pf->next;  //pb从基准元素的下一个元素开始
		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;
	}
}


int main()
{
	STU* head = NULL, * p_new = NULL, * pb = NULL;
	int num, i;
	printf("请输入链表初始个数：");
	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);
	//link_free(&head);
	link_order(head);
	printf("排序后：\n");
	link_print(head);
}

结果：

请输入链表初始个数：3
请输入学号，分数，名字：
6 98 l
请输入学号，分数，名字：
3 9 j
请输入学号，分数，名字：
9 87 h
num=6 score=98 name=l
num=3 score=9 name=j
num=9 score=87 name=h
排序后：
num=3 score=9 name=j
num=6 score=98 name=l
num=9 score=87 name=h

双向链表：一个结点由一个数据域，两个指针域（保存上一个节点的地址 保存下一个结点的地址）

1.双向链表的创建和遍历
第一步：创建一个结点作为头结点 将两个指针域都保存NULL
第二步：先找到链表中的最后一个结点 然后让最后一个结点的指针域保存新节点插入结点的地址，新插入结点的两个指针域，一个保存上一个节点地址 一个保存NULL
代码8：（有点问题）

#include<stdio.h>
#include<stdlib.h>
#include<string.h>
#pragma warning(disable:4996)

//定义结构体
typedef struct student
{
	//数据域
	int num;
	int score;
	char name[20];
	//指针域
	struct student* front;//保存上一个结点的地址
	struct student* next; //保存下一个结点的地址
}STU;

void double_link_creat_head(STU** p_head, STU* p_new)
{
	STU* p_mov = *p_head;
	if (*p_head == NULL) //当第一次加入链表为空时，head执行p_new
	{
		*p_head = p_new;
		p_new->next = NULL;
		p_new->next = NULL;
	}
	else //第二次及以后加入链表
	{
		while (p_mov->next != NULL)
		{
			p_mov = p_mov->next; //找到原有链表的最后一个节点
		}
		p_mov->next = p_new;//将新申请的节点加入链表
		p_new->front = p_mov;
		p_new->next = NULL;
	}

}

//链表的遍历
void double_link_print(STU* head)
{
	STU* pb;
	pb = head;
	while (pb->next != NULL) //从头打印到尾
	{
		printf("num=%d score=%d name=%s \n", pb->num, pb->score, pb->name);
		pb = pb->next;
	}
	printf("num=%d score=%d name=%s \n", pb->num, pb->score, pb->name);
	printf("******************");
	while (pb != NULL) //从尾打印到头
	{
		printf("num=%d score=%d name=%s \n", pb->num, pb->score, pb->name);
		pb = pb->front;
	}
	
}

//链表的释放
void link_free(STU** p_head)
{
	//定义一个指针变量保存头指针的地址
	STU* pb = *p_head;

	while (*p_head != NULL)
	{
		//先保存p_head指向的结点的地址
		pb = *p_head;
		//p_head保存下一个结点的地址
		*p_head = (*p_head)->next;
		//释放结点并防止野指针
		free(pb);
		pb = NULL;
	}
}




//链表结点的删除
void link_detele_num(STU** p_head, int num)
{
	STU* pb, * pf;
	pb = pf = *p_head;
	if (*p_head == NULL)  //链表为空 不用删
	{
		printf("链表为空，没有您要删的结点");
		return;
	}
	while (pb->num != num && pb->next != NULL)  //循环找，要删除的结点
	{
		pf = pb;
		pb = pb->next;
	}
	if (pb->num == num) //找到了一个结点的num和num相同
	{
		if (pb == *p_head)  //要删除的是头结点
		{
			//让保存头结点的指针保存后一个结点的地址
			*p_head = pb->next;
		}
		else
		{
			//前一个结点的指针域保存要删除的后一个结点的地址
			pf->next = pb->next;
		}
		//释放空间
		free(pb);
		pb = NULL;
	}
	else //没有找到
	{
		printf("没有你要删除的结点\n");
	}


}




int main()
{
	STU* head = NULL, * p_new = NULL, * pb = NULL;
	int num, i;
	printf("请输入链表初始个数：");
	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);
		double_link_creat_head(&head, p_new);  //将节点加入新的链表
	}
	double_link_print(head);
	//link_free(&head);

}
liyaoliy
关注
C语言链表
future的博客
03-16 701
C语言链表 链表是一个非常重要的数据结构。更数组相比，它更加的灵活。关于链表的基本操作有： 创建（头插 和 尾插方法） 插入 删除 1、链表的创建之尾插法 首先，尾插法的方法创建。 tail-&gt;next = newPtr; tail = newPtr; 意思就是： 让tail这个尾节点，先指向head(头节点)，当有新节点创建时，让tail-&gt;next指针指向新节点（newPtr...
C语言链表存储查找节点,C语言之链表(示例代码)
weixin_36254564的博客
05-17 795
这两天在复习C语言的知识，为了给下个阶段学习OC做准备，以下的代码的编译运行环境是Xcode5.0版本，写篇博文把昨天复习的C语言有关链表的知识给大家分享一下，以下是小菜自己总结的内容，代码也是按照自己的思路所编写的，有不足之处还请大牛们批评指教。确切的说链表属于数据结构中线性表中的内容，在链表中存储的内容是按线性排列的，就像是一条线把所要存的数据串起来，可以把链表类比成一串珠子，数据就是一个个的...
c语言链表详解（超详细）
热门推荐
Endeavor_G的博客
06-03 63万+
链表是一种常见的基础数据结构，结构体指针在这里得到了充分的利用。链表可以动态的进行存储分配，也就是说，链表是一个功能极为强大的数组，他可以在节点中定义多种数据类型，还可以根据需要随意增添，删除，插入节点。链表都有一个头指针，一般以head来表示，存放的是一个地址。链表中的节点分为两类，头结点和一般节点，头结点是没有数据域的。链表中每个节点都分为两部分，一个数据域，一个是指针域。说到这里你应该就明白...
C语言—单链表
最新发布
2302_81120572的博客
10-06 2285
C语言—单链表
C语言 链表
m0_68484018的博客
02-27 3157
int data;int data;} Node;上面，我们定义了链表类型，那么我们如何创建链表变量呢，一般采用以下几步：通过调试器可以看到每个数据都是相互连接的。
C语言——链表
m0_62386635的博客
11-20 2万+
C语言——链表 链表是一种基础的数据结构类型，一种能够动态维护数据的线性数据表。链表的数据以结点形式存储信息，并通过结点之间的指针实现结点之间的衔接。 为什么要用链表？ 链表和数组类似，但是功能比数组强大得多，数组的空间是固定的，在定义数组的时候，数组的大小已经被固定，在使用时有可能会造成空间的浪费或者面临空间不够的风险，而链表的空间是动态的，则避免了这一问题。 我们来看最基础的单向链表： 1.首先要定义结构体作为链表的结点： typedef struct node { int data; struct
C语言—链表
weixin_73588765的博客
01-01 2万+
【C语言】—链表 创建,遍历,增删改查 链表是一种数据结构，是一种数据存放的思想；
C语言之链表HuffmanTree
03-27
本项目聚焦于C语言实现的链表HuffmanTree，这是一个基于链表数据结构和哈夫曼编码（Huffman Coding）理论的实现。下面我们将深入探讨相关知识点。 首先，链表是计算机科学中的一种基本数据结构，它由一系列节点组成...
C语言使用链表实现学生信息管理系统
08-25
C语言使用链表实现学生信息管理系统 该资源主要介绍了使用C语言和链表实现学生信息管理系统的方法，文中提供了详细的示例代码，展示了学生信息管理系统的实现过程。下面是该资源的知识点总结： 1.链表的基本概念：...
C语言之链表
weixin_41043617的博客
04-19 185
C语言之链表 链表是一种物理存储单元上非连续、非顺序的存储结构，数据元素的逻辑顺序是通过链表中的指针链接次序实现的。链表由一系列结点（链表中每一个元素称为结点）组成，结点可以在运行时动态生成。每个结点包括两个部分：一个是存储数据元素的数据域，另一个是存储下一个结点地址的指针域。 链表主程序 #include <stdio.h> #include<malloc.h> typedef struct node { int data; struct node * pNext
链表（C语言）
m0_72937472的博客
10-02 1578
本文章介绍了链表的基本结构及链表的增、删、查等功能。（因前后关联性比较强，建议一步步看）
C语言数据结构——链表
zcxmjw的博客
12-22 1万+
大家好，本篇文章主要带领大家了解一下什么是链表，链表的两个主要结构，以及链表和顺序表的差别。
C语言中的链表
Innocence网的博客
09-11 3847
链表，一种常见的数据结构。
【c语言】链表（完整版）
MING.MING的博客
03-20 3万+
c语言之链表（完整版）链表（完整版） 全国新增确诊连续两天为0 喜迎遍地飘零的时刻 海外游子也在回家 一起加油！ 链表（完整版） 此版包括以下功能： 链表创建、 头插、 尾插、 删除、 翻转、 删除相同元素、 遍历、 判断链表是否为空 以下为源码 若有不严谨的地方，欢迎指正 //链表创建、头插、尾插、删除、翻转、删除相同元素、遍历、判断链表是否为空 #include<stdio.h>...
C语言单向链表的表示与实现实例详解
12-31
C语言中的单向链表（单链表）是链表的一种，其特点是链表的链接方向是单向的，对链表的访问要通过顺序读取从头部开始。 链表中最简单的一种是单向链表，它包含两个域，一个信息域和一个指针域。这个链接指向列表中的...
关于c语言中链表
zimuHP的博客
10-07 302
关于c语言中链表的学习 萌新最近学习链表的时候，发现有很多回答都比较深奥，于是结合自己的学习分享给大家我所学的 前期所要知道的 1.1知道malloc函数的用法 https://baike.baidu.com/item/malloc函数/8582146?fr=aladdin 1.2与malloc对应的free函数的用法 https://baike.baidu.com/item/free()/984...
C语言链表---定义（1）
naturly的博客
05-06 5608
1、定义 链表是一种数据结构，采用动态分配存储单元方式，与数组相比，有效节省存储空间。 链表都有头指针变量head , 它用于存储指向链表的第一个元素，即用于存放链表第一个元素的地址。 链表中的每一个结点都包括数据域和指针域 链表尾指针指向NULL 注：链表的访问都是通过指针变量从头结点开始 用于链表中的结点是一个结构体类型，结点格式： struct 结构体名 { 定义数据成员；...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值