C# Intermediate – Part III (ADT and Sorting Algorithms)

C# Intermediate – Part III (ADT and Sorting Algorithms), available at $27.99, with 49 lectures, and has 12 subscribers.

You will learn about The intricacies, advantages and disadvantages of the static and dynamic implementation of Linked List, Doubly Linked List, Stack and Queue. When and how to use Hashset and Dictionary. Definition, usage and implementation of Binary Tree and Graph. How to sort data with various sorting algorithms – Selection, Bubble, Insertion, Quick and Merge. In-depth analysis and explanation of the Doubly Linked List, Binary Tree and Graph structures, Quick and Merge sort behavior too. Recursion as an alternative solution and approach to solving iterative problems. Compare your way of thinking and solving exercises with mine solutions to the problems. How to compute the time complexity of sorting algorithms and abstract data structures’ operations. This course is ideal for individuals who are Anyone who has an interest in software development and particularly abstract data structures and sorting algorithms. or Students that finished my course "C# Intermediate – Part II (Reflection, Events, LINQ)". It is particularly useful for Anyone who has an interest in software development and particularly abstract data structures and sorting algorithms. or Students that finished my course "C# Intermediate – Part II (Reflection, Events, LINQ)".

Enroll now: C# Intermediate – Part III (ADT and Sorting Algorithms)

Summary

Title: C# Intermediate – Part III (ADT and Sorting Algorithms)

Price: $27.99

Number of Lectures: 49

Number of Published Lectures: 49

Number of Curriculum Items: 49

Number of Published Curriculum Objects: 49

Original Price: $27.99

Quality Status: approved

Status: Live

What You Will Learn

The intricacies, advantages and disadvantages of the static and dynamic implementation of Linked List, Doubly Linked List, Stack and Queue.
When and how to use Hashset and Dictionary.
Definition, usage and implementation of Binary Tree and Graph.
How to sort data with various sorting algorithms – Selection, Bubble, Insertion, Quick and Merge.
In-depth analysis and explanation of the Doubly Linked List, Binary Tree and Graph structures, Quick and Merge sort behavior too.
Recursion as an alternative solution and approach to solving iterative problems.
Compare your way of thinking and solving exercises with mine solutions to the problems.
How to compute the time complexity of sorting algorithms and abstract data structures’ operations.

Who Should Attend

Anyone who has an interest in software development and particularly abstract data structures and sorting algorithms.
Students that finished my course "C# Intermediate – Part II (Reflection, Events, LINQ)".

Target Audiences

Anyone who has an interest in software development and particularly abstract data structures and sorting algorithms.
Students that finished my course "C# Intermediate – Part II (Reflection, Events, LINQ)".

In this course the students will develop their logical and algorithmic thinking creating the static and dynamic version of the abstract data structures Linked List, Doubly Linked List, Stack and Queue. Understanding the intricacies of the structures, their advantages and disadvantages, how they work, how much memory they need, how to compute their time complexity will boost students’ confidence and clarity. Software developers will be able to pick the right structure for the specific scenario they need in their working environment.

Teaching students complicated topics as graphs and trees are a challenge for every teacher. I am convinced that the subjects are covered in such a way that the students will be able to grasp the fundamental ideas and depending on their skill implement them with code. The advanced concepts are hard because they require knowledge about the recursion which I decided to include as well.

The peculiar data structures Hashset and Dictionary will be covered in the course as well increasing the range of options for the students.

The basic sorting algorithms – Selection, Bubble, Insertion – are explained with examples and code too. The advanced sorting algorithms (Merge and Quick) are presented in a way that will be helpful for the students’ mind to come up with the algorithm and write it down.

Before we start making multi-tier applications a strong foundation of knowledge, skills and experience with solving simple tasks are necessary. This course is the fourth stepping stone towards achieving that goal.

I hope that my students will be benevolent toward each other in the Q&A section of the courses and be successful in their future career as a software developer (and engineer).

Course Curriculum

Chapter 1: Abstract Data Structures

Lecture 1: Excerpts

Lecture 2: Introduction

Lecture 3: Static Implementation Of Dynamic List

Lecture 4: Dynamic Implementation Of Dynamic List

Lecture 5: Queue

Lecture 6: Static Implementation of Queue

Lecture 7: Dynamic Implementation of Queue

Lecture 8: Stack

Lecture 9: Static Implementation of Stack

Lecture 10: Dynamic Implementation of Stack

Chapter 2: Abstract Data Structures – Advanced

Lecture 1: Doubly Linked List

Lecture 2: Doubly Linked List – Implementation

Lecture 3: Additional Video – Recursion

Lecture 4: Solutions to Recursion

Lecture 5: Graphs – Definition and Usage

Lecture 6: Adding and Removing Nodes to Graphs

Lecture 7: DFS and BFS for Graph

Lecture 8: BFS (Better Solution) for Graph

Lecture 9: Binary Tree

Lecture 10: Different Traversal Approaches

Lecture 11: Balancing a Tree and Removing a Node

Lecture 12: Adding Nodes to Binary Tree, DFS and BFS

Lecture 13: Different Traversal Approaches (Solution)

Lecture 14: Balancing a Tree and Removing a Node (Solution)

Lecture 15: Dictionaries

Lecture 16: Hashset

Lecture 17: Exercise VI

Lecture 18: Solutions to Ex. VI

Chapter 3: Sorting Algorithms

Lecture 1: Selection Sort

Lecture 2: Bubble Sort

Lecture 3: Insertion Sort

Lecture 4: Merge Sort

Lecture 5: Solutions to Ex. VII

Lecture 6: Quick Sort

Lecture 7: Solutions to Ex. VIII

Chapter 4: Binary Search and Big O Notation

Lecture 1: Big O Notation

Lecture 2: Tables of Common Time Complexities

Lecture 3: Binary Search

Lecture 4: Solutions to Ex. IX

Lecture 5: End

Lecture 6: Additional Video – Selection, Bubble and Insertion Sort (Code Explained)

Chapter 5: Materials/Solutions

Lecture 1: Abstract Data Types

Lecture 2: Binary Tree

Lecture 3: Graph

Lecture 4: Hashset

Lecture 5: Sorting Algorithms

Lecture 6: Dictionary – Solution to Ex. VI

Lecture 7: Binary Search – Solution to Ex. IX

Lecture 8: Bonus Material

Instructors

Ivan Iliev
Teaching professional classes in Software Development

Rating Distribution

1 stars: 0 votes
2 stars: 0 votes
3 stars: 0 votes
4 stars: 0 votes
5 stars: 0 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!

Menu