The Queue implementation, as it currently stands uses a list and then does a self.items.insert(0, item) to insert an item in the Queue. This is inefficient. A better approach is to modify Queue to use a deque under the hood, instead of a list for increased efficiency. Please let me know if you agree with the above approach so that I can send a pull request with the appropriate changes.

I wrote a simple setup.py program based on this quickstart guide, which required that I add a README.txt file with the same content as your README.md (I don't believe that the markdown files can be read by the method called), and that I tag the current build as 'v1.0'. I successfully installed the union_find package and was able to use it in my work :+1: :D Hopefully, this fork will give an basis for how to use setup.py, and will allow others to include more of the project's packages if desired. Thank you for this excellent project!

This program finds an Eulerian Tour in the given graph. The program is based on Hierholzer's algorithm. You can read about this algorithm at https://en.wikipedia.org/wiki/Eulerian_path

A simple iterative binary search algorithm.

Please review. I know I didn't update my fork but can you please merge this by resolving the merge conflicts?

Thank you.

The initial value will be wrongly added twice when is bigger than the second value:

    max_till_here[-1] + n

This test case will fail:

assert find_max_subarray2(([1,-1]) == 1 // it will return 2

a = BinarySearchTree()
a.insert(12)
a.insert(1)
a.insert(10)

raises error

Traceback (most recent call last):
  File "binarysearchtree.py", line 147, in <module>
    a.insert(1)
  File "binarysearchtree.py", line 109, in insert
    if node.value == value:
AttributeError: 'NoneType' object has no attribute 'value'

@prakhar1989 Is bubblesort in sorting.py actually bubble sort? The code gives correct end result but according to standard bubblesort, for each iteration the largest element is moved to n-1th index

for i in range(len(a)):
        for j in range(i, len(a)):
            if a[i] > a[j]:
                a[i], a[j] = a[j], a[i]
        print a  # print array after each iteration

The result of this for a=[10, 9, 8, 7, 6, 5, 4, 3, 2, 1]

[1, 10, 9, 8, 6, 4, 2]  # element 10 is not moved to last index
[1, 2, 10, 9, 8, 6, 4]
[1, 2, 4, 10, 9, 8, 6]
[1, 2, 4, 6, 10, 9, 8]
[1, 2, 4, 6, 8, 10, 9]
[1, 2, 4, 6, 8, 9, 10]
[1, 2, 4, 6, 8, 9, 10]

# gives the desired result
for i in range(len(a)-1):
        for j in range(0, len(a)-1-i):
                    if a[j+1] < a[j]:
                            a[j+1], a[j] = a[j], a[j+1]
        print a

Figured I'd add to your list of algorithms. This is a max heap sorting algorithm. This algorithm can change the initial order of the items in the list.

I'm getting this error:

  File "test.py", line 42
    print dijkstra (graph, 1)
                 ^
SyntaxError: invalid syntax

when I use this code

from heapq import heappush, heappop
graph = {
    's' : {'t':6, 'y':7},
    't' : {'x':5, 'z':4, 'y':8 },
    'y' : {'z':9, 'x':3},
    'z' : {'x':7, 's': 2},
    'x' : {'t':2}
}

def read_graph(file):
    graph = dict()
    with open(file) as f:
        for l in f:
            (u, v, w) = l.split()
            if int(u) not in graph:
                graph[int(u)] = dict()
            graph[int(u)][int(v)] = int(w)
    return graph

inf = float('inf')
def dijkstra(graph, s):
    n = len(graph.keys())
    dist = dict()
    Q = list()

    for v in graph:
        dist[v] = inf
    dist[s] = 0

    heappush(Q, (dist[s], s))

    while Q:
        d, u = heappop(Q)
        if d < dist[u]:
            dist[u] = d
        for v in graph[u]:
            if dist[v] > dist[u] + graph[u][v]:
                dist[v] = dist[u] + graph[u][v]
                heappush(Q, (dist[v], v))
    return dist

print dijkstra(graph, 1)

All I did was omit the read file line and uncomment the graph.

Found and fixed small bug in mergesort function of sorting.py. Changed standard division to floor division to fix.

Results of running sorting.py BEFORE change:

Trying:
    bubblesort([6, 4, 8, 2, 1, 9, 10])
Expecting:
    [1, 2, 4, 6, 8, 9, 10]
ok
Trying:
    insertionsort([6, 4, 8, 2, 1, 9, 10])
Expecting:
    [1, 2, 4, 6, 8, 9, 10]
ok
Trying:
    mergesort([5, 4, 1, 6, 2, 3, 9, 7])
Expecting:
    [1, 2, 3, 4, 5, 6, 7, 9]
**********************************************************************
File "c:/Users/parker/Documents/GitHub/Algorithms/sorting and basics/sorting.py", line 4, in __main__.mergesort
Failed example:
    mergesort([5, 4, 1, 6, 2, 3, 9, 7])
Exception raised:
    Traceback (most recent call last):
      File "C:\Users\parker\Anaconda3\lib\doctest.py", line 
1329, in __run
        compileflags, 1), test.globs)
      File "<doctest __main__.mergesort[0]>", line 1, in <module>
        mergesort([5, 4, 1, 6, 2, 3, 9, 7])
      File "c:/Users/parker/Documents/GitHub/Algorithms/sorting and basics/sorting.py", line 12, in mergesort
        a1 = mergesort(arr[:n/2])
    TypeError: slice indices must be integers or None or have an __index__ method
Trying:
    mergesort([3, 2, 4, 2, 1])
Expecting:
    [1, 2, 2, 3, 4]
**********************************************************************
File "c:/Users/parker/Documents/GitHub/Algorithms/sorting and basics/sorting.py", line 7, in __main__.mergesort
Failed example:
    mergesort([3, 2, 4, 2, 1])
Exception raised:
    Traceback (most recent call last):
      File "C:\Users\parker\Anaconda3\lib\doctest.py", line 
1329, in __run
        compileflags, 1), test.globs)
      File "<doctest __main__.mergesort[1]>", line 1, in <module>
        mergesort([3, 2, 4, 2, 1])
      File "c:/Users/parker/Documents/GitHub/Algorithms/sorting and basics/sorting.py", line 12, in mergesort
        a1 = mergesort(arr[:n/2])
    TypeError: slice indices must be integers or None or have an __index__ method
Trying:
    quicksort([6, 4, 8, 2, 1, 9, 10])
Expecting:
    [1, 2, 4, 6, 8, 9, 10]
ok
Trying:
    selectionsort([6, 4, 8, 2, 1, 9, 10])
Expecting:
    [1, 2, 4, 6, 8, 9, 10]
ok
2 items had no tests:
    __main__
    __main__.merge
4 items passed all tests:
   1 tests in __main__.bubblesort
   1 tests in __main__.insertionsort
   1 tests in __main__.quicksort
   1 tests in __main__.selectionsort
**********************************************************************
1 items had failures:
   2 of   2 in __main__.mergesort
6 tests in 7 items.
4 passed and 2 failed.
***Test Failed*** 2 failures.

Results of running sorting.py AFTER change:

Trying:
bubblesort([6, 4, 8, 2, 1, 9, 10])
Expecting:
[1, 2, 4, 6, 8, 9, 10]
ok
Trying:
insertionsort([6, 4, 8, 2, 1, 9, 10])
Expecting:
[1, 2, 4, 6, 8, 9, 10]
ok
Trying:
mergesort([5, 4, 1, 6, 2, 3, 9, 7])
Expecting:
[1, 2, 3, 4, 5, 6, 7, 9]
ok
Trying:
mergesort([3, 2, 4, 2, 1])
Expecting:
[1, 2, 2, 3, 4]
ok
Trying:
quicksort([6, 4, 8, 2, 1, 9, 10])
Expecting:
[1, 2, 4, 6, 8, 9, 10]
ok
Trying:
selectionsort([6, 4, 8, 2, 1, 9, 10])
Expecting:
[1, 2, 4, 6, 8, 9, 10]
ok
2 items had no tests:
main
main.merge
5 items passed all tests:
1 tests in main.bubblesort
1 tests in main.insertionsort
2 tests in main.mergesort
1 tests in main.quicksort
1 tests in main.selectionsort
6 tests in 7 items.
6 passed and 0 failed.
Test passed.

In the longest sequence code, the algorithms fails for this test

seq = [5,0,1,2,3,4,5,6,7,8,9,10,11,12, 2, 8, 10, 3, 6, 9, 7]

The output is (13, [0, 1, 2, 3, 4, 5, 6, 7]), when there is clearly a longer sequence.

Just to let you know!

This python program can generate 10 random numbers and sort them accordingly using the Quick Sort algorithm also implement code for display execution time.

Adding two algorithms to the repository.

1. fractional knapsack which is a problem of dynamic programming and add to fix an issue #66 in the demand of fractional knapsack
   
2. Longest palindrome substring is a problem of dynamic programming and add in the repository by seeing the demand of the people to find the solution of the longest palindrome substring in linear time complexity. I use manacher algorithm to find the solution in the least time complexity.