## CS 2005, B Term 1999 Data Structures and Programming Techniques Practice Problems for Test 3

Instructions.   Read each problem carefully. Write your solutions in ink in the spaces provided. Write neatly and explain your answers as clearly as possible.

Refer to the Table class definition that appears below.

```    template <class RecordType>
class Table {
public:
// MEMBER CONSTANT
static const size_t TABLE_SIZE = 811;
// CONSTRUCTORS and DESTRUCTOR
Table( );
Table(const Table& source);
~Table( );
// MODIFICATION MEMBER FUNCTIONS
void insert(const RecordType& entry);
void remove(int key);
void operator =(const Table& source);
// CONSTANT MEMBER FUNCTIONS
void find(int key, bool& found, RecordType& result) const;
bool is_present(int key) const;
private:
Node<RecordType> *data[TABLE_SIZE];
size_t total_records;
// HELPER FUNCTION
size_t hash(int key) const;
Node<RecordType>* find_node(int key) const; };
```
Assume the following Node template declaration:
```    template <class Item>
struct Node     {
Item data;
```
Use the following type for all records:
```   struct MyRecType {
int key;
int data;     };
```

1. For each of the following, write a C++ program segment that accomplishes the stated objective. Table accesses must use only the public members of the Table class. Declare all variables used in your program segment.

• Declares a Table (see above for record type) named mytable and inserts the data value 12 with a key value of 5 into mytable.
```

```

• Assigns the value true to the variable found_it if there is a record with a key value of 5 in the Table named mytable. Assigns false to found_it otherwise. The table must be declared but you may assume that it is initialized elsewhere in the program.
```

```

• State the formula that gives the (approximate) average search time for chained hashing in terms of the load factor a.
```

```
• Recall that the average search time for open-address hashing with basic linear probing is T = (1/2) (1 + 1/(1-a)), where a is the load factor. Calculate the average search time for a table with a storage array of 1200 positions, of which 800 are occupied.
```

```
• Calculate the big-O running time of the following function half() in terms of n.
```size_t half(size_t n) {
if (n <= 1) return 0;
else return half(n/2); }

```

2. Implement the Table member function is_present() specified below without using any linked list toolkit functions. Use the private member variables defined above. Note that this is a chained hashing implementation.
```//   bool is_present(const int& targetkey) const
//     Postcondition: The return value is true if there is a record in the
//     Table with the specified key. Otherwise, the return value is false.

```

3. Suppose you've taken on a job as a grader in the CS department. The 30 exams you've just graded are sitting in a randomly ordered pile on your desk. The professor (your boss) has asked you to return the graded exams to him/her in a sorted pile, with the highest grades at the top of the pile.

• One method you can use is to transfer the exams from the unsorted pile to a second, sorted, pile one exam at a time, placing each exam from the first pile in its correct location in the second pile at each step. What sorting method covered in class does this correspond to?
```

```

• Calculate exactly how many steps are required to sort the 30 exams using the method described above, in the worst case. The unsorted pile should be thought of as a stack, with access only from the top. The second pile should be thought of as a list with a cursor, as in HW3. Examining the current exam in the sorted pile and comparing its score to that of the exam currently on top of the unsorted pile counts as one step. Moving the exam currently at the top of the unsorted pile to some location in the sorted pile counts as an additional step.
```

```

4. Fill in the blanks below to obtain a correct implementation of the quicksort algorithm. Assume that the partition function returns the correct value in the pivot_index argument.
```void quicksort(int data[ ], size_t n)
{
size_t pivot_index; // Array index for the pivot element
size_t n1;          // Number of elements before the pivot element
size_t n2;          // Number of elements after the pivot element

if (n > 1)
{
// Partition the array, and set the pivot index
partition(data, n, pivot_index);

// Compute the sizes of the subarrays
n1 = _______________;
n2 = _______________;

// Recursive calls to sort the subarrays
quicksort(_________________________,_________________________);
quicksort(_________________________,_________________________);
}
}
```

5. Circle all true statements among those on the following list:
```   Every AVL tree is balanced in the sense that all of
its leaf nodes are at the same depth.

Insertion sort is faster than mergesort for array sizes
less than 20 or so.

A derived class inherits all members of the base class
as public members.

A graph with n nodes has an adjacency matrix of size nxn

```