int main(int argc, char *argv[]){
struct Stack *stack = Stack_new(10);
int i=0;
Stack_push(stack, 5);
Stack_push(stack, 50);
Stack_push(stack, 1000);
Stack_push(stack, 25);
Stack_push(stack, 25);
Stack_push(stack, 25);
Stack_push(stack, 25);
Stack_push(stack, 25);
Stack_push(stack, 25);
Stack_push(stack, 25);
Stack_push(stack, 25);
Stack_push(stack, 25);
Stack_push(stack, 25);
Stack_push(stack, 25);
Stack_push(stack, 25);
Stack_push(stack, 25);
for(i=0; i < stack->pos; i++){
printf("Popped %d from the stack (pos %d)\n", stack->store[i], i);
}
Stack_destroy(stack);
return 0;
}
char *test_destroy()
{
mu_assert(stack != NULL, "Failed to make stack #2");
Stack_destroy(stack);
return NULL;
}
void die(char *message, struct Stack *stack){
if(errno){
perror(message);
} else {
printf("ERROR: %s\n", message);
}
Stack_destroy(stack);
exit(1);
}
void rb_free(rb_node_t **root)
{
stack S=NULL;
S=InitStack(S);
rb_node_t *p=NULL;
p = *root;
Push(S, p);
while(!StackEmpty(S))
{
while(p){
if(p->lflag != 1 )
{
p->lflag = 1;
if(p->left){
Push(S, p->left);
p = p->left;
}
}else if(p->rflag != 1 )
{
p->rflag = 1;
if(p->right){
Push(S, p->right);
p = p->right;
}
}
if(p->lflag == 1 && p->rflag == 1){
break;
}
}
p = Pop(S);
rb_node_free(&p);
if(StackEmpty(S)) {
break;
}
p = GetTop(S);
}
*root = NULL;
Stack_destroy(&S, NULL);
}
/**
* Sort 'array' of length 'len' using Donald Knuth's "StackSort"
*
* To do this, you must implement the following pseudo-code:
* (1) Maintain a 'write_index'. This is where you'll write values to
* as you sort them. It starts off as zero.
* (2) Initialize an empty stack
* (3) For each input value 'x':
* (3.a) While the stack is nonempty and 'x' is larger than the
* front 'value' on the stack, pop 'value' and:
* (3.a.i) Write 'value' to array[write_index], and
* increment write_index.
* (3.b) Push x onto the stack.
* (4) While the stack is nonempty, pop the front 'value' and follow
* step (3.a.i).
*
* The output should be a sorted array if, and only if, the array
* is stack-sortable. You can find files full of stack-sortable and
* stack-unsortable arrays in the 'expected' folder.
*/
void stackSort(int * array, int len)
{
int windex = 0;
int readindex = 0;
Stack * tube = Stack_create() ;
while(readindex < len)
{
/* ListNode *lb = malloc(sizeof(ListNode)) ; */
/* lb->value = array[readindex] ; */
/* lb->next = NULL ; */
if( tube->list == NULL )
{
Stack_push(tube,array[readindex]) ;
/* tube->list = malloc(sizeof(ListNode)) ; */
/* tube->list->value = array[readindex] ; */
/* tube->list->next = NULL ; */
}
else
{
while(tube->list != NULL && tube->list->value < array[readindex])
{
array[windex] = Stack_pop(tube) ;
windex ++ ;
}
Stack_push(tube , array[readindex]) ;
}
readindex ++ ;
}
while(tube->list != NULL)
{
array[windex] = Stack_pop(tube) ;
windex ++ ;
}
Stack_destroy(tube) ;
}
int main(int argc, char *argv[])
{
struct Stack *stack = Stack_create(250);
Stack_push(stack, "David");
Stack_push(stack, "Raymond");
Stack_push(stack, "Bryan");
printf("length: %d\n", Stack_length(stack));
printf("%s\n", Stack_peek(stack));
char *popped = Stack_pop(stack);
printf("The popped element is: %s\n", popped);
printf("%s\n", Stack_peek(stack));
Stack_push(stack, "Cynthia");
printf("%s\n", Stack_peek(stack));
Stack_clear(stack);
printf("length: %d\n", Stack_length(stack));
printf("%s\n", Stack_peek(stack));
Stack_push(stack, "Clayton");
printf("%s\n", Stack_peek(stack));
Stack_destroy(stack);
return 0;
}
void StrList_destroy(StrList* list) {
assert(list != NULL);
Stack_destroy(list->stack);
free(list);
list = NULL;
}
char *test_destroy()
{
mu_assert(stack != NULL, "destroy: failed");
Stack_destroy(stack);
return NULL;
}
