int computeMedian(int list1[],int start1, int end1, int list2[],int start2, int end2) { int s1,e1,s2,e2,m1,m2; s1=start1; s2=start2; e1=end1; e2=end2; if((e1-s1==1)&&(e2-s2==1)) { int medianSum = findMax(list1[0],list2[0])+findMin(list1[1],list2[1]); return medianSum/2; } m1 = FindMedianIndex(list1,s1,e1); m2= FindMedianIndex(list2,s2,e2); if(list1[m1]== list2[m2]) { return list1[m1]; } if(m1>m2) { return computeMedian(list1,s1,m1,list2,m2,e2); } else { return computeMedian(list1,m1,e1,list2,s1,m2); } }
Node * findMin(Node *t){ if(t == nullptr) return nullptr; if(t->left == nullptr) return t; return findMin(t->left); }
void doWorker() { printf("[%s.%d] worker started\n", processor_name, my_rank); // begin parallel code; fill in the missing code here MPI_Status status; int master_id = 0; int i = 0; int n = 0; int start = 0; MPI_Recv(&n, 1, MPI_INT, master_id, 0, MPI_COMM_WORLD, &status); int *array = (int*) malloc(sizeof(int) * n); MPI_Recv(array, n, MPI_INT, master_id, 0, MPI_COMM_WORLD, &status); int size = 6; int *newArray = (int*) malloc(sizeof(int) * n); newArray[0] = calcSum(array, n); newArray[1] = calcMean(array, n); newArray[2] = findMax(array, n); newArray[3] = findMin(array, n); MPI_Send(&n, 1, MPI_INT, worker_id, 0, MPI_COMM_WORLD); MPI_Send(&array[start], n, MPI_INT, worker_id, 0, MPI_COMM_WORLD); // end parallel code; no more code change required printf("[%s.%d] worker completed\n", processor_name, my_rank); }
typename AVL<T>::Node* AVL<T>::findMin(Node* rt) const{ if(rt == NULL) return NULL; if(rt->left == NULL) return rt; return findMin(rt->left); }
void AVL<T>::deleteHelper(T &value, Node* &rt){ if(rt == NULL) return; else if (value < rt->element){ deleteHelper(value, rt->left); if(height(rt->right) - height(rt->left) == 2){ if(rt->right->right == NULL) doubleRotateWithRightChild(rt); else rotateWithRightChild(rt); } rt->deltaHeight = max(height(rt->left), height(rt->right)) +1; } else if (value > rt->element){ deleteHelper(value, rt->right); if(height(rt->left) - height(rt->right) == 2){ if(rt->left->right == NULL) doubleRotateWithLeftChild(rt); else rotateWithLeftChild(rt); } rt->deltaHeight = max(height(rt->left),height(rt->right)) + 1; } else if(rt->left != NULL && rt->right != NULL){ rt->element = findMin(rt->right)->element; deleteHelper(rt->element, rt->right); } else{ Node* old = rt; rt = (rt->left != NULL) ? rt->left : rt->right; delete old; numNodes--; } }
NodoB *BinomialHeap::extractMin(BinomialHeap &b) { NodoB *headNode = *b.heap.begin(); NodoB *minTemp= findMin(*headNode); BinomialHeap *btempExtractMin = new BinomialHeap(this->funcionComparar,this->size); NodoB *nodoHead = myreverse(*minTemp); btempExtractMin->heap.push_front(nodoHead); if(minTemp->siblingIzq && minTemp->siblingDer){ minTemp->siblingDer->siblingIzq = minTemp->siblingIzq; minTemp->siblingIzq->siblingDer = minTemp->siblingDer; }else if(!minTemp->siblingDer){ // si hermano derecho es nulo minTemp->siblingIzq->siblingDer = NULL; }else if(!minTemp->siblingIzq){ minTemp->siblingDer->siblingIzq=NULL; } b.junction(b,*btempExtractMin); qDebug()<<"kike"; return minTemp; //btemp->heap.begin() = minTemp->pChild.reverse(); //*minTemp = NULL; //borrado //b=junction(b,btemp); }
struct BstNode* findMin(struct BstNode* root){ if(root==NULL){ printf("Error!!");} else if(root->left==NULL){return root->data;} return findMin(root->left); };
Position findMin(SearchTree T) { if(T == NULL) return NULL; else if(T->left == NULL) return T; else return findMin(T->left); }
int ts_first(TreeSet *ts, void **element) { TNode *current = findMin(ts->root); if (current == NULL) return 0; *element = current->element; return 1; }
BinaryNode * BinarySearchTree::findMin( BinaryNode *t ) const { if ( t == NULL ) return NULL; if ( t->left == NULL ) return t; return findMin( t->left ); }
VecItem* KdTree::findMin(KdNode* node,int dim,int d){ if(node==0) return 0; int next_d = (d+1)%m_k; if( dim==d ){ if(node->left==0){ return node->item; }else{ return findMin(node->left,dim,next_d); } } VecItem* best = node->item; VecItem* item = findMin(node->left,dim,next_d); if(item && item->getPosition()[dim]<=best->getPosition()[dim]) best = item; item = findMin(node->right,dim,next_d); if(item && item->getPosition()[dim]<=best->getPosition()[dim]) best = item; return best; }
/** * Internal method to find the smallest item in a subtree t. * Return node containing the smallest item. */ BinaryNode * findMin( BinaryNode *t ) const { if( t == NULL ) return NULL; if( t->left == NULL ) return t; return findMin( t->left ); }
int findMin(int arr[], int srt, int lst){ if(lst == srt) return srt; int reset = (lst+srt)/2; //if min = reset if(arr[reset-1] > arr[reset]) return reset; //if min = reset+1 if(arr[reset] > arr[reset+1]) return reset+1; //Go to left/right subarray if(arr[reset] > arr[lst]) return findMin(arr, reset+1, lst); else return findMin(arr, srt, reset-1); }
MinMaxOut findMinMax::findExtrema() const { MinMaxOut res; res.max = findMax(); CCIO::cout << "Maximum eigenvalue : " << res.max << "\n"; res.min = findMin(res.max); CCIO::cout << "Minimum eigenvalue : " << res.min << "\n"; return res; }
// just find the most left node NodePtr findMin(NodePtr& root) const { if (root == nullptr || root->left == nullptr) { return root; } return findMin(root->left); }
void main() { int n,near[10],t[10][2],mincost=0; int i, j,temp=999999,k,l; printf("Enter the no. of nodes : "); scanf("%d",&n); printf("Enter the cost adjacency matrix: \n");//Enter the weight if an edge is present else enter 99999 for(i=1; i<=n; i++) { for(j=i+1; j<=n; j++) { printf("%d-%d : ",i,j); scanf("%d",&cost[i][j]); cost[j][i]=cost[i][j]; if(cost[i][j]<temp) { temp=cost[i][j]; // finding the minimum weighted edge of the tree and storing the respective i and j k=i; l=j; } } } mincost=mincost+temp; for(i=1; i<=n; i++) { if(cost[i][k]<cost[i][l]) near[i]=k; // the near array is used to represent the nearest neighbour of the unselected nodes from the selected nodes else near[i]=l; } near[k]=0; near[l]=0; t[1][1]=k; t[1][2]=l; printf("Traversing edge : %d-%d\n",t[1][1],t[1][2]); //as two vertices are already selected only n-2 more to be selected for(i=2; i<n; i++) { j=findMin(near,n); printf("\n%d:%d\n",i,j); if(j!=-1) { t[i][1]=j; t[i][2]=near[j]; printf("Traversing edge : %d-%d\n",t[i][1],t[i][2]); mincost=mincost+cost[j][near[j]]; near[j]=0; for(k=1; k<=n; k++) { if(near[k]!=0 && cost[k][near[k]]>cost[k][j]) near[k]=j; } } else break; } printf("Minimum cost : %d",mincost); }
position findMin(avlTree T){ if (T == NULL){ return NULL; }else if(T->left == NULL){ return T; }else{ return findMin(T); } }
bool RBTree<KEY>::findMin(KEY& key) { RBNode* pIndex = findMin(m_root); if(pIndex == m_null) return false; key = pIndex->key; return true; }
/*glut keyboard function*/ void keyboard(unsigned char key, int x, int y) { switch (key) { case 0x1B: case'q': case 'Q': exit(0); break; case 'n': case 'N': create_vertex(); break; case 'h': case 'H': printarr(); break; case 'c': case 'C': quick_hull(); break; case 't': case 'T': quickHull_Top(allPoints[findMin()],allPoints[findMax()]); break; case 'b': case 'B': quickHull_Bottom(allPoints[findMin()],allPoints[findMax()]); break; case 'p': case 'P': quick_hull_peel(); break; case 'k': case 'K': display_hull(); break; case 'r': case 'R': reset(); break; } }//keyboard
int ts_pollFirst(TreeSet *ts, void **element) { TNode *node = findMin(ts->root); int done = 0; if (node == NULL) return 0; *element = node->element; ts->root = remove(ts->root, node->element, &done, ts->cmp, NULL); return 1; }
// find the minimum, (Attention for its non-recursion implementation ) BinarySearchTree findMin(BinarySearchTree root) { if(root) { if(root->left) return findMin(root->left); else return root; } return NULL; }
BinaryNode * BinarySearchTree::findMin( BinaryNode *t ) const { if ( t == NULL ) return NULL; LeftLinksFollowed++; if ( t->left == NULL ) return t; return findMin( t->left ); }
void doDelete(){ printf("\n\n\n"); int toDelete; struct node *dNode = NULL, *predecessor = NULL, *successor = NULL, *temp = NULL; printf("Node to delete: "); scanf("%d",&toDelete); dNode = searchNode(tRoot,toDelete); if (dNode == NULL) printf("The node does not exist!\n"); else { printf("The node is deleted!\n"); temp = dNode; if (dNode->left == NULL && dNode->right == NULL){ // Case 1 : leaf if (tRoot == dNode) tRoot = NULL; else { if(dNode->parent->right == dNode) dNode->parent->right = NULL; else dNode->parent->left = NULL; } dNode = NULL; } else if (dNode->left != NULL){ predecessor = findMax(dNode->left); // Get predecessor // update predecessor parent if (predecessor->parent->left != NULL) { if (predecessor->parent->left->value == predecessor->value) predecessor->parent->left = NULL; } else predecessor->parent->right = NULL; // swap with predecessor dNode->value = predecessor->value; free(predecessor); } else { successor = findMin(dNode->right); // Get successor // update successor parent if (successor->parent->left != NULL) { if (successor->parent->left->value == successor->value) successor->parent->left = NULL; } else successor->parent->right = NULL; // swap with predecessor dNode->value = successor->value; free(successor); } if (temp->parent != NULL) balanceCheck(temp->parent); temp = NULL; printf("\n--Balance Factor Sheet--\n"); if (tRoot != NULL) bFactorInorder(tRoot); else printf("\nThe tree is empty!\n"); } printf("\n\n\n"); showMenu(); }
void selectionSort(int *parr,int arrLen) { int i,j,temp; for(i=0;i<arrLen;i++) { j=findMin(parr,i,arrLen-1); temp=parr[j]; parr[j]=parr[i]; parr[i]=temp; } }
int main(void) { int max, min; init(m,n); printf("Масивът:\n"); print(m,n); printf("Максимален елемент: %d\n", findMax(m,n)); printf("Минимален елемент: %d\n", findMin(m,n)); findMinMax(&min, &max, m, n); printf("Минимален и максимален елемент едновременно: %d %d\n", min, max); printf("Втори по големина елемент: %d\n", findSecondMax(m,n)); return 0; }
void shiftRight(CBSTree T,int root){ if(isEmpty(T,root)){ return; } shiftRight(T,root*2+1); if(!isEmpty(T,root*2+1)){ T->data[findMin(T,root*2+1)]=T->data[root]; T->data[root]=T->data[findMax(T,root*2)]; } shiftRight(T,root*2); }
int findMin(vector<int>& nums, int left, int right){ //base case 1 if (left==right) return nums[left]; //base case 2 else if (right-left==1) return min(nums[left],nums[right]); //base case 3 //becase if left < right, then array is not rotated if (nums[left]<nums[right]) return nums[left]; //recursive case int mid = (left+right)/2; if (nums[mid]<nums[left]) return findMin(nums, left, mid); else return findMin(nums, mid, right); }
void DataGrapher::updateScaleInterval() { double min_val = 0; double max_val = 0; if (m_draw_best) { min_val = findMin(bestval); } else if (m_draw_average) { min_val = findMin(avgval); } else if (m_draw_worst) { min_val = findMin(worstval); } if (m_draw_worst) { max_val = findMax(worstval); } else if (m_draw_average) { max_val =findMax(avgval); } else if (m_draw_best) { max_val = findMax(bestval); } yMap.setScaleInterval(min_val, max_val); }
void selectionList_sort( int *t, int size ) { int i = 0; List *head = calloc(1, sizeof(List)); List *indice; head = copyTabInList(t, size, head); indice = head; indice = findMin(indice); t[i] = indice ->valeur; while(indice->suiv->suiv != NULL) { indice->suiv = findMin(indice->suiv); t[i] = indice->valeur; indice = indice->suiv; ++i; } t[i] = indice->valeur; head =findMin(head); freeListe(head); }
int main(){ int n,k; while( scanf("%d%d",&n,&k)==2 ){ int ans=2e9; for(int i=0;i<n;i++) scanf("%s",num[i]); for(int i=0;i<k;i++) S[i]=i; for(int i=0;i<n;i++){ for(int j=0;j<k;j++) C[i][j]=num[i][S[j]]; C[i][k]='\0'; } int max=findMax(n,k); int min=findMin(n,k); if( ans>max-min ) ans=max-min; while( true ){ int i,j; for(i=k-2;i>=0&&S[i]>S[i+1];i--); if( i<0 ) break; for(j=k-1;j>i&&S[i]>S[j];j--); SWAP(S[i],S[j]); for(i++,j=k-1;i<j;i++,j--) SWAP(S[i],S[j]); for(int i=0;i<n;i++){ for(int j=0;j<k;j++) C[i][j]=num[i][S[j]]; C[i][k]='\0'; } int max=findMax(n,k); int min=findMin(n,k); if( ans>max-min ) ans=max-min; } printf("%d\n",ans); } return 0; }