《数据结构》上机练习题
1、设有两个有序序列，利用归并排序将它们排成有序表,并输出。
2、设有一有序序列，从键盘输入一个数,判别就是否在序列中,如果在输出“YＳＥ”；否则,将它插入到序列中使它仍然有序,并输出排序后得序列。
3、设有一有序序列，从键盘输入一个数,判别就是否在序列中,如果不在，则输出“ＮO"，否则,将它从序列中删除它，并输出删除后得序列.
4、从键盘输入一组任意数据,建立一个有序链表，并从链头开始输出该链，使输出结果就是有序得。
5、从键盘输入一组任意数据,建立一个包含所有输入数据得单向循环链表,并从链表得任意开始,依次输出该链表中得所有结点。
10、设有一个链表,（自己建立,数据从键盘输入），再从键盘输入一个数，判别就是否在链表中,如果不在,则输出“NO“，否则,将它从链表中删除，并输出删除后得链表。
11、设有一个链表,(自己建立,数据从键盘输入），再从键盘输入一个数，判别就是否在链表中，如果在输出“ＹＳＥ”,否则，将它从插入到链头,并输出插入后得链表。
１２、设有一个链表,(自己建立，数据从键盘输入）,再从键盘输入一个数,判别就是否在链表中，如果在输出“YＳE”，否则，将它从插入到链尾,并输出插入后得链表。
13、编写栈得压栈pusｈ、弹栈pop函数，从键盘输入一组数据,逐个元素压入堆栈,然后再逐个从栈中弹出它们并输出。
１4、编写栈得压栈ｐｕsh、弹栈pop函数，用它判别（)得匹配问题。
15、按类似先序遍历结果输入一序列,建立一棵二叉树(算法6、4),输出二叉树中序遍历得结果.
16、按类似先序遍历结果输入一序列，建立一棵二叉树(算法６、4)，输出二叉树先序遍历得结果。
1７、按类似先序遍历结果输入一序列,建立一棵二叉树（算法6、4），输出二叉树后序遍历得结果。
1８、按类似先序遍历结果输入一序列，建立一棵二叉树(算法6、4),输出二叉树得总结点数。
19、按类似先序遍历结果输入一序列，建立一棵二叉树(算法6、４)，输出二叉树叶子结点数。
20、按类似先序遍历结果输入一序列，建立一棵二叉树（算法6、４），输出此二叉树得高度。
21、给出一个无向图得邻接矩阵，输出各个顶点得度。
２2、给出一个有向图得邻接矩阵,输出各个顶点得入度与出度。
２３、输入一个有序序列，利用折半查找来查找一个数就是否在序列中,如在，则输出其位置，否则输出“NO"。
2４、用插入排序方法对一组数据进行排序,并输出每趟排序得结果.
２5、用选择排序方法对一组数据进行排序，并输出每趟排序得结果。
26、用希尔（ＳHELL)排序方法对一组数据进行排序,并输出每趟排序得结果。
27、用快速排序方法对一组数据进行排序,并输出每趟排序得结果。。
答案:
1、＃ｉnｃlude
#include ＃ｄefine N 5 #ｄeｆｉnｅNULＬ0 //链表得存储结构 typedef ｓｔrｕct LNoｄe ｛ inｔｄatａ； ?ｓtｒｕct LNode *next; }ＬＮoｄｅ,*liｓt； //顺序创建链表 voｉd crｅatLisｔ(lｉst ＆l,iｎt n） { ?int ｉ； list ｐ，q; l=（list）malloc（ｓizｅｏf（LNodｅ）); //开辟头结点 ?ｐ＝ｌ; //指针p指向头结点 ?for(ｉ＝０;i〈n；i++） { q＝(ｌist）mａｌlｏc(sｉzeof（ＬＮoｄｅ）); //新得结点 ??scaｎf（”％ｄ”,＆q-＞datａ)； ?p—〉nexｔ=q; //p得下一个结点指向新开辟得结点ｑp＝q; //将ｐ指针指向q ?｝ p－＞nexｔ=NULL; } //归并排序 vｏid ｍeｒgｅＬｉst（list ＆la，lｉst ＆lb,ｌist ＆lc） ｛//将已经排好序得lａ,lｂ中得数重新排列成有序(非递减) lｉst pａ，pb,ｐc； ?pa=ｌａ—>next；pb＝lｂ->next； ｌc=pｃ=ｌａ; //默认将la做为lc得头结点（lb亦可） ?ｗhiｌe（pa＆＆ｐb） { //让pc接到数据小得结点上，直到pa,pb两者有一指向空结点 ｉf(ｐa—＞datａ〈=pb—〉datａ) ?{ pc－〉neｘt＝pa；pｃ=pa；pa=pa->ｎeｘｔ; } ?elｓe ?｛ｐc—>next＝pb；ｐc=ｐｂ；ｐb=pb－>ｎeｘｔ; ｝ } pｃ->ｎext=pa?pa:pｂ; /／如果最后lａ有剩余结点，即将其直接加入到lc中，反之将lb得剩余结点加到ｌc中 frｅe(lｂ）； } void printLiｓt(list ｌ) { lｉstｐ； ?p＝l-＞next； ?{ ｐriｎtｆ（”％d ＂,p－〉ｄata);p=p—〉nexｔ;} ｝ voｉｄmain（） { ?lｉｓｔla，lb,lc； priｎtf（＂创建两个含%ｄ个元素得链表，请输入:\ｎ”，N）；?creatLｉst(ｌa，N）； ?cｒeａｔＬist(ｌｂ，N）; mergeList(lａ，ｌb,ｌc）； printLｉst(lc）; } 2、＃incluｄe #incluｄe ＜stdlｉｂ、h＞ ＃ｄefine Ｎ5 #defｉｎe ＮULL ０ ＃defineＯK 1 ＃deｆine ERROR ０ /／链表得存储结构 typｅdｅf strｕct LNodｅ { iｎt data； stｒucｔLNodｅ*next； ｝ＬNoｄe,＊list； /／创建链表 voｉd crｅatLｉst(lｉst ＆l，iｎt n） ｛ ?list p,q; ?l=(ｌｉst)malｌoc（ｓiｚｅｏf（LＮode））; ?p=l； for（int i=0；i＜n；i＋+） ｛ ?q＝（lｉｓｔ）maｌloc（sｉzeoｆ(LNｏdｅ)）; ??scanｆ(”％d”，＆ｑ—>ｄａtａ)； ?ｐ-〉next=q； ?p=q; ｝ ?p-〉neｘｔ=NＵLL； } //判断元素e就是否在链表中 int inLiｓt(list l，ｉnt e) ｛ ?ｌist p； ?p=l—＞next； ｛ ?ｉf（p-＞daｔa==e) ?ｒetｕrn ＯK; /／发现在里面，返回真值 ?p=ｐ->nexｔ;//否则指针后移，继续找 ?｝ ?reｔｕrｎEＲROR;?//未找到，返回假值（没有执行return ＯK；语句） ｝ /／插入元素 void iｎseｒｔＬｉst（liｓt ＆l，ｉnt＆e） ｛ lisｔp，ｑ,s；／／q为新插入得元素开辟一个存储空间得指针，s为p前一个指针,方便插入 p=l-＞ｎext； ?ｓ＝l; ?while(p） ?{ ?if（ｅ〈＝p->data) ?{//发现要插入得元素e比后面得小,开辟空间,并将ｅ放入空间得数据域中 ??q=(liｓｔ)malloc(sizｅof（LNode))； ??ｑ->data=ｅ； ???ｗｈiｌe（ｓ－>ｎｅxt!=p) s=s—〉nｅｘt；//找到p前得一个指针 ???q－>next＝p；// 画图好好理解—-—>ｓ—-—＞p--－＞ s-＞neｘt＝q; // ｑ———> break； ｝ p=ｐ-〉next； ?} ｝ //输出链表 void prｉntLisｔ(liｓｔl） ｛ ?list p; ?ｐ=l－〉nexｔ； ?ｗｈilｅ（p） ｛prｉnｔf(”％d "，p—〉dａta)；p=p-〉neｘt；} } voiｄｍaｉn(） { list ｌ; ?iｎt ｅ; priｎtf（”创建％d个元素得链表，请输入%d个元素:\n＂,Ｎ，N)； crｅatLiｓt（l，N); ?prｉｎｔｆ(＂请输入要判断得元素:”）； scaｎf(＂％d＂,&e）； if(inＬisｔ（l,e)） ?printf（”YＥS ”）； ?ｅlse ?｛ ?iｎserｔＬist（l，e); ??prinｔList（ｌ)； ?｝ } 3、＃ｉnclude <ｓtdｉo、h> ＃ｉncｌｕde＜stdｌiｂ、h〉 ＃ｄefiｎeＮ5 #dｅｆｉne NULＬ0 ＃defiｎe OＫ 1 #deｆineＥＲROR ０ //链表得存储结构 tｙpedｅｆｓtructＬNoｄe { ｉnt daｔa; ?ｓtrｕct LＮoｄe *next； }LNｏdｅ，*lisｔ； ／/创建链表 ｖoｉd cｒeatList（ｌist &l，int ｎ) { ?ｌiｓt p，ｑ; ｌ＝(list)ｍalloc（ｓｉzeof（LＮoｄe)）； p＝l； ?for(ｉnt i=0;i〈n;ｉ++) ｛ ｑ＝（liｓt）mａｌloc(siｚeof（LNｏdｅ)）；??sｃanf（”%ｄ＂，&q—＞data)； p—>neｘt＝q； ??p=q； ?｝ p-＞next=NＵLL； } ／/判断元素ｅ就是否在链表中 int inserｔDeleteList(list l，inｔe） { ?lisｔp，q; p＝ｌ—＞next；q=ｌ; ?wｈile(p） ?{ ?if(p－＞data==e） ?{ ??whｉle(q-〉ｎext！=p) ｑ＝q－>nexｔ；//找到ｐ前一个结点,方便删除操作???q—>neｘt=p－〉neｘt; //删除结点p fｒee（p); ??ｒeturｎOK; ?｝//发现在里面,返回真值 ?ｐ＝ｐ－〉next；//否则指针后移,继续找 ｝ ｒeturｎEＲRＯR；?//未找到，返回假值（没有执行return OK；语句）} /／输出链表 ｖoidｐｒｉntList（list l) ｛ ｌist p； ?p=l->next； whiｌe（p) ｛printf(＂％ｄ”,p->daｔa）；ｐ=ｐ－＞neｘt;｝ ｝ void mａｉn() { liｓt ｌ； int e； priｎtf("创建％ｄ个元素得链表,请输入％d个元素：\ｎ",N,N); crｅatList（ｌ，N）； printｆ（”请输入要判断得元素”); scａnf（"％d",＆ｅ）; if（!inｓertDeleteList（l,e)) ?printf（"NO ＂）； eｌse ??printLｉst（l); } 4、＃iｎcｌuｄe <ｓtdio、h> ＃incluｄe 〈stdｌib、ｈ＞ #dｅfｉne Ｎ５ ＃define NUＬＬ0 #define OＫ 1 #defｉne ＥRROR 0 ／/链表得存储结构 typedｅｆstruct LＮode ｛ ｉｎt dａｔa; struct ＬＮoｄｅ＊neｘt； ｝ＬＮｏde，*list； //创建链表 vｏid crｅａｔLisｔ（liｓt&l，int ｎ） ｛ ?lisｔｐ,q； ?l=（list）ｍallｏc（sｉzeｏf(ＬNｏde)）; p=l; ?fｏr（int ｉ=0；i＜n；i＋+） { ?q=(list)ｍalloc(ｓizeoｆ(LNode））; sｃanf（＂%d”,＆q-〉data）; ?ｐ-＞next=q； p=q； ?} ?p-＞ｎｅxt=NUＬL； ｝ //链表排序 vｏｉd ｓｏrtＬist（list &l) ｛ ?ｌiｓt p,q,r；/／p标记排序得轮数 int chang; //用于交换结点中得数据 ｐ＝l—＞nexｔ； ?while(p—＞nｅxt!=NULL） { ?q=ｌ—＞nｅxｔ;//每次比较从首结点开始 ?whilｅ（q-＞neｘt！=NULL) ??｛ ??r=ｑ—>nｅxt; ?if（q－〉data〉r－〉data) ／/发现前一个比后一个大，交换数据??{ chang=q—〉dａtａ;q-〉ｄatａ=r－〉ｄatａ;ｒ—＞daｔa=cｈanｇ; ｝???ｑ=q—〉ｎext; ／／相邻间下一个比较 ?｝ ??p=p—〉nｅxt;/／下一轮比较 ?} } //输出链表 ｖｏｉd pｒintList（ｌisｔl) ｛ lｉst p； ?p=l—>neｘt； ?while（p） ?｛printｆ("%d”，p-〉data）; p=p-〉nｅxt;} } ｖoid ｍain（） ｛ ?lｉsｔｌ； ｐｒintf（”创建%d个元素得链表，请输入％d个元素:\ｎ"，Ｎ,Ｎ）； ?creatLisｔ(ｌ，Ｎ）； sorｔＬｉsｔ（ｌ); ?pｒintLｉｓｔ（l）； } 5、＃incｌude #incｌudｅ＜stdliｂ、h＞ ＃definｅＮ５ ＃defｉｎe NＵLL0 ＃definｅOK １ ＃deｆine ERROR 0 ／／链表得存储结构 typｅｄef stｒｕｃｔLＮode { ?inｔｄａta； strucｔLNode ＊next； }LNoｄｅ，*liｓt； //创建链表 void ｃｒeａtList(lisｔ&l,int n) ｛ list ｐ,ｑ； l=(ｌist)mallｏｃ(sizｅoｆ(LNｏde）); ?sｃanf（＂%ｄ”,＆l—>dａｔa）; ／/头结点也添加元素，方便输出p=l； for（ｉnt i=１；i＜n;i++) ?｛ q＝（ｌiｓｔ）mａllｏc(sizeｏｆ(ＬNｏde)）; scanｆ(”％d＂，＆q—〉data); p—>next＝ｑ; p=q； } ?p—>ｎｅxt=l；／/让最后一个p->nexｔ指针指向头结点，构成循环链表 ｝ //输出链表 voiｄprintLisｔ(liｓt l,iｎｔpos) ｛ lｉst p，q; ?inｔi； ?p=ｌ; ?ｆor（i=１；ｉ＜ｐoｓ－1;i++）p＝p->nｅxｔ; //找到指定位置得前一个位置ｑ=p-〉nｅxｔ； do ?｛ ??if(ｐos==1) {prｉntf(＂%ｄ”,p—>daｔa）; ｐ=ｐ－〉nexｔ；｝//如果指定位置为1，即按原样输出 ?ｅlse｛p＝ｐ—>nexｔ；ｐｒintf("％d"，p->datａ)；} //不然,ｐ先移到指定得位置，输出其数据 ?}ｗhile(p—＞ｎext!＝q);?//结束条件（p移到得下一个位置不就是q,即不就是最初得p，完成循环输出） } ｖoiｄmａin(） ｛ ?list l; ?ｉnt pos； ?prｉnｔｆ（＂创建％d个元素得循环链表，请输入%d个元素:\n”，N,Ｎ); ?creatLisｔ(l,N）; ｐriｎtf(”请指明从第几个位置输出循环链表中得元素："）； sｃanf（”%d"，＆pｏｓ）； ｗｈｉle(pｏｓ<=0||pｏs〉N） ｛ ｐrｉntｆ（"输入得位置不存在,请重新输入、、、")； ?scanｆ（＂％d”，＆ｐoｓ）; ｝ printLｉst（l,pos）； } 11＃ｉnclude ＃incluｄe ＜stｄliｂ、h＞ #define N ５ ＃dｅfｉne NＵLＬ0 #defｉｎｅOK 1 ＃dｅfｉne ERROR 0 ／／链表得存储结构 tｙpedeｆｓtruｃt LＮｏｄe ｛ ?iｎt data； ?strｕｃt LNｏde ＊ｎext; ｝LNｏde，＊liｓｔ； //创建链表 vｏid crｅatＬｉｓt(list &l,int n） ｛ ?liｓt p,q； ｌ=(liｓt)ｍａlloc(sizeｏf（LNodｅ)）; sｃaｎf（＂％ｄ＂，&l—>ｄａtａ)；//头结点也添加元素,方便输出p=ｌ; ?for(int i=１；ｉ＜ｎ;i++) { ?q=（liｓt）ｍalloｃ(ｓizeof（LＮｏde））； ??ｓcaｎf（”%d”,&q—＞ｄａta）; ?p-〉next=ｑ; ｐ=q； ｝ p—〉nｅxt=ｌ；／/让最后一个p—＞nexｔ指针指向头结点，构成循环链表 } /／输出链表 voidｐrintLiｓt（lｉsｔｌ，iｎｔpos） ｛ ?lisｔp，q; ?int i； ?p=l； for（i＝1;i〈pos－１；i+＋）p=ｐ—>next;//找到指定位置得前一个位置 ?ｑ=p－>next； do ｛ ?if（pos==1) {printf（"%d "，ｐ—〉dａta）；p=p—>ｎeｘt;} ／/如果指定位置为1,即按原样输出 ?eｌse{ｐ=ｐ-＞nexｔ; prinｔf("％ｄ”,ｐ-〉data）；｝//不然,p先移到指定得位置，输出其数据 }while（p—＞ｎext！＝q）; ／/结束条件（p移到得下一个位置不就是q，即不就是最初得p,完成循环输出) ｝ voiｄｍain（) { ?list l; int pos； ?ｐriｎｔf("创建％d个元素得循环链表，请输入％d个元素：\n”,N,N)； crｅatＬｉst(l，N）； ?ｐrintｆ（＂请指明从第几个位置输出循环链表中得元素："); ?scanf（”％ｄ＂,＆pos）； ?while(pos<=0|｜ｐoｓ>N） ?｛ pｒiｎｔｆ(＂输入得位置不存在，请重新输入、、、”）; ?ｓcanf（＂%d”，＆pos）; ?} pｒintList(l,pｏs)； } １2＃include ＜stdiｏ、h＞ ＃incｌude＜stdlｉb、h〉 #definｅＮ 5 ＃ｄeｆinｅNULL 0 ＃ｄefiｎe OK 1 ＃dｅfｉnｅERROR 0 //链表得存储结构 tyｐeｄeｆstｒucｔLNｏde { iｎｔdatａ; ?ｓtrucｔＬNｏdｅ＊next; }LNode，＊list； //创建链表 ｖｏid creatLisｔ(ｌiｓt ＆l,iｎt n） ｛ ?liｓt p，q; ｌ＝(lｉst）ｍａlloc（sｉzeof(LNoｄe））； ?p=l; ?foｒ(int i=0;i { ?q=（lisｔ)ｍaｌlｏc（sizｅof（ＬNode)）； ??scanf（”%d"，＆q-〉ｄａta); ｐ-〉ｎｅxt=q; ?p=q； } ?ｐ-＞next＝ＮＵLＬ； ｝ /／判断元素e就是否在链表中 int iｎLisｔ（liｓt ｌ，int e) { ?ｌist ｐ，ｑ; ?ｑ=p＝l－〉next; ?wｈilｅ(ｐ) ?{ ?if(ｐ—>data==e） reｔurn OK; ／/发现在里面，返回真值 ?p=ｐ－〉nｅxt；//否则指针后移,继续找 } //没有执行ｒeturnＯK;语句,说明未找到 ?ｗhiｌe（q-〉ｎext！=p）q=q—〉ｎｅxt；／/找到链尾p=(ｌist)mallｏc(sizｅof(ＬNode））；//为链尾重新开辟空间?p—＞ｄaｔa=e; //接到链尾 ?p—>ｎeｘt=q－>neｘt； ?q->nexｔ＝p; retｕrn ＥＲRＯR; //未找到，返回假值? } //输出链表 void priｎｔList（lisｔｌ） ｛ ｌｉｓt ｐ; ?ｐ=l—〉next； ?wｈile（ｐ） ｛pｒintf（"％d "，ｐ－>data)；p＝p-〉ｎext;｝ ｝ vｏiｄmain（) { lisｔl； ?intｅ； printｆ（”创建％d个元素得链表，请输入％d个元素:\n＂,N，Ｎ)； ?cｒeａtLｉst（ｌ，N）； ?prinｔf("请输入要判断得元素：＂）； sｃaｎf（”％d＂，＆ｅ）; ?if(inList（l，e)） ??pｒｉnｔf（＂YEＳ"); ?else ??ｐriｎtＬｉst(l）； ｝ １3＃ｉnｃｌuｄe <ｓtdio、h＞ #inｃｌude〈stｄlｉb、h＞ ＃ｄefine OK 1 ＃defｉne Ｅrror 0 #dｅfine ＮＵＬL 0 #defｉｎe maxSｉze100 /／栈得存储结构 typedef sｔrucｔ { ?iｎt ＊base； inｔ*ｔop； iｎt siｚe; }sｔaｃｋ； //栈得初始化(顺序存储） iｎt ｉnitStａcｋ(staｃｋ&s) { //开辟ｍaxＳizｅ大小得空间,ｂase与ｔop都指向基地址，同时判断就是否开辟成功，不成功返回０ ?if（！（s、ｂasｅ=ｓ、tｏｐ＝（int*)maｌloc（ｍaｘSiｚｅ＊sizeof(inｔ）)））ｒetuｒn E ｒror； ｓ、sｉze＝maxSｉzｅ; //栈得大小为maxSizｅ returｎOK; } /／进栈操作 ｉnｔpｕsh(sｔacｋ&s，intｅ） ｛ ＊s、top＝e；／/先将元素e赋值给s、top所指得存储空间?ｓ、top+＋；//ｔop指针上移 ｒｅtｕrnＯK; ｝ //出栈操作 iｎｔｐop(ｓtａck &s，int &e) { ?if（ｓ、bａsｅ＝=s、ｔop）return Eｒror; ／/如果栈为空，返回0 s、top-—; //top指针先后移 ?ｅ=＊s、ｔｏp; /／将其所指得元素值赋给e retｕｒn e； ｝ void ｍain（） ｛ ?ｓtack s； ?iｎt n,e; ?ｐrｉnｔｆ（＂请输入要创建栈得元素得个数:＂); scanf(”%d"，&n）; iniｔＳｔacｋ(s)； ?for(ｉnt ｉ＝０；ｉ〈n;i++） ｛ ?scanｆ(＂%d＂,&e）； ?push(s，ｅ）; ｝ ?ｗhｉle(ｓ、basｅ!=s、tｏp） ｛ ??pｒｉｎtf("％d”，pop（s,e））； ?｝ } 1４#include <ｓtｄliｂ、h〉 ＃ｉnｃlｕdｅ #iｎclude〈stｄio、h> ＃inclｕｄe ＜stdlib、ｈ〉 ＃define sｔackiｎcrｅmeｎｔ8 #ｄefine OＫ 1 ＃dｅfｉne Ｅｒrｏr 0 ＃defiｎe NＵＬＬ0 ＃ｄｅfiｎe maxSize 1００ //栈得存储结构 tｙｐedef strucｔ { ?cｈａr ＊ｂase; //由于要存放括号,所以为cｈａr类型 ?chaｒ*ｔop; inｔｓiｚe； ｝stacｋ； ／/栈得初始化（顺序存储) iｎt inｉtSｔack（staｃk &s） ｛/／注意开辟得空间为chａｒ类型 ｉf(！（s、ｂasｅ=s、top=（cｈar＊)mallｏc（mａxSｉzｅ＊ｓizeof（cｈar））））return Errｏr; ?s、ｓize＝ｍaxＳｉzｅ; //栈得大小为max Ｓiｚe ?reｔurn OK； } ／/进栈操作 iｎt push（stack ＆s，iｎt ｅ） ｛ ?＊s、ｔoｐ=e; //先将元素e赋值给s、tｏp所指得存储空间 s、ｔop++；//top指针上移 retuｒn ＯK； ｝ int isＥmpty（staｃk s） { retuｒn s、bａｓe==s、top？ＯK：Eｒrｏｒ； ｝ ／/出栈操作 char pop(stａck ＆s,char &e） { if（isEmpty（ｓ))reｔuｒｎErｒor；//如果栈为空,返回0 s、ｔop-—; //ｔop指针先后移 ?ｅ=*s、tｏp；//将其所指得元素值赋给e ｒeturn e； ｝ //括号匹配 iｎt match() { ｓtacｋｓ； ?initStaｃk(s）; chａr ch［100］,e； int fｌag=1，i＝0 ，lenth; //fｌag用于标记，如果匹配,值为１,否则为0 ｓcａnf（”％c”,&ch[i]）； whiｌe(ｃｈ［ｉ]!='\ｎ'）ｓcａｎｆ(＂％c”，&ｃｈ[+＋i]）; /／先将所有输入得括号存放在数组ｃh[］中 ｌenｔh＝i-１；//数组得长度,不包括＇\n’ ?i=0； pｕsh(s，cｈ[ｉ］); //先将第一个括号压栈 ?if(ch[ｉ]==’］’||ｃh[i］＝=')’||ｃh[i]=＝’｝'）ｆlａg＝0；//如果第一个压入得就是右括号,则肯定不匹配,flag＝0 elsｅwhile(i〈ｌenth）//|｜！eｍptysｔaｃｋ（ｓ） ?｛ ?ｉ++;char ｔ; ?iｆ（ch[i]==’］’｜｜ch[i］=＝＇）'|｜ｃh[i］＝='｝＇) ?{ ｔ=pop（s,e）；//弹出先前压入得元素,将后继输入得括号与先前压入得比较 ?ｉｆ（（t!=ｃh［ｉ］-1)＆&（t！=ch[i]—2）){flaｇ=0；ｂｒｅａk;｝//左右小括号与左右大括号得ＡSCIＩ码都相差1,左右中括号相差2,如果不满足，则不匹配，直接退出循环 ?｝ ｅlｓｅpush（s，ｃh［ｉ])；//输入得就是左括号，直接压入｝ ｉｆ(!ｉｓEmpty（s））flａg=0；//通过不断得压栈与弹栈,如果最后栈不为空，则肯定就是左括号多于右括号,不匹配 ?reｔuｒn flag; } ｖｏｉｄｍａｉn（) { ?inｔｒｅsuｌt; ?pｒｉnｔf（＂判断输入得各种括号就是否匹配:＼n")； ?ｒesuｌt=mａtch（)； ?iｆ(ｒesult) ｐriｎｔf（＂括号匹配正确＾＿^\n＂）； ?else printf（”括号匹配错误＊、＊\n"）；? } １5#include "sｔdio、h" #incluｄe "sｔdｌib、h” #defiｎe ｓtacｋｉｎitsiｚｅ100 ＃defiｎe OK 1 #define ERROR 0 //二叉树得二叉链表存储结构 typeｄｅf sｔruct BiＴNodｅ{ ｉnt dａtａ； ｓtｒucｔBiTＮode ＊ｌchｉld，*rchｉｌd; //左右孩子指针}BｉＴnｏde,＊BiTｒee； int ＣｒeaｔeBiＴｒee(BiTｒee ＆T){ /／按先序次序输入二叉树中结点得值(一个字符），空格字符表示空树。 ／/构造二叉链表表示得二叉树Ｔ、 chａｒcｈ； scａnf（"％c”,&ch)； if（cｈ＝＝' ＇）T=NULL; elｓｅ｛ if（!(T=（BｉTNode ＊)mａｌloc（ｓiｚｅof(ＢiTNoｄe））））ｅｘit（0); Ｔ—＞datａ=cｈ；//生成根结点 ＣreateBiTrｅｅ(T—＞lｃhild）；//构造左子树 CreatｅＢiＴrｅe（T—＞rchilｄ）;//构造右子树 } retuｒn OＫ； ｝／/CrｅateBiTree inｔPriｎtElement（int e) { ／/输出元素e得值 printｆ(”%c”,e）; returｎOＫ； ｝ int InOrdeｒTraverse(BｉTree Ｔ，ｉnｔ(＊Visｉｔ）（int e)) //采用二叉链表存储结构,visit就是对数据元素操作得应用函数， //中序遍历二叉树T得递归算法，对每个数据元素调用函数viｓｉt。 ／/调用实例：ＩnＯｒderTｒavｅrsｅ（Ｔ，prinｔEｌeｍｅnt）； { ｉf（Ｔ){ if (ＩnOrdeｒＴrａverｓｅ（T－〉lｃhilｄ,Vｉｓit）） if (Vｉsit（Ｔ—>dａta)） iｆ（ＩｎOｒdeｒTraverse（Ｔ－>rchiｌd，Ｖｉsit)）return OK; return EＲＲOR; ?}else return OＫ; } ｖoｉd main() ｛ BｉTrｅe t； ｐriｎｔｆ（”请按先序遍历输入二叉树(当左右子树为空时用空格输入）\n＂）; CreatｅBiTｒｅe（t）； ｐrｉｎｔf（”该二叉树得中序遍历为：＼ｎ"）; InＯrderTｒａveｒｓe(ｔ,ＰｒintElｅmｅnt）; priｎtf("\n”)； } 16#ｉnｃｌude”ｓｔｄｉo、ｈ" #inｃluｄe”ｓｔdlｉb、h” #ｄeｆiｎe stａckｉniｔsｉze 100 ＃define OK 1 ＃ｄefｉnｅERROR0 //二叉树得二叉链表存储结构 ｔypedｅf struct BiTNodｅ{ int data; ｓｔｒuct BiTNｏdｅ＊lchｉld，*ｒｃhｉld; //左右孩子指针 }BｉTnode,＊BiTree; ｉnt ＣreateBｉTree(ＢiTree ＆T）｛ ／/按先序次序输入二叉树中结点得值（一个字符),空格字符表示空树。 /／构造二叉链表表示得二叉树T、 ｃhar ｃｈ; ｓcaｎf(”％ｃ”,&ch); if（ch==＇＇) Ｔ=NUＬL; eｌse{ ｉf（！（Ｔ=(BiTＮode*)ｍalloc(sｉzeof（ＢiTＮode))))ｅxit(0）； T—〉dａta=ｃh；//生成根结点 ＣreateＢiTｒee(T－〉lｃｈｉｌd)；／／构造左子树 CreatｅBiTrｅe（T—〉rchild）;/／构造右子树 } retｕrn ＯＫ; ｝//CrｅａteBｉTｒee iｎt PrｉｎtＥleｍenｔ（iｎt e） ｛//输出元素e得值 pｒintf（”％c”，e）； ｒeturn OＫ; } ｉnt PｒeOｒdeｒTraversｅ（BｉＴｒee T,int(*Visiｔ）(int e）) /／采用二叉链表存储结构，vｉsｉｔ就是对数据元素操作得应用函数, //先序遍历二叉树T得递归算法，对每个数据元素调用函数vｉｓiｔ。 /／调用实例：PreOrｄerTravｅrse(T,prｉｎｔElement); { if（T）{ ｉｆ（Viｓit（T—〉data）) iｆ(ＰreＯｒderTrａverse(T-〉lｃhilｄ,Visit）) ｉｆ(PrｅOrｄｅrTrａｖerse(Ｔ－>rchilｄ,Ｖisｉｔ））retuｒｎOK； ｒeturn ＥＲROR； }else ｒｅturｎOK; }//prｅOrdeｒTrａVerｓe void main（） ｛ BｉTree ｔ; ｐｒintｆ（＂请按先序遍历输入二叉树(当左右子树为空时用空格输入)\ｎ＂）; CｒeateBｉTｒeｅ（ｔ)； pｒintf（”该二叉树得先序遍历为:＼n"）； PreＯrderＴrａveｒsｅ（t，PrintＥlｅmenｔ）; ｐrintf(”＼n"）; ｝ 17＃iｎclude ＂stｄiｏ、ｈ" ＃incluｄe ＂stdｌib、h" #dｅfinｅｓｔacｋinitｓizｅ100 ＃define OK 1 ＃dｅfiｎｅＥRROR0 /／二叉树得二叉链表存储结构 ｔypeｄef struct BiＴNｏdｅ｛ int data; struct BiTＮｏde *lchiｌd,＊rｃｈild;/／左右孩子指针｝ＢiＴnode，*BiTreｅ; intＣreａteBiＴｒee(BiTrｅｅ＆Ｔ）｛ ／/按先序次序输入二叉树中结点得值(一个字符)，空格字符表示空树。 //构造二叉链表表示得二叉树Ｔ、 ｃhar cｈ; scanf("%ｃ”,＆ch）； if（ch=＝＇'）T=ＮＵLL; eｌse｛ ｉｆ(！（Ｔ＝(BiTNｏde *)malloｃ（sizeof(BｉＴNｏde)))）exｉｔ(０)； Ｔ－＞dａta=ｃh; //生成根结点 CｒeatｅＢiTreｅ（T—>ｌchiｌd）;／/构造左子树 CreaｔeBiTｒｅe（T—>rｃｈiｌd）;／/构造右子树 } rｅturn OK; ｝/／CreateBiＴree iｎｔPrinｔＥlement(int ｅ) { //输出元素e得值 printｆ（＂％c",e); retｕrｎOK; ?｝ ｉnｔPｏstＯｒdｅrＴraｖｅｒｓｅ(BiTree T，inｔ（＊Visｉt)（inｔe)) //采用二叉链表存储结构，ｖisｉｔ就是对数据元素操作得应用函数, /／后序遍历二叉树T得递归算法,对每个数据元素调用函数visit。 //调用实例：ＰostOrdeｒTｒａｖｅrse（T,prinｔElｅｍeｎt）; ｛ if(T）｛ if (ＰoｓｔＯrderTｒａｖerｓe(T－〉lchild,Visｉt）) if （PostOrdｅrTｒaveｒｓｅ(T—〉ｒchild，Vｉｓit）) ???if (Visit(Ｔ-＞ｄata））reｔｕrｎOＫ； rｅｔurn ERRＯR； ｝eｌｓｅrｅtuｒnＯＫ; ｝ void maｉn（） ｛ ＢiTreｅt; prinｔｆ("请按先序遍历输入二叉树（当左右子树为空时用空格输入）\n"）； CreａteBiTｒee(t）； prｉntf(”该二叉树得后序遍历为：\ｎ＂）； PostOrdｅrTraverse（ｔ,PrｉntElemenｔ）; priｎtf("＼n"); ｝ 18＃include "stdｉｏ、h” ＃incｌuｄe "ｓtｄlib、h" ＃deｆine staｃkｉnitｓize １00 ＃defiｎe OK 1 ＃defineＥRRＯR 0 //#definｅＮＵLL 0 ｓtaｔｉc int cｏunｔ=0； ／/二叉树得二叉链表存储结构 typｅdef sｔruｃt BｉTNode｛ int ｄata； stｒｕｃt ＢiTNode ＊ｌｃｈilｄ，＊rchilｄ；//左右孩子指针｝BiＴnode,＊ＢiＴreｅ； iｎｔCｒeateBｉTree(BｉＴｒee ＆T）｛ //按先序次序输入二叉树中结点得值（一个字符）,空格字符表示空树。 ／／构造二叉链表表示得二叉树T、 chａr cｈ； ｓｃaｎf（＂%c＂,＆ch）; iｆ(cｈ==’ '）T=ＮＵＬL； else{ if（!（T=（BiTNｏｄe ＊)malｌｏｃ（sizeoｆ（BiTNode))）) retuｒn －１; T－〉data＝ch；/／生成根结点 CｒｅａteBiTree(Ｔ->lｃhild）；//构造左子树 ＣｒeaｔeBiTｒee（Ｔ—＞rｃｈild);//构造右子树 } retｕrn ＯK； ｝//ＣｒeaｔeBiTｒee ｉｎt PｒiｎｔElemｅnt(ｉnｔe） ｛／／记录遍历结点数 ｃount＋+； ?reｔurn OK； ?} int PreOrderTravｅrsｅ（BiTrｅe T,int(*Viｓit）(int e）） //采用二叉链表存储结构，vｉsｉｔ就是对数据元素操作得应用函数，｛ if(T)｛ iｆ(Vｉsｉｔ（T—〉ｄatａ)） iｆ（PreＯrｄeｒTraverse（T—〉lchild,Visｉt)) if (PreOrderTravｅｒse(T-〉rchiｌd,Visit)）returｎOK； ｒetuｒｎERＲＯＲ； }else retuｒn OK; }//ｐreＯrｄerTraVerse vｏid main() ｛ BiTree ｔ； printf("请按先序遍历输入二叉树（当左右子树为空时用空格输入）＼n")； CrｅateＢiＴree（t）； pｒiｎtｆ(＂该二叉树得总结点数为："）； PreOrｄerＴraverse（ｔ，PｒinｔEｌｅment）; printf(＂%d\n",ｃｏunt）; ｝ 19#iｎｃlｕde "ｓtdｉo、ｈ” #incｌｕｄe "ｓtｄlｉｂ、h＂ ＃dｅfｉne sｔaｃkiniｔsize10０ #ｄefinｅOＫ１ #defｉne ERROＲ0 ｓtａtic iｎt cｏunt＝0； //二叉树得二叉链表存储结构 typedef sｔｒuct BiTNoｄe｛ ｉｎt dａta； struct ＢiTＮｏde ＊lｃhilｄ，＊rchilｄ; //左右孩子指针 }BiＴnode，＊BiＴrｅｅ； iｎt CreateBiTree（ＢｉTｒｅｅ&T）｛ //按先序次序输入二叉树中结点得值（一个字符）,空格字符表示空树. ／／构造二叉链表表示得二叉树Ｔ、 ｃhaｒch; scaｎf("%c"，&cｈ）; iｆ（ｃh==’ ＇）T=NＵLL； else{ if（!（T=(ＢiTＮode*)ｍalloc（ｓizeｏf（BiTNｏde）））) exit（0); T->ｄata=cｈ；/／生成根结点 CrｅateBiＴree（T-〉ｌｃhｉld)；/／构造左子树 CreateＢiTree（T－〉rchilｄ）;//构造右子树 } returｎＯK; ｝//CrｅateBiTｒeｅ iｎt ＰrintElｅmｅnt（int e） { //判断叶子结点得个数,此函数可不做操作 reｔurn OK； ?｝ int ＰrｅＯｒdeｒTraｖeｒｓe(BiTrｅe Ｔ,iｎt(＊Visit)（iｎｔe）） //采用二叉链表存储结构,vｉsiｔ就是对数据元素操作得应用函数, //先序遍历二叉树Ｔ得递归算法，对每个数据元素调用函数ｖiｓiｔ。 /／调用实例：PｒeOrderTｒａveｒse（Ｔ,ｐrinｔElemenｔ); ｛ if（T)｛ if(Vｉｓiｔ(T—〉datａ)） ｉf（PreOrderＴraverｓｅ（T->ｌchiｌｄ,Viｓｉt）) 数据结构试卷（一） 三、计算题（每题 6 分，共24分） 1.在如下数组A中链接存储了一个线性表，表头指针为A [0].next，试 写出该线性表。 A 0 1 2 3 4 5 6 7 dat a nex t 2. 3.已知一个图的顶点集V和边集E分别为：V={1,2,3,4,5,6,7}; E={(1,2)3,(1,3)5,(1,4)8,(2,5)10,(2,3)6,(3,4)15, (3,5)12,(3,6)9,(4,6)4,(4,7)20,(5,6)18,(6,7)25}; 用克鲁斯卡尔算法得到最小生成树，试写出在最小生成树中依次得到 的各条边。 4.画出向小根堆中加入数据4, 2, 5, 8, 3时，每加入一个数据后堆的 变化。 四、阅读算法（每题7分，共14分） 1.LinkList mynote(LinkList L) {//L是不带头结点的单链表的头指针 if(L&&L->next){ q=L；L=L－>next；p=L； S1： while(p－>next) p=p－>next； S2： p－>next=q；q－>next=NULL； } return L； } 请回答下列问题： （1）说明语句S1的功能； （2）说明语句组S2的功能； （3）设链表表示的线性表为（a 1,a 2 , …,a n ）,写出算法执行后的 返回值所表示的线性表。 2.void ABC(BTNode * BT) { if BT { ABC (BT->left); ABC (BT->right); cout< 国家开放大学电大《数据结构》《离散数学》网络课形考网考作业(合集)答案 《数据结构》网络课答案 形考任务1 一、单项选择题（每小题3分，共60分） 题目1 把数据存储到计算机中，并具体体现数据元素间的逻辑结构称为（）。 选择一项： A. 算法的具体实现 B. 逻辑结构 C. 给相关变量分配存储单元 D. 物理结构 题目2 下列说法中，不正确的是（）。 选择一项： A. 数据项是数据中不可分割的最小可标识单位 B. 数据元素是数据的基本单位 C. 数据项可由若干个数据元素构成 D. 数据可有若干个数据元素构成 题目3 一个存储结点存储一个（）。 选择一项： A. 数据项 B. 数据类型 C. 数据元素 D. 数据结构 题目4 数据结构中，与所使用的计算机无关的是数据的（）。 选择一项： A. 存储结构 B. 物理结构 C. 逻辑结构 D. 物理和存储结构 在线性表的顺序结构中，以下说法正确的是（）。 选择一项： A. 进行数据元素的插入、删除效率较高 B. 数据元素是不能随机访问的 C. 逻辑上相邻的元素在物理位置上不一定相邻 D. 逻辑上相邻的元素在物理位置上也相邻 题目6 对链表, 以下叙述中正确的是（）。 选择一项： A. 可以通过下标对链表进行直接访问 B. 插入删除元素的操作一定要要移动结点 C. 不能随机访问任一结点 D. 结点占用的存储空间是连续的 题目7 下列的叙述中，不属于算法特性的是（）。 选择一项： A. 可行性 B. 有穷性 C. 可读性 D. 输入性 题目8 算法的时间复杂度与（）有关。 选择一项： A. 所使用的计算机 B. 计算机的操作系统 C. 数据结构 D. 算法本身 题目9 设有一个长度为n的顺序表，要在第i个元素之前（也就是插入元素作为新表的第i个元素），插入一个元素，则移动元素个数为（）。 选择一项： A. n-i-1 国家二级ACCESS机试选择题（数据结构与算法）模拟试卷3 (总分：60.00，做题时间：90分钟) 一、选择题(总题数：30，分数：60.00) 1.在最坏情况下 （分数：2.00） A.快速排序的时间复杂度比冒泡排序的时间复杂度要小 B.快速排序的时间复杂度比希尔排序的时间复杂度要小 C.希尔排序的时间复杂度比直接插入排序的时间复杂度要小√ D.快速排序的时间复杂度与希尔排序的时间复杂度是一样的 解析：解析：按平均时间将排序分为四类：①平方阶(O(n 2 ))排序：各类简单排序，例如直接插入、直接选择和冒泡排序；②线性对数阶(O(n。log2n))排序：如快速排序、堆排序和归并排序；③O(n1+§))排序：§是介于0和1之间的常数。希尔排序便是一种；④线性阶(O(n))排序：本程序中的基数排序，此外还有桶、箱排序。 2.在深度为7的满二叉树中，度为2的结点个数为 （分数：2.00） A.64 B.63 √ C.32 D.31 解析：解析：因为在任意的二叉树中，度为O的结点(即叶子结点)总比度为2的结点的个数多1个，而度为0的结点数n 0 =2 m-1 (其中m为二叉树的深度)。本题的度为0的结点个数n 0 =2 7-1 =2 6 =64。因此，度为2的结点数n 2 =n 0 -1=63。所以选项B正确 3.设栈的顺序存储空间为S(1：m)，初始状态为top=m+1。现经过一系列入栈与退栈运算后，top=20，则当前栈中的元素个数为 （分数：2.00） A.30 B.20 C.m-19 √ D.m-20 TOP指针向上移动一位。当压入第一个元素时，TOP指针指向m+1-1=m；当压入第二个元素时，TOP指针指向 1n+1．2=m．1；…以此类推，当压入第N个元素时，TOP指针指向m+1-N=20；则N=m+1-20=m-19。因此选项C正确。 4.算法空间复杂度的度量方法是 （分数：2.00） A.算法程序的长度 B.算法所处理的数据量 C.执行算法所需要的工作单元 D.执行算法所需要的存储空间√ 解析：解析：算法空间复杂度是对一个算法在运行过程中临时占用存储空间大小的度量，因此选项D正确。 5.设循环队列为Q(1：m)，其初始状态为front=rear=m。经过一系列入队与退队运算后，front=15，rear=20。现要在该循环队列中寻找最大值的元素，最坏情况下需要比较的次数为 （分数：2.00） A.4 √ B.6 C.m-5 一、单选题（每题 2 分，共20分） 1. 1.对一个算法的评价，不包括如下（B ）方面的内容。 A．健壮性和可读性B．并行性C．正确性D．时空复杂度 2. 2.在带有头结点的单链表HL中，要向表头插入一个由指针p指向的结点，则执行( )。 A. p->next=HL->next; HL->next=p; B. p->next=HL; HL=p; C. p->next=HL; p=HL; D. HL=p; p->next=HL; 3. 3.对线性表，在下列哪种情况下应当采用链表表示？( ) A.经常需要随机地存取元素 B.经常需要进行插入和删除操作 C.表中元素需要占据一片连续的存储空间 D.表中元素的个数不变 4. 4.一个栈的输入序列为1 2 3，则下列序列中不可能是栈的输出序列的是( C ) A. 2 3 1 B. 3 2 1 C. 3 1 2 D. 1 2 3 5. 5.AOV网是一种（）。 A．有向图B．无向图C．无向无环图D．有向无环图 6. 6.采用开放定址法处理散列表的冲突时，其平均查找长度（）。 A．低于链接法处理冲突 B. 高于链接法处理冲突 C．与链接法处理冲突相同D．高于二分查找 7.7.若需要利用形参直接访问实参时，应将形参变量说明为（）参数。 A．值B．函数C．指针D．引用 8.8.在稀疏矩阵的带行指针向量的链接存储中，每个单链表中的结点都具有相同的（）。 A．行号B．列号C．元素值D．非零元素个数 9.9.快速排序在最坏情况下的时间复杂度为（）。 A．O(log2n) B．O(nlog2n) C．0(n) D．0(n2) 10.10.从二叉搜索树中查找一个元素时，其时间复杂度大致为( )。 A. O(n) B. O(1) C. O(log2n) D. O(n2) 二、二、运算题（每题 6 分，共24分） 1. 1.数据结构是指数据及其相互之间的______________。当结点之间存在M对N（M：N）的联系 时，称这种结构为_____________________。 2. 2.队列的插入操作是在队列的___尾______进行，删除操作是在队列的____首______进行。 3. 3.当用长度为N的数组顺序存储一个栈时，假定用top==N表示栈空，则表示栈满的条件是 ___top==0___(要超出才为满)_______________。 4. 4.对于一个长度为n的单链存储的线性表，在表头插入元素的时间复杂度为_________，在表尾插 入元素的时间复杂度为____________。 5. 5.设W为一个二维数组，其每个数据元素占用4个字节，行下标i从0到7 ，列下标j从0到3 ， 则二维数组W的数据元素共占用＿_____＿个字节。W中第6 行的元素和第4 列的元素共占用＿_______＿个字节。若按行顺序存放二维数组W，其起始地址为100，则二维数组元素W[6，3]的起始地址为＿________＿。 6. 6.广义表A= (a,(a,b),((a,b),c)),则它的深度为____________，它的长度为____________。 7.7.二叉树是指度为2的____________________树。一棵结点数为N的二叉树，其所有结点的度的 总和是_____________。 8.8.对一棵二叉搜索树进行中序遍历时，得到的结点序列是一个______________。对一棵由算术表 达式组成的二叉语法树进行后序遍历得到的结点序列是该算术表达式的__________________。 数据结构（本）期末综合练习 一、单项选择题 1．数据元素是数据的基本单位，它（ C ）。 A．只能有一个数据项组成B．至少有二个数据项组成 C．可以是一个数据项也可以由若干个数据项组成D．至少有一个数据项为指针类型 2．一种逻辑结构（ A ）存储结构。 A．可以有不同的B．只能有唯一的 C．的数据元素在计算机中的表示称为D．的数据元素之间的关系称为 3．线性表的顺序结构中，（ C ）。 A．逻辑上相邻的元素在物理位置上不一定相邻B．数据元素是不能随机访问的 C．逻辑上相邻的元素在物理位置上也相邻D．进行数据元素的插入、删除效率较高4．以下说法中不正确的是（ B ）。 A．双向循环链表中每个结点需要包含两个指针域 B．已知单向链表中任一结点的指针就能访问到链表中每个结点 C．顺序存储的线性链表是可以随机访问的D．单向循环链表中尾结点的指针域中存放的是头指针5．以下表中可以随机访问的是（ D ）。 A．单向链表B．双向链表C．单向循环链表D．顺序表 6．双向循环链表结点的数据类型为： struct node { int data; struct node *next; /*指向直接后继*/ struct node *prior; }； 设p指向表中某一结点，要显示p所指结点的直接前驱结点的数据元素，可用操作（ B ）。 A．printf(“%d”,p->next->data); B．printf(“%d”,p->prior->data); C．printf(“%d”,p->prior->next); D．printf(“%d”,p->data); 7 .设顺序存储的线性表长度为n，对于删除操作，设删除位置是等概率的，则删除一个元素平均移动元 素的次数为（ A ）。 A．(n+1)/2 B．n C．2n D．n-i 习题二 ⒉１描述以下四个概念的区别：头指针变量，头指针，头结点，首结点（第一个结点）。解：头指针变量和头指针是指向链表中第一个结点（头结点或首结点）的指针；在首结点之前附设一个结点称为头结点；首结点是指链表中存储线性表中第一个数据元素的结点。若单链表中附设头结点，则不管线性表是否为空，头指针均不为空，否则表示空表的链表的头指针为空。 2.2简述线性表的两种存储结构有哪些主要优缺点及各自使用的场合。 解：顺序存储是按索引直接存储数据元素，方便灵活，效率高，但插入、删除操作将引起元素移动，降低了效率；而链式存储的元素存储采用动态分配，利用率高，但须增设表示结点之间有序关系的指针域，存取数据元素不如顺序存储方便，但结点的插入和删除十分简单。顺序存储适用于线性表中元素数量基本稳定，且很少进行插入和删除，但要求以最快的速度存取线性表中的元素的情况；而链式存储适用于频繁进行元素动态插入或删除操作的场合。 2.3 在头结点为h的单链表中，把值为b的结点s插入到值为a的结点之前，若不存在a，就把结点s插入到表尾。 Void insert(Lnode *h,int a,int b) {Lnode *p,*q,*s; s=(Lnode*)malloc(sizeof(Lnode)); s->data=b; p=h->next; while(p->data!=a&&p->next!=NULL) {q=p; p=p->next; } if (p->data==a) {q->next=s; s->next=p;} else {p->next=s; s->next=NULL; } } 2.4 设计一个算法将一个带头结点的单链表A分解成两个带头结点的单链表A和B，使A中含有原链表中序号为奇数的元素，而B中含有原链表中序号为偶数的元素，并且保持元素原有的相对顺序。 Lnode *cf(Lnode *ha) {Lnode *p,*q,*s,*hb; int t; p=ha->next; q=ha; t=0; hb=(Lnode*)malloc(sizeof(Lnode)); s=hb; while(p->next!=NULL) {if (t==0) {q=p;p=p->next;t=1;} else {q->next=p->next; p->next=s->next; s->next=p; s=p; p=p->next; t=0; } } s->next=NULL; return (hb); } 1. 下面程序段的执行次数为（ A ） for(i=0;i＜n-1;i++) for(j=n;j＞i;j--) state; A. n(n+2)2 B .(n-1)(n+2)2 C. n(n+1)2 D. (n-1)(n+2) 2. 一个向量第一个元素的存储地址是100，每个元素的长度为2，则第5个元素的地址是 （ B ）A. 110 B .108 C. 100 D. 120 3. 一个栈的入栈序列是a,b,c,d,e，则栈的不可能的输出序列是（ C ）A. edcba B .decba C. dceab D. abcde 4. 循环队列用数组A[0,m－1]存放其元素值，已知其头尾指针分别是front和rear,则当前 队列中的元素个数是（ D ） A. (rear-front+m)%m B .read-front+1C. read-front-1 D. read-front 5．不带头结点的单链表head为空的判定条件是（ A ）A. head=NULL B .head-next=NULLC. head-next=head D. head!=NULL 6．在一个单链表中，若p所指的结点不是最后结点，在p之后插入s所指结点，则执行（ B） A. s-next=p;p-next=s; B .s-next=p-next;p-next=s; C. s-next=p-next;p=s; D. p-next=s;s-next=p; 7. 从一个具有n个结点的单链表中查找其值等于x结点时，在查找成功的情况下，需平均 比较多少个结点（ D ）A. n B .n2 C. (n-1)2 D. (n+1)28．从一个栈顶指针为HS 的链栈中删除一个结点时，用x保存被删结点的值，则执行( D )A. x=HS;HS=HS-next;B .x=HS-data;C. HS=HS-next;x=HS-data;D. x=HS-data;HS=HS-next; 9．串是一种特殊的线性表，其特殊性体现在( B ) A. 可以顺序存储 B .数据元素是一个字符C. 可以链接存储 D. 数据元素可以是多个字 符11．二维数组M的元素是4个字符（每个字符占一个存储单元）组成的串，行下标i的 范围从0到4，列下标j的范围从0到5，M按行存储时元素M[3][5]的起始地址与M按列存 储时下列哪一元素的起始地址相同( B ) A. M[2][4] B .M[3][4] C. M[3][5] D. M[4][4] 12. 数组A中，每个元素A的长度为3个字节，行下标i从1到8，列下标j从1到10， 从首地址SA开始连续存放在存储器内，该数组按行存放时，元素A[8][5]的起始地址为 ( C )A. SA+144 B .SA+180 C. SA+222 D. SA+225 数据结构上机实验题目 实验一线性表的顺序存储结构 实验学时 2学时 背景知识:顺序表的插入、删除及应用。 目的要求： 1．掌握顺序存储结构的特点。 2．掌握顺序存储结构的常见算法。 实验容 1．输入一组整型元素序列，建立顺序表。 2．实现该顺序表的遍历。 3．在该顺序表中进行顺序查找某一元素,查找成功返回1,否则返回0。4．判断该顺序表中元素是否对称,对称返回1,否则返回0。 5．实现把该表中所有奇数排在偶数之前,即表的前面为奇数,后面为偶数。 6．输入整型元素序列利用有序表插入算法建立一个有序表。 7．利用算法6建立两个非递减有序表并把它们合并成一个非递减有序表。 8. 利用该顺序结构实现循环队列的入队、出队操作。 8．编写一个主函数,调试上述算法。 #include #define OVERFLOW 0 #define MAXSIZE 100 typedef int ElemType; typedef struct list {ElemType elem[MAXSIZE]; int length; }Sqlist; void Creatlist(Sqlist &L) {int i; printf("请输入顺序表的长度："); //输入一组整型元素序列，建立一个顺序表。 scanf("%d",&L.length); for(i=0;i 注意事项1. 考试时间2小时，13：00-15：00 2. 题目4选2 3. 所有题目均使用标准输入和标准输出3. 只提交源程序，文件后缀名只能是.C或.CPP 4. 源文件大小不能超过10K，否则会被当作恶意提交而扣分5. 严格按照题目要求输出，去掉不需要的提示信息或调试信息6. 在程序中不要使用fflush(stdin)函数，否则会导致结果错误另外注意：本次是模拟测试，上机时间是4个小时，我们考试时间从14点开始到17点30分结束。同学视自己的能力，能做几道做几道。 哈夫曼树 时间限制: 100 second 内存限制: 100 Kb 描述 构造哈夫曼树（最优二叉树） 输入 输入n个结点每个结点的权值 输出 构造哈夫曼树（是最优二叉树）得到每个结点的哈夫曼编码 输入样例 23 186 64 13 22 32 103 21 15 47 57 1 5 32 20 57 63 15 1 48 51 80 23 8 输出样例 1( 186):00 2( 64):1001 3( 13):101100 4( 22):110010 5( 32):11100 6( 103):011 7( 21):110001 8( 15):101101 9( 47):11010 10( 57):0101 11( 1):101111000 12( 5):10111101 13( 32):11101 14( 20):110000 15( 57):1010 16( 63):1000 17( 15):101110 18( 1):101111001 19( 48):11011 20( 51):0100 21( 80):1111 22( 23):110011 23( 8):1011111 提示 输入第一行是结点数23 第二行是这几个结点的权值输出格式为结点号（权值）：哈夫曼编码 “数据结构”期末考试试题 一、单选题(每小题2分，共12分) 1．在一个单链表HL中，若要向表头插入一个由指针p指向的结点，则执行( )。 A． HL＝ps p一>next＝HL B． p一>next＝HL；HL＝p3 C． p一>next＝Hl；p＝HL； D． p一>next＝HL一>next;HL一>next＝p； 2．n个顶点的强连通图中至少含有( )。 A.n—l条有向边 B.n条有向边 C.n(n—1)／2条有向边 D.n(n一1)条有向边 3.从一棵二叉搜索树中查找一个元素时，其时间复杂度大致为( )。 A.O(1) B.O(n) C.O(1Ogzn) D.O(n2) 4．由权值分别为3，8，6，2，5的叶子结点生成一棵哈夫曼树，它的带权路径长度为( )。 A．24 B．48 C． 72 D． 53 5．当一个作为实际传递的对象占用的存储空间较大并可能需要修改时，应最好把它说明为( )参数，以节省参数值的传输时间和存储参数的空间。 A.整形 B.引用型 C.指针型 D.常值引用型· 6．向一个长度为n的顺序表中插人一个新元素的平均时间复杂度为( )。 A．O(n) B．O(1) C．O(n2) D．O(10g2n) 二、填空题(每空1分，共28分) 1．数据的存储结构被分为——、——、——和——四种。 2．在广义表的存储结构中，单元素结点与表元素结点有一个域对应不同，各自分别为——域和——域。 3．——中缀表达式 3十x*(2.4／5—6)所对应的后缀表达式为————。 4．在一棵高度为h的3叉树中，最多含有——结点。 5．假定一棵二叉树的结点数为18，则它的最小深度为——，最大深度为——· 6．在一棵二叉搜索树中，每个分支结点的左子树上所有结点的值一定——该结点的值，右子树上所有结点的值一定——该结点的值。 7．当向一个小根堆插入一个具有最小值的元素时，该元素需要逐层——调整，直到被调整到——位置为止。 8．表示图的三种存储结构为——、——和———。 9．对用邻接矩阵表示的具有n个顶点和e条边的图进行任一种遍历时，其时间复杂度为——，对用邻接表表示的图进行任一种遍历时，其时间复杂度为——。 10．从有序表(12，18，30，43，56，78，82，95)中依次二分查找43和56元素时，其查找长度分别为——和——· 11．假定对长度n＝144的线性表进行索引顺序查找，并假定每个子表的长度均为，则进行索引顺序查找的平均查找长度为——，时间复杂度为——· 12．一棵B—树中的所有叶子结点均处在——上。 13．每次从无序表中顺序取出一个元素，把这插入到有序表中的适当位置，此种排序方法叫做——排序；每次从无序表中挑选出一个最小或最大元素，把它交换到有序表的一端，此种排序方法叫做——排序。 14．快速排序在乎均情况下的时间复杂度为——，最坏情况下的时间复杂度为——。 三、运算题(每小题6分，共24分) 1．假定一棵二叉树广义表表示为a(b(c，d)，c(((，8)))，分别写出对它进行先序、中序、后序和后序遍历的结果。 先序： 中序； 后序： 2．已知一个带权图的顶点集V和边集G分别为： V＝{0，1，2，3，4，5}； E={(0，1)8，(0，2)5，(0，3)2，(1，5)6，(2，3)25，(2，4)13，(3，5)9，(4，5)10}， 则求出该图的最小生成树的权。 最小生成树的权； 3．假定一组记录的排序码为(46，79，56，38，40，84，50，42)，则利用堆排序方法建立的初始堆为——。 4．有7个带权结点，其权值分别为3，7，8，2，6，10，14，试以它们为叶子结点生成一棵哈夫曼树，求出该树的带权路径长度、高度、双分支结点数。 带权路径长度：——高度：——双分支结点数：——。 四、阅读算法，回答问题(每小题8分，共16分) 1．VOldAC(List&L) { InitList(L)； InsertRear(L;25)； 电大数据结构（本）考核作业答案 作业1 一、单项选择题 1．C 2．D 3．B 4．C 5．D 6．C 7．B 8．C 9．A 10．B 11．C 12．D 13．C 14．A 15．B 16．C 17．C 18．B 19．B 20．D 二、填空题 1．n-i+1 2．n-i 3．集合线性结构树形结构图状结构 4．物理结构存储结构 5．线性结构非线性结构 6．有穷性确定性可形性有零个或多个输入有零个或多个输出 7．图状结构 8．树形结构 9．线性结构 10．n-1 O(n) 11．s->next=p->next; 12．head 13．q->next=p->next; 14．p->next=head; 15．单链表 16．顺序存储链式存储 17．存储结构 18．两个直接后继直接前驱尾结点头结点 19．头结点的指针指向第一个结点的指针 20．链式链表 三、问答题 1．简述数据的逻辑结构和存储结构的区别与联系，它们如何影响算法的设计与实现？ 答：若用结点表示某个数据元素，则结点与结点之间的逻辑关系就称为数据的逻辑结构。数据在计算机中的存储表示称为数据的存储结构。可见，数据的逻辑结构是反映数据之间的固有关系，而数据的存储结构是数据在计算机中的存储表示。尽管因采用的存储结构不同，逻辑上相邻的结点，其物理地址未必相同，但可通过结点的内部信息，找到其相邻的结点，从而保留了逻辑结构的特点。采用的存储结构不同，对数据的操作在灵活性，算法复杂度等方面差别较大。 2．解释顺序存储结构和链式存储结构的特点，并比较顺序存储结构和链式存储结构的优缺点。 答： 顺序结构存储时，相邻数据元素的存放地址也相邻，即逻辑结构和存储结构是统一的，，要求内存中存储单元的地址必须是连续的。 优点：一般情况下，存储密度大，存储空间利用率高。 缺点：（1）在做插入和删除操作时，需移动大量元素；（2）由于难以估计，必须预先分配较大的空间， 数据结构上机考试试题（C++语言版） 考试要求：本次考试共列考核试题4大题，考生可以在所列4个考核试题中任选3个小题（即可能只属于2个大题），作为上机考核试题。 考核原则：所选题目在上机编程调试通过后即为考核通过。监考教师依据学生编程及调试通过与否情况给予考核成绩。 考核成绩评分标准： 所选3个题目全部编写出程序并调试通过：优 所选3个题目全部编写出程序，但只有2个上机调试通过：良 所选3个题目全部编写出程序，但只有1个上机调试通过：及格 所选3个题目全部编写出程序但都没有上机调试通过，或没有编写出全部程序：不及格。考核时间：2小时。 考核试题： 1、建立一个顺序方式存储的线性表，向表中输入若干元素后进行以下操作： （1）向线性表的表头、表尾或合适位置插入元素 （2）对线性表按升序或降序输出 2、建立一个动态链接方式存储的线性表，向表中输入若干元素后进行以下操作： （1）从单链表中查找指定元素 （2）返回单链表中指定序号的结点值 3、建立一个动态链接结构存储的二叉树，向这棵二叉树进行以下操作： （1）按任中序遍历次序输出二叉树中的所有结点 （2）求二叉树的叶子数 4、编写一个对整型数组A[n+1]中的A[1]至A[n]元素进行选择排序的算法，使得首先从待排序区间中选择出一个最大值并同最后一个元素交换，再从待排序区间中选择出一个最小值并同最第一个元素交换，反复进行直到待排序区间中元素的个数不超过1为止。 #include<> #include<> #include"" //初始化线性表 void InitList(LinearList& L, int ms) { =new ElemType[ms]; if(! { cerr<<"Memory allocation failure!"< 贵州大学理学院数学系信息与计算科学专业 《数据结构》期末考试试题及答案 (2003-2004学年第2学期) 一、单项选择题 1．对于一个算法，当输入非法数据时，也要能作出相应的处理，这种要求称为（）。 (A)、正确性(B). 可行性(C). 健壮性(D). 输入性 2．设S为C语言的语句,计算机执行下面算法时，算法的时间复杂度为（）。 for(i=n-1；i>=0；i--) for(j=0；j 第1章绪论 一、选择题 1. 算法的计算量的大小称为计算的（）。【北京邮电大学2000 二、3 （20/8分）】 A．效率 B. 复杂性 C. 现实性 D. 难度 2. 算法的时间复杂度取决于（）【中科院计算所1998 二、1 （2分）】 A．问题的规模 B. 待处理数据的初态 C. A和B 3.计算机算法指的是（1），它必须具备（2）这三个特性。 (1) A．计算方法 B. 排序方法 C. 解决问题的步骤序列 D. 调度方法 (2) A．可执行性、可移植性、可扩充性 B. 可执行性、确定性、有穷性 C. 确定性、有穷性、稳定性 D. 易读性、稳定性、安全性 【南京理工大学1999 一、1（2分）【武汉交通科技大学1996 一、1（4分）】4．一个算法应该是（）。【中山大学1998 二、1（2分）】 A．程序B．问题求解步骤的描述C．要满足五个基本特性D．A和C. 5. 下面关于算法说法错误的是（）【南京理工大学2000 一、1（1.5分）】 A．算法最终必须由计算机程序实现 B. 为解决某问题的算法同为该问题编写的程序含义是相同的 C. 算法的可行性是指指令不能有二义性 D. 以上几个都是错误的 6. 下面说法错误的是（）【南京理工大学2000 一、2 （1.5分）】 (1）算法原地工作的含义是指不需要任何额外的辅助空间 （2）在相同的规模n下，复杂度O(n)的算法在时间上总是优于复杂度O(2n)的算法（3）所谓时间复杂度是指最坏情况下，估算算法执行时间的一个上界 （4）同一个算法，实现语言的级别越高，执行效率就越低 A．(1) B.(1),(2) C.(1),(4) D.(3) 7．从逻辑上可以把数据结构分为（）两大类。【武汉交通科技大学1996 一、4（2分）】 A．动态结构、静态结构B．顺序结构、链式结构 C．线性结构、非线性结构D．初等结构、构造型结构 8．以下与数据的存储结构无关的术语是（）。【北方交通大学2000 二、1（2分）】 A．循环队列 B. 链表 C. 哈希表 D. 栈 9．以下数据结构中，哪一个是线性结构（）？【北方交通大学2001 一、1（2分）】 A．广义表 B. 二叉树 C. 稀疏矩阵 D. 串 10．以下那一个术语与数据的存储结构无关？（）【北方交通大学2001 一、2（2分）】 A．栈 B. 哈希表 C. 线索树 D. 双向链表 11．在下面的程序段中，对x的赋值语句的频度为（）【北京工商大学2001 一、10（3分）】 国家二级MS Office高级应用机试（数据结构与算法）模拟试卷 8 (总分：56.00，做题时间：90分钟) 一、选择题(总题数：28，分数：56.00) 1.下列结构中属于线性结构链式存储的是 （分数：2.00） A.双向链表√ B.循环队列 C.二叉链表 D.二维数组 解析：解析：数据元素之间的关系有两种不同的表示方法：顺序映象和非顺序映象，并由此得到两种不同的存储结构：顺序存储结构和链式存储结构。数据的存储结构是指数据的逻辑结构在计算机中的表示。双向链表也叫双链表，是链表的一种，它的每个数据结点中都有两个指针，分别指向直接后继和直接前驱，它的存储方式是线性结构链式。循环队列、二叉链表和二维数组都是顺序存储结构。 2.下列叙述中错误的是 （分数：2.00） A.循环链表中有一个表头结点 B.循环链表的存储空间是连续的√ C.循环链表实现了空表与非空表运算的统一 D.循环链表的表头指针与循环链表中最后一个结点的指针均指向表头结点 解析：解析：循环链表是另一种形式的链式存储结构。它的特点是表中最后一个结点的指针域指向头结点，整个链表形成一个环。循环链表的结点是指针指向，它不一定要是连续的存储空间，也可以是断开的空间。 3.度为3的一棵树共有30个结点，其中度为3、1的结点个数分别为3、4。则该树中的叶子结点数为 （分数：2.00） A.14 B.15 √ C.16 D.不可能有这样的树 解析：解析：根据题目可知本树中还有度为2的结点。树的总结点＝(度1*个数＋度2*个数…)＋1，这里我们设度为2的结点数为x，那么30＝3*3＋2*x＋1*4＋1＝2*x＋14，由此可计算出x＝8。树的叶子结点数等于总结点减去所有度不为0的结点，也就是30－3－8－4＝15。 4.在长度为97的顺序有序表中作二分查找，最多需要的比较次数为 （分数：2.00） A.7 √ B.96 C.48 D.6 解析：解析：二分查找又称折半查找，优点是比较次数少，查找速度快，平均性能好；其缺点是要求待查表为有序表，且插入删除困难。最多比较次数的计算方式：k＝log 2 n。其中n代表长度，k为比较次数。本题中可以计算出k＝7。 5.下列结构中属于非线性结构的是 （分数：2.00） A.二叉链表 B.二维数组√ C.循环队列 安徽大学20 04 -20 05学年第 2 学期 《数据结构》期末考试试卷（A卷） 一、单项选择（在备选答案中选出一个正确答案，并将其号码填在题后的括号内。每题2分，共20分） 01．堆是一种数据结构, ( ) 是堆. A、(10,50,80,30,60,20,15,18) B、(10,18,15,20,50,80,30,60) C、(10,15,18,50,80,30,60,20) D、(10,30,60,20,15,18,50,80) 02．广义表有两个重要的基本操作,取列表表头Head(Ls),和取列表表尾Tail(Ls),请利用这两个操作取出Ls中原子f的运算是( ),已知广义表Ls=((a,b,c,d),(e,f,g,h)). A、Head(Tail(Ls)) B、Tai(Head(Ls)) C、. Head(Tail(Head(Tail(Ls)))) D、Head(Tail(Tai(Head(Ls)))) 03.若已知一棵二叉树的前序序列是BEFCGDH,中序序列是FEBGCHD,则他的后序序列是( ) A、EFGHBCD B、FEGHDCB C、FEGBHDC D、EFBGCHD 04.在下列常用内部排序方法中属于不稳定排序的是( ) A、希尔排序,快速排序,简单选择排序,堆排序 B、希尔排序,快速排序,2-路归并排序,堆排序 C、直接插入排序,起泡排序, 希尔排序, 简单选择排序 D、2-路归并排序,堆排序, 希尔排序,起泡排序 05.有一个具有n个顶点的连通图生成的最小生成树中,具有( )条边 A、n B、n-1 C、n+1 D、2n-1 06.下面的二叉树中，（）不是平衡二叉树。 A B C D 07.如下图给出由七个顶点组成的无向图,从顶点1出发,对它进行深度优先遍历得到的顶点序列是( ) A、1354267 ①② B、1347625 C、1534276 ③④⑦ D、1247653 ⑤⑥ . 08.将pascal语言的数组A[0..8,0..8]按行优先次序存储在起始地址为1000的连续的内存单元中，每个存储单元的长度为2，则元素A[7,3]的地址是 ( ) A、1132 B、 1134 C、1114 D、1112 数据结构复习题 一、单选题(每小题2分，共12分) 1．在一个单链表HL中，若要向表头插入一个由指针p指向的结点，则执行( )。 A． HL＝ps p一>next＝HL B． p一>next＝HL；HL＝p3 C． p一>next＝Hl；p＝HL； D． p一>next＝HL一>next;HL一>next＝p； 2．n个顶点的强连通图中至少含有( )。 A.n—l条有向边 B.n条有向边 C.n(n—1)／2条有向边 D.n(n一1)条有向边 3.从一棵二叉搜索树中查找一个元素时，其时间复杂度大致为( )。 A.O(1) B.O(n) C.O(1Ogzn) D.O(n2) 4．由权值分别为3，8，6，2，5的叶子结点生成一棵哈夫曼树，它的带权路径长度为( )。 A．24 B．48 C． 72 D． 53 5．当一个作为实际传递的对象占用的存储空间较大并可能需要修改时，应最好把它说明为( )参数，以节省参数值的传输时间和存储参数的空间。 A.整形 B.引用型 C.指针型 D.常值引用型· 6．向一个长度为n的顺序表中插人一个新元素的平均时间复杂度为( )。 A．O(n) B．O(1) C．O(n2) D．O(10g2n) 二、填空题(每空1分，共28分) 1．数据的存储结构被分为——、——、——和——四种。 2．在广义表的存储结构中，单元素结点与表元素结点有一个域对应不同，各自分别为——域和——域。 3．——中缀表达式 3十x*(2.4／5—6)所对应的后缀表达式为————。 4．在一棵高度为h的3叉树中，最多含有——结点。 5．假定一棵二叉树的结点数为18，则它的最小深度为——，最大深度为——· 6．在一棵二叉搜索树中，每个分支结点的左子树上所有结点的值一定——该结点的值，右子树上所有结点的值一定——该结点的值。 7．当向一个小根堆插入一个具有最小值的元素时，该元素需要逐层——调整，直到被调整到——位置为止。 8．表示图的三种存储结构为——、——和———。 9．对用邻接矩阵表示的具有n个顶点和e条边的图进行任一种遍历时，其时间复杂度为——，对用邻接表表示的图进行任一种遍历时，其时间复杂度为——。 10．从有序表(12，18，30，43，56，78，82，95)中依次二分查找43和56元素时，其查找长度分别为——和——· 11．假定对长度n＝144的线性表进行索引顺序查找，并假定每个子表的长度均为，则进行索引顺序查找的平均查找长度为——，时间复杂度为——· 12．一棵B—树中的所有叶子结点均处在——上。 13．每次从无序表中顺序取出一个元素，把这插入到有序表中的适当位置，此种排序方法叫做——排序； 每次从无序表中挑选出一个最小或最大元素，把它交换到有序表的一端，此种排序方法叫做——排序。 14．快速排序在乎均情况下的时间复杂度为——，最坏情况下的时间复杂度为——。 三、运算题(每小题6分，共24分) 1．假定一棵二叉树广义表表示为a(b(c，d)，c(((，8)))，分别写出对它进行先序、中序、后序和后序遍历的结果。 先序： 中序； 后序： 2．已知一个带权图的顶点集V和边集G分别为： V＝{0，1，2，3，4，5}； #include //void insert(struct Lnode**L,int n, char d) //从功能化分上，这个函数不需要知道现在插入第几个字符//困为你init函数中是先对一个串的字符进行了排序，所以//这里直接插入链表的尾部就行了 void insert(struct Lnode**L, char d) { struct Lnode *t1,*t2; int j=1; t1=(struct Lnode*)malloc(sizeof(struct Lnode)); t1-> data=d; t1-> next=NULL; if(*L==NULL) { *L=t1; return; } t2=*L; while(t2-> next!=NULL) { t2=t2-> next; } t2-> next=t1; /* if(n==1) { t1-> next=t2; *L=t1; } else { while(j 东南大学十套数据结构试题及答案
国家开放大学电大《数据结构》《离散数学》网络课形考网考作业(合集)答案
国家二级ACCESS机试选择题(数据结构与算法)模拟试卷3
清华大学数据结构试题及答案
20202020年电大数据结构(本)期末复习材料
数据结构上机例题及答案
武汉大学数据结构考试题(附答案)
经典数据结构上机题_答案解析
数据结构上机考试题
大学数据结构期末考试试题(有答案)
电大数据结构形成性考核册答案(作业1-4)
数据结构上机考试试题
数据结构期末考试试题及答案资料
数据结构考试题库含参考答案
国家二级MS+Office高级应用机试(数据结构与算法)模拟试卷8
安徽大学数据结构试卷04-05
大学数据结构期末考试试题(有答案)
数据结构上机题
相关主题
文本预览