Hands-On Data Structures

Hands-On Data Structures, available at $19.99, has an average rating of 4.25, with 162 lectures, based on 18 reviews, and has 8898 subscribers.

You will learn about Data Structures programming, This course is ideal for individuals who are fresh students, C programmers It is particularly useful for fresh students, C programmers.

Enroll now: Hands-On Data Structures

Summary

Title: Hands-On Data Structures

Price: $19.99

Average Rating: 4.25

Number of Lectures: 162

Number of Published Lectures: 162

Number of Curriculum Items: 162

Number of Published Curriculum Objects: 162

Original Price: ?799

Quality Status: approved

Status: Live

What You Will Learn

Data Structures programming,

Who Should Attend

fresh students, C programmers

Target Audiences

fresh students, C programmers

A data structure is a collection of data values, the relationships among them, and the functions or operations that can be applied to the data. Different types of data structures are suited to different kinds of applications, and some are highly specialized to specific task. Data structures provide a means to manage large amounts of data efficiently. Efficient data structures are key to designing efficient algorithms.  Data structures can be used to organize the storage and retrieval of information stored in both main memory and secondary memory.

Data structures serve as the basis for ADT. The ADT  (Abstract Data Types) defines the logical form of the data type. Data structures are based on the ability of a computer to fetch and store data at any place in its memory, specified by a pointer. 

The array and record data structures are based on computing the addresses of data items with arithmetic operations. The linked data structures are based on storing addresses of data items within the structure itself. The implementation of a data structure usually requires writing a set of procedures that create and manipulate instances of that structure.

A linked list is a linear collection of data elements whose order is not given by their physical placement in memory. Each element points to the next. It is a data structure consisting of a collection of nodes which together represent a sequence. Each node contains: data, and a  link to the next node in the sequence. This structure allows for efficient insertion or removal of elements from any position in the sequence during iteration.

Following topics are covered as part of hands-on / Live coding videos :

Linked Lists (LL) Implementation / Coding:

Concept of link

Creating a Linked List (LL)

Appending a node to LL

Display of LL

Length of LL (count)

Reversing of LL

Sorting

Adding node at Start of LL

Inserting node in between of LL

Deleting a node

Creating a Double LL

Appending a node to Double LL

Display of Double LL

Length of Double LL (count)

Reversing of Double LL

Inserting a node in between a Double LL

Rotate Double LL

Count Pairs with criteria for a Double LL

Questions

Circular LL overview (access pointers)

Creating a Circular LL

Adding node at Start Circular LL (approach 1)

Traversal / Display Circular LL (approach 1)

Inserting node in between a Circular LL (approach 1)

Deleting a node

Adding node at End Circular LL (approach 2)

Traversal / Display Circular LL (approach 2)

Circular LL – Queue (Adding Node)

Circular LL – Queue (Removing Node)

Questions

Stacks (Implementation / Coding):

Stack overview

Stack with Array

Expressions

Evaluation of Postfix expression

Infix to Post fix

Evaluation of Prefix overview. infix to prefix overview

Application: Finding next big element

Stack using Linked List

Reversing Stack with Linked List

Questions

Queues (Implementation / Coding) :

Queue Overview

Queue using Array

Priority Queue with Array

Queue using Linked List

Priority Queue using Double Linked List

Questions

Recursion

Recursion Overview, Phases, Types

Recursive Functions

Linked List operations using Recursion

Questions

Trees

Binary Trees

Tree Traversals

Inorder

preorder

postorder

Binary Search Trees (BST)

BST – Insertion

BST – Insertion & Traversals

Traversals Explained

BST – Search

Search operations

BST Deletion

Deletion cases

Binary Tree to BST conversion

Identify a Tree to be BST

Identify zero, one child nodes of BST

Questions

Sorting

Selection Sort

Selection Sort Analysis

Bubble Sort

Bubble Sort Analysis

Insertion Sort

Insertion Sort Analysis

Quick Sort

Quick Sort Analysis

Quick Sort, Merge Sort Discussion

Questions

Threaded Binary Trees

Need for Threaded Binary Tree (TBT)

Threaded Binary Tree Overview

One way Structure, Traversal

Two way Structure, Traversal

Insert functionality

Traversal functionality

Delete functionality

AVL Trees

Need for AVL Trees

AVL Tree Overview

Tree Rotations (Left, Right)

Insert cases, Application of Insert cases

Insert Functionality code, Demo

Functions Code – LeftRight rotations, RightLeft rotations,

Delete Functionality, Rotations needed for Delete

Graphs

Graphs

Graph Types

Adjacency Matrix, Adjacency List

Traversals

BFS (Breadth First Search)

BFS Algorithm

DFS (Depth First Search)

DFS Algorithm

Spanning tree

Dijkstra Shortest path Algorithm

Minimum Spanning tree

Prim’s algorithm

Kruskal   algorithm

Hashing, Collision Resolution

Hashing

Hash Functions

Collision Resolution

Open Addressing (Closed Hashing)

Probing

Linear, Quadratic, Double hashing

Load factor of Hash Table

Deletion

Separate Chaining (Open Hashing)

Cuckoo Hashing

Lexicographic Order (Lexical Order)

Overview

Previous Permutation

Next Permutation

Course Curriculum

Chapter 1: Linked List (Implementation / Coding)

Lecture 1: About DS Course

Lecture 2: Summarizing DS Topics about Live Coding (/ Hands-on)

Lecture 3: Before understanding Linked List

Lecture 4: Concept of Link

Lecture 5: Linked List

Lecture 6: Creating Linked List (1)

Lecture 7: Creating Linked List (2)

Lecture 8: Display of Linked List, Count

Lecture 9: Reversing Approach

Lecture 10: Reversing Linked List

Lecture 11: Sorting of Linked List

Lecture 12: Add New node at Start

Lecture 13: Insert New node after a position

Lecture 14: Delete a node from the list

Lecture 15: Create Double Linked List (Double LL)

Lecture 16: Double LL: Display and Count

Lecture 17: Reversing a Double LL

Lecture 18: Insert a New node after a position in Double LL

Lecture 19: Double LL: Rotation (1)

Lecture 20: Double LL: Rotation (2)

Lecture 21: Double LL: Counting Pairs with a criteria

Lecture 22: Questions

Lecture 23: Data Structure Topics and Interaction

Lecture 24: Circular LL – overview

Lecture 25: Create LL, Add at Begin via front

Lecture 26: Display (Traversal) via front

Lecture 27: Insert node after an Element via front

Lecture 28: Delete node with key via front

Lecture 29: Add at End via rear, Display

Lecture 30: Create, Add to queue (Circular LL), Display

Lecture 31: Remove from queue (Circular LL), Display

Lecture 32: Questions

Chapter 2: Stacks (Implementation / Coding)

Lecture 1: Stack Overview

Lecture 2: Stack using array

Lecture 3: Application: Handling Expressions

Lecture 4: Evaluation of Postfix expression Overview

Lecture 5: Evaluation of Postfix expression Implementation

Lecture 6: Infix to Postfix Overview

Lecture 7: Infix to Postfix Implementation

Lecture 8: Prefix Evaluation and Infix to Prefix – Overview

Lecture 9: Application: Finding Next Big Element

Lecture 10: Stack using Linked List (LL)

Lecture 11: Reversing Stack using Linked List

Lecture 12: Questions

Chapter 3: Queues (Implementation / Coding)

Lecture 1: Queues Overview

Lecture 2: Queue using Array

Lecture 3: Priority Queue (1)

Lecture 4: Priority Queue (2)

Lecture 5: Queue using Linked List

Lecture 6: Priority Queue using Double Linked List

Lecture 7: Questions

Chapter 4: Recursion, Linked List Ops with Recursion

Lecture 1: Recursion Overview

Lecture 2: Recursive Functions, Phases

Lecture 3: LL Operations using Recursion (1)

Lecture 4: LL Operations using Recursion (2)

Lecture 5: Questions (& Discussion)

Chapter 5: Trees (Implementation / Coding)

Lecture 1: Binary Trees (1)

Lecture 2: Binary Trees (2)

Lecture 3: Tree Traversals (1)

Lecture 4: Binary Tree Traversals (2)

Lecture 5: Binary Tree Traversals (3)

Lecture 6: Binary Search Tree (BST) – Overview

Lecture 7: BST – Insertion Overview

Lecture 8: BST- Insert (Non Recursive)

Lecture 9: BST – Insert (Recursive)

Lecture 10: BST Traversal Explanation

Lecture 11: BST – Insert with Traversals (1)

Lecture 12: BST – Insert with Traversals (2)

Lecture 13: BST – Search (/Find) Overview

Lecture 14: BST – Search (1)

Lecture 15: BST – Search (2)

Lecture 16: BST – Deletion Overview

Lecture 17: BST Delete (1)

Lecture 18: BST Delete (2)

Lecture 19: Binary Tree to BST Conversion

Lecture 20: Identify Tree to be BST

Lecture 21: Identify Zero, One child Nodes of BST

Lecture 22: Questions

Chapter 6: Sorting

Lecture 1: Selection Sort, Analysis

Lecture 2: Bubble Sort, Analysis

Lecture 3: Insertion Sort (1)

Lecture 4: Insertion Sort (2), Analysis

Lecture 5: Quick Sort Overview

Lecture 6: Quick Sort Implementation

Lecture 7: Quick Sort, Analysis, MergeSort Discussion

Lecture 8: Questions

Chapter 7: Threaded Binary Trees

Lecture 1: Need for Threaded Binary Tree

Lecture 2: Thread Binary Tree Overview

Lecture 3: One way Threading Structure

Lecture 4: Traversal – One way Threading

Lecture 5: Two way Threading, Traversal

Lecture 6: Functions – Predecessor, Successor, Inorder

Lecture 7: Functions – Insert

Instructors

Shrirang Korde
Technologist

Rating Distribution

1 stars: 0 votes

2 stars: 0 votes

3 stars: 2 votes

4 stars: 8 votes

5 stars: 8 votes

Frequently Asked Questions

How long do I have access to the course materials?

You can view and review the lecture materials indefinitely, like an on-demand channel.

Can I take my courses with me wherever I go?

Definitely! If you have an internet connection, courses on Udemy are available on any device at any time. If you don’t have an internet connection, some instructors also let their students download course lectures. That’s up to the instructor though, so make sure you get on their good side!