Start work on chapter 1 exercises.

This commit is contained in:
Kyle Isom 2017-12-18 20:30:48 -08:00
parent f7beea9779
commit a35b54f308
4 changed files with 74 additions and 1 deletions

1
.gitignore vendored Normal file
View File

@ -0,0 +1 @@
data/corpus.txt

BIN
data/corpus.txt.gz Normal file

Binary file not shown.

View File

@ -65,4 +65,41 @@ A USet where order matters. Its interface only changes in the `find` function:
* `find(x)`: find the smallest y s.t. y >= x. thereby returning a useful value * `find(x)`: find the smallest y s.t. y >= x. thereby returning a useful value
even if x isn't in the set. AKA successor search. even if x isn't in the set. AKA successor search.
Difference between USet and SSet Difference between USet and SSet: sorting requires more steps (run time) and
complexity. A USet should be used unless an SSet is explicitly required.
## Mathematical background
(See notebook).
## The model of computation
Proper analysis requires a mathematical model of computation. The model in the
book is on a w-bit word-RAM model.
* we can access cells of memory, each of which stores a w-bit word
* basic operations (arithmetic and logical) take constant time
* cells can be read or written in constant time
* the memory manager allows allocating a block of k cells of memory in O(k)
time
* size constraint: w >= log(n) where n is the number of elements stored in a
data structure
* data structures use a generic type T such that T occupies one word
## Correctness, time complexity, and space complexity
Three factors for analysing a data structure:
* correctness: data structure must implement the interface
* time complexity: run times of operations on the data structure should
be as small as possible
* space complexity: the storage space used by a data structure should be
as small as possible
Run times come in three flavours:
1. Worst-case: an operation never takes longer than this
2. Amortized: if a data structure has an amortized run time of f(n), then
a sequence of m operations takes at most m f(n) time.
3. Expected: the actual run time is a random variable, and the expected
value of this run time is at most f(n).

35
src/ch01ex01.cc Normal file
View File

@ -0,0 +1,35 @@
#include <cstdlib>
#include <queue>
#include <iostream>
#include <sstream>
#include <string>
using namespace std;
// Solve the following problems by reading a text file one line at a time
// and performing operations on each line in the appropriate data structure(s).
// Your implementations should be fast enough that even files containing
// a million lines can be processed in a few seconds.
// Read the input one line at a time and then write the lines out in
// reverse order, so that the last input line is printed first, then the
// second last input line, and so on.
static void
problem1(const char *path)
{
return;
}
// main should just execute the problems in sequence.
int
main(int argc, char *argv[])
{
if (argc != 2) {
cerr << "No input file specified, exiting." << endl;
exit(1);
}
problem1(argv[1]);
}