双向链表(C语言版)

合集下载

链表的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 }。

数据结构c语言版试题及答案

数据结构c语言版试题及答案

数据结构c语言版试题及答案一、选择题(每题2分,共10分)1. 在C语言中,以下哪个关键字用于定义结构体?A. structB. unionC. enumD. typedef答案:A2. 若有一个结构体数组,下列哪个函数可以用来初始化数组中的每个元素?A. memsetB. memcpyC. strcpyD. bzero答案:A3. 在C语言中,以下哪个函数用于动态分配内存?A. mallocB. callocC. reallocD. all of the above答案:D4. 对于一个链表,以下哪个操作是正确的?A. 插入节点B. 删除节点C. 遍历链表D. all of the above答案:D5. 在C语言中,以下哪个函数用于释放动态分配的内存?A. freeB. mallocC. callocD. realloc答案:A二、填空题(每题3分,共15分)1. 结构体定义的关键字是______。

答案:struct2. 在C语言中,动态分配内存失败时,malloc函数返回______。

答案:NULL3. 单链表的头节点指针通常初始化为______。

答案:NULL4. 双向链表中,每个节点包含______个指针。

答案:两个5. 树的深度优先遍历包括______、中序遍历和后序遍历。

答案:前序遍历三、简答题(每题5分,共20分)1. 请简述C语言中结构体和联合体的区别。

答案:结构体(struct)可以包含不同类型的数据,并且可以有多个实例;联合体(union)可以包含不同类型的数据,但是只能有一个实例,即在任意时刻只能存储其中一个成员的值。

2. 动态内存分配的优点是什么?答案:动态内存分配允许程序在运行时根据需要分配内存,这样可以更有效地使用内存资源,并且可以创建大小不固定的数据结构。

3. 链表相比于数组有哪些优点?答案:链表的优点包括动态大小,可以灵活地插入和删除节点,不需要预先知道数据的大小。

双向链表逆序

双向链表逆序

双向链表逆序双向链表的逆序操作可以通过修改节点之间的引用关系来实现。

具体步骤如下:1. 定义三个指针:pre表示当前节点的前一个节点,cur表示当前节点,next表示当前节点的后一个节点;2. 遍历整个链表,初始时将pre设置为null,cur设置为链表的头节点;3. 在遍历过程中,先将next指向cur的后一个节点;4. 将cur的next指向pre,将cur的prev指向next。

5. 更新pre和cur,将cur指向next,pre指向cur;6. 重复步骤3~5,直到遍历到链表的最后一个节点。

7. 将最后一个节点的prev指向null,表示链表逆序完成。

以下是Java代码示例:```public class DoublyLinkedList {Node head;class Node {int data;Node prev;Node next;Node(int d) {data = d;prev = null;next = null;}}public void reverse() {Node temp = null;Node current = head;while (current != null) {temp = current.prev;current.prev = current.next;current.next = temp;current = current.prev;}if (temp != null) {head = temp.prev;}}}```注意:逆序之后,原来的头结点会变成尾结点,原来的尾结点会变成头结点。

数据结构考研辅导(潭浩强 C语言版)

数据结构考研辅导(潭浩强 C语言版)

第一讲绪论(对应教材p1—p17)一、数据结构1、什么是数据结构我们大家知道许多非数值计算问题的数学模型常常是数学方程,如线性方程组、微分方程。

所以这类非数值计算问题的解决就归结于对数学模型设计算法、编写程序。

然而在现实社会中存在着许多非数值计算问题,其数学模型难以用数学方程描述。

如●图书馆的书目检索自动化问题----计算机处理的对象之间存在着线性关系,称为线性的数据结构。

●人机对奕问题----计算机处理的对象是一个个格局。

所有可能出现的格局是一棵倒置的树。

●多岔路口交通灯的管理问题----数学模型是图的数学结构。

非数值计算问题的数学模型是表、树和图之类的数据结构。

数据结构:是一门研究非数值计算的程序设计问题中计算机操作对象以及它们之间关系和操作的一门学科。

(三个要素:对象、关系及操作(运算))2、《数据结构》课程1968年美国克努特教授开创了数据结构的最初体系:数据的逻辑结构和存储结构及其操作。

数据结构是一门综合性的专业课程,是一门介于数学、计算机硬件、计算机软件之间的一门核心课程。

是设计和实现编译系统、操作系统、数据库系统及其他系统程序和大型应用程序的基础。

二、基本概念和术语1、数据数据:是指所有能输入到计算机中并被计算机程序处理的符号的总称。

是计算机加工的“原料”。

数据元素:是数据的基本单位,在计算机程序中通常作为一个整体进行考虑和处理。

数据项:有时,一个数据元素可由多个数据项组成。

数据项是数据的不可分割的最小单位。

2、数据对象、数据结构数据对象:是性质相同的数据元素的集合,是数据的一个子集。

数据结构:是相互之间存在一种或多种特定关系的数据元素的集合。

四类基本结构:集合、线性结构、树形结构、图形结构或网状结构。

数据结构的形式定义:数据结构是一个二元组Data_Structure=(D,S)其中,D 是数据元素的有限集, S 是D上关系的有限集。

例:复数 Complex=(C,R)例:课题小组 Group=(P,R)P={T,G1,…,Gn,S11,…,Snm}1≤n≤3,1≤m≤2,R={R1,R2}R1={<T,Gi> |1≤i≤n, 1≤n≤3,}R2={<Gi,Sij> |1≤i≤n, 1≤j≤m,1≤m≤2,}数据结构一般包括三方面的内容:①逻辑结构:数据元素之间的逻辑关系。

数据结构 (C语言版) (第二版)(目录)

数据结构 (C语言版) (第二版)(目录)

数据结构(C语言版)(第二版)(目录)第1章导论
1 算法和数据结构
2 什么是数据结构
3 符号,引理,定理与证明
4 说明文篇
5 C语言和程序设计
6 总结
第2章算法分析
1 算法的衡量标准
2 时间和空间复杂度分析
3 运行时复杂度分析
4 递归分析
第3章线性表
1 一维数组
2 线性表
3 顺序表
4 链表
5 循环链表
6 树表
7 双向链表
第4章栈
1 栈的定义
2 栈的抽象数据类型
3 栈的基本操作
4 栈的应用——后缀表达式的求算
第7章树
1 树的定义
2 树的抽象数据类型
3 树的存储
4 树的遍历
5 二叉树
6 二叉排序树(搜索树)
7 平衡二叉树
8 哈夫曼树
9 图的存储
第8章查找
1 静态查找
2 哈希表
3 动态单值查找
第10章数据结构综合应用
1 树的遍历
2 贪心法
3 回溯法
4 分析与评价
附录 A C语言库
1 算法入口及时区函数
2 内存处理函数
3 字符串处理函数
4 文件处理函数
附录 B 内存分配方式。

C语言链表题目及答案

C语言链表题目及答案

下面哪种选项描述了链表的特点?A) 可以随机访问元素B) 拥有固定大小的内存空间C) 元素之间通过指针连接D) 可以自动调整大小答案: C在链表中,头节点的作用是什么?A) 存储链表的长度B) 存储链表的最后一个节点C) 存储链表的第一个节点D) 存储链表的中间节点答案: C下面哪种选项描述了双向链表的特点?A) 每个节点只有一个指针指向下一个节点B) 每个节点只有一个指针指向上一个节点C) 每个节点同时拥有指向前一个节点和后一个节点的指针D) 只能从链表的一端进行操作答案: C在链表中,删除一个节点的操作涉及修改哪些指针?A) 只需要修改被删除节点的前一个节点的指针B) 只需要修改被删除节点的后一个节点的指针C) 需要修改被删除节点的前一个节点和后一个节点的指针D) 不需要修改任何指针答案: C在链表的尾部添加一个新节点的操作复杂度是多少?A) O(1)B) O(n)C) O(log n)D) O(n^2)答案: A如何遍历链表的所有节点?A) 使用for循环B) 使用while循环C) 使用递归函数D) 使用if语句答案: B在链表中,如何找到特定值的节点?A) 使用线性搜索B) 使用二分搜索C) 使用递归搜索D) 使用栈搜索答案: A链表和数组相比,哪个更适合频繁插入和删除操作?A) 链表B) 数组C) 二叉树D) 堆栈答案: A在链表中,如何在指定位置插入一个新节点?A) 修改前一个节点的指针B) 修改后一个节点的指针C) 修改当前节点的指针D) 不需要修改任何指针答案: A链表的头指针指向什么?A) 链表的第一个节点B) 链表的最后一个节点C) 链表的中间节点D) 链表的空节点答案: A链表中节点的个数称为什么?A) 链表的长度B) 链表的高度C) 链表的宽度D) 链表的容量答案: A在链表中,如何删除指定值的节点?A) 修改前一个节点的指针B) 修改后一个节点的指针C) 修改当前节点的指针D) 不需要修改任何指针答案: A单链表的最后一个节点指向什么?A) 链表的第一个节点B) 链表的最后一个节点C) NULLD) 链表的中间节点答案: C双向链表相比于单向链表的优势是什么?A) 占用更少的内存空间B) 遍历速度更快C) 可以从任意方向遍历D) 插入和删除操作更快答案: C在链表中,如何找到倒数第n个节点?A) 遍历整个链表B) 使用递归函数C) 使用栈数据结构D) 使用双指针技巧答案: D链表的删除操作和数组的删除操作的时间复杂度分别是什么?A) 链表的删除操作为O(1),数组的删除操作为O(n)B) 链表的删除操作为O(n),数组的删除操作为O(1)C) 链表的删除操作为O(n),数组的删除操作为O(n)D) 链表的删除操作为O(1),数组的删除操作为O(1)答案: A在链表中,如何判断链表是否为空?A) 检查头指针是否为NULLB) 检查尾指针是否为NULLC) 检查链表的长度是否为0D) 检查链表的第一个节点是否为NULL答案: A链表的逆序操作是指什么?A) 删除链表中的节点B) 反转链表中节点的顺序C) 插入节点到链表的尾部D) 在链表中查找指定值的节点答案: B在链表中,如何查找指定值的节点?A) 使用线性搜索B) 使用二分搜索C) 使用递归搜索D) 使用栈搜索答案: A在双向链表中,如何删除指定值的节点?A) 修改前一个节点的指针B) 修改后一个节点的指针C) 修改当前节点的指针D) 不需要修改任何指针答案: A链表的插入操作和数组的插入操作的时间复杂度分别是什么?A) 链表的插入操作为O(1),数组的插入操作为O(n)B) 链表的插入操作为O(n),数组的插入操作为O(1)C) 链表的插入操作为O(n),数组的插入操作为O(n)D) 链表的插入操作为O(1),数组的插入操作为O(1)答案: A如何删除单向链表中的重复节点?A) 使用递归算法B) 使用双指针技巧C) 使用栈数据结构D) 不需要额外操作,链表会自动去重答案: B链表的优势之一是什么?A) 随机访问速度快B) 占用内存空间少C) 插入和删除操作高效D) 支持高级操作如排序和搜索答案: C在链表中,如何找到中间节点?A) 遍历整个链表B) 使用递归函数C) 使用栈数据结构D) 使用快慢指针技巧答案: D在链表中,如何在尾部添加一个新节点?A) 修改前一个节点的指针B) 修改后一个节点的指针C) 修改当前节点的指针D) 创建一个新节点并更新尾指针答案: D链表的查找操作的时间复杂度是多少?A) O(1)B) O(log n)C) O(n)D) O(n^2)答案: C在双向链表中,如何找到倒数第n个节点?A) 从头节点开始遍历B) 从尾节点开始遍历C) 使用递归函数D) 使用双指针技巧答案: B链表的删除操作的时间复杂度是多少?A) O(1)B) O(log n)C) O(n)D) O(n^2)答案: A链表和数组相比,哪个更适合频繁插入和删除操作?A) 链表B) 数组C) 哈希表D) 栈答案: A如何判断链表是否有环?A) 使用线性搜索B) 使用递归算法C) 使用快慢指针技巧D) 使用栈数据结构答案: C在链表中,如何反转链表的顺序?A) 使用递归算法B) 使用栈数据结构C) 使用双指针技巧D) 使用循环迭代答案: D在链表中,如何删除所有节点?A) 依次删除每个节点B) 修改头指针为NULLC) 修改尾指针为NULLD) 不需要额外操作,链表会自动清空答案: A链表的头节点是什么?A) 链表的第一个节点B) 链表的最后一个节点C) 链表的中间节点D) 链表的空节点答案: A在链表中,如何插入一个新节点到指定位置之前?A) 修改前一个节点的指针B) 修改后一个节点的指针C) 修改当前节点的指针D) 不需要修改任何指针答案: A在链表中,如何删除指定位置的节点?A) 修改前一个节点的指针B) 修改后一个节点的指针C) 修改当前节点的指针D) 不需要修改任何指针答案: A单向链表和双向链表的区别是什么?A) 单向链表只有一个指针指向下一个节点,双向链表有两个指针分别指向前一个节点和后一个节点B) 单向链表只能从头到尾遍历,双向链表可以从头到尾或者从尾到头遍历C) 单向链表只能在尾部添加节点,双向链表可以在头部和尾部都添加节点D) 单向链表只能包含整型数据,双向链表可以包含任意类型的数据答案: A链表的删除操作和数组的删除操作的时间复杂度分别是什么?A) 链表的删除操作为O(1),数组的删除操作为O(n)B) 链表的删除操作为O(n),数组的删除操作为O(1)C) 链表的删除操作为O(n),数组的删除操作为O(n)D) 链表的删除操作为O(1),数组的删除操作为O(1)答案: A如何判断两个链表是否相交?A) 比较链表的长度是否相等B) 比较链表的头节点是否相等C) 比较链表的尾节点是否相等D) 比较链表中的所有节点是否相等答案: B链表和数组的主要区别是什么?A) 链表是一种线性数据结构,数组是一种非线性数据结构B) 链表的长度可变,数组的长度固定C) 链表支持随机访问,数组只能顺序访问D) 链表的插入和删除操作效率高,数组的访问效率高答案: B在链表中,如何找到倒数第k个节点?A) 从头节点开始遍历,直到倒数第k个节点B) 从尾节点开始遍历,直到倒数第k个节点C) 使用递归函数查找倒数第k个节点D) 使用双指针技巧,一个指针先移动k步,然后两个指针同时移动直到第一个指针到达链表末尾答案: D在链表中,如何判断是否存在环?A) 使用线性搜索,检查是否有重复的节点B) 使用递归算法,判断节点是否已经访问过C) 使用栈数据结构,检查节点是否已经入栈D) 使用快慢指针技巧,如果两个指针相遇,则存在环答案: D如何将两个有序链表合并成一个有序链表?A) 创建一个新链表,依次比较两个链表的节点并插入新链表中B) 将第一个链表的尾节点指向第二个链表的头节点C) 将第二个链表的尾节点指向第一个链表的头节点D) 使用递归算法,依次比较两个链表的节点并合并答案: A在链表中,如何删除重复的节点?A) 使用递归算法,遍历链表并删除重复的节点B) 使用双指针技巧,依次比较相邻节点并删除重复的节点C) 使用栈数据结构,检查节点是否已经入栈并删除重复的节点D) 不需要额外操作,链表会自动去重答案: B链表的优点是什么?A) 占用内存空间少B) 插入和删除操作高效C) 支持高级操作如排序和搜索D) 可以随机访问任意位置的元素答案: B。

lru算法c语言

lru算法c语言

lru算法c语言LRU算法是Least Recently Used的缩写,即最近最少使用算法。

它是一种用于页面置换的算法,主要用于操作系统中对内存进行管理。

其基本思想是将最近最少使用的页面淘汰掉,从而保留当前正在使用的页面。

在实现LRU算法时,需要使用一个数据结构——双向链表。

链表中每个节点都表示一个页面,其中包含了该页面的编号、访问时间等信息。

当访问一个页面时,如果该页面已经存在于链表中,则将其移到链表头部;如果该页面不存在于链表中,则将其加入链表头部,并删除链表尾部的节点。

以下是C语言实现LRU算法的代码:```c#include <stdio.h>#include <stdlib.h>#define CACHE_SIZE 4typedef struct Node {int data;struct Node* prev;struct Node* next;} Node;Node* head = NULL;Node* tail = NULL;int cache[CACHE_SIZE];int cache_index = 0;void insert(int data) {// 如果缓存未满,则直接插入新节点到双向链表头部 if (cache_index < CACHE_SIZE) {Node* node = (Node*)malloc(sizeof(Node)); node->data = data;node->prev = NULL;node->next = head;if (head == NULL) {tail = node;} else {head->prev = node;}head = node;cache[cache_index++] = data;} else {// 如果缓存已满,则删除双向链表尾部节点,并将新节点插入到头部int last_data = tail->data;Node* last_node = tail;tail = tail->prev;if (tail != NULL) {tail->next = NULL;} else {head = NULL;}free(last_node);Node* node = (Node*)malloc(sizeof(Node));node->data = data;node->prev = NULL;node->next = head;if (head == NULL) {tail = node;} else {head->prev = node;}head = node;for (int i = 0; i < CACHE_SIZE; i++) { if (cache[i] == last_data) {cache[i] = data;break;}}}}void print_cache() {printf("Cache: ");for (int i = 0; i < CACHE_SIZE; i++) { printf("%d ", cache[i]);}printf("\n"); }int main() {insert(1);print_cache();insert(2);print_cache();insert(3);print_cache();insert(4);print_cache();insert(5);print_cache();insert(6);print_cache();return 0;}```在上述代码中,我们使用了一个数组cache来保存当前缓存中的页面编号。

c语言中linklist类型

c语言中linklist类型

c语言中linklist类型LinkList类型是C语言中常用的数据结构之一,用于表示链表。

链表是一种动态数据结构,它可以根据需要动态地分配和释放内存空间,比较灵活。

在本文中,我们将深入探讨LinkList类型及其相关操作。

一、什么是链表链表是一种由节点组成的数据结构,每个节点包含数据和指向下一个节点的指针。

链表中的节点可以按照任意顺序存储,通过指针将它们连接起来。

与数组相比,链表的插入和删除操作更加高效,但是访问元素的效率较低。

链表分为单向链表和双向链表两种形式,本文主要介绍单向链表。

二、LinkList类型的定义在C语言中,我们通过结构体来定义链表节点的数据结构,具体定义如下:```ctypedef struct Node{int data;struct Node *next;}Node;typedef Node *LinkList;```其中,Node表示链表的节点类型,LinkList表示链表的类型。

三、LinkList类型的常用操作1. 初始化链表初始化链表主要是将链表的头指针置空,表示链表为空。

具体实现如下:```cvoid InitList(LinkList *L){*L = NULL;}```2. 判断链表是否为空判断链表是否为空可以通过判断链表的头指针是否为空来实现。

具体实现如下:```cint ListEmpty(LinkList L){return L == NULL;}```3. 求链表的长度求链表的长度即统计链表中节点的个数。

具体实现如下:```cint ListLength(LinkList L){int count = 0;Node *p = L;while(p != NULL){count++;p = p->next;}return count;}```4. 插入节点插入节点可以在链表的任意位置插入新的节点。

具体实现如下:```cint ListInsert(LinkList *L, int pos, int data){if(pos < 1 || pos > ListLength(*L) + 1){return 0;}Node *p = *L;Node *newNode = (Node*)malloc(sizeof(Node));newNode->data = data;newNode->next = NULL;if(pos == 1){newNode->next = *L;*L = newNode;}else{for(int i = 1; i < pos - 1; i++){p = p->next;}newNode->next = p->next;p->next = newNode;}return 1;}```5. 删除节点删除节点可以删除链表中指定位置的节点。

数据结构中的双向链表实现和应用场景

数据结构中的双向链表实现和应用场景

数据结构中的双向链表实现和应用场景双向链表是一种常用的数据结构,它在许多实际应用中都发挥着重要的作用。

本文将介绍双向链表的实现原理以及一些常见的应用场景。

一、双向链表的实现原理双向链表由一系列节点组成,每个节点包含两个指针,一个指向前一个节点,一个指向后一个节点。

相比于单向链表,双向链表可以实现双向遍历,提高了一些操作的效率。

1.1 节点定义双向链表的节点通常由数据域和两个指针域组成,例如:```struct Node {int data; // 节点数据Node* prev; // 前一个节点指针Node* next; // 后一个节点指针};```1.2 插入操作在双向链表中插入一个节点可以分为两种情况:在表头插入和在表尾插入。

在表头插入时,只需修改原来头节点的prev指针为新节点的地址,并将新节点的next指针指向原头节点即可。

在表尾插入时,需要先找到原来的尾节点,然后将尾节点的next指针指向新节点的地址,并将新节点的prev指针指向尾节点的地址。

1.3 删除操作删除操作与插入操作类似,同样分为在表头和表尾删除节点。

在表头删除时,只需将头节点的next指针指向新的头节点,同时将新头节点的prev指针置为空。

在表尾删除时,需要先找到尾节点的前一个节点,然后将该节点的next指针置为空。

1.4 查找操作双向链表支持从前向后和从后向前两种遍历方式。

从前向后遍历时,我们可以利用节点的next指针不断向后遍历得到所有节点。

同样,从后向前遍历时,可以利用节点的prev指针不断向前遍历得到所有节点。

二、双向链表的应用场景双向链表广泛应用于各种软件和系统中,下面列举了一些常见的应用场景。

2.1 浏览器的历史记录在浏览器中,经常需要记录用户浏览过的网页历史记录。

这时可以使用双向链表来实现。

每当用户访问一个新的网页,就在双向链表中插入一个新节点,同时将新节点的next指针指向前一个节点,prev指针指向后一个节点。

《C语言链表》课件

《C语言链表》课件
了解如何删除链表中的指定节点
详细描述
删除链表中的节点需要找到要删除的节点,修改其前一个节点的指针,使其指向要删除节点的下一个 节点,然后将要删除节点的指针置为NULL。如果要删除的是头节点或尾节点,还需要对头指针或尾 指针进行相应的修改。
遍历链表
总结词
了解如何遍历链表中的所有节点
VS
详细描述
遍历链表需要从头节点开始,依次访问每 个节点,直到达到链表的尾部。在遍历过 程中,可以使用一个指针变量来指向当前 节点,每次循环将指针向后移动一个节点 ,即修改指针的next指针。
链表和循环链表的主要区别在于它们的最后一个节点指向的方向。在链表中,最后一个节点指向NULL; 而在循环链表中,最后一个节点指向第一个节点。循环链表具有更好的性能,但实现起来相对复杂一些 。
05
总结与展望
总结链表的重要性和应用场景
总结1
链表作为C语言中一种基本的数据结构,在计算机科学中 有着广泛的应用。通过学习链表,可以更好地理解数据 结构的基本概念,提高编程能力和解决实际问题的能力 。
详细描述
合并两个有序链表可以通过比较两个链表的 节点值来实现。从头节点开始比较,将较小 的节点添加到结果链表中,并将指针向后移 动。重复此过程直到其中一个链表为空。如 果还有剩余的节点,将其添加到结果链表的 末尾。这种方法的时间复杂度为O(n),其中
n为两个链表中节点的总数。
04
常见错误与注意事项
内存泄漏问题
内存泄漏定义
在C语言中,内存泄漏是指在使用动 态内存分配函数(如malloc、calloc 、realloc等)分配内存后,未能正确 释放这些内存,导致程序运行过程中 不断占用越来越多的内存,最终可能 导致程序崩溃或性能下降。

c语言数据结构及算法

c语言数据结构及算法

C语言是一种广泛应用于编程和软件开发的编程语言,它提供了一系列的数据结构和算法库,使得开发者能够在C语言中使用这些数据结构和算法来解决各种问题。

以下是C语言中常用的数据结构和算法:数据结构:1. 数组(Array):一组相同类型的元素按顺序排列而成的数据结构。

2. 链表(Linked List):元素通过指针连接而成的数据结构,可分为单向链表、双向链表和循环链表等。

3. 栈(Stack):具有后进先出(LIFO)特性的数据结构,可用于实现函数调用、表达式求值等。

4. 队列(Queue):具有先进先出(FIFO)特性的数据结构,可用于实现任务调度、缓冲区管理等。

5. 树(Tree):一种非线性的数据结构,包括二叉树、二叉搜索树、堆、A VL树等。

6. 图(Graph):由节点和边组成的数据结构,可用于表示网络、关系图等。

7. 哈希表(Hash Table):基于哈希函数实现的数据结构,可用于高效地查找、插入和删除元素。

算法:1. 排序算法:如冒泡排序、插入排序、选择排序、快速排序、归并排序等。

2. 查找算法:如线性查找、二分查找、哈希查找等。

3. 图算法:如深度优先搜索(DFS)、广度优先搜索(BFS)、最短路径算法(Dijkstra、Floyd-Warshall)、最小生成树算法(Prim、Kruskal)等。

4. 字符串匹配算法:如暴力匹配、KMP算法、Boyer-Moore 算法等。

5. 动态规划算法:如背包问题、最长公共子序列、最短编辑距离等。

6. 贪心算法:如最小生成树问题、背包问题等。

7. 回溯算法:如八皇后问题、0-1背包问题等。

这只是C语言中常用的一部分数据结构和算法,实际上还有更多的数据结构和算法可以在C语言中实现。

开发者可以根据具体需求选择适合的数据结构和算法来解决问题。

同时,C语言也支持自定义数据结构和算法的实现,开发者可以根据需要进行扩展和优化。

数据结构(C语言版)(第2版)课后习题答案

数据结构(C语言版)(第2版)课后习题答案

精品文档考试教学资料施工组织设计方案数据结构(C语言版)(第2版)课后习题答案李冬梅2015.3目录第1章绪论 (1)第2章线性表 (5)第3章栈和队列 (13)第4章串、数组和广义表 (26)第5章树和二叉树 (33)第6章图 (42)第7章查找 (54)第8章排序 (65)第1章绪论1.简述下列概念:数据、数据元素、数据项、数据对象、数据结构、逻辑结构、存储结构、抽象数据类型。

答案:数据:是客观事物的符号表示,指所有能输入到计算机中并被计算机程序处理的符号的总称。

如数学计算中用到的整数和实数,文本编辑所用到的字符串,多媒体程序处理的图形、图像、声音、动画等通过特殊编码定义后的数据。

数据元素:是数据的基本单位,在计算机中通常作为一个整体进行考虑和处理。

在有些情况下,数据元素也称为元素、结点、记录等。

数据元素用于完整地描述一个对象,如一个学生记录,树中棋盘的一个格局(状态)、图中的一个顶点等。

数据项:是组成数据元素的、有独立含义的、不可分割的最小单位。

例如,学生基本信息表中的学号、姓名、性别等都是数据项。

数据对象:是性质相同的数据元素的集合,是数据的一个子集。

例如:整数数据对象是集合N={0,±1,±2,…},字母字符数据对象是集合C={‘A’,‘B’,…,‘Z’,‘a’,‘b’,…,‘z’},学生基本信息表也可是一个数据对象。

数据结构:是相互之间存在一种或多种特定关系的数据元素的集合。

换句话说,数据结构是带“结构”的数据元素的集合,“结构”就是指数据元素之间存在的关系。

逻辑结构:从逻辑关系上描述数据,它与数据的存储无关,是独立于计算机的。

因此,数据的逻辑结构可以看作是从具体问题抽象出来的数学模型。

存储结构:数据对象在计算机中的存储表示,也称为物理结构。

抽象数据类型:由用户定义的,表示应用问题的数学模型,以及定义在这个模型上的一组操作的总称。

具体包括三部分:数据对象、数据对象上关系的集合和对数据对象的基本操作的集合。

28课有的人课堂笔记

28课有的人课堂笔记

28课有的人课堂笔记
《数据结构(C语言实现》第28课课堂笔记:
一、本节主要内容
1. 双向链表的定义及使用场景
2. 实现双向链表的增删改查
3. 内存分配及释放等操作
二、双向链表
1. 双向链表结构体:
struct Node
{
DataType data;
struct Node *prior;
struct Node *next;
}
2. 双向链表的特点:
双向链表和单链表一样,是一种物理存储结构,其每个元素的数据域和地址域是分链式存储的,元素自身的地址不固定,而是由前驱和后继相互关联。

有前驱和后继指针 for establishing the link,它没有像数组
那样存在规律性,是一种不连续存储结构。

三、双向链表的基本操作
1. 创建双向链表
以头结点作为哨兵,该结点存在于链表第一个结点前面;注意,头结点不存放数据,它只是“占位置”,而是指向链表第一个有效结点。

函数声明:struct Node* createList();
2. 增
head = addListFront(head,data);
3. 删
head = deleteList(head,data);
4. 改
updateList(head,data,newData);
5. 查
struct Node *findData(head,data);
四、双向链表的应用
双向链表通常用于在给定的元素中插入或删除元素,因为它提供了删除和插入操作的前后顺序遍历。

此外,可以使用双向链表实现一个队列,链表头指定插入位置,链表尾指定删除位置。

数据结构--数组、单链表和双链表介绍以及双向链表

数据结构--数组、单链表和双链表介绍以及双向链表

数据结构--数组、单链表和双链表介绍以及双向链表数组:数组有上界和下界,数组的元素在上下界内是连续的。

数组的特点是:数据是连续的;随机访问速度快。

数组中稍微复杂⼀点的是多维数组和动态数组。

对于C语⾔⽽⾔,多维数组本质上也是通过⼀维数组实现的。

⾄于动态数组,是指数组的容量能动态增长的数组;对于C语⾔⽽⾔,若要提供动态数组,需要⼿动实现;⽽对于C++⽽⾔,STL提供了Vector。

单向链表:单向链表(单链表)是链表的⼀种,它由节点组成,每个节点都包含下⼀个节点的指针。

表头为空,表头的后继节点是"节点10"(数据为10的节点),"节点10"的后继节点是"节点20"(数据为10的节点),"节点20"的后继节点是"节点30"(数据为20的节点),"节点30"的后继节点是"节点40"(数据为10的节点),......删除"节点30"删除之前:"节点20" 的后继节点为"节点30",⽽"节点30" 的后继节点为"节点40"。

删除之后:"节点20" 的后继节点为"节点40"。

在"节点10"与"节点20"之间添加"节点15"添加之前:"节点10" 的后继节点为"节点20"。

添加之后:"节点10" 的后继节点为"节点15",⽽"节点15" 的后继节点为"节点20"。

单链表的特点是:节点的链接⽅向是单向的;相对于数组来说,单链表的的随机访问速度较慢,但是单链表删除/添加数据的效率很⾼。

双向链表上的插入和删除算法

双向链表上的插入和删除算法

编写程序,演示在双向链表上的插入和删除算法。

问题分析:1、在双向链表上操作首先要生成一个双向链表:1>节点定义struct DuLNode{ElemType data;DuLNode *prior;DuLNode *next;};2.> 创建双列表L=(DuLinkList)malloc(sizeof(DuLNode));L->next=L->prior=L;3>输入链表数据;2、3、对向链表进行插入操作算法:在节点p的前面加入一个新的节点q:q=(DuLinkList)malloc(sizeof(DuLNode));q->data=e;q->prior=p->prior;q->next=p;p->prior->next=q;p->prior=q;4、对双向链表进行删除操作算法删除给定节点p得到的代码如下:#include<iostream>#include<malloc.h>#define OK 1#define ERROR 0using namespace std;typedef int ElemType;typedef int status;struct DuLNode{ ElemType data;DuLNode *prior;DuLNode *next;};typedef DuLNode *DuLinkList;status DuListInsert_L(DuLinkList L,int i , ElemType e)//插入函数{DuLinkList p=L; //定义两个指向头节点的指针DuLinkList q=L;int j=0;while(p->next!=L&&j<i) //判断p是否到最后一个数据{p=p->next;j++;}if(p->next==L||j<i) //如果p是最后一个节点或者插入位置大于链表节点数{printf("无效的插入位置!\n");return ERROR;}//创建新节点q,数据为e,指针为nullq=(DuLinkList)malloc(sizeof(DuLNode));q->data=e;q->prior=p->prior;q->next=p;p->prior->next=q;p->prior=q;return OK;}status DuListDelete_L(DuLinkList L,int i , ElemType &e)//删除{DuLinkList p=L;int j=0;while(p->next!=L&&j<i){p=p->next;j++;}if(p->next==L||j<i){return ERROR;}p->prior->next=p->next;p->next->prior=p->prior;e=p->data;free(p);return OK;}int main(){ //初始化双向循环链表LDuLinkList L;L=(DuLinkList)malloc(sizeof(DuLNode)); //创建空双列表头结点L->next=L->prior=L;DuLNode *p,*q;ElemType e;//给L赋初始值p=L;q=L;while(cin>>e){p->next=(DuLNode*)malloc(sizeof(DuLNode));//分配新的节点q=p;p=p->next; //p指向新的节点p->data=e; //新结点的数据域为刚输入的ep->next=L; //新结点的指针域为头结点,表示这是单链表的最后一个结点p->prior=q;L->prior=p;}//p指向头指针,逐一输出链表的每个结点的值p=L;while(p->next!=L) //输出原列表{cout<<p->next->data<<' ';p=p->next;}cin.clear(); //清除上一个cin的错误信息cin.ignore(); //清空输入流int i;cout<<"输入待插入的元素e:";cin>>e;cout<<"输入待插入的位置i:";cin>>i;if(DuListInsert_L(L,i,e)){cout<<"插入后的双链为:";p=L;while(p->next!=L){cout<<p->next->data<<' ';p=p->next;}}printf("\n");p=L;while(p->next!=L) //输出列表{cout<<p->next->data<<' ';p=p->next;}int k;cin.clear(); //清除上一个cin的错误信息cin.ignore(); //清空输入流cout<<"要删除第几个节点k :";cin>>k;if(DuListDelete_L(L,k,e)){cout<<"被删除的元素为:"<<e<<endl;cout<<"删除后的元素为:";p=L;while(p->next!=L) //输出删除后的列表{cout<<p->next->data<<' ';p=p->next;}}elsecout<<"删除出错";return 0;}得到的结果如图罗达明电科一班学号2010301510028 2013、3、17。

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语言版 线性表__C版
17
2. 求表长
L.length
3. 取第i个元素
L.elem[i-1]
(0<i<L.length+1)
18
4. 元素定位操作
分析:依次取出每个元素和给定值进行比较 int LocateElem_Sq (SqList L, ElemType e, Status (*compare)(ElemType, ElemType))
6. 删除操作
线性表的删除运算是指将表的第i(1≦i≦n)个元 素删除,使长度为n的线性表: (a1,…a i-1,ai,a i+1…,an) 变成长度为n-1的线性表 (a1,…a i-1,a i+1,…,an)
操作步骤: ① 判断线性表是否为空 ② 判断i值是否合法:1≦i≦n ③ 元素前移 ④ 表长减1
2
线性结构:数据元素之间存在1对1的关系。 四个特征: ① 存在惟一的一个“第一元素” ② 存在惟一的一个“最后元素” ③ 除最后元素外,其它元素均有惟一的“后继” ④ 除第一元素外,其它元素均有惟一的“前驱”
3
2.1 线性表的类型定义
一.定义
线性表(Linear List) :由n(n≧0)个数据元素组成的 有限序列。记作: (a1,a2,…an) 其中数据元素的个数n定义为表的长度。当n=0时称 为空表 这里的数据元素ai(1≦i≦n)只是一个抽象的符号, 其具体含义在不同的情况下可以不同。 例1、26个英文字母组成的字母表 (A,B,C、…、Z) 例2、某校从1978年到1983年各种型号的计算机拥 有量的变化情况。 4 (6,17,28,50,92,188)
思考:若要直接查相等的呢?
19
5. 插入操作
线性表的插入运算是指在表的第i(1≦i≦n+1)个位置上,插 入一个新元素e,使长度为n的线性表(a1,…a i-1,ai,…,an) 变成长度为n+1的线性表 (a1,…a i-1,e,ai,…,an) 操作步骤: ① 判断i是否符合要求:1≦i≦n+1 ② 判断表长是否溢出 ③ 元素右移 ④ 插入 ⑤ 表长增1

056312409数据结构(C语言版)(夏燕张兴科)--习题答案--第2章

056312409数据结构(C语言版)(夏燕张兴科)--习题答案--第2章

2.7 习题与上机操作⒈选择题⒉⑴114⑵物理结构指向后继的指针⑶n-i⑷head->next=NULL⑸线性链表、循环链表、双向链表⒊简答题⑴试描述头指针、头结点、开始结点的区别、并说明头指针和头结点的作用。

答:开始结点是指链表中的第一个结点,也就是没有直接前趋的那个结点。

链表的头指针是一指向链表开始结点的指针(没有头结点时),单链表由头指针唯一确定,因此单链表可以用头指针的名字来命名。

头结点是在链表的开始结点之前附加的一个结点。

有了头结点之后,头指针指向头结点,不论链表否为空,头指针总是非空。

而且头指针的设置使得对链表的第一个位置上的操作与在表其他位置上的操作一致(都是在某一结点之后)。

⑵在顺序表中插入和删除一个结点需平均移动多少个结点?具体的移动次数取决于哪两个因素?答:在等概率情况下,顺序表中插入一个结点需平均移动n/2个结点。

删除一个结点需平均移动(n-1)/2个结点。

具体的移动次数取决于顺序表的长度n以及需插入或删除的位置i。

i越接近n则所需移动的结点数越少。

⑶为什么在单循环链表中设置尾指针比设置头指针更好?答:尾指针是指向终端结点的指针,用它来表示单循环链表可以使得查找链表的开始结点和终端结点都很方便,设一带头结点的单循环链表,其尾指针为rear,则开始结点和终端结点的位置分别是rear->next->next 和rear, 查找时间都是O(1)。

若用头指针来表示该链表,则查找终端结点的时间为O(n)。

⑷何时选用顺序表、何时选用链表作为线性表的存储结构为宜?答:在实际应用中,应根据具体问题的要求和性质来选择顺序表或链表作为线性表的存储结构,通常有以下几方面的考虑:①.基于空间的考虑。

当要求存储的线性表长度变化不大,易于事先确定其大小时,为了节约存储空间,宜采用顺序表;反之,当线性表长度变化大,难以估计其存储规模时,采用动态链表作为存储结构为好。

②基于时间的考虑。

若线性表的操作主要是进行查找,很少做插入和删除操作时,采用顺序表做存储结构为宜;反之,若需要对线性表进行频繁地插入或删除等的操作时,宜采用链表做存储结构。

数据结构(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)。

++j;
}
if(!p||j>i-1)
{
printf("插入失败\n");
return;
}
q=(dullinklist)malloc(sizeof(dulnode));
q->data=e;
//在最后一位插入元素
if(p->next==0)
{
q->next=0;
p->next=q;
q->prior=p;
#include<stdio.h>
//双向链表定义
typedef struct node{
int data;
//数据域
struct node *prior; //前驱
struct node *next;
//后继
}dulnode,*dullinklist;
//初始化
dullinklist initlist()
===================================="); printf("\n删除位置:"); scanf("%d",&i); dellist(l,i,&e); printf("表长:%d\n",listlength(l)); printlist(l); //printf("e=%d\n",e); printf("被删除元素:%d\n",e); printf("======================================END=============== putchar('\n');
{
p->next=q->next;
q->next->prior=p;
}else
p->next=0;
//删除元素位于最后一位
*e=q->data;
free(q);
printf("--删除成功--\n");Βιβλιοθήκη return *e;}
//打印表中元素
void printlist(dullinklist l) {
int count=0;
p=l->next;
//printf("%d",p);
while(p)
{
p=p->next;
count++;
}
return count; //返回表长度
}
//后插法创建双向链表
void createlist(dullinklist l,int n)
{
dullinklist p,r;
//插入新结点
r=p;
//尾结点后移
}
printf("--创建双向链表成功--\n");
}
//插入
void insertlist(dullinklist l,int i,int e)
{
int j=0;
dullinklist p,q;
p=l;
while(p&&j<i-1)
{
p=p->next;
//找寻第i-1个结点
}
printf("--插入成功--\n");
return;
}
//在非最后一位插入元素
q->next=p->next;
p->next->prior=q;
p->next=q;
q->prior=p;
printf("--插入成功--\n");
}
//删除
int dellist(dullinklist l,int i,int *e)
{
int j=0;
dullinklist p,q;
p=l;
//找寻第i-1个结点
while(p&&j<i-1)
{
p=p->next;
j++;
}
if(!p||j>i-1)
{
printf("删除失败\n");
return -1;
}
q=p->next;
//被删除结点
if(q->next)
//删除元素非最后一位
int i=0;
r=l;
//生成新结点
for(;i<n;i++)
{
p=(dullinklist)malloc(sizeof(dulnode)); //生成新结点
printf("输入元素:");
scanf("%d",&p->data);
//输入元素
p->next=0;r->next=p;p->prior=r;
dullinklist p; p=l->next; while(p) {
printf("%3d",p->data); p=p->next; } putchar('\n'); } void main() { int i,e,n; dullinklist l; printf("====================================初始化 ===================================="); putchar('\n'); l=initlist(); printf("表长:%d\n",listlength(l)); printf("=================================创建双向链表 ================================="); putchar('\n'); printf("元素个数:"); scanf("%d",&n); createlist(l,n); printf("表长:%d\n",listlength(l)); printf("======================================插入 ===================================="); printf("\n插入位置:"); scanf("%d",&i); printf("插入元素:"); scanf("%d",&e); insertlist(l,i,e); printf("表长:%d\n",listlength(l)); printlist(l); printf("======================================删除
{
dullinklist l;
l=(dullinklist)malloc(sizeof(dulnode));
l->prior=0;
l->next=0;
printf("--初始化成功--\n");
return l;
}
//表长
int listlength(dullinklist l)
{
dullinklist p;
相关文档
最新文档