Stacks. Chapter 3. Exercises. 1. See Figure 3-1. FIGURE 3-1 Solution to Exercise 1

Transcription

1 Chapter 3 Stacks Exercises 1. See Figure S 1 S 2 FIGURE 3-1 Solution to Exercise 1 3. a. Prefix: D - B + C ((D - B) + C) (+(-D B) C) + - D B C Postfix: D - B + C ((D - B) + C) ((D B -) C +) D B - C + b. Prefix: A * B + C * D ((A * B) + (C * D)) (+ (*A B) (* C D)) + * A B * C D Postfix: A * B + C * D ((A * B) + (C * D)) ((A B *) (C D *) +) A B * C D * + c. Prefix: (A + B) * C - D * F + C ((((A + B) * C) - (D * F)) + C) (+ (- (* (+ A B) C) (* D F)) C) + - * + A B C * D F C Postfix: (A + B) * C - D * F + C ((((A + B) * C) - (D * F)) + C) ((((A B +) C *) (D F *) -) C +) A B + C * D F * - C + d. Prefix: (A - 2 * (B + C) - D * E) * F 9

2 10 Chapter 3 Stacks 5. a. (((A - (2 * (B + C))) - (D * E)) * F) (* (- (- A (* 2 (+ B C))) (* D E)) F) * - - A * 2 + B C * D E F Postfix: (A - 2 * (B + C) - D * E) * F (((A - (2 * (B + C))) - (D * E)) * F) (((A (2 (B C +) *) -) (D E *) -) F *) A 2 B C + * - D E * - F * A B * C - D * b. A B C + * D * * Note: Stacks are shown in top bottom order. a. See Table 3-1. b. See Table 3-2. Original Stack Output D - B + C B + C D B + C - D + C - D B C + D B - + D B - C D B - C + TABLE 3-1 Solution to Exercise 7a c. See Table 3-3. d. See Table 3-4. Original Stack Output A * B + C * D * B + C * D A B + C * D * A + C * D * A B C * D + A B * * D + A B * C D * + A B * C * + A B * C D A B * C D * + TABLE 3-2 Solution to Exercise 7b

3 Exercises 11 Original Stack Output (A+B)*C-D*F+C A+B)*C-D*F+C ( +B)*C-D*F+C ( A B)*C-D*F+C +( A )*C-D*F+C +( AB *C-D*F+C AB+ C-D*F+C * AB+ -D*F+C * AB+C D*F+C - AB+C* *F+C - AB+C*D F+C *- AB+C*D +C *- AB+C*DF C + AB+C*DF*- + AB+C*DF*-C AB+C*DF*-C+ TABLE 3-3 Solution to Exercise 7c Original Stack Output (A-2*(B+C)-D*E)*F A-2*(B+C)-D*E)*F ( -2*(B+C)-D*E)*F ( A 2*(B+C)-D*E)*F -( A *(B+C)-D*E)*F -( A2 (B+C)-D*E)*F *-( A2 B+C)-D*E)*F (*-( A2 +C)-D*E)*F (*-( A2B C)-D*E)*F +(*-( A2B )-D*E)*F +(*-( A2BC -D*E)*F *-( A2BC+ D*E)*F -( A2BC+* *E)*F -( A2BC+* D E)*F *-( A2BC+* D )*F *-( A2BC+* DE *F A2BC+* DE*- F * A2BC+* DE*- * A2BC+* DE*-F A2BC+* DE*-F* TABLE 3-4 Solution to Exercise 7d

4 12 Chapter 3 Stacks Problems 9. See Program 3-1. PROGRAM 3-1 Solution to Problem 9 /* =================== revlist ======================= This program will reverse a list of integers read from the keyboard by pushing them into a stack and retrieving them one by one. Written by: Date: #include <stdio.h> #include <stdlib.h> #include "stacksadt.h" int main (void) int data; int* dataptr; STACK* stack = createstack(); printf ("\nprint list of integers reversed.\n\n"); printf ("Please enter an integer: "); scanf ("%d", &data); do dataptr = (int*)malloc(sizeof(int)); if (!dataptr) printf ("\n\a**int* malloc failed**\n\n"); return -1; } // if dataptr *dataptr = data; if (!pushstack (stack, dataptr)) printf ("\n\a**allocation failed**\n\n"); return -1; } // if overflow printf ("\nenter next integer <EOF> to stop: "); } while ((scanf("%d", &data)!= EOF) &&!fullstack(stack)); printf ("\n\n The reversed list:\n\n "); while (dataptr = popstack(stack)) printf ("%d ", *dataptr); printf ("\n\n return 0; } // main --- End of Program ---\n\n"); 11. See Program 3-2. PROGRAM 3-2 Solution to Problem 11 /* This program will read a decimal number from the keyboard and convert it to hexadecimal form. Written by: Date:

5 Problems 13 PROGRAM 3-2 Solution to Problem 11 (continued) #include <stdio.h> #include <stdlib.h> #include "stacksadt.h" int main (void) int number; int* digitptr; STACK* stack; printf ("Convert a decimal number to hex.\n\n"); stack = createstack(); printf ("Please enter an integer: "); scanf ("%d", &number); while (number > 0) digitptr = (int*)malloc(sizeof(int)); if (!digitptr) printf ("\n\a**int* malloc failed**\n\n"); return -1; } // if digitptr *digitptr = number % 16; if (!pushstack (stack, digitptr)) printf ("\n\a**allocation Error**\n\n"); return -1; } // if overflow number /= 16; printf ("\n The hexadecimal number:\n 0x"); while (digitptr = popstack(stack)) switch (*digitptr) case 10 : printf ("%c", 'A'); case 11 : printf ("%c", 'B'); case 12 : printf ("%c", 'C'); case 13 : printf ("%c", 'D'); case 14 : printf ("%c", 'E'); case 15 : printf ("%c", 'F'); default : printf ("%d", *digitptr); } // switch stack not empty printf ("\n --- End of Program ---\n"); return 0; } // main

6 14 Chapter 3 Stacks 13. See Program 3-3. PROGRAM 3-3 Solution to Problem 13 /* This program changes an infix formula to a postfix formula. Written by: Date: #include <stdio.h> #include <ctype.h> #include <string.h> #include <stdlib.h> #include "stacksadt.h" #define MAX_STRING 81 // Prototype Declarations bool getformula (char *instring); int convert (char *instring, char *outstring); int priority (char ch); void printformula (char *outstring); int main (void) int error; char instring [ MAX_STRING ] = '\0' }; char outstring [ MAX_STRING ] = '\0' }; printf ("Change infix formula to postfix.\n\n"); while (getformula(instring)) error = convert (instring, outstring); if (error) printf ("\n\a**error in the formula**\n\n"); else printformula (outstring); printf ("\n === End of Program ==="); return 0; } // main /* =================== getformula =================== Reads an infix formula from the keyboard. Pre formula is variable to receive formula Post infix expression read & stored Returns true if expression entered, false if 'quit' bool getformula (char* formula) printf ("Enter infix formula <quit>)\n" " Infix Formula : "); fgets(formula, MAX_STRING - 1, stdin); formula[strlen(formula) -1] = '\0'; if (strcmp("quit", formula) == 0 strcmp("quit", formula) == 0) return false; return true; } // getformula

7 Problems 15 PROGRAM 3-3 Solution to Problem 13 (continued) /* =================== convert =================== Convert an infix formula to a postfix formula. Pre instring is the infix formula outstring is the postfix formula Post instring has been converted to postfix Returns -1 if memory allocation failure 0 if successful. int convert(char* instring, char* outstring) char current; char* curptr; char* topptr; char* pin; char* pout; STACK* stack; stack = createstack(); pin = instring; pout = outstring; current = *pin; while (current!= '\0') if (!isspace(current)) switch (current) case '(' : curptr = (char*)malloc(sizeof(char)); *curptr = current; if (!pushstack(stack, curptr)) printf("\n\a**stk1 Overflow\n"); return -1; } // if!push case '*' : case '/' : case '+' : case '-' : topptr = stacktop(stack); while (!emptystack(stack) && priority(current) <= priority(*topptr)) *pout = *(char*)popstack(stack); *pout = ' '; topptr = stacktop (stack); curptr = (char*)malloc(sizeof(char)); *curptr = current; if (!pushstack(stack, curptr)) printf("\n\a**stk2 overflow\n"); return -1; } // if!push case ')' : topptr = stacktop(stack); while (!emptystack(stack) *pout = *(char*)popstack(stack);

8 16 Chapter 3 Stacks PROGRAM 3-3 Solution to Problem 13 (continued) *pout = ' '; topptr = stacktop (stack); topptr = popstack(stack); default : *pout = current; *pout = ' '; } // switch } // if current!= space pin++; current = *pin; not end of input string while (!emptystack (stack)) *pout = *(char*)popstack(stack); *pout = ' '; *pout = '\0'; return 0; } // convert /* =================== priority =================== This function tests the priority of an operator Pre op is an operator (+, -, (, *, or /) Post returns priority of operator 2 for * and / 1 for + and - 0 for ( int priority (char op) switch (op) case '(' : return 0; case '+' : case '-' : return 1; case '*' : case '/' : return 2; } // switch } // priority /* =================== printformula =================== This function prints the postfix formula. Pre : outstring is the postfix formula. Post : The formula has been printed. Returns : Nothing void printformula (char* outstring) printf (" Postfix Formula: %s\n", outstring); return; } // printformula

9 Problems See Program 3-4. PROGRAM 3-4 Solution to Problem 15 /* This program evaluates a postfix expression. Written by: Date: #include <stdio.h> #include <limits.h> #include <ctype.h> #include <string.h> #include "stacksadt.h" #define MAX_STRING 81 // Prototype Declarations bool getformula (char* instring); int evalpostfix (char* instring); int calculate (int operand1, char op, int operand2); void printresult (char* instring, int result); int main (void) int result; char instring [ MAX_STRING ] = '\0' }; printf ("Evaluate a postfix expression.\n\n"); while (getformula(instring)) result = evalpostfix (instring); if (result == INT_MIN) // Stack overflow return result; else if (result == INT_MIN + 1) printf("\n\a**error in formula**\n\n"); else printresult (instring, result); printf ("\n return 0; } // main === End of Program ===\n"); /* =================== getformula =================== This function prompts for and reads an postfix expression from the keyboard. Pre expression is variable for the expression Post Postfix expression read & stored Returns true if an expression entered false if 'quit' bool getformula (char* expression) printf ("Enter a postfix expression <quit>\n" " Postfix Expression: "); fgets(expression, MAX_STRING - 1, stdin); expression[strlen(expression) -1] = '\0'; if (strcmp("quit", expression) == 0 strcmp("quit", expression) == 0) return false;

10 18 Chapter 3 Stacks PROGRAM 3-4 Solution to Problem 15 (continued) return true; } // getformula /* =================== evalpostfix =================== This function evaluates a postfix expression. Pre expr is postfix expression Post expression evaluated & result returned Return INT_MIN + 1 if postfix expression invalid INT_MIN if a memory allocation fails result of evaluation if successful int evalpostfix(char* expr) char* pcurrent; int inputnum; int* numptr; int operand1; int operand2; int result ; STACK* stack; stack = createstack(); pcurrent = expr; while (*pcurrent!= '\0') if (isdigit(*pcurrent)) inputnum = strtol(pcurrent, &pcurrent, 10); numptr = (int*)malloc(sizeof(int)); *numptr = inputnum; if (!pushstack(stack, numptr)) printf ("\n\a**stack overflow\n"); return INT_MIN; } // if!push } // if isdigit else switch (*pcurrent) case '+' : case '-' : case '*' : case '/' : operand2 = *(int*)popstack (stack); operand1 = *(int*)popstack (stack); result = calculate (operand1,*pcurrent, operand2); numptr = (int*)malloc(sizeof(int)); *numptr = result; if (!pushstack (stack, numptr)) printf ("\n\a**stack overflow\n"); return INT_MIN; } // if!pushok default : // Must be space } // switch pcurrent++; } // else expr // if the stack has other than 1 item left, the // original postfix expression was wrong. if (stackcount(stack)!= 1)

11 Problems 19 PROGRAM 3-4 Solution to Problem 15 (continued) printf ("\n\a**error in postfix expression\n"); result = INT_MIN + 1; } // if count!= 1 else result = *(int*)popstack (stack); return result; } // evalpostfix /* =================== calculate =================== This function returns the result of a mathematical operation based on 4 possible operator characters that can be passed by the calling function. Pre op is mathematical operator (+ - * /) operand1 & operand2 are the operands Post operation performed Return Returns the result of the operation int calculate (int operand1, char op, int operand2) switch (op) case '+' : return (operand1 + operand2); case '-' : return (operand1 - operand2); case '*' : return (operand1 * operand2); case '/' : return (operand1 / operand2); } // switch } // calculate /* =================== printresult =================== The result of the calculation has been printed. Pre instring is postfix formula. Post result printed. void printresult (char* instring, int result) printf ("\n %s = %d\n", instring, result); return; } // printformula 17. See Algorithm 3-1. ALGORITHM 3-1 Solution to Problem 17 algorithm copystack (sourcestack, newstack) This algorithm copies the source stack to the destination stack, preserving the top-to-base ordering. Pre sourcestack is a valid stack Post newstack is a copy of sourcestack 1 set tempstack to createstack 2 loop (not empty sourcestack) 1 data = popstack (sourcestack) 2 pushstack (tempstack, data) 3 end loop Now copy tempstack to newstack 4 loop (not empty tempstack) 1 data = popstack (tempstack) 2 pushstack (newstack, data) 5 end loop 6 destroystack (tempstack) end copystack

12 20 Chapter 3 Stacks 19. See Program 3-5. PROGRAM 3-5 Solution to Problem 19 /* This program tests the palindrome function. Written by: Date: #include <stdio.h> #include <stdlib.h> #include <string.h> #include <ctype.h> #include "stacksadt.h" #define MAX_STRING 81 // Prototype Declarations bool palindrome (char* string); void packstring (char* string); int main (void) char string [ MAX_STRING ]; printf (" === Welcome to Palindromes ===\n\n"); printf ("\nplease enter a string : "); while ((scanf("%[^\n]", string))!= EOF) switch (palindrome(string)) case true : printf (" \"%s\" is a palindrome.\n", string); case false : printf (" \"%s\" is NOT a palilndrome.\n", string); } // switch getchar(); // Clear \n printf ("\nenter next string or <EOF> : "); printf ("\n === End of Palindrome ===\n"); return 0; } // main /* =================== palindrome =================== This function tests to if a string is a palindrome. Pre string is the string to test Post string has been tested Returns true if the string is a palindrome false if the string is not a palindrome bool palindrome (char* string) char* walker; char* charptr; char teststring1[ MAX_STRING ]; char teststring2[ MAX_STRING ]; STACK* stack; stack = createstack();

13 Problems 21 PROGRAM 3-5 Solution to Problem 19 (continued) strcpy (teststring1, string); packstring(teststring1); walker = teststring1; while (*walker!= '\0') charptr = (char*)malloc(sizeof(char)); *charptr = *walker; if (!pushstack (stack, charptr)) printf ("Stack O/F in palindrome\n"); exit (100); } // if walker++; walker = teststring2; while (!emptystack(stack)) *walker = *(char*)popstack(stack); walker++; *walker = '\0'; destroystack (stack); return (strcmp(teststring1, teststring2) == 0); } // palindrome /* =================== packstring =================== This function removes spaces and punctuation and converts all characters to upper case. Pre string is a valid string Post string has been packed void packstring (char* string) char* current; char* next; current = next = string; while (*next!= '\0') if (isalpha(*next)) *current = toupper(*next); current++; } // if next++; *current = '\0'; return; } // packstring 21. See Algorithm 3-2. ALGORITHM 3-2 Solution to Problem 21 algorithm reversestack (stack) Reverse the contents of a stack. Pre stack is valid Post contents have been reversed 1 set temp1 to createstack

14 22 Chapter 3 Stacks ALGORITHM 3-2 Solution to Problem 21 (continued) 1 set temp2 to createstack 2 loop (stack not empty ) 1 popstack (stack, data) 2 pushstack (temp1, data) 3 end loop 4 loop (temp1 not empty) 1 popstack (temp1, data) 2 pushstack (temp2, data) 5 end loop 6 loop (temp2 not empty) 1 popstack (temp2, data) 2 pushstack (stack, data) 7 end loop end reversestack