Beispiel #1
0
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);
    }

}
Beispiel #2
0
 Node * findMin(Node *t){
     if(t == nullptr)
         return nullptr;
     if(t->left == nullptr)
         return t;
     return findMin(t->left);
 }
Beispiel #3
0
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);
}
Beispiel #4
0
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);
}
Beispiel #5
0
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);
};
Beispiel #8
0
Position findMin(SearchTree T) {
    if(T == NULL)
        return NULL;
    else if(T->left == NULL)
        return T;
    else
        return findMin(T->left);
}
Beispiel #9
0
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 );
}
Beispiel #11
0
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);
}
Beispiel #14
0
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);
}
Beispiel #17
0
position findMin(avlTree T){
    if (T == NULL){
        return NULL;
    }else if(T->left == NULL){
        return T;
    }else{
        return findMin(T);
    }
}
Beispiel #18
0
bool RBTree<KEY>::findMin(KEY& key)
{
    RBNode* pIndex = findMin(m_root);
    if(pIndex == m_null)
        return false;

    key = pIndex->key;
    return true;
}
Beispiel #19
0
/*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
Beispiel #20
0
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;
}
Beispiel #22
0
  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();
}
Beispiel #24
0
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);
}
Beispiel #27
0
 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);
 }
Beispiel #28
0
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;
}