Logical Design Operation, A Simple Questions?
It's been a long time since I've done this the long way.

The Truth Table 

The first step for learning what these circuits do is to create a truth table. Perhaps you already know how to do this, but didn't know it was the first step, we'll go over it in any case. I'll work out the first example circuit.

Make columns for each of your inputs and outputs. Sometimes it's easier to also make columns for intermediate values, just to help you determine the final outputs. You have A, B, and C as inputs, the output of the mux is not labeled, but it is the output for this circuit.

+---+---+---+-----+
| A | B | C | Out |
+---+---+---+-----+


Now fill out the possible inputs. You'll only want to do this for truth tables with fewer than four or five inputs, they get too big otherwise. I always start with the rightmost input and alternate between writing one 0 and one 1 while filling out the rows. There are three inputs, so that means there are eight possible permutations (2^3). For the next input to the right you fill in by alternate between writing two 0's and two 1's while filling out the rows. The final input by alternate between writing four 0's and four 1's while filling out the rows. That's just how I used to do it; find your own best way. The rows are just counting up in binary.

+---+---+---+-----+
| A | B | C | Out |
+---+---+---+-----+
| 0 | 0 | 0 |     |
+---+---+---+-----+        
| 0 | 0 | 1 |     |
+---+---+---+-----+
| 0 | 1 | 0 |     |
+---+---+---+-----+
| 0 | 1 | 1 |     |
+---+---+---+-----+
| 1 | 0 | 0 |     |
+---+---+---+-----+
| 1 | 0 | 1 |     |
+---+---+---+-----+
| 1 | 1 | 0 |     |
+---+---+---+-----+
| 1 | 1 | 1 |     |
+---+---+---+-----+


Now fill it in with the obvious stuff first. For instance, since A is controlling the mux, anytime its equal to 1, the output is simply NOT B. That takes care of the bottom half of the table. 

For the other half, when A is 0, the output is simply B AND C.

+---+---+---+-----+
| A | B | C | Out |
+---+---+---+-----+
| 0 | 0 | 0 |  0  |
+---+---+---+-----+        
| 0 | 0 | 1 |  0  |
+---+---+---+-----+
| 0 | 1 | 0 |  0  |
+---+---+---+-----+
| 0 | 1 | 1 |  1  |
+---+---+---+-----+
| 1 | 0 | 0 |  1  |
+---+---+---+-----+
| 1 | 0 | 1 |  1  |
+---+---+---+-----+
| 1 | 1 | 0 |  0  |
+---+---+---+-----+
| 1 | 1 | 1 |  0  |
+---+---+---+-----+


The Equation

By looking at it piecewise like that, what you're really doing is translating the circuit into sentences, those sentences can then be described with boolean equations.

The sentences were:

If A, then the output is NOT B.

If NOT A, then the output is B AND C.

In terms of the output this means that the output is true when either B AND C is true and NOT A is true or A is true and NOT B is true. 

Thus the equation is Output = (~A &amp; (B &amp; C)) | (A &amp; ~B).

That method may be too difficult for you at first. The long way for the equation is to write out the equation for each row of the truth table and reduce the logic with boolean algebra. You should do that once, then learn how to draw a karnaugh map and write the equation from the reduced logic produced by that.