算法与数据结构实战实验—— 查找及排序（使用C语言）

实验目的——通过实验达到： ⑴ 理解和掌握用BST树实现动态查找的基本思想和相应的实现算法。 ⑵
理解和掌握HASH存储结构的基本思想、HASH查找的思想、实现； ⑶ 理解典型排序的基本思想，掌握典型排序方法的思想和相应实现算法； ⑷
掌握典型查找、排序算法的算法分析。

题目1：HASH表的建立及查找

生成50个在[200, 1000]之间互不相同的整数保存数组A中，以此数组元素作为关键字，设计实现以下操作的程序：
① 建立对应的HASH表并输出所建立的HASH表：HASH函数为h(k)=key% p（p为20以内的某个素数），采用链地址法解决冲突；
② 在所建立的HASH表中查找指定的关键字（输入要查找的整数），给出操作的结论及相应的操作次数；
③ 在所建立的HASH表中删除指定的关键字（输入要删除的整数），给出操作的结论及相应的操作次数；
④ 主函数通过调用函数实现以上操作。

⑴ 所定义的数据结构:

typedef struct MyHash {
	int key;
	int value;
	struct MyHash* next;
}MyHash;

MyHash hash[17];

⑵ 主要操作算法思想或算法步骤:

#include<stdio.h>
#include<malloc.h>

typedef struct MyHash {
	int key;
	int value;
	struct MyHash* next;
}MyHash;

MyHash hash[17];
//主要操作：
//初始化
void ini(MyHash hash[], int n) {
	for (int i = 0; i < n; i++) {
		hash[i].key = -1;
		hash[i].value = -1;
		hash[i].next = NULL;
	}
}

//添加。返回1为成功，-1为失败（重复）
int addData(int key, int value) {
	int t = key % 17;
	if (hash[t].key == -1) {
		hash[t].key = key;
		hash[t].value = value;
		return 1;
	}
	MyHash* p = (MyHash*)malloc(sizeof(MyHash));
	*p = hash[t];
	if (p->next == NULL) {
		MyHash* h = (MyHash*)malloc(sizeof(MyHash));
		h->key = key;
		h->value = value;
		h->next = NULL;
		hash[t].next = h;
		return 1;
	}
	while (p->next != NULL) {
		if (p->next->key == key) {
			return -1;
		}
		if (p->next->key ==-1) {
			p->next->key = key;
			p->next->value = value;
			return 1;
		}
		p = p->next;
	}

	MyHash* h = malloc(sizeof(MyHash));
	h->key = key;
	h->value = value;
	h->next = NULL;
	p->next = h;
	return 1;
}

//查找
int search(int key) {
	int t = key % 17;
	int n = 0;//查找次数

	n++;
	if (hash[t].key == key) {
		printf("查找成功，查找次数为%d次\n", n);
		return n;
	}

	MyHash* p = (MyHash*)malloc(sizeof(MyHash));
	*p = hash[t];
	n++;
	if (p == NULL) {
		printf("查找失败，查找次数为%d次\n", n);
		return n;
	}
	while (p != NULL) {
		n++;
		if (p->key == key) {
			printf("查找成功，查找次数为%d次\n", n);
			return n;
		}
		p = p->next;
	}
	printf("查找失败，查找次数为%d次\n", n);
	return n;
}

//删除
int delete(int key) {
	int t = key % 17;
	int n = 0;//操作次数
	n++;
	if (hash[t].key == key) {
		hash[t].key = -1;
		hash[t].value = -1;
		n += 2;
		printf("删除成功，操作次数为%d次\n", n);
		return n;
	}

	MyHash* p = (MyHash*)malloc(sizeof(MyHash));
	*p = hash[t];
	n++;
	if (p == NULL) {
		printf("查找失败，不存在此数，操作次数为%d次\n", n);
		return n;
	}
	while (p != NULL) {
		n++;
		if (p->key == key) {
			hash[t].key = -1;
			hash[t].value = -1;
			n += 2;
			printf("删除成功，操作次数为%d次\n", n);
			return n;
		}
		p = p->next;
		n++;
	}
	printf("查找失败，不存在此数，操作次数为%d次\n", n);
	return n;
}

//步骤与测试
main() {
	ini(&hash, 17);
	int count = 50;
	int i;
	while (count > 0) {
		i = rand();
		if (i > 199 && i < 1001) {
			if (addData(i, 0) > 0) {
				count--;
			}
		}
	}

	printf("查找500(500为自定义的数)\n");
	search(500);

	printf("\n");
	printf("查找%d(%d为生成的随机数)\n", i,i);
	search(i);

	printf("\n");
	printf("删除%d\n", i);
	delete(i);

}

题目2：排序

① 生成100个在[200, 1000]之间的整数保存数组A中，以此数组元素作为关键字，采用希尔排序算法按非递减方式进行排序，给出操作的结果及相应的操作次数；
③ 生成200个在[200, 10000]之间的整数保存数组A中，以此数组元素作为关键字，采用快速排序算法按非递减方式进行排序，给出操作的结果及相应的操作次数；
④ 生成500个在[200, 10000]之间的整数保存数组A中，以此数组元素作为关键字，采用堆排序算法按非递减方式进行排序，给出操作的结果及相应的操作次数；
⑤ 主函数通过调用函数实现以上操作。

⑴ 所定义的数据结构:

	int A[100];
	int count = 0;//计数器

⑵ 主要操作算法思想或算法步骤:

//主要操作：
//希尔排序
int shell_sort(int array[], int length) {
	int i;
	int j;
	int k;
	int step;	//分组的步长
	int temp;	//哨兵
    int count = 0;//计算操作数
	for (step = length / 2; step > 0; step = step / 2) {
		for (i = 0; i < step; i++, count++) {
			for (j = i + step; j < length; j = j + step) {	//单独一次的插入排序
				if (array[j] < array[j - step]) {
					temp = array[j];	//哨兵
					k = j - step;
					while (k >= 0 && array[k] > temp) {
						array[k + step] = array[k];
						k = k - step;
                        count += 4;
					}
					array[k + step] = temp;
                    count += 5;
				}
			}
		}
	}
    return count;
}

//快速排序
int quickSort(int* arr, int low, int high) {
    int c = 0;
    c++;
    if (low < high) {
        int i = low;
        int j = high;
        int k = arr[low];
        while (i < j) {
            c+=5;
            while (i < j && arr[j] >= k) {    // 从右向左找第一个小于k的数
                j--; c++;
            }
            if (i < j) {
                arr[i++] = arr[j]; 
            }
            while (i < j && arr[i] < k) {     // 从左向右找第一个大于等于k的数
                i++; c++;
            }
            if (i < j) {
                arr[j--] = arr[i];
            }
        }
        arr[i] = k;
        c += 6;
        // 递归调用
        c+=quickSort(arr, low, i - 1);     // 排序k左边
        c+=quickSort(arr, i + 1, high);    // 排序k右边
    }
    return c;
}


//堆排序
void swap(int* a, int* b) {
    int temp = *a;
    *a = *b;
    *b = temp;
}
int percDown(int  A[], int i, int N) {
    int child;
    int temp;
    int c=0;

    c+=2;
    for (temp = A[i]; 2 * i + 1 < N; i = child) {
        c+=2;
        child = 2 * i + 1; //数组下标是从0开始的
        c++;

        c++;
        if (child != N - 1 && A[child + 1] > A[child]) {
            ++child; //找到最大的儿子节点
            c++;
        }
        c++;
        if (temp < A[child]) {
            A[i] = A[child];
            c++;
        }
        else
            break;
    }
    A[i] = temp;
    c++;

    return c;
}

int heapSort(int A[], int N) {
    int i;
    int c=0;//操作次数

    c+=2;
    for (i = N / 2; i >= 0; --i) {
        c += 2;
        c+=percDown(A, i, N);    //构造堆
    }
    for (i = N - 1; i > 0; --i) {
        c += 2;

        swap(&A[0], &A[i]);   //将最大元素（根）与数组末尾元素交换，从而删除最大元素，重新构造堆
        c += 3;

        c+=percDown(A, 0, i);
    }

    return c;
}


//测试函数
main() {
	int A[100];
	int count = 0;//计数器
	while (count<100)	{
		int num = rand();
		if (num >= 200 && num <= 1000) {
			A[count] = num;
			count++;
		}
	}

    printf("未排序：\n");
    for (int i = 0; i < 100; i++)
        printf("%d  ", A[i], i);
    printf("\n\n");

    int c=0;//操作次数
    //c=shell_sort(A, 100);//希尔排序
    //c=quickSort(A, 0, 99);//快速排序
    c=heapSort(A, 100);//堆排序

    printf("排序后：\n");
	for (int i = 0; i < 100; i++)
		printf("%d  ", A[i]);
    printf("\n\n操作次数：%d\n", c);
}