求出数组前面k个元素或数组中元素大于一半的元素（快速排序与堆排序的灵活运用）

int a[101],n;//定义全局变量，这两个变量需要在子函数中使用 
void quicksort(int left,int right) 
{ 
    int i,j,t,temp; 
    if(left>right) 
       return; 
                                
    temp=a[left]; //temp中存的就是基准数 
    i=left; 
    j=right; 
    while(i!=j) 
    { 
                   //顺序很重要，要先从右边开始找 
                   while(a[j]>=temp && i<j) 
                            j--; 
                   //再找右边的 
                   while(a[i]<=temp && i<j) 
                            i++; 
                   //交换两个数在数组中的位置 
                   if(i<j) 
                   { 
                            t=a[i]; 
                            a[i]=a[j]; 
                            a[j]=t; 
                   } 
    } 
    //最终将基准数归位 
    a[left]=a[i]; 
    a[i]=temp; 
                             
    quicksort(left,i-1);//继续处理左边的，这里是一个递归的过程 
    quicksort(i+1,right);//继续处理右边的 ，这里是一个递归的过程 
} 

int partition_quickSort(int *arr,int start,int end)
{
	int cmp_val=arr[start]; 
	int i=start; 
	int j=end; 
	while(i!=j){
		while(i<j&&arr[j]>=cmp_val){
			j--; 
		}
		while(i<j&&arr[i]<=cmp_val){
			i++; 
		}
		if(i<j){
			int  ex_temp=arr[j]; 
			arr[j]=arr[i];
			arr[i]=ex_temp; 
		}
	}
	arr[start]=arr[i]; 
	arr[i]=cmp_val; 
	return i; 
}

int partition_quickSort(int *arr,int start,int end)

int moreThanHalfNum_Partition(int *arr,int Length){
	if(arr==NULL||Length==0){
		return 0; 
	}
	int low=0; 
	int high=Length-1; 
	int mid=Length>>1; 
	int index= partition_quickSort(arr,low,high); 
	while(index!=mid){
		if(index>mid){
			index= partition_quickSort(arr,low,index-1); 
		}else{
			index= partition_quickSort(arr,index+1,high); 
		}
	}
	int key=arr[mid]; 
	if(isMoreHalf(arr,Length,key)){
		return key; 
	}else{
		return 0; 
	}
}

index>mid

int partition_quickSort(int *arr,int start,int end){
	int cmp_val=arr[start]; 
	int i=start; 
	int j=end; 
	while(i!=j){
		while(i<j&&arr[j]>=cmp_val){
			j--; 
		}
		while(i<j&&arr[i]<=cmp_val){
			i++; 
		}
		if(i<j){
			int  ex_temp=arr[j]; 
			arr[j]=arr[i];
			arr[i]=ex_temp; 
		}
	}
	arr[start]=arr[i]; 
	arr[i]=cmp_val; 
	return i; 
}

bool minKDataBeforeArr(int *arr,int Length,int k_bef){
	if(arr==NULL||k_bef>Length){
		return false; 
	}
	int start=0; 
	int k_index=0; 
	int end=Length-1; 
	k_index=partition_quickSort(arr,start,end); 
	while(k_index!=k_bef-1){
		if(k_index>k_bef-1){
			end=k_index-1; 
			k_index=partition_quickSort(arr,start,end); 
		}else{
			start=k_index+1; 
			k_index=partition_quickSort(arr,start,end); 
		}
	}
	for(int i=0;i<k_bef; i++){
		for(int j=k_bef;j<Length; j++){
			if(arr[i]>arr[j]){
				return false; 
			}
		}
	}
	return true; 
}