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

作业一（单链表）

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

代码

#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.mzph.cn/news/132239.shtml

如若内容造成侵权/违法违规/事实不符，请联系多彩编程网进行投诉反馈email:809451989@qq.com，一经查实，立即删除！

相关文章

LangChain+LLM实战---ChatGPT的工作原理

LangChain+LLM实战---ChatGPT的工作原理

一个词一个词的输出 ChatGPT能够自动生成类似于人类书写的文本&#xff0c;这是非常了不起和出乎意料的。但它是如何做到的&#xff1f;为什么会有效果呢&#xff1f;我的目的在于大致概述ChatGPT内部发生了什么&#xff0c;然后探讨它为什么能够很好地生成我们认为有意义的文…
阅读更多...
干货满满，mac屏幕录制实用教程！

干货满满，mac屏幕录制实用教程！

在当今科技飞速发展的时代&#xff0c;屏幕录制已经成为了人们日常生活中经常使用的功能&#xff0c;无论是工作还是生活&#xff0c;我们都需要使用到屏幕录制软件来捕捉屏幕上的内容。mac作为苹果公司开发的操作系统&#xff0c;拥有许多内置的屏幕录制工具。本文将详细介绍两…
阅读更多...
【六、http】go的http的客户端重定向

【六、http】go的http的客户端重定向

一、http的重定向 重定向过程&#xff1a;客户浏览器发送http请求----》web服务器接受后发送302状态码响应及对应新的location给客户浏览器–》客户浏览器发现是302响应&#xff0c;则自动再发送一个新的http请求&#xff0c;请求url是新的location地址----》服务器根据此请求寻…
阅读更多...
win10下.net framework 3.5 | net framework 4 无法安装解决方案

win10下.net framework 3.5 | net framework 4 无法安装解决方案

.net缺失解决方案 win10 .net framework 3.5组策略设置方案一方案二 win10 .net framework 4 参考文章 win10 .net framework 3.5 组策略设置 方案一 搜索组策略&#xff0c;依次展开“计算机配置”、“管理模板”&#xff0c;然后选择“系统”&#xff0c;找到指定可选组件…
阅读更多...
Panda3d 相机控制

Panda3d 相机控制

Panda3d 相机控制 文章目录 Panda3d 相机控制Panda3d中的透视镜头和垂直镜头透视镜头垂直镜头 Panda3d 中用代码控制相机的移动用键盘控制相机的移动用鼠标控制相机的移动 Panda3d 把相机也当做是一个 PandaNode&#xff0c;因此可以向操作其他节点对其进行操作。 真正的相机是…
阅读更多...
使用pandas处理excel文件【Demo】

使用pandas处理excel文件【Demo】

一、代码示例 import pandas as pd from pandas import Series,DataFrame from pandasql import sqldf import matplotlib.pyplotidInfos DataFrame(pd.read_excel(home_data.xlsx))print(idInfos.head(2))print(idInfos.dtypes)# print(idInfos[:][姓名]) # 自定义一个函数s…
阅读更多...
音视频报警可视对讲15.6寸管理机

音视频报警可视对讲15.6寸管理机

音视频报警可视对讲15.6寸管理机 一、管理机技术指标&#xff1a; 1、15.6寸原装京东方工业液晶触摸屏&#xff0c;分辨率1920 (H) x 1080 (V)&#xff1b; 2、1000M/100M自适应双网口&#xff1b; 4、按键设置&#xff1a;报警/呼叫按键&#xff0c;通话/挂机按键&#xff…
阅读更多...
AGV 导航方法总体设计与分析

AGV 导航方法总体设计与分析

导航方案设计 导航方法分为三个部分——路径规划、实时定位、轨迹纠正。 视觉定位模块 主要有三个工作任务&#xff1a;利用二维码定位对 AGV 初始位姿 进行矫正&#xff0c;保证 AGV 初始运动时其运动轨迹能够与道路平行&#xff1b;利用 ORBSLAM 定位能够实时的获得 AGV 在…
阅读更多...
WebSocket Day 01:入门案例

WebSocket Day 01:入门案例

前言 欢迎来到WebSocket入门案例系列的第一天&#xff01;在今天的博客中&#xff0c;我们将一起探索WebSocket的基础知识和使用方法。本系列将以一个简单的入门案例为基础&#xff0c;带领您逐步了解WebSocket的原理和用法。 一、什么是 WebSocket ? WebSocket是一种在Web应…
阅读更多...
香港金融科技周VERTU CSO Sophie谈Web3.0的下一个风口 手机虚拟货币移动支付

香港金融科技周VERTU CSO Sophie谈Web3.0的下一个风口 手机虚拟货币移动支付

10月31日&#xff0c;香港金融科技周正式拉开帷幕。这项香港金融科技界地年度盛事今年已经踏入了第八届&#xff0c;本届活动吸引超过数百位金融科技专业人士、创业者和行业领袖现场参与&#xff0c;线上参与观众超过10万人次。 在金融科技周的圆桌会议上&#xff0c;VERTU首席…
阅读更多...
看门狗溢出实验（按键不停喂狗）

看门狗溢出实验（按键不停喂狗）

/*----------------------------------------------- 内容&#xff1a;通过按键喂狗防止溢出复位 看门狗演示程序 在16383个机器周期内必须至少喂狗一次 标准AT89s52单片机试验通过。 ------------------------------------------------*/ #include <reg5…
阅读更多...
acwing算法基础之数据结构--并查集算法

acwing算法基础之数据结构--并查集算法

目录 1 基础知识2 模板3 工程化 1 基础知识 并查集支持O(1)时间复杂度实现&#xff1a; 将两个集合合并。询问两个元素是否在一个集合中。 基本原理&#xff1a;每个集合用一颗树来表示。树根的编号就是整个集合的编号。每个结点存储它的父结点&#xff0c;p[x]表示x的父结点…
阅读更多...
第十二章《搞懂算法:朴素贝叶斯是怎么回事》笔记

第十二章《搞懂算法:朴素贝叶斯是怎么回事》笔记

朴素贝叶斯是经典的机器学习算法&#xff0c;也是统计模型中的一个基本方法。它的基本思想是利用统计学中的条件概率来进行分类。它是一种有监督学习算法&#xff0c;其中“朴素”是指该算法基于样本特征之间相互独立这个“朴素”假设。朴素贝叶斯原理简单、容易实现&#xff0…
阅读更多...
查询当前目录下指定大小的文件和跳过指定文件夹查文件夹大小

查询当前目录下指定大小的文件和跳过指定文件夹查文件夹大小

要筛选当前目录下大于500MB的文件并将它们记录在日志文件中&#xff0c;你可以使用以下步骤&#xff1a; 打开终端或命令提示符。使用以下命令列出当前目录下所有文件及其大小&#xff0c;并将结果重定向到一个文本文件中&#xff0c;例如filelist.txt&#xff1a; find . -t…
阅读更多...
缓解缓存击穿的大杀器之---singleflight深入浅出

缓解缓存击穿的大杀器之---singleflight深入浅出

singleflight简单介绍 singlefight直译“单飞”&#xff0c;那顾名思义就是有一堆鸟&#xff0c;但是咱只让一只鸟单飞。。。&#x1f604; singleflight 提供了重复函数调用抑制机制&#xff0c;使用它可以避免同时进行相同的函数调用。第一个调用未完成时后续的重复调用会等…
阅读更多...
【Unity细节】为什么UI移动了锚点，中心点和位置，运行的时候还是不在设置的位置当中

【Unity细节】为什么UI移动了锚点，中心点和位置，运行的时候还是不在设置的位置当中

&#x1f468;‍&#x1f4bb;个人主页&#xff1a;元宇宙-秩沅 hallo 欢迎 点赞&#x1f44d; 收藏⭐ 留言&#x1f4dd; 加关注✅! 本文由 秩沅 原创 &#x1f636;‍&#x1f32b;️收录于专栏&#xff1a;unity细节和bug &#x1f636;‍&#x1f32b;️优质专栏 ⭐【…
阅读更多...
[MRCTF2020]你传你呢1

[MRCTF2020]你传你呢1

提示 只对php以及phtml文件之类的做了防护content-type.htaccess文件 这里就不整那么麻烦直接抓包测试 首先对后缀测试看过滤了哪些 (php php3 pht php5 phtml phps) 全部被ban了 到这里的后续思路通过上传一些配置文件把上传的图片都以php文件执行 尝试上传图片码, 直接上传成…
阅读更多...
新大陆NVH200-AP(U)扫码枪在上位机软件开发中的应用

新大陆NVH200-AP(U)扫码枪在上位机软件开发中的应用

前言： 由于本次使用的是USB接口的扫码枪 1、先安装Nset软件，使用扫码枪扫描“启动设置条码”，然后扫描“USB CDC串口”条码 2、打开NSet软件，点击“刷新按钮” 就能找到扫码枪设备 3、设置条码后缀 点击“高级设置”，然后点击“数据编辑”，在“后缀”那里设置结束符…
阅读更多...
spring boot中的多环境配置

spring boot中的多环境配置

1.切换环境 spring:profiles:include: devactive: dev的作用是为了启动某个环境&#xff0c;两个作用基本一致&#xff0c; 环境定义如下&#xff1a; spring:profiles: dev或者是查找application-dev.yml这个文件的所有配置 2.加载文件 spring:config:import:- optional:f…
阅读更多...
逆向学习记录（2）windows常用基本操作及用环境变量配置上多个python版本

逆向学习记录（2）windows常用基本操作及用环境变量配置上多个python版本

1、如何打开cmd 第一种方法&#xff1a;按下winr&#xff0c;运行cmd 第二种方法&#xff1a;进入一个目录&#xff0c;点击路径处&#xff08;显示蓝色背景&#xff09;&#xff0c;然后直接键盘输入cmd&#xff0c;回车&#xff0c;运行cmd并直接进入此目录。 2、命令dir&am…
阅读更多...
最新文章

Copyright @ 2022~2023