void calc_clear(stk_t * s)
{
if( s == NULL)
return;
while( ! stk_is_empty(s) )
stk_pop(s);
}
void calc_print_top(stk_t * s, FILE * f)
{
if( stk_is_empty(s) )
{
fprintf(f,"Stack is empty, no top element\n");
return;
}
fprintf(f, "Top element is %d\n", stk_get_top(s));
}
void calc_swap_top(stk_t * s)
{
if( stk_is_empty(s) )
{
fprintf(stderr,"Stack is empty, can't swap top two elements\n");
return;
}
stk_swap( s, 0, 1 );
stk_print( s , stdout);
}
/*
* Our idle function. Does a step of mergesort and quicksort, and calls the
* display functions.
*
*/
void update_lists(void) {
// Mergesort part.
// we only want to display if we've performed a merge.
bool performed_a_merge = false;
// if mergesort isn't finished, perform a step of it.
if (!stk_is_empty(mergesort_stack)) {
Node *cur_node = pop(mergesort_stack);
State cur_state = cur_node->state;
if (cur_state == unsorted) {
size_t cur_size = cur_node->size;
// If length 0 or 1, change state to sorted and put back on stack.
if (cur_size == 1 || cur_size == 0) {
cur_node->state = sorted;
push(mergesort_stack, cur_node);
}
else {
// Split and place back on stack.
// Make two new arrays, and fill them.
size_t first_array_size = (cur_size / 2);
size_t second_array_size = (cur_size - first_array_size);
int *first = malloc(first_array_size * sizeof(int));
int *second = malloc(second_array_size * sizeof(int));
half(cur_node->array, first, first_array_size, second,
second_array_size);
// Push new arrays on stack as nodes.
Node *first_node = make_node(first, first_array_size,
unsorted);
int cur_start_index = cur_node->start_index;
first_node->start_index = cur_start_index;
first_node->end_index = cur_start_index + first_array_size - 1;
push(mergesort_stack, first_node);
Node *second_node = make_node(second, second_array_size,
unsorted);
second_node->start_index = cur_start_index + first_array_size;
second_node->end_index = cur_node->end_index;
push(mergesort_stack, second_node);
free_node(cur_node);
}
} else if (cur_state == sorted) {
if (!stk_is_empty(mergesort_stack)) {
// If stack isn't empty, get next_node and merge or swap.
Node *next_node = pop(mergesort_stack);
// If next_node's sorted, merge them together; else switch
// them.
if (next_node->state == sorted) {
// Merge them into a new node.
size_t first_half_size = cur_node->size;
size_t second_half_size = next_node->size;
size_t merged_size = first_half_size + second_half_size;
int *merged_array = malloc(merged_size * sizeof(int));
merge(cur_node->array, first_half_size, next_node->array,
second_half_size, merged_array, compare);
Node *merged_node = make_node(merged_array, merged_size,
sorted);
merged_node->start_index = cur_node->start_index;
merged_node->end_index = next_node->end_index;
push(mergesort_stack, merged_node);
free_node(cur_node);
free_node(next_node);
performed_a_merge = true;
} else if (next_node->state == unsorted) {
// Swap position of nodes.
push(mergesort_stack, cur_node);
push(mergesort_stack, next_node);
} else {
printf("Unrecognized state.");
}
} else {
free_node(cur_node);
}
} else {
printf("Unrecognized state.");
}
// If we performed a merge, the newly merged element should be at the
// top of the stack.
if (performed_a_merge) {
mergesort_counter++;
Node *mergedNode = peek(mergesort_stack);
int *cur_array = mergedNode->array;
int start_index = mergedNode->start_index;
int end_index = mergedNode->end_index;
// Put the merged array into the appropriate place in xs_mergesort.
for (int i = start_index; i <= end_index; i++) {
xs_mergesort[i] = cur_array[i - start_index];
}
glutSetWindow(upper_win);
glutPostRedisplay();
}
}
/* We want to run and display quicksort if either mergesort is done or if
* we just performed a merge. We could also run quicksort regardless of
* what the mergesort algorithm did, but this way we can compare how the
* display iterations of the algorithms look since they're running at
* the same time.
*/
if (performed_a_merge || stk_is_empty(mergesort_stack)) {
// if (true) {
if (!stk_is_empty(quicksort_stack)) {
Sublist *current_sublist = pop(quicksort_stack);
int start_index = current_sublist->start_index;
int end_index = current_sublist->end_index;
int pivot_index = partition(xs_quicksort, start_index, end_index,
compare);
// Create two sublists and push them on the stack.
int left_start_index = start_index;
int left_end_index = pivot_index - 1;
if (left_end_index - left_start_index >= 1) {
Sublist *left_list = malloc(sizeof(Sublist));
left_list->start_index = left_start_index;
left_list->end_index = left_end_index;
push(quicksort_stack, left_list);
}
int right_start_index = pivot_index + 1;
int right_end_index = end_index;
if (right_end_index - right_start_index >= 1) {
Sublist *right_list = malloc(sizeof(Sublist));
right_list->start_index = right_start_index;
right_list->end_index = right_end_index;
push(quicksort_stack, right_list);
}
free(current_sublist);
quicksort_counter++;
}
// Partition happens at every step, so we'll always display.
glutSetWindow(lower_win);
glutPostRedisplay();
}
}
void stk_dump(stk_t * s,FILE * out)
{
fprintf(out,"stk_dump:\n" );
while( ! stk_is_empty(s) )
fprintf(out,"%d\n", stk_pop(s) );
}
void impl( )
{
stk_t * k = stk_new();
char cur;
int lhs;
int rhs;
int val;
int total = 0;
while( (cur = fgetc(stdin)) != EOF )
{
if(isdigit(cur))
{
int digits[MAXDIGITS];
int n_digits = 0;
digits[ n_digits++ ] = cur - '0';
while( (cur = fgetc(stdin)) != EOF && isdigit(cur) && n_digits < MAXDIGITS)
digits[ n_digits++ ] = cur - '0';
int val = 0;
for(int i = 0, j = n_digits - 1; i < n_digits; i ++, j-- )
val += digits[i] * pow(10, j);
stk_push(k, val);
}
switch(cur)
{
// handle operators
case '%':
case '+':
case '-':
case '*':
case '/':
//printf("got op, %c\n",cur);
if(! stk_is_empty(k) )
if( (lhs = stk_pop(k)) == -1 )
{
printf("Bad lhs pop\n");
return;
}
if(! stk_is_empty(k) )
{
if( (rhs = stk_pop(k)) == -1 )
{
printf("Bad rhs pop\n");
return;
}
fprintf(stdout, "lhs %d, rhs %d, op %c\n",lhs,rhs,cur);
stk_push(k, calc_op(cur, lhs, rhs));
}
else
{
stk_push(k,lhs);
stk_push(k,cur);
}
break;
// clear stack with _ underscore
case '_':
calc_clear(k);
break;
case '.':
calc_print_top(k,stdout);
break;
case '>':
calc_swap_top(k);
break;
}
}
stk_dump(k,stdout);
stk_free(k);
}
/*
* Check if the given string is balanced
*/
int checkBalanced(StackPtr stack, char* n, int debug) {
//go through the string
int x = 0; //keep track of where the unbalanced symbol is
int unbalanced = 0;
int miss = 0;
int i;
for(i = 0; i < strlen(n) - 1; i++) {
//If we encounter an opening symbol
if(n[i] == '(' || n[i] == '{' || n[i] == '[' || n[i] == '<') {
if(debug) {
printf("Debug mode: Pushing to stack: %c\n", n[i]);
}
stk_push(stack, n[i], debug);
x++;
}
//if we encounter a closing symbol
if(n[i] == ')' || n[i] == '}' || n[i] == ']' || n[i] == '>'){
//if closing is encountered next, if correct closing bracket pop from stack
if(n[i] == ')') {
if(stk_top(stack) == '(') {
if(debug) {
printf("Debug mode: Popping from stack: %c\n", stk_top(stack));
}
stk_pop(stack);
} else {
miss = 1;
unbalanced = 1;
}
} else if(n[i] == '}') {
if(stk_top(stack) == '{') {
if(debug) {
printf("Debug mode: Popping from stack: %c\n", stk_top(stack));
}
stk_pop(stack);
} else {
miss = 2;
unbalanced = 1;
}
} else if(n[i] == ']') {
if(stk_top(stack) == '[') {
if(debug) {
printf("Debug mode: Popping from stack: %c\n", stk_top(stack));
}
stk_pop(stack);
} else {
miss = 3;
unbalanced = 1;
}
} else if(n[i] == '>') {
if(stk_top(stack) == '<') {
if(debug) {
printf("Debug mode: Popping from stack: %c\n", stk_top(stack));
}
stk_pop(stack);
} else {
miss = 4;
unbalanced = 1;
}
}
}
}
if(stk_is_empty(stack) && !unbalanced) {
printf("\n%s", n);
printf("Expression is Balanced!\n\n\n");
return 1;
} else {
printf("\n%s\n", n);
int i;
for(i = 0; i < x; i++) {
printf(" ");
}
printf("^");
if(miss == 1) {
printf(" missing (");
} else if(miss == 2) {
printf(" missing {");
} else if(miss == 3) {
printf(" missing [");
} else if(miss == 4) {
printf(" missing <");
}
printf("\n\n\n");
return 0;
}
}
