From bca1c5046d3baa98a686270de58c3b4a06b9a536 Mon Sep 17 00:00:00 2001 From: Deepak Raj Date: Mon, 5 Oct 2020 23:25:57 +0530 Subject: [PATCH] updating documentation --- .gitignore | 176 ++++++- C++/Algorithms/DivideAndConquer/README.md | 0 C++/Algorithms/DynamicPrograming/README.md | 0 C++/Algorithms/NumberTheory/README.md | 0 C++/Algorithms/Pattern Matching/README.md | 0 C++/Algorithms/README.md | 35 -- C++/Algorithms/RecursionAlgorithms/README.md | 0 C++/Algorithms/SearchingAlgorithms/README.md | 81 --- C++/Algorithms/Sieve Algorithms/README.md | 0 C++/Algorithms/SortingAlgorithms/README.md | 0 C++/Data Structure/Stacks/README.md | 16 - .../BackTrackingAlgorithms/README.md | 0 .../DeepLearningAlgorithms/README.md | 0 Python/Algorithms/DivideAndConquer/README.md | 0 Python/Algorithms/DynamicPrograming/README.md | 0 .../EularianPathAlgorithms/README.md | 0 .../MachineLearningAlgorithms/README.md | 0 Python/Algorithms/Maths/README.md | 1 - .../PathFindingAlgorithms/README.md | 0 .../Permutations_of_string/README.md | 0 Python/Algorithms/README.md | 21 +- .../Algorithms/RecursionAlgorithms/README.md | 0 .../Algorithms/SearchingAlgorithms/README.md | 81 --- Python/Algorithms/Sieve Algorithms/README.md | 21 - Python/Algorithms/SortingAlgorithms/README.md | 0 Python/Algorithms/SpiralMatrix/README.md | 0 .../__pycache__/linkedlist.cpython-37.pyc | Bin 2316 -> 0 bytes .../__pycache__/node.cpython-37.pyc | Bin 471 -> 0 bytes .../__pycache__/testlinkedlist.cpython-37.pyc | Bin 2889 -> 0 bytes Python/DataStructure/README.md | 0 README.md | 8 +- ...40b622142f1c98125abcfe89a76a661b0e8e343910 | 1 + docs/Gemfile | 30 ++ docs/Gemfile.lock | 83 +++ .../README.md => docs/_data/algorithm.csv | 0 .../README.md => docs/_data/ds.csv | 0 docs/algorithms/index.html | 6 + docs/algorithms/searchingalgorithm/index.html | 60 +++ docs/algorithms/sortingalgorithms/index.html | 5 + docs/datastructure/array/index.html | 6 + docs/datastructure/index.html | 7 + docs/datastructure/linkedlist/index.html | 5 + docs/index.html | 478 +----------------- 43 files changed, 401 insertions(+), 720 deletions(-) delete mode 100644 C++/Algorithms/DivideAndConquer/README.md delete mode 100644 C++/Algorithms/DynamicPrograming/README.md delete mode 100644 C++/Algorithms/NumberTheory/README.md delete mode 100644 C++/Algorithms/Pattern Matching/README.md delete mode 100644 C++/Algorithms/README.md delete mode 100644 C++/Algorithms/RecursionAlgorithms/README.md delete mode 100644 C++/Algorithms/SearchingAlgorithms/README.md delete mode 100644 C++/Algorithms/Sieve Algorithms/README.md delete mode 100644 C++/Algorithms/SortingAlgorithms/README.md delete mode 100644 C++/Data Structure/Stacks/README.md delete mode 100644 Python/Algorithms/BackTrackingAlgorithms/README.md delete mode 100644 Python/Algorithms/DeepLearningAlgorithms/README.md delete mode 100644 Python/Algorithms/DivideAndConquer/README.md delete mode 100644 Python/Algorithms/DynamicPrograming/README.md delete mode 100644 Python/Algorithms/EularianPathAlgorithms/README.md delete mode 100644 Python/Algorithms/MachineLearningAlgorithms/README.md delete mode 100644 Python/Algorithms/Maths/README.md delete mode 100644 Python/Algorithms/PathFindingAlgorithms/README.md delete mode 100644 Python/Algorithms/Permutations_of_string/README.md delete mode 100644 Python/Algorithms/RecursionAlgorithms/README.md delete mode 100644 Python/Algorithms/SearchingAlgorithms/README.md delete mode 100644 Python/Algorithms/Sieve Algorithms/README.md delete mode 100644 Python/Algorithms/SortingAlgorithms/README.md delete mode 100644 Python/Algorithms/SpiralMatrix/README.md delete mode 100644 Python/DataStructure/LinkedListDS/__pycache__/linkedlist.cpython-37.pyc delete mode 100644 Python/DataStructure/LinkedListDS/__pycache__/node.cpython-37.pyc delete mode 100644 Python/DataStructure/LinkedListDS/__pycache__/testlinkedlist.cpython-37.pyc delete mode 100644 Python/DataStructure/README.md create mode 100644 docs/.jekyll-cache/Jekyll/Cache/Jekyll--Cache/b7/9606fb3afea5bd1609ed40b622142f1c98125abcfe89a76a661b0e8e343910 create mode 100644 docs/Gemfile create mode 100644 docs/Gemfile.lock rename C++/Algorithms/BackTrackingAlgorithms/README.md => docs/_data/algorithm.csv (100%) rename C++/Algorithms/Bit Manipulation/README.md => docs/_data/ds.csv (100%) create mode 100644 docs/algorithms/index.html create mode 100644 docs/algorithms/searchingalgorithm/index.html create mode 100644 docs/algorithms/sortingalgorithms/index.html create mode 100644 docs/datastructure/array/index.html create mode 100644 docs/datastructure/index.html create mode 100644 docs/datastructure/linkedlist/index.html diff --git a/.gitignore b/.gitignore index 6ddd9b65..cc9e240c 100644 --- a/.gitignore +++ b/.gitignore @@ -1,3 +1,6 @@ +# Ignore site dir +_site/ + # Prerequisites *.d @@ -33,4 +36,175 @@ # Environment files **/__pycache__ -**/.vscode \ No newline at end of file +**/.vscode + +# Byte-compiled / optimized / DLL files +__pycache__/ +*.py[cod] +*$py.class + +# C extensions +*.so + +# Distribution / packaging +.Python +build/ +develop-eggs/ +dist/ +downloads/ +eggs/ +.eggs/ +lib/ +lib64/ +parts/ +sdist/ +var/ +wheels/ +pip-wheel-metadata/ +share/python-wheels/ +*.egg-info/ +.installed.cfg +*.egg +MANIFEST + +# PyInstaller +# Usually these files are written by a python script from a template +# before PyInstaller builds the exe, so as to inject date/other infos into it. +*.manifest +*.spec + +# Installer logs +pip-log.txt +pip-delete-this-directory.txt + +# Unit test / coverage reports +htmlcov/ +.tox/ +.nox/ +.coverage +.coverage.* +.cache +nosetests.xml +coverage.xml +*.cover +*.py,cover +.hypothesis/ +.pytest_cache/ + +# Translations +*.mo +*.pot + +# Django stuff: +*.log +local_settings.py +db.sqlite3 +db.sqlite3-journal + +# Flask stuff: +instance/ +.webassets-cache + +# Scrapy stuff: +.scrapy + +# Sphinx documentation +docs/_build/ + +# PyBuilder +target/ + +# Jupyter Notebook +.ipynb_checkpoints + +# IPython +profile_default/ +ipython_config.py + +# pyenv +.python-version + +# pipenv +# According to pypa/pipenv#598, it is recommended to include Pipfile.lock in version control. +# However, in case of collaboration, if having platform-specific dependencies or dependencies +# having no cross-platform support, pipenv may install dependencies that don't work, or not +# install all needed dependencies. +#Pipfile.lock + +# PEP 582; used by e.g. github.com/David-OConnor/pyflow +__pypackages__/ + +# Celery stuff +celerybeat-schedule +celerybeat.pid + +# SageMath parsed files +*.sage.py + +# Environments +.env +.env.test + +# parcel-bundler cache (https://parceljs.org/) +.cache + +# Next.js build output +.next + +# Nuxt.js build / generate output +.nuxt +dist + +# Gatsby files +.cache/ +# Comment in the public line in if your project uses Gatsby and *not* Next.js +# https://nextjs.org/blog/next-9-1#public-directory-support +# public + +# vuepress build output +.vuepress/dist + +# Serverless directories +.serverless/ + +# FuseBox cache +.fusebox/ + +# DynamoDB Local files +.dynamodb/ + +# TernJS port file +.tern-port + +# VSCode config +.vscode/ +.venv +env/ +venv/ +ENV/ +env.bak/ +venv.bak/ + +# Spyder project settings +.spyderproject +.spyproject + +# Rope project settings +.ropeproject + +# mkdocs documentation +/site + +# mypy +.mypy_cache/ +.dmypy.json +dmypy.json + +# Pyre type checker +.pyre/ + +# vscode +.vscode + +# exe files +*.exe \ No newline at end of file diff --git a/C++/Algorithms/DivideAndConquer/README.md b/C++/Algorithms/DivideAndConquer/README.md deleted file mode 100644 index e69de29b..00000000 diff --git a/C++/Algorithms/DynamicPrograming/README.md b/C++/Algorithms/DynamicPrograming/README.md deleted file mode 100644 index e69de29b..00000000 diff --git a/C++/Algorithms/NumberTheory/README.md b/C++/Algorithms/NumberTheory/README.md deleted file mode 100644 index e69de29b..00000000 diff --git a/C++/Algorithms/Pattern Matching/README.md b/C++/Algorithms/Pattern Matching/README.md deleted file mode 100644 index e69de29b..00000000 diff --git a/C++/Algorithms/README.md b/C++/Algorithms/README.md deleted file mode 100644 index ad8f9d23..00000000 --- a/C++/Algorithms/README.md +++ /dev/null @@ -1,35 +0,0 @@ -# [AlgorithmsImplementation](/ALGORITHM.md) - -Data Structure and Algorithm Implementation in Python. - -- [AlgorithmsImplementation](#algorithmsimplementation) - - [BackTrackingAlgorithms](#backtrackingalgorithms) - - [DeepLearningAlgorithms](#deeplearningalgorithms) - - [DivideAndConquer](#divideandconquer) - - [DynamicPrograming](#dynamicprograming) - - [GreedyAlgorithms](#greedyalgorithms) - - [MachineLearningAlgorithms](#machinelearningalgorithms) - - [PathFindingAlgorithms](#pathfindingalgorithms) - - [RecursionAlgorithms](#recursionalgorithms) - - [SearchingAlgorithms](#searchingalgorithms) - - [SortingAlgorithms](#sortingalgorithms) - -## BackTrackingAlgorithms - -## DeepLearningAlgorithms - -## DivideAndConquer - -## DynamicPrograming - -## GreedyAlgorithms - -## MachineLearningAlgorithms - -## PathFindingAlgorithms - -## RecursionAlgorithms - -## SearchingAlgorithms - -## SortingAlgorithms diff --git a/C++/Algorithms/RecursionAlgorithms/README.md b/C++/Algorithms/RecursionAlgorithms/README.md deleted file mode 100644 index e69de29b..00000000 diff --git a/C++/Algorithms/SearchingAlgorithms/README.md b/C++/Algorithms/SearchingAlgorithms/README.md deleted file mode 100644 index 19f51e76..00000000 --- a/C++/Algorithms/SearchingAlgorithms/README.md +++ /dev/null @@ -1,81 +0,0 @@ -

- -

-

- -## Introduction - -Searching for data stored in different data structures is a crucial part of pretty much every single application. - -There are many different algorithms available to utilize when searching, and each have different implementations and rely on different data structures to get the job done. - -Being able to choose a specific algorithm for a given task is a key skill for developers and can mean the difference between a fast, reliable and stable application and an application that crumbles from a simple request. - -* Linear Search -* Binary Search -* Jump Search -* Fibonacci Search -* Exponential Search -* Interpolation Search - -## Linear Search - -Linear search is one of the simplest searching algorithms, and the easiest to understand. We can think of it as a ramped-up version of our own implementation of Python's in operator. - -The algorithm consists of iterating over an array and returning the index of the first occurrence of an item once it is found. - -The time complexity of linear search is O(n), meaning that the time taken to execute increases with the number of items in our input list - -## Binary Search - -Binary search follows a divide and conquer methodology. It is faster than linear search but requires that the array be sorted before the algorithm is executed. - -Assuming that we're searching for a value val in a sorted array, the algorithm compares val to the value of the middle element of the array, which we'll call mid. - -* If mid is the element we are looking for (best case), we return its index. -* If not, we identify which side of mid val is more likely to be on based on whether val is smaller or greater than mid, and discard the other side of the array. -* We then recursively or iteratively follow the same steps, choosing a new value for mid, comparing it with val and discarding half of the possible matches in each iteration of the algorithm. - -We can only pick one possibility per iteration, and our pool of possible matches gets divided by two in each iteration. This makes the time complexity of binary search O(log n). - -## Jump Search - -Jump Search is similar to binary search in that it works on a sorted array, and uses a similar divide and conquer approach to search through it. - -It can be classified as an improvement of the linear search algorithm since it depends on linear search to perform the actual comparison when searching for a value. - -Given a sorted array, instead of searching through the array elements incrementally, we search in jumps. - -The time complexity of jump search is O(√n), where √n is the jump size, and n is the length of the list, placing jump search between the linear search and binary search algorithms in terms of efficiency. - -## Fibonacci Search - -Fibonacci search is another divide and conquer algorithm which bears similarities to both binary search and jump search. It gets its name because it uses Fibonacci numbers to calculate the block size or search range in each step. - -Fibonacci numbers start with zero and follow the pattern 0, 1, 1, 2, 3, 5, 8, 13, 21... where each element is the addition of the two numbers that immediately precede it. -The algorithm works with three Fibonacci numbers at a time. - -The time complexity for Fibonacci search is O(log n); the same as binary search. This means the algorithm is faster than both linear search and jump search in most cases. - -## Exponential Search - -Exponential search is another search algorithm that can be implemented quite simply in Python, compared to jump search and Fibonacci search which are both a bit complex. It is also known by the names galloping search, doubling search and Struzik search. - -Exponential search depends on binary search to perform the final comparison of values. The algorithm works by: - -* Determining the range where the element we're looking for is likely to be -* Using binary search for the range to find the exact index of the item - -Exponential search runs in O(log i) time, where i is the index of the item we are searching for. In its worst case, the time complexity is O(log n), when the last item is the item we are searching for (n being the length of the array). - -## Interpolation Search - -Interpolation search is another divide and conquer algorithm, similar to binary search. Unlike binary search, it does not always begin searching at the middle. - -The time complexity of interpolation search is O(log log n) when values are uniformly distributed. If values are not uniformly distributed, the worst-case time complexity is O(n), the same as linear search. - -Interpolation search works best on uniformly distributed, sorted arrays. Whereas binary search starts in the middle and always divides into two, interpolation search calculates the likely position of the element and checks the index, making it more likely to find the element in a smaller number of iterations. - -

- -

diff --git a/C++/Algorithms/Sieve Algorithms/README.md b/C++/Algorithms/Sieve Algorithms/README.md deleted file mode 100644 index e69de29b..00000000 diff --git a/C++/Algorithms/SortingAlgorithms/README.md b/C++/Algorithms/SortingAlgorithms/README.md deleted file mode 100644 index e69de29b..00000000 diff --git a/C++/Data Structure/Stacks/README.md b/C++/Data Structure/Stacks/README.md deleted file mode 100644 index d631dca1..00000000 --- a/C++/Data Structure/Stacks/README.md +++ /dev/null @@ -1,16 +0,0 @@ -# Stack :- - -> Stack is a linear data structure which follows a particular order in which the operations are performed. The order LIFO(Last in First Out).Insertion and deletion happens on the same end. For array based implementation of a stack, the push and pop operations take constant time - -- [Stack :-](#stack--) - - [function of Stack :-](#function-of-stack--) - -## function of Stack :- - -> Stack are work on LIFO method. where a new element is added at one end and element removed from that end only. - -- empty() - Returns wheather the stack is empty O(1) -- size() - Return the size of the stack O(1) -- top() - Returns a reference to the top most element of stack O(1) -- push() - Adds the element at the same end in stack O(1) -- pop() - Delete the top most element of the stack O(1) diff --git a/Python/Algorithms/BackTrackingAlgorithms/README.md b/Python/Algorithms/BackTrackingAlgorithms/README.md deleted file mode 100644 index e69de29b..00000000 diff --git a/Python/Algorithms/DeepLearningAlgorithms/README.md b/Python/Algorithms/DeepLearningAlgorithms/README.md deleted file mode 100644 index e69de29b..00000000 diff --git a/Python/Algorithms/DivideAndConquer/README.md b/Python/Algorithms/DivideAndConquer/README.md deleted file mode 100644 index e69de29b..00000000 diff --git a/Python/Algorithms/DynamicPrograming/README.md b/Python/Algorithms/DynamicPrograming/README.md deleted file mode 100644 index e69de29b..00000000 diff --git a/Python/Algorithms/EularianPathAlgorithms/README.md b/Python/Algorithms/EularianPathAlgorithms/README.md deleted file mode 100644 index e69de29b..00000000 diff --git a/Python/Algorithms/MachineLearningAlgorithms/README.md b/Python/Algorithms/MachineLearningAlgorithms/README.md deleted file mode 100644 index e69de29b..00000000 diff --git a/Python/Algorithms/Maths/README.md b/Python/Algorithms/Maths/README.md deleted file mode 100644 index fa54225e..00000000 --- a/Python/Algorithms/Maths/README.md +++ /dev/null @@ -1 +0,0 @@ -Decimal to N base value convertion program added. diff --git a/Python/Algorithms/PathFindingAlgorithms/README.md b/Python/Algorithms/PathFindingAlgorithms/README.md deleted file mode 100644 index e69de29b..00000000 diff --git a/Python/Algorithms/Permutations_of_string/README.md b/Python/Algorithms/Permutations_of_string/README.md deleted file mode 100644 index e69de29b..00000000 diff --git a/Python/Algorithms/README.md b/Python/Algorithms/README.md index e3681ef0..dc862031 100644 --- a/Python/Algorithms/README.md +++ b/Python/Algorithms/README.md @@ -1,4 +1,4 @@ -# Algorithm Implementation in Python +# Algorithm Implementation in Python List of Algorithms in Python contained in this repository @@ -14,8 +14,8 @@ List of Algorithms in Python contained in this repository - [Sorting Algorithms](#sortingalgorithms) - [Finding all permutation](#permutationalgorithms) - [Spiral Matrix](#SpiralMatrix) - -### Backtracking Algorithms: + +### Backtracking Algorithms: Backtracking is a technique for solving problems recursively by trying to build a solution incrementally, one piece at a time, removing those solutions that fail to satisfy the constraints of the problem at any point of time. Example of implementation- Soduku solving. @@ -24,14 +24,14 @@ Deep learning is part of machine learning, whose methods are based on artificial Examples include- CNN, RNN, LSTM, GAN, RBM, etc. ### Divide And Conquer: -Divide and Conquer is an algorithm design paradigm based on multi-branched recursion. A divide-and-conquer algorithm works by recursively breaking down a problem into two or more sub-problems of the same or related type, until these become simple enough to be solved directly. -Example of implementation- Quick Sort, Merge Sort. +Divide and Conquer is an algorithm design paradigm based on multi-branched recursion. A divide-and-conquer algorithm works by recursively breaking down a problem into two or more sub-problems of the same or related type, until these become simple enough to be solved directly. +Example of implementation- Quick Sort, Merge Sort. ### Dynamic Programing: Dynamic Programming is primarily an optimization over plain recursion. Wherever we see a recursive solution that has repeated calls for same inputs, we can optimize it using Dynamic Programming. The idea is to store the results of subproblems, so that we do not have to re-compute them when needed later. Examples of implementation- Knapsack, Longest Common Subsequence. -### Greedy Algorithms: +### Greedy Algorithms: A greedy algorithm is a simple, intuitive algorithm that is used in optimization problems. The algorithm makes the optimal choice at each step as it attempts to find the overall optimal way to solve the entire problem. Examples of implementation- Kruskal's algorithm, Prim's algorithm. @@ -40,20 +40,20 @@ A machine learning algorithm is a method that provides systems the ability to au Examples include- Linear Regression, Logistic Regression, Naïve Bayes, KNN, etc ### Path Finding Algorithms: -Pathfinding or pathing is the plotting, by a computer application, of the shortest route between two points. It is a more practical variant on solving mazes. +Pathfinding or pathing is the plotting, by a computer application, of the shortest route between two points. It is a more practical variant on solving mazes. Example of implemntation- A* search, Dijkstra's algorithm. ### Recursion Algorithms: Recursion is a method of solving a problem where the solution depends on solutions to smaller instances of the same problem. Such problems can generally be solved by iteration, but this needs to identify and index the smaller instances at programming time. Examples of implementation- Tower of Hanoi, Tree traversals, DFS. -### Searching Algorithms: -The searching algorithms are used to search or find one or more than one element from a dataset. These type of algorithms are used to find elements from a specific data structures, which maybe sequential or not. +### Searching Algorithms: +The searching algorithms are used to search or find one or more than one element from a dataset. These type of algorithms are used to find elements from a specific data structures, which maybe sequential or not. Examples of implementation- Binary Search, Linear Search, Fibonacci Search. ### Sorting Algorithms: A Sorting algorithm is an algorithm that puts elements of a list in a certain order. The most frequently used orders are numerical order and lexicographical order. Efficient sorting is important for optimizing the efficiency of other algorithms that require input data to be in sorted lists. -Examples of implementation- Quick Sort, Merge Sort. +Examples of implementation- Quick Sort, Merge Sort. ### Finding all permutation: In mathematics, a permutation of a set is, loosely speaking, an arrangement of its members into a sequence or linear order, or if the set is already ordered, a rearrangement of its elements. The word "permutation" also refers to the act or process of changing the linear order of an ordered set. @@ -61,4 +61,3 @@ Examples of implementation-Input : str = 'ABC' Output : ABC,ACB,BAC,BCA,CAB,CB ### Spiral Matrix: The Spiral Matrix problem takes a 2-Dimensional array of N-rows and M-columns as an input, and prints the elements of this matrix in spiral order. The spiral begins at the top left corner of the input matrix, and prints the elements it encounters, while looping towards the center of this matrix, in a clockwise manner. - diff --git a/Python/Algorithms/RecursionAlgorithms/README.md b/Python/Algorithms/RecursionAlgorithms/README.md deleted file mode 100644 index e69de29b..00000000 diff --git a/Python/Algorithms/SearchingAlgorithms/README.md b/Python/Algorithms/SearchingAlgorithms/README.md deleted file mode 100644 index 19f51e76..00000000 --- a/Python/Algorithms/SearchingAlgorithms/README.md +++ /dev/null @@ -1,81 +0,0 @@ -

- -

-

- -## Introduction - -Searching for data stored in different data structures is a crucial part of pretty much every single application. - -There are many different algorithms available to utilize when searching, and each have different implementations and rely on different data structures to get the job done. - -Being able to choose a specific algorithm for a given task is a key skill for developers and can mean the difference between a fast, reliable and stable application and an application that crumbles from a simple request. - -* Linear Search -* Binary Search -* Jump Search -* Fibonacci Search -* Exponential Search -* Interpolation Search - -## Linear Search - -Linear search is one of the simplest searching algorithms, and the easiest to understand. We can think of it as a ramped-up version of our own implementation of Python's in operator. - -The algorithm consists of iterating over an array and returning the index of the first occurrence of an item once it is found. - -The time complexity of linear search is O(n), meaning that the time taken to execute increases with the number of items in our input list - -## Binary Search - -Binary search follows a divide and conquer methodology. It is faster than linear search but requires that the array be sorted before the algorithm is executed. - -Assuming that we're searching for a value val in a sorted array, the algorithm compares val to the value of the middle element of the array, which we'll call mid. - -* If mid is the element we are looking for (best case), we return its index. -* If not, we identify which side of mid val is more likely to be on based on whether val is smaller or greater than mid, and discard the other side of the array. -* We then recursively or iteratively follow the same steps, choosing a new value for mid, comparing it with val and discarding half of the possible matches in each iteration of the algorithm. - -We can only pick one possibility per iteration, and our pool of possible matches gets divided by two in each iteration. This makes the time complexity of binary search O(log n). - -## Jump Search - -Jump Search is similar to binary search in that it works on a sorted array, and uses a similar divide and conquer approach to search through it. - -It can be classified as an improvement of the linear search algorithm since it depends on linear search to perform the actual comparison when searching for a value. - -Given a sorted array, instead of searching through the array elements incrementally, we search in jumps. - -The time complexity of jump search is O(√n), where √n is the jump size, and n is the length of the list, placing jump search between the linear search and binary search algorithms in terms of efficiency. - -## Fibonacci Search - -Fibonacci search is another divide and conquer algorithm which bears similarities to both binary search and jump search. It gets its name because it uses Fibonacci numbers to calculate the block size or search range in each step. - -Fibonacci numbers start with zero and follow the pattern 0, 1, 1, 2, 3, 5, 8, 13, 21... where each element is the addition of the two numbers that immediately precede it. -The algorithm works with three Fibonacci numbers at a time. - -The time complexity for Fibonacci search is O(log n); the same as binary search. This means the algorithm is faster than both linear search and jump search in most cases. - -## Exponential Search - -Exponential search is another search algorithm that can be implemented quite simply in Python, compared to jump search and Fibonacci search which are both a bit complex. It is also known by the names galloping search, doubling search and Struzik search. - -Exponential search depends on binary search to perform the final comparison of values. The algorithm works by: - -* Determining the range where the element we're looking for is likely to be -* Using binary search for the range to find the exact index of the item - -Exponential search runs in O(log i) time, where i is the index of the item we are searching for. In its worst case, the time complexity is O(log n), when the last item is the item we are searching for (n being the length of the array). - -## Interpolation Search - -Interpolation search is another divide and conquer algorithm, similar to binary search. Unlike binary search, it does not always begin searching at the middle. - -The time complexity of interpolation search is O(log log n) when values are uniformly distributed. If values are not uniformly distributed, the worst-case time complexity is O(n), the same as linear search. - -Interpolation search works best on uniformly distributed, sorted arrays. Whereas binary search starts in the middle and always divides into two, interpolation search calculates the likely position of the element and checks the index, making it more likely to find the element in a smaller number of iterations. - -

- -

diff --git a/Python/Algorithms/Sieve Algorithms/README.md b/Python/Algorithms/Sieve Algorithms/README.md deleted file mode 100644 index 6c45bb60..00000000 --- a/Python/Algorithms/Sieve Algorithms/README.md +++ /dev/null @@ -1,21 +0,0 @@ -# Algorithms - -- [Algorithms](#algorithms) - - [Sieve of Eratosthenes](#sieve-of-eratosthenes) - - [Sieve of Atkin](#sieve-of-atkin) - -## Sieve of Eratosthenes - -Sieve of Eratosthenes is a simple and ancient algorithm used to find the prime numbers up to any given limit. It is one of the most efficient ways to find small prime numbers. - -In the following algorithm, the number 0 represents a composite number. - -- To find out all primes under nn, generate a list of all integers from 2 to n. (Note: 1 is not prime) -- Start with a smallest prime number, ie p = 2. -- Mark all the multiples of pp which are less than nn as composite. To do this, mark the value of the numbers (multiples of pp) in the generated list as 0. Do not mark pp itself as composite. -- Assign the value of pp to the next prime. The next prime is the next non-zero number in the list which is greater than p. -- Repeat the process until p <= n**1/2 - -## Sieve of Atkin - -> The `Sieve of Atkin` is a modern algorithm for finding all prime number upto a specified integer. diff --git a/Python/Algorithms/SortingAlgorithms/README.md b/Python/Algorithms/SortingAlgorithms/README.md deleted file mode 100644 index e69de29b..00000000 diff --git a/Python/Algorithms/SpiralMatrix/README.md b/Python/Algorithms/SpiralMatrix/README.md deleted file mode 100644 index e69de29b..00000000 diff --git a/Python/DataStructure/LinkedListDS/__pycache__/linkedlist.cpython-37.pyc b/Python/DataStructure/LinkedListDS/__pycache__/linkedlist.cpython-37.pyc deleted file mode 100644 index a305aae75858ad73fd9a2328dbc2d658aadf0fdb..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 2316 zcma)7&u`;I6rLG7iR-56wy^B7{7|^S8ZA+8psK2Np@>TrAw}$>ZmN-$Fz?R?qdNc36?|pCl<=UFd@cj69BL8eK z_7@FikA==deCdY}iYXqk5kKIZeZ!Pc)(fVr3vnQn-D6(uHFTKAOS_w>U_gV}BhYz> zFWrX-*a24zo467$*ny=iWuvuKP1VuXR6{vv>uN>0Xd7x(HPJe1O|{UjsC9JTC({SzVsak#R?|jJ|t{I3dOKnbTz4ZR%ssvzA77oWE^LK zF73<@BMK!Aq96WX+JV-ac(C37E)8_r_v0*y`+Lb?JPP7$Iu4Vu@An@?&k`MGN2Byn ztoHoO?`3*C$i_P8fBQT;qHR|uFTLOE^&=BXgitys&r3(jFb*>*DL-i)g7G@u{H@DP zote%&c8Z&Vq6DOEh=L8-grC1%aDA`fkFi+rA)oM5=Lv8D3cTwHZ9}uPN`Pz&Qmv zyyOLc#eZX}{<{S?8{J$yJ-l{Y4=0%%Kf{5CtqIRed>8x|aSB=*$30P6X@;~aV2^?5 zY#~;#bSbts?hb)JNJb~Scj;ULv(EC5uKWJ+3M4DMFe` zb;&^K%uacqtdRSRz*($;nZ|(9MGqk}M`s6vg4ski{yDA%$ubZNBoiQ@NIxymN@1iG zw`i^q(ynHwx5R66OVo4?M`QxBOs!FDI=11e;CY;J<7~|^5kZWIOA7M{Q z@KPv_DQZVJJioI5-lG0IgX9N&ChcUNYN#qM_aZR_0Zj-pYYD~}EHZbD!Pnb8K58J(GcmG10+xb~N_b?wT9 z;L3AbEA_%T_c8a(%()m0`V8^pNpBKX2Sv%Ly)=dE1u0 zwJN_}_&Le`4X2g9S8`f8KbhqkzaBm;x>$%xS6+w%`f&teyvLsh9F2s5d8eAL_M%9qQ4HgJQsu$(XPEG}+{xUGi>8(8Xt)C(cRr39ugx Cjc%L( diff --git a/Python/DataStructure/LinkedListDS/__pycache__/testlinkedlist.cpython-37.pyc b/Python/DataStructure/LinkedListDS/__pycache__/testlinkedlist.cpython-37.pyc deleted file mode 100644 index 09f8c37bc590915fe7a33330dfc7594f7cb580b8..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 2889 zcmb_eTW=Fb6rS0eH;!XMpwNP7SE5DQ%1t2`a}h$J3FQS@Eup2_*jlYT(_~@2hS@P~ ztnd`x`xl(Y{-u5Glm9}Wdd`knd$A#=Vl96&dpT$3`)1BL^TX0onZWgI*z+Hj2>AzZ z-d+ZDw&0)K0bqpDh2H<|fd6Ln4o)(N3tvrAlS z2==7m(zN_2jGuG%C`@D=(RM;Y-nMw#}8c)A+HGnmONxHnme+0a^S zft8^xu|-ya)@Dnr3he?r!+i| z$!mH<22^TC^q4Yw0$dpZFIuCo?X_H8pi#OQBncPt!OLC{rFtTTtEEQ5qu*0Aih$zZ zMA-1%zhe7N^B4FsX$GyVv2d9NmZAUJx|zNBdn7%7adFKW00D40fgHwPjE6 z=1+(60L=;y$4qv1n-Zu+nY1|W>Wjnl0zUH9GiadCJ1^uR&L=^(gj%%!O;M87**5K& zN_`DJMoQ5EYD6gk%`~ZJnrXRadSi$V`ug6DmTM^GDq)Pu`H2jK6gVGY0=Sy6un!wi zNtfv-7T`9$GBvqL9~Jl{L0jZirv2J!%qERz6I=ynQv{K!_6}7&r)o6BB3KP^cl52j zwVIPt7C6KCm|p!LQ(yiOw)t7`mf&J4zQB0xV;CzZpOE)Zhp7y4A%XXL&DqG8x;#>v z$80|Om)}PpJY0kUinPC-lQtNC6kRP}W?dTDjxH?oGE79^A^_cunzP<=&1`3j6?`%O zT3`DBSzjLTScS-yDc+m&^PceYDJ4Mm0(E#-f{cBp!(4&=UJ0_~pe7HiclCcuQ1p{a zfIAi^nC1OCbX2hac}YSxJEl9NRecTlf1n*@0snIODdsoGZUf^4YG5Apkl(O`_E)bv z-`#U=Agm#*BWxgSBGeIXBHTi_J=!p-DS~*Pt9^sh@oXuAS5PcCl$ksmrZiN!5My2? z#OXL08HVw`3t#1NQl(YeKQ&Iq#s!5i_ht(H2%Y&9lEw-BYZy#Y z@5e!h`+i#X{Z5zlBJ5XuAJ0hYjX>?i62cjTa|q`VK128d;Y)iG;oK_>`nhA~tf{4&XF`UWEgY8fZ9ctotal contributors

- + - [AlgorithmsAndDataStructure](#algorithmsanddatastructure) - [Introduction](#introduction) - [Data Structure](#data-structure) @@ -46,7 +46,7 @@ We are now open to everyone again! Data structures & Algorithms are an essential part of programming. It comes under the fundamentals of computer science. It gives us the advantage of writing better and efficient code in less time. It is a key topic when it comes to Software Engineering interview questions so as developers, we must have knowledge of Data Structure and Algorithms -:star2: Star it +:star2: Star it :fork_and_knife:Fork it :handshake: Contribute to it! @@ -62,7 +62,7 @@ An algorithm is a set of instructions that are used to accomplish a task, such a Algorithms are not limited to computers. They are like a set of step-by-step instructions or an even a recipe, containing things you need, steps to do, the order to do them, conditions to look for, and expected results. -## Languages +## Languages - C++ - Python @@ -153,7 +153,7 @@ Check [Contribution](/CONTRIBUTING.md) Guide Before Contribution. - Create separate issues for Python and C++. - You can only work on issues that you have been assigned to. -- Use Flake8 locally for linting Python Code. `pip install flake8`. +- Use Flake8 locally for linting Python Code. `pip install flake8`. (We have linting checks so if your code fails it we will not merge the PR.) ## Authors and acknowledgment diff --git a/docs/.jekyll-cache/Jekyll/Cache/Jekyll--Cache/b7/9606fb3afea5bd1609ed40b622142f1c98125abcfe89a76a661b0e8e343910 b/docs/.jekyll-cache/Jekyll/Cache/Jekyll--Cache/b7/9606fb3afea5bd1609ed40b622142f1c98125abcfe89a76a661b0e8e343910 new file mode 100644 index 00000000..635cf06f --- /dev/null +++ b/docs/.jekyll-cache/Jekyll/Cache/Jekyll--Cache/b7/9606fb3afea5bd1609ed40b622142f1c98125abcfe89a76a661b0e8e343910 @@ -0,0 +1 @@ +I"o{"source"=>"/home/codeperfectplus/Documents/PyContributors/AlgorithmsAndDataStructure/docs", "destination"=>"/home/codeperfectplus/Documents/PyContributors/AlgorithmsAndDataStructure/docs/_site", "collections_dir"=>"", "cache_dir"=>".jekyll-cache", "plugins_dir"=>"_plugins", "layouts_dir"=>"_layouts", "data_dir"=>"_data", "includes_dir"=>"_includes", "collections"=>{"posts"=>{"output"=>true, "permalink"=>"/:categories/:year/:month/:day/:title:output_ext"}}, "safe"=>false, "include"=>[".htaccess"], "exclude"=>[".sass-cache", ".jekyll-cache", "gemfiles", "Gemfile", "Gemfile.lock", "node_modules", "vendor/bundle/", "vendor/cache/", "vendor/gems/", "vendor/ruby/"], "keep_files"=>[".git", ".svn"], "encoding"=>"utf-8", "markdown_ext"=>"markdown,mkdown,mkdn,mkd,md", "strict_front_matter"=>false, "show_drafts"=>nil, "limit_posts"=>0, "future"=>false, "unpublished"=>false, "whitelist"=>[], "plugins"=>[], "markdown"=>"kramdown", "highlighter"=>"rouge", "lsi"=>false, "excerpt_separator"=>"\n\n", "incremental"=>false, "detach"=>false, "port"=>"4000", "host"=>"127.0.0.1", "baseurl"=>nil, "show_dir_listing"=>false, "permalink"=>"date", "paginate_path"=>"/page:num", "timezone"=>nil, "quiet"=>false, "verbose"=>false, "defaults"=>[], "liquid"=>{"error_mode"=>"warn", "strict_filters"=>false, "strict_variables"=>false}, "kramdown"=>{"auto_ids"=>true, "toc_levels"=>[1, 2, 3, 4, 5, 6], "entity_output"=>"as_char", "smart_quotes"=>"lsquo,rsquo,ldquo,rdquo", "input"=>"GFM", "hard_wrap"=>false, "guess_lang"=>true, "footnote_nr"=>1, "show_warnings"=>false}, "livereload_port"=>35729, "serving"=>true, "watch"=>true, "url"=>"http://localhost:4000"}:ET \ No newline at end of file diff --git a/docs/Gemfile b/docs/Gemfile new file mode 100644 index 00000000..d5f7936e --- /dev/null +++ b/docs/Gemfile @@ -0,0 +1,30 @@ +source "https://rubygems.org" +# Hello! This is where you manage which Jekyll version is used to run. +# When you want to use a different version, change it below, save the +# file and run `bundle install`. Run Jekyll with `bundle exec`, like so: +# +# bundle exec jekyll serve +# +# This will help ensure the proper Jekyll version is running. +# Happy Jekylling! +gem "jekyll", "~> 4.1.1" +# This is the default theme for new Jekyll sites. You may change this to anything you like. +gem "minima", "~> 2.5" +# If you want to use GitHub Pages, remove the "gem "jekyll"" above and +# uncomment the line below. To upgrade, run `bundle update github-pages`. +# gem "github-pages", group: :jekyll_plugins +# If you have any plugins, put them here! +group :jekyll_plugins do + gem "jekyll-feed", "~> 0.12" +end + +# Windows and JRuby does not include zoneinfo files, so bundle the tzinfo-data gem +# and associated library. +platforms :mingw, :x64_mingw, :mswin, :jruby do + gem "tzinfo", "~> 1.2" + gem "tzinfo-data" +end + +# Performance-booster for watching directories on Windows +gem "wdm", "~> 0.1.1", :platforms => [:mingw, :x64_mingw, :mswin] +gem 'jekyll-sitemap' diff --git a/docs/Gemfile.lock b/docs/Gemfile.lock new file mode 100644 index 00000000..69613269 --- /dev/null +++ b/docs/Gemfile.lock @@ -0,0 +1,83 @@ +GEM + remote: https://rubygems.org/ + specs: + addressable (2.7.0) + public_suffix (>= 2.0.2, < 5.0) + colorator (1.1.0) + concurrent-ruby (1.1.7) + em-websocket (0.5.2) + eventmachine (>= 0.12.9) + http_parser.rb (~> 0.6.0) + eventmachine (1.2.7) + ffi (1.13.1) + forwardable-extended (2.6.0) + http_parser.rb (0.6.0) + i18n (1.8.5) + concurrent-ruby (~> 1.0) + jekyll (4.1.1) + addressable (~> 2.4) + colorator (~> 1.0) + em-websocket (~> 0.5) + i18n (~> 1.0) + jekyll-sass-converter (~> 2.0) + jekyll-watch (~> 2.0) + kramdown (~> 2.1) + kramdown-parser-gfm (~> 1.0) + liquid (~> 4.0) + mercenary (~> 0.4.0) + pathutil (~> 0.9) + rouge (~> 3.0) + safe_yaml (~> 1.0) + terminal-table (~> 1.8) + jekyll-feed (0.15.0) + jekyll (>= 3.7, < 5.0) + jekyll-sass-converter (2.1.0) + sassc (> 2.0.1, < 3.0) + jekyll-seo-tag (2.6.1) + jekyll (>= 3.3, < 5.0) + jekyll-sitemap (1.4.0) + jekyll (>= 3.7, < 5.0) + jekyll-watch (2.2.1) + listen (~> 3.0) + kramdown (2.3.0) + rexml + kramdown-parser-gfm (1.1.0) + kramdown (~> 2.0) + liquid (4.0.3) + listen (3.2.1) + rb-fsevent (~> 0.10, >= 0.10.3) + rb-inotify (~> 0.9, >= 0.9.10) + mercenary (0.4.0) + minima (2.5.1) + jekyll (>= 3.5, < 5.0) + jekyll-feed (~> 0.9) + jekyll-seo-tag (~> 2.1) + pathutil (0.16.2) + forwardable-extended (~> 2.6) + public_suffix (4.0.6) + rb-fsevent (0.10.4) + rb-inotify (0.10.1) + ffi (~> 1.0) + rexml (3.2.4) + rouge (3.23.0) + safe_yaml (1.0.5) + sassc (2.4.0) + ffi (~> 1.9) + terminal-table (1.8.0) + unicode-display_width (~> 1.1, >= 1.1.1) + unicode-display_width (1.7.0) + +PLATFORMS + ruby + +DEPENDENCIES + jekyll (~> 4.1.1) + jekyll-feed (~> 0.12) + jekyll-sitemap + minima (~> 2.5) + tzinfo (~> 1.2) + tzinfo-data + wdm (~> 0.1.1) + +BUNDLED WITH + 2.1.4 diff --git a/C++/Algorithms/BackTrackingAlgorithms/README.md b/docs/_data/algorithm.csv similarity index 100% rename from C++/Algorithms/BackTrackingAlgorithms/README.md rename to docs/_data/algorithm.csv diff --git a/C++/Algorithms/Bit Manipulation/README.md b/docs/_data/ds.csv similarity index 100% rename from C++/Algorithms/Bit Manipulation/README.md rename to docs/_data/ds.csv diff --git a/docs/algorithms/index.html b/docs/algorithms/index.html new file mode 100644 index 00000000..abf522d5 --- /dev/null +++ b/docs/algorithms/index.html @@ -0,0 +1,6 @@ +layout : default +title : Algorithms | PyContributors +description : Algorithms Description +image : +--- +## algorithm page diff --git a/docs/algorithms/searchingalgorithm/index.html b/docs/algorithms/searchingalgorithm/index.html new file mode 100644 index 00000000..20a367b1 --- /dev/null +++ b/docs/algorithms/searchingalgorithm/index.html @@ -0,0 +1,60 @@ +layout : default +title : Searching Algorithm | PyContributors +description : Algorithms Description +image : +--- +

+ +

+

+ +

Introduction

+

Searching for data stored in different data structures is a crucial part of pretty much every single application.

+

There are many different algorithms available to utilize when searching, and each have different implementations and rely on different data structures to get the job done.

+

Being able to choose a specific algorithm for a given task is a key skill for developers and can mean the difference between a fast, reliable and stable application and an application that crumbles from a simple request.

+
    +
  • Linear Search
    • +
  • Binary Search
    • +
  • Jump Search
    • +
  • Fibonacci Search
    • +
  • Exponential Search
    • +
  • Interpolation Search
    • +
+ +

Linear search is one of the simplest searching algorithms, and the easiest to understand. We can think of it as a ramped-up version of our own implementation of Python's in operator.

+

The algorithm consists of iterating over an array and returning the index of the first occurrence of an item once it is found.

+

The time complexity of linear search is O(n), meaning that the time taken to execute increases with the number of items in our input list

+ +

Binary search follows a divide and conquer methodology. It is faster than linear search but requires that the array be sorted before the algorithm is executed.

+

Assuming that we're searching for a value val in a sorted array, the algorithm compares val to the value of the middle element of the array, which we'll call mid.

+
    +
  • If mid is the element we are looking for (best case), we return its index.
    • +
  • If not, we identify which side of mid val is more likely to be on based on whether val is smaller or greater than mid, and discard the other side of the array.
    • +
  • We then recursively or iteratively follow the same steps, choosing a new value for mid, comparing it with val and discarding half of the possible matches in each iteration of the algorithm.
    • +
+

We can only pick one possibility per iteration, and our pool of possible matches gets divided by two in each iteration. This makes the time complexity of binary search O(log n).

+ +

Jump Search is similar to binary search in that it works on a sorted array, and uses a similar divide and conquer approach to search through it.

+

It can be classified as an improvement of the linear search algorithm since it depends on linear search to perform the actual comparison when searching for a value.

+

Given a sorted array, instead of searching through the array elements incrementally, we search in jumps.

+

The time complexity of jump search is O(√n), where √n is the jump size, and n is the length of the list, placing jump search between the linear search and binary search algorithms in terms of efficiency.

+ +

Fibonacci search is another divide and conquer algorithm which bears similarities to both binary search and jump search. It gets its name because it uses Fibonacci numbers to calculate the block size or search range in each step.

+

Fibonacci numbers start with zero and follow the pattern 0, 1, 1, 2, 3, 5, 8, 13, 21... where each element is the addition of the two numbers that immediately precede it. +The algorithm works with three Fibonacci numbers at a time.

+

The time complexity for Fibonacci search is O(log n); the same as binary search. This means the algorithm is faster than both linear search and jump search in most cases.

+ +

Exponential search is another search algorithm that can be implemented quite simply in Python, compared to jump search and Fibonacci search which are both a bit complex. It is also known by the names galloping search, doubling search and Struzik search.

+

Exponential search depends on binary search to perform the final comparison of values. The algorithm works by:

+
    +
  • Determining the range where the element we're looking for is likely to be
    • +
  • Using binary search for the range to find the exact index of the item
    • +
+

Exponential search runs in O(log i) time, where i is the index of the item we are searching for. In its worst case, the time complexity is O(log n), when the last item is the item we are searching for (n being the length of the array).

+ +

Interpolation search is another divide and conquer algorithm, similar to binary search. Unlike binary search, it does not always begin searching at the middle.

+

The time complexity of interpolation search is O(log log n) when values are uniformly distributed. If values are not uniformly distributed, the worst-case time complexity is O(n), the same as linear search.

+

Interpolation search works best on uniformly distributed, sorted arrays. Whereas binary search starts in the middle and always divides into two, interpolation search calculates the likely position of the element and checks the index, making it more likely to find the element in a smaller number of iterations.

+

+ +

diff --git a/docs/algorithms/sortingalgorithms/index.html b/docs/algorithms/sortingalgorithms/index.html new file mode 100644 index 00000000..9e01e162 --- /dev/null +++ b/docs/algorithms/sortingalgorithms/index.html @@ -0,0 +1,5 @@ +layout : default +title : Sorting Algorithm | PyContributors +description : Algorithms Description +image : +--- diff --git a/docs/datastructure/array/index.html b/docs/datastructure/array/index.html new file mode 100644 index 00000000..1559153e --- /dev/null +++ b/docs/datastructure/array/index.html @@ -0,0 +1,6 @@ +layout : default +title : Array | PyContributors +description : array description +image : +--- +array diff --git a/docs/datastructure/index.html b/docs/datastructure/index.html new file mode 100644 index 00000000..789bc828 --- /dev/null +++ b/docs/datastructure/index.html @@ -0,0 +1,7 @@ +layout : default +title : Data Structure | PyContributors +description : Data Structure Description +image : +--- + +data strucutre page diff --git a/docs/datastructure/linkedlist/index.html b/docs/datastructure/linkedlist/index.html new file mode 100644 index 00000000..331e7f0e --- /dev/null +++ b/docs/datastructure/linkedlist/index.html @@ -0,0 +1,5 @@ +layout : default +title : LinkedList | PyContributors +description : Linked List Description +image : +--- diff --git a/docs/index.html b/docs/index.html index 8ae4e5e7..069ca099 100644 --- a/docs/index.html +++ b/docs/index.html @@ -1,472 +1,12 @@ -

- website title image -

👉 A Collection of Algorithm And Data Structures in Cpp and Python 👈

-

- -

- - -github stars -github forks -code size +layout : default +title : Algo&Ds | PyContributors +description : Data Structure and Algorithms +image : https://images.pexels.com/photos/265152/pexels-photo-265152.jpeg?auto=compress&cs=tinysrgb&dpr=2&h=650&w=940 +--- +

+ website title image +

👉 A Collection of Algorithm And Data Structures in Cpp and Python 👈

-

-open issues -closed issues -open pull request -closed pull request -

-

-hacktoberfest -MIT license -

-

-discord invite -last contributions -total contributors -

- - -- [AlgorithmsAndDataStructure](#algorithmsanddatastructure) - - [Introduction](#introduction) - - [Data Structure](#data-structure) - - [Algorithms](#algorithms) - - [Support](#support) - - [Contributing](#contributing) - - [Authors and acknowledgment](#authors-and-acknowledgment) - - [License](#license) - - [Project status](#project-status) - - [Maintainers](#maintainers) - -#Note -~~We have enabled an Interaction Limit till Monday(5th October). This is because we received a lot of duplicate issues and spam PRs, so we need some time to label them as invalid.~~ -We are now open to everyone again! - -## Introduction - -Data structures & Algorithms are an essential part of programming. It comes under the fundamentals of computer science. It gives us the advantage of writing better and efficient code in less time. It is a key topic when it comes to Software Engineering interview questions so as developers, we must have knowledge of Data Structure and Algorithms - -:star2: Star it -:fork_and_knife:Fork it -:handshake: Contribute to it! - - -## Data Structure - -In computer science, a data structure is a data organization, management, and storage format that enables efficient access and modification. -Data structure is a way or a format how your data is stored in memory for effecient usage and retrieval. - -## Algorithms - -An algorithm is a set of instructions that are used to accomplish a task, such as finding the largest number in a list, removing all the red cards from a deck of playing cards, sorting a collection of names, figuring out an average movie rating from just your friend's opinion - -Algorithms are not limited to computers. They are like a set of step-by-step instructions or an even a recipe, containing things you need, steps to do, the order to do them, conditions to look for, and expected results. - -## Languages -- C++ -- Python - -## Support -Check [Contribution](/CONTRIBUTING.md) Guide Before Contribution. -## Project Progress - -

Data Structures

 -
- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
Data StructureC++PythonStatus/Remarks
Linked ListYesYesBeing improved #23
SetsYesYesImplemented
StackYesIn progress #13
QueueIn progress #7In progress #12
- -
- -

Algorithms

 -
- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
AlgorithmC++PythonRemarks
Searching
Binary SearchNoIn progress #9
Jump SearchIn progress #39In progress #10
Fibonacci SearchNoIn progress #11
Sorting
Selection SortIn progress #29In progress #30
Bubble SortYesYes
Insertion SortIn progress #2Yes
Merge SortIn progress #3Yes
Quick SortIn progress #4Yes
Heap SortIn progress #5In progress #6
Radix SortIn progress #63Yes
Recursion
Fibonacci NumbersNoYes
Fibonacci ListNoYes
FactorsNoYes
RecursionNoYes
Recursive SumNoYes
Sieve
Sieve of ErosothenesNoYes
Dynamic Programming
Knapsack ProblemNoYes
Longest Common SubsequenceNoYes
Longest Increasing SubsequenceNoYes
Merge SortNoYesDuplicate
Fibonacci NumberNoYesDuplicate
Naive Pattern SearchIn progress #18In progress #17
Rabin-Karp AlgorithmNo
Backtracking
Suduko SolverIn progress #21No
The Knight's TourIn progress #33In progress #32
Subset SumIn progress #36In progress #35
Deep Learning
Activation FunctionNoYes
Feed Forward Normal FunctionNoYes
LayersNoYes
Loss FunctionNoYes
OptimizersNoYes
Machine Learning
Gradient DescentNoYes
Linear RegressionNoYes
Logistic RegressionNoYes
Decision TreeNoIn progress #37
K-Nearest NeighboursNoIn progress #38
-
- -

Contributing

- -Before submitting a bug, please do the following: -Check [Contribution](/CONTRIBUTING.md) Guide Before Contribution. - -- Create separate issues for Python and C++. -- You can only work on issues that you have been assigned to. -- Use Flake8 locally for linting Python Code. `pip install flake8`. - (We have linting checks so if your code fails it we will not merge the PR.) - -## Authors and acknowledgment - -Show your appreciation to those who have contributed to the project. - -## [License](/LICENSE) - -For open-source projects, Under [MIT License](/LICENSE). - -

Maintainers

- -- [CodePerfectPlus](https://github.com/codePerfectPlus) -- [ExpressHermes](https://github.com/ExpressHermes) -- [Ayush Modi](https://github.com/hot9cups) -- [rex_divakar](https://github.com/rexdivakar) -- [Shubham Pawar](https://github.com/shubham5351) -- [Shantanu Kale](https://github.com/SSKale1) - -

-built by developers -

+

This page is currently under construction