Trying to figure out Big-O (asymptotic running time)

Question

In class we are working on algorithm analysis big-o and I do not exactly understand it all yet. I have figured out some example that the prof has given us but can figure out some harder ones. If anybody would help me figure this out that would be great as I am trying to figure this stuff out and haven't been able to find a whole lot of good tutorials about it on the net. So for the example codes that he gives us this is what he says to try and do:
[font=Arial]Try to find the asymptotic running time of each of the following public methods. If a method is not public, then it is used by a public method, so try to find its running time also, as part of the justification of the running time of the public method. Find the tightest running time possible (i.e., the lowest running time that is a bound on the method's worst case running time). Express your answer in terms of n, the number of elements in the array when an array is input to the method. Otherwise, express your answer in terms of the magnitude of the input parameter to the method (problems 5 and 6). Assume that any methods which are not defined here (such as equals) take O(1) time, and that all object parameters to methods are not null.[font]
Here are the sample codes that he gives us:
1. public boolean contains(Object[] arr, Object key) {
           for (Object obj : arr)
                if (obj.equals(key))
                     return true;
           return false;
2. // assume arr is sorted in increasing order
     public boolean contains2(Comparable[] arr, Comparable key) {
           return contains2Rec(arr, key, 0, arr.length - 1);
     private boolean contains2Rec(Comparable[] arr, Comparable key, int start, int end) {
          if (end � start < 0)
                return false;
           if (end � start == 0)
                return arr[start].equals(key);
           int mid = start + (end � start) / 2;
           int comp = key.compareTo(arr[mid]);
           if (comp < 0)
                return contains2Rec(arr, key, start, mid - 1);
           else if (comp > 0)
                return contains2Rec(arr, key, mid + 1, end);
           else
                return true;
3. public int numOccurrences(Object[] arr, Object key) {
           int num = 0;
           for (int i=0; i<arr.length; i++)
                if (arr.equals(key))
                    num++;
          return num;
4. public void reverse(Object[] arr) {
          for (int i=0; i<arr.length; i++) {
               int j = arr.length � i - 1;
               Object sw = arr[i];
               arr[i] = arr[j];
               arr[j] = sw;
5. // returns the n'th fibonacci number
     public int fib(int n) {
          if (n < 1)
               throw new IllegalArgumentException("n must be positive");
          if (n == 1 || n == 2)
               return 1;
          return fib(n-1) + fib(n-2);
6. // returns the n'th fibonacci number
     public int fib2(int n) {
          if (n < 1)
               throw new IllegalArgumentException("n must be positive");
          int[] nums = new int[n];
          nums[0] = nums[1] = 1;
          for (int i=2; i<n; i++)
               nums[i] = nums[i-1] + nums[i-2];
          return nums[n-1];
Please help me figure this out! Thank you!
-haryy

Answer 1

Danny,
The theme to Doctor Who is in 12/8. In music theory, there's no such thing as a 12th note, the notation and nomenclature is all based on things being divisible by four. So for the diddly-dum feel to happen, you have to give the beat to a quarter note plus another eighth note -- we call it a dotted quarter note, and now you have three eighth notes per beat so you can go diddly. So, since you can't call the time signature 12/dotted quarter, you call it 12/8 and go faster. Make sense? Anyway, for GB's purposes, all you need to know is that you'll get that feel by choosing 12/8.