int isBalanced(char *exp)
{
int n = 10;
stack_t s;
stackInit(&s, n);
int i;
for (i = 0; i < n; i++)
{
if ((exp[i] == '(') || (exp[i] == '{') || (exp[i] == '['))
{
stackPush(&s, exp[i]);
}
else if ((exp[i] == ')') || (exp[i] == '}') || (exp[i] == ']'))
{
if (stackIsEmpty(&s) || !isPair(s.contents[s.top], exp[i]))
{
return -1;
}
else
stackPop(&s);
}
}
return stackIsEmpty(&s) ? 0 : -1;
}
int main() {
int n;
check(scanf("%d", &n) == 1, "can't read value");
struct Node *nodesP = allocateNodes(n);
for(size_t i = 0; i < n; i++) {
check(scanf("%d", &nodesP[i].value) == 1, "can't read value");
nodesP[i].key = i;
}
stackT *stackP = allocateStack(n);
for(size_t i = n; i > 0; i--) {
while(!stackIsEmpty(stackP) && stackTop(stackP).value < nodesP[i-1].value) {
stackPop(stackP);
}
if(stackIsEmpty(stackP)) {
nodesP[i-1].nearMax = n;
} else {
nodesP[i-1].nearMax = stackTop(stackP).key;
}
stackPush(stackP, nodesP[i-1]);
}
freeStack(stackP);
traverseTree(nodesP, 0, n-1, TRAVERSE_POSTORDER);
printf("\n");
traverseTree(nodesP, 0, n-1, TRAVERSE_INORDER);
printf("\n");
free(nodesP);
return 0;
}
int getOccurence(char* funcName){
//printf("getOccurence\n");
if(symStack == NULL){
return 0;
}
void* backup = stackNew(sizeof(funcVars*));
int occ = 0;
while(!(stackIsEmpty(symStack))){
funcVars* pk = (funcVars*) malloc (sizeof(funcVars));
stackPeek(symStack, &pk);
if(strcmp(pk->funcName,funcName) == 0){
occ = pk->occurence;
break;
}
else{
stackPop(symStack, (&pk));
stackPush(backup, (&pk));
}
}
while(!(stackIsEmpty(backup))){
funcVars* b = (funcVars*) malloc (sizeof(funcVars));
stackPop(backup, (&b));
stackPush(symStack, (&b));
}
return occ;
}
void DFS_in_iterative(btree_node *root) {
stack *s = createStack(20);
btree_node *current = NULL;
bTreeVisitedReset(root);
if (s) {
push(s, root);
while (!stackIsEmpty(s)) {
current = pop(s);
if (!current->left || current->left->visited) {
printf("%c ", current->key);
current->visited = 1;
if (current->right) { // it is not possible that the right child is visited
push(s, current->right);
}
} else {
push(s, current);
push(s, current->left);
}
}
free(s);
} else {
fprintf(stderr, "Unable to create stack\n");
}
}
char *reverseString(char *stringToReverse)
{
int i, j = 0;
char *reversedString;
Stack *stack = stackNew(512);
printf("stack:%p \n", stack);
printf("size:%d, length:%d\n", stack->size, stack->length);
for(i = 0; stringToReverse[i] != '\0'; i++)
{
stackPush(stack , (int)stringToReverse[i]);
printf("%c", stringToReverse[i]);
}
printf("\ni:%d\n", i);
reversedString = malloc(sizeof(char) * (i + 1));
//while(i--)
while(!stackIsEmpty(stack))
{
reversedString[j++] = stackPop(stack);
printf("%c", reversedString[j-1]);
}
reversedString[j] = '\0';
return reversedString;
}
btree_node * top(stack *s) {
btree_node *r = NULL;
if (!stackIsEmpty(s)) {
r = s->els[s->top];
}
return r;
}
stackElement_t stackPop(stack_t *stackP)
{
if (stackIsEmpty(stackP))
exit(EXIT_FAILURE);
return stackP->contents[stackP->top--];
}
uint16_t stackTop(stack *s) {
if (!stackIsEmpty(s)) {
return (*s).data;
} else {
return 0;
}
}
// Returns 0 to indicate error
// Verify that the next stack element exists and is of the given type
// If e==ANY_TYPE, the type check is ommited
static int checkPeek(Elm e) {
if (stackIsEmpty(stack)){
fprintf(stderr,"Illegal document structure, expected %s\n", elmNames[e]);
XML_StopParser(parser, XML_FALSE);
return 0; // error
}
return e==ANY_TYPE ? 1 : checkElementType(stackPeek(stack), e);
}
///////////////////////////////////////////////////////////////////////////////
/// Verify that the next stack element exists and is of the given type.
/// If e==ANY_TYPE, the type check is ommited.
///
///\param e The element.
///\return 0 if there is no error occurred. Otherwise, return 1 to indicate an error.
///////////////////////////////////////////////////////////////////////////////
static int checkPeek(Elm e) {
if (stackIsEmpty(stack)){
printf("Illegal document structure, expected %s\n", elmNames[e]);
XML_StopParser(parser, XML_FALSE);
return 1; // error
}
return e==ANY_TYPE ? 0 : checkElementType(stackPeek(stack), e); //stackPeek() retrieves item at top of stack
}
void *stackPeek(Stack *s)
{
if (stackIsEmpty(s))
{
return NULL;
}
return s->head->data;
}
void stackDrop(stack **s) {
stack *p;
if (!stackIsEmpty((*s))) {
p = (*s);
(*s) = (*(*s)).next;
free(p);
}
}
char findMajority(CDataType m[], unsigned size, CDataType *majority)
{ unsigned i, cnt;
stackInit();
for (stackPush(m[0]), i = 1; i < size; i++) {
if (stackIsEmpty())
stackPush(m[i]);
else if (stackTop() == m[i])
stackPush(m[i]);
else
stackPop();
}
if (stackIsEmpty()) return 0;
for (*majority = stackPop(), i = cnt = 0; i < size; i++)
if (m[i] == *majority)
cnt++;
return(cnt > size / 2);
}
int printBill(Customer *c)
{
if(c==NULL)
{
printf("Error: No customer to process.");
return -1;
}
int i;
time_t invoiceTime;
basketItem *b;
Stack *temp=newStack();
stackInit(temp);
clearScreen();
time(&invoiceTime);
printf("\n\tInvoice id: %s\n\n\tDate/Time: %s\n\n", c->id, ctime(&invoiceTime));
printf("\t| Code\t Item\t\t Price\t Qty.\t Subtotal\t\n");
printLine();
while(stackIsEmpty(c->basket)==0)
{
b=stackPop(c->basket);
if(b!=NULL)
{
printItem(b);
c->total+=subTotal(b);
stackPush(temp, b);
}
}
printf("\n\tTotal number of items: %d", c->quantity);
printf("\n\n\tTotal Payable: %0.2f\n", c->total);
printLine();
while(stackIsEmpty(temp)==0)
stackPush(c->basket, stackPop(temp));
return 0;
}
/* function that returns the top element in the stack without removing it */
stkElement stackPeek(stack *stkPtr)
{
if (stackIsEmpty(stkPtr)) {
fprintf(stderr, "Stack is empty - can't peek.\n");
exit(1);
}
return (stkPtr->top)->element;
}
void halt()
{
printf("Done.\n");
int i;
while(!stackIsEmpty())
printf("%f\n", stackPop());
closeAll();
exit(0);
}
int stackFree(Stack *s)
{
// Remove all elements from stack till it becomes empty.
while(stackIsEmpty(s)==0)
stackPop(s);
// Free memory used by stack.
free(s);
}
int getExecutionFlag(){
if(didFuncEntryExecute == NULL || stackIsEmpty(didFuncEntryExecute)){
return 1;
}
else{
int* execFlag = (int *)malloc(sizeof(int));
stackPeek(didFuncEntryExecute,&execFlag);
return *execFlag;
}
}
uint16_t stackPop(stack **s) {
uint16_t v;
if (!stackIsEmpty((*s))) {
v = stackTop((*s));
stackDrop(s);
return v;
} else {
return 0;
}
}
void stackPop(Stack *s, void *element) {
assert(!stackIsEmpty(s));
node *top;
top = s->head;
s->head = s->head->next;
s->elementsCnt--;
memcpy(element, top->element, s->elementSize);
free(top->element);
free(top);
}
//////////////////////////////////////////////////////////////////////////////////
/// Parse the fmu. The receiver must call freeElement(md) to release AST memory.
///
///\param xmlPath The xml file to be parsed
///\return the root node md of the AST if no error occurred. NULL to indicate failure
/////////////////////////////////////////////////////////////////////////////////
ModelDescription* parse(const char* xmlPath) {
ModelDescription* md = NULL;
FILE *file;
int done = 0;
stack = stackNew(100, 10); // Allocate stack memory
if (checkPointer(stack)) return NULL; // Check if the stack is creatted
parser = XML_ParserCreate(NULL); // Create an parser
if (checkPointer(parser)) return NULL; // Check if the parser is created
XML_SetElementHandler(parser, startElement, endElement); // Set handler for start and end tags
XML_SetCharacterDataHandler(parser, handleData); // Set handler for text
file = fopen(xmlPath, "rb");
if (file == NULL) {
printfError("Cannot open file '%s'\n", xmlPath);
XML_ParserFree(parser); // Free the memory for parser
return NULL; // Failure
}
while (!done) {
int n = fread(text, sizeof(char), XMLBUFSIZE, file); // Read XMLBUFSIZE characters from file
if (n != XMLBUFSIZE) done = 1; // Reach the end of file
if (!XML_Parse(parser, text, n, done)){
printf("Parse error in file %s at line %d:\n%s\n",
xmlPath,
(int)XML_GetCurrentLineNumber(parser),
XML_ErrorString(XML_GetErrorCode(parser)));
while (!stackIsEmpty(stack)) md = stackPop(stack);
if (md) freeElement(md);
cleanup(file);
return NULL; // failure
}
}
md = stackPop(stack);
assert(stackIsEmpty(stack));
cleanup(file);
//printElement(1, md); // Print the element for debugging
return md; // Success if all refs are valid
}
stackData * stackTop(Stack *s)
{
// Return pointer to data at top of stack if stack is not empty.
if(stackIsEmpty(s)==0)
return s->top->data;
else
printf("Error: Stack is empty.\n");
return NULL;
}
CDGNode *pathToList(CDGNode * head) {
assert(NULL != head);
Stack *nodeStack = stackNew(sizeof(CDGNode *));
CDGNode *node;
CDGNode *list = NULL;
postOrder(head, nodeStack);
while (!stackIsEmpty(nodeStack)) {
stackPop(nodeStack, &node);
list = setNextNode(copyToPathNode(newBlankNode(), node), list);
}
return list;
}
int stackPop(stackT *stack, stackElementT *element)
{
if(stackIsEmpty(stack)) {
printf("stack is empty.\n");
return -1;
}
*element = stack->contents[stack->top];
stack->top--;
return 0;
}
//pop
void* stackPop(struct stack *stack){
void *data;
pthread_mutex_lock(&stack->lock);
if(!stackIsEmpty(stack)){
data = stack->row[stack->top];
stack->top--;
pthread_mutex_unlock(&stack->lock);
return data;
}
pthread_mutex_unlock(&stack->lock);
return NULL;
}
void deleteCDG(CDGNode * root) {
if (NULL == root)
return;
CDGNode *node;
Stack *nodeStack = stackNew(sizeof(CDGNode *));
postOrder(root, nodeStack);
while (!stackIsEmpty(nodeStack)) {
stackPop(nodeStack, &node);
deleteNode(node);
}
stackFree(nodeStack);
}
CDGNode *updateCDG(CDGNode * root, int initialize) {
int size = sizeof(CDGNode *);
assert(NULL != root);
Stack *nodeStack = stackNew(size);
CDGNode *node;
postOrder(root, nodeStack);
while (!stackIsEmpty(nodeStack)) {
stackPop(nodeStack, &node);
updateScore(node, initialize);
}
stackFree(nodeStack);
return root;
}
void coverNodes(CDGNode * root, CDGNode * nodes[], int size) {
assert(NULL != root);
if (0 == size)
return;
Stack *nodeStack = stackNew(sizeof(CDGNode *));
CDGNode *node;
postOrder(root, nodeStack);
while (!stackIsEmpty(nodeStack)) {
stackPop(nodeStack, &node);
visitIfExists(node, nodes, size);
}
updateCDG(root, 0);
return;
}
void *stackPop(Stack *s)
{
int data;
if (stackIsEmpty(s))
{
return NULL;
}
StackNode *oldHead = s->head;
s->head = oldHead->next;
data = oldHead->data;
free(oldHead);
s->size--;
return data;
}
// Returns NULL to indicate failure
// Otherwise, return the root node md of the AST.
// The receiver must call freeElement(md) to release AST memory.
ModelDescription* parse(const char* xmlPath) {
ModelDescription* md = NULL;
FILE *file;
int done = 0;
stack = stackNew(100, 10);
if (!checkPointer(stack)) return NULL; // failure
parser = XML_ParserCreate(NULL);
if (!checkPointer(parser)) return NULL; // failure
XML_SetElementHandler(parser, startElement, endElement);
XML_SetCharacterDataHandler(parser, handleData);
file = fopen(xmlPath, "rb");
if (file == NULL) {
fprintf(stderr,"Cannot open file '%s'\n", xmlPath);
XML_ParserFree(parser);
return NULL; // failure
}
while (!done) {
int n = fread(text, sizeof(char), XMLBUFSIZE, file);
if (n != XMLBUFSIZE) done = 1;
if (!XML_Parse(parser, text, n, done)){
fprintf(stderr,"Parse error in file %s at line %d:\n%s\n",
xmlPath,
(int)XML_GetCurrentLineNumber(parser),
XML_ErrorString(XML_GetErrorCode(parser)));
while (! stackIsEmpty(stack)) md = stackPop(stack);
if (md) freeElement(md);
cleanup(file);
return NULL; // failure
}
}
md = stackPop(stack);
assert(stackIsEmpty(stack));
cleanup(file);
//printElement(1, md); // debug
return md; // success if all refs are valid
}
