Course Details

Free Courses

Data Structure

4.0

Description

This course will help you in better understanding the basics of Data Structures and how algorithms are implemented in a high-level programming language. This course consists of lectures on data structures and algorithms which cover 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 teach you about data structures and algorithms.

There are 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 set up to make sure you have all the software you need in order to get 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:

Recursion
Stacks, Queues, Deques
Linked List
Trees & Binary Trees
Binary Search Trees
Priority Queues and Heaps
Graphs & Graph Traversal Algorithms
Searching and Sorting algorithms

Again, 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.

What You Will Learn

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

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

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

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

Implementation of Searching Algorithms in Python

Implementation of Binary Tree Traversal Techniques in Python

Implementation of Sorting Algorithms in Python

Requirements

Course Curriculum

Course Overview

Course Introduction
Get the most out of this course
Why We Need Data Structure?
Why Learn Algorithms?
Abstract Data Type (ADT)
Python Installation on Windows
PyCharm (IDE) Installation on Windows

Analysis of Algorithms

Time Complexity
Order of Growth
Asymptotic Analysis
Big-Oh Notation
Big Omega Notation
Big Theta Notation
Performance Summary
Space Complexity

Recursion and Analysis of Recursive Functions

How Recursion Works ?
Iteration vs recursion lets Implement
Time Complexity of Recursion - Recurrence Relation
Recurrence Relation - Another example
Types of Recursion - Tail and Head Recursion
Types of Recursion - Tree Recursion
Types of Recursion - Indirect Recursion
Sum of N Natural Numbers
Lets Implement Sum of N Numbers
Factorial
Lets Implement Factorial

Searching Algorithms

Linear Search Algorithm
Lets Implement Linear Search
Binary Search Iterative Algorithm
Lets Implement Binary Search using Iterations
Binary Search Recursive Algorithm
Lets Implement Binary Search using Recursion

Sorting Algorithms

Sorting Introduction
Stable and Unstable Sorting
Selection Sort - Explanation, Algorithm and Analysis
Selection Sort - Implementation
Insertion Sort - Explanation, Algorithm and Analysis
Insertion Sort - Implementation
Bubble Sort - Explanation, Algorithm and Analysis
Bubble Sort - Implementation
Shell Sort - Explanation, Algorithm and Analysis
Shell Sort - Implementation
Merge Sort
Merge Sort - Algorithm
Merging - Algorithm
Merge Sort - Complexity Analysis
Merge Sort - Implementation
Quick Sort
Quick Sort - Algorithm
Quick Sort - Complexity Analysis
Quick Sort - Implementation
Count Sort - Explanation, Algorithm and Analysis
Count Sort - Implementation
Radix Sort - Explanation, Algorithm and Analysis
Radix Sort - Implementation
Python's Built-in Sorting Functions
Sorting Algorithms - Summary of Complexities

Linked List

Why Do We Use Linked List?
Creating Node of Linked List
Playing with the links of Linked List
How to Create Linked List
Displaying or Traversing Linked List
Lets Implement Creating and Displaying Linked List
Searching Element in Linked List
Lets Implement Search in Linked List
Insert Element at the Beginning of Linked List
Lets Implement Insert Element at the Beginning of Linked List
Insert Element Anywhere in between the Linked List
Lets Implement Insert Element Anywhere in Between the Linked List
Delete Element at Beginning of Linked List
Lets Implement Delete Element at Beginning of the Linked List
Delete Element at End of Linked List
Lets Implement Delete Element at End of Linked List
Delete Element Anywhere in between Linked List
Lets Implement Delete Element Anywhere in between Linked List
Circular Linked List
Creating Circular Linked List
Traversing Circular Linked List
Lets Implement Creating and Displaying Circular Linked List
Insert Element at the Beginning of Circular Linked List
Lets Implement Insert Element at the Beginning of Circular Linked List
Insert Element Anywhere in between the Circular Linked List
Lets Implement Insert Element Anywhere in between the Circular Linked List
Delete Element at Beginning of Circular Linked List
Lets Implement Delete Element at Beginning of Circular Linked List
Delete Element at End of Circular Linked List
Lets Implement Delete Element at End of Circular Linked List
Delete Element Anywhere in between Circular Linked List
Lets Implement Delete Element Anywhere in between Circular Linked List
Double Linked List
Creating Node of Doubly Linked List
Playing with links of Doubly Linked List
Creating Doubly Linked List
Traversing Doubly Linked List
Lets Implement Creating and Displaying Doubly Linked List
Insert Element at the Beginning of Doubly Linked List
Lets Implement Insert Element at the Beginning of Doubly Linked List
Insert Element Anywhere in between the Doubly Linked List
Lets Implement Insert Element Anywhere in between the Doubly Linked List
Delete Element at Beginning of Doubly Linked List
Lets Implement Delete Element at Beginning of Doubly Linked List
Delete Element at End of Doubly Linked List
Lets Implement Delete Element at End of Doubly Linked List
Delete Element Anywhere in between Doubly Linked List
Lets Implement Delete Element Anywhere in between Doubly Linked List

Stacks

What is Stack Data Structure?
Stacks using Arrays
Lets Implement Stacks using Arrays
Stacks using Linked List
Lets Implement Stacks using Linked List

Queues Deque

What is Queue Data Structure ?
Queues using Arrays
Lets Implement Queues using Arrays
Queues using Linked List
Lets Implement Queues using Linked List
What are Double Ended Queues (DEQue) ?
Lets Implement Double Ended Queues using Arrays
Lets Implement Double Ended Queues using Linked List

Binary Tree

Trees Definition and Properties
Trees - Terminology
Trees - Height and Levels
Degree of Node and Tree
Binary Trees and it's Properties
Proper Binary Tree
Full Binary Tree
Complete Binary Tree
Full Vs Complete Vs Proper Binary Tree
Binary Tree Representation - Array Based
Binary Tree Representation - Linked Based
Traversing Binary Trees
Binary Trees Traversal - Preorder
Binary Trees Traversal - Inorder
Binary Trees Traversal - Postorder
Binary Trees Traversal - Level Order
Easy way of remembering Binary Trees Traversals
Creating Binary Trees
Function for Preorder Traversal
Function for Inorder Traversal
Function for Postorder Traversal
Lets Implement Creating Binary Trees
Lets Implement Traversing Binary Trees
Lets Create Binary Trees
Lets Create Binary Trees - Another Example
Function for Level Order Traversal
Lets Implement Level Order Traversal
Count Number of Nodes in Binary Tree
Lets Implement Count Operations of Binary Tree
Find Height of Binary Tree
Lets Implement Height Operations of Binary Tree

Binary Search Trees

What are Binary Search Trees ?
Binary Search Trees - Searching (Concept)
Binary Search Trees - Iterative Search Function
Binary Search Trees - Recursive Search Function
Binary Search Trees - Insertion (Concept)
Binary Search Trees - Iterative Insert Function
Binary Search Trees - Recursive Insert Function
Traversing Binary Search Tree
Lets Implement Binary Search Tree - Insertion
Lets Implement Recursive Insertion
Lets Implement Iterative Search
Lets Implement Recursive Search
Binary Search Tree - Deletion
Binary Search Tree - Deletion Case-Leaf Node
Binary Search Tree - Deletion Case-Node with One Subtree
Binary Search Tree - Deletion Case-Node with Both Subtrees
Lets Implement Deletion in Binary Search Tree
Performance and Problem of Binary Search Trees

Balanced Search Trees

Balanced Search Trees
AVL Trees
AVL Tree Rotations for Insertion
AVL Tree - LL Rotation
AVL Tree - RR Rotation
AVL Tree - LR Rotation
AVL Tree - RL Rotation
AVL Tree Rotations after Deletion
Performance Analysis of AVL Trees
Red-Black Trees
Red-Black Trees - Restructuring
Red-Black Trees - Insertion
Red-Black Trees - Deletion
Performance Analysis of Red-Black Trees
Splay Trees
Splay Trees - Zig-Zig Restructuring
Splay Trees - Zig-Zag Restructuring
Splay Trees - Zig Restructuring
Splay Trees - Splaying
Performance Analysis of Splay Trees

Priority Queues Heaps

What are Priority Queues ?
Heaps Data Structure
Heaps - Insertion
Heaps - Insert Function
Lets Implement Creating Heaps using Insert function
Heaps - Deletion
Heaps - Delete Function
Lets Implement Deletion from Heaps
heapq Module in Python
Heap Sort - Explanation, Algorithm and Analysis
Lets Implement Heap Sort

Hashing

What is Hashing
Chaining - Collision Detection Scheme
Let us Implement Chaining
Linear Probing
Let us Implement Linear Probing
Quadratic Probing
Double Hashing
Bucket Sort - Explanation, Algorithm and Analysis
Lets Implement Bucket Sort

Graphs

Graphs - Introduction
Graphs - Degree of a Vertex
Graphs - Path and Cycle
Graphs - Subgraphs and Connected Components
Graph Abstract Data Type (ADT)
Graphs Representations
Graphs - Edge List Representation
Graphs - Adjacency List Representation
Graphs - Adjacency Matrix Representation
Graphs Representation - Summary of Performance
Lets Implement Graphs ADT
Lets Implement Undirected Graph
Lets Implement Weighted Undirected Graph
Lets Implement Directed Graph
Lets Implement Weighted Directed Graph
Graph Traversals
Breadth First Search
Breadth First Search Algorithm
Lets Implement Breadth First Search
Depth First Search
Depth First Search Algorithm
Lets Implement Depth First Search

Appendix

How to install Numpy Python module in PyCharm on Windows
Getting Certificate of Completion

Free Free Courses

Popular Courses