# Writing programs to solve problem consists of a large. how to represent aspects of the problem for solution

Save this PDF as:

Size: px
Start display at page:

Download "Writing programs to solve problem consists of a large. how to represent aspects of the problem for solution"

## Transcription

1 Algorithm Efficiency & Sorting Algorithm efficiency Big-O notation Searching algorithms Sorting algorithms 1 Overview 2 If a given ADT (i.e. stack or queue) is attractive as part of a solution How will the ADT implemention affect the program's: correctness and performance? Several goals must be balanced by a developer in producing a solution to a problem correctness, clarity, and efficient use of computer resources to produce the best performance How is solution performance best measured? time and space 3 Overview Writing programs to solve problem consists of a large number of decisions how to represent aspects of the problem for solution which of several approaches to a given solution component to use If several algorithms are available for solving a given problem, the developer must choose among them If several ADTs can be used to represent a given set of problem data which ADT should be used? how will ADT choice affect algorithm choice? Overview 3 The order of importance is, generally, correctness efficiency clarity Clarity of expression is qualitative and somewhat dependent on perception by the reader developer salary costs dominate many software projects time efficiency of understanding code written by others can thus have a significant monetary implication Focus of this chapter is execution efficiency mostly, run-time (some times, memory space) 2 4

2 Measuring Algorithmic Efficiency Analysis of algorithms provides tools for contrasting the efficiency of different methods of solution Comparison of algorithms should focus on significant differences in efficiency should not consider reductions in computing costs due to clever coding tricks Difficult to compare programs instead of algorithms how are the algorithms coded? what computer should you use? what data should the programs use? Analyzing Algorithmic Cost Analyzing Algorithmic Cost Analyzing Algorithmic Cost 3 Do not attempt to accumulate a precise prediction for program execution time, because far too many complicating factors: compiler instructions output, variation with specific data sets, target hardware speed Provide an approximation, an order of magnitude estimate, that permits fair comparison of one algorithm's behavior against that of another 6 8

3 Analyzing Algorithmic Cost 4 Various behavior bounds are of interest best case, average case, worst case Worst-case analysis A determination of the maximum amount of time that an algorithm requires to solve problems of size n Average-case analysis A determination of the average amount of time that an algorithm requires to solve problems of size n Best-case analysis A determination of the minimum amount of time that an algorithm requires to solve problems of size n 9 Example Linked List Traversal Assumptions C 1 = cost of assign. C 2 = cost of compare C 3 = cost of write Node *cur = head; // assignment op while (cur!= NULL) // comparisons op << endl; // write op // assignment op Consider the number of operations for n items T(n) = (n+1)c 1 + (n+1)c 2 + nc 3 = (C 1 +C 2 +C 3 )n + (C 1 +C 2 ) = K 1 n + K 2 Says, algorithm is of linear complexity work done grows linearly with n but also involves constants 11 Analyzing Algorithmic Cost 5 Complexity measures can be calculated in terms of T(n): time complexity and S(n): space complexity Basic model of computation used sequential computer (one statement at a time) all data require same amount of storage in memory each datum in memory can be accessed in constant time each basic operation can be executed in constant time Note that all of these assumptions are incorrect! good for this purpose Calculations we want are order of magnitude 10 Example Sequential Search Number of comparisons T B (n) = 1 T w (n) = n T A (n) = (n+1)/2 In general, what developers worry about the most is that this is O(n) algorithm more precise analysis is nice but rarely influences algorithmic decision Seq_Search(A: array, key: integer); i = 1; i = i + 1 endwhile; then return(i) else return(0) endif; end Sequential_Search; 12

4 Bounding Functions Asymptotic Upper Bound Asymptotic Upper Bound Algorithm Growth Rates measured as a function of the problem size Number of nodes in a linked list Size of an array Number of items in a stack Number of disks in the Towers of Hanoi problem 14 16

5 Algorithm Growth Rates 2 Algorithm A requires time proportional to n 2 Algorithm B requires time proportional to n Order-of-Magnitude Analysis and Big O Notation Figure 9-3a A comparison of growth-rate functions: (a) in tabular form Algorithm Growth Rates 3 algorithm with another Example if, algorithm A requires time proportional to n 2, and algorithm B requires time proportional to n algorithm B is faster than algorithm A n 2 and n are growth-rate functions Algorithm A is O(n 2 ) - order n 2 Algorithm B is O(n) - order n Growth-rate function f(n) order in terms of the size of the problem Order-of-Magnitude Analysis and Big O Notation Figure 9-3b A comparison of growth-rate functions: (b) in graphical form 18 20

6 Order-of-Magnitude Analysis and Big O Notation Order of growth of some common functions O(C) < O(log(n)) < O(n) < O(n * log(n)) < O(n 2 ) < O(n 3 ) < O(2 n ) < O(3 n ) < O(n!) < O(n n ) Properties of growth-rate functions O(n 3 + 3n) is O(n 3 ): ignore low-order terms O(5 f(n)) = O(f(n)): ignore multiplicative constant in the high-order term O(f(n)) + O(g(n)) = O(f(n) + g(n)) Keeping Your Perspective If the problem size is always small, you can order-of-magnitude analysis focuses on large problems Weigh the trade- time requirements and its memory requirements Compare algorithms for both style and efficiency Keeping Your Perspective Only significant differences in efficiency are interesting Frequency of operations how frequently particular ADT operations occur in a given application however, some seldom-used but critical operations must be efficient 22 Sequential Search Sequential search look at each item in the data collection in turn stop when the desired item is found, or the end of the data is reached int search(const int a[ ], int number_used, int target) { int index = 0; bool found = false; while ((!found) && (index < number_used)) { if (target == a[index]) found = true; else Index++; if (found) return index; else return -1; 24

7 Efficiency of Sequential Search Worst case: O(n) key value not present, we search the entire list to prove failure Average case: O(n) all positions for the key being equally likely Best case: O(1) key value happens to be first Sorting Algorithms and Their Efficiency Sorting A process that organizes a collection of data into either ascending or descending order The sort key is the data item that we consider when sorting a data collection Sorting algorithm types comparison based bubble sort, insertion sort, quick sort, etc. address calculation radix sort The Efficiency of Searching Algorithms Binary search of a sorted array Strategy Repeatedly divide the array in half Determine which half could contain the item, and discard the other half Efficiency Worst case: O(log 2 n) For large arrays, the binary search has an enormous advantage over a sequential search At most 20 comparisons to search an array of one million items Sorting Algorithms and Their Efficiency Categories of sorting algorithms An internal sort Requires that the collection of data fit entirely in the An external sort main memory all at once, but must reside in secondary storage 26 28

8 Selection Sort Strategy Place the largest (or smallest) item in its correct place Place the next largest (or next smallest) item in its correct place, and so on Algorithm for index=0 to size-2 { -1]; swap(a[index], min); Analysis worst case: O(n 2 ), average case: O(n 2 ) does not depend on the initial arrangement of the data Bubble Sort Strategy compare adjacent elements and exchange them if they are out of order moves the largest (or smallest) elements to the end of the array repeat this process eventually sorts the array into ascending (or descending) order Analysis: worst case: O(n 2 ), best case: O(n) Selection Sort Figure 9-4 A selection sort of an array of five integers Bubble Sort algorithm for i = 1 to size - 1 do for index = 1 to size - i do if A[index] < A[index-1] swap(a[index], A[index-1]); endfor; endfor; 30 32

9 Bubble Sort Figure 9-5 The first two passes of a bubble sort of an array of five integers: (a) pass 1; (b) pass 2 Insertion Sort Figure 9-7 An insertion sort of an array of five integers Insertion Sort Strategy Partition array in two regions: sorted and unsorted initially, entire array is in unsorted region take each item from the unsorted region and insert it into its correct position in the sorted region each pass shrinks unsorted region by 1 and grows sorted region by 1 Analysis Worst case: O(n 2 ) Appropriate for small arrays due to its simplicity Prohibitively inefficient for large arrays Mergesort A recursive sorting algorithm Performance is independent of the initial order of the array items Strategy divide an array into halves sort each half merge the sorted halves into one sorted array divide-and-conquer approach 34 36

10 Mergesort Algorithm mergesort(a,first,last) { if (first < last) { mid = (first + last)/2; mergesort(a, first, mid); mergesort(a, mid+1, last); merge(a, first, mid, last) Mergesort Mergesort Mergesort Properties Needs a temporary array into which to copy elements during merging doubles space requirement Mergesort is stable items with equal key values appear in the same order in the output array as in the input Advantage mergesort is an extremely fast algorithm Analysis: worst / average case: O(n * log2n) 38 40

11 Quicksort A recursive divide-and-conquer algorithm given a linear data structure A with n records divide A into sub-structures S 1 and S 2 sort S 1 and S 2 recursively Algorithm Base case: if S ==1, S is already sorted Recursive case: divide A around a pivot value P into S 1 and S 2, such that all elements of S 1 <=P and all elements of S 2 >=P recursively sort S1 and S2 in place Quicksort Pivot Partitioning Pivot selection and array partition are fundamental work of algorithm Pivot selection perfect value: median of A[ ] sort required to determine median (oops!) approximation: If A > N, N==3 or N==5, use median of N Heuristic approaches used instead Choose A[first] OR A[last] OR A[mid] (mid = (first+last)/2) OR Random element heuristics equivalent if contents of A[ ] randomly arranged Quicksort Partition() (a) scans array, (b) chooses a pivot, (c) divides A around pivot, (d) returns pivot index Invariant: items in S 1 are all less than pivot, and items in S 2 are all greater than or equal to pivot Quicksort() partitions A, sorts S 1 and S 2 recursively Quicksort Pivot Partitioning Example A= [5,8,3,7,4,2,1,6], first =0, last =7 A[first]: pivot = 5, A[last]: pivot = 6, A[mid]: mid =(0+7)/2=3, pivot = 7 A[random()]: any key might be chosen A[medianof3]: median(a[first], A[mid], A[last]) is median(5,7,6) = 6 a sort of a fixed number of items is only O(1) Good pivot selection computed in O(1) time and partitions A into roughly equal parts S1 and S

12 Quicksort Pivot Partitioning Middle element is pivot lasts1: index of last element of S1 partition firstunknown: first element needing classification if <p, then add to first partition by incrementing last S1 and swapping incrementing firstunknown expands partitioned sets either way Partitioning is an O(n) operation over A[ ] int partition(a,first,last) { middle = (first+last)/2; pivot = A[middle]; swap(a[middle],a[first]); lasts1 = first; firstunknown = first+1; while( firstunknown <= last ) { if (A[firstUnknown] < pivot) { lasts1++; swap(a[firstunknown],a[lasts1]); firstunknown++; swap(a[first],a[lasts1]); pivotindex = lasts1; return(pivotindex); 45 Quicksort Analysis Best case perfect partition at each level, log 2 n levels O(n log n) total Average case roughly equal partition O(n log n) Worst case S1 or S2 always empty When the array is already sorted and the smallest item is chosen as the pivot O(n 2 ), n levels, rare as long is input is in random order 47 Quicksort Pivot Partitioning lasts1 firstunknown first last mid pivotindex = 5 S1 = A[0..4] S2 = A[6..7] Quicksort Analysis Partitioning and recursive call overhead is such that for A < 10 or so it is faster to simply use insertion sort precise tipping point will vary with architecture but, Quicksort is usually extremely fast in practice Not stable like Mergesort, but sorts in place Even performance is acceptable for moderately large arrays 46 48

13 Radix Sort Radix sort is a special kind of distribution sort that can efficiently sort data items using integer or other t element keys (a t a t-1...a 0 ) m in a given radix (base) m character string keys work as well; total order of all characters required Strategy Treats each data element as a character string Repeatedly organizes the data into groups according to the i th character in each element Radix Sort Figure 9-21 A radix sort of eight integers Radix Sort Basic idea each key consists of t places, each holding one of m possible values use m buckets and iterate the basic algorithm t times, each time using a different element of the key for sorting iterate from least significant to most significant key position Five digit key, iterated over 10 0, 10 1, 10 2, 10 3, 10 4 using buckets 0-9 each time FRED Four character keys using capitol letters, iterated from right to left using 26 buckets A-Z each time Analysis: Radix sort is O(n) A Comparison of Sorting Algorithms Heapsort Figure 9-22 Approximate growth rates of time required for eight sorting algorithms 50 52

14 Summary Order-of-magnitude analysis and Big O requirement as a function of the problem size by using a growth-rate function To compare the efficiency of algorithms examine growth-rate functions when problems are large consider only significant differences in growth-rate functions 53 Summary Worst case complexity of sorting algorithms Imput in Sorted Order Bubble Sort O(n) O(n 2 ) Insertion Sort O(n) O(n 2 ) Selection Sort O(n 2 ) O(n 2 ) Merge Sort O(n log n) O(n log n) Quick Sort O(n 2 ) O(n 2 ) Radix Sort O(n) O(n) Input in Reverse Sorted Order 55 Summary Worst-case and average-case analyses worst-case analysis considers the maximum amount of work an algorithm will require on a problem of a given size average-case analysis considers the expected amount of work that an algorithm will require on a problem of a given size Summary Complexity of sorting algorithms for random data, most common case TB(n) TW(n) TA(n) Bubble O(n) O(n 2 ) O(n 2 ) Insertion O(n) O(n 2 ) O(n 2 ) Selection O(n 2 ) O(n 2 ) O(n 2 ) Merge O(n log n) O(n log n) O(n log n) Quiksort O(n log n) O(n 2 ) O(n log n) Radix O(n) O(n) O(n) 54 56

15 Summary Stability of sorting algorithms stable sort preserves the input order of data items with identical keys Thus, if input items x and y have identical keys, and x precedes y in the input data set, x will precede y in the output sorted data set bubble, insertion, selection, merge, and radix are stable sorting algorithms 57

### 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

### 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

### CSC148 Lecture 8. Algorithm Analysis Binary Search Sorting

CSC148 Lecture 8 Algorithm Analysis Binary Search Sorting Algorithm Analysis Recall definition of Big Oh: We say a function f(n) is O(g(n)) if there exists positive constants c,b such that f(n)

### Sorting Algorithms. Nelson Padua-Perez Bill Pugh. Department of Computer Science University of Maryland, College Park

Sorting Algorithms Nelson Padua-Perez Bill Pugh Department of Computer Science University of Maryland, College Park Overview Comparison sort Bubble sort Selection sort Tree sort Heap sort Quick sort Merge

### 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

### 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

### In mathematics, it is often important to get a handle on the error term of an approximation. For instance, people will write

Big O notation (with a capital letter O, not a zero), also called Landau's symbol, is a symbolism used in complexity theory, computer science, and mathematics to describe the asymptotic behavior of functions.

### CSE 326, Data Structures. Sample Final Exam. Problem Max Points Score 1 14 (2x7) 2 18 (3x6) 3 4 4 7 5 9 6 16 7 8 8 4 9 8 10 4 Total 92.

Name: Email ID: CSE 326, Data Structures Section: Sample Final Exam Instructions: The exam is closed book, closed notes. Unless otherwise stated, N denotes the number of elements in the data structure

### 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

### 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 >

### 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

### Mergesort and Quicksort

Mergesort Mergesort and Quicksort Basic plan: Divide array into two halves. Recursively sort each half. Merge two halves to make sorted whole. mergesort mergesort analysis quicksort quicksort analysis

### 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

### 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

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

### 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

### 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

### 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

### Today s Outline. Exercise. Binary Search Analysis. Linear Search Analysis. Asymptotic Analysis. Analyzing Code. Announcements. Asymptotic Analysis

Today s Outline Announcements Assignment #1 due Thurs, Oct 7 at 11:45pm Asymptotic Analysis Asymptotic Analysis CSE 7 Data Structures & Algorithms Ruth Anderson Autumn 2010 Exercise Analyzing Code bool

### 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

### 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

### Algorithm Analysis [2]: if-else statements, recursive algorithms. COSC 2011, Winter 2004, Section N Instructor: N. Vlajic

1 Algorithm Analysis []: if-else statements, recursive algorithms COSC 011, Winter 004, Section N Instructor: N. Vlajic Algorithm Analysis for-loop Running Time The running time of a simple loop for (int

### 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:

### 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

### 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

### 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

### Divide and Conquer. Textbook Reading Chapters 4, 7 & 33.4

Divide d Conquer Textook Reading Chapters 4, 7 & 33.4 Overview Design principle Divide d conquer Proof technique Induction, induction, induction Analysis technique Recurrence relations Prolems Sorting

### 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

### 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

### DATA STRUCTURES USING C

DATA STRUCTURES USING C QUESTION BANK UNIT I 1. Define data. 2. Define Entity. 3. Define information. 4. Define Array. 5. Define data structure. 6. Give any two applications of data structures. 7. Give

### CS473 - Algorithms I

CS473 - Algorithms I Lecture 9 Sorting in Linear Time View in slide-show mode 1 How Fast Can We Sort? The algorithms we have seen so far: Based on comparison of elements We only care about the relative

### Efficiency of algorithms. Algorithms. Efficiency of algorithms. Binary search and linear search. Best, worst and average case.

Algorithms Efficiency of algorithms Computational resources: time and space Best, worst and average case performance How to compare algorithms: machine-independent measure of efficiency Growth rate Complexity

### 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

### Data Structures. Algorithm Performance and Big O Analysis

Data Structures Algorithm Performance and Big O Analysis What s an Algorithm? a clearly specified set of instructions to be followed to solve a problem. In essence: A computer program. In detail: Defined

### 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

### AS-2261 M.Sc.(First Semester) Examination-2013 Paper -fourth Subject-Data structure with algorithm

AS-2261 M.Sc.(First Semester) Examination-2013 Paper -fourth Subject-Data structure with algorithm Time: Three Hours] [Maximum Marks: 60 Note Attempts all the questions. All carry equal marks Section A

### recursion, O(n), linked lists 6/14

recursion, O(n), linked lists 6/14 recursion reducing the amount of data to process and processing a smaller amount of data example: process one item in a list, recursively process the rest of the list

### 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

### 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

### 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

### 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

### AP Computer Science AB Syllabus 1

AP Computer Science AB Syllabus 1 Course Resources Java Software Solutions for AP Computer Science, J. Lewis, W. Loftus, and C. Cocking, First Edition, 2004, Prentice Hall. Video: Sorting Out Sorting,

### 1. The memory address of the first element of an array is called A. floor address B. foundation addressc. first address D.

1. The memory address of the first element of an array is called A. floor address B. foundation addressc. first address D. base address 2. The memory address of fifth element of an array can be calculated

### Data Structures and Data Manipulation

Data Structures and Data Manipulation What the Specification Says: Explain how static data structures may be used to implement dynamic data structures; Describe algorithms for the insertion, retrieval

### Data Structure [Question Bank]

Unit I (Analysis of Algorithms) 1. What are algorithms and how they are useful? 2. Describe the factor on best algorithms depends on? 3. Differentiate: Correct & Incorrect Algorithms? 4. Write short note:

### 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

### 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 -

### Vimal P.Parmar Research Scholar, Department of Computer Science Saurashtra University, Rajkot Gujarat, INDIA

Comparing Linear Search and Binary Search Algorithms to Search an Element from a Linear List Implemented through Static Array, Dynamic Array and Linked List Vimal P.Parmar Research Scholar, Department

### Comp 245 Data Structures. Stacks

Comp 245 Data Structures Stacks What is a Stack? A LIFO (last in, first out) structure Access (storage or retrieval) may only take place at the TOP NO random access to other elements within the stack An

### Chapter 13: Query Processing. Basic Steps in Query Processing

Chapter 13: Query Processing! Overview! Measures of Query Cost! Selection Operation! Sorting! Join Operation! Other Operations! Evaluation of Expressions 13.1 Basic Steps in Query Processing 1. Parsing

### 12 Abstract Data Types

12 Abstract Data Types 12.1 Source: Foundations of Computer Science Cengage Learning Objectives After studying this chapter, the student should be able to: Define the concept of an abstract data type (ADT).

### Sorting algorithm. Sorting algorithms used in computer science are often classified by:

Sorting algorithm In computer science and mathematics, a sorting algorithm is an algorithm that puts elements of a list in a certain order. The most used orders are numerical order and lexicographical

### Introduction to Programming (in C++) Sorting. Jordi Cortadella, Ricard Gavaldà, Fernando Orejas Dept. of Computer Science, UPC

Introduction to Programming (in C++) Sorting Jordi Cortadella, Ricard Gavaldà, Fernando Orejas Dept. of Computer Science, UPC Sorting Let elem be a type with a operation, which is a total order A vector

### Sample Questions Csci 1112 A. Bellaachia

Sample Questions Csci 1112 A. Bellaachia Important Series : o S( N) 1 2 N N i N(1 N) / 2 i 1 o Sum of squares: N 2 N( N 1)(2N 1) N i for large N i 1 6 o Sum of exponents: N k 1 k N i for large N and k

### 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

### External Sorting. Chapter 13. Database Management Systems 3ed, R. Ramakrishnan and J. Gehrke 1

External Sorting Chapter 13 Database Management Systems 3ed, R. Ramakrishnan and J. Gehrke 1 Why Sort? A classic problem in computer science! Data requested in sorted order e.g., find students in increasing

### Analysis of Computer Algorithms. Algorithm. Algorithm, Data Structure, Program

Analysis of Computer Algorithms Hiroaki Kobayashi Input Algorithm Output 12/13/02 Algorithm Theory 1 Algorithm, Data Structure, Program Algorithm Well-defined, a finite step-by-step computational procedure

### 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

### 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

### Biostatistics 615/815

Merge Sort Biostatistics 615/815 Lecture 8 Notes on Problem Set 2 Union Find algorithms Dynamic Programming Results were very ypositive! You should be gradually becoming g y g comfortable compiling, debugging

### Algorithms and Data Structures

Algorithm Analysis Page 1 BFH-TI: Softwareschule Schweiz Algorithm Analysis Dr. CAS SD01 Algorithm Analysis Page 2 Outline Course and Textbook Overview Analysis of Algorithm Pseudo-Code and Primitive Operations

### 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

### Data Structures. Topic #12

Data Structures Topic #12 Today s Agenda Sorting Algorithms insertion sort selection sort exchange sort shell sort radix sort As we learn about each sorting algorithm, we will discuss its efficiency Sorting

### Many algorithms, particularly divide and conquer algorithms, have time complexities which are naturally

Recurrence Relations Many algorithms, particularly divide and conquer algorithms, have time complexities which are naturally modeled by recurrence relations. A recurrence relation is an equation which

### Quiz 4 Solutions EECS 211: FUNDAMENTALS OF COMPUTER PROGRAMMING II. 1 Q u i z 4 S o l u t i o n s

Quiz 4 Solutions Q1: What value does function mystery return when called with a value of 4? int mystery ( int number ) { if ( number

### Unit 1. 5. Write iterative and recursive C functions to find the greatest common divisor of two integers. [6]

Unit 1 1. Write the following statements in C : [4] Print the address of a float variable P. Declare and initialize an array to four characters a,b,c,d. 2. Declare a pointer to a function f which accepts

### 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

### 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 7: Sequential Data Structures

Java by Definition Chapter 7: Sequential Data Structures Page 1 of 112 Chapter 7: Sequential Data Structures We have so far explored the basic features of the Java language, including an overview of objectoriented

### External Sorting. Why Sort? 2-Way Sort: Requires 3 Buffers. Chapter 13

External Sorting Chapter 13 Database Management Systems 3ed, R. Ramakrishnan and J. Gehrke 1 Why Sort? A classic problem in computer science! Data requested in sorted order e.g., find students in increasing

### 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

### 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

### 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)

### 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,

### Exam study sheet for CS2711. List of topics

Exam study sheet for CS2711 Here is the list of topics you need to know for the final exam. For each data structure listed below, make sure you can do the following: 1. Give an example of this data structure

### Chapter 7. Ch.7 Problem Solving and Algorithms

Chapter 7 Ch.7 Problem Solving and Algorithms QUIZ: Match the steps in Polya s method to the ones in the computer method for problem solving Devise a plan Look back Understand Carry out the plan Analysis

### To My Parents -Laxmi and Modaiah. To My Family Members. To My Friends. To IIT Bombay. To All Hard Workers

To My Parents -Laxmi and Modaiah To My Family Members To My Friends To IIT Bombay To All Hard Workers Copyright 2010 by CareerMonk.com All rights reserved. Designed by Narasimha Karumanchi Printed in

### THIS CHAPTER studies several important methods for sorting lists, both contiguous

Sorting 8 THIS CHAPTER studies several important methods for sorting lists, both contiguous lists and linked lists. At the same time, we shall develop further tools that help with the analysis of algorithms

### CS 102: SOLUTIONS TO DIVIDE AND CONQUER ALGORITHMS (ASSGN 4)

CS 10: SOLUTIONS TO DIVIDE AND CONQUER ALGORITHMS (ASSGN 4) Problem 1. a. Consider the modified binary search algorithm so that it splits the input not into two sets of almost-equal sizes, but into three

### 4.2 Sorting and Searching

Sequential Search: Java Implementation 4.2 Sorting and Searching Scan through array, looking for key. search hit: return array index search miss: return -1 public static int search(string key, String[]

### , 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

### 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

### Binary Search Trees. A Generic Tree. Binary Trees. Nodes in a binary search tree ( B-S-T) are of the form. P parent. Key. Satellite data L R

Binary Search Trees A Generic Tree Nodes in a binary search tree ( B-S-T) are of the form P parent Key A Satellite data L R B C D E F G H I J The B-S-T has a root node which is the only node whose parent

### 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

### EFFICIENT EXTERNAL SORTING ON FLASH MEMORY EMBEDDED DEVICES

ABSTRACT EFFICIENT EXTERNAL SORTING ON FLASH MEMORY EMBEDDED DEVICES Tyler Cossentine and Ramon Lawrence Department of Computer Science, University of British Columbia Okanagan Kelowna, BC, Canada tcossentine@gmail.com

### Heaps & Priority Queues in the C++ STL 2-3 Trees

Heaps & Priority Queues in the C++ STL 2-3 Trees CS 3 Data Structures and Algorithms Lecture Slides Friday, April 7, 2009 Glenn G. Chappell Department of Computer Science University of Alaska Fairbanks

### 5. A full binary tree with n leaves contains [A] n nodes. [B] log n 2 nodes. [C] 2n 1 nodes. [D] n 2 nodes.

1. The advantage of.. is that they solve the problem if sequential storage representation. But disadvantage in that is they are sequential lists. [A] Lists [B] Linked Lists [A] Trees [A] Queues 2. The

### Lecture 6: Binary Search Trees CSCI 700 - Algorithms I. Andrew Rosenberg

Lecture 6: Binary Search Trees CSCI 700 - Algorithms I Andrew Rosenberg Last Time Linear Time Sorting Counting Sort Radix Sort Bucket Sort Today Binary Search Trees Data Structures Data structure is a

### Data Structure and Algorithm I Midterm Examination 120 points Time: 9:10am-12:10pm (180 minutes), Friday, November 12, 2010

Data Structure and Algorithm I Midterm Examination 120 points Time: 9:10am-12:10pm (180 minutes), Friday, November 12, 2010 Problem 1. In each of the following question, please specify if the statement

### 6 March 2007 1. Array Implementation of Binary Trees

Heaps CSE 0 Winter 00 March 00 1 Array Implementation of Binary Trees Each node v is stored at index i defined as follows: If v is the root, i = 1 The left child of v is in position i The right child of

### 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 Algorithm Analysis (CSC317) Intro/Review of Data Structures Focus on dynamic sets

Data Structures and Algorithm Analysis (CSC317) Intro/Review of Data Structures Focus on dynamic sets We ve been talking a lot about efficiency in computing and run time. But thus far mostly ignoring data

### Krishna Institute of Engineering & Technology, Ghaziabad Department of Computer Application MCA-213 : DATA STRUCTURES USING C

Tutorial#1 Q 1:- Explain the terms data, elementary item, entity, primary key, domain, attribute and information? Also give examples in support of your answer? Q 2:- What is a Data Type? Differentiate

### For example, we have seen that a list may be searched more efficiently if it is sorted.

Sorting 1 Many computer applications involve sorting the items in a list into some specified order. For example, we have seen that a list may be searched more efficiently if it is sorted. To sort a group

### 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

### Data Structures. Level 6 C30151. www.fetac.ie. Module Descriptor

The Further Education and Training Awards Council (FETAC) was set up as a statutory body on 11 June 2001 by the Minister for Education and Science. Under the Qualifications (Education & Training) Act,

### Chapter Objectives. Chapter 9. Sequential Search. Search Algorithms. Search Algorithms. Binary Search

Chapter Objectives Chapter 9 Search Algorithms Data Structures Using C++ 1 Learn the various search algorithms Explore how to implement the sequential and binary search algorithms Discover how the sequential

### Recursive void Methods. Chapter 11. A recursive method is a method that includes a call to itself Recursion is based on the general problem.

Chapter 11 Recursion Recursive void Methods A recursive method is a method that includes a call to itself Recursion is based on the general problem solving technique of breaking down a task into subtasks