add graph.py

Author: shellfly

README.md

@@ -3,13 +3,15 @@
 This repository contains the Python source code for the algorithms in the textbook
 <a href = "http://amzn.to/13VNJi7">Algorithms, 4th Edition</a> by Robert Sedgewick and Kevin Wayne.
 
+The official Java source code is <a href="https://github.com/kevin-wayne/algs4">here</a>.
+
 The programs are organized in the package <code>algs4</code>.
 
 ## Goals
 
 Make a Python implementation of the library so that a Python programmer can learn this book easily.
 
-Try to keep the interface and variable name consistent with the original book without violating the Python coding standards.
+Try to keep the interface and variable name consistent with the original book while not violating Python coding standards.
 
 ## Installing
 
@@ -29,5 +31,5 @@ This code is released under MIT.
 
 ## Contribute to this repository
 
-Issue reports and code fixes are welcome. please follow the same style as the code in the repository and thoroughly test your
+Issue reports and code fixes are welcome. please follow the same style as the code in the repository and add test for your
 code.

algs4/binary_search_st.py

@@ -0,0 +1,88 @@
+from algs4.utils.st import Node, STKeyIterator
+
+
+class BinarySearchST:
+
+    def __init__(self):
+        self.keys = []
+        self.vals = []
+        self.size = 0
+
+    def contains(self, key):
+        x = self.first
+        while x:
+            if key == x.key:
+                return True
+            x = x.next
+        return False
+
+    def rank(self, key):
+        lo = 0
+        hi = self.size - 1
+        while lo <= hi:
+            mid = lo + (hi - lo) / 2
+            if key < self.keys[mid]:
+                hi = mid - 1
+            elif key > self.keys[mid]:
+                lo = lo + 1
+            else:
+                return mid
+        return lo
+
+    def get(self, key):
+        i = self.rank(key)
+        if i < self.size and self.keys[i] == key:
+            return self.vals[i]
+        else:
+            return None
+
+    def put(self, key, val):
+        i = self.rank(key)
+        if i < self.size and self.keys[i] == key:
+            self.vals[i] = val
+            return
+
+        self.keys.append(key)
+        self.vals.append(val)
+        j = self.size - 1
+        while j > i:
+            self.keys[j] = self.keys[j - 1]
+            self.vals[j] = self.vals[j - 1]
+        self.keys[i] = key
+        self.vals[i] = val
+        self.size += 1
+
+    def delete(self, key):
+        i = self.rank(key)
+        if i < self.size and self.keys[i] == key:
+            self.size -= 1
+            for j in range(i, self.size):
+                self.keys[j] = self.keys[j + 1]
+                self.vals[j] = self.vals[j + 1]
+            self.keys[-1] = None
+            self.vals[-1] = None
+
+    def is_empty(self):
+        return self.size == 0
+
+    def min(self):
+        return self.keys[0]
+
+    def max(self):
+        return self.keys[-1]
+
+    def select(self, k):
+        return self.keys[k]
+
+    def ceiling(self, key):
+        i = self.rank(key)
+        if i == self.size:
+            return None
+
+        return self.keys[i]
+
+    def floor(self, key):
+        i = self.rank(key)
+        if i == 0:
+            return None
+        return self.keys[i - 1]

algs4/frequency_counter.py

@@ -0,0 +1,51 @@
+"""
+    Execution:
+        python frequency_counter L < input.txt
+    Data files:   
+        https://algs4.cs.princeton.edu/31elementary/tnyTale.txt
+        https://algs4.cs.princeton.edu/31elementary/tale.txt
+        https://algs4.cs.princeton.edu/31elementary/leipzig100K.txt
+        https://algs4.cs.princeton.edu/31elementary/leipzig300K.txt
+        https://algs4.cs.princeton.edu/31elementary/leipzig1M.txt
+
+    Read in a list of words from standard input and print out
+    the most frequently occurring word that has length greater than
+    a given threshold.
+
+    % python frequency_counter 1 < tinyTale.txt
+    it 10
+  
+    % python frequency_counter 8 < tale.txt
+    business 122
+  
+    % python frequency_counter 10 < leipzig1M.txt
+    government 24763
+"""
+
+#from algs4.st import ST
+from algs4.sequential_search_st import SequentialSearchST
+
+
+class FrequencyCounter:
+    pass
+
+if __name__ == "__main__":
+    import sys
+    minlen = int(sys.argv[1])
+    st = SequentialSearchST()
+    for line in sys.stdin:
+        words = line.split()
+        for word in words:
+
+            if len(word) < minlen:
+                continue
+            if not st.contains(word):
+                st.put(word, 1)
+            else:
+                st.put(word, st.get(word) + 1)
+    maxstr = ""
+    st.put(maxstr, 0)
+    for word in st.keys():
+        if st.get(word) > st.get(maxstr):
+            maxstr = word
+    print(maxstr, " ", st.get(maxstr))

algs4/graph.py

@@ -0,0 +1,51 @@
+class Graph:
+
+    def __init__(self, v):
+        self.V = v
+        self.E = 0
+        self.adj = {}
+        for v in range(self.V):
+            self.adj[v] = []
+
+    def __str__(self):
+        s = "%d vertices, %d edges\n" % (self.V, self.E)
+        s += "\n".join("%d: %s" % (v, " ".join(str(w)
+                                               for w in self.adj[v])) for v in range(self.V))
+        return s
+
+    def add_edge(self, v, w):
+        v, w = int(v), int(w)
+        self.adj[v].append(w)
+        self.adj[w].append(v)
+        self.E += 1
+
+    def degree(self, v):
+        return len(self.adj[v])
+
+    def max_degree(self):
+        max_deg = 0
+        for v in self.V:
+            max_deg = max(max_deg, self.degree(v))
+        return max_deg
+
+    def avg_degree(self):
+        return 2 * self.E / self.V
+
+    def number_of_self_loops(self):
+        count = 0
+        for v in range(self.V):
+            for w in self.adj[v]:
+                if w == v:
+                    count += 1
+        return count
+
+if __name__ == '__main__':
+    import sys
+
+    V = int(sys.stdin.readline())
+    E = int(sys.stdin.readline())
+    g = Graph(V)
+    for i in range(E):
+        v, w = sys.stdin.readline().split()
+        g.add_edge(v, w)
+    print(g)

algs4/sequential_search_st.py

@@ -0,0 +1,53 @@
+from algs4.utils.st import Node, STKeyIterator
+
+
+class SequentialSearchST:
+
+    def __init__(self):
+        self.first = None
+        self.size = 0
+
+    def contains(self, key):
+        x = self.first
+        while x:
+            if key == x.key:
+                return True
+            x = x.next
+        return False
+
+    def get(self, key):
+        x = self.first
+        while x:
+            if key == x.key:
+                return x.val
+            x = x.next
+        return None
+
+    def put(self, key, val):
+        x = self.first
+        while x:
+            if key == x.key:
+                x.val = val
+                return
+            x = x.next
+        self.first = Node(key, val, self.first)
+        self.size += 1
+
+    def delete(self, key):
+        prev = None
+        curr = self.first
+        while curr:
+            if key == curr.key:
+                if prev:
+                    prev.next = curr.next
+                else:
+                    self.first = curr.ext
+                self.size -= 1
+            prev = curr
+            curr = curr.next
+
+    def keys(self):
+        return STKeyIterator(self.first)
+
+    def is_empty(self):
+        return self.size == 0

algs4/st.py

@@ -0,0 +1,30 @@
+"""
+  Execution:    python st < input.txt
+  Data files:   https://algs4.cs.princeton.edu/35applications/tinyST.txt
+  
+  Does not allow duplicates.
+ """
+
+
+class ST:
+
+    def put(self, key, value):
+        pass
+
+    def get(self, key):
+        pass
+
+    def delete(self, key):
+        pass
+
+    def contains(self, key):
+        pass
+
+    def is_empty(self):
+        pass
+
+    def size(self):
+        pass
+
+    def keys(self):
+        pass

algs4/utils/st.py

@@ -0,0 +1,40 @@
+class Node:
+
+    def __init__(self, key, val, nextItem):
+        self.key = key
+        self.val = val
+        self.next = nextItem
+
+
+class STKeyIterator:
+
+    def __init__(self, current):
+        self.current = current
+
+    def __iter__(self):
+        return self
+
+    def __next__(self):
+        if self.current is None:
+            raise StopIteration()
+        else:
+            key = self.current.key
+            self.current = self.current.next
+            return key
+
+
+class STValueIterator:
+
+    def __init__(self, current):
+        self.current = current
+
+    def __iter__(self):
+        return self
+
+    def __next__(self):
+        if self.current is None:
+            raise StopIteration()
+        else:
+            val = self.current.val
+            self.current = self.current.next
+            return val