Book Details : | |
---|---|

Language | English |

Pages | 828 |

Format | |

Size | 32.7 MB |

Data Structures and Algorithms Made Easy 5th Edition Data Structures and Algorithms Puzzles by Narasimha Karumanchi | PDF Free Download.

Introduction

- Variables
- Data Types
- Data Structures
- Abstract Data Types (ADTs)
- What is an Algorithm?
- Why the Analysis of Algorithms?
- The goal of the Analysis of Algorithms
- What is Running Time Analysis?
- How to Compare Algorithms
- What is the Rate of Growth?
- Commonly Used Rates of Growth
- Types of Analysis
- Asymptotic Notation
- Big-O Notation [Upper Bounding Function]
- Omega-Q Notation [Lower Bounding Function]
- Theta-Θ Notation [Order Function]
- Important Notes
- Why is it called Asymptotic Analysis?
- Guidelines for Asymptotic Analysis
- Simplyfying properties of asymptotic notations
- Commonly used Logarithms and Summations
- Master Theorem for Divide and Conquer Recurrences
- Divide and Conquer Master Theorem: Problems & Solutions
- Master Theorem for Subtract and Conquer Recurrences
- Variant of Subtraction and Conquer Master Theorem
- Method of Guessing and Confirming
- Amortized Analysis
- Algorithms Analysis: Problems & Solutions

Recursion and Backtracking

- Introduction
- What is Recursion?
- Why Recursion?
- Format of a Recursive Function
- Recursion and Memory (Visualization)
- Recursion versus Iteration
- Notes on Recursion
- Example Algorithms of Recursion
- Recursion: Problems & Solutions
- What is Backtracking?
- Example Algorithms of Backtracking
- Backtracking: Problems & Solutions

Linked Lists

- What is a Linked List?
- Linked Lists ADT
- Why Linked Lists?
- Arrays Overview
- Comparison of Linked Lists with Arrays & Dynamic Arrays
- Singly Linked Lists
- Doubly Linked Lists
- Circular Linked Lists
- A Memory-efficient Doubly Linked List
- Unrolled Linked Lists
- Skip Lists
- Linked Lists: Problems & Solutions

Stacks

- What is a Stack?
- How Stacks are used
- Stack ADT
- Applications
- Implementation
- Comparison of Implementations
- Stacks: Problems & Solutions

Queues

- What is a Queue?
- How are Queues Used?
- Queue ADT
- Exceptions
- Applications
- Implementation
- Queues: Problems & Solutions

Trees

- What is a Tree?
- Glossary
- Binary Trees
- Types of Binary Trees
- Properties of Binary Trees
- Binary Tree Traversals
- Generic Trees (N-ary Trees)
- Threaded Binary Tree Traversals (Stack or Queue-less Traversals)
- Expression Trees
- XOR Trees
- Binary Search Trees (BSTs)
- Balanced Binary Search Trees
- AVL(Adelson-Velskii and Landis) Trees
- Other Variations on Trees

Priority Queues and Heaps

- What is a Priority Queue?
- Priority Queue ADT
- Priority Queue Applications
- Priority Queue Implementations
- Heaps and Binary Heaps
- Binary Heaps
- Heapsort
- Priority Queues [Heaps]: Problems & Solutions

Disjoint Sets ADT

- Introduction
- Equivalence Relations and Equivalence Classes
- Disjoint Sets ADT
- Applications
- Tradeoffs in Implementing Disjoint Sets ADT
- Fast UNION Implementation (Slow FIND)
- Fast UNION Implementations (Quick FIND)
- Summary
- Disjoint Sets: Problems & Solutions

Graph Algorithms

- Introduction
- Glossary
- Applications of Graphs
- Graph Representation
- 9.5 Graph Traversals
- Topological Sort
- Shortest Path Algorithms
- Minimal Spanning Tree
- Graph Algorithms: Problems & Solutions

Sorting

- What is Sorting?
- Why is Sorting Necessary?
- Classification of Sorting Algorithms
- Other Classifications
- Bubble Sort
- Selection Sort
- Insertion Sort
- Shell Sort
- Merge Sort
- Heap Sort
- Quick Sort
- Tree Sort
- Comparison of Sorting Algorithms
- Linear Sorting Algorithms
- Counting Sort
- Bucket Sort (or Bin Sort)
- Radix Sort
- Topological Sort
- External Sorting
- Sorting: Problems & Solutions

Searching

- What is Searching?
- Why do we need Searching?
- Types of Searching
- Unordered Linear Search
- Sorted/Ordered Linear Search
- Binary Search
- Interpolation Search
- Comparing Basic Searching Algorithms
- Symbol Tables and Hashing
- String Searching Algorithms
- Searching: Problems & Solutions

Selection Algorithms [Medians]

- What is Selection Algorithms?
- Selection by Sorting
- Partition-based Selection Algorithm
- Linear Selection Algorithm - Median of Medians Algorithm
- Finding the K Smallest Elements in Sorted Order
- Selection Algorithms: Problems & Solutions

Symbol Tables

- Introduction
- What are Symbol Tables?
- Symbol Table Implementations
- Comparison Table of Symbols for Implementations
- Hashing
- What is Hashing?
- Why Hashing?
- HashTable ADT
- Understanding Hashing
- Components of Hashing
- Hash Table
- Hash Function
- Load Factor
- Collisions
- Collision Resolution Techniques
- Separate Chaining
- Open Addressing
- Comparison of Collision Resolution Techniques
- 1How Hashing Gets O(1) Complexity?
- Hashing Techniques
- Problems for which Hash Tables are not suitable
- Bloom Filters
- Hashing: Problems & Solutions

String Algorithms

- Introduction
- String Matching Algorithms
- Brute Force Method
- Rabin-Karp String Matching Algorithm
- String Matching with Finite Automata
- KMP Algorithm
- Boyer-Moore Algorithm
- Data Structures for Storing Strings
- Hash Tables for Strings
- Binary Search Trees for Strings
- Tries
- Ternary Search Trees
- Comparing BSTs, Tries and TSTs
- Suffix Trees
- String Algorithms: Problems & Solutions
- Algorithms Design Techniques
- Introduction
- Classification
- Classification by Implementation Method
- Classification by Design Method
- Other Classifications

Greedy Algorithms

- Introduction
- Greedy Strategy
- Elements of Greedy Algorithms
- Does Greedy Always Work?
- Advantages and Disadvantages of Greedy Method
- Greedy Applications
- Understanding Greedy Technique
- Greedy Algorithms: Problems & Solutions

Divide and Conquer Algorithms

- Introduction
- What is the Divide and Conquer Strategy?
- Does Divide and Conquer Always Work?
- Divide and Conquer Visualization
- Understanding Divide and Conquer
- Advantages of Divide and Conquer
- Disadvantages of Divide and Conquer
- Master Theorem
- Divide and Conquer Applications
- Divide and Conquer: Problems & Solutions

Dynamic Programming

- Introduction
- What is Dynamic Programming Strategy?
- Properties of Dynamic Programming Strategy
- Can Dynamic Programming Solve All Problems?
- Dynamic Programming Approaches
- Examples of Dynamic Programming Algorithms
- Understanding Dynamic Programming
- Longest Common Subsequence
- Dynamic Programming: Problems & Solutions

Complexity Classes

- Introduction
- Polynomial/Exponential Time
- What is a Decision Problem?
- Decision Procedure
- What is a Complexity Class?
- Types of Complexity Classes
- Reductions
- Complexity Classes: Problems & Solutions

Miscellaneous Concepts

- Introduction
- Hacks on Bit-wise Programming
- Other Programming Questions

Dear Reader,

Please hold on! I know many people typically do not read the Preface of a book. But I strongly recommend that you read this particular Preface. It is not the main objective of this book to present you with the theorems and proofs on data structures and algorithms.

I have followed a pattern of improving the problem solutions with different complexities (for each problem, you will find multiple solutions with different, and reduced, complexities).

Basically, it’s an enumeration of possible solutions. With this approach, even if you get a new question, it will show you a way to think about the possible solutions. You will find this book useful for interview preparation, competitive exams preparation, and campus interview preparations.

As a job seeker, if you read the complete book, I am sure you will be able to challenge the interviewers.

If you read it as an instructor, it will help you to deliver lectures with an approach that is easy to follow, and as a result, your students will appreciate the fact that they have opted for Computer Science / Information Technology as their degree.

This book is also useful for Engineering degree students and Masters's degree students during their academic preparations. In all the chapters you will see that there is more emphasis on problems and their analysis rather than on theory.

In each chapter, you will first read about the basic required theory, which is then followed by a section on problem sets.

In total, there are approximately 700 algorithmic problems, all with solutions. If you read the book as a student preparing for competitive exams for Computer Science / Information Technology, the content covers all the required topics in full detail.

While writing this book, my main focus was to help students who are preparing for these exams. In all the chapters you will see more emphasis on problems and analysis rather than on theory.

In each chapter, you will first see the basic required theory followed by various problems. For many problems, multiple solutions are provided with different levels of complexity.

We start with the brute force solution and slowly move toward the best solution possible for that problem.

For each problem, we endeavor to understand how much time the algorithm takes and how much memory the algorithm uses.

**Download Data Structures and Algorithms Made Easy 5th Edition by Karumanchi in PDF Format For Free.**