數(shù)據(jù)結(jié)構(gòu)實(shí)訓(xùn)一(順序表)

數(shù)據(jù)結(jié)構(gòu)實(shí)訓(xùn)一（順序表）

#include<srdio.h>

#mclude<conio.h>〃包含getchQ函數(shù)

#include<stdlib.h>

^defineMAXSIZE1000

"定義順序表類型

typedefmtElemTpe;

typedefstiuct(

ElemTypedatafMAXSIZE];

intlength;

}SeqList;〃給順序表類型起-個(gè)別名SeqList;

〃定義接II

mtLiputChoice(jy/iS擇函數(shù)

voidInitList(SeqList*List);//初始化順序表

voidDisphy(SeqListList);n顯示函數(shù)

voidlusE(SeqList*List);〃插入函數(shù)

voidSearch(SeqListList)〃查找函數(shù)

voidDelete(SeqList*List);//刪除函數(shù)

voidSiinpleSort(SeqListList)〃簡(jiǎn)單選擇排序

intPanition(SeqListList,mtleftjntright);〃，快排分割調(diào)整

voidQuicksort(SeqListintleft,intright);〃'快速其F序

voidBuiaiySeaich(SeqListList)〃折半查找

voidInveser(SeqListList);〃逆置順序表

voidInseiISoit(SeqListList);〃直接插入排序

voidBubbleSoit(SeqListList)〃冒泡排序

voidOrderliisert(SeqList*List);〃W序插入

voidDeleteBehveeiiXY(SeqList禮ist);〃?|I除介于X和Y之間的俱

voidMergeList(SeqList*List_LSeqList*List_2.SeqLisr*List_3);u合并順序表voidSplitList(SeqList

*List_l,SeqList*List_2,SeqList*List_3)〃拆分順序表voidSheUSon(SeqListList);〃希爾排序

voidHeapAdjust(SeqList*List,mtroot,inrlength);〃建立大頂堆

voidHcapSort(SeqListList);〃堆排序

voidmain。

(

intmyChoice;

SeqListList;

SeqListList1;

SeqListList2;

SeqListList.3;

wlule(l)

(

systein(McisM);

myClioice=IiiputChoiceO;

switch(my*Choice)

(

case0:

exit(0);

break;

case1:

TnitList(&List);

break;

case2:

printf("當(dāng)前順序表為：“)；

Display(List);

getchO；

break;

case3:

liisert(&List);

break;

case4:

Seaich(IJst);

break;

case5:

Delete(ftList);

break;

case6:

SmipleSon(List);

break;

case7:

prmrf(排序前：”)；

Display(List);

Quicksort(&List,0,List.length-1);

prmtf(”“快速排序成功!S由于能力有限,暫無法計(jì)算挪移和比較次數(shù)…‘心山”);

printf(”排序后：〃)；

Display(List);

getchO;

break;

case8:

BinarySearch(List);

break;

case9:

Inveser(List);

break:

case10:

InsenSon(List);break;

case11:

BubbleSort(List);

break;

case12:

Orderhisen(&List);

break;

case13:

DeleteBetweeiiXY(&List);break;

case14:

MergeList(&List_l,&List_2,&List_3);break;

case15:

Spli(List(&List_L&List_2.&List_3);break;

case16:

HeapSon(List);break;

case17:

ShellSon(List);break;

default:

break;

}

)

)

〃選擇函數(shù)

mtliiputChoiceQ

(

mtmyChoice;

print町\n\iT);

pimtf*\t\t\t\t網(wǎng)頁序表操作\n"):

pnntff,\t\t----------------------------------------------\n");

pnntR>>\t\t1：初始化\t")；pnntRu\t\t2:顯示W(wǎng));

priiitfC\t\t3：插入W);

prmtff\t\t4：查找\n")；

prmtfC\t\t5：刪除\t")：

prmtf(*\t\t6：簡(jiǎn)單選擇排序\n”)；

pnntRw\t\t7：快速排序\t")；

pnntff\t\t8：折半查找\n”)：

prmtfr\t\t9：逆置線性表\t”)：

priiitf(*\t\t10：直接插入排序\n")；

pimtf^VtXt11：冒泡排序\t")；

prmtfl*\t\t12：有序插入山”)；

printf(M\t\t13：刪除介于X&Y值之問的數(shù)“);prmtf("\t14：合并順序表

E");prmtf15：拆分M頁序表\f)；

pnntff,t16：堆排序\n")；prmtf("\t\t17：希爾排序W);

priiitf(*\t\t0：退出\n");

print---------------------------------------------------〃)；

pnntR〃\l\t\r請(qǐng)選擇：")：scaiif(w%d\&myChoice);

pnntRW);

retuinmyClioice;

)

〃初始化

voidImtList(SeqList*List)

{

iiitlength,seed;

pimrfT請(qǐng)輸入元素個(gè)數(shù)(0-%d)：M,MAXSIZE);

while(1)

(

scaiif(M%d\<Srlength);

if-lengtli>=0&&lengtli<=MAXSIZE)break;

else

printf("您的輸入不合法，請(qǐng)重新輸入;

}

pun頃-請(qǐng)輸入隨機(jī)數(shù)種子(0-32767):;whUe(1)

(

scaiif(W,&seed);ifseed>=0&&seed<=32767)break;

else

printf("您的輸入不合法，請(qǐng)重新輸入;

)

srand(seed);

"初始化數(shù)據(jù)和長(zhǎng)度

fbr(inti=0:i<length;i++)List->data[i]=rand()%90+10;

for(intj=lengtliMAXSIZEj++)List->dataIj]=O,

List->leiigth=length;

pnntfT初始化成功...’n")；

getchO；

〃顯示函數(shù)

voidDisplay(SeqListList)

i=0;i<List.length;i++)printR"%dWJ.istdata[i]);

pnntffp")；

)

〃插入函數(shù)

voidInsen(SeqList*List)

{

intlocauon.element,

prints當(dāng)前順序表為：");

Display(*List);

〃判斷是否溢出

if(List.>lengrh—MAXSIZE)

printf—該順序表存儲(chǔ)空間己滿.無法繼續(xù)插入…偵)；else

(

pnnif(”\n請(qǐng)輸入插入位置：”)；

while(1)

(

scanfV*%d”,&locau(m);

if(location>0&&location<=List->length)break;

else

pnntf(“插入位置不合法，請(qǐng)重新輸入■>：")；}prmrf(〃請(qǐng)輸入插入的

元素：”);

scanf("%d”.&eleinent),

List->length++;

foi(inti=List->leugth-l;i>=location;i-)

List->data[i]=IJst->data[i-1];

List->data[location-1]=element;

pnniR“兀素%d插入％d位置成功…\n‘,elementJoca(ion);pnntR”插入后順序表

為：”);

Display(*List);

getchO；

"查找函數(shù)

voidSeaicli(SeqListList)

(

ElemTypeelement;

inti=0;

pimtff請(qǐng)輸入要查找的兀素：“)；scanf(%d\&element);

while(i<List.lengtli)

if^List.data[i++]=elemeuT)

break;

pnntfT整個(gè)查找過程共挪移了％d次

if(i<List.lengtli)

(

pnntR"查找成功…"”)；

prmtfl"兀素%d在順序表中的位置是：版I",element,i);}else

(

pimtfl〃查找失敗..An“)；

pnntR”在該順序表中未找到兀素％delement);

}

getcliQ;

}

"刪除函數(shù)

voidDelete(SeqList*List)

(

intelement;

血i=0j;

pnntfC請(qǐng)輸入要?jiǎng)h除的元素：“)；

scanf("%(!1\<Sre1emenr);

while(i<List->leng±)

if"IJst->data[i++]=element)break;

prints本次刪除共比較次，挪移%一次

if(i<List->length)

(

fdr(j=ij<List->length;j++)List->data[j-l]=List->data[j];

prmtR”刪除成功..NT);

prmtff?刪除后的順序表為：”)；

〃順序表長(zhǎng)度減一

List->length—;

Display(*List);

)

else

pnnifC刪除失敗，該順序表中不含有一元素刎element);getch(J;

)

〃簡(jiǎn)單選擇排序

voidSimpleSort(SeqListList)

intij.nun;

iiitiCount=0jCount=0;

pnntf(n排序前：”)；

Display(List);

fbr(i=0;i<List.lengtli-1;i++)

{

mm=i;

for(j=i+lj<List.lengtlij++)

{

if(List,datalj]<List.datafmin])

mm二j;

jCouiit++;

List.data[i]List.data[i]+List.data[min];

List.data[niin]=List.data[i]-Lisr.data[min];List.data[i]=List.data[i]-List.data[miii];

)

iCount+*;

)

pnntfC簡(jiǎn)單選擇排序共挪移：%d次,比較了:%d次…\n”，iCoimt+jCoimt,jCoimt);pnntf("

排序后：”);

Display(List);

getchO；

)

〃分割數(shù)據(jù)將無序數(shù)列首項(xiàng)中間(左小-首項(xiàng)-右大)位置

intPanitiou(SeqList*List,mtleft,intlight)

{

inti=leftj=nght,temp;

temp=List->data[i];

whileo!』J

(

while(i<j&&List->data[j]>=Temp)

1R1VJ)

List->data[i]=List->data[j];

while(i<j&&List->data[i]<=teinp)

1++;

如勺)

List->data[j]=Lis(->data[i],

)

List->dcita[i]=temp;

returni:

"快速排序

voidQinckSort(SeqList*Lisr.mtleft,mtright)

(

inti;

if(left<nght)

(

i=Panition(List,left,right);

Quicksort(List1);

QuickSon(List4+1jight);

"折半查找

voidBuiaiySeaich(SeqListList)

iiitcount=0//i己錄比較次數(shù)mtelementJow.mid.high;1ow=0:

high二List,length-1;

pnntfT請(qǐng)輸入要查找的元素：");scanf("%d\&element);

"快速排序使其成為有序數(shù)列

Quicksort(&List,0,List,lengthJ)；

wlnle(low<=higli)

(

mid=(low+high)/2;

coxuit-1~;

if-List,data[mid]—element)

break;

else

if(List,data[nud]<element)low=mid+];

else

lugli=mid-l;

)

pirntfC,本次查找次數(shù)為：.\i『count);

if(low<=lugh)

(

pnntf(w查找成功…W);

pnntR"兀素刎在順序表中的位置是：%d.element.nud-l);}else

(

pnntR”查找失敗…，iT)；

pnntR“兀素%d不在該順序表中...8"，element);

)

getcliQ;

}

〃逆置順序表

voidInvesei(SeqIJstList)

(

mtj=List.lengtli-1;

pimtfc逆置前：”);

Display(List);

fbr(inti=0:i<Lisr.lengthA;i++)

(

List.data[i]=List.data[i]+List.data[j];

List.data[j]=List.data[i]-List.data(j];

List.data[i]=List.data[i]-List.data[j];

)prmtT逆置后：”);Display(List);

getcho;

)

〃直接插入排序

voidInseiISoit(SeqListList)

(

intij.k,temp;printfC升F序育If:")；Display(Lisr);

j<List.lengthj++)

if(List.data(j]>List.data[i])break:

tenip=List.data[j]tfbr(k=j;k>i+l;k??)

List.data[k]=List.data[k-l];

List.data[i+l]=teinp;

)

}pnntff排序后：”);Display(Lisr);

getchO；

1

〃冒泡排序

voidBubbleSoil(SeqListList)

pant町,封E序刖：");Display(Lisr);

inti,j=List.lengtli-1;

\vhile(j>0)

(

for(i=0;i<j;i++)

if(List.data[i]>List.data[i+l])

(

List.data[i]=List.data[i]+List.data[i+l];

List.data[i+l]=List.data[i]-Listdata[i+l];

List.data[i]=List.data[i]-List.data[i+l];

pnntff?排序后：");

Display(List);

getcliQ;

}

"有序插入

voidOrderliisert(SeqList*List)

(

〃溢出判斷

if(List->length>=MAXSIZE)

prmtfC?順序表存儲(chǔ)空間己滿，無法進(jìn)行插入操作...3)；else

(

uu1j.element;

"快排使其成為有序數(shù)列

QuickSoil(List,0,List->lengtli~l);

printf("插入前：");

Display(*List);

pnntff");

prinlf(”請(qǐng)輸入要插入的元素：");scanf(,，%dv,&element);

〃根據(jù)數(shù)值大小找到插入位置for(i=0;i<List->length;i-H-)if(element<List->data[i])

break;

List->length++;//表長(zhǎng)加一1〃空出插入位置后賦值插入for(j=List->Iengtli-1j>ij—)

List->data[j]=List->data[j-l];

List->data[iJ=element;

printf(“本次插入比較的次數(shù)為：%d,挪移的次數(shù)為：％d.\n\iJList^>length-M);

pnnif("插入后：”);

Display(*List);

)getcho；

〃刪除X利Y之間的值

voidDeleteBerweeiiXY(SeqList*List)

{

mtm,n,maxjnui;

mti,j=0;

pnntfT刪除前：”),

Display(*List);

pnntf("請(qǐng)輸入要?jiǎng)h除的范圍…公司；

pnntR”最大值：”)；

pnntf("最小值：”)；

(

prmtf("您的輸入不和邏輯，系統(tǒng)將自動(dòng)更正m=m+n;

n=m-n;

m=ni-n;

)

niax=m;

miii=n;

fbi(i=0;i<List->lengdi;i++)

〃遍歷所有數(shù)值，不在*和丫之問的值賦值給U]

if^List->data[i]<niui||List->data[i]>max)

List->data[j++]=List->data[i];

List->length=j;

pnntf(w刪除后i");

Display"List);

getchO；

)

"合并順序表

voidMergeList(SeqList*List_l.SeqList*List_2.SeqList*List_3){

intij.k;

prmtfT初始化順序表L..M")；

IiutList(List_l);

pnntffW);

pimtfT初始化順序表2...3);

ImtList(List2),

pimtif偵');

QuickSon(List1.0,List1->length-l);

QuickSoiT(List_2.0Xist_2->lengtli-l);pnntR”合并前..An")；pnntfT順序表1：”）；

Display(*List1);

pnntR”順序表2：”);

Display(*List_2);

"比較兩個(gè)表中是否存在相同的值

fbr(i=0;i<List_l->lengthsi++)

for(j=0:j<List_2->lengthj++)

if(List_2->data[j]=List_l->data[i])

List_l->data[i]=-l;

1=0；j=0;k=0;

"當(dāng)兩個(gè)表同時(shí)存在時(shí)

wlule(i<List_1->length&&j<List_2->length)

if(List_l->data[i]<LisC2->data|j])

->data[i]==?1)

i++:

else

List_3->data[k++]=List」-〉data[i++];el

LisC3->data[k++]=List_2->data[j—I-];

"當(dāng)僅有表1存在時(shí)

\vhile(i<List_l->lengtli)

if*List_l->data[i]=-l)

1++;

else

Lisc3->data[k+]=Listl->data[i++];

"當(dāng)僅有表2存在時(shí)

\vhile(j<List_2->lengtli)

List_3->data[k一F]=List_2->data[j++];

〃表3的長(zhǎng)度為k

List_3->length=k;

pnntfC'合并后

pnntR”順序表為：”);

Display(逗Lis七3);

getchQ；

〃拆分順序表

voidSplitIJst(SeqListSeqList*List_25eqList*List_3)

intij=0,k=0;

prmtfT初始化順序表?..W)；

ImtList(List1),

pmitf({[^，);拆分前pnntfC順序表為：”)Display(*List」)；

pnntf(*\n");foi(i=0;i<List_l->length5i++)

if(Liscl->data[i]%2-=0)

List_2->data[j++]=List」->data[i];

else

List_3->data[k++]=LisCl->data[i];

List2->length);

List_3->length=k;

pnntfC拆分后

pirntfC偶數(shù)順序表為：”)：

Display(*List_2);

pirntf(-奇數(shù)順序表為：”)；

Display(*List_3)