Пример #1
0
int maxHeight(treeNode *p)
{
    if (!p) return 0;
    int left_height = maxHeight(p->left);
    int right_height = maxHeight(p->right);
    return (left_height > right_height) ? left_height + 1 : right_height + 1;
}
Пример #2
0
 int maxHeight(TreeNode *root)
 {
     if(!root)
         return 0;
     if(!root->left && !root->right)
         return 1;
     return 1 + max(maxHeight(root->left), maxHeight(root->right));
 }
Пример #3
0
// Vrátí výšku celého stromu
int maxHeight(struct node **root)
{
	if(*root==0)
		return 0;

	int mLeft = maxHeight(&(*root)->left);
	int mRight = maxHeight(&(*root)->right);
	return (mLeft > mRight? mLeft : mRight) + 1;
}
Пример #4
0
 bool isBalanced(TreeNode *root) {
     // Start typing your C/C++ solution below
     // DO NOT write int main() function
     if(!root)
         return true;
     int diff = abs(maxHeight(root->left) - maxHeight(root->right));
     if(diff > 1)
         return false;
     return isBalanced(root->left) && isBalanced(root->right);
 }
Пример #5
0
/* Calculate the height of the tree. */
int maxHeight(node *root){
	if (root == NULL){
		return 0;
	} 
	else{
		int lh = maxHeight(root->left);
		int rh = maxHeight(root->right);
		return 1 + (lh > rh ? lh : rh);
	}
}
Пример #6
0
//---------------------------------------------------------------------------
// maxHeight
// Calculates the height of any Node as defined by the furthest Node from it
// in its subtree using recursion.
int BinTree::maxHeight(Node* item) const
{
    if (!item) // item not found
        return 0;
    int left_height = maxHeight(item->left); // search left
    int right_height = maxHeight(item->right); // search right
    // if left height is greater than right, add 1 to left_height, and
    // vice versa
    return (left_height > right_height) ? left_height + 1 : right_height + 1;
}
Пример #7
0
int maxHeight(Tree * tree){
    
    if (tree == NULL)
        return 0;
    int left = maxHeight(getLeftSubtree(tree));
    int right = maxHeight(getRightSubtree(tree));
    if (left < right)
        return right + 1;
    else
        return left + 1;
}
Пример #8
0
//---------------------------------------------------------------------------
// getHeight
// Returns the height of a Node in given BST, with the definition that a leaf
// is of level 1, the next Node up is level 2, etc.  This definition says
// that for a Node that is not a leaf, you count up from 1 from the lowest
// Node in its subtree.
int BinTree::getHeight(const NodeData& item) const
{
    bool found = false; // true if data is found
    Node *temp = root;
    int heightOfTree;
    if (isEmpty()) // depth is 0 if tree is empty
        return 0;
    while((temp!= NULL))
    {
        if (item == *temp->data) // calculate height of subtree
        {
            found = true;
            heightOfTree = maxHeight(temp);
            break;
        }
        else if(item < *temp->data) // search left
            temp = temp->left;
        else
            temp = temp->right; // search right
    }
    if (!found) //No data match, return 0
        return 0;
    if (temp->left == NULL && temp->right == NULL)
        return 1;
    return heightOfTree;
}
Пример #9
0
int maxHeight(struct node* node) {
  
  if (!node)
    return 0;
  
  int left_height = maxHeight(node->left);
  int right_height = maxHeight(node->right);
  
  if (node->left ==NULL && node->right==NULL)
  {
    return 0;
  }
  
  return (left_height > right_height) ? left_height + 1 : right_height + 1;
  
}
Пример #10
0
// @TODO dopsat funkci pro vytvoření stromu, aby byl veškerý kód ve funkcích
int main(int argc, char **argv)
{
	struct node *tree = 0;

	add(1, &tree);
	add(2, &tree);
	add(3, &tree);
	add(4, &tree);
	add(5, &tree);
	add(6, &tree);
	add(7, &tree);

	printf("Height: %i\n", maxHeight(&tree));

	printf("inOrderWalk:   ");
	inOrderWalk(&tree);
	printf("\n");

	printf("preOrderWalk:  ");
	preOrderWalk(&tree);
	printf("\n");

	printf("postOrderWalk: ");
	postOrderWalk(&tree);
	printf("\n");
	return 0;
}
Пример #11
0
 /**
  * Return some information about the CMP. 
  *
  * @return  A std::string that represents this object.
  **/
 std::string toString() const
     {
     std::string s("CMP\n");
     s += "- graph size: " + mtools::toString(graphSize()) + "\n";
     s += "- number of clusters: " + mtools::toString(nbClusters()) + "\n";
     s += "   - number of trivial site: " + mtools::toString(nbTrivialClusters()) + "\n";
     s += "   - number of single clusters: " + mtools::toString(nbIsolatedClusters()) + "\n";
     s += "   - number of compounded clusters: " + mtools::toString(nbNonAtomicClusters()) + "\n";
     s += "- maximum height: " + mtools::toString(maxHeight()) + "\n";
     auto it = clusterActiveSet.rbegin();
     s += "- Largest cluster:\n";
     if (isMasterCluster()) { s += "    - *** MASTER CLUSTER : contains ever other cluster in its action radius ***\n"; }
     s += "    - size: " + mtools::toString((*it)->size) + "\n";
     s += "    - weight: " + mtools::toString((*it)->weight) + "\n";
     s += "    - height: " + mtools::toString((*it)->height) + "\n";
     if (clusterActiveSet.size() > 1) 
         {
         it++;
         s += "- 2nd largest cluster:\n";
         s += "    - size: " + mtools::toString((*it)->size) + "\n";
         s += "    - weight: " + mtools::toString((*it)->weight) + "\n";
         s += "    - height: " + mtools::toString((*it)->height) + "\n";
         }
     if (clusterActiveSet.size() > 2)
         {
         it++;
         s += "- 3th largest cluster:\n";
         s += "    - size: " + mtools::toString((*it)->size) + "\n";
         s += "    - weight: " + mtools::toString((*it)->weight) + "\n";
         s += "    - height: " + mtools::toString((*it)->height) + "\n";
         }
     return s;
     }
Пример #12
0
int main(int argc, char const* argv[])
{
  /** the size of our vectors */
  const size_t N = 2;

  /** the size of gravity */
  const double G = 9.81;

  double initVel[N];
	double maxH[N];

  double d;

  //here

	makeInitVel(1,M_PI/4,initVel);

	d = maxDistance(initVel,G,N);
	maxHeight(initVel,G,maxH,N);

	printf("Max Distance: %f\n",d);
	printf("Max Height:\n");
	printf("  [ %f %f]\n",maxH[0],maxH[1]);

  return 0;
}
// Pretty formatting of a binary tree to the output stream
// @ param
// level  Control how wide you want the tree to sparse (eg, level 1 has the minimum space between nodes, while level 2 has a larger space between nodes)
// indentSpace  Change this to add some indent space to the left (eg, indentSpace of 0 means the lowest level of the left node will stick to the left margin)
void printPretty(BinaryTree *root, int level, int indentSpace, ostream& out) {
	int h = maxHeight(root);
	int nodesInThisLevel = 1;

	int branchLen = 2 * ((int)pow(2.0, h) - 1) - (3 - level)*(int)pow(2.0, h - 1);  // eq of the length of branch for each node of each level
	int nodeSpaceLen = 2 + (level + 1)*(int)pow(2.0, h);  // distance between left neighbor node's right arm and right neighbor node's left arm
	int startLen = branchLen + (3 - level) + indentSpace;  // starting space to the first node to print of each level (for the left most node of each level only)

	deque<BinaryTree*> nodesQueue;
	nodesQueue.push_back(root);
	for (int r = 1; r < h; r++) {
		printBranches(branchLen, nodeSpaceLen, startLen, nodesInThisLevel, nodesQueue, out);
		branchLen = branchLen / 2 - 1;
		nodeSpaceLen = nodeSpaceLen / 2 + 1;
		startLen = branchLen + (3 - level) + indentSpace;
		printNodes(branchLen, nodeSpaceLen, startLen, nodesInThisLevel, nodesQueue, out);

		for (int i = 0; i < nodesInThisLevel; i++) {
			BinaryTree *currNode = nodesQueue.front();
			nodesQueue.pop_front();
			if (currNode) {
				nodesQueue.push_back(currNode->left);
				nodesQueue.push_back(currNode->right);
			}
			else {
				nodesQueue.push_back(NULL);
				nodesQueue.push_back(NULL);
			}
		}
		nodesInThisLevel *= 2;
	}
	printBranches(branchLen, nodeSpaceLen, startLen, nodesInThisLevel, nodesQueue, out);
	printLeaves(indentSpace, level, nodesInThisLevel, nodesQueue, out);
}
Пример #14
0
int main(){
    
    int64_t n; scanf("%lld", &n);
    std::vector<std::pair<int64_t, std::pair<int64_t, int64_t> > > v(n);
    for(int64_t p = 0; p < n; p++){
        int64_t a, b, h; scanf("%lld %lld %lld", &a, &b, &h); 
        v[p].first = b;
        v[p].second.first = a;
        v[p].second.second = h;
    }
    
    sort(v.rbegin(), v.rend());
    
    std::stack<int64_t> s;
    int64_t height(0), maxHeight(0);
    for(int64_t p = 0; p < n; p++){
        while(!s.empty() && v[p].first <= v[s.top()].second.first){height -= v[s.top()].second.second; s.pop();}
        s.push(p);
        height += v[p].second.second;
        maxHeight = (maxHeight > height) ? maxHeight : height;
    }
    
    printf("%lld\n", maxHeight);
    
    return 0;
}
/*
	Debugging/Testing
*/
int main(int argc, char *argv[]) {
	Node *tree = createNode(3);
	Node *tmp = createNode(2, tree, true);
	createNode(1, tmp, true);
	createNode(5, tree, false);
	// Inorder
	inorderR(tree);
	std::cout << std::endl;
	inorder(tree);
	std::cout << std::endl;
	// Preorder
	preorderR(tree);
	std::cout << std::endl;
	preorder(tree);
	std::cout << std::endl;
	// Postorder
	postorderR(tree);
	std::cout << std::endl;
	postorder(tree);
	std::cout << std::endl;
	// Max Height
	std::cout << "Max Height R: " << maxHeightR(tree) << std::endl;
	std::cout << "Max Height I: " << maxHeight(tree) << std::endl;
	return 0;
}
 vector<vector<int> > levelOrderBottom(TreeNode *root) {
     vector < vector<int> > result;
     if(!root) return result;
     int height = maxHeight(root);
     result.resize(height);
     queue < pair <TreeNode*, int> > Q;
     int prev_level = 0, curr_level;
     Q.push(make_pair(root, 1));
     vector <int> container;
     while(!Q.empty()) {
         pair <TreeNode*, int> node = Q.front();
         Q.pop();
         TreeNode *curr = node.first;
         curr_level = node.second;
         if(curr_level > prev_level) {
             if(container.size() > 0) {
                 result[--height] = container;
             }
             container.clear();
         }
         container.push_back(curr->val);
         
         if(curr->left) Q.push(make_pair(curr->left, curr_level + 1));
         if(curr->right) Q.push(make_pair(curr->right, curr_level + 1));
         
         prev_level = curr_level;
     }
     if(container.size() > 0) result[--height] = container;
     
     return result;
 }
Пример #17
0
/**
 * Removes full rows
 * */
short removeRows(Game* game) {
	short i, j, k, l;
	short counter = 0, rowCounter = 0;
	short gameHeight = maxHeight(game);
	
	for(i=T_HEIGHT-1; i>=gameHeight; i--) {
		j=0;
		counter = 0;
		while(getBitboardValue(game->array[i], j) !=0 && j < T_WIDTH) {
			j++;
			counter++;
		}
		
		if(counter == T_WIDTH) {
			rowCounter++;
			
			for(k=i; k>=gameHeight-1; k--) {
				for(l=0; l<T_WIDTH; l++)
					game->array[k] = setBitboardValue(game->array[k], l, getBitboardValue(game->array[k-1], l));
			}
			i++; // incrementing i because all went one case down
		}
	}
	return rowCounter;
}
Пример #18
0
 int maxHeight(TreeNode* node) {
     if (node == NULL) {
         return 0;
     }
     int leftChildHeight = maxHeight(node->left);
     if (leftChildHeight == -1) {
         return -1;
     }
     int rightChildHeight = maxHeight(node->right);
     if (rightChildHeight == -1) {
         return -1;
     }
     if (abs(leftChildHeight - rightChildHeight) > 1) {
         return -1;
     }
     return max(leftChildHeight, rightChildHeight) + 1;
 }
Пример #19
0
int main(){
	int num, i, n, c;
	/* Prompt the user to input the size. */
	printf("Please enter the number of nodes in the tree: ");
	scanf("%d", &num);
	while (num < 1) {
		printf("Invalid, please make sure the number is greater than 0.\n");
		printf("Please enter the number of nodes in the tree: ");
		scanf("%d", &num);
	}
	node *root = NULL;
	for (i = 0; i < num; i++){
		/* Prompt the user to input the value. */
		printf("Please enter an integer: ");
		scanf("%d", &n);
		insertNode(&root, createNode(n));
	}
	/* Constantly ask the user to choose an option. */
	while (1){
		printf("0 -- Exit the program.\n");
      		printf("1 -- Print the inorder traversal of the Tree.\n");
       		printf("2 -- Print the preorder traversal of the Tree.\n");
       		printf("3 -- Print the size(no. of nodes) in the Tree.\n");
       		printf("4 -- Print the maximum height of the Tree.\n");
       		printf("5 -- Print the minimum value in the Tree.\n");
       		printf("Please choose an option among 0-5: ");
		scanf("%d", &c);
		switch(c){
		case 0:
			return 0;
		case 1:
			inOrder(root);
			printf("\n");
			break;
		case 2:
			preOrder(root);
			printf("\n");
			break;
		case 3:
			printf("There are %d nodes in tree.\n", sizeOfTree(root));
			break;
		case 4:
			printf("Maximum height of the tree is %d.\n", maxHeight(root));
			break;
		case 5:
			printf("Minimum value in the tree is %d.\n", minValue(root));
			break;
		default:
           		printf("Invalid choice. try again!!\n");
           		break;
       		}
		printf("\n");
	}
	return 0;
}
Пример #20
0
int heightRight( struct node* node) // Find the # of leaves in the right subtree
{
    
    int right_height = maxHeight(node->right);

    if (node == NULL)
        return 0;
    else
        return right_height;
    
}
Пример #21
0
/**
 * Update the AWT and Swing size information due to change in internal
 * state, e.g. if one or more of the icons that might be displayed
 * is changed
 */
/*public*/ void PositionableJPanel::updateSize() {
//    invalidate();
    setSize(maxWidth(), maxHeight());
    if (debug) {
//            javax.swing.JTextField text = (javax.swing.JTextField)_popupUtil->_textComponent;
//        log->debug("updateSize: "+_popupUtil->toString()+
//                  ", text: w="+getFontMetrics(_popupUtil->getFont()).stringWidth(_popupUtil->getText())+
//                  "h="+getFontMetrics(_popupUtil->getFont()).getHeight());
    }
    //validate();
    repaint();
}
Пример #22
0
int heightLeft( struct node* node) // Find the # of leaves in the left subtree
{

  int left_height = maxHeight(node->left);
  
  if (node==NULL)
    return(0);

    else
        return  left_height;
    
  
}
Пример #23
0
// driver program to test indenticalTrees function
int main()
{

struct node * root1 = newNode(1);

root1->left = newNode(2);
root1->right = newNode(3);
struct node * root2 = newNode(1);

int s = maxHeight(root1);
//int s2 = size(root2);
printf("%d\n",s);
//printf("%d\n",s2);



}
Пример #24
0
void printT(treeNode *tree)
{
    char s[consoleY+1][consoleX+1];
    int i, j, height = maxHeight(tree) * 2;
    if (!height) {
        puts("Empty!");
        return;
    }
    memset(s, 32, sizeof(s));
    _printT(tree, 0, 0, 0, s);
    for (i = 0; i < height; ++i) {
        putchar(10);
        for (j = 0; j < consoleX; ++j)
            putchar(s[i][j]);
    }
    puts("");
}
Пример #25
0
SurfaceItem::SurfaceItem(QWaylandSurface *surface)
    : m_depthOffset(0)
    , m_opacity(0.55)
    , m_textureId(0)
    , m_height(maxHeight() * 0.99)
    , m_focus(false)
    , m_mipmap(true)
{
    setSurface(surface);
    m_time.start();
    connect(surface, &QWaylandSurface::damaged, this, &SurfaceItem::surfaceDamaged);
    connect(surface, &QWaylandSurface::sizeChanged, this, &SurfaceItem::sizeChanged);
    //m_dirty = QRect(QPoint(), surface->size());

    qDebug() << "surface size:" << surface->size();
    m_opacityAnimation = new QPropertyAnimation(this, "opacity");
    m_opacityAnimation->setDuration(400);
    sizeChanged();
}
void displayOBSTInfo(OBSTComputation *obstComp)
{
	BinaryTree *obst = obstComp->getOBST();
	double timeTaken = obstComp->getTimeTaken();
	double averageCase = obstComp->getAverageTime();
	int worstCase = maxHeight(obst) - 1;
	double stdDev = obstComp->getStandardDeviation();
	double eOfXSquared = obstComp->getEOfXSquared();
	queue<int> levelOrderTraversal = levelOrderTraversalWrapper(obst, 7);

	cout << "Level Order Traversal: ";
	displayQueue(levelOrderTraversal);
	cout << "Program completed in " << timeTaken << " seconds" << endl
		<< "Total Frequencies: " << obstComp->getTotalFrequencies() << endl
		<< "Total Nodes: " << obstComp->getTotalNodes() << endl
		<< "Best Case: 1" << endl
		<< "Average Case: " << setprecision(3) << averageCase << endl
		<< "Worst Case: " << worstCase << endl
		<< "E[X^2] = " << eOfXSquared << endl
		<< "Standard Deviation: " << stdDev << endl
		<< "Sum of Frequencies: " << obstComp->getSumOfFrequencies() << endl;
}
Пример #27
0
void SurfaceItem::setHeight(qreal height)
{
    m_height = qBound(qreal(0.4), height, maxHeight());
}
// Find the maximum height of the binary tree
int maxHeight(BinaryTree *p) {
	if (!p) return 0;
	int leftHeight = maxHeight(p->left);
	int rightHeight = maxHeight(p->right);
	return (leftHeight > rightHeight) ? leftHeight + 1 : rightHeight + 1;
}
bool ExynosMPP::isProcessingSupported(hwc_layer_1_t &layer, int format,
        bool local_path, int loc_out_downscale)
{
    if (local_path && loc_out_downscale == 0)
        return false;

    if (isUsingMSC() && local_path)
        return false;

    private_handle_t *handle = private_handle_t::dynamicCast(layer.handle);

    int max_w = maxWidth(layer);
    int max_h = maxHeight(layer);
    int min_w = minWidth(layer);
    int min_h = minHeight(layer);
    int crop_max_w = 0;
    int crop_max_h = 0;

    if (isUsingMSC()) {
        crop_max_w = 8192;
        crop_max_h = 8192;
    } else {
        crop_max_w = isRotated(layer) ? 2016 : 4800;
        crop_max_h = isRotated(layer) ? 2016 : 3344;
    }
    int crop_min_w = isRotated(layer) ? 32: 64;
    int crop_min_h = isRotated(layer) ? 64: 32;

    int srcAlign = sourceAlign(handle->format);
    int dstAlign;
    if (local_path)
        dstAlign = destinationAlign(HAL_PIXEL_FORMAT_EXYNOS_YCbCr_420_SP_M);
    else
        dstAlign = destinationAlign(HAL_PIXEL_FORMAT_BGRA_8888);

    int maxDstWidth;
    int maxDstHeight;

    bool rot90or270 = !!(layer.transform & HAL_TRANSFORM_ROT_90);
    // n.b.: HAL_TRANSFORM_ROT_270 = HAL_TRANSFORM_ROT_90 |
    //                               HAL_TRANSFORM_ROT_180

    int src_w = WIDTH(layer.sourceCropf), src_h = HEIGHT(layer.sourceCropf);
    int dest_w, dest_h;
    if (rot90or270) {
        dest_w = HEIGHT(layer.displayFrame);
        dest_h = WIDTH(layer.displayFrame);
    } else {
        dest_w = WIDTH(layer.displayFrame);
        dest_h = HEIGHT(layer.displayFrame);
    }

    if (getDrmMode(handle->flags) != NO_DRM)
        alignCropAndCenter(dest_w, dest_h, NULL,
                GSC_DST_CROP_W_ALIGNMENT_RGB888);

    int max_downscale = local_path ? loc_out_downscale : 16;
    maxDstWidth = 2560;
    maxDstHeight = 1600;
    int max_upscale = 8;

    /* check whether GSC can handle with local path */
    if (local_path) {
        /* GSC OTF can't handle rot90 or rot270 */
        if (!rotationSupported(rot90or270))
            return 0;
        /*
         * if display co-ordinates are out of the lcd resolution,
         * skip that scenario to OpenGL.
         * GSC OTF can't handle such scenarios.
         */
        if (layer.displayFrame.left < 0 || layer.displayFrame.top < 0 ||
            layer.displayFrame.right > mDisplay->mXres || layer.displayFrame.bottom > mDisplay->mYres)
            return 0;

        /* GSC OTF can't handle GRALLOC_USAGE_PROTECTED layer */
        if (getDrmMode(handle->flags) != NO_DRM)
            return 0;

        return isFormatSupportedByGsc(format) &&
            isFormatSupportedByGscOtf(format) &&
            mDisplay->mHwc->mS3DMode == S3D_MODE_DISABLED &&
            paritySupported(dest_w, dest_h) &&
            handle->stride <= max_w &&
            src_w <= dest_w * max_downscale &&
            dest_w <= maxDstWidth &&
            dest_w <= src_w * max_upscale &&
            handle->vstride <= max_h &&
            src_h <= dest_h * max_downscale &&
            dest_h <= maxDstHeight &&
            dest_h <= src_h * max_upscale &&
            src_w <= crop_max_w &&
            src_h <= crop_max_h &&
            src_w >= crop_min_w &&
            src_h >= crop_min_h;
     }

    bool need_gsc_op_twice = false;
    if (getDrmMode(handle->flags) != NO_DRM) {
        need_gsc_op_twice = ((dest_w > src_w * max_upscale) ||
                                   (dest_h > src_h * max_upscale)) ? true : false;
        if (need_gsc_op_twice)
            max_upscale = 8 * 8;
    } else {
        if (!mDisplay->mHasDrmSurface) {
            need_gsc_op_twice = false;
            max_upscale = 8;
        }
    }

    if (getDrmMode(handle->flags) != NO_DRM) {
        /* make even for gscaler */
        layer.sourceCropf.top = (unsigned int)layer.sourceCropf.top & ~1;
        layer.sourceCropf.left = (unsigned int)layer.sourceCropf.left & ~1;
        layer.sourceCropf.bottom = (unsigned int)layer.sourceCropf.bottom & ~1;
        layer.sourceCropf.right = (unsigned int)layer.sourceCropf.right & ~1;
    }

    /* check whether GSC can handle with M2M */
    return isFormatSupportedByGsc(format) &&
            src_w >= min_w &&
            src_h >= min_h &&
            isDstCropWidthAligned(dest_w) &&
            handle->stride <= max_w &&
            handle->stride % srcAlign == 0 &&
            src_w < dest_w * max_downscale &&
            dest_w <= src_w * max_upscale &&
            handle->vstride <= max_h &&
            handle->vstride % srcAlign == 0 &&
            src_h < dest_h * max_downscale &&
            dest_h <= src_h * max_upscale &&
            // per 46.2
            (!rot90or270 || (unsigned int)layer.sourceCropf.top % 2 == 0) &&
            (!rot90or270 || (unsigned int)layer.sourceCropf.left % 2 == 0) &&
            src_w <= crop_max_w &&
            src_h <= crop_max_h &&
            src_w >= crop_min_w &&
            src_h >= crop_min_h;
            // per 46.3.1.6
}
Пример #30
0
 bool isBalanced(TreeNode* root) {
     return maxHeight(root) != -1;
 }