What we are looking for in this problem is a standard traversal of a 2D array. When you do this, you need to make sure that you iterate through both the rows and the columns. In order to do this, you first must set up a loop like:

for(int i = 0; i < vals.length;i++) {...

The value of vals.length indicates the number of rows in the 2D array.

Now, for each row, you have a certain number of columns. (A 2D array is like an "array of arrays".) Thus, for each row, you need to run through the entire set of columns for that row:

for(int j = 0; j < vals\[i\].length; j++) { ...

Notice that none of the incorrect questions use vals\[i\].length in this way. Thus, none of them iterate through the two dimensions of the array correctly.

Of course, this is an inefficient way to do such a delete, but arrays are rather "locked" data structures in that their size cannot change without a reassignment. (You could, of course keep track of the last "used" index. However, that is a different implementation, not reflected here.) The correct answer is the one that carefully goes through the original array, copying those contents into the new array skipping the one value that is not wanted.

This code simulates the removal of a value from an array by shifting all of the elements after that one so that the array no longer contains the first instance of that value. So, for instance, this code takes the original array {3,4,4,5,17,4,3,1} and notices the first instance of 4: {3,**4**,4,5,17,4,3,1}. Next, it starts shifting things to the left. Thus, some of the steps will look like this:

{3,4,4,5,17,4,3,1}

{3,4,5,5,17,4,3,1}

{3,4,5,17,17,4,3,1}

...

{3,4,5,5,17,4,1,1}

Then, at the very end, it sets the last element to 0:

{3,4,5,17,4,3,1,0}

Use a for loop to traverse the list. The .size() method is used for Lists as opposed to the .length method for arrays. The .get() method is used for Lists as opposed to accessing the index for arrays.

It is easiest to understand this by a bit of code parsing:

First, there is the loop: for(int j = 0; j < x; j++) { // ...

This will fill the array with 20 + 0, 20 + 40, 20 + 80, ... Thus, it will be:

20, 60, 100, 140, 180, 220

Next, there is the array: for(int j = x; j > i; j--) { // ...

This basically shifts everything after index i backward by 1. Thus you have:

20, 60, 100,100, 140, 180, 220

Next, you set arr\[2\] equal to 20:

20, 60, 20,100, 140, 180, 220

Finally you output each of the first 6 elements. Be careful here. Notice that it is from j = 0 to x - 1!

Thus, the answer is:

20 60 20 100 140 180

This algorithm basically implements a simple kind of array deletion.

A quesiton like this is most easily understood by doing a careful reading of the code in question. Let's consider each major section of code:

int[] ret = new int[arr.length + 1];

This line of code creates a new array, one that is 1 longer than the array arr.

for(int i = 0; i < index; i++) . . .

This loop copies into ret the values of arr up to index - 1.

(This is because of the i < index condition)

Then, the code stores the value val in ret[index]

_for(int i = index + 1; i < ret.length; i++) . . ._

It then finishes copying the values into ret.

Thus, what this does is insert a value into the original array arr, returning the new array that is one size larger. (This is necessary because of the static sizing of arrays in Java.)

The most obvious possible error is that the array arr might be a null value. You need to check for these kinds of values before using the variables. (If you do arr[0] on a null value, an exception will be thrown.) In addition, it is possible that a value for index might be given that is too large. Consider if index = 100 but arr is only 4 elements long. Then, you will have ret be a 5 value array. When the first loop starts to run, you will go all the way to 99 (or at least attempt to do so) for the index value i_; h_owever, once you get to ret[4] = arr[4], there will be an out of bounds error on arr, which only has indices 0, 1, 2, and 3. Of course, there could be other problems later on with ret, but the question only asks about this first loop.

Let us presume that the array arr looks like the following list of integers:

{4,51,41,0,0,0,0,0,0,0}

Presume that our new value is 77.

A stack could either push on to the beginning and move everything back one, giving you something like:

{77,4,51,41,0,0,0,0,0,0}

However, none of the options do this. (No, not even the one that uses the index 0. This one does not add on to the array so much as replace the first element of it.)

So, the other option is to put it on the "end" of the list. The variable arrFill is being used for this purpose. If it is 3, this means that it is the value of the fourth element. Thus, you can set arr\[4\] = 77 (where 4 really is arrFill).

This will give you:

{4,51,41,77,0,0,0,0,0,0}

You also need to add one to the value of arrFill.

The other options do not correctly address the array. They either are too large or too small by one.

Insertion into an ArrayList is typically O(1). However, since an ArrayList uses an array as its underlying data structure, there can be a need to resize the underlying array. Resizing an array requires creating a new array and copying all the data from the old array to the new array which takes O(N) time.

The code given is a standard implementation of a binary tree containing an insert and a parse method. For now, you can merely pay attention to your parse logic, particularly just the logic that will be invoked for the indicator value PARSE_IN. (Notice that this is merely in the else of the parse method. This is a "catch all" / default in case a bad value is given for the parse order.)

retVal.addAll(leftList);

retVal.add(node.name);

retVal.addAll(rightList);

This is just the standard binary tree style of parsing based on our insert. The smaller items are on the left of the current node, and the larger ones are on the right of it. Thus, you have:

List of all smaller values + This current value + List of all larger values

Recursively, this will end with an ordered list, which is just what you need.

This code is a standard implementation of a Binary Tree class. The call that we are making in main is meant to parse the tree (traverse it) in post-fix order. This means that we will always look to the left of each node first, then to the right, then finally to the value we are at. However, the tree is unbalanced, so the parsing will do much more right traveral than anything else. See the following sequence of inserts:

Step 1:

Step 2:

Step 3:

Step 4:

Step 5:

Now, your traversal path will look like this:

Interestingly, this means that you will end up with a list that is in reverse order. This is only the case for the given data as it happened to have been inserted.

The first call is in the declaration. Because 6 > 1, it calls recur, which makes the total 2.

Next, it calls recur(6/2). Because 3 > 1, it calls recur again, which makes the total 3.

Next, it calls recur(3/2). Because it's dividing integers, this evaluates to recur(1).

Because 1 <= 1, it doesn't call recur anymore, so that total number of calls is 3.

When a preorder traversal is done, you go through the following:

1. ROOT

2. LEFT CHILD

3. RIGHT CHILD

Therefore, starting at the root (1), we go to the LEFT node (2). That node however, is the root/parent of other nodes, so we go left again (4). That node is a parent/root, so we go left (5). Now it's time to go to the right; however, only node 1 has a right child, so going to the right of one we land at (3). That node is the parent/root of more children so we go left (6). Node 6 doesn't have any left children, but it does have a right so we go right (8). Node 8 has a left child to traverse (9) and then a right (5). And we finish the traversal by going to the right of three (7). This is a rather complicated example; however, make sure you can traverse the tree properly.

In the above image, you can see the approach of the pre-order traversal. First you go through the roots, then the left trees, then the right trees. Make sure that if you're guiding yourself by the image above, that you don't repeat the nodes that you already traversed. Understanding the algorithm is key.

The correct answer is:

1

3

The important line here is the if statement, which only executes if (a%2==0) is true, or if the loop counter divided by 2 is 0. A possible error is to divide each element of the array by 2 instead of the loop counter. So the println statement will only execute if the loop counter is even, which happens on the 1st itteration (a=0) and the 3rd itteration (a=2). The for loop ends at arr.length-1, which means that a takes on a maximum value of 3, and not 4 (choosing the option 1 3 5 would mean you did not notice the bounds on the for loop). Finally, println prints a new line every time, so, it is not possible for all the integers to be on one line, as println is executed twice.

In this case, the names help to identify the different types of traversals. In order traversal processes the binary tree "in order", meaning it will go through the left subtree, process the node, then go on to the right. Why is this in order? Because remember, a binary sort tree lists any value less than the node to the left, and any value greater to the right, so in order traversal will actually go from greatest to smallest.

Preorder traversal is the same except that it processes the root node first, hence the "pre" order.

The first thing to notice in the code for the method foo is that it implements the algorithm for a binary search. The value c functions as the midpoint for the algorithm. This requires that the list be in order. The values a and b are used to control the loop so as to let you search the correct portions of the list. If the value in the middle of the list is not equal to what you are looking for (i.e. x), then it looks either "above" or "below" in the list (since it is presumed to be in order). This is what is happening when either a or b is changed.

So, this searches for the value and returns the index number for that value if it is found. Otherwise, it returns -1. Since the value 41 is in the array, it returns 6.

If you do not recognize this algorithm, you are likely to have some problems—and will have to trace the code!!

The binary search presumes that the array being searched is already sorted. This is because of how it probes the values in the array. It begins at the center of the array to see if the values match. If the value is smaller than this center element, it then presumes that the value is in the lower half of the array. Otherwise, it presumes that the value must be larger and hence in the upper half of the array. It then probes the center of whichever half it has chosen, continuing to do this until the value has certainly not been found.

The basic way to implement a sequential search is to test each element of an array until you match the value you want to find. All of these possible answers are very close to doing this. They all iterate through the given array. They all do check for the value. However, one option (with the if-else logic) could return false even if the element was found, for it continues to run after it is found. If another value does not match later in the array, the variable success will then be set to false. This will be returned, indicating failure to find the value. The integer-returning method seems to be fine, but it would be ambiguous if the value for the search is negative one. In this one case, this return value will not signal necessarily that it has been found—it could be just the "flag" indicating that nothing was found. Thus, the simplest method is the best here: return true as soon as it is found.

To make this question much easier, first notice that the foo method implements a sequential search. (This is a search that merely goes through each element of an array and sees if it equals the probe value.) It returns the index if it is found. Otherwise, it returns -1. Now, in the code block in the question itself, the loop iterates for i = 0 to i = 19. It will only execute a search, however, on the values 0...3. This is because of the modulus operator. Thus, it will do (from 0 to 19), 0...3 a total of five times. Thus, it will probe for 1 and 3 five times—these are each in the array. So, the word "Indubitably!" will be output a total of ten times.

Sequential search has a running time of O(N). Binary search has a running time of O(log(N)). Because sequential search has to go through each element in a list at least once it's less efficient.