C / C++ / MFC

double floor(double x);
float floor(float x); // C++ only
long double floor(long double x); // C++ only
float floorf(float x);

-Malli...!

inline int iround(double v)
{
	int retval;
	__asm fld qword ptr [v]
	__asm fistp dword ptr [retval]
	return retval;
}

class node
{
	node *m_pLeftNode;
	node *m_pRightNode;

	int m_iData;

public :

	PostOrderTravarse()
	{
		m_pLeftNode->PostOrderTravarse();	//Travarse the right tree
		m_pRightNode->PostOrderTravarse();	//Travarse the left tree

		cout<<m_iData; 				// Visiting Node;
	}	

	PreOrderTravarse()
	{
		cout<<m_iData; 				// Visiting Node;

		m_pLeftNode->PreOrderTravarse();	//Travarse the right tree
		m_pRightNode->PreOrderTravarse();	//Travarse the left tree
	}	

	InOrderTravarse()
	{
		m_pLeftNode->InOrderTravarse();		//Travarse the right tree
		cout<<m_iData; 				// Visiting Node;
		m_pRightNode->InOrderTravarse();	//Travarse the left tree
	}	
};

-Malli...!

aksgh wrote:

Its a huffman tree.

typedef struct _node_info {
  int is_leaf;
  char value;
}node_info;

typedef struct _node {
  node_info inf;
  node* l;
  node* r;
} node;

// returns the root of the tree, from an array of node_info's structs, that
// represents the preorder traversal of the huffman tree. we assume a global stack s
// initially empty
node* built_tree(node_info* preorder_array, int preorder_array_size)
{
  node *root, *n;
  int i;
  root = malloc(sizeof(node));
  stack_push(s, root);
  for (i = 0; i < preorder_array_size; i++) {
    assert(!stack_empty(s));
    n = stack_pop(s);
    n->inf = preorder_array[i];
    if (!n->inf.is_leaf) {
      n->r = malloc(sizeof(node));
      stack_push(s, n->r);
      n->l = malloc(sizeof(node));
      stack_push(s, n->l);
    }
  }
  assert(stack_empty(s));
  return root;
}