Metadata-Version: 2.1
Name: EasyDSA
Version: 0.0.2
Summary: A Data Structures and Algorithms collection written in Pyhton which helps developers in implementing fast and efficient algorithms
Home-page: https://github.com/mad-skull/EasyDSA.git
Author: Deep Awasthi
Author-email: da.madskull@gmail.com
License: UNKNOWN
Description: # Python EasyDSA
        A Data structure collection package written in Python which helps developers in implementing fast and efficient algorithms.
        
        
        ## Package
        The Pypi [EasyDSA](https://github.com/mad-skull/EasyDSA.git) package can be found [here](https://github.com/mad-skull/EasyDSA.git)
        
        ## Getting Started (More Will Be Added Soon)
        The datastructure_collection has three data structure classes :
        
        * 1. [BinarySearchTree](https://github.com/mad-skull/EasyDSA.git)
        
        * 2. [HashMap](https://github.com/mad-skull/EasyDSA.git)
        
        * 3. [LinkedList](https://github.com/mad-skull/EasyDSA.git)
        
        I Look forward to add more datastructures and algorithms in the future.
        
        ## Installation
        
        Run the following to install package :
        
        ```bash
        pip install EasyDSA
        ```
        ## Usage
        
        [Example](https://github.com/mad-skull/EasyDSA/blob/master/tests/datastructure_example.py)
        
        To use this package :
        
        ```python
        from EasyDSA import BinarySearchTree
        
        from EasyDSA import HashMap
        
        from EasyDSA import LinkedList
        ```
        
        ## Binary Search Tree
        The Binary Search Tree operations and the time complexities are shown in the table below:
        
        | Operation                 | Best Case     |  Worst Case   |  
        | -------------             |:-------------:|:-------------:|
        | tree = BinarySearchTree() | O(1)          | O(1)          |
        |                           |               |               |
        | tree.add(key, value)      | O(logN)       | O(N)          | 
        | tree.remove(key)          | O(logN)       | O(N)          |
        | tree.valueOf(key)         | O(logN)       | O(N)          |
        | tree.isEmpty()            | O(1)          | O(1)          |
        | tree.minValue()           | O(logN)       | O(N)          |
        | tree.maxValue()           | O(logN)       | O(N)          |
        | n = len(tree)             | O(1)          | O(1)          |
        | x in tree                 | O(logN)       | O(N)          |
        | traversal                 | O(N)          | O(N)          |
        
        As seen from the table above the Binary Search Tree has an advantage over a Linear List in terms of its searching mechanism the tree will be to somewhat sorted where the left elements of a node are less that the elements of a right node, thus giving it a Best case runtime of O(logN) as compared to a List search of O(N).
        The Worst Case of a Binary Search Tree O(N) occurs when the elements of the tree are ordered linearly ie (elements are inserted with increasing order)
        * **NB** The add,remove,minValue,maxValue and __contains__ ie "in", valueOf operators uses the search mechanism to locate the target.
        
        The Worst Case of a BinarySearchTree can however be improved by implementing a **Balanced Search Tree** with datastructures like **(AVL trees, splay trees, and red-black trees)**  which i however shall add in the future.
        
        ### Example BinarySearchTree
        ```python
        
        #import the BinarySearchTree Class
        from EasyDSA import BinarySearchTree
        
        #Instantiate BinarySearchTree object
        tree = BinarySearchTree()
        
        tree.add(1,"Orange")
        tree.add(4,"Banana")
        tree.add(7,"Apple")
        tree.add(2,"Tomato")
        
        
        for i in tree:
            print(i) #Prints the sorted List of tuples contaiing the key, value pairs
        
        tree.remove(4) #this removes the Banana node from the tree
        print(len(tree)) #this returns a length of 3 since the Banana node was removed
        
        ```
        ## Hash Map
        The [HashMap](https://pypi.org/project/EasyDSA/) is the most commonly used data structure in solving  big data and maping problems. In most datastructure collection ,searching is the most important operation, and as such we need to do it fast and efficiently. Unilike most datastructures like Lists, Trees which are based on on key comparison when searching for a target, the [Hashmap]() uses a concept of **hashing** the keys upon searching which run in constant time O(1) to locate an index of a specific key.
        I have used the concept of **double hashing** in implemnenting the hashing algorithm and **closed hashing/open addressing** for **Probing** . The hashing algorithm is as follows:
        ```python
        '''
            def _double_hashing(self,k):
                double hashing reduces clusters primary and secondary thus reducing collisions
                Find the next slot by probing
                slot = (position + i ) % M  whrere i = 1,2,3 .. M-1 ; position = index position index to which the key was originally mapped by the hash
                function DOUBLE HASHING IS AS FOLLOWS:
                slot = (position + i ∗ hp(key)) % M
                hp(key) = 1 + key % P         P = constant  < M
                pass
            '''
        
        ```
        Double hashing reduces primary and secondary clusture thus reducing collisions.
        
        The table below shows the operations and time complexities of a [HashMap](https://pypi.org/project/EasyDSA/)
        
        | Operation                | Best Case     |  Worst Case   |  
        | -------------            |:-------------:|:-------------:|
        | map = HashMap()          | O(1)          | O(1)          |
        |                          |               |               |
        | map.add(key, value)      | O(1)          | O(N)          | 
        | map.remove(key)          | O(1)          | O(N)          |
        | map[key] = value         | O(1)          | O(N)          |
        | map.get(key)             | O(1)          | O(N)          |
        | map.isEmpty()            | O(1)          | O(1)          |
        | n = len(map)             | O(1)          | O(1)          |
        | x in map                 | O(1)          | O(N)          |
        | traversal                | O(N)          | O(N)          |
        
        As noted from the table above a [HashMap](https://pypi.org/project/EasyDSA/) one one of the strongest data structure in implementing a map, as the fundamental core oprations ie **__getitem__**,
        **__setitem__**,**__deltitem__**, runs at constant time at Best Case. The Hash Map worst case run-time can always be enhanced by implementing **SortedTableMap** which improves the Worst Case O(N) to O(logN), which i hope to add the datastructure in the future.
        
        
        ### Example HashMap
        ```python
        hash = HashMap()
        
        hash.add('man',34)
        hash.add('person',23)
        hash.add('women',674)
        hash.add('camera',5)
        hash.add('tv',89)
        
        for i in hash:
            print('{}: {}'.format(i.key,i.value)) #prints the key value paris
        
        print(len(hash)) #returns length 5
        
        print(hash.remove('tv'))
        print(hash.remove('women'))
        print(hash.remove('man'))
        hash['women'] = 566
        
        for i in hash:
            print('{}: {}'.format(i.key,i.value))
        print(len(hash)) #returns lenth 3 
        print(hash.get('women')) # returns 566
        
        ```
        
        ## Linked List
        One might ask why implement a  [LinkedList](https://pypi.org/project/EasyDSA/) datastructure if we already have a list in Python. Insertions and Deletions operation in a List requires items to be shifted to make a room or close the gap. This howver can be time consuming especially for large data. The add operator in a Linked List requires O(1) time where as the Pyhton List requires O(N)
        
        The table below shows the operations and time complexities of a [LinkedList](https://pypi.org/project/EasyDSA/)
        
        | Operation                | Pyhton List   |  Linked List  |  
        | -------------            |:-------------:|:-------------:|
        | linked = LinkedList()    | O(1)          | O(1)          |
        |                          |               |               |
        | linked.add(value)        | NA            | O(1)          |
        | linked.append(value)     | O(N)          | O(N)          |  
        | linked.remove(value)     | O(1)          | O(N)          |
        | linked.isEmpty()         | O(1)          | O(1)          |
        | n = len(map)             | O(1)          | O(1)          |
        | x in linked              | O(N)          | O(N)          |
        | traversal                | O(N)          | O(N)          |
        
        ### Example Linked List
        
        ```python
        linked  = LinkedList()
        
        for _ in range(10):
            linked.add(_)
        linked.add(5)
        linked.remove(5)
        linked.append(55)
        linked.append(56)
        linked.append(7)
        linked.add(59)
        linked.append(79)
        print('List Length: ',len(linked))
        linked.remove(0)
        print(linked)
        print('List Length: ',len(linked))
        
        for i in linked:
            print(i) #Prints the values in the Linked List
        
        print(77 in linked) #Returns False 77 is not in Linked
        
        ```
        
        ### Pull Requests
        I Welcome and i encourage all Pull Requests. For major changes, please open an issue first to discuss what you would like to change.
        
        Please make sure to update tests as appropriate.
        
        ## Created and Maintained by
        * Author: [Deep Awasthi](https://github.com/mad-skull) :
        * Email:  [da.madskull@gmail.com]
        
        ### License
        ```
        MIT License
        
        Copyright (c) 2021 Deep Awasthi
        
        Permission is hereby granted, free of charge, to any person obtaining a copy
        of this software and associated documentation files (the "Software"), to deal
        in the Software without restriction, including without limitation the rights
        to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
        copies of the Software, and to permit persons to whom the Software is
        furnished to do so, subject to the following conditions:
        
        The above copyright notice and this permission notice shall be included in all
        copies or substantial portions of the Software.
        
        THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
        IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
        FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
        AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
        LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
        OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
        SOFTWARE.
        
        
        ```
        
Platform: UNKNOWN
Classifier: Programming Language :: Python :: 3
Classifier: License :: OSI Approved :: MIT License
Classifier: Operating System :: OS Independent
Requires-Python: >=3.5
Description-Content-Type: text/markdown
