int kthSmallest(struct TreeNode *root,int k){
int counter = 0;
struct TreeNode *current = root;
while (current || !EMPTY_STACK()){
while (current) {
PUSH_STACK(current);
current = current->left;
}
current = TOP_STACK();
counter++;
if (counter == k)
return current->val;
POP_STACK();
current = current->right;
}
return -1;
}
void pic16c62x_device::retfie()
{
m_PC = POP_STACK();
PCL = m_PC & 0xff;
//INTCON(7)=1;
}
void pic16c62x_device::returns()
{
m_PC = POP_STACK();
PCL = m_PC & 0xff;
}
void pic16c62x_device::retlw()
{
m_W = m_opcode.b.l;
m_PC = POP_STACK();
PCL = m_PC & 0xff;
}
/*
=================
PC_Expression_Parse
=================
*/
static bool PC_Expression_Parse( int handle, float *f )
{
pc_token_t token;
int unmatchedParentheses = 0;
exprList_t stack, fifo;
exprToken_t *value;
bool expectingNumber = true;
#define FULL( a ) ( a.b >= ( MAX_EXPR_ELEMENTS - 1 ) )
#define EMPTY( a ) ( a.f > a.b )
#define PUSH_VAL( a, v ) \
{ \
if( FULL( a ) ) { \
return false; } \
a.b++; \
a.l[ a.b ].type = EXPR_VALUE; \
a.l[ a.b ].u.val = v; \
}
#define PUSH_OP( a, o ) \
{ \
if( FULL( a ) ) { \
return false; } \
a.b++; \
a.l[ a.b ].type = EXPR_OPERATOR; \
a.l[ a.b ].u.op = o; \
}
#define POP_STACK( a ) \
{ \
if( EMPTY( a ) ) { \
return false; } \
value = &a.l[ a.b ]; \
a.b--; \
}
#define PEEK_STACK_OP( a ) ( a.l[ a.b ].u.op )
#define PEEK_STACK_VAL( a ) ( a.l[ a.b ].u.val )
#define POP_FIFO( a ) \
{ \
if( EMPTY( a ) ) { \
return false; } \
value = &a.l[ a.f ]; \
a.f++; \
}
stack.f = fifo.f = 0;
stack.b = fifo.b = -1;
while ( trap_Parse_ReadToken( handle, &token ) )
{
if ( !unmatchedParentheses && token.string[ 0 ] == ')' )
{
break;
}
// Special case to catch negative numbers
if ( expectingNumber && token.string[ 0 ] == '-' )
{
if ( !trap_Parse_ReadToken( handle, &token ) )
{
return false;
}
token.floatvalue = -token.floatvalue;
}
if ( token.type == TT_NUMBER )
{
if ( !expectingNumber )
{
return false;
}
expectingNumber = !expectingNumber;
PUSH_VAL( fifo, token.floatvalue );
}
else
{
switch ( token.string[ 0 ] )
{
case '(':
unmatchedParentheses++;
PUSH_OP( stack, '(' );
break;
case ')':
unmatchedParentheses--;
if ( unmatchedParentheses < 0 )
{
return false;
}
while ( !EMPTY( stack ) && PEEK_STACK_OP( stack ) != '(' )
{
POP_STACK( stack );
PUSH_OP( fifo, value->u.op );
}
// Pop the '('
POP_STACK( stack );
break;
case '*':
case '/':
case '+':
case '-':
if ( expectingNumber )
{
return false;
}
expectingNumber = !expectingNumber;
if ( EMPTY( stack ) )
{
PUSH_OP( stack, token.string[ 0 ] );
}
else
{
while ( !EMPTY( stack ) && OpPrec( token.string[ 0 ] ) < OpPrec( PEEK_STACK_OP( stack ) ) )
{
POP_STACK( stack );
PUSH_OP( fifo, value->u.op );
}
PUSH_OP( stack, token.string[ 0 ] );
}
break;
default:
// Unknown token
return false;
}
}
}
while ( !EMPTY( stack ) )
{
POP_STACK( stack );
PUSH_OP( fifo, value->u.op );
}
while ( !EMPTY( fifo ) )
{
POP_FIFO( fifo );
if ( value->type == EXPR_VALUE )
{
PUSH_VAL( stack, value->u.val );
}
else if ( value->type == EXPR_OPERATOR )
{
char op = value->u.op;
float operand1, operand2, result;
POP_STACK( stack );
operand2 = value->u.val;
POP_STACK( stack );
operand1 = value->u.val;
switch ( op )
{
case '*':
result = operand1 * operand2;
break;
case '/':
result = operand1 / operand2;
break;
case '+':
result = operand1 + operand2;
break;
case '-':
result = operand1 - operand2;
break;
default:
Com_Error( ERR_FATAL, "Unknown operator '%c' in postfix string", op );
}
PUSH_VAL( stack, result );
}
}
POP_STACK( stack );
*f = value->u.val;
return true;
#undef FULL
#undef EMPTY
#undef PUSH_VAL
#undef PUSH_OP
#undef POP_STACK
#undef PEEK_STACK_OP
#undef PEEK_STACK_VAL
#undef POP_FIFO
}
static void retlw(void)
{
R.W = R.opcode.b.l;
R.PC = POP_STACK();
R.PCL = R.PC & 0xff;
}
