int search(vector<int>& nums, int target) {
int n = nums.size();
// if (n == 0) return -1;
// if (n == 1) return (target == nums[0])-1;
//find pivot
int pivot = -1;
int l = 0, r = n-1;
while (l < r)
{
int mid = l + (r-l)/2;
nums[mid] > nums[r]? l = mid+1: r = mid;
}
pivot = r-1; //index of maximum
cout <<pivot;
if (pivot == -1) //all ascending
return BinarySearch(nums, 0, n-1, target);
// if (target > nums[pivot] || target < nums[r] || (target >nums[n-1] && target < nums[0]))
// return -1;
else if (target >=nums[0])
return BinarySearch(nums, 0, pivot, target);
else
return BinarySearch(nums, pivot+1, n-1, target);
}
size_t CosineTree::BinarySearch(arma::vec& cDistribution,
double value,
size_t start,
size_t end)
{
size_t pivot = (start + end) / 2;
// If pivot is zero, first point is the sampled point.
if (!pivot)
{
return pivot;
}
// Binary search recursive algorithm.
if (value > cDistribution(pivot - 1) && value <= cDistribution(pivot))
{
return (pivot - 1);
}
else if (value < cDistribution(pivot - 1))
{
return BinarySearch(cDistribution, value, start, pivot - 1);
}
else
{
return BinarySearch(cDistribution, value, pivot + 1, end);
}
}
int BinarySearch(int A[],int low,int high,int x){
if (low > high) return -1;
int mid = low + (high-low)/2; //low+high can overflow
if(x == A[mid]) return mid; // Found X, return (exit)
else if(x < A[mid]) return BinarySearch(A, low, mid-1,x); //X lies before mid
else return BinarySearch(A, mid+1, high, x); //X lies after mid
}
//CDynamicArray &aWord: the words array
//CDynamicArray &aWordBinaryNet:the net between words
//double dSmoothingPara: the parameter of data smoothing
//CDictionary &DictBinary: the binary dictionary
//CDictionary &DictCore: the Core dictionary
bool CSegment::BiGraphGenerate(CDynamicArray &aWord, CDynamicArray &aBinaryWordNet,double dSmoothingPara,CDictionary &DictBinary,CDictionary &DictCore)
{
PARRAY_CHAIN pTail,pCur,pNextWords;//Temp buffer
unsigned int nWordIndex=0,nTwoWordsFreq=0,nCurWordIndex,nNextWordIndex;
//nWordIndex: the index number of current word
double dCurFreqency,dValue,dTemp;
char sTwoWords[WORD_MAXLENGTH];
m_nWordCount=aWord.GetTail(&pTail);//Get tail element and return the words count
if(m_npWordPosMapTable)
{//free buffer
delete [] m_npWordPosMapTable;
m_npWordPosMapTable=0;
}
if(m_nWordCount>0)//Word count is greater than 0
{
m_npWordPosMapTable=new int[m_nWordCount];//Record the position of possible words
memset(m_npWordPosMapTable,0,m_nWordCount*sizeof(int));
}
pCur=aWord.GetHead();
while(pCur!=NULL)//Set the position map of words
{
m_npWordPosMapTable[nWordIndex++]=pCur->row*MAX_SENTENCE_LEN+pCur->col;
pCur=pCur->next;
}
pCur=aWord.GetHead();
while(pCur!=NULL)//
{
if(pCur->nPOS>=0)//It's not an unknown words
dCurFreqency=pCur->value;
else//Unknown words
dCurFreqency=DictCore.GetFrequency(pCur->sWord,2);
aWord.GetElement(pCur->col,-1,pCur,&pNextWords);//Get next words which begin with pCur->col
while(pNextWords&&pNextWords->row==pCur->col)//Next words
{
//Current words frequency
strcpy(sTwoWords,pCur->sWord);
strcat(sTwoWords,WORD_SEGMENTER);
strcat(sTwoWords,pNextWords->sWord);
nTwoWordsFreq=DictBinary.GetFrequency(sTwoWords,3);
//Two linked Words frequency
dTemp=(double)1/MAX_FREQUENCE;
//Smoothing
dValue=-log(dSmoothingPara*(1+dCurFreqency)/(MAX_FREQUENCE+80000)+(1-dSmoothingPara)*((1-dTemp)*nTwoWordsFreq/(1+dCurFreqency)+dTemp));
//-log{a*P(Ci-1)+(1-a)P(Ci|Ci-1)} Note 0<a<1
if(pCur->nPOS<0)//Unknown words: P(Wi|Ci);while known words:1
dValue+=pCur->value;
//Get the position index of current word in the position map table
nCurWordIndex=BinarySearch(pCur->row*MAX_SENTENCE_LEN+pCur->col,m_npWordPosMapTable,m_nWordCount);
nNextWordIndex=BinarySearch(pNextWords->row*MAX_SENTENCE_LEN+pNextWords->col,m_npWordPosMapTable,m_nWordCount);
aBinaryWordNet.SetElement(nCurWordIndex,nNextWordIndex,dValue,pCur->nPOS);
pNextWords=pNextWords->next;//Get next word
}
pCur=pCur->next;
}
return true;
}
int BinarySearch(int arr[],int first,int last,int target){
int mid;
if(first>last) return -1;
mid=(first+last)/2;
if(arr[mid]==target) return mid;
else if(arr[mid]>target) return BinarySearch(arr,first,mid-1,target);
else return BinarySearch(arr,mid+1,last,target);
}
int _tmain(int argc, _TCHAR* argv[])
{
int i = BinarySearch(a, 101, 0, kSize);
i = BinarySearch(a, 76, 0, kSize);
i = BinarySearchIterative(a, 77, 0, kSize);
i = BinarySearchIterative(a, 3, 0, kSize);
i = BinarySearchIterative(a, 101, 0, kSize);
i = BinarySearchIterative(a, 76, 0, kSize);
return 0;
}
// 在a的[low, high]区间内找到ley的位置并返回
int BinarySearch(int* a, int low, int high, int key){
if(low > high) return -1;
// 算出中间位置
int mid = (low + high) / 2;
if(key > a[mid]){
return BinarySearch(a, mid + 1, high, key);
} else if(key < a[mid]){
return BinarySearch(a, low, mid - 1, key);
} else return mid;
}
void Table3D::InterpolatePoint_old(void) {
// Dimension 1
BinarySearch(interp->index[0], interp->weight[0][0], x1, 0, n1-1, point[0]);
interp->weight[0][1] = 1.0 -interp->weight[0][0];
// Dimension 2
BinarySearch(interp->index[1], interp->weight[1][0], x2, 0, n2-1, point[1]);
interp->weight[1][1] = 1.0 -interp->weight[1][0];
// Dimension 3
BinarySearch(interp->index[2], interp->weight[2][0], x3, 0, n3-1, point[2]);
interp->weight[2][1] = 1.0 -interp->weight[2][0];
}
// Returns the index of number within array a or -1 if not found
int BinarySearch(const int a[], int number, int low, int high)
{
if (low < 0 || high < 0) return -1;
if (low > high) return -1;
int mid = (low + high) / 2;
if (number == a[mid]) return mid;
else if (number < a[mid])
return BinarySearch(a, number, low, mid - 1);
else // number > a[mid]
return BinarySearch(a, number, mid + 1, high);
}
int BinarySearch(int* arr, int key, int min_idx, int max_idx) {
if(max_idx < min_idx) {
return -1; // Not Found
}
int mid_idx = min_idx + ((max_idx - min_idx) / 2);
if(key < arr[mid_idx]) {
return BinarySearch(arr, key, min_idx, mid_idx - 1);
}
if(key > arr[mid_idx]) {
return BinarySearch(arr, key, mid_idx + 1, max_idx);
}
return mid_idx;
}
int main(int argc, char** argv){
int i, j, k, m;
int A[] = {2,5,-3,45,12,4,8,19,3,12};
int B[] = {2,4,6,8,10,12,14,16,18,20};
i = SequentialSearch(A, 10, 12);
j = SequentialSearch(B, 10, 12);
k = BinarySearch(B, 10, 12);
m = BinarySearch(B, 10, 13);
printf("%d, %d, %d, %d\n", i, j, k, m);
return(EXIT_SUCCESS);
}
/* Search an ordered array of strings in a recursive binary fashion.
* Returns the index of the string found. Less than 0 if false.
*/
int BinarySearch(char *name,int l, int h, char *array[])
{
register int m, rc;
if (l > h)
return (-1);
m = (l + h) / 2;
if ((rc = strcmp(name, array[m])) == 0)
return (m);
else if (rc < 0)
return (BinarySearch(name, l, m - 1, array));
else
return (BinarySearch(name, m + 1, h, array));
}
int BinarySearchType::BinarySearch(/* IN */ int First,
/* IN */ int Last)
//-------------------------------------------------
// Pre : First, Last and Value are assigned
// and 0 <= First, Last <= SIZE-1,
// where SIZE is the maximum size of the array,
// and pDC_[First..Last] and pValue_ are assigned
// Post: pDC_ has been search for Value point to by pValue_
// if Value is found
// returns index within DataContainer
// else
// returns -1
//-------------------------------------------------
{
int Index;
if (First > Last)
{
Index = -1; // Value not in original DataContainer
}
else
{
int Mid = (First + Last)/2;
//if (Value == A[Mid])
if ((*pValue_) == pDC_->GetItem(Mid))
{
Index = Mid; // Value found at DataContainer[Mid]
}
// else if (Value < A[Mid])
else if ((*pValue_) < pDC_->GetItem(Mid))
{
//BinarySearch(A, First, Mid-1, Value, Index); // X
Index = BinarySearch(First, Mid-1); // X
}
else
{
//BinarySearch(A, Mid+1, Last, Value, Index); // Y
Index = BinarySearch(Mid+1, Last); // Y
}
} // end else
return (Index);
} // end BinarySearch
void *multiGenerateSplit(void *arg)
{
void **argT=(void **)arg;
uint64_t num=(uint64_t )argT[0];
uint64_t THREAD_NUM=(uint64_t)argT[1];
free(argT);
uint64_t segment=BWTLEN/THREAD_NUM;
uint64_t start=num*segment,i;
uint64_t specialSApoint,branchPoint;
specialSApoint=BinarySearch(start,specialSA,countRead-1);
branchPoint=BinarySearch(start,specialBranch,specialBranchNum-1);
for(i=start;i<BWTLEN;i++)
{
unsigned int multioutFlag=0;
//check whether is multiout or not
uint64_t distance=specialSA[specialSApoint]-i;
if(distance>=KMER_LENGTH)// use the main module, for kmer info was stored in it
{
uint64_t checkSeq=convert(i)>>((32-KMER_LENGTH)<<1);
unsigned int formerSeq=checkSeq>>(REDLEN<<1);
uint64_t latterSeq=(checkSeq&REDEXTRACT);
uint64_t redLen;
//operation to check multiout, use hash
if(formerSeq>0)
{
redLen=blackTable[formerSeq]-blackTable[formerSeq-1];
}
else
{
redLen=blackTable[0];
}
if(redLen>0)
{
//binary search
uint64_t startPoint=blackTable[formerSeq]-redLen;
uint64_t *searchRedSeq=&redSeq[startPoint];
uint64_t candidate=BinarySearch_red(latterSeq,searchRedSeq,redLen-1);
if(candidate<redLen)
{
if((searchRedSeq[candidate]>>2)==latterSeq)
{
// Then we can judge whether it is multiout
unsigned int tempFlag=searchRedSeq[candidate]&3;
multioutFlag=tempFlag&1;
}
}
}
}
void findSorted(int *list,int k,int n)
{
int i,j;
int x,y,IndexX=-1,IndexY=-1;
int low,high;
FILE *out=fopen("output.txt","w");
for(i=0; i<n ; i++)
{
x= list[i];
IndexX=i;
y=k-x;
IndexY=BinarySearch(list,y,n);
if(IndexY==-1)
printf("There is no x+y=k exist\n\n");
else if(list[IndexX] < list[IndexY])
{
printf("List[%d]'s element is %d\nList[%d]'s element is %d\n",IndexX,list[IndexX],IndexY,list[IndexY]);
printf("Sum of these is equal to %d\n\n",k);
fprintf(out,"%d %d \n",list[IndexY], list[IndexX]);
}
}
fclose(out);
}
void CosineTree::ColumnSamplesLS(std::vector<size_t>& sampledIndices,
arma::vec& probabilities,
size_t numSamples)
{
// Initialize the cumulative distribution vector size.
arma::vec cDistribution;
cDistribution.zeros(numColumns + 1);
// Calculate cumulative length-squared distribution for the node.
for (size_t i = 0; i < numColumns; i++)
{
cDistribution(i + 1) = cDistribution(i) +
(l2NormsSquared(i) / frobNormSquared);
}
// Initialize sizes of the 'sampledIndices' and 'probabilities' vectors.
sampledIndices.resize(numSamples);
probabilities.zeros(numSamples);
for (size_t i = 0; i < numSamples; i++)
{
// Generate a random value for sampling.
double randValue = arma::randu();
size_t start = 0, end = numColumns, searchIndex;
// Sample from the distribution and store corresponding probability.
searchIndex = BinarySearch(cDistribution, randValue, start, end);
sampledIndices[i] = indices[searchIndex];
probabilities(i) = l2NormsSquared(searchIndex) / frobNormSquared;
}
}
size_t CosineTree::ColumnSampleLS()
{
// If only one element is present, there can only be one sample.
if (numColumns < 2)
{
return 0;
}
// Initialize the cumulative distribution vector size.
arma::vec cDistribution;
cDistribution.zeros(numColumns + 1);
// Calculate cumulative length-squared distribution for the node.
for (size_t i = 0; i < numColumns; i++)
{
cDistribution(i + 1) = cDistribution(i) +
(l2NormsSquared(i) / frobNormSquared);
}
// Generate a random value for sampling.
double randValue = arma::randu();
size_t start = 0, end = numColumns;
// Sample from the distribution.
return BinarySearch(cDistribution, randValue, start, end);
}
/*!
\brief Nearest Neighbor search function
Searches for the k nearest neighbors to the point q. The answer
vector returned will contain the indexes to the answer points
This function is thread-safe.
\param q The query point
\param k The number of neighbors to return
\param nn_idx Answer vector
\param dist Distance Vector
\param eps Error tolerence, default of 0.0.
*/
void ksearch(Point q, unsigned int k, std::vector<long unsigned int> &nn_idx, std::vector<double> &dist, float Eps) {
long unsigned int query_point_index;
qknn que;
query_point_index = BinarySearch(points, q, lt);
ksearch_common(q, k, query_point_index, que, Eps);
que.answer(nn_idx, dist);
}
int main()
{
int n,i,j,temp,arr[100],lower,upper,search,s;
printf("\nEnter the number of elements :\n");
scanf("%d",&n);
printf("Enter the elements :\n");
for(i=0;i<n;i++)
scanf("%d",&arr[i]);
printf("Enter the element to be searched :\n");
scanf("%d",&search);
lower=0;
upper=n;
for(i=0;i<n-1;i++)
{
for(j=i+1;j<n;j++)
{
if(arr[i]>arr[j])
{
temp=arr[i];
arr[i]=arr[j];
arr[j]=temp;
}
}
}
s=BinarySearch(lower,upper,arr,search);
if(s==-1)
printf("The element %d is not present in the array\n",search);
else
printf("The element %d is in position %d\n",search,s);
return 0;
}
int main() {
int myArray[10], val, answer;
srand(time(0));
// Fill the array randomly, then sort.
randArray(myArray, 10, 100);
// Print out the original contents.
printf("Here are the values in your array: ");
printArray(myArray, 10);
bubbleSort(myArray, 10);
// Print out the contents after the sort.
printf("Here are the values in your array: ");
printArray(myArray, 10);
// Ask the user for an element for which to search.
printf("For which element would you like to search?");
scanf("%d", &val);
// Perform a binary search.
answer = BinarySearch(myArray, 10, val);
// Print out the results!
if (answer != NOT_FOUND)
printf("Your value was found in index %d of the array.\n", answer);
else
printf("Your value wasn't found.\n");
system("PAUSE");
return 0;
}
int main(int argc,char **argv)
{
int32_t num,search,i = 0,result = 0;
fprintf(stdout,"Enter the number of elements :\n");
fscanf(stdin,"%d",&num);
int32_t *array = (int32_t *)malloc(sizeof(int32_t) * num);
fprintf(stdout,"Enter the elements :\n");
while(i < num)
{
fscanf(stdin,"%d",(array + i));
i++;
}
fprintf(stdout,"Enter the element to be searched :\n");
fscanf(stdin,"%d",&search);
result = BinarySearch(0,(num - 1),array,search);
if(result == -1)
fprintf(stdout,"The element %d is not present in the array\n",search);
else
fprintf(stdout,"The element %d is in position %d\n",search,result);
free(array);
return 0;
}
// It should never be the case that more than one hash prefixes match a given
// full hash. However, if that happens, this method returns any one of them.
// It does not guarantee which one of those will be returned.
nsresult
VariableLengthPrefixSet::Matches(const nsACString& aFullHash, uint32_t* aLength)
{
MutexAutoLock lock(mLock);
// Only allow full-length hash to check if match any of the prefix
MOZ_ASSERT(aFullHash.Length() == COMPLETE_SIZE);
NS_ENSURE_ARG_POINTER(aLength);
*aLength = 0;
// Check if it matches 4-bytes prefixSet first
const uint32_t* hash = reinterpret_cast<const uint32_t*>(aFullHash.BeginReading());
uint32_t value = BigEndian::readUint32(hash);
bool found = false;
nsresult rv = mFixedPrefixSet->Contains(value, &found);
NS_ENSURE_SUCCESS(rv, rv);
if (found) {
*aLength = PREFIX_SIZE_FIXED;
return NS_OK;
}
for (auto iter = mVLPrefixSet.ConstIter(); !iter.Done(); iter.Next()) {
if (BinarySearch(aFullHash, *iter.Data(), iter.Key())) {
*aLength = iter.Key();
MOZ_ASSERT(*aLength > 4);
return NS_OK;
}
}
return NS_OK;
}
/*
* === FUNCTION ======================================================================
* Name: main
* Description:
* =====================================================================================
*/
int
main ( )
{
int n, i, key, position;
int *array;
printf("请输入有序数组的大小：");
scanf("%d", &n);
array = (int*)malloc(sizeof(int)*n);
printf("请按升序输入数据：\n");
for(i=0;i<n;i++)
{
scanf("%d", &array[i]);
}
printf("请输入想要查找的数：\n");
scanf("%d", &key);
if(position = BinarySearch(array, key, 0, n-1))
{
printf("%d的位置为：%d\n", key, position);
}
else
{
printf("%d不存在.\n");
}
return 0;
} /* ----- end of function main ----- */
/*! \brief Calibration function
*
* Performs the calibration according to calibration method chosen.
* Compares different calibration results in order to achieve optimal results.
*
*/
void CalibrateInternalRc(void)
{
unsigned int count;
#ifdef CALIBRATION_METHOD_SIMPLE // Simple search method
unsigned char cycles = 0x80;
do{
count = Counter();
if (count > countVal)
OSCCAL--; // If count is more than count value corresponding to the given frequency:
NOP(); // - decrease speed
if (count < countVal)
OSCCAL++;
NOP(); // If count is less: - increase speed
if (count == countVal)
cycles=1;
} while(--cycles); // Calibrate using 128(0x80) calibration cycles
#else // Binary search with or without neighbor search
unsigned char countDiff;
unsigned char neighborSearchStatus = FINISHED;
while(calibration == RUNNING){
count = Counter(); // Counter returns the count value after external ticks on XTAL
if (calStep != 0)
{
BinarySearch(count); // Do binary search until stepsize is zero
}
else
{
if(neighborSearchStatus == RUNNING)
{
countDiff = ABS((signed int)count-(signed int)countVal);
if (countDiff < bestCountDiff) // Store OSCCAL if higher accuracy is achieved
{
bestCountDiff = countDiff;
bestOSCCAL = OSCCAL;
}
NeighborSearch(); // Do neighbor search
}
else // Prepare and start neighbor search
{
#ifdef CALIBRATION_METHOD_BINARY_WITHOUT_NEIGHBOR // No neighbor search if deselected
calibration = FINISHED;
countDiff = ABS((signed int)count-(signed int)countVal);
bestCountDiff = countDiff;
bestOSCCAL = OSCCAL;
#else
neighborSearchStatus = RUNNING; // Do neighbor search by default
neighborsSearched = 0;
countDiff = ABS((signed int)count-(signed int)countVal);
bestCountDiff = countDiff;
bestOSCCAL = OSCCAL;
#endif
}
}
}
#endif
}
void Puzzle2DNA::Mutate() {
std::vector<float> copyValidDNA = m_validPieces;
for (size_t i = 0; i < m_bin1.size(); i++) {
auto it = m_bin1.begin() + i;
if (!BinarySearch(copyValidDNA, it)) {
m_bin1.erase(it);
i--;
}
}
for (size_t i = 0; i < m_bin2.size(); i++) {
auto it = m_bin2.begin() + i;
if (!BinarySearch(copyValidDNA, it)) {
m_bin2.erase(it);
i--;
}
}
for (size_t i = 0; i < m_bin3.size(); i++) {
auto it = m_bin3.begin() + i;
if (!BinarySearch(copyValidDNA, it)) {
m_bin3.erase(it);
i--;
}
}
// could add extra mutate here
int newDNA;
if (copyValidDNA.size() > 0) {
while (m_bin1.size() < 10) {
newDNA = rand() % copyValidDNA.size();
m_bin1.push_back(copyValidDNA[newDNA]);
}
}
if (copyValidDNA.size() > 0) {
while (m_bin2.size() < 10) {
newDNA = rand() % copyValidDNA.size();
m_bin2.push_back(copyValidDNA[newDNA]);
}
}
if (copyValidDNA.size() > 0) {
while (m_bin3.size() < 10) {
newDNA = rand() % copyValidDNA.size();
m_bin3.push_back(copyValidDNA[newDNA]);
}
}
}
bool Pessoa::hasAluguer(Aluguer* al) //verifica se a pessoa tem o aluguer al activo
{
int pos = BinarySearch(alugueres, *al);
if (pos != -1)
return true;
return false;
}
int main(){
int A[] = {2,4,5,7,13,14,15,23};
printf("Enter a number: ");
int x; scanf("%d",&x);
int index = BinarySearch(A,0,8,x);
if(index != -1) printf("Number %d is at index %d",x,index);
else printf("Number %d not found",x);
}
/* Checks to see if the type of entity is to be output
*/
static int IsValidEntType(char *type)
{
if (BinarySearch(type, 0, options.entTypesCount - 1,
options.entTypes) >= 0)
return TRUE;
return False;
}
// -----------------------------------------------------------------------------
bool Algorithms::Test_BinarySearch()
{
bool pass = true;
{
int a[] = {};
std::vector<int> v = vec_transform(a, sizeof(a) / sizeof(int));
pass = pass && (BinarySearch(v, 0) == KEY_NOT_FOUND);
}
{
int a[] = {1};
std::vector<int> v = vec_transform(a, sizeof(a) / sizeof(int));
pass = pass && (BinarySearch(v, 0) == KEY_NOT_FOUND) &&
(BinarySearch(v, 1) == 0)
;
}
{
int a[] = {1, 2, 3, 4, 5, 6, 7, 8, 9};
std::vector<int> v = vec_transform(a, sizeof(a) / sizeof(int));
pass = pass && (BinarySearch(v, 0) == KEY_NOT_FOUND)
&& (BinarySearch(v, 1) == 0)
&& (BinarySearch(v, 9) == 8)
&& (BinarySearch(v, 5) == 4)
;
}
return pass;
}
int main() {
int arr[10] = {1, 3, 5, 11, 12, 13, 17, 22, 25, 28}; // Sorted
for(int i = 0; i < 10; i++) {
std::cout << "arr[" << i << "] = "<< arr[i] << std::endl;
}
int key = 22;
std::cout << "key : " << key << std::endl;
std::cout << "ans : " << BinarySearch(arr, key, 0, 9) << std::endl;
}
