Vectors, Stacks, and Queues

Due: 30 Sep 2014

Educational objectives:

• Primary objectives: Experience implementing vector, stack, and queue classes, using recursive function calls, analyzing the runtime of your code.

• Secondary objectives: Implementing and using templates.

Statement of work: (i) Implement generic vector, stack, and queue classes, (ii) evaluate a recursive function, and (iii) analyze time complexities.

Deliverables:

• Turn in a makefile and all header (*.h) and cpp (*.cpp) files that are needed to build your software, as described in www.cs.fsu.edu/~asriniva/courses/DS14/HWinstructions.html. Turn in your development log too, which should be a plain ASCII text file called LOG.txt in your project directory.

Requirements:

• Create a subdirectory called proj2.
• You will need to have a makefile in this directory. In addition, all the header and cpp files needed to build your software must be present here, as well as the LOG.txt file.
• You should create the following additional files.
  • Vector.h: This should implement a generic Vector class (note the capitalization of the first letter in Vector). The following features must be implemented: (i) a default constructor that initializes an array of capacity 2, (ii) a destructor, (iii) void push_back(const T &e), (iv) the operator[], (v) int size( ) const, (vi) and void pop_back(). The time complexities of these operators should be as good as feasible in a vector. When the array capacity is exhausted, the array size should be increased by a factor of 4. You may implement additional features, if you wish to. If you do not implement a copy constructor and an assignment operator, then you should prevent their use by making them private.
  • stack.h: Use the Vector class to implement a generic stack class with at least the following features: (i) void push(const T &), (ii) void pop(), (iii) T &top(), and (iv) bool empty(). The amortized time complexities for all operations should be O(1).

  • queue.h: This should use the Vector class to implement a generic queue class with at least the following features: (i) void push(const T &), (ii) void pop(), (iii) T &front(), and (iv) bool empty(). The amortized time complexities for all operations should be O(1).

  • usestack.cpp: This should be a simple code that checks whether your stack is working correctly. It should output Stack works if the stack works correctly in your test, and Stack does not work if the stack does not work correctly.

  • Other files: You may use more files.

  • main.cpp: This is a program to evaluate a recursive function. It has nothing to do with the previous part of the assignment. The command: ./recurse N1 C1 A1 M1 M2 M3 M4 D1 D2 S1 S2 Arg Op will cause the function given below to be evaluated recursively and the answer output. The function is defined as follows.

    f(N) = 0, if N < N1

    f(N1) = C1

    f(N)= A1 + M1*f(M2*N/D1 - S1) Op M3*f(M4*N/D2 - S2), if N > N1

    Here, f(Arg) needs to be evaluated. N₁ C₁ A₁ M₁ M₂ M₃ M₄ D₁ D₂ S₁ S₂, Arg are integers and Op is either + or -. The division performed is the usual integer division with truncation.

    Example:

    Prompt> ./recurse 2 3 2 1 2 0 1 3 6 0 0 18 +

    13 (program output)

  • Analysis.pdf: This file should contain the following. (i) The asymptotic time complexity for the evaluation of the recursive function as a function of all arguments to the executable recurse which influence the running time of that program. For the analysis alone, assume that S1 = S2 = 0, M2 = M4 = 1, and D1 = D2 > 1. (ii) The amortized time complexity for N push operations on your stack class. Justify the results of your analysis.

Sample executable: A sample executable is available at ~cop4530/fall14/solutions/proj2/recurse on linprog. The first person to find errors in our program will get a bonus point!

Notes:

1. You should not use the STL list, vector, deque, stack, or queue classes. You may use the string class. Please get my written permission before using any other STL feature.
2. We will test your Vector, stack, and queue classes on entirely different applications. So it is important for these classes to be generic and exactly as specified.
3. You will get 5 bonus points if, in addition to the recursive implementation of the above function, you also provide an iterative implementation that explicitly uses a stack object to simulate the recursive implementation. This implementation should be in a file called RecurseStack.cpp and the corresponding executable should be named RecurseStack. Please email the TAs if you submit this additional file.

---

Last modified: 26 Sep 2014