Data Structures CSci 1200 Test 2 Questions

Transcription

1 Overview Data Structures CSci 1200 Test 2 Questions Test 2 will be held Thursday, March 10, 2010, 12:00-1:30pm, Darrin 308. No make-ups will be given except for emergency situations, and even then a written excuse from the Dean of Students office will be required. Purpose: Check your understanding of the basics of (a) classes, (b) pointers and dynamic memory, (c) vector and string class implementation, (d) lists and iterators, and (e) programming problems associated with each of these. Coverage: Lectures 6-11, Labs 4-6, HW 3-4. Coverage of the material in Lecture 11 will be relatively minor if you can write Checkpoint 3 of Lab 6 you will be fine! Closed-book and closed-notes. At the start of the test, we will provide a handout summary of important C++ syntax, including standard library classes. Below are sample questions. Solutions will be posted on-line. These questions cover material that may not have been as well covered in labs and homeworks. The test questions will be closely tied to these questions, and to the lecture, homework and lab problems. How to study? Work through the sample questions, writing out solutions! You are encouraged to work with other students. Review and re-do lecture exercises, lab and homework problems. Identify the problems that cause you difficulty and review lecture notes and background reading on these topic areas. Note that the questions on classes from the test 1 practice are still relevant and should be reviewed. Questions 1. Given an array of integers, intarray, and a number of array elements, n, write a short code segment that uses pointer arithmetic and dereferencing to add every second entry in the array. For example, when intarray is and n==9, the segment should add to get 22. Store the result in a variable called sum. sum = 0; for ( int *p = intarray; p < intarray+n; p+=2 ) sum += *p; 2. Show the output from the following code segment. int x = 45; int y = 30; int *p = &x; *p = 20;

2 cout << "a: x = " << x << endl; int *q = &y; int temp = *p; *p = *q; *q = temp; cout << "b: x = " << x << ", y = " << y << endl; int * r = p; p = q; q = r; cout << "c: cout << "d: *p = " << *p << ", *q = " << *q << endl; x = " << x << ", y = " << y << endl; a: x = 20 b: x = 30, y = 20 c: *p = 20, *q = 30 d: x = 30, y = Write a function that takes an array of ints and copies the even integers into a dynamically-allocated array of ints, storing the values in in reverse order. For example, given an array containing the 12 values 5, -1, 4, 0, 13, 27, 98, 17, 97, 24, 98, 89 the resulting array should contain the values (in order) 98, 24, 98, 0, 4 after the function is completed. When doing dynamic allocation, you may only allocate enough space to store the actual numbers, and no more. Also, you may only allocate the array once, not in a loop. The return type of the function must be. Start by specifying the function prototype. Think carefully about the parameters needed and their types. Repeat the problem using pointers instead of array subscripting. Give an O estimate for both of your solutions. One challenge here is how to pass the resulting array. Two reference parameters are needed. One is a pointer to the dynamically-allocated array and the second is an integer giving the size of the array. Here is the result: even_integers_reversed( int a[], int n, int* & b, int & m ) m = 0; for ( unsigned int i=0; i<n; ++i ) // count even values if ( a[i] % 2 == 0 ) ++m; b = new int[m]; int i=0; // index into array pointed to by b for ( int j=n-1; j>=0; j-- ) // go backwards through a if ( a[j] % 2 == 0 ) b[i] = a[j]; ++ i; 2

3 Here is the pointer version even_integers_reversed( int a[], int n, int* & b, int & m ) m = 0; for ( int* p = a; p < a+n; ++p ) // count even values if ( *p % 2 == 0 ) ++m; b = new int[m]; int * q = b; // index into array pointed to by b for ( int* p = a+n-1; p>=a; p-- ) // go backwards through a if ( *p % 2 == 0 ) *q = *p; ++ q; Both versions are O(n). In both cases separate (non-nested) loops through array a. In each loop, a constant amount of work is done per iteration and there are n loop iterations. This gives O(n) per loop, but since they are in sequence, the total cost is O(n) overall. 4. Write code that (a) uses pointers to dynamically allocate an array of n doubles, (b) reads n doubles into the array from cin, and (c) then, in a separate loop, outputs the differences between consecutive doubles, all on one line. For example, if n==5 and the input is then the output should have the 4 values In the loop for part (b) you may use subscripting. In the loop for part (c) no subscripting may be used and no integer counting variables may be employed; in this part everything must be done using pointers. double * arr = new double[n]; for ( unsigned int i=0; i<n; ++i ) cin >> arr[i]; for ( double *p = arr; p<arr+n-1; ++p ) cout << *(p+1) - *p << ; cout << \n ; 5. Write a Vec<T> class member function that creates a new Vec<T> from the current Vec<T> that stores the same values as the original vector but in reverse order. The function prototype is Vec<T> Vec<T>::reverse() const; Recall that Vec<T> class objects have three member variables: 3

4 T* m_data; // Pointer to first location in the allocated array size_type m_size; // Number of elements stored in the vector size_type m_alloc; // Number of array locations allocated, m_size <= m_alloc The confusing part of the problem is that the new vector being created is not the current object the object the member function is called on. Instead it is created as a local variable. Still, since we are inside the Vec class, we have direct access to its member variables. The solution uses pointers, but subscripting would work just as well. Vec<T> Vec<T>::reverse( ) const Vec<T> new_vec; new_vec.m_size = new_vec.m_alloc = m_size; new_vec.m_data = new T[new_vec.m_size]; for ( T * p = new_vec.m_data, *q = m_data+m_size-1; q >= m_data; p++, q-- ) *p = *q; return new_vec; 6. Write a code segment that copies the contents of a string into a list of char in reverse order. // assume the string is s and s has been initialized list<char> result; for ( int i=0; i<s.size(); ++i ) result.push_front( s[i] ); 7. Recall that each container class has its own associated erase function, which accepts an iterator as an argument, erases the contents of the container referenced by the iterator, and returns a new iterator that references the next location in the container. Is erase more efficient for std::list or std::vector or is the efficiency the same? Briefly justify your answer. The function is more efficient for a list because it just requires a view pointer manipulations and therefore is a constant time operation. On the other hand, the vector operation is O(n) because all values above the iterator location need to be copied down. 8. Write a templated function that determines whether or not the values in a std::list are in increasing order. The function prototype is bool is_increasing( std::list<t> const& t ) You must assume that operator< is defined for type T. bool is_increasing( std::list<t> const& t ) if ( t.size() <= 1 ) return true; 4

5 std::list<t>::const_iterator p, q; p = q = t.begin(); // refers to current value q ++; // refers to next value while ( q!= t.end() ) if ( *p > *q ) return false; p ++; q ++; return true; // no misordering found // misordering found 9. Write a function named filter that takes in a single argument, words, that is a list of strings that are lowercase three-letter words. Your function will remove words from the list as necessary such that in the end, no words have any common characters. For example, given the input sequence of strings: cat bat dog too use zoo won you ace zip bin leg The words bat, too, and ace are removed because they have a common character with cat. The words zoo, won, you, and leg are removed because they have a common character with dog. And the word bin is removed because it has a common character with zip. Then after calling filter the variable words contains these strings: cat dog use zip bool common_char(const string &a, const string &b) for (int i = 0; i < a.size(); i++) for (int j = 0; j < b.size(); j++) if (a[i] == b[j]) return true; return false; filter(list<string>& words) list<string>::iterator i,j; i = words.begin(); while (i!= words.end()) j = i; j++; while (j!= words.end()) if (common_char(*i,*j)) cout << *i << " removes " << *j << endl; j = words.erase(j); else j++; 5

6 i++; 10. Write a function that takes an array of ints and copies the even integers into a dynamically-allocated array of ints, storing the values in in reverse order. For example, given an array containing the 12 values 5, -1, 4, 0, 13, 27, 98, 17, 97, 24, 98, 89 the resulting array should contain the values (in order) 98, 24, 98, 0, 4 after the function is completed. When doing dynamic allocation, you may only allocate enough space to store the actual numbers, and no more. Also, you may only allocate the array once, not in a loop. The return type of the function must be. Start by specifying the function prototype. Think carefully about the parameters needed and their types. Repeat the problem using (a) pointers instead of array subscripting and (b) returning the even integers in a vector instead of an array. Give an O estimate for each. One challenge here is how to pass the resulting array. Two reference parameters are needed. One is a pointer to the dynamically-allocated array and the second is an integer giving the size of the array. Here is the result: even_integers_reversed( int a[], int n, int* & b, int & m ) m = 0; for ( unsigned int i=0; i<n; ++i ) // count even values if ( a[i] % 2 == 0 ) ++m; b = new int[m]; int i=0; // index into array pointed to by b for ( int j=n-1; j>=0; j-- ) // go backwards through a if ( a[j] % 2 == 0 ) b[i] = a[j]; ++ i; Here is the pointer version even_integers_reversed( int a[], int n, int* & b, int & m ) m = 0; for ( int* p = a; p < a+n; ++p ) // count even values if ( *p % 2 == 0 ) ++m; b = new int[m]; int * q = b; // index into array pointed to by b for ( int* p = a+n-1; p>=a; p-- ) // go backwards through a if ( *p % 2 == 0 ) 6

7 *q = *p; ++ q; The vector version requires that we go backward through a, but only one time. even_integers_reversed( int a[], int n, vector<int> & b ) b.clear(); for ( int j=n-1; j>=0; j-- ) // go backwards through a if ( a[j] % 2 == 0 ) b.push_back( a[j] ); All versions are O(n). In the first two cases there are two separate (non-nested) loops through array a. In each loop, a constant amount of work is done per iteration and there are n loop iterations. This gives O(n) per loop, but since they are in sequence, the total cost is O(n) overall. The argument is even simpler for the vector version as long as we can assume push_back is constant time, which it is on average. 11. Write a function that rearranges a list of doubles so that all the negative values come before all the non-negative values AND the order of the negative values is preserved AND the order of the positive values is preserved. For example, if the list contains -1.3, 5.2, 8.7, 0.0, -4.5, 7.8, -9.1, 3.5, 6.6 Then the modified list should contain -1.3, -4.5, -9.1, 5.2, 8.7, 0.0, 7.8, 3.5, 6.6 Solve it in four different ways: (a) Assume the values are in a std::list<double>. scratch space. Rearrange the values using an extra list as (b) Assume the values are in a std::list<double>. Rearrange the values without using an extra list (or any other extra container). Here s an in-place solution which does not use an extra list. Whenever a non-negative number is seen it is removed and placed on the back of the list. Negative numbers are skipped. The trick to ensuring this works is using a separate counter to ensure that all items in the list are tested exactly once. Otherwise, some will be examined multiple times. rearrange( list<double>& dbl ) unsigned int sz = dbl.size(); unsigned int i; list<double>::iterator itr = dbl.begin(); for ( i=0; i<sz; ++i ) if ( *itr < 0 ) ++ itr; else 7

8 dbl.push_back( *itr ); itr = dbl.erase( itr ); Here s a second solution which uses an extra list and two passes through the list. The first pass puts the negative numbers on the front and the second pass puts the positive numbers on the back. rearrange( list<double>& dbl ) list<double> temp; list<double>::iterator i; for ( i = dbl.begin(); i!= dbl.end(); ++i ) if ( *i < 0 ) temp.push_back( *i ); for ( i = dbl.begin(); i!= dbl.end(); ++i ) if ( *i >= 0 ) temp.push_back( *i ); dbl = temp; 12. Using the following Node<T> class class Node public Node * next; T value; Node( const T & v ) : value(v), next(0) ; write a function that takes a pointer to the head of a singly-linked list and returns a pointer to the head of a new linked list that is a copy of the linked list. Here is the prototype Node<T>* copy_list( Node<T>* head ) Node<T>* copy_list( Node<T>* head ) if (!head) return 0; // empty list Node<T> * nh = new Node<T>( head->value ); Node<T> * nt = nh; // Go through the existing list front to back, copying nodes, // adding them to the tail and updating the tail. 8

9 Node<T> * q = head->next; while ( q ) Node<T> * p = new Node<T>(q->value); nt->next = p; nt = p; return nh; 9