写一个函数insert，用来向一个动态链表插入节点。

最新推荐文章于 2022-12-17 23:01:20 发布
最新推荐文章于 2022-12-17 23:01:20 发布
阅读量3.9k 收藏 19
点赞数 6
分类专栏： C程序设计（第五版） 谭浩强 著 文章标签： c语言 指针 链表 算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/AKK188888881/article/details/105602327
版权

写一个函数insert，用来向一个动态链表插入节点。

方法一：

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

struct Student
{                       //声明结构体（双向链表结构体）
	int num;
	float score;
	struct Student *prev;
	struct Student *next;
};

struct Student *input();                     //声明输入函数
struct Student *insert(struct Student **stu, int m, char direc, struct Student *ins);   //声明插入函数
void print(struct Student *stu);             //声明输出函数

int main()
{
	struct Student *stud, in, *inser;        //定义结构体指针，插入的结构体变量，指向插入结构体变量的指针
	int insert_num;                   //定义要插入的结点学号
	char dir;                         //定义前插后插的方向变量
	stud=input();                     //调用输入函数
	print(stud);                      //输出全部数据
	printf("Please enter insert student info: ");      //输入要插入的学生数据（学号和成绩）
	scanf("%d %f", &in.num, &in.score);
	getchar();
	inser=&in;                        //结构体变量指针指向in
	printf("Please enter insert num: ");               //输入要插入哪个学号
	scanf("%d", &insert_num);
	getchar();
	printf("Please enter F or B: ");                   //输入是要插入学号前还是后，F是前插，B是后插。
	scanf("%c", &dir);
	getchar();
	stud=insert(&stud, insert_num, dir, inser);             //调用插入函数，并把返回值head赋值给stud 
	print(stud);
	return 0;
}

//输入函数
struct Student *input()
{
	struct Student *p1, *p2, *head;
	int n=0;
	p1=p2=(struct Student*)malloc(sizeof(struct Student));
	printf("Please enter No.%d student info: ", n+1);
	scanf("%d %f", &p1->num, &p1->score);
	getchar();
	head=NULL;
	while (p1->num!=0)
	{
		n++;
		if (n==1)
		{
			head=p1;
			p1->prev=NULL;
		}
		else
		{
			p2->next=p1;
			p1->prev=p2;
		}
		p2=p1;
		p1=(struct Student*)malloc(sizeof(struct Student));
		printf("Please enter No.%d student info: ", n+1);
		scanf("%d %f", &p1->num, &p1->score);
		getchar();
	}
	p2->next=NULL;
	return head;
}

//插入函数
struct Student *insert(struct Student **stu, int m, char direc, struct Student *ins)
{
	struct Student *p, *head;
	for (p=*stu, head=p; p!=NULL; p=p->next)
	{
		if (p->num==m)
		{
			if (direc=='F')
			{
				if (p==head)//若为第一个结构体数组 
				{
					ins->next=p;
					ins->prev=NULL;
					head->prev=ins;
					head=ins;
				}
				else
				{
					ins->prev=p->prev;
					p->prev->next=ins;
					ins->next=p;
					p->prev=ins;
				}
			}
			else if (direc=='B')
			{
				if (p->next==NULL)//若为最后一个结构体数组 
				{
					p->next=ins;
					ins->next=NULL;
					ins->prev=p;
				}
				else
				{
					ins->next=p->next;
					p->next=ins;
					ins->prev=p;
				}
			}
		}
	}
	return head;//返回值为head 
}

//输出函数
void print(struct Student *stu)
{
	struct Student *p;
	printf("Output Result:\n");
	for (p=stu; p!=NULL; p=p->next)
	{
		printf("%d %.2f\n", p->num, p->score);
	}
}

在VS2019下，需将源文件的scanf做些修改：

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

struct Student
{                       //声明结构体（双向链表结构体）
	int num;
	float score;
	struct Student* prev;
	struct Student* next;
};

struct Student* input();                     //声明输入函数
struct Student* insert(struct Student** stu, int m, char direc, struct Student* ins);   //声明插入函数
void print(struct Student* stu);             //声明输出函数

int main()
{
	struct Student* stud, in, * inser;        //定义结构体指针，插入的结构体变量，指向插入结构体变量的指针
	int insert_num;                   //定义要插入的结点学号
	char dir;                         //定义前插后插的方向变量
	stud = input();                     //调用输入函数
	print(stud);                      //输出全部数据
	printf("Please enter insert student info: ");      //输入要插入的学生数据（学号和成绩）
	scanf_s("%d %f", &in.num, &in.score);
	getchar();
	inser = &in;                        //结构体变量指针指向in
	printf("Please enter insert num: ");               //输入要插入哪个学号
	scanf_s("%d", &insert_num);
	getchar();
	printf("Please enter F or B: ");                   //输入是要插入学号前还是后，F是前插，B是后插。
	scanf_s("%c", &dir, (unsigned int)sizeof(char));
	getchar();
	stud = insert(&stud, insert_num, dir, inser);             //调用插入函数，并把返回值head赋值给stud 
	print(stud);
	return 0;
}

//输入函数
struct Student* input()
{
	struct Student* p1, * p2, * head;
	int n = 0;
	p1 = p2 = (struct Student*)malloc(sizeof(struct Student));
	printf("Please enter No.%d student info: ", n + 1);
	scanf_s("%d %f", &p1->num, &p1->score);
	getchar();
	head = NULL;
	while (p1->num != 0)
	{
		n++;
		if (n == 1)
		{
			head = p1;
			p1->prev = NULL;
		}
		else
		{
			p2->next = p1;
			p1->prev = p2;
		}
		p2 = p1;
		p1 = (struct Student*)malloc(sizeof(struct Student));
		printf("Please enter No.%d student info: ", n + 1);
		scanf_s("%d %f", &p1->num, &p1->score);
		getchar();
	}
	p2->next = NULL;
	return head;
}

//插入函数
struct Student* insert(struct Student** stu, int m, char direc, struct Student* ins)
{
	struct Student* p, * head;
	for (p = *stu, head = p; p != NULL; p = p->next)
	{
		if (p->num == m)
		{
			if (direc == 'F')
			{
				if (p == head)//若为第一个结构体数组 
				{
					ins->next = p;
					ins->prev = NULL;
					head->prev = ins;
					head = ins;
				}
				else
				{
					ins->prev = p->prev;
					p->prev->next = ins;
					ins->next = p;
					p->prev = ins;
				}
			}
			else if (direc == 'B')
			{
				if (p->next == NULL)//若为最后一个结构体数组 
				{
					p->next = ins;
					ins->next = NULL;
					ins->prev = p;
				}
				else
				{
					ins->next = p->next;
					p->next = ins;
					ins->prev = p;
				}
			}
		}
	}
	return head;//返回值为head 
}

//输出函数
void print(struct Student* stu)
{
	struct Student* p;
	printf("Output Result:\n");
	for (p = stu; p != NULL; p = p->next)
	{
		printf("%d %.2f\n", p->num, p->score);
	}
}

方法二：

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

struct Student
{                       //声明结构体（双向链表结构体）
	int num;
	float score;
	struct Student *prev;
	struct Student *next;
};

struct Student *input();                     //声明输入函数
void insert(struct Student **stu, int m, char direc, struct Student *ins);   //声明插入函数
void print(struct Student *stu);             //声明输出函数

int main()
{
	struct Student *stud, in, *inser;        //定义结构体指针，插入的结构体变量，指向插入结构体变量的指针
	int insert_num;                   //定义要插入的结点学号
	char dir;                         //定义前插后插的方向变量
	stud=input();                     //调用输入函数
	print(stud);                      //输出全部数据
	printf("Please enter insert student info: ");      //输入要插入的学生数据（学号和成绩）
	scanf("%d %f", &in.num, &in.score);
	getchar();
	inser=&in;                        //结构体变量指针指向in
	printf("Please enter insert num: ");               //输入要插入哪个学号
	scanf("%d", &insert_num);
	getchar();
	printf("Please enter F or B: ");                   //输入是要插入学号前还是后，F是前插，B是后插。
	scanf("%c", &dir);
	getchar();
	insert(&stud, insert_num, dir, inser);             //调用插入函数
	print(stud);
	return 0;
}

//输入函数
struct Student *input()
{
	struct Student *p1, *p2, *head;
	int n=0;
	p1=p2=(struct Student*)malloc(sizeof(struct Student));
	printf("Please enter No.%d student info: ", n+1);
	scanf("%d %f", &p1->num, &p1->score);
	getchar();
	head=NULL;
	while (p1->num!=0)
	{
		n++;
		if (n==1)
		{
			head=p1;
			p1->prev=NULL;
		}
		else
		{
			p2->next=p1;
			p1->prev=p2;
		}
		p2=p1;
		p1=(struct Student*)malloc(sizeof(struct Student));
		printf("Please enter No.%d student info: ", n+1);
		scanf("%d %f", &p1->num, &p1->score);
		getchar();
	}
	p2->next=NULL;
	return head;
}

//插入函数
void insert(struct Student **stu, int m, char direc, struct Student *ins)
{
	struct Student *p, *head, *front=NULL, *back=NULL;
	for (head=*stu, p=head; p!=NULL; p=p->next) 
	{
		if (p->num==m) 
		{
			if (direc=='F') 
			{
				front=p->prev;
				back=p;
			}
			else if (direc=='B') 
			{
				front=p;
				back=p->next;
			}
			if(head==back)
				head=ins;
			if(front!=NULL)
				front->next=ins;
			if(back!=NULL)
				back->prev=ins;
			ins->prev=front;
			ins->next=back;
		}
	}
	*stu=head;//因为stu指向stud，所以把head赋值给del函数里的*stu就是赋值给主函数main的stud
}

//输出函数
void print(struct Student *stu)
{
	struct Student *p;
	printf("Output Result:\n");
	for (p=stu; p!=NULL; p=p->next)
	{
		printf("%d %.2f\n", p->num, p->score);
	}
}

在VS2019下，需将源文件的scanf做些修改：

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

struct Student
{                       //声明结构体（双向链表结构体）
	int num;
	float score;
	struct Student* prev;
	struct Student* next;
};

struct Student* input();                     //声明输入函数
void insert(struct Student** stu, int m, char direc, struct Student* ins);   //声明插入函数
void print(struct Student* stu);             //声明输出函数

int main()
{
	struct Student* stud, in, * inser;        //定义结构体指针，插入的结构体变量，指向插入结构体变量的指针
	int insert_num;                   //定义要插入的结点学号
	char dir;                         //定义前插后插的方向变量
	stud = input();                     //调用输入函数
	print(stud);                      //输出全部数据
	printf("Please enter insert student info: ");      //输入要插入的学生数据（学号和成绩）
	scanf_s("%d %f", &in.num, &in.score);
	getchar();
	inser = &in;                        //结构体变量指针指向in
	printf("Please enter insert num: ");               //输入要插入哪个学号
	scanf_s("%d", &insert_num);
	getchar();
	printf("Please enter F or B: ");                   //输入是要插入学号前还是后，F是前插，B是后插。
	scanf_s("%c", &dir, (unsigned int)sizeof(char));
	getchar();
	insert(&stud, insert_num, dir, inser);             //调用插入函数
	print(stud);
	return 0;
}

//输入函数
struct Student* input()
{
	struct Student* p1, * p2, * head;
	int n = 0;
	p1 = p2 = (struct Student*)malloc(sizeof(struct Student));
	printf("Please enter No.%d student info: ", n + 1);
	scanf_s("%d %f", &p1->num, &p1->score);
	getchar();
	head = NULL;
	while (p1->num != 0)
	{
		n++;
		if (n == 1)
		{
			head = p1;
			p1->prev = NULL;
		}
		else
		{
			p2->next = p1;
			p1->prev = p2;
		}
		p2 = p1;
		p1 = (struct Student*)malloc(sizeof(struct Student));
		printf("Please enter No.%d student info: ", n + 1);
		scanf_s("%d %f", &p1->num, &p1->score);
		getchar();
	}
	p2->next = NULL;
	return head;
}

//插入函数
void insert(struct Student** stu, int m, char direc, struct Student* ins)
{
	struct Student* p, * head, * front=NULL, * back=NULL;
	for (head = *stu, p = head; p != NULL; p = p->next)
	{
		if (p->num == m)
		{
			if (direc == 'F')
			{
				front = p->prev;
				back = p;
			}
			else if (direc == 'B')
			{
				front = p;
				back = p->next;
			}
			if (head == back)
				head = ins;
			if (front != NULL)
				front->next = ins;
			if (back != NULL)
				back->prev = ins;
			ins->prev = front;
			ins->next = back;
		}
	}
	*stu = head;//因为stu指向stud，所以把head赋值给del函数里的*stu就是赋值给主函数main的stud
}

//输出函数
void print(struct Student* stu)
{
	struct Student* p;
	printf("Output Result:\n");
	for (p = stu; p != NULL; p = p->next)
	{
		printf("%d %.2f\n", p->num, p->score);
	}
}

方法三：

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

struct Student
{                       //声明结构体（双向链表结构体）
	int num;
	float score;
	struct Student *prev;
	struct Student *next;
};

struct Student *input();                     //声明输入函数
struct Student *insert(struct Student **stu, int m, char direc, struct Student *ins);   //声明插入函数
void print(struct Student *stu);             //声明输出函数

int main()
{
	struct Student *stud, in, *inser;        //定义结构体指针，插入的结构体变量，指向插入结构体变量的指针
	int insert_num;                   //定义要插入的结点学号
	char dir;                         //定义前插后插的方向变量
	stud=input();                     //调用输入函数
	print(stud);                      //输出全部数据
	printf("Please enter insert student info: ");      //输入要插入的学生数据（学号和成绩）
	scanf("%d %f", &in.num, &in.score);
	getchar();
	inser=&in;                        //结构体变量指针指向in
	printf("Please enter insert num: ");               //输入要插入哪个学号
	scanf("%d", &insert_num);
	getchar();
	printf("Please enter F or B: ");                   //输入是要插入学号前还是后，F是前插，B是后插。
	scanf("%c", &dir);
	getchar();
	stud=insert(&stud, insert_num, dir, inser);             //调用插入函数，并把返回值head赋值给stud 
	print(stud);
	return 0;
}

//输入函数
struct Student *input()
{
	struct Student *p1, *p2, *head;
	int n=0;
	p1=p2=(struct Student*)malloc(sizeof(struct Student));
	printf("Please enter No.%d student info: ", n+1);
	scanf("%d %f", &p1->num, &p1->score);
	getchar();
	head=NULL;
	while (p1->num!=0)
	{
		n++;
		if (n==1)
		{
			head=p1;
			p1->prev=NULL;
		}
		else
		{
			p2->next=p1;
			p1->prev=p2;
		}
		p2=p1;
		p1=(struct Student*)malloc(sizeof(struct Student));
		printf("Please enter No.%d student info: ", n+1);
		scanf("%d %f", &p1->num, &p1->score);
		getchar();
	}
	p2->next=NULL;
	return head;
}

//插入函数
struct Student *insert(struct Student **stu, int m, char direc, struct Student *ins)
{
	struct Student *p, *head, *front=NULL, *back=NULL;
	for (head=*stu, p=head; p!=NULL; p=p->next) 
	{
		if (p->num==m) 
		{
			if (direc=='F') 
			{
				front=p->prev;
				back=p;
			}
			else if (direc=='B') 
			{
				front=p;
				back=p->next;
			}
			if(head==back)
				head=ins;
			if(front!=NULL)
				front->next=ins;
			if(back!=NULL)
				back->prev=ins;
			ins->prev=front;
			ins->next=back;
		}
	}
	return head;//返回值为head 
}

//输出函数
void print(struct Student *stu)
{
	struct Student *p;
	printf("Output Result:\n");
	for (p=stu; p!=NULL; p=p->next)
	{
		printf("%d %.2f\n", p->num, p->score);
	}
}

在VS2019下，需将源文件的scanf做些修改：

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

struct Student
{                       //声明结构体（双向链表结构体）
	int num;
	float score;
	struct Student* prev;
	struct Student* next;
};

struct Student* input();                     //声明输入函数
struct Student* insert(struct Student** stu, int m, char direc, struct Student* ins);   //声明插入函数
void print(struct Student* stu);             //声明输出函数

int main()
{
	struct Student* stud, in, * inser;        //定义结构体指针，插入的结构体变量，指向插入结构体变量的指针
	int insert_num;                   //定义要插入的结点学号
	char dir;                         //定义前插后插的方向变量
	stud = input();                     //调用输入函数
	print(stud);                      //输出全部数据
	printf("Please enter insert student info: ");      //输入要插入的学生数据（学号和成绩）
	scanf_s("%d %f", &in.num, &in.score);
	getchar();
	inser = &in;                        //结构体变量指针指向in
	printf("Please enter insert num: ");               //输入要插入哪个学号
	scanf_s("%d", &insert_num);
	getchar();
	printf("Please enter F or B: ");                   //输入是要插入学号前还是后，F是前插，B是后插。
	scanf_s("%c", &dir, (unsigned int)sizeof(char));
	getchar();
	stud = insert(&stud, insert_num, dir, inser);             //调用插入函数，并把返回值head赋值给stud 
	print(stud);
	return 0;
}

//输入函数
struct Student* input()
{
	struct Student* p1, * p2, * head;
	int n = 0;
	p1 = p2 = (struct Student*)malloc(sizeof(struct Student));
	printf("Please enter No.%d student info: ", n + 1);
	scanf_s("%d %f", &p1->num, &p1->score);
	getchar();
	head = NULL;
	while (p1->num != 0)
	{
		n++;
		if (n == 1)
		{
			head = p1;
			p1->prev = NULL;
		}
		else
		{
			p2->next = p1;
			p1->prev = p2;
		}
		p2 = p1;
		p1 = (struct Student*)malloc(sizeof(struct Student));
		printf("Please enter No.%d student info: ", n + 1);
		scanf_s("%d %f", &p1->num, &p1->score);
		getchar();
	}
	p2->next = NULL;
	return head;
}

//插入函数
struct Student* insert(struct Student** stu, int m, char direc, struct Student* ins)
{
	struct Student* p, * head, * front=NULL, * back=NULL;
	for (head = *stu, p = head; p != NULL; p = p->next)
	{
		if (p->num == m)
		{
			if (direc == 'F')
			{
				front = p->prev;
				back = p;
			}
			else if (direc == 'B')
			{
				front = p;
				back = p->next;
			}
			if (head == back)
				head = ins;
			if (front != NULL)
				front->next = ins;
			if (back != NULL)
				back->prev = ins;
			ins->prev = front;
			ins->next = back;
		}
	}
	return head;//返回值为head 
}

//输出函数
void print(struct Student* stu)
{
	struct Student* p;
	printf("Output Result:\n");
	for (p = stu; p != NULL; p = p->next)
	{
		printf("%d %.2f\n", p->num, p->score);
	}
}

方法四：

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

struct Student
{                       //声明结构体（双向链表结构体）
	int num;
	float score;
	struct Student *prev;
	struct Student *next;
};

struct Student *input();                     //声明输入函数
void insert(struct Student **stu, int m, char direc, struct Student *ins);   //声明插入函数
void print(struct Student *stu);             //声明输出函数

int main()
{
	struct Student *stud, in, *inser;        //定义结构体指针，插入的结构体变量，指向插入结构体变量的指针
	int insert_num;                   //定义要插入的结点学号
	char dir;                         //定义前插后插的方向变量
	stud=input();                     //调用输入函数
	print(stud);                      //输出全部数据
	printf("Please enter insert student info: ");      //输入要插入的学生数据（学号和成绩）
	scanf("%d %f", &in.num, &in.score);
	getchar();
	inser=&in;                        //结构体变量指针指向in
	printf("Please enter insert num: ");               //输入要插入哪个学号
	scanf("%d", &insert_num);
	getchar();
	printf("Please enter F or B: ");                   //输入是要插入学号前还是后，F是前插，B是后插。
	scanf("%c", &dir);
	getchar();
	insert(&stud, insert_num, dir, inser);             //调用插入函数
	print(stud);
	return 0;
}

//输入函数
struct Student *input()
{
	struct Student *p1, *p2, *head;
	int n=0;
	p1=p2=(struct Student*)malloc(sizeof(struct Student));
	printf("Please enter No.%d student info: ", n+1);
	scanf("%d %f", &p1->num, &p1->score);
	getchar();
	head=NULL;
	while (p1->num!=0)
	{
		n++;
		if (n==1)
		{
			head=p1;
			p1->prev=NULL;
		}
		else
		{
			p2->next=p1;
			p1->prev=p2;
		}
		p2=p1;
		p1=(struct Student*)malloc(sizeof(struct Student));
		printf("Please enter No.%d student info: ", n+1);
		scanf("%d %f", &p1->num, &p1->score);
		getchar();
	}
	p2->next=NULL;
	return head;
}

//插入函数
void insert(struct Student **stu, int m, char direc, struct Student *ins)
{
	struct Student *p, *head, *front=NULL, *back=NULL;
	for (head=*stu, p=head; p!=NULL; p=p->next) 
	{
		if (p->num==m) 
		{
			if (direc=='F') 
			{
				front=p->prev;
				back=p;
			}
			else if (direc=='B') 
			{
				front=p;
				back=p->next;
			}
			if(head==back)
				head=ins;
			if(front!=NULL)
				front->next=ins;
			if(back!=NULL)
				back->prev=ins;
			ins->prev=front;
			ins->next=back;
		}
	}
	*stu=head;//因为stu指向stud，所以把head赋值给del函数里的*stu就是赋值给主函数main的stud
}

//输出函数
void print(struct Student *stu)
{
	struct Student *p;
	printf("Output Result:\n");
	for (p=stu; p!=NULL; p=p->next)
	{
		printf("%d %.2f\n", p->num, p->score);
	}
}

在VS2019下，需将源文件的scanf做些修改：

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

struct Student
{                       //声明结构体（双向链表结构体）
	int num;
	float score;
	struct Student* prev;
	struct Student* next;
};

struct Student* input();                     //声明输入函数
void insert(struct Student** stu, int m, char direc, struct Student* ins);   //声明插入函数
void print(struct Student* stu);             //声明输出函数

int main()
{
	struct Student* stud, in, * inser;        //定义结构体指针，插入的结构体变量，指向插入结构体变量的指针
	int insert_num;                   //定义要插入的结点学号
	char dir;                         //定义前插后插的方向变量
	stud = input();                     //调用输入函数
	print(stud);                      //输出全部数据
	printf("Please enter insert student info: ");      //输入要插入的学生数据（学号和成绩）
	scanf_s("%d %f", &in.num, &in.score);
	getchar();
	inser = &in;                        //结构体变量指针指向in
	printf("Please enter insert num: ");               //输入要插入哪个学号
	scanf_s("%d", &insert_num);
	getchar();
	printf("Please enter F or B: ");                   //输入是要插入学号前还是后，F是前插，B是后插。
	scanf_s("%c", &dir, (unsigned int)sizeof(char));
	getchar();
	insert(&stud, insert_num, dir, inser);             //调用插入函数
	print(stud);
	return 0;
}

//输入函数
struct Student* input()
{
	struct Student* p1, * p2, * head;
	int n = 0;
	p1 = p2 = (struct Student*)malloc(sizeof(struct Student));
	printf("Please enter No.%d student info: ", n + 1);
	scanf_s("%d %f", &p1->num, &p1->score);
	getchar();
	head = NULL;
	while (p1->num != 0)
	{
		n++;
		if (n == 1)
		{
			head = p1;
			p1->prev = NULL;
		}
		else
		{
			p2->next = p1;
			p1->prev = p2;
		}
		p2 = p1;
		p1 = (struct Student*)malloc(sizeof(struct Student));
		printf("Please enter No.%d student info: ", n + 1);
		scanf_s("%d %f", &p1->num, &p1->score);
		getchar();
	}
	p2->next = NULL;
	return head;
}

//插入函数
void insert(struct Student** stu, int m, char direc, struct Student* ins)
{
	struct Student* p, * head, * front = NULL, * back = NULL;
	for (head = *stu, p = head; p != NULL; p = p->next)
	{
		if (p->num == m)
		{
			if (direc == 'F')
			{
				front = p->prev;
				back = p;
			}
			else if (direc == 'B')
			{
				front = p;
				back = p->next;
			}
			if (head == back)
				head = ins;
			if (front != NULL)
				front->next = ins;
			if (back != NULL)
				back->prev = ins;
			ins->prev = front;
			ins->next = back;
		}
	}
	*stu = head;//因为stu指向stud，所以把head赋值给del函数里的*stu就是赋值给主函数main的stud
}

//输出函数
void print(struct Student* stu)
{
	struct Student* p;
	printf("Output Result:\n");
	for (p = stu; p != NULL; p = p->next)
	{
		printf("%d %.2f\n", p->num, p->score);
	}
}

方法五：

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

struct Student
{                       //声明结构体（双向链表结构体）
	int num;
	float score;
	struct Student *prev;
	struct Student *next;
};

struct Student *input();                     //声明输入函数
void insert(struct Student **stu, int m, char direc, struct Student *ins);   //声明插入函数
void print(struct Student *stu);             //声明输出函数

int main()
{
	struct Student *stud, in, *inser;        //定义结构体指针，插入的结构体变量，指向插入结构体变量的指针
	int insert_num;                   //定义要插入的结点学号
	char dir;                         //定义前插后插的方向变量
	stud=input();                     //调用输入函数
	print(stud);                      //输出全部数据
	printf("Please enter insert student info: ");      //输入要插入的学生数据（学号和成绩）
	scanf("%d %f", &in.num, &in.score);
	getchar();
	inser=&in;                        //结构体变量指针指向in
	printf("Please enter insert num: ");               //输入要插入哪个学号
	scanf("%d", &insert_num);
	getchar();
	printf("Please enter F or B: ");                   //输入是要插入学号前还是后，F是前插，B是后插。
	scanf("%c", &dir);
	getchar();
	insert(&stud, insert_num, dir, inser);             //调用插入函数
	print(stud);
	return 0;
}

//输入函数
struct Student *input()
{
	struct Student *p1, *p2, *head;
	int n=0;
	p1=p2=(struct Student*)malloc(sizeof(struct Student));
	printf("Please enter No.%d student info: ", n+1);
	scanf("%d %f", &p1->num, &p1->score);
	getchar();
	head=NULL;
	while (p1->num!=0)
	{
		n++;
		if (n==1)
		{
			head=p1;
			p1->prev=NULL;
		}
		else
		{
			p2->next=p1;
			p1->prev=p2;
		}
		p2=p1;
		p1=(struct Student*)malloc(sizeof(struct Student));
		printf("Please enter No.%d student info: ", n+1);
		scanf("%d %f", &p1->num, &p1->score);
		getchar();
	}
	p2->next=NULL;
	return head;
}

//插入函数
void insert(struct Student **head, int m, char direc, struct Student *ins)//head指向stud，修改*head就是修改stud 
{
	struct Student *p, *front=NULL, *back=NULL;
	for (p=*head; p!=NULL; p=p->next) 
	{
		if (p->num==m) 
		{
			if (direc=='F') 
			{
				front=p->prev;
				back=p;
			}
			else if (direc=='B') 
			{
				front=p;
				back=p->next;
			}
			if(*head==back)
				*head=ins;
			if(front!=NULL)
				front->next=ins;
			if(back!=NULL)
				back->prev=ins;
			ins->prev=front;
			ins->next=back;
		}
	}
}

//输出函数
void print(struct Student *stu)
{
	struct Student *p;
	printf("Output Result:\n");
	for (p=stu; p!=NULL; p=p->next)
	{
		printf("%d %.2f\n", p->num, p->score);
	}
}

在VS2019下，需将源文件的scanf做些修改：

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

struct Student
{                       //声明结构体（双向链表结构体）
	int num;
	float score;
	struct Student* prev;
	struct Student* next;
};

struct Student* input();                     //声明输入函数
void insert(struct Student** stu, int m, char direc, struct Student* ins);   //声明插入函数
void print(struct Student* stu);             //声明输出函数

int main()
{
	struct Student* stud, in, * inser;        //定义结构体指针，插入的结构体变量，指向插入结构体变量的指针
	int insert_num;                   //定义要插入的结点学号
	char dir;                         //定义前插后插的方向变量
	stud = input();                     //调用输入函数
	print(stud);                      //输出全部数据
	printf("Please enter insert student info: ");      //输入要插入的学生数据（学号和成绩）
	scanf_s("%d %f", &in.num, &in.score);
	getchar();
	inser = &in;                        //结构体变量指针指向in
	printf("Please enter insert num: ");               //输入要插入哪个学号
	scanf_s("%d", &insert_num);
	getchar();
	printf("Please enter F or B: ");                   //输入是要插入学号前还是后，F是前插，B是后插。
	scanf_s("%c", &dir, (unsigned int)sizeof(char));
	getchar();
	insert(&stud, insert_num, dir, inser);             //调用插入函数
	print(stud);
	return 0;
}

//输入函数
struct Student* input()
{
	struct Student* p1, * p2, * head;
	int n = 0;
	p1 = p2 = (struct Student*)malloc(sizeof(struct Student));
	printf("Please enter No.%d student info: ", n + 1);
	scanf_s("%d %f", &p1->num, &p1->score);
	getchar();
	head = NULL;
	while (p1->num != 0)
	{
		n++;
		if (n == 1)
		{
			head = p1;
			p1->prev = NULL;
		}
		else
		{
			p2->next = p1;
			p1->prev = p2;
		}
		p2 = p1;
		p1 = (struct Student*)malloc(sizeof(struct Student));
		printf("Please enter No.%d student info: ", n + 1);
		scanf_s("%d %f", &p1->num, &p1->score);
		getchar();
	}
	p2->next = NULL;
	return head;
}

//插入函数
void insert(struct Student** head, int m, char direc, struct Student* ins)//head指向stud，修改*head就是修改stud 
{
	struct Student* p, * front = NULL, * back = NULL;
	for (p = *head; p != NULL; p = p->next)
	{
		if (p->num == m)
		{
			if (direc == 'F')
			{
				front = p->prev;
				back = p;
			}
			else if (direc == 'B')
			{
				front = p;
				back = p->next;
			}
			if (*head == back)
				*head = ins;
			if (front != NULL)
				front->next = ins;
			if (back != NULL)
				back->prev = ins;
			ins->prev = front;
			ins->next = back;
		}
	}
}

//输出函数
void print(struct Student* stu)
{
	struct Student* p;
	printf("Output Result:\n");
	for (p = stu; p != NULL; p = p->next)
	{
		printf("%d %.2f\n", p->num, p->score);
	}
}
AKK188888881
关注
  • 6
    点赞
  • 踩
  • 19
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
依旧链表练习——完成insert函数功能：将n值插入链表，保证链表升序；
yooppa的博客
09-24 477
最近 因为迫于数据结构的压力 Java的学习进度暂停… node * insert(node * head, int n) { int temp=0; node * p = head->next; node * s = (node *)malloc(sizeof(node)); node * p1=NULL,* p2=NULL,* pend=NULL; s->data = n; //完成代码，将n值插入链表，并保证链表有序（升序），如还需要定义变量，可在前面添加 s-&g
c语言insert作用,写一个函数insert,用来向一个动态链表插入结点。 C语言
weixin_32955207的博客
05-16 2477
C语言 写一个函数insert,用来向一个动态链表插入结点。【c源程序】#include struct student{long num;float score;struct student*next;};int n;struct student *insert(struct student *head,struct student *stud){struct student *p0,*p1,*p...
9.8写一个函数insert，用来向一个动态链表插入结点
weixin_44589540的博客
01-29 5908
//C程序设计第四版（谭浩强） //章节：第九章 用户自己建立数据类型 //题号：9.8 //题目:写一个函数insert，用来向一个动态链表插入结点 #include &lt;stdio.h&gt; #include &lt;stdlib.h&gt; struct node { int data; struct node *next; }; struct node *insert(str...
C语言程序设计第四版(谭浩强）9.8 写一个函数insert,用来向一个动态链表插入结点。
冰糖的博客
06-04 1560
//*作者：冰糖 //*日期：2018年12月1日 //*章节：第九章 //*题号：8 //*题目：写一个函数insert,用来向一个动态链表插入结点。 #include<stdio.h> #include<stdlib.h> struct student { int num; char name[20]; float score[3]; float aver; struct student *next; }; int main() { void insert(stru
(C语言)写一个函数insert,用来向一个动态链表插入节点
爱上小公举
05-11 9591
写一个函数insert,用来向一个动态链表插入节点
链表_链表_用链表将两个数组升序合并到另一个数组_
10-02
接着，我们需要实现一个链表类，包括插入节点、遍历链表等基本操作。例如，`SqList`类可以这样设计： ```cpp class SqList { public: ListNode* head; // 链表头节点 SqList() : head(NULL) {} // 构造函数 ...
一个链表的实现（插入 删除）
06-26
`deleteNode` 函数则需要找到目标节点并将其从链表中移除，这涉及到修改前一个节点的指针指向目标节点的下一个节点： ```c void deleteNode(ListNode **head, int target) { ListNode *current = *head; ListNode...
用链表做一个拥有查找、插入、删除、排序的功能程序
01-06
在这个程序设计任务中，我们使用链表来实现一个具备查找、插入、删除和排序功能的程序。下面将详细阐述各个知识点。 1. **链表结构**： 链表由一系列节点组成，每个节点包含数据和指向下一个节点的指针。在C语言中...
lianbiao.rar_链表插入 java
09-20
`insert`方法用于在链表末尾插入新节点，而`insertAt`方法则允许在指定位置插入节点。注意，`insertAt`方法会检查索引是否有效，避免出现数组越界异常。 要使用这个链表实现，你可以创建一个`LinkedList`对象，然后...
用C语言创建一个单链表的方法
最新发布
10-18
定义链表的插入函数，用于在链表末尾插入节点： void insert(Node** head, int data) { Node* newNode = (Node*)malloc(sizeof(Node)); // 创建新节点 newNode->data = data; // 设置新节点的数据值 newNode->...
写一个函数insert,用来向一个动态链表插入结点
月已满西楼的博客
06-08 2334
写一个函数insert,用来向一个动态链表插入结点 #include <stdio.h> #include <stdlib.h> typedef struct LNode { int num; struct LNode *next; } LNode; void insert(int n, LNode *node) { //创建新节点 LNode *newNode = (LNode *)malloc(sizeof(LNode)); newNode->num = n;
c语言insertTai函数怎么用,写一个函数insert,用来向一个动态链表插入结点。 C语言...
weixin_28839629的博客
05-20 378
C语言 写一个函数insert,用来向一个动态链表插入结点。【c源程序】#include struct student{long num;float score;struct student*next;};int n;struct student *insert(struct student *head,struct student *stud){struct student *p0,*p1,*p...
编写函数，向链表的尾部插入数据建立一个链表。
夕阳之歌的博客
06-12 1057
#include<stdio.h> #include<stdlib.h> struct node { int x; struct node *next; }; //尾插法： void insert_tail(struct node *H,int n) { struct node * temp= (struct node*)malloc(sizeof(struct node)); //temp 就是我们要插入的结点 struct node * p;//这里不需要申请
编写链表按序插入结点的insert函数。并通过循环，在测试用的主函数中随机生成100个整数，用insert插入链表之中。
hello.尘心
08-09 378
编写链表按序插入结点的insert函数。并通过循环，在测试用的主函数中随机生成100个整数，用insert插入链表之中。 #include<stdio.h> #include<stdlib.h> #include<time.h> //定义结构体 typedef struct LNode { int data; struct LNode *next; }LNode; //定义返回链表头指针的insert函数 LNode *insert(LNode *head,
有序链表的插入函数
pcb931126的博客
06-16 1413
创建一个节点 typedef struct NODE { struct NODE *link; int value; }Node; 调用有序链表的插入函数： //插入到一个有序链表。函数的参数是一个指向链表根指针的指针，以及一个需要插入的新值 result=sll_insert(&root,12); 插入函数1 #include <st...
c语言 运用函数实现单向链表的创建，添加节点和插入节点（头插入，中间插入，尾插入）
weixin_44592938的博客
08-11 2458
链表的创建： 基本元素为： 两个关键： 1、结构体变量； 2、与结构体同种类型的指针； 添加节点：（添加至链表尾部） 定义一个空类型的函数，形参为头指针，尾指针，和结构体中所含变量（举我自己的代码为例子：仅有一个变量id），声明一个同种类型的结构体指针，将其放在堆区开辟新的空间，传入参数，新创建的结构体指针指向NULL； 然后分两种情况：1、头指针为空，那么新创建指针的地址传给头指针 新创建指针的...
子函数插入头结点链表
u010068275的专栏
10-23 441
为了在链表的起始位置插入一个结点，函数必须
用函数实现链表的创建、输出、删除、插入
m0_51196956的博客
12-17 886
插入模式可选首端和末端，插入首端的话需要从新返回链表首地址，因此需要返回值，同时需要结点的信息一并传入函数，再由mallco()函数开辟新空间，接受相应数据。函数考虑两种情况，及删除的结点为第一项，和为结点的其他项，因此函数有返回类型，并且传入两个参数。链表的首地址，和需要删除结点的信息。接着看函数内部，变量为四个Peo*类型指针，其中p3作用是记录上一个结构体变量地址，当输入0使，使p3为链表最后一项。先看函数，不含参数，有返回值，返回值类型是 Peo*类型指针，Peo为我们创建的结构体类型。
链表
weixin_42272882的博客
02-22 253
一、链表 1.链表即为线性表的链式存储结构，逻辑上相邻的元素在物理上不相邻。   2.通过指针来实现元素之间的逻辑关系，一个链表由数据域和指针域构成。   3.相对于顺序表，链表不能实现随机存储，查找元素需要从头开始遍历；但是链表在对元素进行插入和删除操作时，不需要移动元素，并且不需要分配连续的储存空间。 二、链表的实现 链表是一种递归的数据结构，要么为空，要么指向下一个结点。定义一...
c语言写一个函数insert，用来向一个动态链表插入节点
05-15
下面是一个示例代码，实现在动态链表中插入节点的功能： ```c struct Node { int data; struct Node* next; }; void insert(struct Node** head_ref, int new_data) { struct Node* new_node = (struct Node*)...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值