Algorithms Data Structures Csharp

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

Last updated 2022-01-10 | 4.4

- 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

What you'll 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

* Requirements

* Some experience in C# or Java
* Tooling: a free version of Visual Studio (Community Edition)

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!

Who this course is for:

  • C# developers who want to learn algorithms and data structures in their beloved programming language
  • Junior developers (C# or Java) who want to successfully pass programming interviews

Course content

18 sections • 137 lectures

Source Code Preview 00:01

Join .NET Community of Students Preview 00:02

Time Complexity Preview 16:06

Building a Log-Log Plot. Predicting the Running Time. Preview 05:23

Approximations Preview 05:40

Order of Growth Preview 05:01

Quick Overview of Arrays Built-In C# Preview 20:02

Arrays in Memory Preview 09:21

Time Complexity of Operations on Array Preview 16:18

Bubble Sort (Theory) Preview 06:21

Bubble Sort (Implementation) Preview 14:03

Stability of Sort Algorithms Preview 05:34

Selection Sort (Theory) Preview 04:03

Selection Sort (Implementation) Preview 05:24

Insertion Sort (Theory) Preview 06:21

Insertion Sort (Implementation) Preview 05:46

Recursion Preview 14:32

Shell Sort (Theory) Preview 12:23

Shell Sort (Implementation) Preview 08:35

Merge Sort (Theory) Preview 07:43

Merge Sort (Implementation) Preview 12:27

Quick Sort (Theory) Preview 08:07

Quick Sort (Implementation) Preview 07:39

List Built-In BCL Preview 22:56

Node as a Basic Building Block Preview 07:43

Linked Lists Preview 01:09

Singly-Linked List (Theory) Preview 04:29

Singly-Linked List (Implementation) Preview 24:11

Doubly-Linked List (Theory) Preview 02:02

Doubly-Linked List (Implementation) Preview 13:43

LinkedList Built-In BCL Preview 05:39

Stacks (Theory) Preview 04:46

Stack Implementation (Array) Preview 16:06

Stack Implementation (LinkedList) Preview 07:17

Stack Built-In .NET & General Characteristics Preview 03:26

Queue (Theory) Preview 06:11

Queue Implementation (Array) Preview 11:37

Circular Queue (Theory) Preview 02:07

Circular Queue (Implementation) Preview 15:32

Queue Implementation (LinkedList) Preview 05:51

Queue Built-In .NET BCL Preview 05:30

Linear Search Preview 19:29

Binary Search (Theory) Preview 03:03

Binary Search (Implementation) Preview 11:30

Introduction to Symbol Tables Preview 02:37

API of Symbol Tables Preview 06:31

Sequential Search (Trivial Approach) Preview 12:35

Sequential Search: Homework Preview 00:53

Sequential Search: Solution for Homework Preview 06:12

Binary Search-based Symbol Table Preview 26:10

Binary Search-based Symbol Table: Homework Preview 02:39

Binary Search-based Symbol Table: Solution for Homework Preview 11:26

Conclusion Preview 01:11

Introduction to Hash Tables Preview 04:53

Hashing in Primitives and GetHashCode Preview 09:53

GetHashCode in Value Types and Reference Types Preview 06:50

Importance of Hash Codes. Implementing GetHashCode Preview 28:25

Resolving Collisions Preview 04:56

Separate Chaining Preview 20:39

Separate Chaining: Homework Preview 02:00

Separate Chaining: Solution for Homework Preview 16:24

Linear Probing Preview 22:02

Built-In Dictionaries Preview 04:37

Sets and Built-In Sets Preview 07:31

Introduction to Trees Preview 04:21

Binary Search Tree (BST) Preview 06:32

Simple BST Implementation Preview 25:43

Removal in BST: Theory Preview 05:29

Removal in BST: Implementation Preview 09:21

Heap Definition Preview 03:54

Heaps and Arrays Preview 03:31

Insertion: Theory Preview 02:17

Insertion: Implementation Preview 15:40

Remove: Theory Preview 03:18

Implementing Peek and Remove Preview 18:13

Performance of Operations in a Heap Preview 01:11

Heap Sort: Theory Preview 05:12

Heap Sort: Implementation Preview 04:58

Priority Queue: to be continued... Preview 00:03

Outline Preview 01:32

Introduction Preview 04:37

Immutability and Memory Pressure Preview 06:36

Immutable Stack and Queue Preview 09:24

Immutable List Preview 04:35

Immutable Sets Preview 05:23

Immutable Dictionaries Preview 04:28

Builders in Immutable Collections Preview 04:13

Concurrent Queue and Concurrent Stack Preview 05:49

Concurrent Bag Preview 04:08

Concurrent Dictionary Preview 07:49

Conclusion Preview 02:01

Source Code for Unit Testing Appendix Preview 00:01

Outline Preview 00:58

What is a Unit Test Preview 03:09

Unit Testing Frameworks Preview 03:22

Your First Unit Test Preview 08:49

Naming Conventions Preview 04:34

Running & Debugging Unit Tests Preview 05:02

Benefits of Unit Testing Preview 03:35

Who Should Write Unit Tests and When Preview 02:51

Programmer's Oath Preview 03:17

Exercise: Degree Converter Preview 01:29

Solution: Degree Converter Preview 06:54

Conclusion Preview 01:15

Outline Preview 01:01

Assert Intro Preview 05:29

Assert Demo Preview 10:27

Arrange-Act-Assert Preview 00:58

Running Tests from Console Preview 01:51

SetUp and TearDown Preview 05:09

OneTimeSetUp and OneTimeTearDown Preview 02:13

Parameterized Unit Tests Preview 03:40

Grouping and Ignoring Unit Tests Preview 02:14

Code Coverage Preview 01:42

Exercise: FizzBuzz Preview 01:07

Solution: FizzBuzz Preview 05:05

Exercise: Parsing Roman Numerals Preview 02:27

Solution: Parsing Roman Numerals Preview 09:27

Exercise: Stack Preview 00:59

Solution: Stack Preview 09:02

Conclusion Preview 01:25

Source Code - TDD Preview 00:02

Outline Preview 01:06

Why We Need TDD Preview 16:18

What is TDD Preview 05:00

Red/Green/Refactor Preview 04:16

Three Laws of TDD Preview 01:42

Changing Requirements and the Safety Net Preview 05:23

F.I.R.S.T. Preview 02:48

Different Types of Tests Preview 04:04

Testing Frameworks and Tools Preview 05:06

When TDD Fails Preview 02:46

Conclusion Preview 02:02