Basic Concepts Pseudocode Abstract Data Type ADT Implementation

Basic Concepts Pseudocode, Abstract Data Type, ADT Implementation, Algorithm Efficiency

What is Pseudocode? Used to define algorithms An English-like representation of the algorithm logic It is part English, part structured code

Example 1 Algorithm sample(page. Number) This algorithm reads a file and prints a report. Pre page. Number passed by reference Post Report Printed page. Number contains number of pages in report Return Number of lines printed 1 loop (not end of file) 1 read file 2 if (full page) 1 Increment page number 2 Write page heading 3 end if 4 write report line 5 increment line count 2 end loop 3 return line count end sample

Parts of a Pseudocode Algorithm Header Names the algorithm, lists its parameters, and describes any preconditions and postconditions Purpose, Conditions and Return Algorithm search (list, argument location) Search array for specific item and prints out index location. Pre list contains data array to be searched argument contains data to be located in list Post location contains matching index -or- undetermined if not found Return true if found, false if not found

Parts of a Pseudocode Statement Numbers Variables Intelligent data names Not necessary to define the variables used in an algorithm Rules Do not use single-character names Do not use generic names in application programs Abbreviations are not excluded as intelligent data names

Parts of a Pseudocode Statement Constructs Sequence Do not alter the execution path within an algorithm Selection 1 Evaluates a condition and executes zero or more alternatives if (condition) 1 action 1 else 1 action 2 end if 2 3 Loop Iterates a block of code Algorithm Analysis

Example 2 Algorithm deviation Pre nothing Post average and numbers w/ their deviation printed 1 loop (not end of file) 1 Read number into array 2 Add number to total 3 Increment count 2 End loop 3 Set average to total / count 4 Print average 5 Loop (not end of array) 1 set dev. From. Ave to array element – average 2 print array element and dev. From. Ave 6 End loop end deviation Analysis There are two points worth mentioning in the algorithm. First, there are no parameters. Second, the variables have not been declared. A variables type and purpose should be easily determined by its name and usage

The Abstract Data Type Spaghetti code Modular Programming Structured Programming (Edsger Dijkstra and Niklaus Wirth)

Atomic and Composite Data Atomic Data that consist of a single piece of information Example: integer number 4562 Composite Data that can be broken into subfields that have meaning Example: telephone number

Data Type Consists of two parts A set of values A set of operations on values Type Values Operations Integer …-2, -1, 0, 1, 2, … *, +, -, %, /, ++, --, … Floating point …, 0. 0, … *, +, -, /, … Character , …, ’A’, ‘B’, …, ’a’, ‘b’, …, ~ <, >, …

Data Structure An aggregation of atomic and composite data into a set with defined relationships In this definition, structure means a set of rules that holds the data together A combination of elements in which each is either a data type or another data structure A set of associations or relationships involving the combined elements Array Record Homogeneous sequence of data or data types known as elements Heterogeneous combination of data into a single structure with an identified key Position association among the elements No association

Abstract Data Type Abstraction We know what a data type can do How it is done is hidden Matrix Tree Linear Graph

Abstract Data Type Definition A data declaration packaged together with the operations that are meaningful for the data type. In other words, we encapsulate the data and the operations on the data, then we hide them from the user Abstract Data Type Declaration of Data Declaration of Operations Encapsulation of Data and Operations

ADT Implementations Array Implementations The sequentiality of a list is maintained by the order structure of elements in the array (indexes) Linked List Implementations An ordered collection of data in which each element contains the location of the next element or elements.

ADT Implementations data list data link data LINEAR LIST list link data link NON-LINEAR LIST list EMPTY LIST data link

ADT Iplementations Node The elements in a linked list Structure that has two parts: the data and one or more links Self-referential structures data

ADT Implementations Node with one data field Node with three data fields number name Structure in a node name address phone id grd. Pts

ADT Implementations Pointers to Linked Lists A linked list must always have a head pointer Depending on how the list is used, there could be several other pointers as well

Generic Code void typedef struct node { void *data. Ptr; struct node* link; } NODE; data. Ptr link To next node

Example A main Dynamic Memory new. Data 7 node. Data node create. Node data. Ptr item. Ptr node. Ptr link

Creating a Node Header File typedef struct node { void* data. Ptr; struct node* link; } NODE; NODE* create. Node (void* item. Ptr) { NODE* node. Ptr; node. Ptr = malloc(sizeof(NODE)); node. Ptr->data. Ptr = item. Ptr; node. Ptr->link = NULL; return node. Ptr; }

Demonstrate Node Creation #include <stdio. h> #include <conio. h> #include “Prog. CN. h” int main(void) { int * new. Data; int * node. Data; NODE* node; new. Data = malloc(sizeof(int)); *new. Data = 7; node = create. Node(new. Data); node. Data = (int*)node->data. Ptr; printf(“Data from node: %dn”, *node. Data); return 0; }

Activity 2 (Structure for two linked nodes) main Dynamic Memory 7 75 node create. Node data. Ptr node. Ptr link data. Ptr link

Demonstrate Node Creation #include <stdio. h> #include <conio. h> #include “Prog. CN. h” int main(void) { int * new. Data; int * node. Data; NODE* node; new. Data = malloc(sizeof(int)); *new. Data = 7; node = create. Node(new. Data); new. Data = malloc(sizeof(int)); *new. Data = 75; node->link = create. Node(new. Data); node. Data = (int*)node->data. Ptr; printf(“Data from node 1: %dn”, *node. Data); node. Data = (int*)node->link->data. Ptr; printf(“Data from node 2: %dn”, *node. Data); return 0; }

Algorithm Efficiency Algorithmics term used by Brassard and Bratley to define the systematic study of the fundamental techniques used to design and analyze efficient algorithms. General Format of an algorithm’s efficiency f(n) = efficiency

Linear Loops for (i=0; i<1000; i++) application code The number of iterations is directly proportional to the loop factor f(n) = n for (i=0; i<1000; i+=2) application code f(n) = n/2 Plotting these would give us a straight line. For this reason, they are called linear loops.

Logarithmic Loops The controlling variable is multiplied or divided in each iteration. for (i=1; i<=1000; i*=2) for (i=1000; i>=1; i/=2) application code Multiply application code Divide Iteration Value of I Iteration Value of i 1 2 3 4 5 6 7 8 9 10 (exit) 1 2 4 8 16 32 64 128 256 512 1024 1 2 3 4 5 6 7 8 9 10 (exit) 1000 500 250 125 62 31 15 7 3 1 0

Logarithmic Loops The number of iterations is a function of the multiplier or divisor Multiply 2 iterations < 1000 Divide 1000/2 iterations >= 1 Generalizing this analysis f(n) = logn

Nested Loops To find the total number of iterations in nested loops, we find the product of the number of iterations in the inner loop and the number of iterations in the outer loop Three nested loops Linear Logarithmic Quadratic Dependent Quadratic

Linear Logarithmic for (i=0; i<10; i++) for (j=0; j<10; j*=2) application code Total number of iterations = 10 log 10 f(n) = nlogn

Quadratic Loops for (i=0; i<10; i++) for (j=0; j<10; j++) application code Total number of iterations = 10 * 10 f(n) = n 2

Dependent Quadratic for (i=0; i<10; i++) for (j=0; j<i; j++) application code The number of iterations in the body if the inner loops is calculated as 1 + 2 +3 + … + 9 + 10 = 55 (n+1) 2 Total number of iterations = n * inner loop iterations f(n) = n * ((n+1)/2)

Big-O Notation With the speed of computer’s today, we are not concerned with an exact measurement of an algorithm’s efficiency as much as we are with its general order of magnitude. Although developed as a part of pure mathematics, it is now frequently also used in computational complexity theory to describe how the size of the input data affects an algorithm’s usage of computational resources (usually running time or memory). It is also used in many other fields to provide similar estimates. We don’t need to determine the complete measures of efficiency, only the factor that determines the magnitude. This factor is the big-O. O(n)

Big-O Notation For example, the time (or the number of steps) it takes to complete a problem of size n might be found to be T(n) = 4 n² − 2 n + 2. As n grows large, the n² term will come to dominate, so that all other terms can be neglected — for instance when n = 500, the term 4 n² is 1000 times as large as the 2 n term. Ignoring the latter would have negligible effect on the expression's value for most purposes.

Derivation of the Big-O Steps In each term, set the coefficient of the term to 1 Keep the largest term in the function and discard the others. Terms are ranked from lowest to highest as shown below logn n nlogn n 2 n 3 … nk 2 n n!

Standard Measures of Efficiency Big-O Iterations Estimated Time Logarithmic O(log n) 14 Microseconds Linear O(n) 10000 Seconds Linear Logarithmic O(n(logn)) 140000 Seconds Quadratic O(n 2) 100002 Minutes Polynomial O(nk) 10000 k Hours Exponential O(cn) 210000 Intractable Factorial O(n!) 10000! Intractable

Exercise Calculate the run-time efficiency of the following program segment for (i=1; i<=n; i++) printf(“%d”, i); If the algorithm do. It() has an efficiency factor of 5 n, calculate the runtime efficiency of the following program segment for (i=1; i<=n; i++) do. It(…) If the efficiency of the algorithm do. It() can be expressed as O(n 2), calculate the efficiency of the following program segment. for (i=1; i<=n; i*=2) do. It(…)

Exercise Given that the efficiency of an algorithm is n 3, if a step in this algorithm takes 1 nanosecond(10 -9 seconds), how long does it take the algorithm to process an input of size 1000? An algorithm processes a given input of size n. If n is 4096, the run time is 512 milliseconds. If n is 16, 384, the run time is 2048 milliseconds. What is the big-O notation? An algorithm processes a given input of size n. If n is 4096, the run time is 512 milliseconds. If n is 16, 384, the run time is 8192 milliseconds. What is the big-O notation?