【摆烂成长组】对分查找-分块查找（编程）C语言

有位好友是在反复观看吗？有疑惑或者是有想讨论的可以在评论区里找我哦

放在开头：请勿直接用于提交作业，欢迎评论区讨论指导本fw，感激不尽

有一个问题：随机数足够多时会出现重复的情况，排序后，查找方法不同会给出相同数据的不同地址 
做一个假设的可能解决方法，不在代码实现，当找到key后，顺序遍历排查key后与key相同的元素并给出位置，
直到下一个不同，则进入下一次查找。但问题是分块时可能将同一数据分向两个块需要对两个块都查找，
工作量*2，不好，待思考*

学习心得：开始有意识掌握代码规范化

问题，变量的命名不规范，有效注释不足

评价：

反正也没人看

#include <stdio.h>
#include <stdlib.h>
#include <time.h>
#define N 100000//定义一个10万 表长 
#define B 100//定义一个100   要找的个数 
#define L 200//定义一个200   块数 
void Bubble(int *item, int count)
{
	int a, b, t, c;
	
	for ( a=1; a < count; a++)
	{
		c=1;
		for(b=1; b <= count - a; b++)
		{
			if (item[b-1] > item[b])
				{
					t = item[b-1];
					item[b-1] = item[b];
					item[b] = t; 
					c=0;
				}
	    }
	    if (c)
			break;
	}   
}//改进的冒泡排序 

int BinarySearch(int *item, int n, int key)
{
	int left, right, mid;
	
	left = 0;
	right = n-1;
	while (left <= right)
	{
		mid = (left + right) / 2;
		if (key < item[mid])
			right = mid - 1;
		else if (key > item[mid])
			left = mid + 1;
		else
		{
			printf("\n查找成功 ");
			return mid ; 
		}
	}
	printf("\n查找失败 ");
	return -1;	
}
void BlockSearch(int *target, int *num , int p, int r, int q)//p为表长,r为要找的个数,q为块个数 
{
	int i, j, t, s, temp;
	int *b;
	
	b = (int *)malloc(q * sizeof(int));	
	b[0] = -1;
	s = (p / q);//为每块的长度 
	t = s - 1;
	for (i=1; i <= q; i++ )
	{
		b[i] = num[t];
		t = t+s;
	}
	for (i=0; i < r; i++ )
	{
		for (j=0; j <= q; j++ )
		{
			if (b[j] < target[i] && target[i] <= b[j+1]) 
				{if (target[i] == b[j+1])
					printf("查找成功，位置为%d",s * (j + 1) - 1);
				else 	
				{
					if ((temp = BinarySearch(&num[s * j], s, target[i])) != -1 )
						temp = (s * j) + temp;
						printf("位置为%d",temp);
				}
				}
		}
	}
	free(b);	
}//可以根据表长自由分块 

void TFBubble(int *num, int count )
{
	long i = 10000000L;
	clock_t start, finish;
	double duration;
/* 测量一个事件持续的时间*/

	printf( "Time to do %ld empty loops is ", i );
	start = clock();
	Bubble(num , count);	
	finish = clock();
	duration = (double)(finish - start) / CLOCKS_PER_SEC;
	printf( "%f seconds(TFBubble)\n", duration );
}
//对数组进行冒泡排序并测量排序时间 

void TFBinarySearch(int *num, int count_1, int *target, int count_2)//count_2 为 
{   
	long i = 10000000L;
	clock_t start, finish;
	double duration;
	int p, q;
/* 测量一个事件持续的时间*/

	printf( "Time to do %ld empty loops is ", i );
	start = clock();
	for (p=0; p < count_2; p++)
		printf("位置为%d",BinarySearch(num, count_1, target[p]));
	finish = clock();
	duration = (double)(finish - start) / CLOCKS_PER_SEC;
	printf( "\n%f seconds(TFBinarySearch)\n", duration );
}
//对数组进行对分查找并测量排序时间

void TFBlockSearch(int *target, int *num , int p, int r, int q)
{
	long i = 10000000L;
	clock_t start, finish;
	double duration;
/* 测量一个事件持续的时间*/

	printf( "Time to do %ld empty loops is ", i );
	start = clock();
	BlockSearch( target, num , p, r, q);
	finish = clock();
	duration = (double)(finish - start) / CLOCKS_PER_SEC;
	printf( "\n%f seconds(TFBlockSearch)\n", duration );
}

int main()
{
	int i;
	int *num, *target;
	
	num = (int *)malloc(N * sizeof(int));
	for (i=0; i<N; i++)
		num[i] = rand();
	TFBubble(num, N );
	target = (int *)malloc(B * sizeof(int));
	for (i=0; i<B; i++)
		target[i] = rand();
	TFBinarySearch(num, N, target, B);
	TFBlockSearch(target, num , N, B, L);
	free(num);
	free(target);
	return 0;	
}