File Input and Output

Transcription

1 CPSC 211 Data Structures & Implementations (c) Texas A&M University [ 153] File Input and Output File I/O is much simpler than in Java. æ Include stdio.h to use built-in file functions and types æ Declare a pointer to a type called FILE (provided by the system) æ Call fopen to open the file for reading or writing returns pointer to the file æ Writing to a file is done with fprintf (analogous to printf. æ Reading from a file is done with fscanf (analogous to scanf. æ Call fclose to close the file.

2 CPSC 211 Data Structures & Implementations (c) Texas A&M University [ 154] File I/O Example /* to use the built in file functions */ #include <stdio.h> main () { /* create a pointer to a struct called FILE; */ /* it is system dependent */ FILE* fp; char line[80]; int i; /* open the file for writing */ fp = fopen("testfile", "w"); /* write into the file */ fprintf(fp,"line %i ends \n", 1); fprintf(fp,"line %i ends \n", 2); /* close the file */ fclose(fp); /* open the file for reading */ fp = fopen("testfile", "r"); /* read six strings from the file */ for (i = 1; i < 7; i++) { fscanf(fp,"%s", line); printf("got from the file: %s \n", line); /* close the file fclose(fp);

3 CPSC 211 Data Structures & Implementations (c) Texas A&M University [ 155] Motivation for Stacks Some examples of last-in, first-out (LIFO) behavior: æ Web browser s back button retraces your steps in the reverse order in which you visited the sites. æ Text editors often provide an undo mechanism that will cancel editing changes, starting with the most recent one you made. æ The most recent pending method/function call the current one to execute. æ To evaluate an arithmetic expression, you need to finish evaluating the current sub-expression before you can finish evaluating the previous one. A stack is a sequence of elements, to which elements can be added (push) and removed (pop): elements are removed in the reverse order in which they were added. is

4 CPSC 211 Data Structures & Implementations (c) Texas A&M University [ 156] Specifying an ADT with an Abstract State We would like a specification to be as independent of any particular implementation as possible. But since people naturally think in terms of state, a popular way to specify an ADT is with an abstract, or high-level, implementation : 1. describe an abstract version of the state, and 2. describe the effect of each operation on the abstract state.

5 CPSC 211 Data Structures & Implementations (c) Texas A&M University [ 157] Specifying the Stack ADT with an Abstract State 1. A stack s state is modeled as a sequence of elements. 2. Initially the state of the stack is the empty sequence. 3. The effect of a push(x) operation is to append x to the end of the sequence that represents the state of the stack. This operation returns nothing. 4. The effect of a pop operation is to delete the last element of the sequence that represents the state of the stack. This operation returns the element that was deleted. If the stack is empty, it should return some kind of error indication.

6 CPSC 211 Data Structures & Implementations (c) Texas A&M University [ 158] Specifying an ADT with Operation Sequences But a purist might complain that a state-based specification is, implicitly, suggesting a particular implementation. To be even more abstract, one can specify an ADT simply by the allowable sequences of operations. For instance: æ push(a) pop(a): allowable æ pop(a): not allowable since stack is empty initially æ push(a) push(b) push(c) pop(c) pop(b) push(d) pop(d): allowable æ push(a) push(b) pop(a): not allowable since a is no longer the top of the stack But it is more involved to give a precise and complete definition of the allowable sequences without reference to an abstract state.

7 CPSC 211 Data Structures & Implementations (c) Texas A&M University [ 159] Additional Stack Operations Other operations that you sometimes want to provide: æ peek: return the top element of the stack, but do not remove it from the stack; sometimes called top æ size: return number of elements in stack æ empty: tells whether or not the stack is empty Java provides a Stack class, in java.util, with methods push, pop, empty, peek, andsearch.

8 CPSC 211 Data Structures & Implementations (c) Texas A&M University [ 160] Balanced Parentheses Recursive definition of a sequence of parentheses that is balanced: æ the sequence ( ) is balanced. æ if the sequence s is balanced, then so are the sequences s ( ) and ( ) s and ( s ). According to this definition: æ ( ) : balanced æ (()(())): balanced æ (()))(): notbalanced æ ( ) ) ( : not balanced

9 CPSC 211 Data Structures & Implementations (c) Texas A&M University [ 161] Algorithm to Check for Balanced Parentheses Key observations: 1. There must be the same total number of left parens as right parens. 2. In any prefix, the number of right parens can never exceed the number of left parens. Pseudocode: create an empty stack for each char in the string if char = ( then push ( onto the stack if char = ) then pop ( off the stack if the pop causes an error then unbalanced endfor if stack is empty then balanced else unbalanced

10 CPSC 211 Data Structures & Implementations (c) Texas A&M University [ 162] Java Method to Check for Balanced Parentheses Using java.util.stack class (which manipulates objects): import java.util.*; boolean isbalanced(char[] parens) { Stack S = new Stack(); try { // pop might throw an exception for (int i = 0; i < parens.length; i++) { if ( parens[i] == ( ) S.push(new Character( ( )); else S.pop(); // discard popped object return S.empty(); catch (EmptyStackException e) { return false;

11 CPSC 211 Data Structures & Implementations (c) Texas A&M University [ 163] Checking for Multiple Kinds of Balanced Parens Suppose there are 3 different kinds of parentheses: (and),[and],f and g. Modify the program: When we encounter a ), we should pop off a (. When we encounter a ], we should pop off a [. When we encounter a g, we should pop off a f. boolean isbalanced3(char[] parens) { Stack S = new Stack(); try { for (int i = 0; i < parens.length; i++) { if (leftparen(parens[i]) // ( or [ or { S.push(new Character(parens[i])); else { char leftp = ((Character)S.pop()).charValue(); if (!match(leftp,parens[i])) return false; return S.empty(); // end try catch (EmptyStackException e) { return false;

12 CPSC 211 Data Structures & Implementations (c) Texas A&M University [ 164] Multiple Kinds of Parentheses (cont d) boolean leftparen(char c) { return ((c == ( ) (c == [ ) c == { )); boolean match(char lp, char rp) { if ((lp == ( ) && (rp == ) ) return true; if ((lp == [ ) && (rp == ] ) return true; if ((lp == { ) && (rp == ) return true; return false;