void ABPInOrderRep (PtABPNode proot) /* travessia em in-ordem repetitiva - repetitive in-order traversal */ { PtABPNode Node = proot; PtStack Stack; if (proot == NULL) { Error = ABP_EMPTY; return; } /* arvore vazia - empty tree */ if ((Stack = StackCreate (sizeof (PtABPNode))) == NULL) { Error = NO_MEM ; return; } StackPush (Stack, &Node); /* armazenar a raiz - storing the root */ while (!StackIsEmpty (Stack)) { if (Node != NULL) /* não é um no externo - not an external node */ { Node = Node->PtLeft; StackPush (Stack, &Node); /* subarvore esquerda - left subtree */ } else /* é um no externo */ { StackPop (Stack, &Node); /* retirar e descartar o no externo - retrieve and ignore the external node */ if (!StackIsEmpty (Stack)) { StackPop (Stack, &Node); /* recuperar o no anterior - retrieve and preview node */ printf ("%d ", Node->Elem); /* imprimir o elemento - printing the element */ Node = Node->PtRight; /* subarvore direita - right subtree */ StackPush (Stack, &Node); } } } StackDestroy (&Stack); /* destruir a pilha - releasing the stack */ Error = OK; }
bool check(int a[],int num){ Stack text; InitializeStack(&text); Item temp; int read_edx= num; //指示此时什么值应该被弹出 int arr_edx = num-1; //指示数组下标,数组反向读取 while(num--){ if(StackIsFull(&text)){ return false; }else{ temp.data = a[arr_edx]; Push(temp,&text); while(!(StackIsEmpty(&text)) && text.end->item.data == read_edx ){ Pop(&text); read_edx--; } } arr_edx--; } if(StackIsEmpty(&text)){ return true; }else{ return false; } }
int dequeue (queue_t * queue,DATA_TYPE * data){ if( StackIsEmpty((queue->s1)) && StackIsEmpty((queue->s2)) ) return 0; if(StackIsEmpty((queue->s2))){ DATA_TYPE tempdata; while(stackPop((queue->s1),&tempdata)) stackPush((queue->s2),tempdata); } stackPop((queue->s2),data); return 1; }
int ABPMultSum (PtABPNode proot, int pvalue) { PtABPNode node = proot; PtStack stack; int sum = 0; if (proot == NULL) { Error = ABP_EMPTY; return -1; } if ((stack = StackCreate(sizeof(PtABPNode))) == NULL) { Error = NO_MEM; return -1; } StackPush(stack, &node); while (!StackIsEmpty(stack)) { StackPop(stack, &node); if (!(node->Elem % pvalue)) sum += node->Elem; if (node->PtRight != NULL) StackPush(stack, &(node->PtRight)); if (node->PtLeft != NULL) StackPush(stack, &(node->PtLeft)); } StackDestroy(&stack); Error = OK; return sum; }
void ABPPostOrderRep (PtABPNode proot) /* travessia em pós-ordem repetitiva - repetitive post-order traversal */ { PtABPNode Node = proot, Last = proot; PtStack Stack; if (proot == NULL) { Error = ABP_EMPTY; return; } /* arvore vazia - empty tree */ if ((Stack = StackCreate (sizeof (PtABPNode))) == NULL) { Error = NO_MEM ; return; } while (1) /* enquanto houver elementos para visitar - while there are nodes */ { /* travessia pela esquerda até atingir a folha mais à esquerda - left traversal until the left most leaf */ while (Node->PtLeft != NULL) { StackPush (Stack, &Node); Node = Node->PtLeft; } /* se não tem subarvore direita ou já completou a sua travessia - without right subtree or already completed the traversal */ while (Node->PtRight == NULL || Node->PtRight == Last) { printf ("%d ", Node->Elem); /* imprimir o elemento - printing the element */ Last = Node; /* assinalar último elemento visitado - marking the last visited element */ /* terminar quando não há mais elementos na pilha - terminate when there are no more elments in the stack */ if (StackIsEmpty (Stack)) { StackDestroy (&Stack); Error = OK; return; } StackPop (Stack, &Node); /* retirar o elemento anterior - retrieve the preview element */ } StackPush (Stack, &Node); /* recolocar o elemento na pilha - restore the element in the stack */ Node = Node->PtRight; /* iniciar travessia da subarvore direita - start the right subtree traversal */ } }
int StackPeek(stackT stackP) { if (StackIsEmpty(stackP)) { fprintf(stderr, "Can't pop element from stack: stack is empty.\n"); exit(1); /* Exit, returning error code. */ } return stackP->contents[stackP->top]; }
unsigned int ABPSizeRep (PtABPNode proot) /* cálculo do número de elementos repetitiva - repetitive number of nodes */ { PtABPNode Node = proot; PtStack Stack; unsigned int Number = 0; if (proot == NULL) { Error = ABP_EMPTY; return 0; } /* arvore vazia - empty tree */ if ((Stack = StackCreate (sizeof (PtABPNode))) == NULL) { Error = NO_MEM ; return 0; } StackPush (Stack, &Node); /* armazenar a raiz - storing the root */ while (!StackIsEmpty (Stack)) /* enquanto existirem nos - while there are nodes */ { StackPop (Stack, &Node); /* recuperar o no - retrieve the node */ Number++; /* contar o no - counting the node */ /* armazenar a raiz da subarvore esquerda - storing the left subtree root */ if (Node->PtLeft != NULL) StackPush (Stack, &Node->PtLeft); /* armazenar a raiz da subarvore direita - storing the right subtree root */ if (Node->PtRight != NULL) StackPush (Stack, &Node->PtRight); } StackDestroy (&Stack); /* destruir a pilha - releasing the stack */ Error = OK; return Number; }
void qsort_1 (int *arr, int size) { stackT stack; stackElementT element, e; int k; StackInit (&stack, size); element.left = 0; element.right = size - 1; StackPush(&stack, element); while (!StackIsEmpty (&stack)) { element = StackPop (&stack); while (element.left < element.right) { if (element.right - element.left < SWITCH_THRESH) { insertsort(&arr[element.left], element.right - element.left + 1); element.left = element.right; } else { k = partition(arr, element.left, element.right); e.left = element.left; e.right = k; StackPush(&stack, e); element.left = k+1; } } } StackDestroy (&stack); return; }
void *qsort_4_thread (void *threadarg) { //global busy thread count mutex and cv static pthread_mutex_t mutex_busy = PTHREAD_MUTEX_INITIALIZER; static pthread_cond_t cv_work = PTHREAD_COND_INITIALIZER; //deference thread argument struct struct qsort_4_thread_args *args = threadarg; //working vars int left, right, idle = 1, pivot; stackElementT element; while (1) { while (idle) { //try to get work pthread_mutex_lock (&mutex_busy); if (!StackIsEmpty (args->work)) { element = StackPop (args->work); (*args->busy)++; pthread_mutex_unlock (&mutex_busy); left = element.left; right = element.right; idle = 0; continue; } //if there's no work and nobody is busy signal and quit if (*args->busy == 0) { pthread_cond_broadcast (&cv_work); pthread_mutex_unlock (&mutex_busy); return (void *) 0; } //wait for signal of more work pthread_cond_wait (&cv_work, &mutex_busy); pthread_mutex_unlock (&mutex_busy); } while (!idle) { //if nothing to do, set idle and decrement busy if (left >= right) { idle = 1; pthread_mutex_lock (&mutex_busy); (*args->busy)--; pthread_mutex_unlock (&mutex_busy); continue; } //if problem small enough, insert sort if (right - left < SWITCH_THRESH && left < right) { insertsort (&args->data[left], right - left + 1); left = right; } else { //else partition, push and signal pivot = partition (args->data, left, right); element.left = pivot + 1; element.right = right; right = pivot; pthread_mutex_lock (&mutex_busy); StackPush (args->work, element); pthread_cond_broadcast (&cv_work); pthread_mutex_unlock (&mutex_busy); } } } }
int StackOrderIsLegal(StackElementType *input,StackElementType *output,int n){ SeqStack S; StackElementType e; int i,j; i = j = 0; InitStack(&S); while(j<n){ if(StackIsEmpty(&S)){ Push(&S,input[i]); printf("Push%d\t",input[i]); i ++; continue; } GetTop(&S,&e); if(e == output[j]) { Pop(&S,&e); printf("Pop%d\t",e); i ++; j ++; } else if(i < n){ Push(&S,input[i]); printf("Push%d\t",input[i]); i ++; } else { break; } } if(j < n) return 0; return 1; }
bool Pop(Stack * pstack){ if(StackIsEmpty(pstack)){ return false; } if(pstack->size == 1){ free(pstack->end); pstack->head = NULL; pstack->end = NULL; } else{ int max_num = StackItemCount(pstack); Node * this_node; Node * pre_node = pstack->head; int count=1; while(count < max_num -1){ pre_node = pre_node->next; count++; } this_node = pre_node->next; free(this_node); pre_node->next = NULL; pstack->end = pre_node; } pstack->size--; return true; }
stackElementT StackPop(stackT *stackP) { if(StackIsEmpty(stackP)) { fprintf(stderr, "Can't pop element from stack: stack is empty.\n"); exit(1); } return stackP->contents[stackP->top--]; }
/** * @brief * @param S * @returns * * */ ElementType StackTop(Stack S) { if (!StackIsEmpty(S)) { return S->next->element; } fprintf(stderr, "StackTop: empty stack"); return 0; }
StackElement StackPop(stackT *stackP) { if (StackIsEmpty(stackP)){ fprintf(stderr, "Не могу вытолкнуть элемент: стек пуст"); exit(1); } return stackP->contents[stackP->top--]; }
bool isValid(char *s) { int len = strlen(s); stackT left, right; StackInit(&left, len); StackInit(&right,len); int i; for(i = 0; i < len; i ++) { StackPush(&left, s[i]); } char a, b; while(!StackIsEmpty(&left)) { a = StackPop(&left); switch(a) { case '(': if(StackIsEmpty(&right)) return false; b = StackPop(&right); if( b != ')') return false; else break; case '[': if(StackIsEmpty(&right)) return false; b = StackPop(&right); if( b != ']') return false; else break; case '{': if(StackIsEmpty(&right)) return false; b = StackPop(&right); if( b != '}') return false; else break; case ')': StackPush(&right, a); break; case ']': StackPush(&right, a); break; case '}': StackPush(&right, a); break; default: printf("unrecognized char.\n"); } } if(StackIsEmpty(&right)) return true; return false; }
stackElementT StackPop(stackT *stackptr) { if (StackIsEmpty(stackptr)) { fprintf(stderr, "Can't pop element from stack: stack is empty.\n"); exit(1); /* Exit, returning error code. */ } return stackptr->contents[stackptr->top--]; }
/** * @brief * @param S * @returns * * */ ElementType StackPop(Stack S) { if(StackIsEmpty(S)) { fprintf(stderr, "StackPop: empty stack"); exit(1); } PtrToStackNode first = S->next; S->next = first->next; first->next = NULL; return first->element; }
/** * @brief * @param S * * */ void StackMakeEmpty(Stack S) { if (S == NULL) { fprintf(stderr, "Stack: Must use newStack first"); exit(1); } while(!StackIsEmpty(S)) { StackPop(S); } }
int ABPEvenOrderSum (PtABPNode proot) { PtABPNode node = proot; PtStack stack; int order = 0, sum = 0; if (proot == NULL) { Error = ABP_EMPTY; return -1; } if ((stack = StackCreate(sizeof(PtABPNode))) == NULL) { Error = NO_MEM; return -1; } StackPush(stack, &node); while(!StackIsEmpty(stack)) { if (node != NULL) { node = node->PtLeft; StackPush(stack, &node); } else { StackPop(stack, &node); if (!StackIsEmpty(stack)) { StackPop(stack, &node); if (order++ & 1) sum += node->Elem; node = node->PtRight; StackPush(stack, &node); } } } StackDestroy(&stack); Error = OK; return sum; }
void ABPPreOrderRep (PtABPNode proot) /* travessia em pré-ordem repetitiva - repetitive pre-order traversal */ { PtABPNode Node = proot; PtStack Stack; if (proot == NULL) { Error = ABP_EMPTY; return; } /* arvore vazia - empty tree */ if ((Stack = StackCreate (sizeof (PtABPNode))) == NULL) { Error = NO_MEM ; return; } StackPush (Stack, &Node); /* armazenar a raiz - storing the root */ while (!StackIsEmpty (Stack)) /* enquanto existirem nos - while there are nodes */ { StackPop (Stack, &Node); /* recuperar o no - retrieve the node */ printf ("%d ", Node->Elem); /* imprimir o elemento - printing the element */ /* colocar a raiz da subarvore direita, caso exista - storing the right subtree root if it exists */ if (Node->PtRight != NULL) StackPush (Stack, &Node->PtRight); /* colocar a raiz da subarvore esquerda, caso exista - storing the left subtree root if it exists */ if (Node->PtLeft != NULL) StackPush (Stack, &Node->PtLeft); } StackDestroy (&Stack); /* destruir a pilha - releasing the stack */ Error = OK; }
// This gets called in two circumstances. It may be called for the roots // in which case the stack will be empty and we want to process it completely // or it is called for a constant address in which case it will have been // called from RecursiveScan::ScanAddressesInObject and that can process // any addresses. PolyObject *RecursiveScan::ScanObjectAddress(PolyObject *obj) { PolyWord pWord = obj; // Test to see if this needs to be scanned. // It may update the word. bool test = TestForScan(&pWord); obj = pWord.AsObjPtr(); if (test) { MarkAsScanning(obj); if (obj->IsByteObject()) Completed(obj); // Don't need to put it on the stack // If we already have something on the stack we must being called // recursively to process a constant in a code segment. Just push // it on the stack and let the caller deal with it. else if (StackIsEmpty()) RecursiveScan::ScanAddressesInObject(obj, obj->LengthWord()); else PushToStack(obj); } return obj; }
// This is called via ScanAddressesInRegion to process the permanent mutables. It is // also called from ScanObjectAddress to process root addresses. // It processes all the addresses reachable from the object. void RecursiveScan::ScanAddressesInObject(PolyObject *obj, POLYUNSIGNED lengthWord) { if (OBJ_IS_BYTE_OBJECT(lengthWord)) { Completed(obj); return; } while (true) { ASSERT (OBJ_IS_LENGTH(lengthWord)); // Get the length and base address. N.B. If this is a code segment // these will be side-effected by GetConstSegmentForCode. POLYUNSIGNED length = OBJ_OBJECT_LENGTH(lengthWord); PolyWord *baseAddr = (PolyWord*)obj; if (OBJ_IS_CODE_OBJECT(lengthWord)) { // It's better to process the whole code object in one go. ScanAddress::ScanAddressesInObject(obj, lengthWord); length = 0; // Finished } ASSERT(! OBJ_IS_BYTE_OBJECT(lengthWord)); // Check - remove this later // else it's a normal object, // If there are only two addresses in this cell that need to be // followed we follow them immediately and treat this cell as done. // If there are more than two we push the address of this cell on // the stack, follow the first address and then rescan it. That way // list cells are processed once only but we don't overflow the // stack by pushing all the addresses in a very large vector. PolyWord *endWord = baseAddr + length; PolyObject *firstWord = 0; PolyObject *secondWord = 0; while (baseAddr != endWord) { PolyWord wordAt = *baseAddr; if (wordAt.IsDataPtr() && wordAt != PolyWord::FromUnsigned(0)) { // Normal address. We can have words of all zeros at least in the // situation where we have a partially constructed code segment where // the constants at the end of the code have not yet been filled in. if (TestForScan(baseAddr)) // Test value at baseAddr (may side-effect it) { PolyObject *wObj = (*baseAddr).AsObjPtr(); if (wObj->IsByteObject()) { // Can do this now - don't need to push it MarkAsScanning(wObj); Completed(wObj); } else if (firstWord == 0) { firstWord = wObj; // We mark the word immediately. We can have // two words in an object that are the same // and we don't want to process it again. MarkAsScanning(firstWord); } else if (secondWord == 0) secondWord = wObj; else break; // More than two words. } } else if (wordAt.IsCodePtr()) { // If we're processing the constant area of a code segment this could // be a code address. PolyObject *oldObject = ObjCodePtrToPtr(wordAt.AsCodePtr()); // Calculate the byte offset of this value within the code object. POLYUNSIGNED offset = wordAt.AsCodePtr() - (byte*)oldObject; wordAt = oldObject; bool test = TestForScan(&wordAt); // TestForScan may side-effect the word. PolyObject *newObject = wordAt.AsObjPtr(); wordAt = PolyWord::FromCodePtr((byte*)newObject + offset); if (wordAt != *baseAddr) *baseAddr = wordAt; if (test) { if (firstWord == 0) { firstWord = newObject; MarkAsScanning(firstWord); } else if (secondWord == 0) secondWord = newObject; else break; } } baseAddr++; } if (baseAddr == endWord) { // We have done everything except possibly firstWord and secondWord. Completed(obj); if (secondWord != 0) { MarkAsScanning(secondWord); // Put this on the stack. If this is a list node we will be // pushing the tail. PushToStack(secondWord); } } else // Put this back on the stack while we process the first word PushToStack(obj); if (firstWord != 0) // Process it immediately. obj = firstWord; else if (StackIsEmpty()) return; else obj = PopFromStack(); lengthWord = obj->LengthWord(); } }
stackElementT StackTope(AbstractStack pila) { if (!StackIsEmpty(pila)) return pila->datos[pila->cant - 1]; else return NULL; }
stackElementT StackPop(AbstractStack pila) { if (!StackIsEmpty(pila)) return pila->datos[--pila->cant]; else return NULL; }
stackElementT Pop(stackADT stack) { if (StackIsEmpty(stack)) Error("Stos jest pusty"); return stack->elements[--stack->count]; }
stackElementT Pop(stackADT stack) { if(StackIsEmpty(stack)) Error("Pop of an empty stack"); return (stack->elements[--stack->count]); }
int queueIsEmpty(queue_t * queue){ StackIsEmpty((queue->s1)); printf("queue empty\n" ); return 1; }
void *qsort_3_thread (void *threadarg) { //global busy thread count mutex static pthread_mutex_t mutex_busy = PTHREAD_MUTEX_INITIALIZER; //deference thread argument struct struct qsort_3_args *args = threadarg; //working vars int left = 0, right = 0, idle = 1, pivot; stackElementT element; while (1) { if (right - left < SWITCH_THRESH && left < right) { //insertsort #ifdef DEBUG printf("Performing insertsort on [%d,%d]\n", left, right); #endif insertsort(&args->data[left], right - left + 1); left = right; } while (left >= right) { pthread_mutex_lock (&mutex_busy); if (!StackIsEmpty(args->work)) { if (idle) (*args->busy)++; idle = 0; element = StackPop (args->work); left = element.left; right = element.right; #ifdef DEBUG printf("Thread accepted range [%d,%d]\nBusy threads: %d\n", left, right, *args->busy); #endif } else { if (!idle) (*args->busy)--; idle = 1; #ifdef DEBUG printf("Busy threads: %d\n", *args->busy); #endif } pthread_mutex_unlock (&mutex_busy); if (right - left < SWITCH_THRESH && !idle) { #ifdef DEBUG printf("Performing insertsort on [%d,%d]\n", left, right); #endif insertsort(&args->data[left], right - left + 1); left = right; } if (*args->busy == 0) return (void *) 0; } //partition pivot = partition (args->data, left, right); #ifdef DEBUG printf("Partitioned [%d,%d] found pivot %d\n", left, right, pivot); #endif //push area to left element.left = left; element.right = pivot; pthread_mutex_lock (&mutex_busy); #ifdef DEBUG printf("Pushing range [%d,%d]\n", element.left, element.right); #endif StackPush (args->work, element); pthread_mutex_unlock (&mutex_busy); //process area to right left = pivot + 1; } }
stackElementT StackGetFirst(AbstractStack pila) { if (!StackIsEmpty(pila)) return pila->datos[0]; else return NULL; }
static void ClearStack(stackADT stack) { while (!StackIsEmpty(stack)) Pop(stack); }