×

Close

Type:
**Note**Institute:
**
Jawaharlal nehru technological university anantapur college of engineering
**Specialization:
**Computer Science Engineering**Offline Downloads:
**353**Views:
**7272**Uploaded:
**10 months ago**

Touch here to read

Page-1

- Contents - ( 2 - 3 )
- Basic Concepts of DAA - ( 4 - 15 )
- Advanced Data Structures and Recurrence Relations - ( 16 - 55 )
- Divide and Conquer - ( 56 - 74 )
- Greedy Method - ( 75 - 101 )
- Dynamic Programming - ( 102 - 132 )
- Basic Traversal and Search Techniques - ( 133 - 163 )
- Backtracking - ( 164 - 176 )
- Branch and Bound - ( 177 - 200 )

Topic:

LECTURE NOTES ON
DESIGN AND ANALYSIS OF ALGORITHMS
Department of Computer Science and Engineering

CONTENTS
CHAPTER 1 BASIC CONCEPTS
Algorithm
Performance of Programs
Algorithm Design Goals
Classification of Algorithms
Complexity of Algorithms
Rate of Growth
Analyzing Algorithms
The Rule of Sums
The Rule of products
The Running time of Programs
Measuring the running time of programs
Asymptotic Analyzing of Algorithms
Calculating the running time of programs
General rules for the analysis of programs
CHAPTER 2 Advanced Data Structures and Recurrence Relations
Priority Queue, Heap and Heap sort
Heap Sort
2.3
Priority Queue implementation using heap tree
Binary Search trees
Balanced Trees
Dictionary
Disjoint Set Operations
Recurrence Relations – Iterative Substitution Method
Recursion Tree
The Guess-and test
The Master Theorem Method
Cold Form expression
Solving Recurrence relations
CHAPTER 3 Divide And Conquer
General Method
Control Abstraction of Divide and Conquer
Binary Search
External and Internal path length
Merge Sort
Strassen’s Matrix Multiplication
Quick Sort
Straight Insertion Sort
CHAPTER 4 Greedy Method
4.1
General Method
Control Abstraction
Knapsack Problem
Optimal Storage on Tapes
Job Sequencing with deadlines
Optimal Merge Patterns
Huffman Codes
I

Graph Algorithms
CHAPTER 5 Dynamic programming
Multi Storage graphs
All Pairs Shortest paths
Traveling Sales Person problem
Optimal Binary Search Tree
0/1 Knapsack
Reliability design
CHAPTER 6 Basic Traversal and Search Techniques
Techniques for traversal of Binary tree
Techniques for graphs
Representation of Graph and Digraphs
Depth First and Breadth First Spanning trees
Articulation Points and bi-connected components
Articulation points by Depth First Search
Game planning
Alpha-Beta pruning
AND/OR Graphs
CHAPTER 7 Backtracking
General method
Terminology
N-Queens problem
Sum of Subsets
Graph Coloring( for planar graphs)
Hamiltonian Cycles
0/1 Knapsack
Traveling Sales Person using Backtracking
CHAPTER 8 Branch and Bound
General method
Least Cost (LC) Search
Control Abstraction for LC-Search
Bounding
The 15-Puzzle problem
LC Search for 15-Puzzle Problem
Job Sequencing with deadlines
Traveling Sales Person problem
0/1 Knapsack
II

Chapter
1
Basic Concepts
Algorithm
An Algorithm is a finite sequence of instructions, each of which has a clear meaning
and can be performed with a finite amount of effort in a finite length of time. No
matter what the input values may be, an algorithm terminates after executing a finite
number of instructions. In addition every algorithm must satisfy the following
criteria:
Input: there are zero or more quantities, which are externally supplied;
Output: at least one quantity is produced;
Definiteness: each instruction must be clear and unambiguous;
Finiteness: if we trace out the instructions of an algorithm, then for all cases
the algorithm will terminate after a finite number of steps;
Effectiveness: every instruction must be sufficiently basic that it can in
principle be carried out by a person using only pencil and paper. It is not
enough that each operation be definite, but it must also be feasible.
In formal computer science, one distinguishes between an algorithm, and a program.
A program does not necessarily satisfy the fourth condition. One important example
of such a program for a computer is its operating system, which never terminates
(except for system crashes) but continues in a wait loop until more jobs are entered.
We represent algorithm using a pseudo language that is a combination of the
constructs of a programming language together with informal English statements.
Performance of a program:
The performance of a program is the amount of computer memory and time needed
to run a program. We use two approaches to determine the performance of a
program. One is analytical, and the other experimental. In performance analysis we
use analytical methods, while in performance measurement we conduct experiments.
Time Complexity:
The time needed by an algorithm expressed as a function of the size of a problem is
called the time complexity of the algorithm. The time complexity of a program is the
amount of computer time it needs to run to completion.
The limiting behavior of the complexity as size increases is called the asymptotic time
complexity. It is the asymptotic complexity of an algorithm, which ultimately
determines the size of problems that can be solved by the algorithm.
1

## Leave your Comments