第一篇：數(shù)據(jù)結(jié)構(gòu)實(shí)驗(yàn)報(bào)告-排序與查找

電 子 科 技 大 學(xué)

實(shí)

驗(yàn)

報(bào)

告

學(xué)生姓名：XXX 學(xué) 號(hào)：20***

指導(dǎo)教師：劉嶠 實(shí)驗(yàn)地點(diǎn)：信軟機(jī)房306

實(shí)驗(yàn)時(shí)間：2014/6/20

一、實(shí)驗(yàn)室名稱：軟件實(shí)驗(yàn)室

二、實(shí)驗(yàn)項(xiàng)目名稱：數(shù)據(jù)結(jié)構(gòu)與算法—排序與查找

三、實(shí)驗(yàn)學(xué)時(shí)：4

四、實(shí)驗(yàn)原理：

快速排序的基本思想是：通過一躺排序?qū)⒁判虻臄?shù)據(jù)分割成獨(dú)立的兩部分，其中一部分的所有數(shù)據(jù)都比另外一不部分的所有數(shù)據(jù)都要小，然后再按次方法對(duì)這兩部分?jǐn)?shù)據(jù)分別進(jìn)行快速排序，整個(gè)排序過程可以遞歸進(jìn)行，以此達(dá)到整個(gè)數(shù)據(jù)變成有序序列。

假設(shè)要排序的數(shù)組是A[1]……A[N]，首先任意選取一個(gè)數(shù)據(jù)（通常選用第一個(gè)數(shù)據(jù)）作為關(guān)鍵數(shù)據(jù)，然后將所有比它的數(shù)都放到它前面，所有比它大的數(shù)都放到它后面，這個(gè)過程稱為一躺快速排序。一躺快速排序的算法是：

1）設(shè)置兩個(gè)變量I、J，排序開始的時(shí)候I：=1，J：=N

2）以第一個(gè)數(shù)組元素作為關(guān)鍵數(shù)據(jù)，賦值給X，即X：=A[1]；

3）從J開始向前搜索，即（J：=J-1），找到第一個(gè)小于X的值，兩者交換；

4）從I開始向后搜索，即（I：=I+1），找到第一個(gè)大于X的值，兩者交換；

5）重復(fù)第3、4步，直到I=J。

二分法查找（折半查找）的基本思想：

（1）確定該區(qū)間的中點(diǎn)位置：mid=（low+high）/2 min代表區(qū)間中間的結(jié)點(diǎn)的位置，low代表區(qū)間最左結(jié)點(diǎn)位置，high代表區(qū)間最右結(jié)點(diǎn)位置

（2）將待查a值與結(jié)點(diǎn)mid的關(guān)鍵字（下面用R[mid].key）比較，若相等，則查找成功，否則確定新的查找區(qū)間：

A)如果R[mid].key>a，則由表的有序性可知，R[mid].key右側(cè)的值都大于a，所以等于a的關(guān)鍵字如果存在，必然在R[mid].key左邊的表中,這時(shí)high=mid-1;

B)如果R[mid].key

C)如果R[mid].key=a，則查找成功。

（3）下一次查找針對(duì)新的查找區(qū)間，重復(fù)步驟（1）和（2）

（4）在查找過程中，low逐步增加，high逐步減少，如果high

五、實(shí)驗(yàn)?zāi)康模?/p>

本實(shí)驗(yàn)通過實(shí)現(xiàn)快速排序和折半查找算法，使學(xué)生理解如何實(shí)現(xiàn)快速查找和排序的基本算法思想。通過練習(xí)，加強(qiáng)對(duì)算法的理解，提高編程能力。

六、實(shí)驗(yàn)內(nèi)容：

（1）實(shí)現(xiàn)數(shù)據(jù)序列的輸入;

（2）實(shí)現(xiàn)快速排序算法,并對(duì)輸入的序列排序后輸出；

（3）實(shí)現(xiàn)折半查找算法,并在步驟(2)排序后的序列上,進(jìn)行任意地 查找,并輸出查詢結(jié)果。

七、實(shí)驗(yàn)器材（設(shè)備、元器件）：

八、數(shù)據(jù)結(jié)構(gòu)及程序

#include

#define MAX_LEN 100

void Sort(int *data,int left,int right){

int i,j,temp;

i=left;

j=right;

temp=data[left];

if(left>right)

return;

while(i!=j){

while(data[j]>=temp&&j>i)

j--;

if(j>i)

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

while(data[i]<=temp&&j>i)

i++;

if(j>i)

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

}

data[i]=temp;

Sort(data,left,i-1);PC機(jī)一臺(tái)，裝有C/C++語言集成開發(fā)環(huán)境。

Sort(data,i+1,right);}

int Search(int *data,int start,int end,int key,int num){

int result;

int p =(start + end)/ 2;

if(data[p] == key&&start<=end){

result = p;

num++;

if(data[p] > key)

result = Search(data, start, p, key,num);

else

result = Search(data, p + 1, end, key,num);

return result;

}

else if(num==0&&start>end){

result =-1;

printf(“n 404 NO FOUNDn”);

return result;

}

else if(num!=0&&start>end){

result=-1;

if(num==1)

printf(“nFounded number only one”);

else

printf(“nFounded number more than one”);

return result;

}

else if(result!=-1){

if(data[p] > key)

result = Search(data, start, p-1, key, num);

else

result = Search(data, p + 1, end, key, num);

return result;

}

else {

result=-1;

return result;

} }

void loadFile(int *data,char *filename,int n){

int i;

FILE *pfile=NULL;

pfile=fopen(filename,“r”);

if(!pfile){

printf(“Open file failn”);

exit(0);

}

else

printf(“Open file success!n”);

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

fscanf(pfile , “%d ”,&data[i]);}

int main(int argc, const char * argv[]){

int input=1,data[MAX_LEN],num=0,key=1,i,cmd;

char filename[100];

printf(“Choose Mode :n 1.Input Mode

2.File Moden”);

scanf(“%d”,&cmd);

if(cmd==1){

printf(“Input data :(Enter 0 to detemine)n”);

while(input!=0){

printf(“Enter the %d data :”,num+1);

scanf(“%d”,&input);

if(input!=0){

data[num]=input;

num++;

}

}

}

else{

printf(“nInput the address of the file: ”);

scanf(“%s”,filename);

printf(“nInput the number of elem: ”);

scanf(“%d”,&num);

loadFile(data,filename,--num);

}

Sort(data, 0, num);

printf(“nSort result: ”);

for(i=1;i<=num;i++)

printf(“%d ”,data[i]);

printf(“nn”);

while(key!=0){

printf(“nInput a key to search :(Enter 0 to detemine)”);

scanf(“%d”,&key);

if(key!=0)

Search(data, 0, num, key, 0);

}

return 0;}

九、程序運(yùn)行結(jié)果： 1.打開程序：

2.嘗試手動(dòng)輸入模式：

3.搜索已存在數(shù)： 4.搜索不存在數(shù)：

5.嘗試文件讀入模式并搜索

實(shí)驗(yàn)成功。

十、實(shí)驗(yàn)結(jié)論：

使用好的排序與查找算法對(duì)于程序的運(yùn)行效率至關(guān)重要，一個(gè)好的算法，適合的算法能使計(jì)算機(jī)對(duì)數(shù)據(jù)的處理事半功倍，而選用錯(cuò)誤的算法，不但可能事倍功半，還有可能造成不穩(wěn)定因素。

快速排序的時(shí)間復(fù)雜度為n（log2n）,是排序算法中最為快速的一種，但是不穩(wěn)定，對(duì)基本有序的序列效率較差。

二分查找算法在查找算法中，速度快，效率高，但是要求數(shù)據(jù)要有序。

十一、總結(jié)及心得體會(huì)：

當(dāng)空間充足，對(duì)穩(wěn)定性要求不高的情況，排序算法宜使用快速排序。

快速排序和二分查找配合，可以以較高的效率查找目標(biāo)元素。

第二篇：數(shù)據(jù)結(jié)構(gòu)查找實(shí)驗(yàn)報(bào)告

實(shí)驗(yàn)題9.1 設(shè)計(jì)一個(gè)程序exp9-1.cpp，輸出在順序表{3，6，2，10，1，8，5，7，4，9}中采用順序方法找關(guān)鍵字5的過程。程序如下：

//文件名:exp9-1.cpp #include #define MAXL 100 typedef int KeyType;typedef char InfoType[10];typedef struct {

KeyType key;

//KeyType為關(guān)鍵字的數(shù)據(jù)類型 //其他數(shù)據(jù)

//定義表中最多記錄個(gè)數(shù)

InfoType data;

} NodeType;typedef NodeType SeqList[MAXL];

//順序表類型

int SeqSearch(SeqList R,int n,KeyType k)//順序查找算法

{

int i=0;

while(i

{

} printf(“%d ”,R[i].key);i++;

//從表頭往后找

if(i>=n)return-1;

else

} void main(){ SeqList R;{

} printf(“%d”,R[i].key);return i;

} int n=10,i;KeyType k=5;int a[]={3,6,2,10,1,8,5,7,4,9};for(i=0;i

//建立順序表

printf(“關(guān)鍵字序列:”);for(i=0;i

截圖如下：

實(shí)驗(yàn)題9.2 設(shè)計(jì)一個(gè)程序exp9-2.cpp，輸出在順序表{1，2，3，4，5，6，7，8，9，10}中采用折半查找法查找關(guān)鍵字9的過程。

程序如下：

//文件名:exp9-2.cpp #include #define MAXL 100 typedef int KeyType;typedef char InfoType[10];typedef struct {

//定義表中最多記錄個(gè)數(shù) KeyType key;

//KeyType為關(guān)鍵字的數(shù)據(jù)類型

InfoType data;

//其他數(shù)據(jù) } NodeType;typedef NodeType SeqList[MAXL];

//順序表類型

int BinSearch(SeqList R,int n,KeyType k)//二分查找算法 { int low=0,high=n-1,mid,count=0;while(low<=high)

{

mid=(low+high)/2;printf(“ 第%d

次

比

較

:在[%d,%d]R[%d]:%dn”,++count,low,high,mid,R[mid].key);

if(R[mid].key==k)

//查找成功返回

return mid;

if(R[mid].key>k)

//繼續(xù)在R[low..mid-1]中查找

high=mid-1;

else

low=mid+1;

//繼續(xù)在R[mid+1..high]中查找 } return-1;} void main(){ SeqList R;KeyType k=9;int a[]={1,2,3,4,5,6,7,8,9,10},i,n=10;for(i=0;i

//建立順序表

R[i].key=a[i];printf(“關(guān)鍵字序列:”);for(i=0;i

比

較

元

素

中

} else printf(“元素%d的位置是%dn”,k,i);printf(“元素%d不在表中n”,k);

截圖如下：

實(shí)驗(yàn)題9.3 設(shè)計(jì)一個(gè)程序exp9-3.cpp，輸出在順序表{8，14，6，9，10,22,34,18,19,31,40,38,54,66,46,71,78,68,80,85,100,94,88,96,87}中采用分塊查找法查找（每塊的塊長為5，共5塊）關(guān)鍵字46的過程。

程序如下：

//文件名:exp9-3.cpp #include #define MAXL 100 #define MAXI 20 typedef int KeyType;typedef char InfoType[10];typedef struct {

KeyType key;

//KeyType為關(guān)鍵字的數(shù)據(jù)類型

//定義表中最多記錄個(gè)數(shù)

//定義索引表的最大長度

InfoType data;

//其他數(shù)據(jù) } NodeType;typedef NodeType SeqList[MAXL];typedef struct {

KeyType key;int link;

//KeyType為關(guān)鍵字的類型 //指向分塊的起始下標(biāo)

//順序表類型

} IdxType;typedef IdxType IDX[MAXI];

//索引表類型

int IdxSearch(IDX I,int m,SeqList R,int n,KeyType k)//分塊查找算法 { int low=0,high=m-1,mid,i,count1=0,count2=0;int b=n/m;

//b為每塊的記錄個(gè)數(shù)

printf(“二分查找n”);while(low<=high)

//在索引表中進(jìn)行二分查找,找到的位置存放在low中

{

mid=(low+high)/2;printf(“ 第%d

次

比

較

:在[%d,%d]

中

比

較

元R[%d]:%dn”,count1+1,low,high,mid,R[mid].key);

if(I[mid].key>=k)

high=mid-1;

else

low=mid+1;

count1++;

//累計(jì)在索引表中的比較次數(shù)

} if(low

//在索引表中查找成功后,再在線性表中進(jìn)行順序查找

{

printf(“比較%d次,在第%d塊中查找元素%dn”,count1,low,k);

i=I[low].link;

printf(“順序查找:n

”);

while(i<=I[low].link+b-1 && R[i].key!=k)

{

i++;count2++;

printf(“%d ”,R[i].key);} //count2累計(jì)在順序表對(duì)應(yīng)塊中的比較次數(shù)

printf(“n”);

printf(“比較%d次,在順序表中查找元素%dn”,count2,k);

if(i<=I[low].link+b-1)

return i;

else

return-1;}

素 } return-1;void main(){

} SeqList R;KeyType k=46;IDX I;int a[]={8,14,6,9,10,22,34,18,19,31,40,38,54,66,46,71,78,68,80,85,100,94,88,96,87},i;for(i=0;i<25;i++)R[i].key=a[i];

//建立順序表

I[0].key=14;I[0].link=0;I[1].key=34;I[1].link=4;I[2].key=66;I[2].link=10;I[3].key=85;I[3].link=15;I[4].key=100;I[4].link=20;if((i=IdxSearch(I,5,R,25,k))!=-1)else printf(“元素%d不在表中n”,k);printf(“元素%d的位置是%dn”,k,i);printf(“n”);

截圖如下：

第三篇：《數(shù)據(jù)結(jié)構(gòu)》實(shí)驗(yàn)報(bào)告——排序

《數(shù)據(jù)結(jié)構(gòu)》實(shí)驗(yàn)報(bào)告 排序

實(shí)驗(yàn)題目：

輸入十個(gè)數(shù)，從插入排序，快速排序，選擇排序三類算法中各選一種編程實(shí)現(xiàn)。

實(shí)驗(yàn)所使用的數(shù)據(jù)結(jié)構(gòu)內(nèi)容及編程思路：

1.插入排序：直接插入排序的基本操作是，將一個(gè)記錄到已排好序的有序表中，從而得到一個(gè)新的，記錄增一得有序表。

一般情況下，第i趟直接插入排序的操作為：在含有i-1個(gè)記錄的有序子序列r［1..i-1］中插入一個(gè)記錄r［i］后，變成含有i個(gè)記錄的有序子序列r［1..i］；并且，和順序查找類似，為了在查找插入位置的過程中避免數(shù)組下標(biāo)出界，在 r［0］處設(shè)置哨兵。在自i-1起往前搜索的過程中，可以同時(shí)后移記錄。整個(gè)排序過程為進(jìn)行n-1趟插入，即：先將序列中的第一個(gè)記錄看成是一個(gè)有序的子序列，然后從第2個(gè)記錄起逐個(gè)進(jìn)行插入，直至整個(gè)序列變成按關(guān)鍵字非遞減有序序列為止。

2.快速排序：基本思想是，通過一趟排序?qū)⒋庞涗浄指畛瑟?dú)立的兩部分，其中一部分記錄的關(guān)鍵字均比另一部分記錄的關(guān)鍵字小，則可分別對(duì)這兩部分記錄繼續(xù)進(jìn)行排序，以達(dá)到整個(gè)序列有序。

假設(shè)待排序的序列為{L.r[s]，L.r[s+1],?L.r[t]},首先任意選取一個(gè)記錄(通常可選第一個(gè)記錄L.r[s])作為樞軸（或支點(diǎn)）（pivot），然后按下述原則重新排列其余記錄：將所有關(guān)鍵字較它小的記錄都安置在它的位置之前，將所有關(guān)鍵字較大的記錄都安置在它的位置之后。由此可以該“樞軸”記錄最后所羅的位置i作為界線，將序列{L.r[s]，?，L.r[t]}分割成兩個(gè)子序列{L.r[i+1],L.[i+2],?,L.r[t]}。這個(gè)過程稱為一趟快速排序，或一次劃分。

一趟快速排序的具體做法是：附設(shè)兩個(gè)指針low和high，他們的初值分別為low和high，設(shè)樞軸記錄的關(guān)鍵字為pivotkey，則首先從high所指位置起向前搜索找到第一個(gè)關(guān)鍵字小于pivotkey的記錄和樞軸記錄互相交換，然后從low所指位置起向后搜索，找到第一個(gè)關(guān)鍵字大于pivotkey的記錄和樞軸記錄互相 1 交換，重復(fù)這兩不直至low=high為止。

具體實(shí)現(xiàn)上述算法是，每交換一對(duì)記錄需進(jìn)行3次記錄移動(dòng)（賦值）的操作。而實(shí)際上，在排列過程中對(duì)樞軸記錄的賦值是多余的，因?yàn)橹挥性谝惶伺判蚪Y(jié)束時(shí)，即low=high的位置才是樞軸記錄的最后位置。由此可以先將樞軸記錄暫存在r[0]的位置上，排序過程中只作r[low]或r[high]的單向移動(dòng)，直至一趟排序結(jié)束后再將樞軸記錄移至正確位置上。

整個(gè)快速排序的過程可遞歸進(jìn)行。若待排序列中只有一個(gè)記錄，顯然已有序，否則進(jìn)行一趟快速排序后再分別對(duì)分割所得的兩個(gè)子序列進(jìn)行快速排序。

3.簡單選擇排序：其操作為，通過n-i次關(guān)鍵字間的比較，從n-i+1個(gè)記錄中選出關(guān)鍵字最小的記錄，并和第i（1≤i≤n）個(gè)記錄交換之。

顯然，對(duì)L.r[1?n]中的記錄進(jìn)行簡單選擇排序的算法為：令i從1至n-1，進(jìn)行n-1趟選擇操作。可以看出，簡單選擇排序過程中，所需進(jìn)行記錄移動(dòng)的操作次數(shù)較少，其最小值為“0”，最大值為3（n-1）。然后，無論記錄的初始排列如何，所需進(jìn)行的關(guān)鍵字之間的比較次數(shù)相同，均為n(n-1)/2。

程序清單： 1．插入排序： #include structsqlist {int key[11];int length;} insertsort(structsqlist *l){ inti,j;for(i=2;i<=l->length;i++)if(l->key[i]key[i-1]){l->key[0]=l->key[i];l->key[i]=l->key[i-1];for(j=i-2;l->key[0]key[j];j--)l->key[j+1]=l->key[j];l->key[j+1]=l->key[0];} } main(){ inti,j,k;structsqlistnum;num.length=10;for(i=1;i<=num.length;i++)scanf(“%d”,&(num.key[i]));insertsort(&num);printf（“charu：”）；

for(i=1;i<=num.length;i++)printf(“%d ”,num.key[i]);} 測試用例：

輸入：23 34 12 98 56 45 67 8 9 37 輸出：charu：8 9 12 23 34 37 45 56 67 98 2快速排序： #include structsqlist { int key[11];int length;};int partition(structsqlist *l,intlow,int high){ intpivotkey;l->key[0]=l->key[low];pivotkey=l->key[low];while(lowkey[high]>=pivotkey)high--;l->key[low]=l->key[high];while(lowkey[low]<=pivotkey)low++;l->key[high]=l->key[low];} l->key[low]=l->key[0];return low;} voidqsort(structsqlist *l,intlow,int high){intpivotloc;if(lowlength);} main(){ inti,j;structsqlistnum;num.length=10;for(i=1;i<=num.length;i++)scanf(“%d”,&(num.key[i]));quicksort(&num);printf（“kuaisu：”）；

for(i=1;i<=num.length;i++)printf(“%d ”,num.key[i]);} 測試用例：

輸入：23 34 12 98 56 45 67 8 9 37 輸出：charu：8 9 12 23 34 37 45 56 67 98 3選擇排序： #include structsqlist {int key[11];int length;};

intselectminkey(structsqlist *l,int a){ inti,j=a;for(i=a;i<=l->length;i++)if(l->key[i]key[j])j=i;return j;} voidselectsort(structsqlist *l){inti,j,k;for(i=1;ilength;i++){j=selectminkey(l,i);if(i!=j){k=l->key[i];l->key[i]=l->key[j];l->key[j]=k;} } } main(){ inti,j;structsqlistnum;num.length=10;for(i=1;i<=num.length;i++)scanf(“%d”,&(num.key[i]));selectsort(&num);printf（“xuanze：”）；

for(i=1;i<=num.length;i++)printf(“%d ”,num.key[i]);} 測試用例：

輸入：23 34 12 98 56 45 67 8 9 37 輸出：charu：8 9 12 23 34 37 45 56 67 98

編程感想： 本次編程總共使用了三種排序方法，而這三種編程方法放在一起進(jìn)行編寫時(shí)，很容易就讓我們對(duì)齊難易程度有了更深刻的了解。

首先，三種排序中，我們都像查表那樣，設(shè)置了哨兵，而哨兵的使用可以減少對(duì)整個(gè)表的驗(yàn)空操作，使程序更加節(jié)省空間。

其次，對(duì)于插入排序，每次都要對(duì)一段序列進(jìn)行檢索，每排一次所要檢索的序列長度減一，其時(shí)間發(fā)雜度為O（n^2）。

接著，對(duì)于快速排序，這個(gè)程序是比較復(fù)雜的，總共是3個(gè)函數(shù)，并且使用了遞歸的方法，這是但是，這種算法卻是最優(yōu)越的，平均性能也是最好的，我在編這個(gè)程序時(shí)，對(duì)其排序的思想有了進(jìn)一步的了解，并努力拿他與冒泡排序進(jìn)行比較，看出了些許其優(yōu)越性。

還有，就是選擇排序，簡單選擇排序思路簡單，易于進(jìn)行，但其時(shí)間發(fā)雜度與簡單插入排序方法一樣，都是O（n^2），性能不如快速排序。

最后，本次試驗(yàn)是數(shù)據(jù)結(jié)構(gòu)課的最后一次實(shí)驗(yàn)，經(jīng)過數(shù)據(jù)結(jié)構(gòu)試驗(yàn)課的鍛煉，使我對(duì)數(shù)據(jù)結(jié)構(gòu)有了更深刻的理解，對(duì)我對(duì)其知識(shí)起到了重要的影響，增加了我編程的實(shí)踐活動(dòng)，為我將來進(jìn)一步學(xué)習(xí)打下了基礎(chǔ)。

第四篇：數(shù)據(jù)結(jié)構(gòu)課程設(shè)計(jì)-查找排序

查找及排序算法實(shí)現(xiàn)

一、實(shí)驗(yàn)?zāi)康?/p>

1、熟練掌握二叉排序樹查找算法及C語言描述。

2、熟練掌握折半查找算法及C語言描述。

3、熟練掌握簡單選擇排序算法及C語言描述。

4、熟練掌握簡單插入排序算法及C語言描述。

5、熟練掌握冒泡（起泡）排序算法及C語言描述。

6、了解各種查找及排序算法的優(yōu)缺點(diǎn)、實(shí)用性及應(yīng)用。

7、將理論與實(shí)際相結(jié)合，切實(shí)提高自己的邏輯能力和動(dòng)手能力。

二、設(shè)計(jì)內(nèi)容

1.折半查找算法

折半查找算法的思路：

初始狀態(tài)：假設(shè)表長為n，low、high和mid分別指向待查元素所在區(qū)間的下界、上界和中點(diǎn),key為給定值，初始時(shí)，令low=0,high=n-1,mid=(low+high)/2 讓key與mid指向的記錄比較

若key==r[mid].key，查找成功,算法結(jié)束；若keyr[mid].key，則low=mid+1；重復(fù)上述操作，直至low>high時(shí)，查找失敗。2.起泡排序算法

起泡排序的思路：

首先將第一個(gè)記錄的關(guān)鍵字和第二個(gè)記錄的關(guān)鍵字進(jìn)行比較，若為逆序（即L.r[1].key>L.r[2].key），則將兩個(gè)記錄交換之，然后比較【第二個(gè)記錄和第三個(gè)記錄】的關(guān)鍵字。以此類推，直至第n-1個(gè)記錄和第n個(gè)記錄的關(guān)鍵字進(jìn)行過比較為止。上述過程稱做第一趟起泡排序，其結(jié)果使得關(guān)鍵字最大的記錄被安置到最后一個(gè)記錄的位置上，然后進(jìn)行第二趟起泡排序，對(duì)前n-1個(gè)記錄進(jìn)行同樣操作，其結(jié)果是使關(guān)鍵字次大的記錄被安置到第n-1個(gè)記錄的位置上。一般地，第i躺起泡排序是從L.r[1]到L.r[n-i+1]以此比較相鄰兩個(gè)記錄的關(guān)鍵字，并在“逆序”時(shí)交換相鄰記錄，其結(jié)果是這n-i+1個(gè)記錄中關(guān)鍵字最大的記錄被交換到第n-i+1的位置上。整個(gè)排序過程需進(jìn)行k(1<=k

首先以一個(gè)元素為基準(zhǔn)，從一個(gè)方向開始掃描，比如從左至右掃描，以a[0]為基準(zhǔn)，接下來從a[0]...a[9] 中找出最小的元素，將其與a[0]交換，然后將基準(zhǔn)位置右

移一位，重復(fù)上面的動(dòng)作，比如，以a[1]為基準(zhǔn)，找出a[1]至a[9]中最小的，將其與a[1]交換，一直進(jìn)行到基準(zhǔn)位置移到數(shù)組最后一個(gè)元素時(shí)排序結(jié)束（此時(shí)基準(zhǔn)左邊所有元素均遞增有序，而基準(zhǔn)為最后一個(gè)元素，故完成排序）。4.直接插入排序算法

直接插入排序是一種最簡單的排序方法，它的基本操作是將一個(gè)記錄插入到已排好序的有序表中，從而得到一個(gè)新的，記錄數(shù)增1的有序表。

一般情況下，第i趟直接插入排序的操作為：在含有i-1個(gè)記錄的有序子序列r[1...i-1]中插入一個(gè)記錄r[i]后，變成含有i個(gè)記錄的有序子序列r[1....i].在自i-1起往前搜索的過程中，可以同時(shí)后移記錄。

整個(gè)排序過程為進(jìn)行n-1躺插入，即：先將序列中的第一個(gè)記錄看成是一個(gè)有序的子序列，然后從第二個(gè)記錄起逐個(gè)進(jìn)行插入，直至整個(gè)序列變成按關(guān)鍵字非遞減有序序列為止

三、程序源代碼

1.二叉排序樹的創(chuàng)建、遍歷和查找刪除算法

#include #include typedef int KeyType;typedef struct node { KeyType data;struct node *lchild,*rchild;}LNode,*Tree;

void Insert(Tree &T,KeyType key){

if(!T){ T=new LNode;T->data=key;T->lchild=T->rchild=NULL;} else

} {

} if(keydata)Insert(T->lchild,key);else Insert(T->rchild,key);void CreatTree(Tree &T)//二叉排序樹的創(chuàng)建 {

} int num;char c;while(scanf(“%d”,&num)){

} Insert(T,num);c=getchar();if(c=='n')return;void In_Order(Tree T)//中序遍歷 {

if(T){ In_Order(T->lchild);printf(“%d ”,T->data);} In_Order(T->rchild);} void Delete(Tree &p){

Tree q,s;if(!p->rchild){

q = p;p=p->lchild;free(q);} else if(!p->lchild){

} q = p;p=p->rchild;free(q);

else {

} q = p;s = p->lchild;while(s->rchild){

} q = s;s = s->rchild;p->data = s->data;if(q!=p)q->rchild = s->lchild;else q->lchild = s->lchild;free(s);} void DelNode(Tree &T,KeyType key){

} if(!T){ printf(“n該結(jié)點(diǎn)不存在n”);return;} else {

} if(key == T->data)Delete(T);else if(key < T->data)DelNode(T->lchild, key);else DelNode(T->rchild,key);Tree Search(Tree T,KeyType key)//二叉排序樹查找

{

if(!T){

} printf(“該結(jié)點(diǎn)不存在”);return 0;else if(key == T->data)return T;else if(key < T->data)

return(Search(T->lchild, key));else return(Search(T->rchild, key));} int main()//主函數(shù) { Tree T,p;T=NULL;KeyType x;

printf(“請(qǐng)輸入二叉樹各結(jié)點(diǎn)：n”);

CreatTree(T);

printf(“中序遍歷為：n”);In_Order(T);printf(“n請(qǐng)輸入要查找和刪除的結(jié)點(diǎn)：n”);scanf(“%d”,&x);p=Search(T, x);if(p){

} DelNode(T, x);printf(“中序遍歷為：n”);In_Order(T);

}

2、冒泡排序和折半查找算法

#include #include #define M 10 //冒泡排序

int BubbleSort(int c[]){

int i,t,j;for(i=0;i<9;i++){

} for(j=0;j<9-i;j++){

} if(c[j]>c[j+1]){

} t=c[j];c[j]=c[j+1];c[j+1]=t;

printf(“n您所輸入的數(shù)字的升序排列是:nn”);for(i=0;i<10;i++){ printf(“%d”,c[i]);printf(“ ”);} return 1;} //折半查找

int BinarySearch(int b[]){

} int t,mid;int i=0;int j=9;printf(“nn請(qǐng)輸入您要查找的數(shù)字：”);scanf(“%d”, &t);while(i<=j){ mid=i+(j-i)/2;

} return 1;if(t==b[mid]){ printf(“n您要查找的數(shù)字的排列位置是：%dn”,mid+1);break;} else if(t

int main(int argc,char *argv[]){

int a[10];printf(“請(qǐng)您輸入數(shù)據(jù):nn”);for(int i=0;i<10;i++){ scanf(“%d”,&a[i]);

} } BubbleSort(a);BinarySearch(a);return 0;

3、簡單選擇排序和簡單插入排序算法

#include int SelectionSort(int*a,int n){

int i,j,min,p,key,k;

for(i=0;i

{

key=0;

min=a[i];

} for(j=i;j

if(a[j]

if(key==1){a[p]=a[i];

a[i]=min;}

for(k=0;k

printf(“%d ”,a[k]);printf(“n”);

return 1;} int InserSort(int*a,int n){

int i,j,k;for(i=2;i<=n;i++){

a[0]=a[i];for(j=1;j

{

if(a[j]>a[i]){for(k=i;k>j;k--)

a[k]=a[k-1];

a[k]=a[0];

}

}

break;} } for(j=1;j<=n;j++){ } printf(“%d ”,a[j]);printf(“n”);return 1;int main(){

int a[80],i,n,b;printf(“請(qǐng)輸入關(guān)鍵字的個(gè)數(shù)：”);scanf(“%d”,&n);printf(“排序類型：n”);printf(“1.選擇排序n”);printf(“2.插入排序n”);printf(“請(qǐng)選擇：”);scanf(“%d”,&b);switch(b){

case 1:

printf(“請(qǐng)輸入關(guān)鍵字：n”);for(i=0;i

SelectionSort(a,n);

return 1;

break;

case 2:

printf(“請(qǐng)輸入關(guān)鍵字：n”);

for(i=1;i<=n;i++){

scanf(“%d”,&a[i]);} printf(“插入排序的流程以及結(jié)果：n”);

InserSort(a,n);return 1;

} break;}while(a!=0);

四、實(shí)驗(yàn)運(yùn)行結(jié)果

1.二叉排序樹的創(chuàng)建、遍歷和查找刪除算法

2、冒泡排序和折半查找算法

3、簡單選擇排序和簡單插入排序算法

七、心得體會(huì)

通過本次的數(shù)據(jù)結(jié)構(gòu)課程設(shè)計(jì)報(bào)告，掌握了查找和排序的幾種基本排序算法，了解了他們各自的特點(diǎn)和優(yōu)缺點(diǎn)，完成了對(duì)于他們C語言的描述和實(shí)際應(yīng)用，對(duì)他們有了一個(gè)更加具體、深刻的認(rèn)識(shí)，同時(shí)也鍛煉了我們的邏輯思維能力和動(dòng)手實(shí)踐能力，使我們受益匪淺，給我們今后的計(jì)算機(jī)專業(yè)課程學(xué)習(xí)帶來很大的幫助。

第五篇：數(shù)據(jù)結(jié)構(gòu)實(shí)驗(yàn)報(bào)告-查找算法

《數(shù)據(jù)結(jié)構(gòu)》 第八次實(shí)驗(yàn)報(bào)告

學(xué)生姓名 學(xué)生班級(jí) 學(xué)生學(xué)號(hào) 指導(dǎo)老師

重慶郵電大學(xué)計(jì)算機(jī)學(xué)院 計(jì)算機(jī)專業(yè)實(shí)驗(yàn)中心

一、實(shí)驗(yàn)內(nèi)容

1)有序表的二分查找

?建立有序表，然后進(jìn)行二分查找 2)二叉排序樹的查找 ?建立二叉排序樹，然后查找

二、需求分析

二分查找的基本思想是將n個(gè)元素分成大致相等的兩部分，取a[n/2]與x做比較，如果x=a[n/2],則找到x,算法中止；如果xa[n/2],則只要在數(shù)組a的右半部搜索x.時(shí)間復(fù)雜度無非就是while循環(huán)的次數(shù)！總共有n個(gè)元素，漸漸跟下去就是n,n/2,n/4,....n/2^k（接下來操作元素的剩余個(gè)數(shù)），其中k就是循環(huán)的次數(shù) 由于你n/2^k取整后>=1 即令n/2^k=1 可得k=log2n,（是以2為底，n的對(duì)數(shù)）所以時(shí)間復(fù)雜度可以表示O()=O(logn)下面提供一段二分查找實(shí)現(xiàn)的偽代碼: BinarySearch(max,min,des)mid-<(max+min)/2 while(min<=max)mid=(min+max)/2 if mid=des then return mid elseif mid >des then max=mid-1 else min=mid+1 return max 折半查找法也稱為二分查找法，它充分利用了元素間的次序關(guān)系，采用分治策略，可在最壞的情況下用O(log n)完成搜索任務(wù)。它的基本思想是，將n個(gè)元素分成個(gè)數(shù)大致相同的兩半，取a[n/2]與欲查找的x作比較，如果x=a[n/2]則找到x，算法終止。如 果xa[n/2]，則我們只要在數(shù)組a的右 半部繼續(xù)搜索x。

三、概要設(shè)計(jì)

1、順序查找，在順序表R[0..n-1]中查找關(guān)鍵字為k的記錄，成功時(shí)返回找到的記錄位置，失敗時(shí)返回-1，具體的算法如下所示：

int SeqSearch(SeqList R,int n,KeyType k){

} int i=0;while(i

} if(i>=n){ } printf(“%d”,R[i].key);return i;return-1;else printf(“%d”,R[i].key);i++;

2、二分查找，在有序表R[0..n-1]中進(jìn)行二分查找，成功時(shí)返回記錄的位置，失敗時(shí)返回-1，具體的算法如下：

int BinSearch(SeqList R,int n,KeyType k){

} return-1;} int low=0,high=n-1,mid,count=0;while(low<=high){ mid=(low+high)/2;printf(“第%d次查找：在[ %d ,%d]中找到元素R[%d]:%dn ”,++count,low,high,mid,R[mid].key);if(R[mid].key==k)

return mid;high=mid-1;low=mid+1;if(R[mid].key>k)else

四、詳細(xì)設(shè)計(jì)

源代碼：

#include #include

static int a[1024],count=0;

void Find1(int low,int high,int x){ int mid;if(low<=high){ mid=(low+high)/2;count++;if(a[mid]>x)Find1(low,mid-1,x);else if(a[mid]

void Find2(int low,int high,int x){ int mid;if(low<=high){ mid=(low+high)/2;count++;if(a[mid]x)Find2(mid+1,high,x);else printf(“n查é找ò到?元a素?位?置?為a%d，?查é找ò次?數(shù)簓為a%d。￡”,mid,count);} else printf(“n查é找ò失骸?敗悒?，?查é找ò次?數(shù)簓為a%d。￡”,count);} int main(){ int n,x;printf(“請(qǐng)?輸?入?元a素?個(gè)?數(shù)簓:”);scanf(“%d”,&n);printf(“n請(qǐng)?按恪?從洙?高?到?低臺(tái)?或ò從洙?低臺(tái)?到?高?順3序ò輸?入?各÷元a素?(以?空?格?隔?開a):nn”);for(int i=1;i<=n;i++)scanf(“%d”,&a[i]);printf(“n請(qǐng)?輸?入?要癮查é找ò的?元a素?：阰”);scanf(“%d”,&x);if(a[1]<=a[n])Find1(1,n,x);else Find2(1,n,x);printf(“nn”);system(“pause”);}

五、心得體會(huì)

通過這次在實(shí)現(xiàn)順序和二分查找算法的過程中，讓我對(duì)順序和二分查找算法有了更多的了解。查找根據(jù)給定的某個(gè)值，在查找表中確定一個(gè)其關(guān)鍵字等于給定值的數(shù)據(jù)元素或（記錄）的操作，應(yīng)用十分廣泛。順序查找是一種最簡單的查找方法。它的基本思路是：從表的一端開始,順序掃描線性表,依次將掃描到的關(guān)鍵字和給定值k相比較,若當(dāng)前掃描到的關(guān)鍵字與k相等,則查找成功；若掃描結(jié)束后,仍未找到關(guān)鍵字等于k的記錄,則查找失敗。二分查找也稱為折半查找要求線性表中的結(jié)點(diǎn)必須己按關(guān)鍵字值的遞增或遞減順序排列。它首先用要查找的關(guān)鍵字k與中間位置的結(jié)點(diǎn)的關(guān)鍵字相比較,這個(gè)中間結(jié)點(diǎn)把線性表分成了兩個(gè)子表,若比較結(jié)果相等則查找完成;若不相等,再根據(jù)k與該中間結(jié)點(diǎn)關(guān)鍵字的比較大小確定下一步查找哪個(gè)子表,這樣遞歸進(jìn)行下去,直到找到滿足條件的結(jié)點(diǎn)或者該線性表中沒有這樣的結(jié)點(diǎn)。在學(xué)習(xí)過程中，善于發(fā)現(xiàn)，會(huì)找到更多的捷徑。

六、附錄 運(yùn)行結(jié)果截圖。