Algorithms and Data Structures in C#: Complete Tutorial

Learn data structures and algorithms in C# from A to Z. Pass coding interview. Learn unit testing and TDD in addition.

4.39 (1848 reviews)
Udemy
platform
English
language
Software Engineering
category
instructor
14,075
students
15.5 hours
content
Jul 2020
last update
$69.99
regular price

What you will learn

Implement all the common data structures such as List, Stack, Queue and others understanding how they work under the covers

Use available data structures built-in .NET correctly: choose right data structures, understanding how they work under the covers

Pass coding interviews where interviewers torture you by asking to implement different algorithms and data structures

Solve custom problems related to algorithms and data structures, so you'll be able to combine data structures and re-implement algorithms suiting them for concrete cases

Implement Binary Search Tree

Understand and Apply Hash Tables

Understand and Apply Symbol Tables

Understand and Apply Heaps

Description

Why learn about data structures and algorithms? 

Algorithms and data structures constitute the fundamentals of programming.

  • Good understanding of algorithms and data structures is one of the most important requirements for a great number of work positions. You'll have to solve  many problems related to algorithms and data structures at coding interviews. Indeed, you can live without an understanding of algorithms and data structures, in general. However, you can do that until you face a real problem which requires to choose right data structures and implement custom algorithms. If you haven't ever faced such problems, believe me, this is just a matter of time. One day, you'll face such a problem and if you don't understand algorithms and data structures in depth, you'll feel yourself ashamed and helpless. You'll be stuck.

  • If you're not good at algorithms and data structures, you'll never pass a coding interview in a decent company. Almost all the companies   prefer to hire those developers who have good understanding of algorithms and data structures, remember that.  Do not delay the study of fundamental concepts.

  • Better hardware is not a solution  for all the performance-related problems. Sometimes, you need to write software for very slow devices. And that very often depends on the budget of a customer, by the way, so you don't have a control over it.

  • You'd better to understand what's going on under the hood at least one level in-depth. Indeed, if you don't understand how List works, sometimes you'll make sub-optimal or completely wrong decisions.

Why this course?

You may ask me "why should I take exactly your course?" And here is my answer:

  • This course is a comprehensive tutorial which covers a great number of topics

  • I tried to do my best to make this course not dry

  • This course concentrates not only at algorithms and data structures in general but it uncovers the internals of data structures and algorithms built-in .NET BCL (.NET Core's BCL is the same regarding fundamental data structures and algorithms)

  • This course is practical with exercises and solutions

  • This course will definitely help you to pass technical interviews

  • This course is made by a professional software developer with more than 10 years of real-world experience

  • and many other reasons :)

What's in the Course?

For now, the course covers:

  • Introduction to Algorithms and Data Structures: what is a data structure, abstract data type and what's the difference between these notions. What is an algorithm and why they are important to us?

  • Introduction to Algorithm Analysis:  determine how long will a program work, build a log-log plot, approximations, order of growth (Big-O notation), memory consumption

  • Arrays: arrays in C#, arrays in memory, time complexity of operations on arrays

  • Sort Algorithms: bubble sort, selection sort, insertion sort, recursion, shell sort, merge sort, quick sort, stability of sort algorithms

  • Lists: List built-in .NET BCL, nodes, linked list including singly and doubly linked lists, linked list built-in .NET

  • Stacks: theory and practice; stack based on array, stack based on a linked list, stack built-in .NET

  • Queues: theory and practice; queue based on array, circular queue, queue based on linked list, queue built-in .NET BCL

  • Search Algorithms: linear search, binary search (more will be added in the future)

  • Symbol Tables: intro, API, sequential search-based, binary search-based

  • Hash Tables: intro, hash functions, GetHashCode, approaches to collisions resolving: separate chaining and linear probing, Dictionary built-in BCL, Sets in BCL

  • Trees: binary search tree (BST), implementing BST (more will be added in the future)

  • Heaps: intro, heaps and arrays, implementation, Heap Sort (more will be added in the future, specifically about Priority Queues)

  • Immutable Collections: immutability and memory pressure, immutable stacks and queues, immutable list, immutable sets, immutable dictionaries, builders in immutable collections

  • Different Algorithms. This section will include different algorithms as you might guess. For now it convers the Sieve of Eratosthenes.

Take this course now and you'll be satisfied! Don't forget that Udemy provides 30-day money back refund policy, so if you don't like the course, you just click on a couple of buttons and get your money back!

Content

Materials

Source Code
Join .NET Community of Students

Introduction to Algorithms and Data Structures

Intro to Data Structures
Intro to Algorithms

Introduction to Algorithm Analysis

Time Complexity
Building a Log-Log Plot. Predicting the Running Time.
Approximations
Order of Growth

Arrays

Quick Overview of Arrays Built-In C#
Arrays in Memory
Time Complexity of Operations on Array

Sorting Algorithms

Bubble Sort (Theory)
Bubble Sort (Implementation)
Stability of Sort Algorithms
Selection Sort (Theory)
Selection Sort (Implementation)
Insertion Sort (Theory)
Insertion Sort (Implementation)
Recursion
Shell Sort (Theory)
Shell Sort (Implementation)
Merge Sort (Theory)
Merge Sort (Implementation)
Quick Sort (Theory)
Quick Sort (Implementation)

Lists

List Built-In BCL
Node as a Basic Building Block
Linked Lists
Singly-Linked List (Theory)
Singly-Linked List (Implementation)
Doubly-Linked List (Theory)
Doubly-Linked List (Implementation)
LinkedList Built-In BCL

Stacks

Stacks (Theory)
Stack Implementation (Array)
Stack Implementation (LinkedList)
Stack Built-In .NET & General Characteristics

Queues

Queue (Theory)
Queue Implementation (Array)
Circular Queue (Theory)
Circular Queue (Implementation)
Queue Implementation (LinkedList)
Queue Built-In .NET BCL

Search Algorithms

Linear Search
Binary Search (Theory)
Binary Search (Implementation)

Symbol Tables

Introduction to Symbol Tables
API of Symbol Tables
Sequential Search (Trivial Approach)
Sequential Search: Homework
Sequential Search: Solution for Homework
Binary Search-based Symbol Table
Binary Search-based Symbol Table: Homework
Binary Search-based Symbol Table: Solution for Homework
Conclusion

Symbol Tables and Hashing (Hash Tables)

Introduction to Hash Tables
Hashing in Primitives and GetHashCode
GetHashCode in Value Types and Reference Types
Importance of Hash Codes. Implementing GetHashCode
Resolving Collisions
Separate Chaining
Separate Chaining: Homework
Separate Chaining: Solution for Homework
Linear Probing
Built-In Dictionaries
Sets and Built-In Sets

Trees

Introduction to Trees
Binary Search Tree (BST)
Simple BST Implementation
Removal in BST: Theory
Removal in BST: Implementation

Heaps and Heap Sort

Heap Definition
Heaps and Arrays
Insertion: Theory
Insertion: Implementation
Remove: Theory
Implementing Peek and Remove
Performance of Operations in a Heap
Heap Sort: Theory
Heap Sort: Implementation
Priority Queue: to be continued...

Different Algorithms

Sieve of Eratosthenes
to be continued...

Immutable and Concurrent Collections

Outline
Introduction
Immutability and Memory Pressure
Immutable Stack and Queue
Immutable List
Immutable Sets
Immutable Dictionaries
Builders in Immutable Collections
Concurrent Queue and Concurrent Stack
Concurrent Bag
Concurrent Dictionary
Conclusion

Appendix. Intro to Unit Testing

Source Code for Unit Testing Appendix
Outline
What is a Unit Test
Unit Testing Frameworks
Your First Unit Test
Naming Conventions
Running & Debugging Unit Tests
Benefits of Unit Testing
Who Should Write Unit Tests and When
Programmer's Oath
Exercise: Degree Converter
Solution: Degree Converter
Conclusion

Appendix. NUnit - Unit Testing Framework

Outline
Assert Intro
Assert Demo
Arrange-Act-Assert
Running Tests from Console
SetUp and TearDown
OneTimeSetUp and OneTimeTearDown
Parameterized Unit Tests
Grouping and Ignoring Unit Tests
Code Coverage
Exercise: FizzBuzz
Solution: FizzBuzz
Exercise: Parsing Roman Numerals
Solution: Parsing Roman Numerals
Exercise: Stack
Solution: Stack
Conclusion

Appendix. Intro to TDD

Source Code - TDD
Outline
Why We Need TDD
What is TDD
Red/Green/Refactor
Three Laws of TDD
Changing Requirements and the Safety Net
F.I.R.S.T.
Different Types of Tests
Testing Frameworks and Tools
When TDD Fails
Conclusion

Screenshots

Algorithms and Data Structures in C#: Complete Tutorial - Screenshot_01Algorithms and Data Structures in C#: Complete Tutorial - Screenshot_02Algorithms and Data Structures in C#: Complete Tutorial - Screenshot_03Algorithms and Data Structures in C#: Complete Tutorial - Screenshot_04

Reviews

Kavya
June 27, 2023
Training is too big so somewhere we lost the interest. I agree too many content but it will make to sleep often
Alexander
March 14, 2023
Very good course that explains concepts elaborately with a nice mixture of theory and application! The extra sections regarding testing was a nice bonus as well.
Luis
February 27, 2023
It's a good course! I've learned much about DSA and Unit Tests. But the last sections (before the appendix) were covered quickly. There's a lack of explanation in it.
Pavani
December 17, 2022
Teaching is very bad and teaching is not in detail its waste of money to buy this kind of shit coerces Udemy is fraud
Oleksandr
August 18, 2022
Looks like the course was prepared in a kind of a lazy mode. Sometimes we have broken audio, was it hard to talk through for the one more time the text? In most cases when the author says "solve a lot of problems", those problems aren't introduced - emm, okay. And videos of algorithms from YouTube it's like 10/10 of laziness and he even says something like - it's not the classic version or it's another variation - so he could google more and find finally the variation of the algorithm actually needed. Cause I did that. I thought we are paying money for the author's approach and time for preparing the high or at least some quality course, but we have a bit of random knowledge from wiki and youtube said in a kind of a straightforward way.
Shaked
July 20, 2022
i think for begginers you should explain what is time complexity deeper and why we use it , and explain more about the syntax.
Jay
May 3, 2022
Solid C# implementations of fundamental algorithms and analysis of their time complexity. I felt I learned a significant amount about using C# to implement algorithms and how to use NUnit to test C# code. CON: a bit minor BUT ... code not provided for Immutable and Concurrent Collections section. That should be rectified.
Michael
December 15, 2021
Clear, concise, and explains things in great detail with alternative ways of doing the same thing. Very comprehensive.
Robert
October 2, 2021
Seems rushed at times. Recording volume varies from lecture to lecture. Assumes you know the math behind the content, which is not a problem for me but I could see it really confusing others.
Ronald
September 12, 2021
I feel like the word 'trivial' is overused! If you are a student trying to get to grips with the concepts, and because the material moves at speed, being told something is trivial is not helpful - anything is 'trivial' if you understand it... Thanks.
Natalia
June 17, 2021
Until now, it seems that it is what I am looking for. Hope to be the same for all sections. It's just the beggining of the begining
Pavel
March 9, 2021
Clear explanations, very well structured. Storyline is easy to follow, all concepts are revealed one after another. Author clearly articulates important points and concepts, again connected with the storyline.
Vern_russell@hotmail.com
February 3, 2021
Good match. Excellent material. Would like some more depth in places, but the quick overview is great too. It gives me several things to try for practice and covered several knowledge gaps that were not filled previously.
Ravi
November 16, 2019
I have started from scratch in Data Structure and Algorithm. So far so good. Logic started building in my mind. Like your way of teaching from basics, simple narration and raising the complexity later.
Redar
August 19, 2019
the course is great, but the instructor is not responsive, and recursion is important but only one video is made about it, other than that it is amazing course

Charts

Price

Algorithms and Data Structures in C#: Complete Tutorial - Price chart

Rating

Algorithms and Data Structures in C#: Complete Tutorial - Ratings chart

Enrollment distribution

Algorithms and Data Structures in C#: Complete Tutorial - Distribution chart
2028392
udemy ID
11/15/2018
course created date
10/14/2019
course indexed date
Bot
course submited by