This repository contains a collection of projects in C++ and Python that implement various data structures and algorithms. The projects are organized by language and topic, and include detailed explanations and examples to help you understand how they work.

Ever since I first tackled Algorithms and Data Structures at university in 2015, I've found it super useful to regularly go back to the basics. This becomes even more important when you're trying to learn a new programming language - a strong foundation is key. To help others, I've decided to share my code and notes on the subject with everyone.

My code is written in two programming languages I really enjoy, C++ and Python. I've done my best to stick to the latest best practices. Alongside the code, you'll find the notes I made while learning. These notes give more context and could be really handy for anyone new to Algorithms and Data Structures.

The following requirements are necessary to build and run the code in this repository:

• For C++ projects:
  • A C++ compiler supporting C++14
  • CMake 3.15 or later
• For Python projects:
  • Python 3.10 or later

No additional libraries or modules are required.

This repository is organized into distinct algorithm implementations, each contained in its own subdirectory. These subdirectories provide the source code, unit tests, and build configuration files necessary for each algorithm. Because each algorithm forms a separate project, you should handle the build and test processes individually.

Building and testing C++ projects involve a sequence of steps. Here's a detailed walkthrough:

1. Navigate to the project directory: Start by moving into the directory containing the specific project you want to build and test.

2. Create and navigate into the build directory:

mkdir -p build && cd build

This command creates a new directory named build (if it doesn't already exist) and then navigates into it. The build directory is where the output files of the build process will be stored.

3. Generate the build files with CMake:

cmake ..

This command runs CMake to generate the build files. .. tells CMake to look for the CMakeLists.txt file in the directory above build.

4. Build the project:

make

This command compiles the source code using the instructions specified in the CMakeLists.txt file.

5. Run the unit tests:

ctest --verbose

The ctest --verbose command executes the unit tests and uses the verbose flag to provide a detailed output.

To test a Python project, execute the following command in the project directory:

python -m unittest discover -v

This command uses Python's built-in unittest module to discover and run the tests. The -v (verbose) flag is used to get more detailed output from the tests.

For convenience, this repository includes a utility script named run_tests.sh. Execute the following commands from the repository's root to run tests in all subprojects:

• To run all unit tests: ./run_tests.sh
• To run all Python tests: ./run_tests.sh --python
• To run all C++ tests: ./run_tests.sh --cpp
• To read all options from terminal: ./run_tests.sh --help

Consistent code formatting is essential for maintaining readability and understanding of the codebase. Therefore, we have adopted specific formatting guidelines for each programming language used in this repository.

We adhere to the Google C++ Style Guide. To automatically format the code, we use clang-format. Use the following command to format your code:

find . -regex '.*\\.(cpp|hpp|cu|c|h)' -exec clang-format -style=file -i {} \\;

This command recursively finds all files with .cpp, .hpp, .cu, .c, or .h extensions and formats them using clang-format.

CMake files should have a consistent style as well. For this, we use cmake-format. To format a CMakeLists.txt file, execute the following command:

cmake-format CMakeLists.txt -i

This command applies the cmake-format to the CMakeLists.txt file.

We follow the PEP 8 - Style Guide for Python Code for Python projects and use black to automatically format the code. Use the following command to format your Python code:

black .

This command formats all Python files in the current directory and its subdirectories using black.

• Basic concepts.
• Data structures.
• Graph algorithms.
• Backtracking.
• Dynamic programming.
• Sorting.
• Brain teasers.

We encourage contributions that enhance the repository's value. To contribute:

1. Fork the repository.
2. Create your feature branch (git checkout -b feature/AmazingFeature).
3. Commit your changes (git commit -m 'Add some AmazingFeature').
4. Push to the branch (git push origin feature/AmazingFeature).
5. Open a Pull Request.

• Cormen, Thomas H.; Leiserson, Charles E.; Rivest, Ronald L.; Stein, Clifford
  Introduction to Algorithms, 3rd Edition (The MIT Press)
  Amazon Link

• Halim, Steven
  Competitive Programming 3
  Amazon Link

• Karumanchi, Narasimha
  Data Structures and Algorithms Made Easy: Data Structures and Algorithmic Puzzles
  Amazon Link

• Kernighan, Brian; Ritchie, Dennis
  The C Programming Language
  Amazon Link

• Skiena, Steven; Revilla, Miguel
  Programming Challenges: The Programming Contest Training Manual
  Amazon Link

• Laaksonen, Antti
  Guide to Competitive Programming: Learning and Improving Algorithms Through Contests (Undergraduate Topics in Computer Science)
  Amazon Link

• Nimajneb, Nite
  The Hitchhiker’s Guide to the Programming Contests

• Prasad, L. V. Narashima; Patro, E. Kishna Rao
  Lecture Notes on Data Structures using C

• Stanford CS Library
• Stanford Introduction to Programming Contests
• MIT OCW: Advanced Data Structures - Spring 2012
• MIT OCW: Introduction to Computational Thinking and Data Science - Fall 2016
• Data Structures and Algorithms by University of Birmingham
• UC Irvine - Data Structures and Algorithms
• Columbia University - Old Computer Science Courses
• University of Auckland - Computer Science Lectures
• UC Berkeley - Data Structures, Spring 2019
• KTH Royal Institute of Technology - Problem Solving and Programming under Pressure
• CP Algorithms
• Computational Geometry by Kent State University
• CodeAhoy - Learn C Programming

This project is licensed under the MIT License - see the LICENSE file for details.