Examples using Arrays
Summing Squares
•	Problem: To compute the sum of the squares of N numbers

•	N is given

•	N values are also given 

•	These should be read and stored in an array
The Program
        Program sum_square
        implicit none
        integer:: N, Sum, Index, i
        ! N - the total number of items to be summed
        integer, dimension(100):: Arr
        Sum = 0
        read *,N
        read *, (Arr(i), i= 1, N)
        do index = 1, N
              Sum = Sum + Arr(index) ** 2
        end do
        print *, Sum
        end program
Another Example
•	 Searching an item in an array
–	Given an array of integers, check whether a given integer is in the array or not

•	This is an abstraction of standard and important problem for searching an item from a large collection of data items

•	Algorithm idea:
–	Examine each item in the array and compare with the given item
–	If there is a match return success, return failure otherwise
•	This is called Linear Search
The program
             Program l_search
        implicit none
        integer::  N, Index,  i, item
        ! N - the total number of items to be summed
        logical ::  found
        ! logical variable that store the search result
        integer, dimension(100)::  Arr
        read *,item
        read *,N
        read *, (Arr(i), i=1, N)
        found = .false.
        do index = 1, N
            if ( Arr(index) == item ) then
                 found = .true.
                 exit
            endif
        end do
        print *, found
        end program 
Complexity of Linear Searching
•	Total number of operations
–	depends on the input

•	Worst case estimate
–	when the given item is not present in the array
–	constant number of operations per iteration
–	number of iterations is N
–	Total number of operations: (k*N)

•	Can we do better?
–	Yes, if the array is sorted
–	(k*log N) algorithm
Sorting
•	Sorting of data items is a very standard task in various applications
–	Rank students according to their marks
–	Order animals in a zoo in the order of their weights
–	Obtain the top 5% batsmen in one-day matches in a calendar year
–	Order the world cup footballers in the order of their goals

•	Ascending and Descending Orders

•	Sorting is a typical example using arrays
Specification of Sorting
•	Input: A(1..N) is an array of integers
•	Output: A(1..N) is the sorted (in ascending order) version of old array
•	Sorted Version:
			The output A(1..N) is a permutation of old 		array. It is, further sorted in ascending 			order

•	Examples: 
          Input:    9  3  4  8  10  34  2  7  11  10
		Output: 2  3  4  7  8  9  10  10  11  34
How to do Sorting
Simplest Strategy
•	Choose the smallest number and place in the first position
•	Choose the next smallest number and place in the second position
•	and so on

Illustration
         23	5	5	5
		12	12	12	12
	    37	37	37   	23
		5	23	23   	37
The algorithm
Algorithm Sort
Input A(1:N)
Output A(1:N)

•	read input values into A
•	i = 1
•	while (i < N)
	3.1 find N  >= j > i s.t. A(j) is the least element in A(i:N)
	3.2 swap A(i) and A(j)
	3.3 i = i+1
•	output A(1:N)

•	This algorithm is called Selection Sort
Program Ssort
         implicit none
 integer:: N, i, j, min, temp  ! N - total no. of items in array
 integer, dimension(100):: Arr
      print *, "input the size of the array"
 read *, N
 print *, "Input the array elements in the same line"
 read *, (Arr(i), I = 1, N)

 do i = 1, N
       min = i
       do j = i+1, N
              if (Arr(min) > Arr(j)) then
                 min = j
              endif
        end do
         temp = Arr(i)
         Arr(i) = Arr(min)
         Arr(min) = temp
  end do
       print *, (Arr(i),I = 1, N)

 Analysis
•	Is the program Correct?
–	Find loop invariants for the do-loops
•	How many number of operations?
–	Iterations count for the outer loop: N
–	Iteration count for the inner one:  (N-1) for 1st, (N-2) for 2nd, ...

–	Total operations  1 + 2 + 3 + ... (N-1) = N(N-1)/2 

•	Can we do better?
–	Yes, More on this later
Bubble Sort
•	Most sorting algorithms are based upon iterative swapping
•	Selection sort, in each iteration, swaps A(i) with the least element in A(i+1),...,A(N)
•	Bubble sort uses a simpler swap operation. 
–	Swaps adjacent elements if they are in the wrong order
•	Keep iterating such swaps until no adjacent elements are in the wrong order
•	The array is sorted then
An abstract algorithm
•	Here is a very high level description

	while there is a pair of adjacent elements in the wrong order
		swap the two elements
	end

•	The details of algorithm is in systematically searching for the adjacent pair of elements in the wrong order

•	Search from left to right
A simple version
             program b_sort

        ...  declarations and reading inputs

        do
           do i = 1, (N-1)
             if Arr(i) > Arr(i+1) then
                 temp = Arr(i)
                 Arr(i) = Arr(i+1)
                 Arr(i+1) = temp 
                 swapped  = .true.
             endif   
           enddo
           if (.not. ( swapped)) exit
        enddo
        print *, (Arr(i),i=1,N)
 
            end program
An improvement
•	This algorithm is correct (why?)
•	The inner loop `sweeps' through the entire array in every iteration
•	Observe that in the I iteration, the largest element goes rightmost, its right position
•	In the II iteration, the second largest element reaches its destination and so on
•	Every successive iteration needs to sweeps less and less to the right
•	The same is the case if the array if already is sorted (in the right)
•	Bubblesort makes use of this property
Bubblesort
             program bubble_sort

        ...  declarations and reading inputs

        rt_end = N
        do
           if (rt_end < = 1) exit
           index = 0 
           do i = 1, (rt_end-1)
             if (A(i) > A(i+1)) then
                 temp = Arr(i)
                 Arr(i) = Arr(i+1)
                 Arr(i+1) = temp
                 index = i
             endif
           enddo
           rt_end = index 
        enddo
        print *, (Arr(i),i=1,N)

        end program
Analysis
•	Is the algorithm correct?

•	How many number of operations?

•	Can there be a better algorithm?
Sort before searching
•	Recall the Linear Searching algorithm
•	N comparisons are required
•	One has to look at all the items
•	Can we avoid looking at all items?
•	It appears no but actually one need not, if the array is sorted
•	In a sorted array, every section containing the item has:
–	left most item less than or equals and
–	right most item greater than or equals 
    the searched item
•	We give an algorithm exploiting this fact
Binary Search Algorithm
•	Idea: 
–	Obtain an initial section possibly containing the searched item
–	Keep reducing the size of the section until
–	 the section contains just one or two elements
•	What is the initial section?
		The entire array if the given item
			> = first item
			< = last item
•	How to reduce a given section?
–	If the section contains k elements, break it into two (hence binary) sections,  at most one of which will possibly contain the element
Program bin_search
     ....
integer *, left, right 
left = 1
right = N
do 
    If ((A(left)>x) .or. (A(right) < x)) then
       print *, "Not found"
       exit
    end if
    mid = (left + right)/2
    If (A(mid)< x) then
        left = mid + 1
    elseif (A(mid)>x) then  
        right = mid
   else 
          print *, x," is found at index ", mid
         exit
   end if
end do  

Analysis of the algorithm
•	Is the program correct?

•	What is the loop invariant?

•	Does the loop terminate?

•	How many comparison?

•	Log N in the worst case

•	Can we do better? No.