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 algorithmAlgorithm Sort

Input A(1:N)

Output A(1:N)

1. read input values into A

2. i = 1

3. 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

4. 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 = 1right = Ndo 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 ifend 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.