实验13-14-15

实验十三查找

一、实验目的

1、掌握查找表、动态查找表、静态查找表和平均查找长度的概念。

2、掌握线性表中顺序查找和折半查找的方法。

3、学会哈希函数的构造方法，处理冲突的机制以及哈希表的查找。

二、实验预习

说明以下概念

1、顺序查找：

2、折半查找：

3、哈希函数：

4、冲突及处理：

三、实验内容和要求

1. 静态查找表技术

编写程序13-1.C来实现顺序查找、折半查找。已知两个查找表如下：

查找表1 ： { 8 ，15 ，19 ，26 ，33 ，41 ，47 ，52 ，64 ，90 }

查找表2 ： {12 ，76 ，29 ，15 ，62 ，35 ，33 ，89 ，48 ，20 }

⑴编写实现顺序查找算法的函数Search_Seq(SqList *)。

⑵编写实现折半查找算法的函数Search_Binary(SqList *)。

⑶编写主函数main，分别对上述两个查找表选择一个合适的算法，要求：

在查找表1中查找41，比较次数是多少？

在查找表2中查找35，比较次数是多少？

⑷请画出上述折半查找的判定树

2、哈希表的构造与查找，编写程序13-2.C如下，并调试运行。

/* 采用开放地址法构造哈希表*/

#include

#include

#define MAXSIZE 25

#define P 13

#define OK 1

#define ERROR 0

#define DUPLICATE -1

#define TRUE 1

#define FALSE 0

typedef struct{ /*哈希表元素结构*/

int key; /*关键字值*/

int flag; /*是否存放元素*/

}ElemType;

typedef struct {

ElemType data[MAXSIZE];

int count; /*元素个数*/

int sizeindex; /*当前哈希表容量*/

}HashTable;

int d1[15]={0,1,2,3,4,5,6,7,8,9,10,11,12,13,14}; /*线性探测序列*/

int d2[15]={0,1,-1,2*2,-2*2,3*3,-3*3,4*4,-4*4,5*5,-5*5,6*6,-6*6,7*7,-7*7}; /*二次探测序列*/ void dataset(int ds[],int *len);

int InsertHash(HashTable *H,int e,int d[]);

int CreateHash(HashTable *H,int ds[],int len,int d[]);

int SearchHash(HashTable *H, int e,int d[]);

void menu();

/*输入查找表*/

void dataset(int ds[],int *len){

int n,m;

n=0;

printf("\n查找表输入：");

while(scanf("%d",&m)==1){ /*以输入一个非整数作为结束*/

ds[n]=m;

n++;

}

*len=n;

}

/*计算哈希地址，插入哈希表*/

int InsertHash(HashTable *H,int e,int d[]){

int k,i=1;

k=e%P;

while(H->data[k].flag==TRUE||k<0){

k=(e%P+d[i])%MAXSIZE;i++;

if(i>=15)

return ERROR;

}

H->data[k].key=e;

H->data[k].flag=TRUE;

H->count++;

return OK;

}

/*构造哈希表*/

int CreateHash(HashTable *H,int ds[],int len,int d[]){ int i;

for(i=0;i

if(SearchHash(H,ds[i],d)!=-1)

return DUPLICA TE;

InsertHash(H,ds[i],d);

if(H->count>=MAXSIZE)

return ERROR;

}

return OK;

}

/*初始化哈希表*/

void InitHash(HashTable *H){

int i;

for(i=0;i

H->data[i].key=0;

H->data[i].flag=FALSE;

}

}

/*在哈希表中查找*/

int SearchHash(HashTable *H, int e,int d[]){

int k,i=1;

k=e%P;

while(H->data[k].key!=e){

k=(e%P+d[i])%MAXSIZE;i++;

if(i>=15)

return -1;

}

return k;

}

/*演示菜单*/

void menu(){

int choice;int *p;

HashTable h;

h.count=0;h.sizeindex=MAXSIZE;

int a[MAXSIZE]={0};

int i,n,e;

dataset(a,&n); /*建立查找表*/

getchar();

printf("\n");

do{

printf("\n----哈希查找演示----\n");

printf("\n1.线性探测构造哈希表\n");

printf("\n2.二分探测构造哈希表\n");

printf("\n3.退出\n");

printf("\n输入选择：");

scanf("%d",&choice);

if(choice==1)

p=d1;

else if(choice==2)

p=d2;

else

return;

InitHash(&h); /*初始化哈希表*/

if(!(i=CreateHash(&h,a,n,p))) /*构造哈希表*/

printf("\n哈希表构造失败！\n");

else if(i==DUPLICA TE)

printf("\n哈希表具有重复关键字！\n");

else{

printf("\n哈希表：\n");

for(i=0;i

printf("%3d",h.data[i].key);

printf("\n\n哈希查找\n输入要查找的key值：");

getchar();

scanf("%d",&e);

if((i=SearchHash(&h,e,p))==-1)

printf("\n%d未找到\n",e);

else

printf("\n%d在哈希表中下标为%d\n",e,i);

}

getchar();

}while(1);

}

int main(){

menu();

return 0;

}

输入查找表为：19 14 23 1 68 20 84 27 55 11 10 79（注意以输入一个非整数结束）。运行结果：

1)线性探测散列：

哈希表形态：

84在哈希表中的位置:

2）二次探测散列：

哈希表形态：

84在哈希表中的位置：

思考回答：哈希表创建过程和哈希查找过程有何关系？

3、拓展实验

编写程序13-3.C，实现平衡二叉树处理。

在插入一个新结点到二叉树后，可能导致该树不平衡，注意从4种平衡处理方法中选择正确的方法进行处理。

平衡二叉树结点结构定义如下：

typedef struct BSTnode

{ int data;

int bf; //平衡因子

struct BSTnode *lc,*rc;

}BSTnode;

四、实验小结

实验十四排序（1）

一、实验目的

1、掌握插入排序、交换排序的典型算法；

2、分析比较上述排序算法的效率；

3、理解上述各类典型排序算法的稳定性。

二、实验预习

说明以下概念

1、直接插入排序：

2、希尔排序：

3、快速排序：

三、实验内容和要求

1、直接插入排序

编写程序14-1.C，实现直接插入排序，部分代码如下：

#include

#include

#define INIT_SIZE 20

int list[INIT_SIZE];

void insertSort(int list[], int n);

void createList(int list[], int *n);

void printList(int list[], int n);

/*直接插入排序*/

void insertSort(int list[], int n){

int i=1,j,count = 1;

printf("对序列进行直接插入排序：\n");

printf("初始序列为：");

printList(list,n);

for(i=2;i<= ;i++){

list[0]=list[i];

j=i-1;

while(j>0&& ){

list[j+1]=list[j];

;

}

list[j+1]=list[0];

printf("第%d次排序结果：", count++);

printList(list, n);

}

}

/*生成待排序序列，list[0]用作排序时的临时存储单元*/

void createList(int list[], int *n)

{

int i = 1,a;

printf("请输入待排序序列(长度小于50,以输入一个字符结束):\n");

while(scanf("%d",&a)==1)

{

list[i] = a;

;

}

*n= ;

getchar();

}

void printList(int list[], int n)

{

int i = 1;

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

{

printf(" %d ", list[i]);

if(i % 10 ==0 && i != 0)

printf("\n");

}

printf("\n");

}

⑴在横线处填写正确的代码。

⑵编写主函数main，调用相应的函数实现对待排序数据进行排序并输出每趟排序结果。

⑶键盘输入待排序序列：18,17, 60,40,7,32,73,65,85（以输入一个字符作为结束）

⑷直接插入排序是稳定排序吗？试分析其渐近时间复杂度。

运行结果：

2、希尔排序

编写程序14-2.C，实现希尔排序，部分代码如下：

#include

#define INIT_SIZE 20

int list[INIT_SIZE ];

void Shellinsert(int list[],int dk,int n);

void ShellSort(int list[],int dlta[],int t,int n)

{

int i,k;

for (k=0;k< ; ++k)

{

printf("\n第%d趟希尔排序，增量dlta=%d，排序结果为：\n",k+1,dlta[k]);

Shellinsert( list, , );

for (i=1;i<= ;i++) //输出每趟排序结果

printf("%d ",L->list[i]);

}

}

void Shellinsert(int list[],int dk,int n) //list[0]作为临时的存储空间使用

{

int i,j;

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

if(list[i]< )

{

list[0] =list[i] ;

for(j=i-dk;j>0&&list[0]

list[ ] = list[j] ;

list[j+dk] = ;

}

}

⑴在横线处填写正确的代码。

⑵最后一趟的希尔排序的增量必须为多少？为什么？

⑶编写主函数main，实现希尔排序并输出每趟排序的增量和排序结果。

⑷键盘输入待排序的原始数据为：47,26,32,6,68,14,93,85,52

dlta增量设置为：dlta[3]={5,3,1}

⑸希尔排序是稳定的排序么？

运行结果：

3、快速排序

编写程序14-3.C，实现快速排序递归算法，部分代码如下：

#include

#define INIT_SIZE 20

int list [INIT_SIZE 20];

void QuickSort(int list[],int n);

void QSort(int list[], int low, int high);

int Partition(int list[],int low,int high);

int times=0; //划分次数

void QuickSort(int list[],int n) // 对具有n个数据元素的list表进行快速排序

{ QSort ( list , 1 , ) ;}

void QSort (int list[] , int low , int high )

{ int pivotloc,i,pivotkey;

if ( low < high )

{ pivotkey=list[low];

printf("\n这是第%d次划分，枢轴值为：%d\n",++times,pivotkey);

// 对low 和high 范围的子表进行分区，确定其分区后枢轴的位置。

pivotloc = Partition ( list , low , high ) ;

//输出划分后的结果

for(i=low;i<=high;i++)

{ if (list[i]== pivotkey)

printf("[%d] ",list[i]);

else

printf("%d ",list[i]);

}

// 对范围从low到枢轴前一位记录的前半区进行快速排序

QSort (list , , pivotloc - 1 ) ;

// 对范围从枢轴后一位的记录到high的后半区进行快速排序

QSort (list , , high ) ;

}

}

int Partition (int list[] , int low , int high )

// 对范围从low 到high 的子表进行分区，分区后的子表以枢轴为界限，前面（后面）

// 的记录均不大于（小于）它。设置两个扫描指针：低位指针low ，高位指针high 分

// 别指向子表的头和尾

{ int pivotkey ;

list [ 0 ] = list[ low ] ; // 复制子表的第一个记录

pivotkey = list[ low ] ; // 将其作为枢轴

// 当两个扫描指针的位置保持low 在high 左边时，说明对整个子表的扫描没有完成；

// 如果low 运动到high 的右边则说明对整个子表的扫描已经完成

while ( )

{

while ( low < high && list[ high ] >= pivotkey )

;

// 高位指针high 先从子表的尾端向前扫描，如果记录大于枢轴的值，则继续扫描，直

// 至发现比枢轴小的记录

list[ low ] =list[ high ] ; // 交换比枢轴小的记录至低位指针所指向的记录

while ( low < high && list[low] <= pivotkey )

;

// 低位指针low从子表的头部向后扫描，如果记录小于枢轴的值，则继续扫描，直至发

// 现比枢轴大的记录

list[ high] = list[ low ] ; // 交换比枢轴大的记录至高位指针所指向的记录}

list[ low ] = list[ 0 ] ; //枢轴记录到位

return low ; // 返回枢轴的位置

}

⑴在横线处填写正确的代码。

⑵请描述QSort递归函数递归出口的含义。

⑶编写主函数main，实现快速排序并输出每趟排序结果。

⑷键盘输入待排序的原始数据为：47,26,32,6,68,14,93,85,52

⑸快速排序是稳定的排序么？

运行结果：

4、拓展实验

传统的起泡排序在每一趟排序后只能使一个关键字最小的记录到达顶端，然后再找第二个最小的记录，试编写程序14-4.C，设计一个函数实现双向起泡：每一趟通过两两比较，产生最大和最小的元素。

四、实验小结

实验十五排序（2）

一、实验目的

1、掌握选择排序、2路归并排序的典型算法；

2、分析比较上述排序算法的效率；

3、理解上述各类典型排序算法的稳定性。

二、实验预习

说明以下概念

1、选择排序：

2、堆排序：

3、2路归并排序：

三、实验内容和要求

1、直接选择排序

编写程序15-1.C，实现直接选择排序，部分代码如下：

#include

#define INIT_SIZE 20

typedef int ElemType; /*定义表元素的类型*/

ElemType list[INIT_SIZE ];

int Select_MinKey (ElemType list[] ,int i ,int n) ;//从位置i到n 的记录中查找关键字最小的值int times=0; //排序趟数

void SelectSort (ElemType list[] ,int n )

{

int i,j,k,temp;

//在表中依次查找关键字为第i 小的记录，将其交换到第i 个位置上

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

{

printf("\n第%d趟排序：\n",++times);

k = Select_MinKey ( list , i ,n) ;

if ( i != ) // 与第i 个记录交换

{

temp=list[ i ] ;

list[ i ] =list[ k ] ;

list[ k] =temp;

}

for ( j =0; j

printf("%d\t", list[ j ] );

}

}

int Select_MinKey(ElemType list[] ,int i,int n )

{

int min,j,k;

min=list[i];

k=i;

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

if (list[j]< )

{

min=list[j];

k= ;

}

return k;

}

⑴在横线处填写正确的代码。

⑵直接选择排序是稳定的排序算法么？请描述该算法的渐进时间复杂度。

⑶编写主函数main，实现从键盘输入N个数据存储到list表中，并进行直接选择排序，

输出每趟的排序过程及最终的排序结果。

输入的数据为：49 38 65 97 13 27 49 6 54 82

⑷如果要进行直接选择排序得到非递减的序列，如何修改程序？请调试运行。

运行结果：

2、堆排序

编写程序15-2.C，实现堆排序，部分代码如下：

#include

#include

#define INIT_SIZE 20

typedef int ElemType; /*定义表元素的类型*/

ElemType list[INIT_SIZE ];

void createList(ElemType list[],int *n);

void printList(ElemType list[],int n);

void heapAdjust(ElemType list[], int u, int v);

void heapSort(ElemType list[],int n);

/*堆排序*/

void heapAdjust(ElemType list[], int u, int v)

{

int i = u, j , temp = list[i];

j = 2 * i;

while (j <= v)

{

if(j < v && list[j] < list[j+1])

j++; /*若右孩子较大，则把j修改为右孩子的下标*/ if(temp

{

list[i] = list[j]; /*将list[j]调到父亲的位置上*/

i = j;

j = 2 * i; /*修改i和j的值，以便继续向下筛选*/

}

else

break; /*筛选完成，终止循环*/

}

list[i] = temp; /*被筛结点的值放入最终位置*/

}

void heapSort(ElemType list[],int n)

{

int i = 0, count = 1;

printf("对序列进行堆排序：\n");

printf("初始序列为：");

printList(list);

for (i = n / 2; i > 0; i--)

heapAdjust(list, i, n); /*建立初始堆*/

printf("建立的初始堆为：");

printList(list,n);

for(i =n ; i > 1; i--)

{/*循环，完成堆排序*/

list[0] =list[1];

list[1] =list[i];

list[i] = list[0]; /*将第一个元素同当前区间内最后一个元素对换*/

heapAdjust(list, 1 , i-1); /*筛选出list[1]结点*/

printf("第%d次排序结果：", count++);

printList(list,n);

}

}

/*生成待排序序列*/

void createList(ElemType list[],int *n)

{

int i = 1,a;

printf("请输入待排序序列(长度小于50,以输入一个字符结束):\n");

while(scanf("%d",&a)==1)

{

list[i] = a;

i++;

}

*n=i-1;

getchar();

}

/*输出排序结果*/

void printList(ElemType list[],int n)

{

int i = 1;

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

{

printf(" %d ", list[i]);

if(i % 10 ==0 && i != 0)

printf("\n");

}

printf("\n");

}

⑴堆排序是稳定的排序算法么？请描述该算法的渐进时间复杂度。

⑵编写主函数main，实现从键盘输入N个数据存储到list表中，并进行堆排序，输出每

趟的排序过程及最终的排序结果。

输入的数据为：43 36 61 99 17 28 43 5 52 86

注意：顺序表list[0]作为临时存储单元。

⑶如果要进行堆排序得到非递增的序列，如何修改程序？请调试运行。

运行结果：

3、2路归并排序

编写程序15-3.C，实现2路归并排序，部分代码如下：

#include

#include

#define INIT_SIZE 20

int list[INIT_SIZE],temp[INIT_SIZE];

int times=0; //归并次数

int slist[MAX] ; /*待排序序列*/

void MSort(int SR[], int TR[],int low ,int high); //将SR归并到TR中

//将temp[low..m]和temp[m+1..high]的有序表归并到slist[low..high]中

void Merge(int temp[],int slist[], int low,int m,int high);

void MSort(int SR[],int TR[], int low ,int high)

{

int m;

int temp[MAX];

if ( ) //递归出口

TR[low]=SR[low];

else

{

m=(low+high)/2;

MSort(SR,temp,low, );

MSort(SR,temp, ,high);

Merge(temp,TR,low,m,high);

}

}

void Merge(int temp[],int slist[], int low,int m,int high)

{

int j,k,i=low;

printf("\n这是第%d次归并，temp[%d,%d],m=%d:\n",++times,low,high,m);

for (k=low;k<=high;k++)

printf("%d ",temp[k]);

for (j=m+1,k=i;i<=m&&j<=high;++k){

if (temp[i]

slist[k]= ;

else slist[k]= ;

}

while (i<=m) slist[k++]=temp[i++];

while (j<=high) slist[k++]=temp[j++];

printf("\n并入slist:");

for (j=low;j<=high;j++)

printf("%d ",slist[j]);

}

⑴在横线处填写正确的代码。

⑵归并排序是稳定的排序算法么？请描述该算法的渐进时间复杂度。

⑶编写主函数main，实现从键盘输入N个数据存储到顺序表中，并进行归并排序，输出每

趟的排序过程及最终的排序结果。

输入的数据为：43 36 61 99 17 28 43 5 52 86

⑷如果要进行归并排序得到非递增的序列，如何修改程序？请调试运行。

运行结果：

1、拓展实验

编写程序15-4.C，函数radixSort实现对2位以下的整数进行基数排序。

四、实验小结

请比较各个排序算法的性能。