数据结构第二次作业 二分

首先是我自己的想法，题目的意思就是在一组序列中，找到某个数的重复次数。

显然如果是用暴力的，时间复杂度是需要O(N^2)，根据题目的提示，采用二分查找的方法，即O(logn)的复杂度，由于采用二分是对有序数列而言，还要采用快排对输入的序列进行排序，即O(nlogn)，那么复杂度就降低了。

步骤：

        Step1：对输入序列进行快排

        Step2：用二分找到需要查询数在数组中出现的第一个位置t1

        Step3：用二分找到需要查询数在数组中出现的最后一个位置t2

        Step4：将t2-t1+1就是查询数在序列中出现的次数。

代码如下：

 
            #include <stdio.h>
#include <string.h>
#include <stdlib.h>
int a[500001]={0},b[500001]={0},m[500001]={0};//数组a存珠宝，数组b存查询的价格，数组m存相关价格的珠宝个数
int cmp(const void *x,const void *y)
{
	return (*(int*)x-*(int*)y);
}
int GetFirst(int *sortedArray,int k,int start,int end)
{
	if(sortedArray==NULL||start<0||end<0||start>end)
	{
		return -1;
	}
	if(sortedArray[start]==k)
	{
		return start;
	}
	while(start<=end)
	{
		int mid=start+(end-start)/2;//为了防止start+end整数溢出的问题，若相加结果大于范围，(start+end)/2不会出现正确的结果，用start+((end-start)/2//不会产生这个问题
		if(sortedArray[mid]<k)
			start=mid+1;
		else if(sortedArray[mid]>k)
			end=mid-1;
		else
		{
			if(sortedArray[mid-1]==k)//mid位置为k，再往前找，直到找到第一个k的位置
			{
				end=mid-1;
			}
			else
			{
				return mid;
			}
		}
	}
	return -1;
}

int GetLast(int *sortedArray,int k,int start,int end)
{
	if(sortedArray==NULL||start<0||end<0||start>end)
		return -1;
	if(sortedArray[end]==k)
		return end;
	while(start<=end)
	{
		int mid=start+(end-start)/2;
		if(sortedArray[mid]<k)
			start=mid+1;
		else if(sortedArray[mid]>k)
			end=mid-1;
		else
		{
			if(sortedArray[mid+1]==k)//mid位置为k，继续向后找，直到找到最后一个k
			{
				start=mid+1;
			}
			else
			{
				return mid;
			}
		}
	}
	return -1;
}

int main()
{
	int i,n,q,t1,t2,start=0;
	scanf("%d%d",&n,&q);
	for(i=0;i<n;i++)
		scanf("%d",&a[i]);
	qsort(a,n,sizeof(a[0]),cmp);
	for(i=0;i<q;i++)
		scanf("%d",&b[i]);
	for(i=0;i<=q;i++)
	{
		t1=GetFirst(a,b[i],start,n-1);
		t2=GetLast(a,b[i],start,n-1);
		if(t1!=-1&&t2!=-1)
		{
		m[i]=t2-t1+1;
		}
		else
			m[i]=0;
	}
	for(i=0;i<q;i++)
		printf("%d\n",m[i]);
	return 0;
}
        

根据优秀作业的情况，还提供了两种解法：

①开一个二维数组，a[][0]存价格，a[][1]存数量，每次输入，边插入，边排序并统计数量。同样运用二分查找每个数是否已存在，这种方法类似插入排序，最坏情况的复杂度是O(n^2)，介意将插入排序改为基数排序。

②方法和我的方法类似，只写了一个二分查找的函数，每次查找完以后，向前向后遍历是否还有与要查询数相同的数，做加加处理。个人认为这种向前向后的遍历比较耗时。