数据结构(c语言版) 链表(单链表、双链表、循环单链表、循环双链表)

news/2024/11/15 7:00:14/

作业一（单链表）

单链表的创建，增加，插入，查找，删除操作, 单链表集合的做差，交集，并集操作

代码

#include <stdio.h>
#include <malloc.h>//定义结构体类型
struct ListNode{int element;struct ListNode * next;
};//初始化结构体
void initList(struct ListNode * head){head->next = NULL;
}/**************************  插入操作  ******************************/
//插入新结点操作，头插法
void insertNode_t(struct ListNode* head, int value){if(head==NULL){printf("没有头节点，插入数据失败");return;}struct ListNode* cur = head;struct ListNode* NewNode = malloc(sizeof(struct ListNode));NewNode->next = cur->next;NewNode->element = value;cur->next = NewNode;
}//插入新结点操作,尾插法
void insertNode_w(struct ListNode* head, int value){if(head==NULL){printf("没有头节点，插入数据失败");return;}struct ListNode* cur = head;while(cur->next != NULL){cur = cur->next;}struct ListNode* NewNode =  malloc(sizeof(struct ListNode));NewNode->next = NULL;NewNode->element = value;cur->next = NewNode;
}//插入新结点操作，定位后插法
void insertNode_dh(struct ListNode* head, int index, int value){if(head==NULL){printf("没有头节点，插入数据失败\n");return;}if(index<1){printf("插入位置非法！\n");return;}while(--index){head = head->next;if(head == NULL){printf("插入失败：插入位置超出链表长度\n");return;}}struct ListNode* NewNode = malloc(sizeof(struct ListNode));if(NewNode == NULL){printf("插入失败：创建新结点失败\n");}NewNode->next = head->next;NewNode->element = value;head->next = NewNode;}/**************************  查找操作  ******************************/
//按值查询数据位置
void findNode_z(struct ListNode* head, int value){int index = 0;int flag = 0;while(head != NULL){if(head->element == value){printf("查找成功：数字%d在第 %d 位\n",value, index);flag = 1;}index ++;head = head->next;}if(flag == 0){printf("未查找到数据%d", value);}
}//按位置查找数据
void findNode_v(struct ListNode* head, int index){if(index < 1){printf("查找失败：输入的查询位置非法！\n");return;}int temp = 1;int flag = 0;while(head->next != NULL){if(temp == index){printf("查找成功：第%d位的数字为 %d \n",index, head->next->element);flag = 1;}temp ++;head = head->next;}if(flag == 0){printf("查找失败：输入的查询位置超过链表长度！\n");}
}/**************************  删除操作  ******************************/
//按位置删除
void deleteNode_w(struct ListNode* head, int index){if(index < 1){printf("删除失败：删除位置非法！\n");return;}while (--index){head = head->next;if(head->next == NULL){printf("删除失败：删除位置越界！\n");return;}}struct ListNode* temp = head->next;head->next = head->next->next;free(temp);printf("删除成功!\n");
}//按值删除
void deleteNode_z(struct ListNode* head, int value){if(head == NULL){printf("删除失败：传入的结点不存在！\n");}while (head->next->element != value){head = head->next;if(head->next == NULL){printf("删除的元素不在该单链表中！\n");return;}}struct ListNode* temp = head->next;head->next = head->next->next;free(temp);printf("删除成功!\n");
}/**************************  显示打印操作  ******************************/
//打印
void printfList(struct ListNode* head){int index = 1;struct ListNode* L = head->next;while(L != NULL){printf("第%d个节点上的数据为%d\n",index, L->element);index ++;L = L->next;}
}/**************************  集合问题操作  ******************************/
//集合做差：LA - LB
void set_deviation(struct ListNode* LA, struct ListNode* LB){struct ListNode* La = LA;while (La->next != NULL){struct ListNode* temp = La->next;int Adata = La->next->element;int flag=0;struct ListNode* Lb =LB;while (Lb->next != NULL){if(Lb->next->element == Adata){flag = 1;break;}Lb = Lb->next;}if(flag == 1){La->next = La->next->next;free(temp);continue;}La = La->next;}
}//集合做并集
void set_union(struct ListNode* LA, struct ListNode* LB, struct ListNode* LC){while (LA->next != NULL){int Adata = LA->next->element;int flag = 0;struct ListNode* Lb = LB;while (Lb->next != NULL){if(Lb->next->element == Adata){flag = 1;break;}Lb = Lb->next;}if(flag==0){struct ListNode* NewNode = malloc(sizeof(struct ListNode));NewNode->element = LA->next->element;NewNode->next = NULL;LC->next = NewNode;LC = LC->next;}LA = LA->next;}while(LB->next != NULL){struct ListNode* NewNode = malloc(sizeof(struct ListNode));NewNode->element = LB->next->element;NewNode->next = NULL;LC->next = NewNode;LC = LC->next;LB = LB->next;}}//集合做交集
void set_intersection(struct ListNode* LA, struct ListNode* LB, struct ListNode* LC){while (LA->next != NULL){int Adata = LA->next->element;int flag = 0;struct ListNode* Lb = LB;while (Lb->next != NULL){if(Lb->next->element == Adata){flag = 1;break;}Lb = Lb->next;}if(flag==1){struct ListNode* NewNode = malloc(sizeof(struct ListNode));NewNode->element = LA->next->element;NewNode->next = NULL;LC->next = NewNode;LC = LC->next;}LA = LA->next;}
}int main(){//创建头节点struct ListNode head;//初始化initList(&head);//头插入数据printf("********头插入数据*********\n");while (1){int value;printf("请输入需要插入单链表Lhead的数值（输入666则退出）：");scanf("%d",&value);if(value == 666){break;}insertNode_t(&head, value);}printfList(&head);//尾插入数据printf("\n********尾插入数据*********\n");while (1){int value;printf("请输入需要插入单链表Lhead的数值（输入666则退出）：");scanf("%d",&value);if(value == 666){break;}insertNode_w(&head, value);}printfList(&head);//定位后插法printf("\n********定位后插法*********\n");int index_1;int value_1;printf("请输入需要插入的位置：");scanf("%d",&index_1);printf("请输入需要插入单链表Lhead的数值：");scanf("%d",&value_1);insertNode_dh(&head, index_1, value_1);printfList(&head);//按值查询数据的位置printf("\n********按值查询数据的位置*********\n");int value_2;printf("请输入需要查询的数值：");scanf("%d",&value_2);findNode_z(&head, value_2);//按位置查找数据printf("\n********按位置查找数据*********\n");int value_3;printf("请输入需要查询的位置：");scanf("%d",&value_3);findNode_v(&head, value_3);//按位置删除元素printf("\n********按位置删除数据*********\n");int value_4;printf("请输入需要删除的位置：");scanf("%d",&value_4);deleteNode_w(&head, value_4);printfList(&head);//按值删除元素printf("\n********按值删除数据*********\n");int value_5;printf("请输入需要删除的数值：");scanf("%d",&value_5);deleteNode_z(&head, value_5);printfList(&head);//集合操作printf("\n********集合差操作*********\n");//创建头节点struct ListNode LA;struct ListNode LB;struct ListNode LC;//初始化initList(&LA);initList(&LB);initList(&LC);printf("LA的单链表：\n");while (1){int value;printf("请输入需要插入单链表LA的数据（输入666则结束）：");scanf("%d",&value);if(value == 666){break;}insertNode_w(&LA,value);}printfList(&LA);printf("\n");printf("LB的单链表：\n");while (1){int value;printf("请输入需要插入单链表LB的数据（输入666则结束）：");scanf("%d",&value);if(value == 666){break;}insertNode_w(&LB,value);}printfList(&LB);printf("\n");//集合做差printf("集合做差的结果：\n");set_deviation(&LA, &LB);printfList(&LA);//集合做并集printf("集合做并集的结果：\n");set_union(&LA,&LB,&LC);printfList(&LC);//集合做交集printf("集合做交集的结果：\n");set_intersection(&LA,&LB,&LC);printfList(&LC);
}

运行结果

********头插入数据*********
请输入需要插入单链表Lhead的数值（输入666则退出）：11
请输入需要插入单链表Lhead的数值（输入666则退出）：22
请输入需要插入单链表Lhead的数值（输入666则退出）：33
请输入需要插入单链表Lhead的数值（输入666则退出）：44
请输入需要插入单链表Lhead的数值（输入666则退出）：55
请输入需要插入单链表Lhead的数值（输入666则退出）：666
第1个节点上的数据为55
第2个节点上的数据为44
第3个节点上的数据为33
第4个节点上的数据为22
第5个节点上的数据为11********尾插入数据*********
请输入需要插入单链表Lhead的数值（输入666则退出）：100
请输入需要插入单链表Lhead的数值（输入666则退出）：666
第1个节点上的数据为55
第2个节点上的数据为44
第3个节点上的数据为33
第4个节点上的数据为22
第5个节点上的数据为11
第6个节点上的数据为100********定位前插法*********
请输入需要插入的位置：1
请输入需要插入单链表Lhead的数值：200
第1个节点上的数据为200
第2个节点上的数据为55
第3个节点上的数据为44
第4个节点上的数据为33
第5个节点上的数据为22
第6个节点上的数据为11
第7个节点上的数据为100********按值查询数据的位置*********
请输入需要查询的数值：22
查找成功：数字22在第 5 位********按位置查找数据*********
请输入需要查询的位置：3
查找成功：第3位的数字为 44********按位置删除数据*********
请输入需要删除的位置：1
删除成功!
第1个节点上的数据为55
第2个节点上的数据为44
第3个节点上的数据为33
第4个节点上的数据为22
第5个节点上的数据为11
第6个节点上的数据为100********按值删除数据*********
请输入需要删除的数值：11
删除成功!
第1个节点上的数据为55
第2个节点上的数据为44
第3个节点上的数据为33
第4个节点上的数据为22
第5个节点上的数据为100********集合差操作*********
LA的单链表：
请输入需要插入单链表LA的数据（输入666则结束）：1
请输入需要插入单链表LA的数据（输入666则结束）：2
请输入需要插入单链表LA的数据（输入666则结束）：3
请输入需要插入单链表LA的数据（输入666则结束）：4
请输入需要插入单链表LA的数据（输入666则结束）：5
请输入需要插入单链表LA的数据（输入666则结束）：6
请输入需要插入单链表LA的数据（输入666则结束）：7
请输入需要插入单链表LA的数据（输入666则结束）：666
第1个节点上的数据为1
第2个节点上的数据为2
第3个节点上的数据为3
第4个节点上的数据为4
第5个节点上的数据为5
第6个节点上的数据为6
第7个节点上的数据为7LB的单链表：
请输入需要插入单链表LB的数据（输入666则结束）：10
请输入需要插入单链表LB的数据（输入666则结束）：20
请输入需要插入单链表LB的数
据（输入666则结束）：30
请输入需要插入单链表LB的数据（输入666则结束）：40
请输入需要插入单链表LB的数据（输入666则结束）：50
请输入需要插入单链表LB的数据（输入666则结束）：666
第1个节点上的数据为10
第2个节点上的数据为20
第3个节点上的数据为30
第4个节点上的数据为40
第5个节点上的数据为50集合做差的结果：
第1个节点上的数据为1
第2个节点上的数据为2
第3个节点上的数据为3
第4个节点上的数据为4
第5个节点上的数据为5
第6个节点上的数据为6
第7个节点上的数据为7集合做并集的结果：
第1个节点上的数据为1
第2个节点上的数据为2
第3个节点上的数据为3
第4个节点上的数据为4
第5个节点上的数据为5
第6个节点上的数据为6
第7个节点上的数据为7
第8个节点上的数据为10
第9个节点上的数据为20
第10个节点上的数据为30
第11个节点上的数据为40
第12个节点上的数据为50集合做交集的结果：
第1个节点上的数据为1
第2个节点上的数据为2
第3个节点上的数据为3
第4个节点上的数据为4
第5个节点上的数据为5
第6个节点上的数据为6
第7个节点上的数据为7
第8个节点上的数据为10
第9个节点上的数据为20
第10个节点上的数据为30
第11个节点上的数据为40
第12个节点上的数据为50进程已结束，退出代码为 0

作业二（循环单链表）

两个循环单链表的合并

代码

#include <stdio.h>
#include <malloc.h>//定义结构体类型
struct ListNode{int element;struct ListNode * next;
};//初始化结构体
void initList(struct ListNode * head){head->next = head;
}//插入新结点操作,尾插法
void insertNode_w(struct ListNode* head, int value){if(head==NULL){printf("没有头节点，插入数据失败");return;}struct ListNode* cur = head;while(cur->next != head){cur = cur->next;}struct ListNode* NewNode =  malloc(sizeof(struct ListNode));NewNode->next = head;NewNode->element = value;cur->next = NewNode;
}//打印
void printfList(struct ListNode* head){int index = 1;struct ListNode* L = head->next;while(L != head){printf("第%d个节点上的数据为%d\n",index, L->element);index ++;L = L->next;}
}//合并
void merge(struct ListNode* LA, struct ListNode* LB){struct ListNode* L1 = LA;while (L1->next != LA ){L1 = L1->next;}L1->next = LB->next;while (L1->next != LB){L1 = L1->next;}L1->next = LA;
}int main() {//创建头节点struct ListNode LA;struct ListNode LB;//初始化initList(&LA);initList(&LB);//头插入数据printf("********头插入数据*********\n");for(int i=1; i < 10; i++){insertNode_w(&LA, i);}printf("LA的链表是：\n");printfList(&LA);for(int i=1; i < 10; i++){insertNode_w(&LB, i*10);}printf("LB的链表是：\n");printfList(&LB);printf("合并结果：\n");merge(&LA, &LB);printfList(&LA);
}

运行结果

********头插入数据*********
LA的链表是：
第1个节点上的数据为1
第2个节点上的数据为2
第3个节点上的数据为3
第4个节点上的数据为4
第5个节点上的数据为5
第6个节点上的数据为6
第7个节点上的数据为7
第8个节点上的数据为8
第9个节点上的数据为9
LB的链表是：
第1个节点上的数据为10
第2个节点上的数据为20
第3个节点上的数据为30
第4个节点上的数据为40
第5个节点上的数据为50
第6个节点上的数据为60
第7个节点上的数据为70
第8个节点上的数据为80
第9个节点上的数据为90
合并结果：
第1个节点上的数据为1
第2个节点上的数据为2
第3个节点上的数据为3
第4个节点上的数据为4
第5个节点上的数据为5
第6个节点上的数据为6
第7个节点上的数据为7
第8个节点上的数据为8
第9个节点上的数据为9
第10个节点上的数据为10
第11个节点上的数据为20
第12个节点上的数据为30
第13个节点上的数据为40
第14个节点上的数据为50
第15个节点上的数据为60
第16个节点上的数据为70
第17个节点上的数据为80
第18个节点上的数据为90

作业三（多项式相加）

单链表实现两个多项式相加，并输出为第一个多项式相加减后的结果

代码

#include <stdio.h>
#include <malloc.h>//定义结构体
struct Polynode{int coef;int exp;struct Polynode * next;
};//初始化结构体
void initList(struct Polynode * poly){poly->next = NULL;
}//输入
void insertNode(struct Polynode * poly){struct Polynode* p = poly;while (1){int c,e;printf("请输入多项式的系数和指数：");scanf("%d %d",&c,&e);if(c == 0){return;}struct Polynode* NewNode = malloc(sizeof(struct Polynode));NewNode->coef = c;NewNode->exp = e;NewNode->next = NULL;p->next = NewNode;p = p->next;}
}//两个多项式相加
void addpoly(struct Polynode * polynomial_1, struct Polynode * polynomial_2){//第一次循环，找到第一个多项式与第二个多项式中有相同指数的项，并进行系数相加，操作结果改变在第一个多项式链表中struct Polynode * p_1 = polynomial_1;while (p_1->next != NULL){struct Polynode * p_2 = polynomial_2;while (p_2->next != NULL){if(p_1->next->exp == p_2->next->exp){p_1->next->coef = p_1->next->coef + p_2->next->coef;break;}p_2 = p_2->next;}p_1 = p_1->next;}//第二次循环，找出第二个多项式与第一个多项式中有不同指数的项，并将该项的指数和系数保存到第一个多项式链表的最后，利用尾插法struct Polynode * p_2_again = polynomial_2;while (p_2_again->next != NULL){int flag = 1;struct Polynode * p_1_again = polynomial_1;while (p_1_again->next != NULL){if(p_2_again->next->exp == p_1_again->next->exp){flag = 0;}p_1_again = p_1_again->next;}if(flag == 1){struct Polynode* NewNode = malloc(sizeof(struct Polynode));NewNode->coef = p_2_again->next->coef;NewNode->exp = p_2_again->next->exp;NewNode->next = NULL;p_1_again->next = NewNode;}p_2_again = p_2_again->next;}}//整理多项式
void tidypoly(struct Polynode * poly_1, struct Polynode * poly_2){struct Polynode* p1 = poly_1;while (p1->next != NULL){//如果系数为0 就跳过这次循环if(p1->next->coef == 0){p1 = p1->next;continue;}struct Polynode* p2 = poly_2;int flag = 0;//头插法，指数大小不是最大while (p2->next != NULL){if(p1->next->exp < p2->next->exp){struct Polynode* NewNode = malloc(sizeof(struct Polynode));NewNode->coef = p1->next->coef;NewNode->exp = p1->next->exp;NewNode->next = p2->next;p2->next = NewNode;flag = 1;break;}p2 = p2->next;}if(flag == 1){p1 = p1->next;continue;}//尾插法，如果链表中没有节点 或者 比较之后指数最大，都应该排最后struct Polynode* NewNode = malloc(sizeof(struct Polynode));NewNode->coef = p1->next->coef;NewNode->exp = p1->next->exp;NewNode->next = NULL;p2->next = NewNode;p1 = p1->next;}
}//打印
void printfList(struct Polynode* poly){int index = 1;struct Polynode* p = poly;while(p->next != NULL){printf("第%d项的系数是 %d 指数是 %d\n",index, p->next->coef, p->next->exp);index ++;p = p->next;}
}int main(){//创建头节点struct Polynode polynomial_1;struct Polynode polynomial_2;struct Polynode polynomial_3;//初始化initList(&polynomial_1);initList(&polynomial_2);initList(&polynomial_3);//插入数据（尾插法）printf("\n*************输入第一个多项式*************\n");insertNode(&polynomial_1);printf("\n*************输入第二个多项式*************\n");insertNode(&polynomial_2);//打印printf("\n*************输出第一个多项式*************\n");printfList(&polynomial_1);printf("\n*************输出第二个多项式*************\n");printfList(&polynomial_2);//多项式相加printf("\n*************两个多项式相加结果*************\n");addpoly(&polynomial_1,&polynomial_2);printfList(&polynomial_1);printf("\n*************整理后结果*************\n");tidypoly(&polynomial_1,&polynomial_3);printfList(&polynomial_3);
}

运行结果

输入0 0是结束输入意思

*************输入第一个多项式*************
请输入多项式的系数和指数：2 3
请输入多项式的系数和指数：4 5
请输入多项式的系数和指数：6 6
请输入多项式的系数和指数：3 7
请输入多项式的系数和指数：0 0*************输入第二个多项式*************
请输入多项式的系数和指数：2 6
请输入多项式的系数和指数：3 9
请输入多项式的系数和指数：6 1
请输入多项式的系数和指数：7 2
请输入多项式的系数和指数：8 1
请输入多项式的系数和指数：0 0*************输出第一个多项式*************
第1项的系数是 2 指数是 3
第2项的系数是 4 指数是 5
第3项的系数是 6 指数是 6
第4项的系数是 3 指数是 7*************输出第二个多项式*************
第1项的系数是 2 指数是 6
第2项的系数是 3 指数是 9
第3项的系数是 6 指数是 1
第4项的系数是 7 指数是 2
第5项的系数是 8 指数是 1*************两个多项式相加结果*************
第1项的系数是 2 指数是 3
第2项的系数是 4 指数是 5
第3项的系数是 8 指数是 6
第4项的系数是 3 指数是 7
第5项的系数是 3 指数是 9
第6项的系数是 6 指数是 1
第7项的系数是 7 指数是 2*************整理后结果*************
第1项的系数是 6 指数是 1
第2项的系数是 7 指数是 2
第3项的系数是 2 指数是 3
第4项的系数是 4 指数是 5
第5项的系数是 8 指数是 6
第6项的系数是 3 指数是 7
第7项的系数是 3 指数是 9进程已结束，退出代码为 0

作业四（双链表）

双链表的创建，增加，查找，插入，删除操作

代码

#include <stdio.h>
#include <malloc.h>//定义结构体类型
struct DListNode{int element;struct DListNode * prior;struct DListNode * next;
};//初始化结构体
void initList(struct DListNode * head){head->prior = NULL;head->next = NULL;
}/**************************  插入操作  ******************************/
//尾插法
void insertNode_w(struct DListNode* head, int value){if(head==NULL){printf("没有头节点，插入数据失败");return;}struct DListNode* cur = head;while (cur->next != NULL){cur = cur->next;}struct DListNode* NewNode = malloc(sizeof(struct DListNode));if(NewNode){NewNode->element = value;NewNode->prior = cur;NewNode->next = NULL;cur->next = NewNode;}
}//头插法
void insertNode_t(struct DListNode* head, int value){if(head==NULL){printf("没有头节点，插入数据失败");return;}struct DListNode* cur = head;struct DListNode* NewNode = malloc(sizeof(struct DListNode));if(NewNode){NewNode->element = value;NewNode->next = cur->next;NewNode->prior = cur;if(cur->next != NULL){cur->next->prior = NewNode;}cur->next = NewNode;}
}//定位插入
void insertNode_d(struct DListNode* head, int index, int value){if(head==NULL){printf("没有头节点，插入数据失败");return;}struct DListNode* cur = head;int i = index;//找到前一个结点while (--index) {cur = cur->next;if (cur == NULL) {printf("\n插入失败：插入位置超出链表长度\n");return;}}struct DListNode* NewNode = malloc(sizeof(struct DListNode));NewNode->element = value;NewNode->next = cur->next;NewNode->prior = cur;if(cur->next != NULL){cur->next->prior = NewNode;}cur->next = NewNode;printf("%d 在第 %d 位插入成功！\n",value, i);
}/**************************  查询操作  ******************************/
//按值查找
void find_value(struct DListNode* head, int value){int index = 1;struct DListNode* cur = head;while (cur->next != NULL){if(cur->next->element == value){printf("查找成功：%d 在第 %d 位\n", value, index);return;}index ++;cur = cur->next;}printf("查找失败：查找的值不在链表中\n");
}//按位序查找
void find_index(struct DListNode* head, int index){if(index < 1){printf("查找失败：输入查找位序非法\n");return;}int flag = 1;struct DListNode* cur = head;while (cur->next != NULL){if(flag == index){printf("查找成功：第 %d 位的值是 %d \n", index, cur->next->element);return;}flag ++;cur = cur->next;}printf("查找失败：查找的位序超过链表长度\n");
}/**************************  删除操作  ******************************/
//按位序删除
void del_index(struct DListNode* head, int index){if(index < 1){printf("删除失败：输入删除位序非法\n");return;}int flag = 1;struct DListNode* cur = head;while (cur->next != NULL){if(flag == index){int e = cur->next->element;struct DListNode* temp = cur->next;if(cur->next->next == NULL){cur->next = NULL;free(temp);printf("第 %d 位的 %d 被删除成功\n",index, e);return;}cur->next = cur->next->next;cur->next->prior = cur;free(temp);printf("第 %d 位的 %d 被删除成功\n",index, e);return;}flag ++;cur = cur->next;}printf("删除失败：删除的位序超过链表长度\n");
}//按值删除
void del_value(struct DListNode* head, int value){int index = 1;struct DListNode* cur = head;while (cur->next){if(cur->next->element == value){struct DListNode* temp = cur->next;if(cur->next->next == NULL){cur->next = NULL;free(temp);printf("\n%d 在第 %d 位被删除成功\n",value, index);return;}cur->next = cur->next->next;cur->next->prior = cur;free(temp);printf("\n%d 在第 %d 位被删除成功\n",value, index);return;}index ++;cur = cur->next;}printf("删除失败：%d 不在链表中\n", value);
}//打印输出
void printfList(struct DListNode* head){struct DListNode* L = head;printf("\n顺序打印：");while(L->next != NULL){printf("%d-->", L->next->element);L = L->next;}printf("\n逆序打印：");printf("%d-->",L->element);while(L->prior != head){printf("%d-->", L->prior->element);L = L->prior;}}int main(){//创建头节点struct DListNode head;//初始化initList(&head);//头插入数据printf("***************头插入数据***************\n");int value_1;printf("请输入需要插入的数据（输入0则退出）：");scanf("%d", &value_1);while (value_1 != 0){insertNode_t(&head, value_1);printf("请输入需要插入的数据（输入0则退出）：");scanf("%d", &value_1);}printf("\n-------头插结果-------");printfList(&head);//尾插入数据printf("\n\n***************尾插入数据***************\n");int value_2;printf("请输入需要插入的数据（输入0则退出）：");scanf("%d", &value_2);while (value_2 != 0){insertNode_w(&head, value_2);printf("请输入需要插入的数据（输入0则退出）：");scanf("%d", &value_2);}printf("\n-------尾插结果-------");printfList(&head);//定位插入数据printf("\n\n***************定位插入数据***************\n");int index_1, value_3;printf("请输入需要插入的位序和数据（输入0 0则退出）：");scanf("%d %d",&index_1, &value_3);while (value_3 != 0){insertNode_d(&head, index_1, value_3);printf("请输入需要插入的位序和数据（输入0 0则退出）：");scanf("%d %d",&index_1, &value_3);}printf("\n-------定位插入结果-------");printfList(&head);printf("\n\n***************按值查找操作***************\n");int value_4;printf("请输入需要查找的数据（输入0则退出）：");scanf("%d", &value_4);while (value_4 != 0){find_value(&head, value_4);printf("请输入需要查找的数据（输入0则退出）：");scanf("%d", &value_4);}printf("\n***************按位序查找操作***************\n");int index_2;printf("请输入需要查找的位序（输入0则退出）：");scanf("%d", &index_2);while (index_2 != 0){find_index(&head, index_2);printf("请输入需要查找的位序（输入0则退出）：");scanf("%d", &index_2);}printf("\n***************按位序删除操作***************\n");int index_3;printf("请输入需要删除的位序（输入0则退出）：");scanf("%d", &index_3);while (index_3 != 0){del_index(&head, index_3);printfList(&head);printf("\n请输入需要删除的位序（输入0则退出）：");scanf("%d", &index_3);}printf("\n***************按值删除操作***************\n");int value_5;printf("请输入需要删除的值（输入0则退出）：");scanf("%d", &value_5);while (value_5 != 0){del_value(&head, value_5);printfList(&head);printf("\n请输入需要删除的值（输入0则退出）：");scanf("%d", &value_5);}
}

运行结果

***************头插入数据***************
请输入需要插入的数据（输入0则退出）：10
请输入需要插入的数据（输入0则退出）：20
请输入需要插入的数据（输入0则退出）：30
请输入需要插入的数据（输入0则退出）：0-------头插结果-------
顺序打印：30-->20-->10-->
逆序打印：10-->20-->30-->***************尾插入数据***************
请输入需要插入的数据（输入0则退出）：1111
请输入需要插入的数据（输入0则退出）：0-------尾插结果-------
顺序打印：30-->20-->10-->1111-->
逆序打印：1111-->10-->20-->30-->***************定位插入数据***************
请输入需要插入的位序和数据（输入0 0则退出）：2 200
200 在第 2 位插入成功！
请输入需要插入的位序和数据（输入0 0则退出）：0 0-------定位插入结果-------
顺序打印：30-->200-->20-->10-->1111-->
逆序打印：1111-->10-->20-->200-->30-->***************按值查找操作***************
请输入需要查找的数据（输入0则退出）：20
查找成功：20 在第 3 位
请输入需要查找的数据（输入0则退出）：0***************按位序查找操作***************
请输入需要查找的位序（输入0则退出）：4
查找成功：第 4 位的值是 10
请输入需要查找的位序（输入0则退出）：0***************按位序删除操作***************
请输入需要删除的位序（输入0则退出）：1
第 1 位的 30 被删除成功顺序打印：200-->20-->10-->1111-->
逆序打印：1111-->10-->20-->200-->
请输入需要删除的位序（输入0则退出）：0***************按值删除操作***************
请输入需要删除的值（输入0则退出）：11111111 在第 4 位被删除成功顺序打印：200-->20-->10-->
逆序打印：10-->20-->200-->
请输入需要删除的值（输入0则退出）：0

作业五（循环双链表合并）

循环双链表的合并

代码

#include <stdio.h>
#include <malloc.h>//定义结构体类型
struct DListNode{int element;struct DListNode * prior;struct DListNode * next;
};//初始化结构体
void initList(struct DListNode * head){head->prior = head;head->next = head;
}//尾插法
void insertNode_w(struct DListNode* head, int value){if(head==NULL){printf("没有头节点，插入数据失败");return;}struct DListNode* cur = head;while (cur->next != head){cur = cur->next;}struct DListNode* NewNode = malloc(sizeof(struct DListNode));if(NewNode){NewNode->element = value;NewNode->prior = cur;NewNode->next = head;cur->next = NewNode;}}//合并操作
void mergeDL(struct DListNode* LA, struct DListNode* LB){struct DListNode* lb = LB;while (lb->next != LB){struct DListNode* la = LA;int flag = 1;while (la->next != LA){if(la->next->element == lb->next->element){flag = 0;}la = la->next;}if(flag == 1){struct DListNode* NewNode = malloc(sizeof(struct DListNode));if(NewNode){NewNode->element = lb->next->element;NewNode->prior = la;NewNode->next = LA;la->next = NewNode;}}lb = lb->next;}}//打印输出
void printfList(struct DListNode* head){struct DListNode* L = head;printf("\n顺序打印：");while(L->next != head){printf("%d-->", L->next->element);L = L->next;}printf("\n逆序打印：");printf("%d-->",L->element);while(L->prior != head){printf("%d-->", L->prior->element);L = L->prior;}}int main(){//创建头节点struct DListNode LA;struct DListNode LB;//初始化initList(&LA);initList(&LB);//尾插入数据printf("\n***************LA尾插入数据***************\n");int value_1;printf("请输入需要插入的数据（输入0则退出）：");scanf("%d", &value_1);while (value_1 != 0){insertNode_w(&LA, value_1);printf("请输入需要插入的数据（输入0则退出）：");scanf("%d", &value_1);}printf("\n-------LA尾插结果-------");printfList(&LA);//尾插入数据printf("\n***************LB尾插入数据***************\n");int value_2;printf("请输入需要插入的数据（输入0则退出）：");scanf("%d", &value_2);while (value_2 != 0){insertNode_w(&LB, value_2);printf("请输入需要插入的数据（输入0则退出）：");scanf("%d", &value_2);}printf("\n-------LB尾插结果-------");printfList(&LB);//合并操作printf("\n\n***************合并操作结果***************\n");mergeDL(&LA,&LB);printfList(&LA);}

运行结果

***************LA尾插入数据***************
请输入需要插入的数据（输入0则退出）：10
请输入需要插入的数据（输入0则退出）：20
请输入需要插入的数据（输入0则退出）：30
请输入需要插入的数据（输入0则退出）：40
请输入需要插入的数据（输入0则退出）：0-------LA尾插结果-------
顺序打印：10-->20-->30-->40-->
逆序打印：40-->30-->20-->10-->
***************LB尾插入数据***************
请输入需要插入的数据（输入0则退出）：11
请输入需要插入的数据（输入0则退出）：22
请输入需要插入的数据（输入0则退出）：33
请输入需要插入的数据（输入0则退出）：44
请输入需要插入的数据（输入0则退出）：0-------LB尾插结果-------
顺序打印：11-->22-->33-->44-->
逆序打印：44-->33-->22-->11-->***************合并操作结果***************顺序打印：10-->20-->30-->40-->11-->22-->33-->44-->
逆序打印：44-->33-->22-->11-->40-->30-->20-->10-->
进程已结束，退出代码为 0

作业六（循环双链表）

循环双链表的创建，增加，查找，插入，删除操作

代码

#include <stdio.h>
#include <malloc.h>//定义结构体类型
struct DListNode{int element;struct DListNode * prior;struct DListNode * next;
};//初始化结构体
void initList(struct DListNode * head){head->prior = head;head->next = head;
}/**************************  插入操作  ******************************/
//尾插法
void insertNode_w(struct DListNode* head, int value){if(head==NULL){printf("没有头节点，插入数据失败");return;}struct DListNode* cur = head;while (cur->next != head){cur = cur->next;}struct DListNode* NewNode = malloc(sizeof(struct DListNode));if(NewNode){NewNode->element = value;NewNode->prior = cur;NewNode->next = head;cur->next = NewNode;head->prior = NewNode;}
}//头插法
void insertNode_t(struct DListNode* head, int value){if(head==NULL){printf("没有头节点，插入数据失败");return;}struct DListNode* cur = head;struct DListNode* NewNode = malloc(sizeof(struct DListNode));if(NewNode){NewNode->element = value;NewNode->next = cur->next;NewNode->prior = head;if(cur->next != head){cur->next->prior = NewNode;}cur->next = NewNode;}
}//定位插入
void insertNode_d(struct DListNode* head, int index, int value){if(head==NULL){printf("没有头节点，插入数据失败");return;}struct DListNode* cur = head;int i = index;//找到前一个结点while (--index) {cur = cur->next;if (cur == head) {printf("\n插入失败：插入位置超出链表长度\n");return;}}struct DListNode* NewNode = malloc(sizeof(struct DListNode));NewNode->element = value;NewNode->next = cur->next;NewNode->prior = cur;if(cur->next != head){cur->next->prior = NewNode;}cur->next = NewNode;printf("%d 在第 %d 位插入成功！\n",value, i);
}/**************************  查询操作  ******************************/
//按值查找
void find_value(struct DListNode* head, int value){int index = 1;struct DListNode* cur = head;while (cur->next != head){if(cur->next->element == value){printf("查找成功：%d 在第 %d 位\n", value, index);return;}index ++;cur = cur->next;}printf("查找失败：查找的值不在链表中\n");
}//按位序查找
void find_index(struct DListNode* head, int index){if(index < 1){printf("查找失败：输入查找位序非法\n");return;}int flag = 1;struct DListNode* cur = head;while (cur->next != head){if(flag == index){printf("查找成功：第 %d 位的值是 %d \n", index, cur->next->element);return;}flag ++;cur = cur->next;}printf("查找失败：查找的位序超过链表长度\n");
}/**************************  删除操作  ******************************/
//按位序删除
void del_index(struct DListNode* head, int index){if(index < 1){printf("删除失败：输入删除位序非法\n");return;}int flag = 1;struct DListNode* cur = head;while (cur->next != head){if(flag == index){int e = cur->next->element;struct DListNode* temp = cur->next;if(cur->next->next == head){cur->next = head;free(temp);printf("第 %d 位的 %d 被删除成功\n",index, e);return;}cur->next = cur->next->next;cur->next->prior = cur;free(temp);printf("第 %d 位的 %d 被删除成功\n",index, e);return;}flag ++;cur = cur->next;}printf("删除失败：删除的位序超过链表长度\n");
}//按值删除
void del_value(struct DListNode* head, int value){int index = 1;struct DListNode* cur = head;while (cur->next != head){if(cur->next->element == value){struct DListNode* temp = cur->next;if(cur->next->next == head){cur->next = head;free(temp);printf("\n%d 在第 %d 位被删除成功\n",value, index);return;}cur->next = cur->next->next;cur->next->prior = cur;free(temp);printf("\n%d 在第 %d 位被删除成功\n",value, index);return;}index ++;cur = cur->next;}printf("删除失败：%d 不在链表中\n", value);
}//打印输出
void printfList(struct DListNode* head){struct DListNode* L = head;printf("\n顺序打印：");while(L->next != head){printf("%d-->", L->next->element);L = L->next;}printf("\n逆序打印：");printf("%d-->",L->element);while(L->prior != head){printf("%d-->", L->prior->element);L = L->prior;}
}int main(){//创建头节点struct DListNode head;//初始化initList(&head);//头插入数据printf("***************头插入数据***************\n");int value_1;printf("请输入需要插入的数据（输入0则退出）：");scanf("%d", &value_1);while (value_1 != 0){insertNode_t(&head, value_1);printf("请输入需要插入的数据（输入0则退出）：");scanf("%d", &value_1);}printf("\n-------头插结果-------");printfList(&head);//尾插入数据printf("\n\n***************尾插入数据***************\n");int value_2;printf("请输入需要插入的数据（输入0则退出）：");scanf("%d", &value_2);while (value_2 != 0){insertNode_w(&head, value_2);printf("请输入需要插入的数据（输入0则退出）：");scanf("%d", &value_2);}printf("\n-------尾插结果-------");printfList(&head);//定位插入数据printf("\n\n***************定位插入数据***************\n");int index_1, value_3;printf("请输入需要插入的位序和数据（输入0 0则退出）：");scanf("%d %d",&index_1, &value_3);while (value_3 != 0){insertNode_d(&head, index_1, value_3);printf("请输入需要插入的位序和数据（输入0 0则退出）：");scanf("%d %d",&index_1, &value_3);}printf("\n-------定位插入结果-------");printfList(&head);printf("\n\n***************按值查找操作***************\n");int value_4;printf("请输入需要查找的数据（输入0则退出）：");scanf("%d", &value_4);while (value_4 != 0){find_value(&head, value_4);printf("请输入需要查找的数据（输入0则退出）：");scanf("%d", &value_4);}printf("\n\n***************按位序查找操作***************\n");int value_5;printf("请输入需要查找的位序（输入0则退出）：");scanf("%d", &value_5);while (value_5 != 0){find_index(&head, value_5);printf("请输入需要查找的位序（输入0则退出）：");scanf("%d", &value_5);}printf("\n***************按位序删除操作***************\n");int index_3;printf("请输入需要删除的位序（输入0则退出）：");scanf("%d", &index_3);while (index_3 != 0){del_index(&head, index_3);printfList(&head);printf("\n请输入需要删除的位序（输入0则退出）：");scanf("%d", &index_3);}printf("\n***************按值删除操作***************\n");int value_6;printf("请输入需要删除的值（输入0则退出）：");scanf("%d", &value_6);while (value_6 != 0){del_value(&head, value_6);printfList(&head);printf("\n请输入需要删除的值（输入0则退出）：");scanf("%d", &value_6);}
}

运行结果

***************头插入数据***************
请输入需要插入的数据（输入0则退出）：12
请输入需要插入的数据（输入0则退出）：23
请输入需要插入的数据（输入0则退出）：34
请输入需要插入的数据（输入0则退出）：45
请输入需要插入的数据（输入0则退出）：0-------头插结果-------
顺序打印：45-->34-->23-->12-->
逆序打印：12-->23-->34-->45-->***************尾插入数据***************
请输入需要插入的数据（输入0则退出）：900
请输入需要插入的数据（输入0则退出）：0-------尾插结果-------
顺序打印：45-->34-->23-->12-->900-->
逆序打印：900-->12-->23-->34-->45-->***************定位插入数据***************
请输入需要插入的位序和数据（输入0 0则退出）：1 600
600 在第 1 位插入成功！
请输入需要插入的位序和数据（输入0 0则退出）：0 0-------定位插入结果-------
顺序打印：600-->45-->34-->23-->12-->900-->
逆序打印：900-->12-->23-->34-->45-->600-->***************按值查找操作***************
请输入需要查找的数据（输入0则退出）：23
查找成功：23 在第 4 位
请输入需要查找的数据（输入0则退出）：0***************按位序查找操作***************
请输入需要查找的位序（输入0则退出）：2
查找成功：第 2 位的值是 45
请输入需要查找的位序（输入0则退出）：0***************按位序删除操作***************
请输入需要删除的位序（输入0则退出）：1
第 1 位的 600 被删除成功顺序打印：45-->34-->23-->12-->900-->
逆序打印：900-->12-->23-->34-->45-->
请输入需要删除的位序（输入0则退出）：0***************按值删除操作***************
请输入需要删除的值（输入0则退出）：1212 在第 4 位被删除成功顺序打印：45-->34-->23-->900-->
逆序打印：900-->23-->34-->45-->
请输入需要删除的值（输入0则退出）：0

http://www.ppmy.cn/news/1202367.html

相关文章

G-LAB IT实验室【11月】网工公开课 即将开始~

G-LAB IT实验室【11月】网工公开课 即将开始~

带你一起走进网工的世界&#xff01;G-LAB网工入门免费公开课即将开讲&#xff01;无论是想学习基础网络组网还是网络互通技术实施&#xff0c;这个公开课都是你不容错过的&#xff01; 公开课课程为期两天&#xff0c;11月7日&#xff06;11月8日晚20&#xff1a;00 分享主题…
阅读更多...
flink状态和检查点

flink状态和检查点

检查点和状态后端的区别 检查点 就是某个时间点下的所有算子的状态快照。这个时间点就是等所有任务将“同一个数据”处理完毕的时候。 状态后端&#xff1a;是一个管理状态的组件&#xff0c;还负责将本地状态&#xff08;检查点&#xff09;持久化到远程文件存储系统中。 分…
阅读更多...
身份证号码算法解析与Java代码实现

身份证号码算法解析与Java代码实现

中国的身份证号码是一串唯一的标识符&#xff0c;由18位数字组成&#xff0c;用于标识中国公民的个人信息。它不仅包含个人的出生日期和顺序码&#xff0c;还包含了地区信息。下面我们将介绍中国身份证号码的结构以及验证算法&#xff0c;并提供了相应的Java代码示例。 身份证…
阅读更多...
应用安全四十二：SSO安全

应用安全四十二：SSO安全

一、什么是SSO SSO是单点登录（Single Sign On）的缩写，是指在多个应用系统中，用户只需要登录一次就可以访问所有相互信任的应用系统。这种方式减少了由登录产生的时间消耗，辅助了用户管理，是比较流行的企业业务整合的解决方案之一。 身份验证过程依赖于双方之间的信任关…
阅读更多...
linq to sql性能优化技巧

linq to sql性能优化技巧

linq to sql 是一个代码生成器和ORM工具，他自动为我们做了很多事情，这很容易让我们对他的性能产生怀疑 linq to sql 是一个代码生成器和ORM工具，他自动为我们做了很多事情，这很容易让我们对他的性能产生怀疑。但是也有几个测试证明显示在做好优化的情况下，linq to sql的…
阅读更多...
IT运营与DevOps：有何不同？

IT运营与DevOps：有何不同？

IT 运营和 DevOps 满足许多现代企业密切相关的需求。然而&#xff0c;尽管这两种角色之间有许多相似之处&#xff0c;但也有重要的区别&#xff0c;将 IT 运营与 DevOps 混为一谈是错误的。 本文通过解释每种类型的角色是做什么的&#xff1b;它们在流程、工具和文化方面的比…
阅读更多...
【Web】在前端中CSS的语法

【Web】在前端中CSS的语法

CSS规则是由两个主要的部分构成&#xff1a;选择器、以及一条或多条声明。 选择器通常是需要改变的HTML元素。 每条声明由一个属性和一个值组成。 属性&#xff08;Property&#xff09;是需要设置的样式属性&#xff08;Style attribute&#xff09;。每一个属性有一个值。…
阅读更多...
VBA技术资料MF80：选择文件及文件夹

VBA技术资料MF80：选择文件及文件夹

我给VBA的定义&#xff1a;VBA是个人小型自动化处理的有效工具。利用好了&#xff0c;可以大大提高自己的工作效率&#xff0c;而且可以提高数据的准确度。我的教程一共九套&#xff0c;分为初级、中级、高级三大部分。是对VBA的系统讲解&#xff0c;从简单的入门&#xff0c;到…
阅读更多...
最新文章

Copyright @ 2022~2023