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

電 子 科 技 大 學(xué)

實

驗

報

告

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

指導(dǎo)教師：劉嶠 實驗地點：信軟機房306

實驗時間：2014/6/20

一、實驗室名稱：軟件實驗室

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

三、實驗學(xué)時：4

四、實驗原理：

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

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

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

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

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

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

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

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

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

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

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

B)如果R[mid].key

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

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

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

五、實驗?zāi)康模?/p>

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

六、實驗內(nèi)容：

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

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

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

七、實驗器材（設(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機一臺，裝有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;}

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

2.嘗試手動輸入模式：

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

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

實驗成功。

十、實驗結(jié)論：

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

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

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

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

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

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

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

實驗題9.1 設(shè)計一個程序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ù)

//定義表中最多記錄個數(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

截圖如下：

實驗題9.2 設(shè)計一個程序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 {

//定義表中最多記錄個數(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);

截圖如下：

實驗題9.3 設(shè)計一個程序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ù)類型

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

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

InfoType data;

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

KeyType key;int link;

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

//順序表類型

} 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為每塊的記錄個數(shù)

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

//在索引表中進行二分查找,找到的位置存放在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++;

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

} if(low

//在索引表中查找成功后,再在線性表中進行順序查找

{

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累計在順序表對應(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ù)據(jù)結(jié)構(gòu)》實驗報告 排序

實驗題目：

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

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

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

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

2.快速排序：基本思想是，通過一趟排序?qū)⒋庞涗浄指畛瑟毩⒌膬刹糠郑渲幸徊糠钟涗浀年P(guān)鍵字均比另一部分記錄的關(guān)鍵字小，則可分別對這兩部分記錄繼續(xù)進行排序，以達到整個序列有序。

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

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

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

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

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

顯然，對L.r[1?n]中的記錄進行簡單選擇排序的算法為：令i從1至n-1，進行n-1趟選擇操作?？梢钥闯?，簡單選擇排序過程中，所需進行記錄移動的操作次數(shù)較少，其最小值為“0”，最大值為3（n-1）。然后，無論記錄的初始排列如何，所需進行的關(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

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

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

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

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

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

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

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

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

一、實驗?zāi)康?/p>

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

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

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

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

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

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

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

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

1.折半查找算法

折半查找算法的思路：

初始狀態(tài)：假設(shè)表長為n，low、high和mid分別指向待查元素所在區(qū)間的下界、上界和中點,key為給定值，初始時，令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時，查找失敗。2.起泡排序算法

起泡排序的思路：

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

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

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

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

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

整個排序過程為進行n-1躺插入，即：先將序列中的第一個記錄看成是一個有序的子序列，然后從第二個記錄起逐個進行插入，直至整個序列變成按關(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é)點不存在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é)點不存在”);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(“請輸入二叉樹各結(jié)點：n”);

CreatTree(T);

printf(“中序遍歷為：n”);In_Order(T);printf(“n請輸入要查找和刪除的結(jié)點：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請輸入您要查找的數(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(“請您輸入數(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(“請輸入關(guān)鍵字的個數(shù)：”);scanf(“%d”,&n);printf(“排序類型：n”);printf(“1.選擇排序n”);printf(“2.插入排序n”);printf(“請選擇：”);scanf(“%d”,&b);switch(b){

case 1:

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

SelectionSort(a,n);

return 1;

break;

case 2:

printf(“請輸入關(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);

四、實驗運行結(jié)果

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

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

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

七、心得體會

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

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

《數(shù)據(jù)結(jié)構(gòu)》 第八次實驗報告

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

重慶郵電大學(xué)計算機學(xué)院 計算機專業(yè)實驗中心

一、實驗內(nèi)容

1)有序表的二分查找

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

二、需求分析

二分查找的基本思想是將n個元素分成大致相等的兩部分，取a[n/2]與x做比較，如果x=a[n/2],則找到x,算法中止；如果xa[n/2],則只要在數(shù)組a的右半部搜索x.時間復(fù)雜度無非就是while循環(huán)的次數(shù)！總共有n個元素，漸漸跟下去就是n,n/2,n/4,....n/2^k（接下來操作元素的剩余個數(shù)），其中k就是循環(huán)的次數(shù) 由于你n/2^k取整后>=1 即令n/2^k=1 可得k=log2n,（是以2為底，n的對數(shù)）所以時間復(fù)雜度可以表示O()=O(logn)下面提供一段二分查找實現(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個元素分成個數(shù)大致相同的兩半，取a[n/2]與欲查找的x作比較，如果x=a[n/2]則找到x，算法終止。如 果xa[n/2]，則我們只要在數(shù)組a的右 半部繼續(xù)搜索x。

三、概要設(shè)計

1、順序查找，在順序表R[0..n-1]中查找關(guān)鍵字為k的記錄，成功時返回找到的記錄位置，失敗時返回-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]中進行二分查找，成功時返回記錄的位置，失敗時返回-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

四、詳細設(shè)計

源代碼：

#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(“請?輸?入?元a素?個?數(shù)簓:”);scanf(“%d”,&n);printf(“n請?按恪?從洙?高?到?低臺?或ò從洙?低臺?到?高?順3序ò輸?入?各÷元a素?(以?空?格?隔?開a):nn”);for(int i=1;i<=n;i++)scanf(“%d”,&a[i]);printf(“n請?輸?入?要癮查é找ò的?元a素?：阰”);scanf(“%d”,&x);if(a[1]<=a[n])Find1(1,n,x);else Find2(1,n,x);printf(“nn”);system(“pause”);}

五、心得體會

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

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