Errata

I was trying to follow the put and get functions for the Separate Chaining section of Chapter 8: Hashing, and I was confused that the put function only accepted a data arg.

Here's what i see in the text:

Next we need to define the put() and get() functions that will work with separate chaining. The put() function hashes the key and then attempts to store the data in the first cell of the chain at the hashed position. If that cell already has data in it, the function searches for the first open cell and stores the data in that cell. Here is the code for the put() function:
function put(data) {
var key = this.betterHash(data);
var index = 0;
if (this.table[key][index] == undefined) {
this.table[key][index] = data;
}
else {
while (this.table[key][index] !== undefined) {
++index;
}
this.table[key][index] = data;
}
}


However, the get function looks like this:

function get(key) {
var index = 0;
var pos = this.betterHash(key);
if (this.table[pos][index] == key) {
return this.table[pos][index+1];
}
else {
while (this.table[pos][index] != key) {
index += 2;
}
return this.table[pos][index+1];
}
return undefined;
}

Based on the get function and the description, shouldn't the put function look something like this?

var put = function(key, data) {
var pos = this.betterHash(key);
var index = 0;
if (typeof this.table[pos][0] === 'undefined') {
this.table[pos][0] = key;
this.table[pos][1] = data;
} else {
while (typeof this.table[pos][index] !== 'undefined') {
++index;
}
this.table[pos][index] = key;
this.table[pos][index+1] = data;
}
};

print() statement is used in javascript.

In the description of the algorithm, point 2, it says: 'Replace n with n/b'.
This should be: 'Replace n with the floored value of n / b'

Further down, in the JavaScript implementation of the algorithm, the value is correctly floored with Math.floor().
However, in this line a superfluous equal sign can be found, the whole line is:
num = Math.floor(num /= base);

num /= base divides num by base and assigns the value to num, which is then floored and assigned to num again. Much simpler would be:

num = Math.floor(num / base);

// It takes the last element to the infinite loop

for(names.front(); names.currPos() < names.length(); names.next()) {
print(names.getElement());
}


as next() function never increments after the listSize()-1
function next(){
if(this.pos < this.listSize - 1){
++this.pos;
}
}

//Same for this
for(names.end(); names.currPos() >= 0; names.prev()) {
print(names.getElement());
}

//It never decrements the value after 0 so the loop never terminates
function prev(){
if(this.pos > 0){
--this.pos;
}
}

"since we can use the split() function without having to perform additional array element accesses."

It should be splice() not split, the split() method is method of String .

The insert algorithm has an error, because it does not take care of the currNode.next.previous value - aka successor of the new node.

The successor of the new node should point back (previous value) to the new node:

newNode.next = current.next;
newNode.previous = current;

// this condition is true when the new node is not inserted
// at the end of the list
if (current.next) {
current.next.previous = newNode;
}

current.next = newNode;

JavaScript does not have a `for each()`

This error occurs in 8 different locations.

"Here is a program to test the `put()` and `get()` functions:"

The code does not use `pnumbers.put()` anywhere.

`hTable.put(someNames[i])` is not setting `data` in `arguments[1]`. As a result, the `undefined` condition within `showDistro()` will always be `true`.

You cannot put code between `if` and `else`. Additionally, your logic seems flawed.

- In `put()`, if the current index is undefined, set new data to the following index?

- In `get()`, why does it return data from the adjacent key? If just for the sake of returning data in cases of collision, you should explain the reasoning in the text. Also, why the `index += 2`? Also, `var hash` should be `var pos`.

Here is a jsFiddle of your code failing: http://jsfiddle.net/noyy41ur/

Perhaps this is what you were trying to do?: http://jsfiddle.net/noyy41ur/1/

all of the codes parts of BFS and DFS and find the shortest path do not works or give wrong results.

There is no this.edgeTo() function defined. Thought it was to call bfs recursively, tried, but didn't work on my code - had no time to review well:

for each(var w in this.adj[v]){
if(!this.marked[w]){
this.bfs(w);
}
}

in function pathTo, path.push(s) should say path.push(source)

In the description of mergesort it is stated that "It is customary, though not necessary, to implement Mergesort as a recursive algorithm. However, it is not possible to do so in JavaScript, as the recursion goes too deep for the language to handle."

This is flat-out wrong. Mergesort is a classic divide-and-conquer algorithm. For an array of length 2^N, the number of recursive calls on the call stack will be approximately N. Using a well implemented recursive mergesort, in order to reach a recursive depth exceeding the call stack size of virtually any JavaScript implementation, you would need to be operating on an array with something like 10^300 or more elements (and more like 10^6000 for many modern browser implementations).

It is very possible to implement a recursive mergesort, the language absolutely can handle it, and the recursion does not go too deep. A good example of a recursive mergesort implemented in JavaScript can be found here: http://www.nczonline.net/blog/2012/10/02/computer-science-and-javascript-merge-sort/

Figure 13.1 should refer to min search, but in my edition I see the a figure related to the binary search.