wxpython
diff --git a/‎graph/dijkstra.py‎
Lines changed: 36 additions & 0 deletions b/‎graph/dijkstra.py‎
Lines changed: 36 additions & 0 deletions
diff --git a/‎stack/ordered_stack.py‎
Lines changed: 33 additions & 0 deletions b/‎stack/ordered_stack.py‎
Lines changed: 33 additions & 0 deletions
diff --git a/‎tests/test_stack.py‎
Lines changed: 15 additions & 0 deletions b/‎tests/test_stack.py‎
Lines changed: 15 additions & 0 deletions
@@ -0,0 +1,36 @@
+#Dijkstra's single source shortest path algorithm
+
+class Graph():
+
+    def __init__(self, vertices):
+        self.vertices = vertices
+        self.graph = [[0 for column in range(vertices)] for row in range(vertices)]
+
+    def min_distance(self, dist, min_dist_set):
+        min_dist = float("inf")
+        for v in range(self.vertices):
+            if dist[v] < min_dist and min_dist_set[v] == False:
+                min_dist = dist[v]
+                min_index = v
+        return min_index
+
+    def dijkstra(self, src):
+
+        dist = [float("inf")] * self.vertices
+        dist[src] = 0
+        min_dist_set = [False] * self.vertices
+
+        for count in range(self.vertices):
+
+            #minimum distance vertex that is not processed
+            u = self.min_distance(dist, min_dist_set)
+
+            #put minimum distance vertex in shortest tree
+            min_dist_set[u] = True
+
+            #Update dist value of the adjacent vertices
+            for v in range(self.vertices):
+                if self.graph[u][v] > 0 and min_dist_set[v] == False and dist[v] > dist[u] + self.graph[u][v]:
+                    dist[v] = dist[u] + self.graph[u][v]
+
+        return dist
@@ -0,0 +1,33 @@
+#The stack remains always ordered such that the highest value is at the top and the lowest at the bottom
+
+class OrderedStack:
+     def __init__(self):
+         self.items = []
+
+     def is_empty(self):
+         return self.items == []
+
+     def push_t(self, item):
+         self.items.append(item)
+
+     def push(self, item): #push method to maintain order when pushing new elements
+         temp_stack = OrderedStack()
+         if self.is_empty() or item > self.peek():
+             self.push_t(item)
+         else:
+             while item < self.peek() and not self.is_empty():
+                 temp_stack.push_t(self.pop())
+             self.push_t(item)
+             while not temp_stack.is_empty():
+                 self.push_t(temp_stack.pop())
+
+     def pop(self):
+         if self.is_empty():
+             raise IndexError("Stack is empty")
+         return self.items.pop()
+
+     def peek(self):
+         return self.items[len(self.items) - 1]
+
+     def size(self):
+         return len(self.items)
@@ -6,6 +6,7 @@
 from stack.valid_parenthesis import is_valid
 from stack.simplify_path import simplify_path
 from stack.stack import ArrayStack, LinkedListStack
+from stack.ordered_stack import OrderedStack
 
 import unittest
 class TestSuite(unittest.TestCase):
@@ -129,5 +130,19 @@ def test_LinkedListStack(self):
 
         self.assertTrue(stack.is_empty())
 
+class TestOrderedStack(unittest.TestCase):
+    def test_OrderedStack(self):
+        stack = OrderedStack()
+        self.assertTrue(stack.is_empty())
+        stack.push(1)
+        stack.push(4)
+        stack.push(3)
+        stack.push(6)
+        "bottom - > 1 3 4 6 "
+        self.assertEqual(6, stack.pop())
+        self.assertEqual(4, stack.peek())
+        self.assertEqual(3, stack.size())
+
+
 if __name__ == "__main__":
     unittest.main()