单循环链表-c语言实现

合集下载

C语言用循环单链表实现约瑟夫环

C语言用循环单链表实现约瑟夫环

C语⾔⽤循环单链表实现约瑟夫环⽤循环单链表实现约瑟夫环(c语⾔),供⼤家参考,具体内容如下源代码如下,采⽤Dev编译通过,成功运⾏,默认数到三出局。

主函数:main.c⽂件#include <stdio.h>#include "head.h"#include "1.h"int main(){Linklist L;int n;printf("请输⼊约瑟夫环中的⼈数:");scanf("%d",&n);Createlist(L,n);printf("创建的约瑟夫环为:\n");Listtrave(L,n);printf("依次出局的结果为:\n");Solution(L,n);return 0;}head.h⽂件:#include "1.h"#include <stdio.h>#include <stdlib.h>typedef int Elemtype;typedef struct LNode{Elemtype data;struct LNode *next;}LNode,*Linklist;void Createlist(Linklist &L,int n){Linklist p,tail;L = (Linklist)malloc(sizeof(LNode));L->next = L;//先使其循环p = L;p->data = 1;//创建⾸节点之后就先给⾸节点赋值,使得后⾯节点赋值的操作能够循环tail = L;for(int i = 2;i <= n;i++){p = (Linklist)malloc(sizeof(LNode));p->data = i;p->next = L;tail->next = p;tail = p;}printf("已⽣成⼀个长度为%d的约瑟夫环!\n",n);}void Listtrave(Linklist L,int n)//遍历函数{Linklist p;p = L;for(int i = 1;i <= n;i++){printf("%3d",p->data);p = p->next;}printf("\n");}int Solution(Linklist L,int n){Linklist p,s;p = L,s = L;int count = 1;while(L){if(count != 3){count++;p = p->next;//进⾏不等于3时的移位}else{Linklist q;q = p;//⽤q保存p所指的位置,⽅便进⾏节点的删除if(s->next->data == s->data)//当只有⼀个元素的时候{printf("%3d\n",s->data);free(s);return OK;}else//当有两个及两个以上的元素的时候{count = 1;//先将count重置为1printf("%3d",p->data);//再打印出出局的值while(s->next != p){s = s->next;//将s移位到p的前驱节点处}p = p->next;//使p指向⾃⼰的下⼀个节点s->next = p;//进⾏删除free(q);}}}}1.h⽂件:#define TRUE 1#define FALSE 0#define OK 1#define ERROR 0#define INFEASIBLE -1#define OVERFLOW -2运⾏结果:以上就是本⽂的全部内容,希望对⼤家的学习有所帮助,也希望⼤家多多⽀持。

C语言单向循环链表实现实现约瑟夫环

C语言单向循环链表实现实现约瑟夫环

C语言实现约瑟夫环问题------单向循环链表实现问题描述:有n个人围成一圈进行报数游戏,从第一个人开始报到m的人出圈,接下来有从下一个人开始,。

一次这样往复,直到最后一个人也出圈,求他们的出圈顺序?(例如8个人,凡报3的人出圈,则他们出圈顺序是3 ,6, 1,,5 ,2 ,8,4 ,7)#include<stdio.h>#include<stdlib.h>typedef struct node{int value;struct node *next;}NODE;//*********************建立循环链表(尾插法建立)***********//NODE *createlink(int number){NODE *head=NULL,*p=NULL,*q=NULL;int i=1;head=(struct node*)malloc(sizeof(struct node)); //***建立第一个节点***//head->value=i;p=head;for(i=2;i<=number;i++) //***建立剩下的number-1节点****//{q=(struct node*)malloc(sizeof(struct node));if(q==0) return 0;p->next=q;p=q;p->value=i;}p->next=head;return head;}//*****************建立约瑟夫环********************// void jose(NODE *p,int number,int n){int i,j,g=0;NODE *q=NULL;for(i=1;i<=number;i++){for(j=1;j<n-1;j++){p=p->next;}q=p->next; //***q用来记录要删除的节点*****//p->next=q->next; //****删去q节点******//p=p->next;printf("第%3d个出圈号是:%3d\n",i,q->value);free(q);}printf("\n");// p->next=NULL; 此表达式不能出现在此处,最后一个节点删除后就不存在了}//***********************主函数*************************//int main( ){int number=0;int n=0;printf("请输入总人数number和出拳编号n:\n");scanf("%d",&number);scanf("%d",&n);NODE *head=NULL;head=createlink(number);jose(head,number,n);system("PAUSE");return 1;}。

链表的c语言实现十

链表的c语言实现十

在这里列举了一个应用单链表基本算法的综合程序,双向链表和循环链表的综合程序大家可以自己去试一试。

#include <stdio.h>#include <malloc.h>#include <string.h>#define N 10 typedef struct node{char name[20];struct node *link;}stud;stud * creat(int n){stud *p,*h,*s;int i;if((h=(stud *)malloc(sizeof(stud)))==NULL){printf("不能分配内存空间!");exit(0);}h->name[0]='\0';h->link=NULL;p=h;for(i=0;i<n;i++){if((s= (stud *) malloc(sizeof(stud)))==NULL){printf("不能分配内存空间!");exit(0);}p->link=s;printf("请输入第%d个人的姓名",i+1);scanf("%s",s->name);s->link=NULL;p=s;}return(h);}stud * search(stud *h,char *x){stud *p;char *y;p=h->link;while(p!=NULL){y=p->name;if(strcmp(y,x)==0)return(p);else p=p->link;}if(p==NULL)printf("没有查找到该数据!");}stud * search2(stud *h,char *x){stud *p,*s;char *y;p=h->link;s=h;while(p!=NULL){y=p->name;if(strcmp(y,x)==0)return(s);else{p=p->link;s=s->link;}}if(p==NULL)printf("没有查找到该数据!");}void insert(stud *p){char stuname[20];stud *s;if((s= (stud *) malloc(sizeof(stud)))==NULL) {printf("不能分配内存空间!");exit(0);}printf("\n请输入你要插入的人的姓名:"); scanf("%s",stuname);strcpy(s->name,stuname);s->link=p->link;p->link=s;}void del(stud *x,stud *y){stud *s;s=y;x->link=y->link;free(s);}void print(stud *h){stud *p;p=h->link;printf("数据信息为:\n");while(p!=NULL){printf("%s ",&*(p->name));p=p->link;}}void quit(){exit(0);}void menu(void){clrscr();printf("\t\t\t单链表C语言实现实例\n");printf("\t\t|————————————————|\n"); printf("\t\t| |\n");printf("\t\t| [1] 建立新表|\n");printf("\t\t| [2] 查找数据|\n");printf("\t\t| [3] 插入数据|\n");printf("\t\t| [4] 删除数据|\n");printf("\t\t| [5] 打印数据|\n");printf("\t\t| [6] 退出|\n");printf("\t\t| |\n");printf("\t\t| 如未建立新表,请先建立!|\n"); printf("\t\t| |\n");printf("\t\t|————————————————|\n");printf("\t\t 请输入你的选项(1-6):");}main(){int choose;stud *head,*searchpoint,*forepoint;char fullname[20];while(1){menu();scanf("%d",&choose);switch(choose){case 1:head=creat(N);break;case 2:printf("输入你所要查找的人的姓名:");scanf("%s",fullname);searchpoint=search(head,fullname);printf("你所查找的人的姓名为:%s",*&searchpoint->name); printf("\n按回车键回到主菜单。

[转载整理]C语言链表实例

[转载整理]C语言链表实例

[转载整理]C语⾔链表实例 C语⾔链表有单链表、双向链表、循环链表。

单链表由数据域和指针域组成,数据域存放数据,指针域存放该数据类型的指针便于找到下⼀个节点。

双链表则含有头指针域、数据域和尾指针域,域单链表不同,双链表可以从后⼀个节点找到前⼀个节点,⼆单链表则不⾏。

循环链表就是在单链表的基础上,将头结点的地址指针存放在最后⼀个节点的指针域⾥以,此形成循环。

此外还有双向循环链表,它同时具有双向链表和循环链表的功能。

单链表如:链表节点的数据结构定义struct node{int num;struct node *p;} ;在此链表节点的定义中,除⼀个整型的成员外,成员p是指向与节点类型完全相同的指针。

※在链表节点的数据结构中,⾮常特殊的⼀点就是结构体内的指针域的数据类型使⽤了未定义成功的数据类型。

这是在C中唯⼀规定可以先使⽤后定义的数据结构。

链表实例代码:1// 原⽂地址 /wireless-dragon/p/5170565.html2 #include<stdio.h>3 #include<stdlib.h>4 #include<string.h>56 typedef int elemType;//定义存⼊的数据的类型可以是int char78 typedef struct NODE{ //定义链表的结构类型9 elemType element;10struct NODE *next;11 }Node;1213/************************************************************************/14/* 以下是关于线性表链接存储(单链表)操作的19种算法 */1516/* 1.初始化线性表,即置单链表的表头指针为空 */17/* 2.创建线性表,此函数输⼊负数终⽌读取数据*/18/* 3.打印链表,链表的遍历*/19/* 4.清除线性表L中的所有元素,即释放单链表L中所有的结点,使之成为⼀个空表 */20/* 5.返回单链表的长度 */21/* 6.检查单链表是否为空,若为空则返回1,否则返回0 */22/* 7.返回单链表中第pos个结点中的元素,若pos超出范围,则停⽌程序运⾏ */23/* 8.从单链表中查找具有给定值x的第⼀个元素,若查找成功则返回该结点data域的存储地址,否则返回NULL */24/* 9.把单链表中第pos个结点的值修改为x的值,若修改成功返回1,否则返回0 */25/* 10.向单链表的表头插⼊⼀个元素 */26/* 11.向单链表的末尾添加⼀个元素 */27/* 12.向单链表中第pos个结点位置插⼊元素为x的结点,若插⼊成功返回1,否则返回0 */28/* 13.向有序单链表中插⼊元素x结点,使得插⼊后仍然有序 */29/* 14.从单链表中删除表头结点,并把该结点的值返回,若删除失败则停⽌程序运⾏ */30/* 15.从单链表中删除表尾结点并返回它的值,若删除失败则停⽌程序运⾏ */31/* 16.从单链表中删除第pos个结点并返回它的值,若删除失败则停⽌程序运⾏ */32/* 17.从单链表中删除值为x的第⼀个结点,若删除成功则返回1,否则返回0 */33/* 18.交换2个元素的位置 */34/* 19.将线性表进⾏冒排序 */35363738/*注意检查分配到的动态内存是否为空*/3940414243/* 1.初始化线性表,即置单链表的表头指针为空 */44void initList(Node **pNode)45 {46 *pNode=NULL;47 printf("initList函数执⾏,初始化成功\n");48 }4950/* 2.创建线性表,此函数输⼊负数终⽌读取数据*/51 Node *creatList(Node *pHead)52 {53 Node *p1,*p2;54 p1=p2=(Node *)malloc(sizeof(Node));55if(p1 == NULL || p2 ==NULL)57 printf("内存分配失败\n");58 exit(0);59 }60 memset(p1,0,sizeof(Node));6162 scanf("%d",&p1->element);63 p1->next=NULL;6465while(p1->element >0) //输⼊的值⼤于0则继续,否则停⽌66 {67if(pHead == NULL)//空表,接⼊表头68 {69 pHead=p1;70 }71else72 {73 p2->next=p1;74 }7576 p2=p1;77 p1=(Node *)malloc(sizeof(Node));7879if(p1==NULL||p2==NULL)80 {81 printf("内存分配失败\n");82 exit(0);83 }84 memset(p1,0,sizeof(Node));85 scanf("%d",&p1->element);86 p1->next=NULL;87 }88 printf("CreatList函数执⾏,链表创建成功\n");89return pHead;90 }9192/* 3.打印链表,链表的遍历*/93void printList(Node *pHead)94 {95if(NULL==pHead)96 {97 printf("PrintList函数执⾏,链表为空\n");98 }99else100 {101while(NULL!=pHead)102 {103 printf("%d\n",pHead->element);104 pHead=pHead->next;105 }106 }107108 }109110111/* 4.清除线性表L中的所有元素,即释放单链表L中所有的结点,使之成为⼀个空表 */ 112void clearList(Node *pHead)113 {114 Node *pNext;115116if(pHead==NULL)117 {118 printf("clearList函数执⾏,链表为空\n");119return;120 }121while(pHead->next!=NULL)122 {123 pNext=pHead->next;124free(pHead);125 pHead=pNext;126 }127 printf("clearList函数执⾏,链表已经清除!\n");128129 }130131/* 5.返回链表的长度*/132int sizeList(Node *pHead)133 {134int size=0;135136while(pHead!=NULL)137 {138 size++;139 pHead=pHead->next;141 printf("sizelist函数执⾏,链表长度为%d\n",size);142return size;143 }144145/* 6.检查单链表是否为空,若为空则返回1,否则返回0 */146int isEmptyList(Node *pHead)147 {148if(pHead==NULL)149 {150 printf("isEmptylist函数执⾏,链表为空!\n");151return1;152 }153154else155 printf("isEmptylist函数执⾏,链表⾮空!\n");156return0;157158 }159160/* 7.返回链表中第post节点的数据,若post超出范围,则停⽌程序运⾏*/161int getElement(Node *pHead,int pos)162 {163int i=0;164if(pos<1)165 {166 printf("getElement函数执⾏,pos值⾮法!");167return0;168 }169if(pHead==NULL)170 {171 printf("getElement函数执⾏,链表为空!");172 }173174while (pHead!=NULL)175 {176 ++i;177if(i==pos)178 {179break;180 }181 pHead=pHead->next;182 }183if(i<pos)184 {185 printf("getElement函数执⾏,pos值超出链表长度\n");186return0;187 }188 printf("getElement函数执⾏,位置%d中的元素为%d\n",pos,pHead->element);189190return1;191 }192193//8.从单⼀链表中查找具有给定值x的第⼀个元素,若查找成功后,返回该节点data域的存储位置,否则返回NULL 194 elemType *getElemAddr(Node *pHead,elemType x)195 {196if(NULL==pHead)197 {198 printf("getEleAddr函数执⾏,链表为空");199return NULL;200 }201if(x<0)202 {203 printf("getEleAddr函数执⾏,给定值x不合法\n");204return NULL;205 }206while((pHead->element!=x)&&(NULL!=pHead->next))//判断链表是否为空,并且是否存在所查找的元素207 {208 pHead=pHead->next;209 }210if(pHead->element!=x)211 {212 printf("getElemAddr函数执⾏,在链表中没有找到x值\n");213return NULL;214 }215else216 {217 printf("getElemAddr函数执⾏,元素%d的地址为0x%x\n",x,&(pHead->element));218 }219return &(pHead->element);220221 }222223224/*9.修改链表中第pos个点X的值,如果修改成功,则返回1,否则返回0*/225int modifyElem(Node *pNode,int pos,elemType x)226 {227 Node *pHead;228 pHead=pNode;229int i=0;230if(NULL==pHead)231 {232 printf("modifyElem函数执⾏,链表为空\n");233return0;234 }235236if(pos<1)237 {238 printf("modifyElem函数执⾏,pos值⾮法\n");239return0;240 }241242while(pHead!= NULL)243 {244 ++i;245if(i==pos)246 {247break;248 }249 pHead=pHead->next;250 }251252if(i<pos)253 {254 printf("modifyElem函数执⾏,pos值超出链表长度\n");255return0;256 }257 pNode=pHead;258 pNode->element=x;259 printf("modifyElem函数执⾏,修改第%d点的元素为%d\n",pos,x);260261return1;262263 }264265/* 10.向单链表的表头插⼊⼀个元素 */266int insertHeadList(Node **pNode,elemType insertElem)267 {268 Node *pInsert;269 pInsert=(Node *)malloc(sizeof(Node));270if(pInsert==NULL) exit(1);271 memset(pInsert,0,sizeof(Node));272 pInsert->element=insertElem;273 pInsert->next=*pNode;274 *pNode=pInsert;275 printf("insertHeadList函数执⾏,向表头插⼊元素%d成功\n",insertElem);276return1;277 }278279/* 11.向单链表的末尾添加⼀个元素 */280int insertLastList(Node *pNode,elemType insertElem)281 {282 Node *pInsert;283 Node *pHead;284 Node *pTmp;285286 pHead=pNode;287 pTmp=pHead;288 pInsert=(Node *)malloc(sizeof(Node));289if(pInsert==NULL) exit(1);290 memset(pInsert,0,sizeof(Node));291 pInsert->element=insertElem;292 pInsert->next=NULL;293while(pHead->next!=NULL)294 {295 pHead=pHead->next;296 }297 pHead->next=pInsert;298 printf("insertLastList函数执⾏,向表尾插⼊元素%d成功!\n",insertElem);299return1;300 }301302/* 12.向单链表中第pos个结点位置插⼊元素为x的结点,若插⼊成功返回1,否则返回0*/ 303int isAddPos(Node *pNode,int pos,elemType x)304 {305 Node *pHead;306 pHead=pNode;307 Node *pTmp;308int i=0;309310if(NULL==pHead)311 {312 printf("AddPos函数执⾏,链表为空\n");313return0;314 }315316if(pos<1)317 {318 printf("AddPos函数执⾏,pos值⾮法\n");319return0;320 }321322while(pHead!=NULL)323 {324 ++i;325if(i==pos)326break;327 pHead=pHead->next;328 }329330if(i<pos)331 {332 printf("AddPos函数执⾏,pos值超出链表长度\n");333return0;334 }335336 pTmp=(Node *)malloc(sizeof(Node));337if(pTmp==NULL) exit(1);338 memset(pTmp,0,sizeof(Node));339 pTmp->next=pHead->next;340 pHead->next=pTmp;341 pTmp->element=x;342343 printf("AddPos函数执⾏成功,向节点%d后插⼊数值%d\n",pos,x); 344return1;345 }346347/* 13.向有序单链表中插⼊元素x结点,使得插⼊后仍然有序 */348int OrrderList(Node *pNode,elemType x)349 {350//注意如果此数值要排到⾏尾要修改本代码351 Node *pHead;352 pHead=pNode;353 Node *pTmp;354355if(NULL==pHead)356 {357 printf("OrrderList函数执⾏,链表为空\n");358return0;359 }360361if(x<1)362 {363 printf("OrrderList函数执⾏,x值⾮法\n");364return0;365 }366367while(pHead!=NULL)368 {369if((pHead->element)>=x)370break;371 pHead=pHead->next;372 }373374375if(pHead==NULL)376 {377 printf("OrrderList函数查找完毕,该函数中没有该值\n");378return0;379 }380381382 pTmp=(Node *)malloc(sizeof(Node));383if(pTmp==NULL) exit(1);384 memset(pTmp,0,sizeof(Node));385 pTmp->next=pHead->next;386 pHead->next=pTmp;387 pTmp->element=x;388389 printf("OrrderList函数成功插⼊数值%d\n",x);390return1;391 }392393/*14.从单链表中删除表头结点,并把该结点的值返回,若删除失败则停⽌程序运⾏*/ 394int DelHeadList(Node **pList)395 {396 Node *pHead;397 pHead=*pList;398if(pHead!=NULL)399 printf("DelHeadList函数执⾏,函数⾸元素为%d删除成功\n",pHead->element); 400else401 {402 printf("DelHeadList函数执⾏,链表为空!");403return0;404 }405 *pList=pHead->next;406return1;407 }408409/* 15.从单链表中删除表尾结点并返回它的值,若删除失败则停⽌程序运⾏ */410int DelLastList(Node *pNode)411 {412 Node *pHead;413 Node *pTmp;414415 pHead=pNode;416while(pHead->next!=NULL)417 {418 pTmp=pHead;419 pHead=pHead->next;420 }421 printf("链表尾删除元素%d成功!\n",pHead->element);422free(pHead);423 pTmp->next=NULL;424return1;425 }426427/* 16.从单链表中删除第pos个结点并返回它的值,若删除失败则停⽌程序运⾏ */ 428int DelPos(Node *pNode,int pos)429 {430 Node *pHead;431 pHead=pNode;432 Node *pTmp;433434int i=0;435436if(NULL==pHead)437 {438 printf("DelPos函数执⾏,链表为空\n");439return0;440 }441442if(pos<1)443 {444 printf("DelPos函数执⾏,pos值⾮法\n");445return0;446 }447448while(pHead!=NULL)449 {450 ++i;451if(i==pos)452break;453 pTmp=pHead;454 pHead=pHead->next;455 }456457if(i<pos)458 {459 printf("DelPos函数执⾏,pos值超出链表长度\n");460return0;461 }462 printf("DelPos函数执⾏成功,节点%d删除数值%d\n",pos,pHead->element); 463 pTmp->next=pHead->next;464free(pHead);465return1;466 }467468/* 17.从单链表中删除值为x的第⼀个结点,若删除成功则返回1,否则返回0 */469int Delx(Node **pNode,int x)470 {471 Node *pHead;472 Node *pTmp;473 pHead=*pNode;474int i=0;475476if(NULL==pHead)477 {478 printf("Delx函数执⾏,链表为空");479return0;480 }481if(x<0)482 {483 printf("Delx函数执⾏,给定值x不合法\n");484return0;485 }486while((pHead->element!=x)&&(NULL!=pHead->next))//判断链表是否为空,并且是否存在所查找的元素487 {488 ++i;489 pTmp=pHead;490 pHead=pHead->next;491 }492if(pHead->element!=x)493 {494 printf("Delx函数执⾏,在链表中没有找到x值\n");495return0;496 }497if((i==0)&&(NULL!=pHead->next))498 {499 printf("Delx函数执⾏,在链表⾸部找到此元素,此元素已经被删除\n");500 *pNode=pHead->next;501free(pHead);502return1;503 }504 printf("Delx函数执⾏,⾸个为%d元素被删除\n",x);505 pTmp->next=pHead->next;506free(pHead);507return1;508 }509510/* 18.交换2个元素的位置 */511int exchange2pos(Node *pNode,int pos1,int pos2)512 {513 Node *pHead;514int *pTmp;515int *pInsert;516int a;517int i=0;518519if(pos1<1||pos2<1)520 {521 printf("DelPos函数执⾏,pos值⾮法\n");522return0;523 }524525 pHead=pNode;526while(pHead!=NULL)527 {528 ++i;529if(i==pos1)530break;531 pHead=pHead->next;532 }533534if(i<pos1)535 {536 printf("DelPos函数执⾏,pos1值超出链表长度\n");537return0;538 }539540 pTmp=&(pHead->element);541 i=0;542 pHead=pNode;543while(pHead!=NULL)544 {545 ++i;546if(i==pos2)547break;548 pHead=pHead->next;549 }550551if(i<pos2)552 {553 printf("DelPos函数执⾏,pos2值超出链表长度\n");554return0;555 }556557 pInsert=&(pHead->element);558 a=*pTmp;559 *pTmp=*pInsert;560 *pInsert=a;561562 printf("DelPos函数执⾏,交换第%d个和第%d个pos点的值\n",pos1,pos2); 563return1;564 }565566int swap(int *p1,int *p2)567 {568int a;569if(*p1>*p2)570 {571 a=*p1;572 *p1=*p2;573 *p2=a;574 }575return0;576 }577578/* 19.将线性表进⾏冒泡排序 */579int Arrange(Node *pNode)580 {581 Node *pHead;582 pHead=pNode;583584int a=0,i,j;585586if(NULL==pHead)587 {588 printf("Arrange函数执⾏,链表为空\n");589return0;590 }591592while(pHead!=NULL)593 {594 ++a;595 pHead=pHead->next;596 }597598 pHead=pNode;599for(i=0;i<a-1;i++)600 {601for(j=1;j<a-i;j++)602 {603 swap(&(pHead->element),&(pHead->next->element));604 pHead=pHead->next;605 }606 pHead=pNode;607 }608 printf("Arrange函数执⾏,链表排序完毕!\n");609return0;610 }611612int main()613 {614 Node *pList=NULL;615int length=0;616617 elemType posElem;618619 initList(&pList);620 printList(pList);621622 pList=creatList(pList);623 printList(pList);624625 sizeList(pList);626 printList(pList);627628 isEmptyList(pList);629630631 posElem=getElement(pList,3);632 printList(pList);633634 getElemAddr(pList,5);635636 modifyElem(pList,4,1);637 printList(pList);638639 insertHeadList(&pList,5);640 printList(pList);641642 insertLastList(pList,10);643 printList(pList);644645 isAddPos(pList,4,5); 646 printList(pList);647648 OrrderList(pList,6);649 printList(pList);650651 DelHeadList(&pList); 652 printList(pList);653654 DelLastList(pList);655 printList(pList);656657 DelPos(pList,5);658 printList(pList);659660 Delx(&pList,5);661 printList(pList);662663 exchange2pos(pList,2,5); 664 printList(pList);665666 Arrange(pList);667 printList(pList);668669 clearList(pList);670return0;671 }。

CC++实现单向循环链表(尾指针,带头尾节点)

CC++实现单向循环链表(尾指针,带头尾节点)

CC++实现单向循环链表(尾指针,带头尾节点) C语⾔实现单向循环链表,主要功能为空链表创建,链表初始化(头插法,尾插法),链表元素读取,按位置插⼊,(有序链表)按值插⼊,按位置删除,按值删除,清空链表,销毁链表。

单向循环链表和单向链表的区别:(1)单向链表为头指针,循环链表为尾指针,头指针指向头结点,尾指针指向终端结点;(2)为统⼀⽅便操作,单向链表设置头结点,单向循环链表设置头结点和尾结点;(3)设置尾结点后,尾指针指向尾结点,插⼊,删除等操作不⽤移动尾指针。

关键思路:创建头结点和尾结点。

1 #include <stdio.h>2 #include <stdlib.h>34 typedef struct Node{5int data;6struct Node *next;7 }Node;89//空循环链表创建10//创建头结点和尾结点11//链表尾指针指向尾结点,尾结点指向头结点,头结点指向尾结点12void iniCList(Node **CListTail){13 *CListTail = (Node *)malloc(sizeof(Node));14 Node *CListHead = (Node *)malloc(sizeof(Node));15if (NULL == *CListTail || NULL == CListHead){16 exit(0);17 }1819 (*CListTail)->next = CListHead;20 CListHead->next = *CListTail;21 }2223//循环链表初始化(头插法)24void iniCListHead(Node **CListTail, int n){25//创建头尾结点26 *CListTail = (Node *)malloc(sizeof(Node));27 Node *CListHead = (Node *)malloc(sizeof(Node));28if (NULL == *CListTail || NULL == CListHead){29 exit(0);30 }3132 (*CListTail)->next = CListHead;33 CListHead->next = *CListTail;3435int i = 0;36while (i < n){3738 Node *tmpNode = (Node *)malloc(sizeof(Node));39if (NULL == tmpNode){40 exit(0);41 }42 tmpNode->data = i;43 tmpNode->next = CListHead->next;44 CListHead->next = tmpNode;45 ++i;46 }47 }4849//循环链表初始化(尾插法)50void iniCListTail(Node **CListTail, int n){51//创建头尾结点52 *CListTail = (Node *)malloc(sizeof(Node));53 Node *CListHead = (Node *)malloc(sizeof(Node));54if (NULL == *CListTail || NULL == CListHead){55 exit(0);56 }5758 (*CListTail)->next = CListHead;59 CListHead->next = *CListTail;6061 Node *pCurrent = CListHead;6263int i = 0;64while (i < n){65 Node *tmpNode = (Node *)malloc(sizeof(Node));66if (NULL == tmpNode){67 exit(0);68 }69 tmpNode->data = i;70 tmpNode->next = *CListTail;71 pCurrent->next = tmpNode;72 pCurrent = tmpNode;7374 ++i;75 }76 }7778//循环链表按位置插⼊79void insertCListPos(Node *CList, int pos, int val){ 8081 Node *pCurrent = CList->next; //指向头结点82int i = 1;83while (pCurrent != CList && i < pos){84 pCurrent = pCurrent->next;85 ++i;86 }8788 Node *tmpNode = (Node *)malloc(sizeof(Node)); 89if (NULL == tmpNode){90 exit(0);91 }92 tmpNode->data = val;93 tmpNode->next = pCurrent->next;94 pCurrent->next = tmpNode;9596 }9798//有序循环链表,按值插⼊99void insertCListValue(Node *CList, int val){100 Node *pCur = CList->next->next;101 Node *pPer = CList->next;102103while (pCur != CList && pCur->data < val){ 104 pPer = pCur;105 pCur = pCur->next;106 }107108 Node *tmpNode = (Node *)malloc(sizeof(Node)); 109if (NULL == tmpNode){110 exit(0);111 }112 tmpNode->data = val;113 tmpNode->next = pPer->next;114 pPer->next = tmpNode;115 }116117//循环链表,按位置删除118void deleteCListPos(Node *CList, int pos){119 Node *pCur = CList->next;120121int i = 1;122while (pCur != CList && i < pos){123 pCur = pCur->next;124 ++i;125 }126127 Node *tmpNode = pCur->next;128 pCur->next = tmpNode->next;129free(tmpNode);130 }131132//循环链表,按值删除133//删除空链表为出问题134void deleteCListValue(Node *CList, int val){135 Node *pCur = CList->next->next;136 Node *pPer = CList->next;137138while (pCur != CList && pCur->data != val){ 139 pPer = pCur;140 pCur = pCur->next;141 }142if (pCur == CList)143return;144else{145 pPer->next = pCur->next;146free(pCur);147 }148 }149150//循环链表,清空链表151void claerCList(Node *CList){152 Node *p = CList->next->next;153 Node *q = NULL;154155while (p != CList){ //到达表尾156 q = p->next;157free(p);158 p = q;159 }160161 CList->next = CList; //将头结点指向尾结点162 }163164//循环链表,销毁链表165void destoryCList(Node **CList){166 Node *p = (*CList)->next;167 Node *q = NULL;168169while (p != (*CList)->next){ //到达表头170 q = p->next;171free(p);172 p = q;173 }174175 *CList = NULL;176 }177178//获取元素179void getCList(Node *CList, int pos, int *val){180 Node *pCur = CList->next->next;181int i = 1;182while (pCur != CList && i < pos){183 pCur = pCur->next;184 ++i;185 }186187 *val = pCur->data;188 }189//遍历输出元素190void printCList(Node *CList){191 Node * tmpNode = CList->next->next;192while (tmpNode != CList){ //到达表尾193 printf("%d\n", tmpNode->data);194 tmpNode = tmpNode->next;195 }196 }197198199int main(){200 Node *CList = NULL;201//iniCListHead(&CList, 8);202//iniCList(&CList);203 iniCListTail(&CList, 8);204205//insertCListPos(CList, 1, 2);206//insertCListPos(CList, 2, 4);207//insertCListPos(CList, 3, 6);208//209//insertCListValue(CList, 1);210//211//deleteCListPos(CList, 3);212//213//deleteCListValue(CList, 6);214215//claerCList(CList);216217int a = 0;218 getCList(CList, 2, &a);219 printf("%d\n", a);220221 printCList(CList);222223 printf("%d\n", CList);224 destoryCList(&CList);225 printf("%d\n", CList);226227 system("pause");228return0;229 }C语⾔完整代码 通过C++实现C语⾔的链表,主要区别:(1)struct可以不通过typedef,直接使⽤Node;(2)将malloc和free更换为new和delete1 #include <stdio.h>2 #include <stdlib.h>34struct Node{5int data;6struct Node *next;7 };89//空循环链表创建10//创建头结点和尾结点11//链表尾指针指向尾结点,尾结点指向头结点,头结点指向尾结点 12void iniCList(Node **CListTail){13 *CListTail = new Node;14 Node *CListHead = new Node;1516 (*CListTail)->next = CListHead;17 CListHead->next = *CListTail;18 }1920//循环链表初始化(头插法)21void iniCListHead(Node **CListTail, int n){22//创建头尾结点23 *CListTail = new Node;24 Node *CListHead = new Node;2526 (*CListTail)->next = CListHead;27 CListHead->next = *CListTail;2829int i = 0;30while (i < n){31 Node *tmpNode = new Node;3233 tmpNode->data = i;34 tmpNode->next = CListHead->next;35 CListHead->next = tmpNode;36 ++i;37 }38 }3940//循环链表初始化(尾插法)41void iniCListTail(Node **CListTail, int n){42//创建头尾结点43 *CListTail = new Node;44 Node *CListHead = new Node;4546 (*CListTail)->next = CListHead;47 CListHead->next = *CListTail;4849 Node *pCurrent = CListHead;5051int i = 0;52while (i < n){53 Node *tmpNode = new Node;5455 tmpNode->data = i;56 tmpNode->next = *CListTail;57 pCurrent->next = tmpNode;58 pCurrent = tmpNode;5960 ++i;61 }62 }6364//循环链表按位置插⼊65void insertCListPos(Node *CList, int pos, int val){6667 Node *pCurrent = CList->next; //指向头结点68int i = 1;69while (pCurrent != CList && i < pos){70 pCurrent = pCurrent->next;71 ++i;72 }7374 Node *tmpNode = new Node;7576 tmpNode->data = val;77 tmpNode->next = pCurrent->next;78 pCurrent->next = tmpNode;7980 }8182//有序循环链表,按值插⼊83void insertCListValue(Node *CList, int val){84 Node *pCur = CList->next->next;85 Node *pPer = CList->next;8687while (pCur != CList && pCur->data < val){88 pPer = pCur;89 pCur = pCur->next;90 }9192 Node *tmpNode = new Node;9394 tmpNode->data = val;95 tmpNode->next = pPer->next;96 pPer->next = tmpNode;97 }9899//循环链表,按位置删除100void deleteCListPos(Node *CList, int pos){ 101 Node *pCur = CList->next;102103int i = 1;104while (pCur != CList && i < pos){105 pCur = pCur->next;106 ++i;107 }108109 Node *tmpNode = pCur->next;110 pCur->next = tmpNode->next;111delete tmpNode;112 }113114//循环链表,按值删除115//删除空链表为出问题116void deleteCListValue(Node *CList, int val){ 117 Node *pCur = CList->next->next;118 Node *pPer = CList->next;119120while (pCur != CList && pCur->data != val){ 121 pPer = pCur;122 pCur = pCur->next;123 }124if (pCur == CList)125return;126else{127 pPer->next = pCur->next;128delete pCur;129 }130 }131132//循环链表,清空链表133void claerCList(Node *CList){134 Node *p = CList->next->next;135 Node *q = NULL;136137while (p != CList){ //到达表尾138 q = p->next;139delete p;140 p = q;141 }142143 CList->next = CList; //将头结点指向尾结点144 }145146//循环链表,销毁链表147void destoryCList(Node **CList){148 Node *p = (*CList)->next;149 Node *q = NULL;150151while (p != (*CList)->next){ //到达表头152 q = p->next;153delete p;154 p = q;155 }156157 *CList = NULL;158 }159160//获取元素161void getCList(Node *CList, int pos, int *val){ 162 Node *pCur = CList->next->next;163int i = 1;164while (pCur != CList && i < pos){165 pCur = pCur->next;166 ++i;167 }168169 *val = pCur->data;170 }171//遍历输出元素172void printCList(Node *CList){173 Node * tmpNode = CList->next->next;174while (tmpNode != CList){ //到达表尾175 printf("%d\n", tmpNode->data);176 tmpNode = tmpNode->next;177 }178 }179180181int main(){182 Node *CList = NULL;183//iniCListHead(&CList, 8);184//iniCList(&CList);185 iniCListTail(&CList, 8);186187//insertCListPos(CList, 1, 2);188//insertCListPos(CList, 2, 4);189//insertCListPos(CList, 3, 6);190//191//insertCListValue(CList, 1);192//193//deleteCListPos(CList, 3);194//195//deleteCListValue(CList, 6);196197//claerCList(CList);198199int a = 0;200 getCList(CList, 2, &a);201 printf("%d\n", a);202203 printCList(CList);204205 printf("%d\n", CList);206 destoryCList(&CList);207 printf("%d\n", CList);208209 system("pause");210return0;211 }C++完整代码单向循环链表 注意:(1)单向循环链表销毁时,需要将头结点和尾结点删除;(2)单向循环链表插⼊,删除,遍历,清空链表时,条件从头结点或第⼀节点始,判断指针是否达到尾结点;(3)清空链表时,最后将头结点指向尾结点;(4)销毁链表时,条件从头结点始,判断条件为指针是否到达头结点,最后将指针置空。

数据结构c语言版创建单链表的代码

数据结构c语言版创建单链表的代码

数据结构c语言版创建单链表的代码单链表作为常用的线性结构之一,常常用于解决以链式方式存储数据的问题。

创建单链表需要掌握一些基础的数据结构知识以及对C语言的熟练运用。

接下来,本文将分步骤地阐述数据结构C语言版创建单链表的代码。

第一步,定义单链表结构体并定义节点类型。

在C语言中,我们可以通过结构体的方式定义单链表,其中结构体中包含两个成员变量,分别为存储数据的data和指向下一个节点的指针next。

对于节点类型,我们可以使用typedef对节点类型进行定义,例如:```struct ListNode {int data;struct ListNode *next;};typedef struct ListNode ListNode;```在以上代码中,我们首先定义了一个结构体ListNode作为单链表的元素类型,其中包含存储数据的data和指向下一个元素的指针next。

接着我们使用typedef将结构体ListNode定义为仿函数ListNode,从而使其更加方便使用。

第二步,初始化单链表。

在创建单链表之前,我们需要先将单链表的头指针初始化为NULL,表示当前链表为空。

具体代码如下:```ListNode *createLinkedList() {ListNode *head = NULL;return head;}```以上代码中,函数createLinkedList用于创建并初始化单链表,其中head表示单链表头指针,我们将其初始化为NULL。

第三步,向单链表中添加元素。

在单链表中添加元素需要借助于指针的指向关系。

具体来说,我们需要先创建新的节点,将其数据添加到节点中,然后将新节点的next指针指向之前的头节点,最后将头指针指向新节点。

具体过程如下:```ListNode *addListNode(ListNode **head, int val) {ListNode *newNode = (ListNode *)malloc(sizeof(ListNode)); newNode->data = val;newNode->next = *head;*head = newNode;return *head;}```在以上代码中,函数addListNode接收一个指向头指针的指针head,以及需要添加的元素值val。

数据结构C语言版 线性表的单链表存储结构表示和实现

数据结构C语言版 线性表的单链表存储结构表示和实现

#include 〈stdio.h>#include <malloc。

h>#include 〈stdlib.h>/*数据结构C语言版线性表的单链表存储结构表示和实现P28—31编译环境:Dev-C++ 4。

9。

9。

2日期:2011年2月10日*/typedef int ElemType;// 线性表的单链表存储结构typedef struct LNode{ElemType data; //数据域struct LNode *next;//指针域}LNode, *LinkList;// typedef struct LNode *LinkList;// 另一种定义LinkList的方法// 构造一个空的线性表Lint InitList(LinkList *L){/*产生头结点L,并使L指向此头结点,头节点的数据域为空,不放数据的。

void *malloc(size_t)这里对返回值进行强制类型转换了,返回值是指向空类型的指针类型.*/(*L)= (LinkList)malloc(sizeof(struct LNode) );if( !(*L))exit(0);// 存储分配失败(*L)-〉next = NULL;// 指针域为空return 1;}// 销毁线性表L,将包括头结点在内的所有元素释放其存储空间。

int DestroyList(LinkList *L){LinkList q;// 由于单链表的每一个元素是单独分配的,所以要一个一个的进行释放while(*L ){q = (*L)—〉next;free(*L );//释放*L = q;}return 1;}/*将L重置为空表,即将链表中除头结点外的所有元素释放其存储空间,但是将头结点指针域置空,这和销毁有区别哦。

不改变L,所以不需要用指针。

*/int ClearList( LinkList L ){LinkList p,q;p = L—〉next;// p指向第一个结点while( p ) // 没到表尾则继续循环{q = p—>next;free( p );//释放空间p = q;}L—>next = NULL; // 头结点指针域为空,链表成了一个空表return 1;}// 若L为空表(根据头结点L—〉next来判断,为空则是空表),则返回1,// 否则返回0.int ListEmpty(LinkList L){if(L—>next ) // 非空return 0;elsereturn 1;}// 返回L中数据元素个数。

C语言的循环链表和约瑟夫环

C语言的循环链表和约瑟夫环

C语言的循环链表和约瑟夫环C语言的循环链表和约瑟夫环约瑟夫问题)是一个数学的应用问题,对于学习C语言四非常挺有帮助的,下面是店铺为大家搜集整理出来的有关于C语言的循环链表和约瑟夫环,一起了解下吧!循环链表的实现单链表只有向后结点,当单链表的尾链表不指向NULL,而是指向头结点时候,形成了一个环,成为单循环链表,简称循环链表。

当它是空表,向后结点就只想了自己,这也是它与单链表的主要差异,判断node->next是否等于head。

代码实现分为四部分:1. 初始化2. 插入3. 删除4. 定位寻找代码实现:1 2 3 4 5 6 7 8 9 1 0 1 1 1 2 1 3 1void ListInit(Node *pNode){int item;Node *temp,*target;cout<<"输入0完成初始化"<<endl; cin="">>item;if(!item)return ;if(!(pNode)){ //当空表的时候,head==NULLpNode = new Node ;if(!(pNode))exit(0);//未成功申请pNode->data = item;pNode->next = pNode;}else{//for(target = pNode;target->next!=pNode;target = target->next);4 15 16 17 18 19 2 0 2 1 2 2 2 3 2 4 2 5 2 6 2 7 2 8 2 9 3 0 3 1 3 2 3 3 3 4 3 5 3temp = new Node;if(!(temp))exit(0);temp->data = item;temp->next = pNode;target->next = temp;}}}void ListInsert(Node *pNode,int i){ //参数是首节点和插入位置Node *temp;Node *target;int item;cout<<"输入您要插入的值:"<<endl; cin="">>item;if(i==1){temp = new Node;if(!temp)exit(0);temp->data = item;for(target=pNode;target->next != pNode;target = target->next);temp->next = pNode;target->next = temp;pNode = temp;}else{target = pNode;for (int j=1;j<i-1;++j) target="target-">next;temp = new Node;if(!temp)exit(0);temp->data = item;temp->next = target->next;target->next = temp;}}void ListDelete(Node *pNode,int i){Node *target,*temp;if(i==1){for(target=pNode;target->next!=pNode;target=target ->next);temp = pNode;//保存一下要删除的首节点 ,一会便于释放6 37 38 39 4 0 4 1 4 2 4 3 4 4 4 5 4 6 4 7 4 8 4 9 5 0 5 1 5 2 5 3 5 4 5 5 5 6 5 7 5pNode = pNode->next;target->next = pNode;temp;}else{target = pNode;for(int j=1;j<i-1;++j) target="target-">next;temp = target->next;//要释放的nodetarget->next = target->next->next;temp;}}int ListSearch(Node *pNode,int elem){ //查询并返回结点所在的位置Node *target;int i=1;for(target = pNode;target->data!=elem && target->next!= pNode;++i)target = target->next;if(target->next == pNode && target->data!=elem)return 0;else return i;}</i-1;++j)></i-1;++j)></endl;></endl;>5 96 0 6 1 6 2 6 3 6 4 6 5 6 6 67 68 69 7 0 7 1 7 2 7 3 7 4 7 5 7 6 7 7 7 8 7 9 8约瑟夫问题约瑟夫环(约瑟夫问题)是一个数学的'应用问题:已知n个人(以编号1,2,3…n分别表示)围坐在一张圆桌周围。

《数据结构C语言版》----第02章

《数据结构C语言版》----第02章
int ListLength(SLNode *head) { SLNode *p = head; int size = 0; while(p->next != NULL) { p = p->next; size ++; } return size; }
p size=0
head
a0
a1
(a)
...
a n 1 ∧
3.顺序表操作的效率分析
时间效率分析: 算法时间主要耗费在移动元素的操作上,因此计算时间复 杂度的基本操作(最深层语句频度) T(n)= O(移动元素次数) 而移动元素的个数取决于插入或删除元素的位置i. 若i=size,则根本无需移动(特别快); 若i=0,则表中元素全部要后移(特别慢); 应当考虑在各种位置插入(共n+1种可能)的平均移动次 数才合理。
(3)带头结点单链表和不带头结点单链表的比较
1).在带头结点单链表第一个数据元素前插入结点
p head s p head data next a0 x

a1

an-1

(a) 插入前
data next a0

a1

an-1

s
x
(b) 插入后
2).删除带头结点单链表第一个数据元素结点
p data next head
(5)取数据元素ListGet(L,
i, x)
int ListGet(SeqList L, int i, DataType *x) { if(i < 0 || i > L.size-1) { printf("参数i不合法! \n"); return 0; } else { *x = L.list[i]; return 1; } }

写出求单链表表长n的类c语言算法

写出求单链表表长n的类c语言算法

1. 概述在计算机科学中,链表是一种常见的数据结构,它由一系列结点组成,每个结点包含数据和指向下一个结点的指针。

单链表是其中一种形式,它只有一个指向下一个结点的指针。

在实际开发中,我们经常需要统计链表的长度,也就是结点的个数。

本文将介绍如何使用C语言编写一个求单链表表长n的算法。

2. 单链表数据结构在C语言中,我们可以使用结构体来表示单链表的结点,定义如下:```ctypedef struct Node {int data;struct Node* next;} Node;```其中,data表示结点中存储的数据,next是指向下一个结点的指针。

我们可以使用这个结构体来创建单链表。

3. 求单链表表长n的算法为了求单链表的表长n,我们需要遍历整个链表并统计结点的个数。

下面是一个使用C语言实现的求表长算法的示例代码:```cint lengthOfLinkedList(Node* head) {int count = 0;Node* current = head;while(current != NULL) {count++;current = current->next;}return count;}```在这段代码中,我们使用了一个循环来遍历链表,每经过一个结点就将计数器加1。

当遍历结束时,计数器的值就是链表的表长n。

4. 算法示例现在让我们来看一个使用上述算法的示例。

假设我们有一个包含5个结点的单链表:```Node 1 -> Node 2 -> Node 3 -> Node 4 -> Node 5 -> NULL ```我们可以使用以下代码来求这个链表的表长:```cNode* head = createLinkedList(); // 假设createLinkedList()是一个创建单链表的函数int length = lengthOfLinkedList(head);printf("The length of the linked list is: d\n", length);```在这个示例中,我们首先创建了一个包含5个结点的单链表,然后使用lengthOfLinkedList函数求链表的表长n,并将结果打印出来。

C语言课程设计单项链表实现工资管理系统

C语言课程设计单项链表实现工资管理系统

高级语言(C语言)课程设计说明书起止日期:2012 年07 月2 日至2012 年07 月14 日题目工资管理系统学生姓名班级学号成绩通信与信息工程学院一.课程设计要求课程设计系统组成及模块功能:工资管理程序主要完成对职工的工资信息录入,然后进行排序,统计,查询,具体要求如下:1. 职工录入工资信息包括:编号,姓名,基本工资,扣款,应发工资,税金,实发工资2.程序主菜单如下:"**************MENU*************", /*菜单的标题行*/0. init list /*初始化单链表*/1. Enter list /*输入数据,创建单链表*/2. List all /*显示所有记录*/3. Calc the salary /*计算实发工资*/4. Search record on name /*查找职工信息数据*/5. Delete a record /*删除记录*/6. Sort on sfgz /*按实发工资升序排序*/7. Computer ticket number /*计算所需票面数*/8. Total on number /*分类合计*/9. Quit /*退出*/3. 要求定义如下函数,对应菜单功能/******函数原型*********/void init(); /*单链表初始化*/void create(); /*创建单链表, 输入数据*/void calc(); /*计算实发工资*/void delete(); /*删除*/void search(); /*查找*/void computer(); /*计算所需各种票面张数*/void sort(); /*排序*/void list(); /*显示所有数据*/void print(SALARY *p); /*输出单条记录*/float fax(float x); /*计算税金*/void total(); /*分类合计*/int menu_select(); /*主菜单*/二.程序的功能设计此工资管理系统主要利用链表实现,由如下八个功能模块实现1、输入模块。

c语言单链表程序代码

c语言单链表程序代码

c语言单链表程序代码C语言单链表程序代码单链表是一种常见的数据结构,它由多个节点组成,每个节点包含一个数据域和一个指向下一个节点的指针。

以下是C语言实现单链表的程序代码:1. 定义节点结构体首先需要定义一个节点结构体,用来存储每个节点的数据和指针信息。

```typedef struct node {int data; // 数据域struct node *next; // 指向下一个节点的指针} Node;```2. 创建链表头节点创建一个头节点,它不存储任何数据,只是作为链表的起始点。

```Node *head = NULL;head = (Node*)malloc(sizeof(Node));head->next = NULL;```3. 插入新节点插入新节点时需要先创建一个新的节点,并将其插入到链表中合适的位置。

```Node *new_node = NULL;new_node = (Node*)malloc(sizeof(Node));new_node->data = new_data;// 找到插入位置Node *current = head;while (current->next != NULL && current->next->data < new_data) {current = current->next;}// 插入新节点new_node->next = current->next;current->next = new_node;```4. 删除指定数据的节点删除指定数据的节点时需要先找到该节点,并将其从链表中删除。

```// 找到要删除的节点Node *current = head;while (current->next != NULL && current->next->data != data) {current = current->next;}// 删除节点if (current->next != NULL) {Node *del_node = current->next;current->next = del_node->next;free(del_node);```5. 遍历链表遍历链表时需要从头节点开始,依次访问每个节点的数据。

假设有一个循环链表的长度大于1,且表中既无头结点也无头指针。已知S为指向链表某个结点的指针(C语言)

假设有一个循环链表的长度大于1,且表中既无头结点也无头指针。已知S为指向链表某个结点的指针(C语言)

#include <stdio.h>#include <stdlib.h>typedef struct _DLNode{struct _DLNode *next;int value;} DLNode;/** 1. 如果链有没有节点,就返回NULL* 2. 如果链表只有一个节点,输入节点的前驱节点就是它本身,则返回输入节点* 3. 如果链表有多于一个节点,就返回输入节点的前驱节点*/DLNode* getPriorNode(DLNode *node){DLNode *next;if (!node){return NULL;}next = node->next;while (node != next->next){next = next->next;}return next;}void delPriorNode(DLNode *node){DLNode *prior = getPriorNode(node);if (prior){getPriorNode(prior)->next = prior->next;/* free(prior); */ /* 只有节点是malloc的才能free */}}void printList(DLNode *node){DLNode *next;if (!node){return;}printf("%d", node->value);next = node->next;while (node != next){printf("-->%d", next->value);next = next->next;}printf("\n");}void main(){DLNode n1, n2, n3, n4, n5, n6;n1.value = 1;n2.value = 2;n3.value = 3;n4.value = 4;n5.value = 5;n6.value = 6;n1.next = &n2;n2.next = &n3;n3.next = &n4;n4.next = &n5;n5.next = &n6;n6.next = &n1;printf("Original list: ");printList(&n1);delPriorNode(&n3);printf("Deleted node third prior node(node 2): "); printList(&n1);}。

c语言单链表代码

c语言单链表代码

c语言单链表代码单链表是一种数据结构,它由一系列节点构成,每个节点都包含一个数据域和一个指向下一个节点的指针域。

在C语言中,实现单链表需要使用指针和动态内存分配。

下面分步骤阐述一下如何实现单链表的代码。

1.定义单链表节点结构体单链表的节点包含两个域,一个是数据域用于存储数据,另一个是指针域用于指向下一个节点。

定义单链表节点结构体如下:```cstruct Node {int data;struct Node* next;};```其中,data表示节点存储的数据,next表示指向下一个节点的指针。

2.创建单链表创建单链表需要考虑两个问题,一个是如何在内存中分配节点的空间,另一个是如何将各个节点连接起来。

在C语言中使用malloc函数动态分配内存。

具体步骤如下:```cstruct Node *create_list(int n) {int i;struct Node *head = NULL;//定义头节点指针,初始化为空struct Node *p, *tail;//定义节点指针p和tail,用于遍历和尾插//读入n个节点的数据for (i = 0; i < n; i++) {p = (struct Node*)malloc(sizeof(struct Node));//动态分配内存scanf("%d", &p->data);p->next = NULL;//新节点的指针要初始化为空if (head == NULL)head = p;elsetail->next = p;//将上一个节点的next指向当前节点 tail = p;//更新尾节点指针}return head;//返回头节点指针}```其中,head指向链表的第一个节点,p表示当前节点,tail表示尾节点,next指向下一个节点。

3.遍历单链表遍历单链表需要用指针从头节点开始往下遍历。

数据结构课程设计-职工信息管理系统-单链表实现程序源代码

数据结构课程设计-职工信息管理系统-单链表实现程序源代码

printf(”请你输入要查找的工号:");
scanf(”%s",findmess);
p=Locate(l,findmess,”num”);
if(p)

printf(”\t\t\t\t查找结果\n”);
printstart(); //打印横线
printc(); //打印各学科标题
printe(p); //打印p结点各个数据成员的值
printf(”\t* [7] 排序 [8] 保存职工信息 *\n");
printf(”\t* [9] 显示数据 [0] 退出系统 *\n”);
printf(”\t* *\n”);
printf("\t*****************************************************************\n”);

void Wrong()

printf("\n=====>提示:输入错误!\n");

void Nofind()

printf("\n=====〉提示:没有找到该职工!\n”);

void printc() /* 本函数用于输出中文 */
{
printf(" 工号\t 姓名 性别 部门 职称 工资 总工资 平均工资\n");
Node *p,*r; /*实现删除操作的临时的结构体指针变量*/
char findmess[20];
if(!l—〉next) //当list无后继结点时,提示和结束返回del()

printf("\n=====>提示:没有记录可以删除!\n");

C语言-链表

C语言-链表

NWPU—CC—ZhangYanChun
13

void main( )
{┇
for(i=1; i<=N; i++)
/*建立链表*/
{┇
}
for(i=1; i<=N; i++)
/*输出链表*/
{ if(i==1) p1=head;
/*p1指向首节点*/
else p1=p1->next; /*p1指向下一节点*/
第第9十页,一共2章8页。 结构体与共用体
NWPU—CC—ZhangYanChun
10
3) 重复第2步,建立并链接多个节点直至所需长
度,将末尾节点的next成员赋值0。
head
1048 p1 1370 p1
2101
2304
1012
2918
89.5
90
85
操作:
1370
1012
NULL
pp22
p2
p1=(struct student *)malloc(len);
成功,返回存储块起始指针,该指针类型为
void *;否则返回空指针(NULL)。
内存释放函数原形:void free(void *p); 功能:释放p所指向的内存块。
包含文件:malloc.h、stdlib.h中均有其原型声明。
C 程序设计
第第4十页,一共2章8页。 结构体与共用体
NWPU—CC—ZhangYanChun
第第5十页,一共2章8页。 结构体与共用体
NWPU—CC—ZhangYanChun
6
6) 链表的类型
单链表:每个节点只有一个指向后继节点的指针 双向链表:每个节点有两个用于指向其它节点的指针;

c语言多线程操作单链表

c语言多线程操作单链表

在C语言中,多线程操作单链表需要特别小心,因为这涉及到并发访问和修改共享数据的问题。

如果不正确地处理,可能会导致数据损坏或程序崩溃。

为了实现多线程操作单链表,可以使用以下方法:1. 锁机制:在访问链表之前,使用互斥锁(mutex)来保护链表,确保同一时间只有一个线程可以访问链表。

当线程需要修改链表时,需要先获取锁,然后进行修改,最后释放锁。

这样可以确保链表操作的原子性和一致性。

2. 读写锁:对于读多写少的场景,可以使用读写锁(read-write lock)。

读写锁允许多个线程同时读取链表,但只允许一个线程写入链表。

这样可以提高并发性能。

3. 条件变量:使用条件变量可以让线程等待链表发生变化。

当链表发生变化时,可以唤醒等待的线程。

这样可以避免线程频繁地检查链表是否发生变化,提高效率。

下面是一个简单的示例代码,演示了如何使用互斥锁实现多线程操作单链表:#include <stdio.h>#include <stdlib.h>#include <pthread.h>struct node {int data;struct node *next;};pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;struct node *head = NULL;void *add_node(void *arg) {pthread_mutex_lock(&mutex);struct node *new_node = (struct node *)malloc(sizeof(struct node));new_node->data = *((int *)arg);new_node->next = head;head = new_node;pthread_mutex_unlock(&mutex);return NULL;}void print_list() {pthread_mutex_lock(&mutex);struct node *p = head;while (p != NULL) {printf("%d ", p->data);p = p->next;}printf("\n");pthread_mutex_unlock(&mutex);}int main() {pthread_t tid1, tid2;int data1 = 1, data2 = 2;pthread_create(&tid1, NULL, add_node, &data1);pthread_create(&tid2, NULL, add_node, &data2);pthread_join(tid1, NULL);pthread_join(tid2, NULL);print_list(); // 输出:1 2return 0;}。

数据结构c语言版单链表心得

数据结构c语言版单链表心得

数据结构c语言版单链表心得单链表是一种常用的数据结构,它能够以链式的形式存储数据,可以动态的插入、删除等操作,非常适合于需要频繁操作数据的场景。

在C语言中,单链表的实现相对来说比较简单,但是需要掌握一些基本的指针操作技巧。

单链表的结构定义通常包含一个数据域和一个指向下一节点的指针域。

例如:```ctypedef struct Node {int data;struct Node* next;} Node;```这里我们定义了一个名为Node的结构体,其中包括一个int类型的数据域和一个指向下一个Node的指针域。

之所以要使用指针域,是因为链表不像数组那样在内存中连续存储,因此我们必须借助指针来建立节点之间的联系。

创建一个链表可以通过动态分配内存来实现,例如:```cNode* create_list() {Node* head = NULL; //头结点Node* tail = NULL; //尾结点int x;while (scanf("%d", &x) != EOF) { //读取数据直到文件末尾Node* node = (Node*)malloc(sizeof(Node)); //动态分配内存node->data = x;node->next = NULL;if (head == NULL) { //如果链表为空head = node; //头结点指向新节点}else {tail->next = node; //尾节点的指针域指向新节点}tail = node; //重置尾节点}return head;}```该函数通过使用malloc动态分配节点内存空间,然后读取数据并将其添加到链表中。

这里head和tail分别指向链表的头结点和尾结点,并且将尾结点的指针域指向新节点。

如果链表为空,则将头结点指向新节点。

遍历链表可以通过循环链表上的节点来实现,例如:```cvoid traverse_list(Node* head) {Node* node = head;while (node != NULL) { //循环链表printf("%d ", node->data);node = node->next; //指向下一个节点}}```该函数以head为参数,循环链表并输出每个节点的数据域。

数据结构(C语言版)习题及答案第二章

数据结构(C语言版)习题及答案第二章

数据结构(C语⾔版)习题及答案第⼆章习题2.1选择题1、线性表的顺序存储结构是⼀种(A)的存储结构,线性表的链式存储结构是⼀种(B)的存储结构。

A、随机存取B、顺序存取C、索引存取D、散列存取2、对于⼀个线性,既要求能够进⾏较快的插⼊和删除,⼜要求存储结构能够反映数据元素之间的逻辑关系,则应该选择(B)。

A、顺序存储⽅式B、链式存储⽅式C、散列存储⽅式D、索引存储⽅式3、已知,L是⼀个不带头结点的单链表,p指向其中的⼀个结点,选择合适的语句实现在p结点的后⾯插⼊s结点的操作(B)。

A、p->next=s ; s->next=p->next ;B、s->next=p->next ; p->next=s ;C、p->next=s ; s->next=p ;D、s->next=p ; p->next=s ;4、单链表中各结点之间的地址( C D)。

A、必须连续B、部分地址必须连续C、不⼀定连续D、连续与否都可以5、在⼀个长度为n的顺序表中向第i个元素(0A、n-iB、n-i+1C、n-i-1D、i2.2填空题1、顺序存储的长度为n的线性表,在任何位置上插⼊和删除操作的时间复杂度基本上都⼀样。

插⼊⼀个元素⼤约移动表中的(n/2)个元素,删除⼀个元素时⼤约移动表中的((n-1)/2)个元素。

2、在线性表的顺序存储⽅式中,元素之间的逻辑关系是通过(物理顺序)来体现的;在链式存储⽅式,元素之间的逻辑关系是通过(指针)体现的。

3、对于⼀个长度为n的单链表,在已知的p结点后⾯插⼊⼀个新结点的时间复杂度为(o(1)),在p结点之前插⼊⼀个新结点的时间复杂度为(o(n)),在给定值为e的结点之后插⼊⼀个新结点的时间复杂度为(o(n))。

4、在双向链表中,每个结点包含两个指针域,⼀个指向(前驱)结点,另⼀个指向(后继)结点。

5、对于循环链表来讲,逐个访问各个结点的结束判断条件是(设P为指向结点的指针,L为链表的头指针,则p->next= =L)。

  1. 1、下载文档前请自行甄别文档内容的完整性,平台不提供额外的编辑、内容补充、找答案等附加服务。
  2. 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
  3. 3、如文档侵犯您的权益,请联系客服反馈,我们会尽快为您处理(人工客服工作时间:9:00-18:30)。
//单循环链表
#include<stdio.h>
#include<stdlib.h>
typedef struct node{
int data;
struct node *next;
}list;
list *create(){//建立单循环链表,返回尾指针
int x;
list *head,*p,*rear;
s->next=q->next;
q->next=s;
}
return rear;
}
//注意:后插需要讨论是否插入点在最后一个元素,若是,尾指针需要改变。
void main(){
//建立
list *rear;
int key,x;
rear=create();
print(rear);
//给定值前插入
printf("(前插)\n输入要 插入位置 的值:");
scanf("%d",&key);
printf("输入要 插入 的值:");
scanf("%d",&x);
insert_h(rear,key,x);
print(rear);
p->data=x;
rear->next=p;
rear=p;
scanf("%d",&x);
}
rear->next=head;
return(rear);
}
void print(list *rear){ //打印链表(遍历)
list *p;
printf("\n当前链表如下:\n");
deleted=1;
}
p=q;
q=q->next;
}
if(deleted)
printf("已删除!\n");
else
printf("没有找到该节点!\n");
}
//给定值前插入新值
void insert_h(list *rear,int key,int x){
list *p,*q,*s;
s=(list*)malloc(sizeof(list));
s->data=x;
p=rear->next;
q=p->next;
while((q!=rear->next)&&q->data!=key){
p=q;
q=q->next;
}
if(q->data==key){
head=(list*)malloc(sizeof(list));
head->data=-1;
rear=head;
printf("请输入链表内容(整数),0作为结束:\n");
scanf("%d",&x);
while(x){
p=(list*)malloc(sizeof(list));
printf("输入要删除的值:");
scanf("%d",&key);
delete_keyx(rear,key);
print(rear);
}
//给定值后插入
printf("(后插)输入要 插入位置 的值:");
scanf("%d",&key);
printf("输入要 插入 值:");
scanf("%d",&x);
rear=insert_r(rear,key,x);
print(rear);
//删除给定值的结点
p=rear->next->next;
while(p!=rear->next){
printf("%5d",p->data);
p=p->next;
}
printf("\n");
}
void delete_keyx(list *rear,int keyx){//删除给定值的节点
list *p,*q;
int deleted=0;//用于标记是否删除过
p=rear->next;
q=p->next;
while(q!=rear->next){
if(q->data==keyx){
p->next=q->next;
free(q);
q=p->next;
s->next=q;
p->next=s;
}
}
//在给定值之后插入新值
list *insert_r(list *rear,int key,int x){
list *q,*s;
s=(list*)malloc(sizeof(list));
s->data=x;
q=rear->next->next;
while((q!=rear->next)&&q->data!=key){
q=q->next;
}
if(q->data==key&&q==rear){
s->next=q->next;
q->next=s;
rear=s;
}
else if(q->data==key){
相关文档
最新文档