34S
February CS106X
Handout 25th, 2011
Winter 2011
CS106B Practice Solution
Solution 1: Linked Lists
a.
Map<string> concatenateMaps(node *maplist) {
Set<string> keys;
for (node *curr = maplist; curr != NULL; curr = curr->next) {
foreach (string key in curr->map) {
keys.add(key);
}
}
Map<string> concatenations;
foreach (string key in keys) {
string value;
for (node *curr = maplist; curr != NULL; curr = curr->next) {
if (curr->map.containsKey(key)) {
value += curr->map.get(key);
}
}
concatenations.put(key, value);
}
return concatenations;
}
b.
void stretchList(node *list) {
int copyCount = 1;
while (list != NULL) {
for (int i = 0; i < copyCount; i++) {
node *newNode = new node;
newNode->value = list->value;
newNode->next = list->next;
list->next = newNode;
list = newNode;
}
list = list->next;
copyCount++;
}
}
2
c.
void BuildSeriallzationArray(node *list, Vector<int>& values) {
if (list == NULL) return;
values.add(list->value);
BuildSeriallzationArray(list->down, values);
BuildSeriallzationArray(list->next, values);
}
node *ArrayToList(Vector<int>& values) {
node *head = NULL;
for (int i = values.size() 1; i >= 0; i--) {
node *newNode = new node;
newNode->value = values[i];
newNode->down = NULL;
newNode->next = head;
head = newNode;
}
return head;
}
node *flattenList(node *list) {
Vector<int> values;
BuildSeriallzationArray(list, values);
return ArrayToList(values);
}
Solution 2: Planetarium Memory Trace
93.1
venus
mars
3
Solution 3: Encoding General Trees
struct genTreeNode {
int value;
Vector<genTreeNode *> children;
};
struct binTreeNode {
int value;
binTreeNode *left;
binTreeNode *right;
};
binTreeNode *encode(Vector<genTreeNode *>& siblings, int start) {
if (start == siblings.size()) return NULL;
binTreeNode *root = new binTreeNode;
root->value = siblings[start]->value;
root->left = encode(siblings[start]->children, 0);
root->right = encode(siblings, start + 1);
return root;
}
binTreeNode *encode(genTreeNode *root) {
Vector<genTreeNode *> rootAsVector;
rootAsVector.add(root);
return encode(rootAsVector, 0);
}
Solution 4: Patricia Trees Revisited
int findChildConnectionIndex(Vector<connection>& children, string word) {
int i = 0;
while (i < children.size() && children[i].letters[0] < word[0]) {
i++;
}
return i;
}
string computeLongestPrefix(string letters, string word) {
int i = 0;
int size = min(letters.size(), word.size());
while (i < size && letters[i] == word[i]) {
i++;
}
return letters.substr(0, i);
}
void insertWord(node *& root, string word) {
if (root == NULL) {
root = new node;
root->isWord = false;
}
if (word.empty()) {
root->isWord = true;
return;
}
int child = findChildConnectionIndex(root->children, word);
if (child == root->children.size() ||
4
root->children[child].letters[0] != word[0]) conn {
connection = {word, NULL};
root->children.insertAt(child, conn);
} // now pretend it was here all along
string prefix = computeLongestPrefix(root->children[child].letters, word);
if (prefix < root->children[child].letters) {
node *splicedNode = new node;
splicedNode->isWord = false;
connection conn = {
root->children[child].letters.substr(prefix.size()),
root->children[child].subtree
};
splicedNode->children.add(conn);
root->children[child].letters = prefix;
root->children[child].subtree = splicedNode;
} // now pretend that this was the structure all along
insertWord(root->children[child].subtree, word.substr(prefix.size()));
}
Solution 5: Dictionaries and Ternary Search Trees
a.)
void Dictionary::add(string word, string definition) {
add(root, word, definition);
}
void Dictionary::add(node *& curr, string suffix, string definition) {
// if were here, were here for a reason and need to make sure
// that curr actually points to something if it doesnt already
if (curr == NULL) {
curr = createNode(suffix[0]); // pretend it was here all along
}
//
//
//
if
if the leading letter of the suffix doesnt match the one held
by the node, then we need to branch left or right without
consuming any characters
(suffix[0] != curr->letter) {
node *& pointer = (suffix[0] < curr->letter) ? curr->less : curr->greater;
add(pointer, suffix, definition);
return;
}
//
//
//
if
if we got this far, then the leading character of the suffix
matches the one within the node. If the suffix happens to be
of length 1, then this is the node that gets the definition.
(suffix.size() == 1) {
if (curr->definitions == NULL)
curr->definitions = new Vector<string>();
curr->definitions->add(definition);
return;
}
// suffix is two or more characaters, but leading character still matches
// the one inside the node, so recur on the tree extending from curr->equals
add(curr->equals, suffix.substr(1), definition);
}
Dictionary::node *Dictionary::createNode(char ch) {
node *newNode = new node;
5
node->letter = ch;
node->definitions = node->less = node->equal = node->greater = NULL;
}
b.)
void Dictionary::mapAll(void (map)(string word, Vector<string>& definitions)) {
mapAll(root, "", map);
}
void Dictionary::mapAll(node *curr, string sofar,
void (map)(string word, Vector<string>& definitions)) {
if (curr == NULL) return;
mapAll(curr->less, sofar, map);
if (curr->definitions != NULL)
map(sofar + curr->letter, *(curr->definitions));
mapAll(curr->equals, sofar + curr->letter, map);
mapAll(curr->greater, sofar, map);
}
c.)
Dictionary::~Dictionary() {
deleteNode(root);
}
void Dictionary::deleteNode(node *curr) {
if (curr == NULL) return;
if (curr->definitions != NULL) delete curr->definitions;
deleteNode(curr->less);
deleteNode(curr->equals);
deleteNode(curr->greater);
delete curr;
}