## Data Structures and Algorithms InDepth using Python

### What you’ll learn

Learn Data Structures, Abstract Data Types and their implementation in Python

Implementation of Searching Algorithms in Python

Implementation of Stacks, Queues, Linked List, Binary Trees, Heaps and Graphs in Python

Implementation of Binary Tree Traversal Techniques in Python

Graph traversals techniques ie Depth First Search and Breadth-First Search in Python

Implementation of Sorting Algorithms in Python

Enhance Analytical Skill and efficiently use searching and sorting algorithms in real applications

### Requirements

Prior knowledge of Programming any high level language

Basic knowledge of Python Programming

### Description

This course will help you in better understanding of the basics of Data Structures and how algorithms are implemented in high-level programming language. This course consists of lectures on data structures and algorithms which covers the computer science theory + implementation of data structures in python language. This course will also help students to face interviews at the top technology companies. This course is like having personal tutors to teach you about data structures and algorithms.There’s tons of concepts and content in this course. To begin the course:We have a discussion of why we need data structures.Then we move on to discuss Analysis of Algorithms ie Time and Space complexity, though the Asymptotic Notation ie Big O, Omega and Theta are taken up at the end of this course so that you do not get confused and concentrate on understanding the concepts of data structures. We have a programming environment setup to make sure you have all the software you need in order to get the hands-on experience in implementing Data structures and algorithms.Then we get to the essence of the course; algorithms and data structures. Each of the specific algorithms and data structures is divided into two sections. Theory lectures and implementation of those concepts in Python. We then move on to learn:RecursionStacks, Queues, DequesLinked ListTrees & Binary TreesBinary Search TreesPriority Queues and HeapsGraphs & Graph Traversal AlgorithmsSearching and Sorting algorithmsAgain, each of these sections includes theory lectures covering data structures & their Abstract Data Types and/or algorithms. Plus the implementation of these topics in Python.

### Overview

Section 1: Course Overview

Lecture 1 Course Introduction

Lecture 2 Get the most out of this course

Lecture 3 Why we need Data Structure ?

Lecture 4 Why Learn Algorithms ?

Lecture 5 Abstract Data Type (ADT)

Lecture 6 Python Installation on Windows

Lecture 7 PyCharm (IDE) Installation on Windows

Section 2: Bonus: Python Crash Course (Basics and Fundamentals)

Lecture 8 First Python Program, Data Types and Variables

Lecture 9 Integers & Float Data Types

Lecture 10 Strings Data Types

Lecture 11 Boolean & None Data Types

Lecture 12 Arithmetic Operators & Integer Division

Lecture 13 Relational or Comparison Operators

Lecture 14 Logical Operators

Lecture 15 input() Function

Lecture 16 print() Function

Lecture 17 if, if-else and elif Statements

Lecture 18 range() Function

Lecture 19 while() & for() Loops

Lecture 20 break & continue Statements

Lecture 21 What are Lists?

Lecture 22 Using Lists and List Indexing

Lecture 23 What are Tuples ?

Lecture 24 Tuple Indexing

Lecture 25 Membership & Identity Operators

Lecture 26 What are Dictionaries?

Lecture 27 Using Dictionaries

Lecture 28 What are Functions?

Lecture 29 Writing Functions in Python?

Lecture 30 Importing Modules in Python

Lecture 31 Creating Your Own Modules

Lecture 32 Fundamentals of Object Oriented Programming

Lecture 33 Defining Classes & Creating Objects

Lecture 34 More on __init__ Method (Constructor)

Lecture 35 Understanding self Parameter

Lecture 36 Static and Local Variables

Section 3: Analysis of Algorithms

Lecture 37 Time Complexity

Lecture 38 Order of Growth

Lecture 39 Asymptotic Analysis

Lecture 40 Big-Oh Notation

Lecture 41 Big Omega Notation

Lecture 42 Big Theta Notation

Lecture 43 Performance Summary

Lecture 44 Space Complexity

Section 4: Recursion and Analysis of Recursive Functions

Lecture 45 How Recursion Works ?

Lecture 46 Iteration vs recursion lets Implement

Lecture 47 Time Complexity of Recursion – Recurrence Relation

Lecture 48 Recurrence Relation – Another example

Lecture 49 Types of Recursion – Tail and Head Recursion

Lecture 50 Types of Recursion – Tree Recursion

Lecture 51 Types of Recursion – Indirect Recursion

Lecture 52 Sum of N Natural Numbers

Lecture 53 Lets Implement Sum of N Numbers

Lecture 54 Factorial

Lecture 55 Lets Implement Factorial

Section 5: Searching Algorithms

Lecture 56 Linear Search Algorithm

Lecture 57 Lets Implement Linear Search

Lecture 58 Binary Search Iterative Algorithm

Lecture 59 Lets Implement Binary Search using Iterations

Lecture 60 Binary Search Recursive Algorithm

Lecture 61 Lets Implement Binary Search using Recursion

Section 6: Sorting Algorithms

Lecture 62 Sorting Introduction

Lecture 63 Stable and Unstable Sorting

Lecture 64 Selection Sort – Explanation, Algorithm and Analysis

Lecture 65 Selection Sort – Implementation

Lecture 66 Insertion Sort – Explanation, Algorithm and Analysis

Lecture 67 Insertion Sort – Implementation

Lecture 68 Bubble Sort – Explanation, Algorithm and Analysis

Lecture 69 Bubble Sort – Implementation

Lecture 70 Shell Sort – Explanation, Algorithm and Analysis

Lecture 71 Shell Sort – Implementation

Lecture 72 Merge Sort

Lecture 73 Merge Sort – Algorithm

Lecture 74 Merging – Algorithm

Lecture 75 Merge Sort – Complexity Analysis

Lecture 76 Merge Sort – Implementation

Lecture 77 Quick Sort

Lecture 78 Quick Sort – Algorithm

Lecture 79 Quick Sort – Complexity Analysis

Lecture 80 Quick Sort – Implementation

Lecture 81 Count Sort – Explanation, Algorithm and Analysis

Lecture 82 Count Sort – Implementation

Lecture 83 Radix Sort – Explanation, Algorithm and Analysis

Lecture 84 Radix Sort – Implementation

Lecture 85 Python’s Built-in Sorting Functions

Lecture 86 Sorting Algorithms – Summary of Complexities

Section 7: Linked List

Lecture 87 Why do we use Linked List

Lecture 88 Creating Node of Linked List

Lecture 89 Playing with the links of Linked List

Lecture 90 How to Create Linked List

Lecture 91 Displaying or Traversing Linked List

Lecture 92 Lets Implement Creating and Displaying Linked List

Lecture 93 Searching Element in Linked List

Lecture 94 Lets Implement Search in Linked List

Lecture 95 Insert Element at the Beginning of Linked List

Lecture 96 Lets Implement Insert Element at the Beginning of Linked List

Lecture 97 Insert Element Anywhere in between the Linked List

Lecture 98 Lets Implement Insert Element Anywhere in Between the Linked List

Lecture 99 Delete Element at Beginning of Linked List

Lecture 100 Lets Implement Delete Element at Beginning of the Linked List

Lecture 101 Delete Element at End of Linked List

Lecture 102 Lets Implement Delete Element at End of Linked List

Lecture 103 Delete Element Anywhere in between Linked List

Lecture 104 Lets Implement Delete Element Anywhere in between Linked List

Lecture 105 Circular Linked List

Lecture 106 Creating Circular Linked List

Lecture 107 Traversing Circular Linked List

Lecture 108 Lets Implement Creating and Displaying Circular Linked List

Lecture 109 Insert Element at the Beginning of Circular Linked List

Lecture 110 Lets Implement Insert Element at the Beginning of Circular Linked List

Lecture 111 Insert Element Anywhere in between the Circular Linked List

Lecture 112 Lets Implement Insert Element Anywhere in between the Circular Linked List

Lecture 113 Delete Element at Beginning of Circular Linked List

Lecture 114 Lets Implement Delete Element at Beginning of Circular Linked List

Lecture 115 Delete Element at End of Circular Linked List

Lecture 116 Lets Implement Delete Element at End of Circular Linked List

Lecture 117 Delete Element Anywhere in between Circular Linked List

Lecture 118 Lets Implement Delete Element Anywhere in between Circular Linked List

Lecture 119 Double Linked List

Lecture 120 Creating Node of Doubly Linked List

Lecture 121 Playing with links of Doubly Linked List

Lecture 122 Creating Doubly Linked List

Lecture 123 Traversing Doubly Linked List

Lecture 124 Lets Implement Creating and Displaying Doubly Linked List

Lecture 125 Insert Element at the Beginning of Doubly Linked List

Lecture 126 Lets Implement Insert Element at the Beginning of Doubly Linked List

Lecture 127 Insert Element Anywhere in between the Doubly Linked List

Lecture 128 Lets Implement Insert Element Anywhere in between the Doubly Linked List

Lecture 129 Delete Element at Beginning of Doubly Linked List

Lecture 130 Lets Implement Delete Element at Beginning of Doubly Linked List

Lecture 131 Delete Element at End of Doubly Linked List

Lecture 132 Lets Implement Delete Element at End of Doubly Linked List

Lecture 133 Delete Element Anywhere in between Doubly Linked List

Lecture 134 Lets Implement Delete Element Anywhere in between Doubly Linked List

Section 8: Stacks

Lecture 135 What is Stack Data Structure ?

Lecture 136 Stacks using Arrays

Lecture 137 Lets Implement Stacks using Arrays

Lecture 138 Stacks using Linked List

Lecture 139 Lets Implement Stacks using Linked List

Section 9: Queues and DEque

Lecture 140 What is Queue Data Structure ?

Lecture 141 Queues using Arrays

Lecture 142 Lets Implement Queues using Arrays

Lecture 143 Queues using Linked List

Lecture 144 Lets Implement Queues using Linked List

Lecture 145 What are Double Ended Queues (DEQue) ?

Lecture 146 Lets Implement Double Ended Queues using Arrays

Lecture 147 Lets Implement Double Ended Queues using Linked List

Section 10: Binary Trees

Lecture 148 Trees Definition and Properties

Lecture 149 Trees – Terminology

Lecture 150 Trees – Height and Levels

Lecture 151 Degree of Node and Tree

Lecture 152 Binary Trees and it’s Properties

Lecture 153 Proper Binary Tree

Lecture 154 Full Binary Tree

Lecture 155 Complete Binary Tree

Lecture 156 Full Vs Complete Vs Proper Binary Tree

Lecture 157 Binary Tree Representation – Array Based

Lecture 158 Binary Tree Representation – Linked Based

Lecture 159 Traversing Binary Trees

Lecture 160 Binary Trees Traversal – Preorder

Lecture 161 Binary Trees Traversal – Inorder

Lecture 162 Binary Trees Traversal – Postorder

Lecture 163 Binary Trees Traversal – Level Order

Lecture 164 Easy way of remembering Binary Trees Traversals

Lecture 165 Creating Binary Trees

Lecture 166 Function for Preorder Traversal

Lecture 167 Function for Inorder Traversal

Lecture 168 Function for Postorder Traversal

Lecture 169 Lets Implement Creating Binary Trees

Lecture 170 Lets Implement Traversing Binary Trees

Lecture 171 Lets Create Binary Trees

Lecture 172 Lets Create Binary Trees – Another Example

Lecture 173 Function for Level Order Traversal

Lecture 174 Lets Implement Level Order Traversal

Lecture 175 Count Number of Nodes in Binary Tree

Lecture 176 Lets Implement Count Operations of Binary Tree

Lecture 177 Find Height of Binary Tree

Lecture 178 Lets Implement Height Operations of Binary Tree

Section 11: Binary Search Trees

Lecture 179 What are Binary Search Trees ?

Lecture 180 Binary Search Trees – Searching (Concept)

Lecture 181 Binary Search Trees – Iterative Search Function

Lecture 182 Binary Search Trees – Recursive Search Function

Lecture 183 Binary Search Trees – Insertion (Concept)

Lecture 184 Binary Search Trees – Iterative Insert Function

Lecture 185 Binary Search Trees – Recursive Insert Function

Lecture 186 Traversing Binary Search Tree

Lecture 187 Lets Implement Binary Search Tree – Insertion

Lecture 188 Lets Implement Recursive Insertion

Lecture 189 Lets Implement Iterative Search

Lecture 190 Lets Implement Recursive Search

Lecture 191 Binary Search Tree – Deletion

Lecture 192 Binary Search Tree – Deletion Case-Leaf Node

Lecture 193 Binary Search Tree – Deletion Case-Node with One Subtree

Lecture 194 Binary Search Tree – Deletion Case-Node with Both Subtrees

Lecture 195 Lets Implement Deletion in Binary Search Tree

Lecture 196 Performance and Problem of Binary Search Trees

Section 12: Balanced Search Trees

Lecture 197 Balanced Search Trees

Lecture 198 AVL Trees

Lecture 199 AVL Tree Rotations for Insertion

Lecture 200 AVL Tree – LL Rotation

Lecture 201 AVL Tree – RR Rotation

Lecture 202 AVL Tree – LR Rotation

Lecture 203 AVL Tree – RL Rotation

Lecture 204 AVL Tree Rotations after Deletion

Lecture 205 Performance Analysis of AVL Trees

Lecture 206 Red-Black Trees

Lecture 207 Red-Black Trees – Restructuring

Lecture 208 Red-Black Trees – Insertion

Lecture 209 Red-Black Trees – Deletion

Lecture 210 Performance Analysis of Red-Black Trees

Lecture 211 Splay Trees

Lecture 212 Splay Trees – Zig-Zig Restructuring

Lecture 213 Splay Trees – Zig-Zag Restructuring

Lecture 214 Splay Trees – Zig Restructuring

Lecture 215 Splay Trees – Splaying

Lecture 216 Performance Analysis of Splay Trees

Section 13: Priority Queues & Heaps

Lecture 217 What are Priority Queues ?

Lecture 218 Heaps Data Structure

Lecture 219 Heaps – Insertion

Lecture 220 Heaps – Insert Function

Lecture 221 Lets Implement Creating Heaps using Insert function

Lecture 222 Heaps – Deletion

Lecture 223 Heaps – Delete Function

Lecture 224 Lets Implement Deletion from Heaps

Lecture 225 heapq Module in Python

Lecture 226 Heap Sort – Explanation, Algorithm and Analysis

Lecture 227 Lets Implement Heap Sort

Section 14: Hashing

Lecture 228 What is Hashing

Lecture 229 Chaining – Collision Detection Scheme

Lecture 230 Let us Implement Chaining

Lecture 231 Linear Probing

Lecture 232 Let us Implement Linear Probing

Lecture 233 Quadratic Probing

Lecture 234 Double Hashing

Lecture 235 Bucket Sort – Explanation, Algorithm and Analysis

Lecture 236 Lets Implement Bucket Sort

Section 15: Graphs

Lecture 237 Graphs – Introduction

Lecture 238 Graphs – Degree of a Vertex

Lecture 239 Graphs – Path and Cycle

Lecture 240 Graphs – Subgraphs and Connected Components

Lecture 241 Graph Abstract Data Type (ADT)

Lecture 242 Graphs Representations

Lecture 243 Graphs – Edge List Representation

Lecture 244 Graphs – Adjacency List Representation

Lecture 245 Graphs – Adjacency Matrix Representation

Lecture 246 Graphs Representation – Summary of Performance

Lecture 247 Lets Implement Graphs ADT

Lecture 248 Lets Implement Undirected Graph

Lecture 249 Lets Implement Weighted Undirected Graph

Lecture 250 Lets Implement Directed Graph

Lecture 251 Lets Implement Weighted Directed Graph

Lecture 252 Graph Traversals

Lecture 253 Breadth First Search

Lecture 254 Breadth First Search Algorithm

Lecture 255 Lets Implement Breadth First Search

Lecture 256 Depth First Search

Lecture 257 Depth First Search Algorithm

Lecture 258 Lets Implement Depth First Search

Section 16: Appendix

Lecture 259 How to install Numpy Python module in PyCharm on Windows

Lecture 260 Getting Certificate of Completion

Students who want to have better understanding of Data Structures,Python programmers curious about Data Structures,IT Professional experimenting implementation of Data Structures in Python

#### Course Information:

Udemy | English | 34h 37m | 7.15 GB

Created by: Syed Mohiuddin

You Can See More Courses in the Developer >> Greetings from CourseDown.com