int findPivot(int *A, int low, int high)
{
int mid= (low+high) / 2;
if ( A[mid+1]<A[mid])
return mid;
if( A[low] >A[mid] )
return findPivot(A ,low,mid-1);
else
return findPivot(A ,mid+1,high);
}
int findPivot(int a[], int start, int end){
if(end < start) return -1;
if(start == end) return end;
int mid = (start + end) / 2;
if(start < mid && a[mid] < a[mid-1])
return mid-1;
if(mid < end && a[mid] > a[mid+1])
return mid;
if(a[start] > a[mid])
return findPivot(a, start, mid-1);
else
return findPivot(a, mid+1, end);
}
/* Function to get pivot. For array 3, 4, 5, 6, 1, 2 it returns
3 (index of 6) */
int findPivot(int arr[], int low, int high)
{
// base cases
if (high < low) return -1;
if (high == low) return low;
int mid = (low + high)/2; /*low + (high - low)/2;*/
if (mid < high && arr[mid] > arr[mid + 1])
return mid;
if (mid > low && arr[mid] < arr[mid - 1])
return (mid-1);
if (arr[low] >= arr[mid])
return findPivot(arr, low, mid-1);
return findPivot(arr, mid + 1, high);
}
int partition( int *array, int left, int right )
{
int p;
int j, temp, i = left + 1;
//MEDIAN OF THREE
findPivot( array, left, right );
p = array[left];
for( j = left + 1; j <= right; j++ )
{
if( array[j] < p )
{
temp = array[j];
array[j] = array[i];
array[i] = temp;
i++;
}
}
//set pivot
temp = array[left];
array[left] = array[i-1];
array[i-1] = temp;
return i - 1;
}
bool search(int A[], int n, int target) {
// Start typing your C/C++ solution below
// DO NOT write int main() function
int pivot = findPivot(A, 0, n - 1);
return bSearch(A, 0, pivot - 1, target) || bSearch(A, pivot, n - 1, target);
}
void recurse_filter_kruskal(WspIter begin, WspIter end, int THold)
{
WspIter part,fpart, part1, part2;
if(end-begin < 1000)
{
Kruskal(begin, end);
}
else
{
findPivot(begin, end, bdpredmin, bdpredmax);
do
{
MyTimer A;
part1 = partition(begin, end, bdpredmin);
std::cout << "Part1 size: " << end-begin << " Time: " << A << std::endl;
if(part1==begin) bdpredmin.minBccp*=2;
}
while(part1==begin);
bdpredmax.maxBccp = bdpredmin.minBccp;
part2 = partition(part1, end, bdpredmax);
do_bccp(part1, part2);
bccppred.maxBccp = bdpredmin.minBccp;
part = partition(part1, part2, bccppred);
Kruskal(begin, part);
fpart = partition(part, end, ufpred);
recurse_filter_kruskal(part, fpart, THold);
}
}
int findPivot(vector<int>& nums, int start , int end) {
int len = end - start + 1;
int mid = start + (end - start) / 2;
if (start == end) return start;
if (end - start == 1) return nums[start] < nums[end] ? end : start;
if (len > 1) {
int halfNum = nums[mid], startNum = nums[start], endNum = nums[end];
if (halfNum < startNum) {
return findPivot(nums, start, mid);
}
if (halfNum > endNum) {
return findPivot(nums, mid, end);
}
}
return -1;
}
void quickSort_aux(int numArray[], int p, int r)
{
int q = 0;
if(p<r)
{
q = findPivot(numArray, p, r);
quickSort_aux(numArray, p, q);
quickSort_aux(numArray,q+1, r);
}
}
int findPivot(int A[], int left, int right)//找到数组中的分割点，这里是后半部分的起始点
{
if(left >= right)return (left + right) >> 1;
int mid = left + ((right - left) >> 1);//防止left + right溢出
if(mid == left) //把这种特殊的情况提出来
if(A[mid] < A[right])return mid;
else return right;
if(A[mid] > A[left])
return findPivot(A, mid, right);//注意从mid开始
else if(A[mid] < A[left])
return findPivot(A, left, mid);//注意包括了Mid
else {
while(left < mid && A[++left] == A[mid]);
return findPivot(A, left, right);
}
}
void rotatedBinarySearch(int *a, int length, int x){
int pivot = findPivot(a, 0, length-1);
if(pivot == -1)
binarySearch(a, 0, length-1, x);
else{
if(x >= a[0])
binarySearch(a, 0, pivot, x);
else
binarySearch(a, pivot+1, length-1, x);
}
}
int pivotedBinarySearch(int A[], int size, int num)
{
int high=size - 1;
int pivot = findPivot(A,0,4);
if(A[pivot]==num)
return pivot;
if ( num > A[high])
return binarySearch(A,0,pivot ,num);
else
return binarySearch(A,pivot +1 ,high ,num);
}
/* Searches an element key in a pivoted sorted array arrp[]
of size n */
int pivotedBinarySearch(int arr[], int n, int key)
{
int pivot = findPivot(arr, 0, n-1);
// If we didn't find a pivot, then array is not rotated at all
if (pivot == -1)
return binarySearch(arr, 0, n-1, key);
// If we found a pivot, then first compare with pivot and then
// search in two subarrays around pivot
if (arr[pivot] == key)
return pivot;
if (arr[0] <= key)
return binarySearch(arr, 0, pivot-1, key);
return binarySearch(arr, pivot+1, n-1, key);
}
//
// Quick sort records by attrib index.
//
bool CCSClones::quickSort(int left, int right)
{
int p = -1;
int pivot = -1;
if (findPivot(left, right, pivot)) {
p = partition(left, right, pivot);
if (!quickSort(left, p - 1)) {
ASSERT(false);
return false;
}
if (!quickSort(p, right)) {
ASSERT(false);
return false;
}
}
return true;
}
void part_and_process(WspIter begin, WspIter end)
{
if((unsigned int) (end-begin) < (wspd.Points.size()*10))
{
Kruskal(begin, end);
}
else
{
WspIter I = findPivot(begin, end);
bdpredmin.minBccp = I->get_bccp_dist();
I = partition(begin, end, bdpredmin);
Kruskal(begin, I);
if(Mst.size() >= wspd.Points.size())
return;
WspIter fpart = partition(I, end, ufpred);
part_and_process(I, fpart);
}
}
int Solution::search(const vector<int> &A, int B) {
// Do not write main() function.
// Do not read input, instead use the arguments to the function.
// Do not print the output, instead return values as specified
// Still have a doubt. Checkout www.interviewbit.com/pages/sample_codes/ for more details
int pivot = findPivot(A);
if(B == A[pivot]){
return pivot;
}
int result = binarySearch(A, 0, pivot-1, B);
if(result == -1){
return binarySearch(A, pivot+1, A.size()-1, B);
}
return result;
// B < A[pivot]
}
void KDnode::pivot(void)
{
//Select the best pivot axis and value for this node
//based on the endpoint data
assert (m_nHitTests >= c_minNodeSize);
//Rotate the axes to encourage (in the event of a tie for best cost)
//that children pivot on different axes than their parents.
int startAxis = m_parent ? ((m_parent->m_pivotAxis + 1) % c_nAxes) : 0;
int bestAxis = startAxis;
float bestValue;
int bestCost;
bool optimalF = findPivot(m_nHitTests,
m_ppEndpoints[bestAxis],
&bestValue,
&bestCost);
for (int i = 1; ((!optimalF) && (i < c_nAxes)); i++)
{
int axis = (i + startAxis) % c_nAxes;
float value;
int cost;
optimalF = findPivot(m_nHitTests,
m_ppEndpoints[axis],
&value, &cost);
if (cost < bestCost)
{
bestAxis = axis;
bestValue = value;
bestCost = cost;
}
}
if (bestCost < 0)
{
//Found a pivot value that did some good ... repivot on the new pivot point
m_pivotAxis = bestAxis;
m_pivotValue = bestValue;
if (!m_children[0])
{
assert (!m_children[1]);
//This node has no children ... create some
m_children[0] = new KDnode(this);
m_children[1] = new KDnode(this);
}
assert (m_children[0] && m_children[1]);
//Reset both children based on the new pivot axis/value.
m_children[0]->reset(false);
m_children[1]->reset(true);
}
else
m_pivotAxis = -1;
}
