第三章：查找与排序（下）----------- 3.12 实践_最小可用id是多少

最小可用ID：在非负数组（乱序）中找到最小可分配的id（从1开始编号），数据量为1000000。

解法1：

暴力解法：O(N²)。从1开始依次探测每个自然数是否在数组中。不推荐

解法2：

先排序，然后看哪个数“不在其位”。NlgN。

#include<iostream>
#include<algorithm>
using namespace std;

int find2(int arr[],int length){
	sort(arr,arr+length);
	int i=0;
	while(i<length){
		if((i+1)!=arr[i]){
			return i+1;
		}
		i++;
	}
	return i+1;
} 

int main(){
	int arr[]={3,6,1,5,9,7,8};
	int len=7;
	cout<<find2(arr,len);
	
	return 0;
}

结果：

解法3：

开辟辅助空间，Eg：若5出现，则标记辅助空间5号单元为1。

待求数组，长度为n，最小可用ID不可能大于n+1。即 最小可用id<=n+1.

 

//伪代码： 
helper=[A.length]
for(i 0...A.length-1){
	helper[A[i]-1]=1;
}
for(i 0...A.length-1){
	if(helper[i]==0)
		return i+1;
}
return A.length+1

 

#include<iostream>
#include<algorithm>
using namespace std;

/* 
改进1：
新建长为n+1的数组F，初始值全为false，扫描原数组中的元素，小于n则将F[A[i]]记录为true
最后再扫描F，返回第一个为false的元素的下标，注：有点类似于计数排序O（n）但是浪费空间
*/
int find3(int arr[],int length){
	int n=length;
	int helper[n+1]; 
	
	//*helper数组初始化 
	for(int i=1;i<n+1;i++){
		helper[i]=0;
	}
	
	for(int i=0;i<n;i++){
		if(arr[i]<n+1){
			helper[arr[i]]=1;  //1:代表出现；0：代表未出现 
		}
	}
	for(int i=1;i<=n;i++){
		if(helper[i]==0){
			return i;
		}
	}
	return n+1;
} 

int main(){
	int arr[]={3,6,1,5,9,7,8};
	int arr2[]={1,2,3,4,5,6,7};
	int len=7;
	cout<<find3(arr,len)<<endl;
	cout<<find3(arr2,len);
	return 0;
}

结果：

解法4：

分区，递归 ：
问题可转化为：n个正数的数组A，如果存在小于n的数不在数组中，必然存在大于n的数在数组中，否则数组排列恰好为1到n

举例判断边界（结束条件）：

 

#include<iostream>
#include<algorithm>
using namespace std;

int selectK(int A[],int p,int r,int k);

/* 
改进2：分区，递归 
问题可转化为：n个正数的数组A，如果存在小于n的数不在数组中，必然存在大于n的数在数组中，否则数组排列恰好为1到n
*/
int find4(int arr[],int l,int r){
	if(l>r){
		return l+1;
	}
	
	int midIndex=l+((r-l)>>1);//中间下标
	int q=selectK(arr,l,r,midIndex-l+1);//实际在中间位置的值
	int t=midIndex+1;//期望值
	
	if(q==t){//左侧紧密 
		return find4(arr,midIndex+1,r);
	} 
	else{//左侧稀疏 
		return find4(arr,l,midIndex-1);
	}
	 
} 

int main(){
	int arr[]={3,6,1,5,9,7,8};
	int len=7;
	
	cout<<find4(arr,0,6);
	return 0;
}

 
//三点中值法 
int partition(int A[],int p,int r){
	
	//优化： 在p、r、mid之间，选一个中间值作为主元
	int midIndex=p+((r-p)>>1); //中间下标
	int midValueIndex=-1; //中值的下标
	if(A[p]<=A[midIndex]&&A[p]>=A[r]){
		midValueIndex=p;
	} 
	else if(A[r]<=A[midIndex]&&A[r]>=A[p]){
		midValueIndex=r;
	} 
	 else{
	 	midValueIndex=midIndex;
	 }
	swap(A[p],A[midValueIndex]);
	int pivot=A[p];
	
	int left=p+1;//扫描指针 
	int right=r; //右侧指针 
 
	
	while(left<=right){
		//left不停往右走，直到遇到大于主元的元素
		while(A[left]<=pivot) left++;   //循环退出时，left一定是指向第一个大于主元的位置 
		while(A[right]>pivot) right--;   //循环退出时，right一定是指向最后一个小于等于主元的位置 
		if(left<right){
			swap(A[right],A[left]);	
		}			
	} 
	//while退出时，两者交错，且right指向的是最后一个小于等于主元的位置，也就是主元应该待的位置 
	swap(A[p],A[right]);
	
	return right;		//返回主元在交换完成后的下标
}
 
int selectK(int A[],int p,int r,int k){
	int q=partition(A,p,r); //主元下标 
	int qK=q-p+1; //主元是第几个元素(排好序后) 
	if(qK==k){
		return A[q];
	} 
	else if(qK>k){
		return selectK(A,p,q-1,k);
	}
	else{
		return selectK(A,q+1,r,k-qK);
	}
}

 结果：