**Algorithms Bootcamp in C++**

English | MP4 | AVC 1280×720 | AAC 44KHz 2ch | 6.5 Hours | 3.96 GB

eLearning | Skill level: All Levels

Recursion, backtracking, dynamic programming and data structures (linked lists, queues, stacks and binary search trees)

This course is for those who are interested in computer science and want to implement the algorithms and given data structures in C++ from scratch. In every chapter you will learn about the theory of a given data structure or algorithm and then you will implement them from scratch.

Chapter 1: Recursion

- theory behind recursion (recursive function calls)
- recursion and stack memory of the OS
- recursive problems: binary search and Towers of Hanoi problem

Chapter 2: Backtracking

- what is backtracking
- how to solve problems with backtracking
- N-queens problem, coloring problem and knight’s tour

Chapter 3: Dynamic Programming

- overlapping subproblems and dynamic programming
- what is “memoization”
- Fibonacci numbers and knapsack problem

Chapter 4: Data Structures

- data structures and abstract data types (ADTs)
- arrays and linked lists
- stacks
- queues
- binary search trees
- priority queues (heaps)
- associative arrays (maps)

Thanks for joining my course, let’s get started!

What you’ll learn

- what is recursion
- what are backtracking and dynamic programming
- what are the fundamental data structures: array, linked lists, stacks, queues and binary search trees

**+ Table of Contents**

**Introduction**

1 Introduction

**Algorithms – Recursion**

2 What is recursion (recursive function call)

3 Recursion and iteration (differences)

4 Head and tail recursion implementation

5 Recursion and stack memory (stack overflow)

6 Factorial problem

7 Fibonacci-numbers problem

8 Fibonacci-numbers with tail recursion

9 Binary search with recursion

10 Towers of Hanoi introduction

11 Towers of Hanoi implementation

**Algorithms – Backtracking**

12 What is backtracking

13 N-queens problem introduction

14 N-queens problem implementation

15 Coloring problem introduction

16 Coloring problem implementation

17 Knight’s tour problem introduction

18 Knight’s tour problem implementation

19 Problems with NP-complete problems

**Algorithms – Dynamic Programming**

20 What is dynamic programming

21 Fibonacci numbers introduction

22 Fibonacci numbers implementation

23 Knapsack problem introduction

24 Knapsack problem example

25 Knapsack problem implementation

**Data Structures – Arrays**

26 Arrays introduction – basics

27 Arrays introduction – operations

28 Arrays in C++

**Data Structures – Linked Lists**

29 Linked lists theory – basics

30 Linked list theory – operations

31 Linked list theory – linked lists versus arrays

32 Linked list implementation

**Data Structures – Stacks**

33 Stack introduction

34 Stacks in memory management ( stacks, heaps )

35 Stacks and recursive method calls

36 Stacks implementation with arrays

37 Stack implementation with linked lists

**Data Structures – Queues**

38 Queues introduction

39 Queue implementation with linked list

**Data Structures – Trees**

40 Binary search trees theory – basics

41 Binary search trees theory – search, insert

42 Binary search trees theory – delete

43 Binary search trees theory – in-order traversal

44 Binary search trees theory – running times

45 Practical (real-world) applications of trees

**Priority Queues (Heaps)**

46 Priority queues introduction

47 Heap introduction – basics

48 Heap introduction – array representation

49 Heap introduction – remove operation

50 Heap introduction – heapsort

51 Heap introduction – running times

52 Other types of heaps binomial and Fibonacci heap

53 Heaps implementation I

54 Heaps implementation II

**Associative Arrays (Maps)**

55 What are associative arrays

56 Hashtables introduction – basics

57 Hashtables introduction – collisions

58 Hashtables introduction – load factor & dynamic resizing

59 Chaining method

60 Linear probing method

61 Practical (real-world) applications of hashing

Resolve the captcha to access the links!