https://github.com/daveanthonyc/data-structures-and-algorithms

👩🏽‍🔧 🧩 🔢 🖩 Based on the course by ThePrimeagen: "The Last Algorithms Course You'll Need" as listed below. The '/src/dsa' directory in this React project contains multiple TypeScript files with implementations of fundamental concepts in data structures and algorithms.
https://github.com/daveanthonyc/data-structures-and-algorithms

computer-science data-structures dsa-practice software-engineering theprimeagen typescript unit-testing vitest

Last synced: 1 day ago
JSON representation

👩🏽‍🔧 🧩 🔢 🖩 Based on the course by ThePrimeagen: "The Last Algorithms Course You'll Need" as listed below. The '/src/dsa' directory in this React project contains multiple TypeScript files with implementations of fundamental concepts in data structures and algorithms.

• Host: GitHub
• URL: https://github.com/daveanthonyc/data-structures-and-algorithms
• Owner: daveanthonyc
• Created: 2024-01-23T01:55:50.000Z (10 months ago)
• Default Branch: main
• Last Pushed: 2024-04-11T04:35:09.000Z (7 months ago)
• Last Synced: 2024-04-11T05:52:34.776Z (7 months ago)
• Topics: computer-science, data-structures, dsa-practice, software-engineering, theprimeagen, typescript, unit-testing, vitest
• Language: TypeScript
• Homepage: https://frontendmasters.com/courses/algorithms/
• Size: 101 KB
• Stars: 1
• Watchers: 1
• Forks: 0
• Open Issues: 0
• Metadata Files:
  • Readme: README.md

Awesome Lists containing this project

README

        
# Data Structures and Algorithms - Implementations in TypeScript and Tests in Vitest

Here are implementations of all the DSA topics from the course by ThePrimeagen, "The Last Algorithms Course You'll Need".

[Access the course here](https://frontendmasters.com/courses/algorithms/)

**UPDATE 2/2/2024: As this course is mainly to learn the fundamentals and implement SOME of the basics, I have added another directory of DSA specific problems called the [Blind 75](https://neetcode.io/practice) to practice the implementations.**

**Helpful markdown notes are included in the separate directories for each topic regarding their basic definitions and tradeoffs. But more importantly, some of my comments and analysis on the nuances of problem solving techniques are noted down as well. This is not only for my learning but also for the helpful guidance of others.**

**My progress is denoted by the ticks next to the topics below:** ✅

## Topics

- Introduction [ ✅ ]

- Basics [ ✅ ] 

- Search [ ✅ ]

    * Linear Search

    * Binary Search

- Sort [ ✅ ]

    * Bubble Sort

    * Linked List Introduction

    * Queue

    * Stack

- Arrays [ ✅ ]

    * Array vs LinkedList

    * ArrayList

    * ArrayBuffer

- Recursion [ ✅ ] 

    * Path Finding Algorithm

- Quick Sort [ ✅ ]

- Doubly Linked List [ ✅ ]

- Trees [ ✅ ] 

    * Pre/In/Post-Order Traversal

- Tree Search [ ✅ ] 

    * Breadth First Search 

    * Search Practice

    * Binary Tree Comparison

    * Depth-First: Find

    * Depth-First: Insert

    * Depth-First: Delete

    * Dpeth-First-Search Implementation

- Heap [ ✅ ] 

    * Heap

    * Implementing Heap

    * Tries

- Graphs [  ] 👈

    * Graph Overview

    * Searching an adjacency matrix

    * Implementing BFS on an adjacency matrix

    * Implementing DFS on an adjacency matrix

    * Dijkstra's Shortest Path

    * Dijkstra's Shortest Path: Implementation

    * Dijkstra's Shortest Path: Running Time

- Maps & LRU [  ]

### Installation

- Clone the project

- Have node installed on your machine

- npm install

- npm test

## Method of Learning

***Context of learning: I have been able to do quite a few LeetCode style questions on AlgoExpert.io previously and have also looked into a few of the topics in the Harvard lectures regarding COMSCI fundamentals. So picking up the general concept was straight forward but learning the implementation and process/mindset to the problem solving was quite a challenge.***

- For this course, I watched through the videos, and simultaneously took down mark down notes for the general concepts.

- If I found it a bit difficult, then I would try to white board the solutions and slowly pick up on what steps are being made and how they translate to code and do this over and over once I have a decent grasp.

- Sometimes I needed to copy down the code and follow it line by line to fully realise how the white boarding was translated into the code and understand the agorithm more.

    - It was at this stage where I also jot down questions for specific gray areas that are confusing.

- During this process of trying to understand, I was looking at the specific ordering that ThePrimeagen was taking steps to approach problems or specific thoughts that he addressed when he was looking at problems. Also the steps he took to implment the code in the editor were things I were noting down as well. One by one, the initial markdown notes on the topic evolved as I gained more understanding on the problem and I also tried to make links with every other problem solving method to see if there are commanalities that would enable me to make a repeatable methodology to approach these style of problems.

- Then I would try to implement the solution from scratch only relying on the ordered steps of problem solving that I attempted to extrapolate from the videos.

- Once I arrived at the solution, then I would answer the questions I had from before.

Ngl, I've been really loving this course as I've not only been solving these problems that are in increasing difficulty BUT ALSO discovering repeatable key details in problem-solving that I've added to my methodology 😆