# Software Development (cs2500)

Save this PDF as:

Size: px
Start display at page:

## Transcription

1 Software Development (cs2500) Lecture 53: Tail Recursion and Search M.R.C. van Dongen March 4, 2011 Contents 1 Outline 1 2 Tail Recursion 2 3 Search 4 4 Linear Search 5 5 Binary Search 6 6 Analysis 7 7 Improvements Sorted Keys Sentinel Final Improvement For Monday 11 9 Bibliography 12 1 Outline This lecture is about tail recursion and search. Tail recursive algorithms are an important class of algorithms. They are recursive, but at a very shallow level. They are almost iterative. This allows us to automatically translate them into iterative algorithms. The advantage of doing this is that it improves the performance. Linear search outperforms binary search for small input sizes. It is an important requirement for the efficient implementation of many algorithms. Any further improvement to linear search will therefore 1

2 also improve these other algorithms. We shall study a number of ideas to improve the performance of linear search. These ideas can also be used for other algorithms. The part about linear search is partially based on [Knuth, 1998, Chapter 6.1]. Many of the code transformations are improvements which are carried out by a compiler. The result of the transformations will usually violate our coding conventions. To keep things simple we shall not bother about this most of the times. 2 Tail Recursion Recursive algorithms are elegant and their correctness/termination properties are usually easy to prove. However, they have the disadvantage of having method call overhead. To overcome this problem of overhead, programmers frequently first implement a recursive algorithm and (if possible) transform it to a more efficient non-recursive (iterative) algorithm. A method is called tail recursive if (during its current invocation) any recursive call is immediately followed by a the return of the current invocation. Modern compilers are able to automatically transform any tail recursive method to an equivalent iterative method. To study tail recursion we shall use the Fibonacci number sequence. The following are the Fibonacci numbers: 1,1,2,3,5,8,13,.... Except for the first two numbers, each number is the sum of its two predecessors. Writing f n for the n-th Fibonacci number we have 1 if n 1 ; f n = f n 1 + f n 2 otherwise. The following method computes the n-th Fibonacci number. int int f( int n ) { if (n <= 1) { return 1; else { return f( n - 1 ) + f( n - 2 ); The method is not tail recursive because there is an addition and a call to f( n - 2 ) after the call to f( n - 1 ). The previous method for Fibonacci numbers is hopelessly inefficient. The reason for the inefficiency is that the number of method calls that are required to compute f n 2 is almost twice the number of calls for that are required to compute f n 1. As a consequence, the number of calls for f n is in (2 n ). Figure 1 graphically shows this effect for n 6. When humans compute Fibonacci numbers they don t use the top-down recursion. Instead they 2

3 f 6 f 5 f 4 f 4 f 3 f 3 f 2 f 3 f 2 f 2 f 2 f 0 f 2 f 0 f 0 f 0 f 0 Figure 1: Fibonacci tree of order 6. The root at the top represents the computation of f 6. enumerate the following sequence: f 0,,, f 2, f 2, f 3,..., f n 1, f {{ n, length n and return f n.there s no need to explicitly construct pairs f i, f i+2. In terms of recursion we can do this as follows: 1 if n = 0 ; f n = F(1,1,1, n) otherwise, where F(f i 1, f i, i, n) is given by: F(f i 1, f i, i, n) = fi if i = n ; F( f i, f i + f i 1, i + 1, n) otherwise. The following implements F in. int int F( int fibprev, int fibcurr, int curr, int n ) { if (curr == n) { return fibcurr; else { return F( fibcurr, fibprev + fibcurr, curr + 1, n ); This definition is tail recursive. A clever compiler may translate the tail recursive definition of F to: 3

4 int int F( int fibprev, int fibcurr, int curr, int n ) { while (curr!= n) { int fibprevold = fibprev; int fibcurrold = fibcurr; fibprev = fibcurrold; fibcurr = fibcurrold + fibcurrold; curr ++; return fibcurr; To see that this works, let s trace the body of the while loop for n == 6. Table 1 depicts the trace. Now the computation of F n requires n iterations of the while loop in F. fibprev fibcurr curr Table 1: Trace of while loop of the method F for n == 6. 3 Search In the remainder of these notes we shall study some more examples of tail-recursive methods. Each is based on the notion of search: GIVEN: A key k and a collection of items. TASK: Look up item with key k. Examples: Given the name of a person, look up their phone number. Look up the meaning of the French word entrepreneur in a French to English dictionary. Enter a customer s account number in to the computer application and look up the balance of their current account. It may not always be true that such queries result in a success: A person s phone number may not be listed. A word may not be listed in the dictionary. 4

5 An account number may be invalid because of a typo.. In the remainder of the lecture we shall study some search algorithms. To simplify things we shall assume that we are given an array with keys and have to look up a given key. The type of our key is int. For simplicity we shall compare ints using the usual order. 4 Linear Search Our first search problem is as follows. GIVEN: unordered array, keys, of keys. QUESTION: Does keys contain key, and if so at which position? This problem is best solved using linear search which roughly boils down to seeking for key in keys from left to right : 1. If there are no more keys then key is not in keys. 2. Otherwise, if the key is not equal to key then search for key in the remaining keys. 3. Otherwise key is in keys at the current position. The following is a tail-recursive method implementing linear search. /** * Linear search algorithm for deciding if keys[ lo..hi ] contains key. * ASSUMPTION: lo <= hi + 1. **/ int linsearch( int[] keys, int key, int lo, int hi ) { if (lo > hi) { // There are no more keys left. return -1; else if (keys[ lo ]!= key) { // Search for key in remaining keys. return linsearch( keys, key, lo + 1, hi ); else { // We ve located key. return lo; The following is an iterative version of the linear search algorithm. 5

6 int linsearch( int[] keys, int key, int lo, int hi ) { while (true) { if (lo > hi) { return -1; else if (keys[ lo ]!= key) { lo = lo + 1; else { return lo; Notice that the previous algorithm was obtained automatically from the tail-recursive definition. The resulting method is not particularly neat and it would not be wise to submit something like this for an assignment. For example, there are two return statements (exit points) in the method s body and a good algorithm should always have a single exit point. 5 Binary Search Our second problem is as follows: GIVEN: An array, keys, of (distinct) keys which are ordered in strictly ascending order. We are aslo given the index, lo, of the first key and the index, hi, of the last key. QUESTION: Does keys contain a given key, key, and if so at which position? Humans usually solve this problem using binary search. To look up word word in keys[ lo..hi ], the binary search algorithm proceeds as follows: 1. If hi < lo then key is not in keys. 2. Else assign (lo + hi) / 2 to mid. This splits keys into three parts: (I) Keys before position mid. These keys are in keys[ lo..mid - 1 ]. (II) Keys after position mid. These keys are in keys[ mid + 1..hi ]. (III) Key keys[ mid ]. Note that (I) and (II) are about half the size of keys[ lo..hi ]. 3. There are three possibilities: (I) If keys[ mid ] > key then search for key in keys[ lo..mid - 1 ]. (II) Else if keys[ mid ] < key then search for key in keys[ mid + 1..hi ]. (III) Else key is in keys at position mid. 6

7 The following tail recursive method implements the binary search algorithm. int binsearch( int[] keys, int key, int lo, int hi ) { if (lo > hi) { return -1; else { // key is in keys[ lo..hi ] int mid = (lo + hi) / 2; if (key < keys[ mid ]) { return binsearch( keys, key, lo, mid - 1 ); else if (key > keys[ mid ]) { return binsearch( keys, key, mid + 1, hi ); else { return mid; Exercise. Transform the recursive method for binary search to an iterative version. 6 Analysis It is instructive to analyse the average running time of our iterative linear and binary search algorithms. We shall measure the running time indirectly by estimating the number of iterations of the algorithms for a random array keys of size n and a random key. We shall first estimate the average running time of linear search. There are two cases to consider: 1. key is not in keys: We have to carry out the statements in the body of the while statement for each of the n keys. 2. key is in keys: It is reasonable to assume that key is random in the sense that it should be equally likely that key == keys[ i ] for all index position i. Then the probability that key == keys[ i ] is 1/n. Given this probability the expected number of iterations is given by 1 n n i = (n + 1)/2. i=1 Our analysis gives us the worst-case running time for free: Theorem. The worst-case running time of linear search is (n). We shall now analyse the worst-case time complexity of binary search. 7

8 As we ve seen, the algorithm reduces the number of relevant index positions by a factor of two in each iterations. For such algorithms it is useful to assume that the input size is proportional to some (discrete) power of 2. To this end, let s assume that n = 2 s, for some integer s. Next we consider the relationship between the i -th iteration and the number of keys left during the i -th iteration. Table 2 depicts this relationship. This gives us the following result: There are at most s, i.e. number of iteration s number of keys left never exceeds 2 s 2 s 1 2 s 2 1 Table 2: Relationship between iteration and the maximum possible number of relevant keys in keys. log 2 (n) iterations. Therefore the worst-case running time of binary search is (log(n)). The average running time can only be better! (But not much.) Using the Big-Oh notation we may now express the worst-case time complexity of linear search as follows. Theorem. The worst-case time complexity of binary search is (log n). 7 Further Improvements to Linear Search In our analysis we assumed that the time complexity only depends on the number of comparisons. This is a reasonable assumption if the number of keys, n, is large. However, it is not a reasonable assumption if n is small: an important case for many search applications. For example, it has been observed that linear search algorithm may outperform the binary search algorithm if n is small. In the remainder of these notes we shall study some clever transformations which improve the linear search algorithm. 7.1 Sorted Keys If the keys are sorted then the performance of the linear search algorithm may be improved. The following is an iterative implementation of linear search for sorted keys. The members of keys are sorted in non-decreasing order. 8

9 /** * Improved linear search algorithm. * The keys are sorted from small to large. **/ int linsearch( int[] keys, int key, int lo, int hi ) { while (lo <= hi) { if (keys[ lo ] < key) { lo = lo + 1; else if (keys[ lo ] > key) { return -1; else { return lo; return -1; We exploit the fact that the keys are ordered. Therefore, if keys[ lo ] > key then keys[ i ] > key for any remaining i in lo+1 hi. 7.2 Sentinel Before implementing the next improvement, we need to tidy up our previous algorithm. The reason for doing this is that there is a return inside the while loop. Some people argue that this is not a good idea. For example, several return statements makes it more difficult to understand the algorithm. The following code fragment is equivalent to the previous algorithm (prove this) but it has the advantage that the algorithm has only one entry and one exit point. int linsearch( int[] keys, int key, int lo, int hi ) { int cmp = -1; while ((lo <= hi) && (cmp < 0)) { cmp = ( keys[ lo ] < key? -1 : keys[ lo ] > key? 1 : 0 ); if (cmp < 0) { lo = lo + 1; return (cmp!= 0? -1 : lo); Our second improvement is more subtle. This improvement works if comparing keys is relatively 9

10 cheap and if we have a special key, KEY, which is larger than any other (allowed) key. If we have such key then we can eliminate the check (lo <= hi). As with the previous case we sort the keys from small to large. However, this time we put KEY immediately after the last key in keys. Then, when looking for a key key which is not in keys[ lo..hi ], we will eventually run into the key KEY and then KEY > key, which proves that key is not in keys[ lo..hi+1 ]. What is more, the comparison KEY > key may be implemented as key[ lo ] > key, which is just the same as before. Effectively, this merges the termination condition for the case where key is not in keys with the termination condition for the case where key is in keys. Compared to the previous algorithm we save one comparison in every iteration at the expense of having one more comparison if key is larger than the last member in keys. In addition there is no longer any need to pass the parameter hi. The following is the improved algorithm. The variable lo has been renamed to position. Note that an ideal candidate for the sentinel s in the algorithm is the largest possible int is Integer.MAX_VALUE. /** * Linear search with sentinel, s, at end of keys. The * keys are sorted from small to large. The sentinel * has the property that s > k for any valid key k. **/ int linsearch( int[] keys, int key, int position ) { int cmp = -1; while (cmp < 0) { cmp = ( keys[ position ] < key? -1 : keys[ position ] > key? 1 : 0 ); if (cmp < 0) { position = position + 1; return (cmp!= 0? -1 : position); 7.3 Final Improvement Our final improvement is to increment position regardless of the value of cmp. Compared to the previous implementation it saves one comparison in every iteration, but if key is in keys then position will be the successor of the position of key in keys. If we return position - 1 in this case then the result is still correct. 10

11 /** * Linear search with sentinel, s, at end of keys. The * keys are sorted from small to large. The sentinel * has the property that s > k for any valid key k. **/ int linsearch( int[] keys, int key, int position ) { int cmp = -1; while (cmp < 0) { cmp = ( keys[ position ] < key? -1 : keys[ position ] > key? 1 : 0 ); position ++; return (cmp!= 0? -1 : position - 1); Using the do-while construct we may avoid the initial assignment of -1 to cmp. /** * Linear search with sentinel, s, at end of keys. The * keys are sorted from small to large. The sentinel * has the property that s > k for any valid key k. **/ int linsearch( int[] keys, int key, int position ) { int cmp; do { cmp = ( keys[ position ] < key? -1 : keys[ position ] > key? 1 : 0 ); position ++; while (cmp < 0); return (cmp!= 0? -1 : position - 1); 8 For Monday Study the lecture notes. Translate the tail recursive version of binsearch to an iterative version. 11

12 9 Bibliography References [Knuth, 1998] D.E. Knuth. The Art of Computer Programming, volume 3: Sorting and Searching, second edition. Addison Wesley,

### Searching and Sorting. Searching. Binary Search. Linear Search. k N-1. <= x??? > x. x not in here???

Searching and Sorting It s a fundamental area of CS since the beginning of time. Well understood! ll professional programmers should have a good understanding of it. lso provides good example for discussion

### Section IV.1: Recursive Algorithms and Recursion Trees

Section IV.1: Recursive Algorithms and Recursion Trees Definition IV.1.1: A recursive algorithm is an algorithm that solves a problem by (1) reducing it to an instance of the same problem with smaller

### What Is Recursion? Recursion. Binary search example postponed to end of lecture

Recursion Binary search example postponed to end of lecture What Is Recursion? Recursive call A method call in which the method being called is the same as the one making the call Direct recursion Recursion

### Algorithms, Integers

CHAPTER 3 Algorithms, Integers 3.1. Algorithms Consider the following list of instructions to find the maximum of three numbers a, b, c: 1. Assign variable x the value of a. 2. If b > x then assign x the

### Symbol Tables. Introduction

Symbol Tables Introduction A compiler needs to collect and use information about the names appearing in the source program. This information is entered into a data structure called a symbol table. The

### Recursion vs. Iteration Eliminating Recursion

Recursion vs. Iteration Eliminating Recursion continued CS 311 Data Structures and Algorithms Lecture Slides Monday, February 16, 2009 Glenn G. Chappell Department of Computer Science University of Alaska

### Recursive Algorithms. Recursion. Motivating Example Factorial Recall the factorial function. { 1 if n = 1 n! = n (n 1)! if n > 1

Recursion Slides by Christopher M Bourke Instructor: Berthe Y Choueiry Fall 007 Computer Science & Engineering 35 Introduction to Discrete Mathematics Sections 71-7 of Rosen cse35@cseunledu Recursive Algorithms

### Divide-and-Conquer Algorithms Part Four

Divide-and-Conquer Algorithms Part Four Announcements Problem Set 2 due right now. Can submit by Monday at 2:15PM using one late period. Problem Set 3 out, due July 22. Play around with divide-and-conquer

### Figure 1: Graphical example of a mergesort 1.

CSE 30321 Computer Architecture I Fall 2011 Lab 02: Procedure Calls in MIPS Assembly Programming and Performance Total Points: 100 points due to its complexity, this lab will weight more heavily in your

### Lecture Notes on Linear Search

Lecture Notes on Linear Search 15-122: Principles of Imperative Computation Frank Pfenning Lecture 5 January 29, 2013 1 Introduction One of the fundamental and recurring problems in computer science is

### The Tower of Hanoi. Recursion Solution. Recursive Function. Time Complexity. Recursive Thinking. Why Recursion? n! = n* (n-1)!

The Tower of Hanoi Recursion Solution recursion recursion recursion Recursive Thinking: ignore everything but the bottom disk. 1 2 Recursive Function Time Complexity Hanoi (n, src, dest, temp): If (n >

### Intro. to the Divide-and-Conquer Strategy via Merge Sort CMPSC 465 CLRS Sections 2.3, Intro. to and various parts of Chapter 4

Intro. to the Divide-and-Conquer Strategy via Merge Sort CMPSC 465 CLRS Sections 2.3, Intro. to and various parts of Chapter 4 I. Algorithm Design and Divide-and-Conquer There are various strategies we

### 1) The postfix expression for the infix expression A+B*(C+D)/F+D*E is ABCD+*F/DE*++

Answer the following 1) The postfix expression for the infix expression A+B*(C+D)/F+D*E is ABCD+*F/DE*++ 2) Which data structure is needed to convert infix notations to postfix notations? Stack 3) The

### Algorithm Design and Recursion

Chapter 13 Algorithm Design and Recursion Objectives To understand basic techniques for analyzing the efficiency of algorithms. To know what searching is and understand the algorithms for linear and binary

### Persistent Binary Search Trees

Persistent Binary Search Trees Datastructures, UvA. May 30, 2008 0440949, Andreas van Cranenburgh Abstract A persistent binary tree allows access to all previous versions of the tree. This paper presents

### Computer Science 210: Data Structures. Searching

Computer Science 210: Data Structures Searching Searching Given a sequence of elements, and a target element, find whether the target occurs in the sequence Variations: find first occurence; find all occurences

### Analysis of Binary Search algorithm and Selection Sort algorithm

Analysis of Binary Search algorithm and Selection Sort algorithm In this section we shall take up two representative problems in computer science, work out the algorithms based on the best strategy to

### Format of Divide-and-Conquer algorithms:

CS 360: Data Structures and Algorithms Divide-and-Conquer (part 1) Format of Divide-and-Conquer algorithms: Divide: Split the array or list into smaller pieces Conquer: Solve the same problem recursively

### Introduction to Algorithms March 10, 2004 Massachusetts Institute of Technology Professors Erik Demaine and Shafi Goldwasser Quiz 1.

Introduction to Algorithms March 10, 2004 Massachusetts Institute of Technology 6.046J/18.410J Professors Erik Demaine and Shafi Goldwasser Quiz 1 Quiz 1 Do not open this quiz booklet until you are directed

### Data Structures Fibonacci Heaps, Amortized Analysis

Chapter 4 Data Structures Fibonacci Heaps, Amortized Analysis Algorithm Theory WS 2012/13 Fabian Kuhn Fibonacci Heaps Lacy merge variant of binomial heaps: Do not merge trees as long as possible Structure:

### Data Structures and Algorithms

Data Structures and Algorithms Computational Complexity Escola Politècnica Superior d Alcoi Universitat Politècnica de València Contents Introduction Resources consumptions: spatial and temporal cost Costs

### CMPS 102 Solutions to Homework 1

CMPS 0 Solutions to Homework Lindsay Brown, lbrown@soe.ucsc.edu September 9, 005 Problem..- p. 3 For inputs of size n insertion sort runs in 8n steps, while merge sort runs in 64n lg n steps. For which

### Zabin Visram Room CS115 CS126 Searching. Binary Search

Zabin Visram Room CS115 CS126 Searching Binary Search Binary Search Sequential search is not efficient for large lists as it searches half the list, on average Another search algorithm Binary search Very

### Lecture Notes on Binary Search Trees

Lecture Notes on Binary Search Trees 15-122: Principles of Imperative Computation Frank Pfenning André Platzer Lecture 17 October 23, 2014 1 Introduction In this lecture, we will continue considering associative

### Data Structures and Algorithms Written Examination

Data Structures and Algorithms Written Examination 22 February 2013 FIRST NAME STUDENT NUMBER LAST NAME SIGNATURE Instructions for students: Write First Name, Last Name, Student Number and Signature where

### ML for the Working Programmer

ML for the Working Programmer 2nd edition Lawrence C. Paulson University of Cambridge CAMBRIDGE UNIVERSITY PRESS CONTENTS Preface to the Second Edition Preface xiii xv 1 Standard ML 1 Functional Programming

### CSE373: Data Structures and Algorithms Lecture 3: Math Review; Algorithm Analysis. Linda Shapiro Winter 2015

CSE373: Data Structures and Algorithms Lecture 3: Math Review; Algorithm Analysis Linda Shapiro Today Registration should be done. Homework 1 due 11:59 pm next Wednesday, January 14 Review math essential

### Dynamic Programming. Lecture 11. 11.1 Overview. 11.2 Introduction

Lecture 11 Dynamic Programming 11.1 Overview Dynamic Programming is a powerful technique that allows one to solve many different types of problems in time O(n 2 ) or O(n 3 ) for which a naive approach

### CS104: Data Structures and Object-Oriented Design (Fall 2013) October 24, 2013: Priority Queues Scribes: CS 104 Teaching Team

CS104: Data Structures and Object-Oriented Design (Fall 2013) October 24, 2013: Priority Queues Scribes: CS 104 Teaching Team Lecture Summary In this lecture, we learned about the ADT Priority Queue. A

### Simplified Analyses of Randomized Algorithms for Searching, Sorting, and Selection

Simplified Analyses of Randomized Algorithms for Searching, Sorting, and Selection i Michael T. Goodrich Roberto Tamassia Dept. of Info. & Computer Science Dept. of Computer Science University of California

### Converting a Number from Decimal to Binary

Converting a Number from Decimal to Binary Convert nonnegative integer in decimal format (base 10) into equivalent binary number (base 2) Rightmost bit of x Remainder of x after division by two Recursive

### Learning Outcomes. COMP202 Complexity of Algorithms. Binary Search Trees and Other Search Trees

Learning Outcomes COMP202 Complexity of Algorithms Binary Search Trees and Other Search Trees [See relevant sections in chapters 2 and 3 in Goodrich and Tamassia.] At the conclusion of this set of lecture

### Analysis of Algorithms: The Non-recursive Case

Analysis of Algorithms: The Non-recursive Case Key topics: * Introduction * Generalizing Running Time * Doing a Timing Analysis * Big-Oh Notation * Big-Oh Operations * Analyzing Some Simple Programs -

### 1 2-3 Trees: The Basics

CS10: Data Structures and Object-Oriented Design (Fall 2013) November 1, 2013: 2-3 Trees: Inserting and Deleting Scribes: CS 10 Teaching Team Lecture Summary In this class, we investigated 2-3 Trees in

### Merge Sort. 2004 Goodrich, Tamassia. Merge Sort 1

Merge Sort 7 2 9 4 2 4 7 9 7 2 2 7 9 4 4 9 7 7 2 2 9 9 4 4 Merge Sort 1 Divide-and-Conquer Divide-and conquer is a general algorithm design paradigm: Divide: divide the input data S in two disjoint subsets

### x if x 0, x if x < 0.

Chapter 3 Sequences In this chapter, we discuss sequences. We say what it means for a sequence to converge, and define the limit of a convergent sequence. We begin with some preliminary results about the

### Lecture 12 Doubly Linked Lists (with Recursion)

Lecture 12 Doubly Linked Lists (with Recursion) In this lecture Introduction to Doubly linked lists What is recursion? Designing a node of a DLL Recursion and Linked Lists o Finding a node in a LL (recursively)

### 16. Recursion. COMP 110 Prasun Dewan 1. Developing a Recursive Solution

16. Recursion COMP 110 Prasun Dewan 1 Loops are one mechanism for making a program execute a statement a variable number of times. Recursion offers an alternative mechanism, considered by many to be more

### Class Overview. CSE 326: Data Structures. Goals. Goals. Data Structures. Goals. Introduction

Class Overview CSE 326: Data Structures Introduction Introduction to many of the basic data structures used in computer software Understand the data structures Analyze the algorithms that use them Know

### PES Institute of Technology-BSC QUESTION BANK

PES Institute of Technology-BSC Faculty: Mrs. R.Bharathi CS35: Data Structures Using C QUESTION BANK UNIT I -BASIC CONCEPTS 1. What is an ADT? Briefly explain the categories that classify the functions

### Sequential Data Structures

Sequential Data Structures In this lecture we introduce the basic data structures for storing sequences of objects. These data structures are based on arrays and linked lists, which you met in first year

### Introduction to data structures

Notes 2: Introduction to data structures 2.1 Recursion 2.1.1 Recursive functions Recursion is a central concept in computation in which the solution of a problem depends on the solution of smaller copies

### Why? A central concept in Computer Science. Algorithms are ubiquitous.

Analysis of Algorithms: A Brief Introduction Why? A central concept in Computer Science. Algorithms are ubiquitous. Using the Internet (sending email, transferring files, use of search engines, online

### Project and Production Management Prof. Arun Kanda Department of Mechanical Engineering Indian Institute of Technology, Delhi

Project and Production Management Prof. Arun Kanda Department of Mechanical Engineering Indian Institute of Technology, Delhi Lecture - 15 Limited Resource Allocation Today we are going to be talking about

### Questions 1 through 25 are worth 2 points each. Choose one best answer for each.

Questions 1 through 25 are worth 2 points each. Choose one best answer for each. 1. For the singly linked list implementation of the queue, where are the enqueues and dequeues performed? c a. Enqueue in

### Recursion. Slides. Programming in C++ Computer Science Dept Va Tech Aug., 2001. 1995-2001 Barnette ND, McQuain WD

1 Slides 1. Table of Contents 2. Definitions 3. Simple 4. Recursive Execution Trace 5. Attributes 6. Recursive Array Summation 7. Recursive Array Summation Trace 8. Coding Recursively 9. Recursive Design

### Homework 5 Solutions

Homework 5 Solutions 4.2: 2: a. 321 = 256 + 64 + 1 = (01000001) 2 b. 1023 = 512 + 256 + 128 + 64 + 32 + 16 + 8 + 4 + 2 + 1 = (1111111111) 2. Note that this is 1 less than the next power of 2, 1024, which

### QUIZ-II QUIZ-II. Chapter 5: Control Structures II (Repetition) Objectives. Objectives (cont d.) 20/11/2015. EEE 117 Computer Programming Fall-2015 1

QUIZ-II Write a program that mimics a calculator. The program should take as input two integers and the operation to be performed. It should then output the numbers, the operator, and the result. (For

### Binary search algorithm

Binary search algorithm Definition Search a sorted array by repeatedly dividing the search interval in half. Begin with an interval covering the whole array. If the value of the search key is less than

### Mathematical Induction. Lecture 10-11

Mathematical Induction Lecture 10-11 Menu Mathematical Induction Strong Induction Recursive Definitions Structural Induction Climbing an Infinite Ladder Suppose we have an infinite ladder: 1. We can reach

### Analysis of a Search Algorithm

CSE 326 Lecture 4: Lists and Stacks 1. Agfgd 2. Dgsdsfd 3. Hdffdsf 4. Sdfgsfdg 5. Tefsdgass We will review: Analysis: Searching a sorted array (from last time) List ADT: Insert, Delete, Find, First, Kth,

### 6. Standard Algorithms

6. Standard Algorithms The algorithms we will examine perform Searching and Sorting. 6.1 Searching Algorithms Two algorithms will be studied. These are: 6.1.1. inear Search The inear Search The Binary

### VALLIAMMAI ENGINEERING COLLEGE SRM NAGAR, KATTANKULATHUR 603 203 DEPARTMENT OF COMPUTER APPLICATIONS QUESTION BANK IN REVISED BLOOM S TAXONOMY

ACADEMIC YEAR: 0 7 VALLIAMMAI ENGINEERING COLLEGE SRM NAGAR, KATTANKULATHUR 0 0 SEMESTER: ODD BRANCH: MCA YEAR: I SEMESTER: I SUBJECT CODE AND NAME: MC70 Problem Solving and Programming NAME OF THE FACULTY

### Outline BST Operations Worst case Average case Balancing AVL Red-black B-trees. Binary Search Trees. Lecturer: Georgy Gimel farb

Binary Search Trees Lecturer: Georgy Gimel farb COMPSCI 220 Algorithms and Data Structures 1 / 27 1 Properties of Binary Search Trees 2 Basic BST operations The worst-case time complexity of BST operations

### Outline. Introduction Linear Search. Transpose sequential search Interpolation search Binary search Fibonacci search Other search techniques

Searching (Unit 6) Outline Introduction Linear Search Ordered linear search Unordered linear search Transpose sequential search Interpolation search Binary search Fibonacci search Other search techniques

### CS 103X: Discrete Structures Homework Assignment 3 Solutions

CS 103X: Discrete Structures Homework Assignment 3 s Exercise 1 (20 points). On well-ordering and induction: (a) Prove the induction principle from the well-ordering principle. (b) Prove the well-ordering

### 10CS35: Data Structures Using C

CS35: Data Structures Using C QUESTION BANK REVIEW OF STRUCTURES AND POINTERS, INTRODUCTION TO SPECIAL FEATURES OF C OBJECTIVE: Learn : Usage of structures, unions - a conventional tool for handling a

### CHAPTER 5. Number Theory. 1. Integers and Division. Discussion

CHAPTER 5 Number Theory 1. Integers and Division 1.1. Divisibility. Definition 1.1.1. Given two integers a and b we say a divides b if there is an integer c such that b = ac. If a divides b, we write a

### Sorting revisited. Build the binary search tree: O(n^2) Traverse the binary tree: O(n) Total: O(n^2) + O(n) = O(n^2)

Sorting revisited How did we use a binary search tree to sort an array of elements? Tree Sort Algorithm Given: An array of elements to sort 1. Build a binary search tree out of the elements 2. Traverse

### Total Quality Management (TQM) Quality, Success and Failure. Total Quality Management (TQM) vs. Process Reengineering (BPR)

Total Quality Management (TQM) Quality, Success and Failure Total Quality Management (TQM) is a concept that makes quality control a responsibility to be shared by all people in an organization. M7011

### Course: Programming II - Abstract Data Types. The ADT Stack. A stack. The ADT Stack and Recursion Slide Number 1

Definition Course: Programming II - Abstract Data Types The ADT Stack The ADT Stack is a linear sequence of an arbitrary number of items, together with access procedures. The access procedures permit insertions

### Jeri R. Hanly and Elliot B. Koffman, Problem Solving and Program Design in C, 7th ed., 2012, Addison- Wesley. (Required)

University of Macau Faculty of Science and Technology Department of Computer and Information Science CISB110 Programming Science Syllabus 1 st Semester 2014/2015 Part A Course Outline Compulsory course

### Binary Heaps * * * * * * * / / \ / \ / \ / \ / \ * * * * * * * * * * * / / \ / \ / / \ / \ * * * * * * * * * *

Binary Heaps A binary heap is another data structure. It implements a priority queue. Priority Queue has the following operations: isempty add (with priority) remove (highest priority) peek (at highest

### Lecture P6: Recursion

Overview Lecture P6: Recursion What is recursion? When one function calls ITSELF directly or indirectly. Why learn recursion? New mode of thinking. Start Goal Powerful programming tool. Many computations

### Chapter 8: Bags and Sets

Chapter 8: Bags and Sets In the stack and the queue abstractions, the order that elements are placed into the container is important, because the order elements are removed is related to the order in which

### CSC 180 H1F Algorithm Runtime Analysis Lecture Notes Fall 2015

1 Introduction These notes introduce basic runtime analysis of algorithms. We would like to be able to tell if a given algorithm is time-efficient, and to be able to compare different algorithms. 2 Linear

### Module 2 Stacks and Queues: Abstract Data Types

Module 2 Stacks and Queues: Abstract Data Types A stack is one of the most important and useful non-primitive linear data structure in computer science. It is an ordered collection of items into which

### Data Structures and Algorithms

Data Structures and Algorithms Luciano Bononi Computer Science Engineering University of Bologna bononi@cs.unibo.it http://www.cs.unibo.it/~bononi/ Slide credits: these slides have been translated from

### Binary Heap Algorithms

CS Data Structures and Algorithms Lecture Slides Wednesday, April 5, 2009 Glenn G. Chappell Department of Computer Science University of Alaska Fairbanks CHAPPELLG@member.ams.org 2005 2009 Glenn G. Chappell

### Algorithms. Margaret M. Fleck. 18 October 2010

Algorithms Margaret M. Fleck 18 October 2010 These notes cover how to analyze the running time of algorithms (sections 3.1, 3.3, 4.4, and 7.1 of Rosen). 1 Introduction The main reason for studying big-o

### The Goldberg Rao Algorithm for the Maximum Flow Problem

The Goldberg Rao Algorithm for the Maximum Flow Problem COS 528 class notes October 18, 2006 Scribe: Dávid Papp Main idea: use of the blocking flow paradigm to achieve essentially O(min{m 2/3, n 1/2 }

### The first step in solving a problem recursively is to formulate a recursive definition of the problem.

Chapter 8 Recursion The subject of this chapter is recursion, an implicit application of the stack ADT. A recursive method is a method that carries out its task by making a call(s) to itself. Each recursive

### Finding the n th digit in a sequence of positive integers placed in a row in ascending order.

Katedralskolan, Uppsala Finding the n th digit in a sequence of positive integers placed in a row in ascending order. By Artem Los 12345...? Candidate number: 121-032 Supervisor: Erik Östergren Page count:

### Introduction to Programming System Design. CSCI 455x (4 Units)

Introduction to Programming System Design CSCI 455x (4 Units) Description This course covers programming in Java and C++. Topics include review of basic programming concepts such as control structures,

### Quicksort is a divide-and-conquer sorting algorithm in which division is dynamically carried out (as opposed to static division in Mergesort).

Chapter 7: Quicksort Quicksort is a divide-and-conquer sorting algorithm in which division is dynamically carried out (as opposed to static division in Mergesort). The three steps of Quicksort are as follows:

### Euclid s Algorithm for the Greatest Common Divisor Desh Ranjan Department of Computer Science New Mexico State University

Euclid s Algorithm for the Greatest Common Divisor Desh Ranjan Department of Computer Science New Mexico State University 1 Numbers, Division and Euclid People have been using numbers, and operations on

### Theory of Computation Prof. Kamala Krithivasan Department of Computer Science and Engineering Indian Institute of Technology, Madras

Theory of Computation Prof. Kamala Krithivasan Department of Computer Science and Engineering Indian Institute of Technology, Madras Lecture No. # 31 Recursive Sets, Recursively Innumerable Sets, Encoding

### A binary search tree or BST is a binary tree that is either empty or in which the data element of each node has a key, and:

Binary Search Trees 1 The general binary tree shown in the previous chapter is not terribly useful in practice. The chief use of binary trees is for providing rapid access to data (indexing, if you will)

### HW4: Merge Sort. 1 Assignment Goal. 2 Description of the Merging Problem. Course: ENEE759K/CMSC751 Title:

HW4: Merge Sort Course: ENEE759K/CMSC751 Title: Merge Sort Date Assigned: March 24th, 2009 Date Due: April 10th, 2009 11:59pm Contact: Fuat Keceli keceli (at) umd (dot) edu 1 Assignment Goal The final

### Overview. Essential Questions. Precalculus, Quarter 4, Unit 4.5 Build Arithmetic and Geometric Sequences and Series

Sequences and Series Overview Number of instruction days: 4 6 (1 day = 53 minutes) Content to Be Learned Write arithmetic and geometric sequences both recursively and with an explicit formula, use them

### , each of which contains a unique key value, say k i , R 2. such that k i equals K (or to determine that no such record exists in the collection).

The Search Problem 1 Suppose we have a collection of records, say R 1, R 2,, R N, each of which contains a unique key value, say k i. Given a particular key value, K, the search problem is to locate the

### recursion here it is in C++ power function cis15 advanced programming techniques, using c++ fall 2007 lecture # VI.1

topics: recursion searching cis15 advanced programming techniques, using c++ fall 2007 lecture # VI.1 recursion recursion is defining something in terms of itself there are many examples in nature and

### Binary Search Trees CMPSC 122

Binary Search Trees CMPSC 122 Note: This notes packet has significant overlap with the first set of trees notes I do in CMPSC 360, but goes into much greater depth on turning BSTs into pseudocode than

### CS 5303 Introduction to Programming and Problem Solving

CS 5303 Introduction to Programming and Problem Solving Spring 2013 Syllabus (Updated on 3/13/2013) Course Information Course level: Graduate Bridge Course Prerequisites Graduate status or Permission of

### Binary Search. Search for x in a sorted array A.

Divide and Conquer A general paradigm for algorithm design; inspired by emperors and colonizers. Three-step process: 1. Divide the problem into smaller problems. 2. Conquer by solving these problems. 3.

### 2. Compressing data to reduce the amount of transmitted data (e.g., to save money).

Presentation Layer The presentation layer is concerned with preserving the meaning of information sent across a network. The presentation layer may represent (encode) the data in various ways (e.g., data

### Loop Invariants and Binary Search

Loop Invariants and Binary Search Chapter 4.3.3 and 9.3.1-1 - Outline Ø Iterative Algorithms, Assertions and Proofs of Correctness Ø Binary Search: A Case Study - 2 - Outline Ø Iterative Algorithms, Assertions

### The Running Time of Programs

CHAPTER 3 The Running Time of Programs In Chapter 2, we saw two radically different algorithms for sorting: selection sort and merge sort. There are, in fact, scores of algorithms for sorting. This situation

### APP INVENTOR. Test Review

APP INVENTOR Test Review Main Concepts App Inventor Lists Creating Random Numbers Variables Searching and Sorting Data Linear Search Binary Search Selection Sort Quick Sort Abstraction Modulus Division

### Chapter 2 Allocation of Virtual Machines

Chapter 2 Allocation of Virtual Machines In this chapter, we introduce a solution to the problem of cost-effective VM allocation and reallocation. Unlike traditional solutions, which typically reallocate

### GRID SEARCHING Novel way of Searching 2D Array

GRID SEARCHING Novel way of Searching 2D Array Rehan Guha Institute of Engineering & Management Kolkata, India Abstract: Linear/Sequential searching is the basic search algorithm used in data structures.

### The Union-Find Problem Kruskal s algorithm for finding an MST presented us with a problem in data-structure design. As we looked at each edge,

The Union-Find Problem Kruskal s algorithm for finding an MST presented us with a problem in data-structure design. As we looked at each edge, cheapest first, we had to determine whether its two endpoints

### Lecture Notes on Binary Search Trees

Lecture Notes on Binary Search Trees 15-122: Principles of Imperative Computation Frank Pfenning Lecture 17 March 17, 2010 1 Introduction In the previous two lectures we have seen how to exploit the structure

### Recursion. Definition: o A procedure or function that calls itself, directly or indirectly, is said to be recursive.

Recursion Definition: o A procedure or function that calls itself, directly or indirectly, is said to be recursive. Why recursion? o For many problems, the recursion solution is more natural than the alternative

### Lecture 9 - Message Authentication Codes

Lecture 9 - Message Authentication Codes Boaz Barak March 1, 2010 Reading: Boneh-Shoup chapter 6, Sections 9.1 9.3. Data integrity Until now we ve only been interested in protecting secrecy of data. However,

### TIE-20106 1 TIE-20106 2

TIE-20106 1 1 List structures In this chapter, a few simple data structures (stack and queue) that can be implemented with arrays and/or lists are covered. Two more complex structures based on lists are

### Pseudo code Tutorial and Exercises Teacher s Version

Pseudo code Tutorial and Exercises Teacher s Version Pseudo-code is an informal way to express the design of a computer program or an algorithm in 1.45. The aim is to get the idea quickly and also easy