1)L'hospitals' rule is to take the ratio of two functions
and apply the limit.

Limit n-> indinity log(n)/n^0.5, becomes the ratio of infinity by infinity.
Taking the derivative at the numerator youget 1/n and the derivative fo the
denominator is 1/(2 sqrt(n)). So their ratio becomes 2/sqrt(n), as limit n 
tends to infinity, the ratio becomes 0. That is the n^0.5 (sqrt(n) 
grows more rapidly than log(n).

optional: Let log(n) =p, then log(log(n)) becomes log(p) and log(n)^2  becomes p^2
and hence log(p) grows slower than p^2.

2. (7,10^6), log(log(n)), 3 ^ sqrt(log(n)), n, 0.5 n log(n+5), n^(4/3), n^5,
n ^log(n), (3/2)^n, 3^n, n 3^n, n!, n^n, 3^3^n, 

3. MERGE3 (A, B, C)
    return MERGE2(A, MERGE2(B,C));

MERGE2 is the merge function in merge sort - this has worst complexity of 
O(length(A)+length(B)+length(C)); However, elements in B and C are looked twice.
Either the  one given above or the one given below is acceptable.
 
Below is more an efficient algorithm but assumes modifying of the parameter (locally) 

 function merge3(A,B,C)
    var list result
    var left = A, middle = B, right = C;
    Extend the lists left, middle and right by 1 and set those new elements
    to infinity.
    set the length of D be length(A)+length(B)+length(C)
    a=1, b=1, c=1; d=0;
    while (d < length (D))
      {
       if (left[a] < middle[b] )
            if (left[a] < right[c])
	      {
                d++;
               D[d] = left[a];
               a++;
              }
             else
              {
	       d++        
               D[d] = right[c];
               c++
               }
       else
          if (middle [b] < right[c])
	     {
               d++;
               D[d] = middle[b]
               b++
	       }
           else
	     {
               d++
               D[d] = right[c]
               c++
             }
       }


4. MERGE3SORT(A)
   {
     if (lebngth(A) <=1) return A
     else 
       {
         a = floor(1/3*(lenth(A)));
         b = floor(2/3*(lenth(A)));
        create 3 new arrays B, C and D
           B= A[1..a]; C=A[a+1,...,b]; D=A[b+1..length(A)];
        /* a can be 0, if that is teh case B is a zero lengtharray */
        /* one can do a special case for length(A)=2 */
        B1 = MERGE3SORT(B);
        C1 = MERGE3SORT(C);
        D1 = MERGE3SORT(D);
        return MERGE3(B1,C1,D1)
      }
}

5.with constant c = 618, c* n^3 log(n) > 18 n^3 log(n) + 100 n^2 + 500 for
all n > 0 Hence it satisfies the big Oh.

6. with constant c = 1, c* n^3 log(n) < 18 n^3 log(n) + 100 n^2 + 500 for
all n and hence satisfies the Omega. Hence big Oh can be relaced by theta.

7.(optional) n! = 1* 2* ... *n . This is strictly less than n^n = n* n* ...*n. (considering n>0)
Hence n! = O(n^n). Hence log(n!) = O(n log(n))

If we take the last n/2 terms of n!, we get (n/2)*(n/2+1)*...*n this is 
strictly greater than (n/2)*(n/2)*...*(n/2) ( there are n/2 terms).
Hence n! > (n/2)^(n/2). hence log(n!) > n/2 (log(n/2)) > n/2 (log(n) -1) =
omega(nlog(n)) with constant = 1/3. Combining these two, we get a theta
bound.