Static Arrays

• What are the characteristics of an array?
  • Homogeneous
  • Contiguous memory
  • Constant access time.
• What does constant access time mean?
  • To discuss this, we need to think about an array
  • It is a collection of $n$ elements, of a given size $e$
  • 
  • The array starts in memory at address $b$
    • This is sometimes called the base address
  • Location of elements

    Element	Index	Location	Location
    1	0	$b$	$b+(1-1)e$
    2	2	$b+e$	$b+(2-1)e$
    3	3	$b+2e$	$b+(3-1)e$
    n	n	$b+(n-1)e$	$b+(n-1)e$
    $1≤ k ≤ n	k	$b+(k-1)e$	$b+(k-1)e$

• But ....
  • Remember assembly, you would do the following code

  • for (i = 0; i < size; i++) {
        A[i] = A[i] + 1;
    } 

  •      la    $r1, A           ; the base addres of the array
         li    $r2, 0           ; the index
         li    $r4, n           ; loop termination condition
    
    TOP: beq   $r2, $r4 OUT
         multi $r3, $r2, ELEMENT_SIZE;   (n-1)*e
         add   $r3, $r1, $r3             b + (n-1) * e;
         lw    $r5, 0($r3)
         addi  $r5, $r5, 1
         sw    $r5, 0($r3)
         addi  $r2, 1
         b     TOP
    OUT: 

  • This is pseudo-mips assembly language
  • Lines 6 and 7 calculate the address.
  • Notice that this does not take more time as the array gets larger.
  • You could optimize this, so lines 6-8 become

  • addi $r3, $r3, ELEMENT_SIZE 

  • Would this take less time than the previous?
  • Would it be a change in $O(f(n))$ notation?
  • What does $O(f(n))$ mean?
  • Would this be different in another assembly language?
• Why is contiguous important?
• By the way, what is the asymptotic time complexity of the above loop?
  • We will work on formal definitions later.
  • We will be sloppy and call this the complexity of the algorithm/program.
• What if I have data arriving and I want an ordered list?
  • Fill the array and sort?
    • We will learn later that the best sort is O(n log n)
    • So if we want a constantly ordered list we would need

    • for each data d
          Insert d into array a
          Sort(a) 

    • This would be O(n log n) for line 3
    • And line 1 would be O(n) for n data items.
    • So the entire thing would be O(n² log n)
    • By the way, what is the cost of line 2?
  • How could you maintain a sorted array?
    • One way is to steal an idea from insertion sort.

    • Insert(a, e)
          loc = a.size()
      
          while(loc > 0 and a[loc-1] > e) 
              ary[loc] = ary[loc-1]
              loc --
      
          a[loc] = e 

  • What does this do?
    • Do we need to trace it?
    • What do lines 4-6 do?
    • What does line 8 do?
    • Big picture what does this do?
  • Can you argue that this works?
    • Assuming a large enough array, will loc ever be out of bounds?
    • Will the order be maintained?
  • What is the performance of this algorithm?
    • Would the performance change if we had an array of battleships, not integers?
    • Would the time for the algorithm to run change?
  • If you really would like to see this, I have implemented it here.
• These are the big three for this class
  • What does it do (or is it supposed to do)
  • Is it right?
  • What is the performance.
• What does it take to
  • Delete an item?
    • Give an algorithm.
    • Do the big three.
  • Find an item in the array?
    • Give an algorithm.
    • Do the big three.