Ecosyste.ms: Awesome

An open API service indexing awesome lists of open source software.
Awesome Lists | Featured Topics | Projects
https://github.com/izzatkarimov/data-structures-and-algorithms

personal notes on data structures and algorithms
https://github.com/izzatkarimov/data-structures-and-algorithms
computer-science dsa-algorithm faang-preparation
Last synced: 4 days ago
JSON representation
personal notes on data structures and algorithms
Host: GitHub
URL: https://github.com/izzatkarimov/data-structures-and-algorithms
Owner: izzatkarimov
License: mit
Created: 2024-04-06T21:58:33.000Z (9 months ago)
Default Branch: main
Last Pushed: 2024-12-13T21:02:54.000Z (19 days ago)
Last Synced: 2024-12-13T21:27:42.883Z (19 days ago)
Topics: computer-science, dsa-algorithm, faang-preparation
Homepage:
Size: 149 KB
Stars: 4
Watchers: 1
Forks: 0
Open Issues: 0
Metadata Files:
- Readme: README.md
- Funding: .github/FUNDING.yml
- License: LICENSE
Awesome Lists containing this project

README

        # Data Structures and Algorithms Notes

![dsa-banner](https://github.com/izzatkarimov/DSA-Notes/assets/108251704/44dda9d8-a66b-45c8-a602-6487ff6fa762)

## Overview

This repository contains my personal notes on Data Structures and Algorithms, with links to websites, courses, books, and other valuable materials.

## Table of Contents

- [Resources](#resources)

  - [Websites](#websites)

  - [Courses](#courses)

  - [YouTube Playlists](#youtube-playlists)

  - [Github Repositories](#github-repositories)

  - [Books](#books)

  - [Practicing](#practicing)

- [Notes](#notes)

  - [Algorithms & Data Structures for Beginners](#algorithms--data-structures-for-beginners---neetcode)

  - [Advanced Algorithms](#advanced-algorithms---neetcode)

  - [Python Data Structures & Algorithms](#python-data-structures--algorithms--leetcode-exercises)

  - [The Last Algorithms Course You'll Need](#the-last-algorithms-course-youll-need)

  - [Algorithms and Data Structures by FreeCodeCamp](#algorithms-and-data-structures-tutorial---freecodecamp)

  - [NeetCode YouTube Videos](#neetcode-youtube-videos)

---

## Resources

> The following is a list of online courses, YouTube videos, and websites to help learn Data Structures & Algorithms. Note that these are not in order of completion.

| All Resources | Type | Links | Notes |

| --- | --- | --- | --- |

| LeetCode | `website`| [Website Link](https://leetcode.com) |

| NeetCode| `website`| [Website Link](https://neetcode.io/practice) |

| AlgoMap | `website` | [Website Link](https://algomap.io/) |

| TopSWE | `website`| [Website Link](https://topswe.com/) |

| LeetCode Patterns | `website` | [Website Link](https://seanprashad.com/leetcode-patterns/) |

| NeetCode Roadmap | `website` | [Website Link](https://neetcode.io/roadmap) |

| VisuAlgo | `website` | [Website Link](https://visualgo.net/en) |

| Data Structure Visualizations | `website` | [Website Link](https://www.cs.usfca.edu/~galles/visualization/Algorithms.html) |

| Big-O CheatSheet | `website` | [Website Link](https://www.bigocheatsheet.com/) |

| Data Structure Visualization | `website` | [Website Link](https://www.cs.usfca.edu/~galles/visualization/Algorithms.html) |

| NeetCode Courses | `course` | [Course Link](https://neetcode.io/courses) | [Notes](#algorithms--data-structures-for-beginners---neetcode)

| Python Data Structures & Algorithms + LEETCODE Exercises | `course` | [Course Link](https://www.udemy.com/course/data-structures-algorithms-python/?couponCode=ACCAGE0923) | [Notes](#python-data-structures--algorithms--leetcode-exercises)

| The Last Algorithms Course You'll Need | `course` | [Course Link](https://frontendmasters.com/courses/algorithms/) |

| Algorithms and Data Structures Tutorial - Full Course for Beginners - FreeCodeCamp | `youtube-videos` | [Video Link](https://youtu.be/8hly31xKli0?si=HmAgr-2AlG3hcRZp) | [Notes](#algorithms-and-data-structures-tutorial---freecodecamp) |

| NeetCode YouTube Videos | `youtube-videos` | [Channel Link](https://www.youtube.com/@NeetCode) | [Notes](#neetcode-youtube-videos)

| Coding Interview University | `github-repo` | [Repository Link](https://github.com/jwasham/coding-interview-university) |

| Awesome Algorithms | `github-repo` | [Repository Link](https://github.com/tayllan/awesome-algorithms) |

### Websites

---

- [Roadmap to learn DSA by Neetcode](https://neetcode.io/roadmap)

- [VisuAlgo](https://visualgo.net/en)

- [Data Structure Visualization](https://www.cs.usfca.edu/~galles/visualization/Algorithms.html)

### Courses

---

- [Neetcode Courses](https://neetcode.io/courses)

  - [Algorithms & Data Structures for Beginners Notes](#algorithms--data-structures-for-beginners---neetcode)

  - [Advanced Algorithms Notes](#advanced-algorithms---neetcode)

  - [System Design for Beginners](#system-design-for-beginners---neetcode)

  - [System Design Interview Notes](#system-design-interview---neetcode)

- [Python Data Structures & Algorithms + LEETCODE Exercises](https://www.udemy.com/course/data-structures-algorithms-python/?couponCode=ACCAGE0923)

  - [Notes from the course](#python-data-structures--algorithms--leetcode-exercises)

- [The Last Algorithms Course You'll Need](https://frontendmasters.com/courses/algorithms/)

  - [Notes from the course](#the-last-algorithms-course-youll-need)

### YouTube Playlists

---

- [Algorithms and Data Structures Tutorial - Full Course for Beginners - FreeCodeCamp](https://youtu.be/8hly31xKli0?si=HmAgr-2AlG3hcRZp)

  - [Notes from the video](#algorithms-and-data-structures-tutorial---freecodecamp)

- [Neetcode Videos on YouTube](https://www.youtube.com/@NeetCode)

  - [Notes from the videos](#neetcode-youtube-videos)

### Github Repositories

---

- [Coding Interview University](https://github.com/jwasham/coding-interview-university)

- [Awesome Algorithms](https://github.com/tayllan/awesome-algorithms)

### Books

---

- Cracking the Coding Interview

- Introduction to Algorithms

### Practicing

---

- [Leetcode](https://leetcode.com/)

- [Neetcode](https://neetcode.io/practice)

- [TopSWE](https://topswe.com/)

- [LeetCode Patterns](https://seanprashad.com/leetcode-patterns/)

## Notes

---

### Algorithms & Data Structures for Beginners - NeetCode

Arrays

`What is Data Structure?`

- Data Structure is a way of structuring data inside of RAM of a computer.

`How do ew store an array in RAM?`

- RAM is measured in bytes. One byte is 8 bits. A bit can be thought of as a position that can store a digit, which has to be either 0 or 1.

`NOTE!`

- Arrays are always stored contiguously in RAM, meaning that they are stored one next to another (there is nothing between them.

`NOTE!`

- Static arrays are Fixed arrays. The biggest limitation of Static Arrays is that we cannot add / delete elements after creation. Technically, we can remove a value, but removing here only means overriding. We cannot actaully delete the value in memory. But, we can override by putting, let's say, 0 in the index location of it.

`Big O Time Complexity of Static Arrays Operations`

| Operation  | Big O Time | 

| ------------- | ------------- |

| Read / Write i-th element  | O(1)  |

| Insert / Remove End | O(1)  |

| Insert Middle | O(n)  |

| Remove Middle  | O(n)  |

`NOTE!`

- In Python and JavaScript, Dynamic Arrays are the default. In Java, we can use an Array List, and in C++, we can use a Vector.

`What is Amortized Time Complexity?`

- Amortized Time Complexity

Linked List

Recursion

Sorting

Binary Search

Trees

Backtracking

Heap & Priority Queue

Hashing

Graphs

Dynamic Programming

Bit Manipulation

---

### Advanced Algorithms - NeetCode

Arrays

Linked Lists

Trees

Heaps

Backtracking

Graphs

Dynamic Programming

---

### Python Data Structures & Algorithms + LEETCODE EXERCISES

> [!NOTE]

> Coming Soon.

---

### The Last Algorithms Course You'll Need

> [!NOTE]

> Coming Soon.

---

### Algorithms and Data Structures Tutorial - FreeCodeCamp

Introduction to Algorithms

`What is an Algorithm`

- An Algorithm is a set of steps or instructions for completing a certain task. For example, a recipe is an algorithm. To-Do List for a Morning Routine is an algorithm. However, in the context of Computer Science, an algorithm more specifically means a set a steps a program takes to finish a certain task.

`Time Complexity`

- Time Complexity is a measure of how long it takes the algorithm to run.

`Space Complexity`

- Space Complexity deals with the amount of memory taken up on the computer.

`Balance between Time & Space Complexity`

- A good algorithm needs to balance between Time and Space Complexity to be useful. For example, you can have a very fast algorithm but it may not matter if the algorithm consumes more memory than you have available.

`Running Time of an Algorithm`

- How long the algorithm runs for a given set of values until the output is called The Running Time or The Running Time of an Algorithm and is used to define Time Complexity.

`Linear Search (Sequential Search)`

- Linear Search is a sequential searching algorithm where we start from one end and check every element of the list until the desired element is found. It is the simplest searching algorithm.

`Binary Search (Hald Interval Search)`

- Binary Search is a searching algorithm for finding an element's position in a sorted way. In this approach, the element is always searched in the middle of a portion of an array. Binary Search can be implemented only on a sorted list of items. If the elements are not sorted already, we need to sort them first.

`Guidelines for defiing an Algorithm:`

  - The steps in the Algorithm need to be in a specific order.

  - The steps also need to be distinct.

  - The algorithm should produce a result.

  - The algorithm should complete in a finite amount of time.

Introduction to Data Structures

Algorithms: Sorting and Searching

---

### NeetCode YouTube Videos

> [!NOTE]

> Coming Soon.