Program Abstraction The solution to a given problem

Program Abstraction

• The solution to a given problem should not be based on a particular computer language. • Otherwise, we spend more time in thinking about how to fit the solution to language syntax rather than thinking about the logic of solution to the problem. • We should think about the solution ignoring the language constructs such as input and output statements, data types, syntax of iteration and selection structures etc. ,

• These decisions can be made when we are certain that the solution correctly solves the problem. • Developing a solution to a problem by ignoring the context of programming language is called 'program abstraction'. • Such an abstract solution is called an 'algorithm'. • Once developed, the algorithmic solution must be documented for later use. • There are two notations to document algorithms, namely, pseudo-code and flow-chart.

Problems, Algorithms and Programs • An Algorithm is the method one has to use to solve a Problem. • A Program is the precise expression of an algorithm in a language that could be followed by a computer.

Software Development Process • Understand the Problem • Come up with an Algorithm to solve it • Flesh out the Algorithm in a program

What is an Algorithm? • An algorithm is a methodical approach to solving a problem • Examples: – An algorithm to multiply X and Y is to add X to itself Y times – An algorithm to compute the average of N numbers is to add them up and then divide by N

The Makeup of an Algorithm • An algorithm is made up of a set of “basic steps” that are followed sequentially. • Each algorithm must have a single “entry” point from which the algorithm is started. • Each algorithm must have one or more “exit” points that indicate when the algorithm is finished.

What Constitutes a Basic Algorithmic Step? • Input a value into a “memory variable” • Output a value from a “memory variable” • Assigning and reassigning a value to a variable • Performing a math or some other operation on a number of memory variables • Deciding the next step based on the outcome of a yes/no question – Decision/choice

Tracing of an Algorithm Ø Tracing an algorithm means checking or verifying the algorithm or flowchart whether is working properly or not. Ø It is one of the way to find out errors in an algorithm or flowchart. Ø Through trace table one can easily detect error in their flowchart. Ø Trace table is also known as verification table. Ø Through algorithm we can draw flowchart and from flowchart we can draw the Trace Table. Ø In Trace Table we take Steps, Input variable, Intermediate Variable and Output.

Examples: 1) To perform addition of two numbers: • Algorithm: 1. Start 2. Read Values a and b 3. Compute a + b and store result in sum. 4. Print value of Sum 5. Stop • Pseudo Code: Begin input a, b sum = a+ b Print sum End

Tracing of algorithm with a=10 and b=20 Start Input Read a & B Sum = a + b Print Sum Stop steps a b output Sum 1 10 20 --- 2 10 20 30 3 10 20 30

1) To perform addition of two numbers and square of sum: • Algorithm: 1. Start 2. Read Values a and b 3. Compute a + b and store result in sum. 4. Compute sum * sum and store in square. 5. Print value of Square 6. Stop • Pseudo Code: Begin input a, b sum = a+ b square = sum * sum Print square End

Tracing of an algorithm with a=3 and b=2 Start ut Read a & B Inp Inter output medi ate Sum Square Sum = a + b steps a b Square= sum * sum 1 3 2 Print Square 2 3 2 5 --- 3 3 2 5 25 4 3 2 5 25 Stop ---

3) To find maximum of 2 numbers: • Algorithm: 1. Start 2. Input two numbers a and b 3. If a > b then goto step 4 else goto step 5 4. Output a 5. Output b 6. Stop

Tracing with a=5 and b=10 Start Input a, b Yes If a > b Output a put No Output b Stop In step b s a 1 5 10 Inter media te outpu t --- --- 2 5 10 --- 3 5 10 --- 10

Implementation Of Algorithm • Algorithms must be designed in such a fashion that they follows the pure top down approach. • This ensures the straight line execution path. • Following points should be kept in mind while writing algorithms: 1)Use of procedures: Ø We write program referring the algorithm. Ø It should emphasis on development of implementation & readability. Ø Modularizing programs will accomplish both of these needs. Ø This allows us to implement independent separate procedures to perform specific task. Ø The main program can have references to different procedures.

2) Choice of variable Names: Ø By choosing appropriate variable names & constants we can make programs more meaningful and easier to understand. Ø Eg: If we wish to add the two numbers and store the result; we can use variables as Num 1, Num 2 and Sum instead of a, b, c. Ø This makes the program self explanatory & self documented. Ø One should ensure that each variable should have only one role in a given program.

3)Documentation of Programs: Ø This is a useful practice to have in programs. Ø Brief and accurate comments should be written at the beginning of each procedure/function. Ø Program documentation is a good practice because the program can be used easily by other people unfamiliar with the working and input requirements of the program. Ø This indicates that the program must specify during execution exactly what responses require from the user.

4)Debugging the program: Ø It is necessary to carry out number of tests during implementation of algorithm , to ensure that the program is behaving correctly according to its specifications. Ø Program may have some logical errors which may not be detected during compilation. Ø To detect such type of errors one may include “print” statements to print information at strategic points in computations. Ø There are no complete methods for debugging. Ø However following steps can be taken to ease the burden of process: 1) Always work the program through by hand before ever attempting execute it. 2) Print out the strategic information.

5) Program Testing: Ø The program should be tested against all possible inputs. Ø Some of the things we might check are whether the program solves the smallest possible problem, whether it handles all the cases for varying input data. Ø Whenever possible programs should be accompanied by input and output sections.

From Algorithm to a Program • Flowcharts are aimed at “humans”; they help programmers “visualize” the algorithm to be followed to solve a problem. • Flowcharts are not suitable for computers to execute because they are not “detailed” and “specific” enough. • To represent an algorithm to be followed by a computer, we have to express that algorithm as a program.

Representation of an Algorithm • 1) 2) 3) An algorithm can be represented as: Flow Charts Pseudo code Programs

Flow Charts • The flowchart is a means of visually presenting the flow of data through an information processing systems, the operations performed within the system and the sequence in which they are performed. • A flowchart is a diagrammatic representation that illustrates the sequence of operations to be performed to get the solution of a problem. • Flowcharts are generally drawn in the early stages of formulating computer solutions. • Flowcharts facilitate communication between programmers and business people.

• Flowcharts play a vital role in the programming of a problem and are quite helpful in understanding the logic of complicated and lengthy problems. • Once the flowchart is drawn, it becomes easy to write the program in any high level language. • Hence, it is correct to say that a flowchart is a must for the better documentation of a complex program.

Symbols Start/Stop Assignment Statements, Expressions Input/Output Decision Making Connector Flow Indicators

ADVANTAGES OF USING FLOWCHARTS The benefits of flowcharts are as follows: 1. Communication: Flowcharts are better way of communicating the logic of a system to all concerned. 2. Effective analysis: With the help of flowchart, problem can be analyzed in more effective way. 3. Proper documentation: Program flowcharts serve as a good program documentation, which is needed for various purposes.

4. Efficient Coding: The flowcharts act as a guide or blueprint during the systems analysis and program development phase. 5. Proper Debugging: The flowchart helps in debugging process. 6. Efficient Program Maintenance: The maintenance of operating program becomes easy with the help of flowchart. It helps the programmer to put efforts more efficiently on that part

LIMITATIONS OF USING FLOWCHARTS 1. Complex logic: Sometimes, the program logic is quite complicated. In that case, flowchart becomes complex and clumsy. 2. Alterations and Modifications: If alterations are required the flowchart may require re-drawing completely. 3. Reproduction: As the flowchart symbols cannot be typed, reproduction of flowchart becomes a problem. 4. The essentials of what is done can easily be lost in the technical details of how it is done.

Pseudo code • Pseudo-Code is simply a numbered list of instructions to perform some task. • It consists of short, English phrases used to explain specific tasks within a program’s algorithm. • It is also called as Structured English. • It requires an algorithm to be specified with the same precision as that of the programming language in which the program is eventually written.

• By moving from diagrams to text , pseudo code brings the design process a step closer to the coding process and makes the ultimate translation of the algorithm into a programming language somewhat easier.

Why is pseudo code necessary? • Programming process is a complicated task. • Firstly it is necessary to understand the program specifications. • Then it is necessary to organize thoughts and create the program. • This is a difficult task when program is big and complex. • A main task is broken down into smaller ones, in order to be able to write fully developed code. • Writing Pseudo Code will save time later during the construction and testing phase of a program’s development.

How to write pseudo code? • First make a list of the main tasks that must be accomplished on a piece of scratch paper. • Then, focus on each of those tasks. • Try to break each main task down into very small tasks that can each be explained with a short phrase. • There may eventually be a one-to-one correlation between the lines of pseudo code and the lines of the code that you write after you have finished pseudo coding.

• Functions and procedures can be shown within pseudo code. • Purpose of pseudo code is to help the programmer efficiently write code. Therefore, you must honestly attempt to add enough detail and analysis to the pseudo code. • In the professional programming world, workers who write pseudo code are often not the same people that write the actual code for a program. In fact, sometimes the person who writes the pseudo code does not know beforehand what programming language will be used to eventually write the program.

Pseudo code Language Constructions • Input/Output: Get “variable”, ”variable”, …. Display “variable”, ”variable”, …. • Computation/Assignment: Set the value of “variable” to “arithmetic expression” or “variable” = “expression”

• Conditional: 6. If “condition” 6. 1 statement 1 6. 2 ………… 7. Else 7. 1 statement 2 7. 2 …………. • Iterative : 9. While “condition” 9. 1 statement 1 9. 2 …………………

• 1. 2. 3. 4. 5. Algorithm, Pseudo code, Flowchart to add two numbers Algorithm: Start Read Values a and b Compute a + b and store result in sum. Print value of Sum Stop • Pseudo Code: Begin input a, b sum = a+ b Print sum End

Start Read a & B Sum = a + b Print Sum Stop

SEARCHING

• Information retrieval is one of the most important applications of computers. • Suppose you want to identify the name of student, whose roll no is 150. • Is it sufficient for you to get the information which you need. ? No since there may be many classes. • We may now add another attribute to our query- “second year”. Even now it may fail, as there may be branches. So another attribute branch name. • Thus we can now formulate the query as: • Find the name of student having Roll. No. 150, studying in second year computer science.

• Every time we are given with a piece of information (e. g. Roll no) and we are asked to find the record that contains associated information for the given piece of information. • The initial piece of information is called “Key”. • Using Key, we are retrieving the information from the database. This is called searching. • Hence searching is a technique where we try to obtain certain information, given a key information.

Sequential Search Ø The simplest way to do a search is to begin at one end of the information, scan down, until the desired key is found or the end is reached. Ø This method is called sequential or linear search. Ø More precisely , we can define sequential search as: A=<a 1, a 2, a 3, …. an> be the list of ‘n’ records, each record has a key element ai. Given a key value ‘v’ we want to find the information or retrieve the record from the list, such that v= ai, i. e. we are finding the target record, by its key value.

Algorithm: Let A be an array of structure, having two fields Rollno and name. The algorithm for making the sequential search to search for a student having Rollno provided as a key is given as follows: Step 1: Read the information of ‘n’ students in the array A. (i. e. rollno and name). Step 2: Read the Rollno, which you want to search, say key. Step 3: Initialize Counter I to 1. Step 4: Repeat steps 5 & 6 until I < n,

Step 5: If (A[i]. rollno = key) then Print ‘Key Found’, Print Rollno, name and goto step 8. Step 6: i=i+1 i. e advance to next entry in the list and goto step 5. Step 7: Else Print ‘No such entry in list’. Steo 8: Stop.

Flowchart: start Read how many nos say n Read the array A of n nos. Read the no. to be searched say x i=1 i=i+1 Yes No Is a[i]=x Yes Is i<= n Print “no. found” No Print “no. not found” Stop

Advantages: 1. It is very easy to implement. It requires no additional data structure. Disadvantage: 1. Its performance degrades when the list grows. Suppose you are searching for a telephone number of Mr. Xavier and that you are searching it sequentially from the beginning. You may read unnecessarily many entries, which could have been avoided.

Binary Search Ø Binary search is an improvement in searching method to reduce the amount of work that is made. Ø If the list is organized in order (just like in telephone directory, where the names are arranged alphabetically) one of the best approach is to , first compare the required target key with the center of the list, and then restrict ourselves to only the first or second half of the list, depending on whether the required item comes before or after the center one. Ø In this way at each step we reduce the length of the list to be searched by half, hence the name binary search.

For example: we are searching for telephone number of Mr. Xavier. The current page which we have opened of the directory is containing names starting with letter say ‘k’. Since ‘x’ > ‘k’ (X of Xavier) we continue to search the upper (next) pages, leaving the earlier pages. This method, can locate a name from a list of million names, within only 20 comparisons. Binary Search method is applicable only when the elements are arranged in order.

Algorithm: Step 1: Read the ‘n’ elements in an array, say A. Step 2: Read the element to be searched say X. Step 3: Low = 1, High =n (initialize the lower and upper limit of the list to be searched) Step 4: Find the middle element, mid-position = (Low + High)/2 Y=A [Mid-position] Step 5: If (X =Y) then Print “element found and its location is ‘mid position’” Goto Step 9.

Step 6: If (X<Y) (i. e. element to be searched is less than the middle element) then search to be continued in lower half; high = mid-position – 1 goto step 8. Step 7: Otherwise the element is in upper half, low = mid-position + 1. Step 8: If (High >= Low) then goto step 4 else print “Element not in the list” Step 9: Stop.

Example 1: Let n=5, and array A have elements: 10, 20, 30, 40, 50 Now we will run the algorithm for searching the element 20. Following table shows run steps for searching x=20.

Sr. No Step no Executed Action/Remarks. 1 3 Low = 1, High =5 2 4 Mid-position= (1+5)/2 =3; 3 6 (X <Y ), High = Mid-Position -1 = 3 -1 = 2 4 8 High>=Low (2>1) 5 4 Mid-Position = (1+2)/2 =1 6 7 (X>Y) (20>10), Low = 1 + 1= 2 7 8 High >= Low (2>=2) 8 4 Mid-Position = (2+2)/ 2=2 ; Y=20 9 5 X=Y, Element Found 10 9 Stop Y=30 ; Y=10

Following table shows run steps for searching x=45. Sr. No Step no Executed Action/Remarks. 1 3 Low = 1, High =5 2 4 Mid-position= (1+5)/2 =3; 3 Y=30 (X >Y ), (45 > 30) Low = Mid-Position +1 = 3 +1 = 4 4 8 High>=Low (5>4) 5 4 Mid-Position = (5+4)/2 =4 6 7 (X>Y )(45>40), Low = Mid-Position + 1 = 4+1 =5 7 8 High >= Low (5=5) 8 4 Mid-Position = (5+5)/ 2=5 ; Y=50 9 6 X<y (45<50) High= 5 -1=4 333310 8 High < Low (4<5) element not found ; Y=40

Example: Consider the following set of numbers: 10 20 30 40 50 60 70 80 With which numbers of comparison is being made while searching for the number: 1) 30 Low Up Mid Remarks 1 8 4 30 < 40 up = mid – 1 1 3 2 30 > 20 Low = mid +1 3 3 3 Found

1) 50 Low 1 Up 8 Mid 4 5 8 6 5 5 5 Remarks 50 > 40 Low = mid + 1 50 < 60 Up = mid -1 Found

Start Read how many nos. say n Read array A of n nos Read the no. to be searched say x Low =1 , Up = n Compute mid = (low + up)/2 No Yes Is a[mid]<x Low = mid + 1 Yes Is a[mid]=x Print “No. Found” No Up =mid-1 Is up >= low Yes No Print “No. not found” Stop

SORTING ALGORITHMS

Sorting Ø Sorting is a process of organizing data in a specific order. Ø Sorting is of two types: 1) Internal Sort: • Internal sorting methods are used when the file to be sorted is small enough so that the entire sorting can be done in main memory. 2) External Sort: • External sorting methods are used when the file to be sorted is large, so that entire sorting can’t be done in main memory. • So we need to swap the records between main memory and secondary storage, frequently, which results in more time for sorting.

Importance of Sorting: 1) Sorting is the basic building block around which many other algorithms are built. By understanding sorting, we obtain an amazing amount of power to solve other problems. 2) Sorting is the most thoroughly studied problem in computer science. 3) Most of the interesting ideas used in the design of algorithms appear in the context of sorting, such as divide – and – conquer, data structures and randomized algorithms.

Applications of Sorting: Ø An important key to algorithm design is to use sorting as a basic building block, because once a set of items is sorted, many other problems become easy. Ø Consider following applications: 1)Searching: Binary search enables you to test whether an item is in a dictionary , once the keys are sorted. 2) Closest Pair: Given a set of n numbers, how do you find the pair of numbers that have the smallest difference between them? After the numbers are sorted, the closest pair of numbers will lie next to each other somewhere in sorted order.

3) Element Uniqueness: Are there any duplicates in a given set of n items? The most efficient algorithm is to sort them and do a linear scan through them checking all adjacent pairs. 4) Frequency Distribution: Given a set of n items, which element occurs the largest number of times in the set? If the items are sorted, we can sweep from left to right and count them, since all identical items will be lumped together during sorting.

Bubble Sort Ø This is the most simple sorting algorithm but least efficient methods among other methods. Ø In computer programming, it is also one of the easiest to implement. Ø Although it is a very slow algorithm when used with a large value set, it can be easily described by a few instructions. Ø The basic idea here is that, the largest number will be pushed down the list, so that it will be placed in its order. (if we arranging the numbers in increasing order). Ø Continue this process till all the numbers are placed in the proper order. Ø Each number is compared with its next (successor) number, and swapped (interchanged) if the first number is larger than the second number. Ø This way, when we reach the end of the list, the largest number will be placed in its proper position. Ø But we need to repeat these steps for many times, so as to get the list sorted.

Pseudocode and Flowchart Bubble. Sort( int a[], int n) Begin for i = 1 to n-1 for j = 0 to n-1 -i if a[j] > a[j+1] temp = a[j] = a[j+1] = temp end for if sorted break from i loop end for End

• Bubble Sort Example i=1 j 0 1 2 3 4 5 6 7 i=2 0 1 2 3 4 5 6 5 3 3 3 3 5 1 1 1 1 5 5 5 9 9 8 8 8 8 9 2 2 2 2 9 4 4 4 4 9 7 7 7 7 0 1 2 3 4 5 3 1 1 1 3 3 3 5 5 5 8 8 2 2 2 8 4 4 4 8 7 9 7 7 7

i=3 j 0 1 2 3 4 0 1 1 1 3 3 3 2 5 5 5 2 2 3 2 2 2 5 4 4 4 5 5 6 7 7 8 7 7 i=4 0 1 2 3 1 1 3 3 2 2 3 3 4 4 5 7 5 5 5

i=5 j 0 1 2 0 1 1 2 2 3 3 4 5 6 7 4 5 4 4 i=6 0 1 2 3 4 1 1 2 3 i=7 0 1 2 3 1 2 • Note for array of size 8, outside i loop repeats 7 times.

Insertion Sort • Based on the technique used by card players to arrange a hand of cards – Player keeps the cards that have been picked up so far in sorted order – When the player picks up a new card, he makes room for the new card and then inserts it in its proper place

Insertion Sort 8 2 4 9 3 3 6 2 8 4 9 2 4 8 9 3 6 2 3 4 8 6 9 6 6 8 9

Insertion Sort Algorithm • For each array element from the second to the last (next. Pos = 1) – Insert the element at next. Pos where it belongs in the array, increasing the length of the sorted subarray by 1

The idea: Consider one element at a time, inserting it in its proper place among already sorted elements. The algorithm: Input: An array A storing N items Output: A sorted in ascending order Algorithm Insertion_Sort (A, N): for i: = 2 to N do { current : = A[i] j : = i while A[j-1] > current A[j] : = A[j-1], j : = j-1 A[j] = current }

Source Code: void insertion( int a[], int n ) { /* Pre-condition: a contains n items to be sorted */ int i, j, v; /* Initially, the first item is considered 'sorted' */ /* i divides a into a sorted region, x<i, and an unsorted one, x >= i */ for(i=1; i<n; i++) { /* Select the item at the beginning of the as yet unsorted section */ v = a[i]; /* Work backwards through the array, finding where v should go */ j = i; /* If this element is greater than v, move it up one */ while ( a[j-1] > v ) { a[j] = a[j-1]; j = j-1; if ( j <= 0 ) break; } /* Stopped when a[j-1] <= v, so put v at position j */ a[j] = v; } }

Selection Sort Ø Selection sort is probably the simplest sorting algorithm to implement so it can be blazingly fast on short arrays. Ø The idea is to find minimum of the array and swap it with the first element of the array. Ø Then repeat the process with the rest of array, shrinking the unsorted part of array by one with each selection. Ø Implementation consists of two loops: 1)External loop index determines the boundary of the sorted area • 2)The inner loop is the classic algorithms of finding a minimum of the array. Ø The selection sort algorithm is in many ways similar to the Simple Sort and Bubble Sort algorithms. Rather than swapping neighbors continuously as the algorithm traverses the (sub) array to be sorted, as done in the Bubble Sort case, this algorithm finds the MINIMUM element of the (sub) array and swaps it with the pivot (or "anchor") element.

As an example, begin with the following array. The selection sort marks the first element (7). It then goes through the remaining data to find the smallest number (1). It swaps with the first element (7) and the smallest element (1) which is placed in its correct position. It then marks the second element (4) and looks through the remaining data for the next smallest number (2). These two numbers are then swapped. Marking the third element (7) and looking through the remaining data for the next smallest number (4). These two numbers are now swapped. Lastly it marks the fourth element (9) and looks through the remaining data for the next smallest number (7). These two numbers are then swapped. If we were not finished at this point this sort would continue until n-1 passes have been made.

Pseudocode: Begin for i = 0 to n-1 minpos = i for j = i+1 to n-1 if a[j] < a[minpos] minpos = j temp = a[i] = a[minpos] = temp End