SYMBOL INDEX (2767 symbols across 201 files)

FILE: src/main/java/edu/princeton/cs/algs4/AVLTreeST.java
  class AVLTreeST (line 67) | public class AVLTreeST<Key extends Comparable<Key>, Value> {
    class Node (line 77) | private class Node {
      method Node (line 85) | public Node(Key key, Value val, int height, int size) {
    method AVLTreeST (line 96) | public AVLTreeST() {
    method isEmpty (line 104) | public boolean isEmpty() {
    method size (line 113) | public int size() {
    method size (line 124) | private int size(Node x) {
    method height (line 136) | public int height() {
    method height (line 147) | private int height(Node x) {
    method get (line 161) | public Value get(Key key) {
    method get (line 177) | private Node get(Node x, Key key) {
    method contains (line 193) | public boolean contains(Key key) {
    method put (line 207) | public void put(Key key, Value val) {
    method put (line 228) | private Node put(Node x, Key key, Value val) {
    method balance (line 252) | private Node balance(Node x) {
    method balanceFactor (line 278) | private int balanceFactor(Node x) {
    method rotateRight (line 288) | private Node rotateRight(Node x) {
    method rotateLeft (line 305) | private Node rotateLeft(Node x) {
    method delete (line 323) | public void delete(Key key) {
    method delete (line 338) | private Node delete(Node x, Key key) {
    method deleteMin (line 370) | public void deleteMin() {
    method deleteMin (line 382) | private Node deleteMin(Node x) {
    method deleteMax (line 395) | public void deleteMax() {
    method deleteMax (line 407) | private Node deleteMax(Node x) {
    method min (line 421) | public Key min() {
    method min (line 432) | private Node min(Node x) {
    method max (line 443) | public Key max() {
    method max (line 454) | private Node max(Node x) {
    method floor (line 469) | public Key floor(Key key) {
    method floor (line 486) | private Node floor(Node x, Key key) {
    method ceiling (line 506) | public Key ceiling(Key key) {
    method ceiling (line 523) | private Node ceiling(Node x, Key key) {
    method select (line 541) | public Key select(int k) {
    method select (line 554) | private Node select(Node x, int k) {
    method rank (line 571) | public int rank(Key key) {
    method rank (line 583) | private int rank(Key key, Node x) {
    method keys (line 596) | public Iterable<Key> keys() {
    method keysInOrder (line 605) | public Iterable<Key> keysInOrder() {
    method keysInOrder (line 617) | private void keysInOrder(Node x, Queue<Key> queue) {
    method keysLevelOrder (line 629) | public Iterable<Key> keysLevelOrder() {
    method keys (line 658) | public Iterable<Key> keys(Key lo, Key hi) {
    method keys (line 675) | private void keys(Node x, Queue<Key> queue, Key lo, Key hi) {
    method size (line 694) | public int size(Key lo, Key hi) {
    method check (line 707) | private boolean check() {
    method isAVL (line 720) | private boolean isAVL() {
    method isAVL (line 730) | private boolean isAVL(Node x) {
    method isBST (line 742) | private boolean isBST() {
    method isBST (line 756) | private boolean isBST(Node x, Key min, Key max) {
    method isSizeConsistent (line 768) | private boolean isSizeConsistent() {
    method isSizeConsistent (line 777) | private boolean isSizeConsistent(Node x) {
    method isRankConsistent (line 788) | private boolean isRankConsistent() {
    method main (line 801) | public static void main(String[] args) {

FILE: src/main/java/edu/princeton/cs/algs4/Accumulator.java
  class Accumulator (line 36) | public class Accumulator {
    method Accumulator (line 44) | public Accumulator() {
    method addDataValue (line 51) | public void addDataValue(double x) {
    method mean (line 62) | public double mean() {
    method var (line 70) | public double var() {
    method stddev (line 79) | public double stddev() {
    method count (line 87) | public int count() {
    method toString (line 95) | public String toString() {
    method main (line 108) | public static void main(String[] args) {

FILE: src/main/java/edu/princeton/cs/algs4/AcyclicLP.java
  class AcyclicLP (line 53) | public class AcyclicLP {
    method AcyclicLP (line 65) | public AcyclicLP(EdgeWeightedDigraph digraph, int s) {
    method relax (line 86) | private void relax(DirectedEdge e) {
    method distTo (line 101) | public double distTo(int v) {
    method hasPathTo (line 113) | public boolean hasPathTo(int v) {
    method pathTo (line 125) | public Iterable<DirectedEdge> pathTo(int v) {
    method validateVertex (line 136) | private void validateVertex(int v) {
    method main (line 147) | public static void main(String[] args) {

FILE: src/main/java/edu/princeton/cs/algs4/AcyclicSP.java
  class AcyclicSP (line 51) | public class AcyclicSP {
    method AcyclicSP (line 64) | public AcyclicSP(EdgeWeightedDigraph digraph, int s) {
    method relax (line 85) | private void relax(DirectedEdge e) {
    method distTo (line 100) | public double distTo(int v) {
    method hasPathTo (line 112) | public boolean hasPathTo(int v) {
    method pathTo (line 124) | public Iterable<DirectedEdge> pathTo(int v) {
    method validateVertex (line 135) | private void validateVertex(int v) {
    method main (line 146) | public static void main(String[] args) {

FILE: src/main/java/edu/princeton/cs/algs4/AdjMatrixEdgeWeightedDigraph.java
  class AdjMatrixEdgeWeightedDigraph (line 38) | public class AdjMatrixEdgeWeightedDigraph {
    method AdjMatrixEdgeWeightedDigraph (line 50) | public AdjMatrixEdgeWeightedDigraph(int V) {
    method AdjMatrixEdgeWeightedDigraph (line 64) | public AdjMatrixEdgeWeightedDigraph(int V, int E) {
    method V (line 82) | public int V() {
    method E (line 90) | public int E() {
    method addEdge (line 99) | public void addEdge(DirectedEdge e) {
    method adj (line 116) | public Iterable<DirectedEdge> adj(int v) {
    class AdjIterator (line 122) | private class AdjIterator implements Iterator<DirectedEdge>, Iterable<...
      method AdjIterator (line 126) | public AdjIterator(int v) {
      method iterator (line 130) | public Iterator<DirectedEdge> iterator() {
      method hasNext (line 134) | public boolean hasNext() {
      method next (line 142) | public DirectedEdge next() {
      method remove (line 149) | public void remove() {
    method toString (line 160) | public String toString() {
    method validateVertex (line 174) | private void validateVertex(int v) {
    method main (line 185) | public static void main(String[] args) {

FILE: src/main/java/edu/princeton/cs/algs4/AllowFilter.java
  class AllowFilter (line 46) | public class AllowFilter {
    method AllowFilter (line 49) | private AllowFilter() { }
    method main (line 51) | public static void main(String[] args) {

FILE: src/main/java/edu/princeton/cs/algs4/Allowlist.java
  class Allowlist (line 45) | public class Allowlist {
    method Allowlist (line 48) | private Allowlist() { }
    method main (line 57) | public static void main(String[] args) {

FILE: src/main/java/edu/princeton/cs/algs4/Alphabet.java
  class Alphabet (line 17) | public class Alphabet {
    method Alphabet (line 90) | public Alphabet(String alpha) {
    method Alphabet (line 117) | private Alphabet(int radix) {
    method Alphabet (line 132) | public Alphabet() {
    method contains (line 143) | public boolean contains(char c) {
    method R (line 153) | @Deprecated
    method radix (line 163) | public int radix() {
    method lgR (line 172) | public int lgR() {
    method toIndex (line 186) | public int toIndex(char c) {
    method toIndices (line 201) | public int[] toIndices(String s) {
    method toChar (line 216) | public char toChar(int index) {
    method toChars (line 231) | public String toChars(int[] indices) {
    method main (line 243) | public static void main(String[] args) {

FILE: src/main/java/edu/princeton/cs/algs4/AmericanFlag.java
  class AmericanFlag (line 48) | public class AmericanFlag {
    method AmericanFlag (line 55) | private AmericanFlag() { }
    method charAt (line 58) | private static int charAt(String s, int d) {
    method sort (line 70) | public static void sort(String[] a) {
    method sort (line 75) | public static void sort(String[] a, int lo, int hi) {
    method insertion (line 138) | private static void insertion(String[] a, int lo, int hi, int d) {
    method exch (line 145) | private static void exch(String[] a, int i, int j) {
    method less (line 152) | private static boolean less(String v, String w, int d) {
    method sort (line 167) | public static void sort(int[] a) {
    method sort (line 172) | private static void sort(int[] a, int lo, int hi) {
    method insertion (line 237) | private static void insertion(int[] a, int lo, int hi, int d) {
    method exch (line 244) | private static void exch(int[] a, int i, int j) {
    method less (line 251) | private static boolean less(int v, int w, int d) {
    method main (line 270) | public static void main(String[] args) {

FILE: src/main/java/edu/princeton/cs/algs4/AmericanFlagX.java
  class AmericanFlagX (line 46) | public class AmericanFlagX {
    method AmericanFlagX (line 51) | private AmericanFlagX() { }
    method charAt (line 54) | private static int charAt(String s, int d) {
    method sort (line 66) | public static void sort(String[] a) {
    method sort (line 71) | public static void sort(String[] a, int lo, int hi) {
    method insertion (line 140) | private static void insertion(String[] a, int lo, int hi, int d) {
    method exch (line 147) | private static void exch(String[] a, int i, int j) {
    method less (line 154) | private static boolean less(String v, String w, int d) {
    method main (line 170) | public static void main(String[] args) {

FILE: src/main/java/edu/princeton/cs/algs4/Arbitrage.java
  class Arbitrage (line 53) | public class Arbitrage {
    method Arbitrage (line 56) | private Arbitrage() { }
    method main (line 64) | public static void main(String[] args) {

FILE: src/main/java/edu/princeton/cs/algs4/AssignmentProblem.java
  class AssignmentProblem (line 39) | public class AssignmentProblem {
    method AssignmentProblem (line 58) | public AssignmentProblem(double[][] weight) {
    method augment (line 94) | private void augment() {
    method reducedCost (line 135) | private double reducedCost(int i, int j) {
    method dualRow (line 155) | public double dualRow(int i) {
    method dualCol (line 168) | public double dualCol(int j) {
    method sol (line 181) | public int sol(int i) {
    method weight (line 192) | public double weight() {
    method validate (line 201) | private void validate(int i) {
    method isDualFeasible (line 213) | private boolean isDualFeasible() {
    method isComplementarySlack (line 227) | private boolean isComplementarySlack() {
    method isPerfectMatching (line 240) | private boolean isPerfectMatching() {
    method certifySolution (line 270) | private boolean certifySolution() {
    method main (line 282) | public static void main(String[] args) {

FILE: src/main/java/edu/princeton/cs/algs4/Average.java
  class Average (line 31) | public class Average {
    method Average (line 34) | private Average() { }
    method main (line 42) | public static void main(String[] args) {

FILE: src/main/java/edu/princeton/cs/algs4/BST.java
  class BST (line 70) | public class BST<Key extends Comparable<Key>, Value> {
    class Node (line 73) | private class Node {
      method Node (line 79) | public Node(Key key, Value val, int size) {
    method BST (line 89) | public BST() {
    method isEmpty (line 96) | public boolean isEmpty() {
    method size (line 104) | public int size() {
    method size (line 109) | private int size(Node node) {
    method contains (line 122) | public boolean contains(Key key) {
    method get (line 135) | public Value get(Key key) {
    method get (line 139) | private Value get(Node node, Key key) {
    method put (line 158) | public void put(Key key, Value val) {
    method put (line 168) | private Node put(Node node, Key key, Value val) {
    method deleteMin (line 184) | public void deleteMin() {
    method deleteMin (line 190) | private Node deleteMin(Node node) {
    method deleteMax (line 202) | public void deleteMax() {
    method deleteMax (line 208) | private Node deleteMax(Node node) {
    method delete (line 222) | public void delete(Key key) {
    method delete (line 228) | private Node delete(Node node, Key key) {
    method min (line 253) | public Key min() {
    method min (line 258) | private Node min(Node node) {
    method max (line 269) | public Key max() {
    method max (line 274) | private Node max(Node node) {
    method floor (line 287) | public Key floor(Key key) {
    method floor (line 295) | private Node floor(Node node, Key key) {
    method floor2 (line 305) | public Key floor2(Key key) {
    method floor2 (line 312) | private Key floor2(Node node, Key key, Key champ) {
    method ceiling (line 328) | public Key ceiling(Key key) {
    method ceiling (line 336) | private Node ceiling(Node node, Key key) {
    method select (line 359) | public Key select(int rank) {
    method select (line 368) | private Key select(Node node, int rank) {
    method rank (line 383) | public int rank(Key key) {
    method rank (line 389) | private int rank(Key key, Node node) {
    method keys (line 405) | public Iterable<Key> keys() {
    method keys (line 421) | public Iterable<Key> keys(Key lo, Key hi) {
    method keys (line 430) | private void keys(Node node, Queue<Key> queue, Key lo, Key hi) {
    method size (line 449) | public int size(Key lo, Key hi) {
    method height (line 463) | public int height() {
    method height (line 466) | private int height(Node node) {
    method levelOrder (line 476) | public Iterable<Key> levelOrder() {
    method check (line 493) | private boolean check() {
    method isBST (line 502) | private boolean isBST() {
    method isBST (line 509) | private boolean isBST(Node node, Key min, Key max) {
    method isSizeConsistent (line 517) | private boolean isSizeConsistent() { return isSizeConsistent(root); }
    method isSizeConsistent (line 518) | private boolean isSizeConsistent(Node node) {
    method isRankConsistent (line 525) | private boolean isRankConsistent() {
    method main (line 539) | public static void main(String[] args) {

FILE: src/main/java/edu/princeton/cs/algs4/BTree.java
  class BTree (line 46) | public class BTree<Key extends Comparable<Key>, Value>  {
    class Node (line 56) | private static final class Node {
      method Node (line 61) | private Node(int k) {
    class Entry (line 68) | private static class Entry {
      method Entry (line 72) | public Entry(Comparable key, Object val, Node next) {
    method BTree (line 82) | public BTree() {
    method isEmpty (line 90) | public boolean isEmpty() {
    method size (line 98) | public int size() {
    method height (line 107) | public int height() {
    method get (line 120) | public Value get(Key key) {
    method search (line 125) | private Value search(Node x, Key key, int ht) {
    method put (line 155) | public void put(Key key, Value val) {
    method insert (line 169) | private Node insert(Node h, Key key, Value val, int ht) {
    method split (line 203) | private Node split(Node h) {
    method toString (line 216) | public String toString() {
    method toString (line 220) | private String toString(Node h, int ht, String indent) {
    method less (line 240) | private boolean less(Comparable k1, Comparable k2) {
    method eq (line 244) | private boolean eq(Comparable k1, Comparable k2) {
    method main (line 254) | public static void main(String[] args) {

FILE: src/main/java/edu/princeton/cs/algs4/Bag.java
  class Bag (line 55) | public class Bag<Item> implements Iterable<Item> {
    class Node (line 60) | private static class Node<Item> {
    method Bag (line 68) | public Bag() {
    method isEmpty (line 79) | public boolean isEmpty() {
    method size (line 88) | public int size() {
    method add (line 97) | public void add(Item item) {
    method iterator (line 111) | public Iterator<Item> iterator()  {
    class LinkedIterator (line 115) | private class LinkedIterator implements Iterator<Item> {
      method LinkedIterator (line 118) | public LinkedIterator(Node<Item> first) {
      method hasNext (line 122) | public boolean hasNext()  {
      method next (line 126) | public Item next() {
    method main (line 139) | public static void main(String[] args) {

FILE: src/main/java/edu/princeton/cs/algs4/BellmanFordSP.java
  class BellmanFordSP (line 66) | public class BellmanFordSP {
    method BellmanFordSP (line 84) | public BellmanFordSP(EdgeWeightedDigraph digraph, int s) {
    method relax (line 106) | private void relax(EdgeWeightedDigraph digraph, int v) {
    method hasNegativeCycle (line 129) | public boolean hasNegativeCycle() {
    method negativeCycle (line 139) | public Iterable<DirectedEdge> negativeCycle() {
    method findNegativeCycle (line 144) | private void findNegativeCycle() {
    method distTo (line 164) | public double distTo(int v) {
    method hasPathTo (line 178) | public boolean hasPathTo(int v) {
    method pathTo (line 192) | public Iterable<DirectedEdge> pathTo(int v) {
    method check (line 209) | private boolean check(EdgeWeightedDigraph digraph, int s) {
    method validateVertex (line 269) | private void validateVertex(int v) {
    method main (line 280) | public static void main(String[] args) {

FILE: src/main/java/edu/princeton/cs/algs4/BinaryDump.java
  class BinaryDump (line 41) | public class BinaryDump {
    method BinaryDump (line 44) | private BinaryDump() { }
    method main (line 55) | public static void main(String[] args) {

FILE: src/main/java/edu/princeton/cs/algs4/BinaryIn.java
  class BinaryIn (line 50) | public final class BinaryIn {
    method BinaryIn (line 60) | public BinaryIn() {
    method BinaryIn (line 70) | public BinaryIn(InputStream is) {
    method BinaryIn (line 80) | public BinaryIn(Socket socket) {
    method BinaryIn (line 96) | public BinaryIn(URL url) {
    method BinaryIn (line 113) | public BinaryIn(String name) {
    method fillBuffer (line 145) | private void fillBuffer() {
    method exists (line 163) | public boolean exists()  {
    method isEmpty (line 173) | public boolean isEmpty() {
    method readBoolean (line 183) | public boolean readBoolean() {
    method readChar (line 197) | public char readChar() {
    method readChar (line 230) | public char readChar(int r) {
    method readString (line 253) | public String readString() {
    method readShort (line 271) | public short readShort() {
    method readInt (line 287) | public int readInt() {
    method readInt (line 306) | public int readInt(int r) {
    method readLong (line 327) | public long readLong() {
    method readDouble (line 343) | public double readDouble() {
    method readFloat (line 353) | public float readFloat() {
    method readByte (line 364) | public byte readByte() {
    method main (line 376) | public static void main(String[] args) {

FILE: src/main/java/edu/princeton/cs/algs4/BinaryInsertion.java
  class BinaryInsertion (line 50) | public class BinaryInsertion {
    method BinaryInsertion (line 53) | private BinaryInsertion() { }
    method sort (line 59) | public static void sort(Comparable[] a) {
    method less (line 88) | private static boolean less(Comparable v, Comparable w) {
    method isSorted (line 95) | private static boolean isSorted(Comparable[] a) {
    method isSorted (line 100) | private static boolean isSorted(Comparable[] a, int lo, int hi) {
    method show (line 107) | private static void show(Comparable[] a) {
    method main (line 119) | public static void main(String[] args) {

FILE: src/main/java/edu/princeton/cs/algs4/BinaryOut.java
  class BinaryOut (line 39) | public final class BinaryOut {
    method BinaryOut (line 49) | public BinaryOut() {
    method BinaryOut (line 57) | public BinaryOut(OutputStream os) {
    method BinaryOut (line 68) | public BinaryOut(String filename) {
    method BinaryOut (line 92) | public BinaryOut(Socket socket) {
    method writeBit (line 111) | private void writeBit(boolean x) {
    method writeByte (line 125) | private void writeByte(int x) {
    method clearBuffer (line 147) | private void clearBuffer() {
    method flush (line 164) | public void flush() {
    method close (line 178) | public void close() {
    method write (line 193) | public void write(boolean x) {
    method write (line 201) | public void write(byte x) {
    method write (line 209) | public void write(int x) {
    method write (line 224) | public void write(int x, int r) {
    method write (line 242) | public void write(double x) {
    method write (line 250) | public void write(long x) {
    method write (line 265) | public void write(float x) {
    method write (line 273) | public void write(short x) {
    method write (line 284) | public void write(char x) {
    method write (line 297) | public void write(char x, int r) {
    method write (line 317) | public void write(String s) {
    method write (line 331) | public void write(String s, int r) {
    method main (line 343) | public static void main(String[] args) {

FILE: src/main/java/edu/princeton/cs/algs4/BinarySearch.java
  class BinarySearch (line 42) | public class BinarySearch {
    method BinarySearch (line 47) | private BinarySearch() { }
    method indexOf (line 56) | public static int indexOf(int[] a, int key) {
    method rank (line 79) | @Deprecated
    method main (line 91) | public static void main(String[] args) {

FILE: src/main/java/edu/princeton/cs/algs4/BinarySearchST.java
  class BinarySearchST (line 68) | public class BinarySearchST<Key extends Comparable<Key>, Value> {
    method BinarySearchST (line 77) | public BinarySearchST() {
    method BinarySearchST (line 85) | public BinarySearchST(int capacity) {
    method resize (line 91) | private void resize(int capacity) {
    method size (line 108) | public int size() {
    method isEmpty (line 118) | public boolean isEmpty() {
    method contains (line 131) | public boolean contains(Key key) {
    method get (line 144) | public Value get(Key key) {
    method rank (line 159) | public int rank(Key key) {
    method put (line 185) | public void put(Key key, Value val)  {
    method delete (line 222) | public void delete(Key key) {
    method deleteMin (line 254) | public void deleteMin() {
    method deleteMax (line 264) | public void deleteMax() {
    method min (line 280) | public Key min() {
    method max (line 291) | public Key max() {
    method select (line 304) | public Key select(int k) {
    method floor (line 319) | public Key floor(Key key) {
    method ceiling (line 335) | public Key ceiling(Key key) {
    method size (line 352) | public int size(Key lo, Key hi) {
    method keys (line 368) | public Iterable<Key> keys() {
    method keys (line 383) | public Iterable<Key> keys(Key lo, Key hi) {
    method check (line 400) | private boolean check() {
    method isSorted (line 405) | private boolean isSorted() {
    method rankCheck (line 412) | private boolean rankCheck() {
    method main (line 426) | public static void main(String[] args) {

FILE: src/main/java/edu/princeton/cs/algs4/BinaryStdIn.java
  class BinaryStdIn (line 39) | public final class BinaryStdIn {
    method BinaryStdIn (line 48) | private BinaryStdIn() { }
    method initialize (line 51) | private static void initialize() {
    method fillBuffer (line 59) | private static void fillBuffer() {
    method close (line 74) | public static void close() {
    method isEmpty (line 89) | public static boolean isEmpty() {
    method readBoolean (line 100) | public static boolean readBoolean() {
    method readChar (line 116) | public static char readChar() {
    method readChar (line 147) | public static char readChar(int r) {
    method readString (line 169) | public static String readString() {
    method readShort (line 187) | public static short readShort() {
    method readInt (line 203) | public static int readInt() {
    method readInt (line 221) | public static int readInt(int r) {
    method readLong (line 242) | public static long readLong() {
    method readDouble (line 259) | public static double readDouble() {
    method readFloat (line 269) | public static float readFloat() {
    method readByte (line 280) | public static byte readByte() {
    method main (line 291) | public static void main(String[] args) {

FILE: src/main/java/edu/princeton/cs/algs4/BinaryStdOut.java
  class BinaryStdOut (line 35) | public final class BinaryStdOut {
    method BinaryStdOut (line 42) | private BinaryStdOut() { }
    method initialize (line 45) | private static void initialize() {
    method writeBit (line 55) | private static void writeBit(boolean bit) {
    method writeByte (line 70) | private static void writeByte(int x) {
    method clearBuffer (line 94) | private static void clearBuffer() {
    method flush (line 113) | public static void flush() {
    method close (line 127) | public static void close() {
    method write (line 143) | public static void write(boolean x) {
    method write (line 151) | public static void write(byte x) {
    method write (line 159) | public static void write(int x) {
    method write (line 173) | public static void write(int x, int r) {
    method write (line 194) | public static void write(double x) {
    method write (line 202) | public static void write(long x) {
    method write (line 217) | public static void write(float x) {
    method write (line 225) | public static void write(short x) {
    method write (line 235) | public static void write(char x) {
    method write (line 247) | public static void write(char x, int r) {
    method write (line 266) | public static void write(String s) {
    method write (line 279) | public static void write(String s, int r) {
    method main (line 289) | public static void main(String[] args) {

FILE: src/main/java/edu/princeton/cs/algs4/BinomialMinPQ.java
  class BinomialMinPQ (line 32) | public class BinomialMinPQ<Key> implements Iterable<Key> {
    class Node (line 37) | private class Node {
    method BinomialMinPQ (line 47) | public BinomialMinPQ() {
    method BinomialMinPQ (line 56) | public BinomialMinPQ(Comparator<Key> C) {
    method BinomialMinPQ (line 65) | public BinomialMinPQ(Key[] a) {
    method BinomialMinPQ (line 76) | public BinomialMinPQ(Comparator<Key> C, Key[] a) {
    method isEmpty (line 86) | public boolean isEmpty() {
    method size (line 96) | public int size() {
    method insert (line 111) | public void insert(Key key) {
    method minKey (line 126) | public Key minKey() {
    method delMin (line 143) | public Key delMin() {
    method union (line 171) | public BinomialMinPQ<Key> union(BinomialMinPQ<Key> heap) {
    method greater (line 199) | private boolean greater(Key n, Key m) {
    method link (line 206) | private void link(Node root1, Node root2) {
    method eraseMin (line 213) | private Node eraseMin() {
    method merge (line 234) | private Node merge(Node h, Node x, Node y) {
    method iterator (line 255) | public Iterator<Key> iterator() {
    class MyIterator (line 259) | private class MyIterator implements Iterator<Key> {
      method MyIterator (line 264) | public MyIterator() {
      method clone (line 269) | private Node clone(Node x, Node parent) {
      method hasNext (line 278) | public boolean hasNext() {
      method next (line 282) | public Key next() {
      method remove (line 287) | public void remove() {
    class MyComparator (line 297) | private class MyComparator implements Comparator<Key> {
      method compare (line 298) | @Override

FILE: src/main/java/edu/princeton/cs/algs4/Bipartite.java
  class Bipartite (line 42) | public class Bipartite {
    method Bipartite (line 55) | public Bipartite(Graph graph) {
    method dfs (line 69) | private void dfs(Graph graph, int v) {
    method isBipartite (line 101) | public boolean isBipartite() {
    method color (line 116) | public boolean color(int v) {
    method oddCycle (line 131) | public Iterable<Integer> oddCycle() {
    method check (line 135) | private boolean check(Graph graph) {
    method validateVertex (line 166) | private void validateVertex(int v) {
    method main (line 177) | public static void main(String[] args) {

FILE: src/main/java/edu/princeton/cs/algs4/BipartiteMatching.java
  class BipartiteMatching (line 56) | public class BipartiteMatching {
    method BipartiteMatching (line 75) | public BipartiteMatching(Graph G) {
    method hasAugmentingPath (line 134) | private boolean hasAugmentingPath(Graph G) {
    method isResidualGraphEdge (line 169) | private boolean isResidualGraphEdge(int v, int w) {
    method mate (line 185) | public int mate(int v) {
    method isMatched (line 200) | public boolean isMatched(int v) {
    method size (line 210) | public int size() {
    method isPerfect (line 222) | public boolean isPerfect() {
    method inMinVertexCover (line 235) | public boolean inMinVertexCover(int v) {
    method validate (line 240) | private void validate(int v) {
    method certifySolution (line 252) | private boolean certifySolution(Graph G) {
    method main (line 312) | public static void main(String[] args) {

FILE: src/main/java/edu/princeton/cs/algs4/BipartiteX.java
  class BipartiteX (line 40) | public class BipartiteX {
    method BipartiteX (line 56) | public BipartiteX(Graph graph) {
    method bfs (line 70) | private void bfs(Graph graph, int s) {
    method isBipartite (line 116) | public boolean isBipartite() {
    method color (line 131) | public boolean color(int v) {
    method oddCycle (line 147) | public Iterable<Integer> oddCycle() {
    method check (line 151) | private boolean check(Graph graph) {
    method validateVertex (line 181) | private void validateVertex(int v) {
    method main (line 192) | public static void main(String[] args) {

FILE: src/main/java/edu/princeton/cs/algs4/BlockFilter.java
  class BlockFilter (line 46) | public class BlockFilter {
    method BlockFilter (line 49) | private BlockFilter() { }
    method main (line 51) | public static void main(String[] args) {

FILE: src/main/java/edu/princeton/cs/algs4/BoruvkaMST.java
  class BoruvkaMST (line 60) | public class BoruvkaMST {
    method BoruvkaMST (line 70) | public BoruvkaMST(EdgeWeightedGraph graph) {
    method edges (line 111) | public Iterable<Edge> edges() {
    method weight (line 120) | public double weight() {
    method less (line 125) | private static boolean less(Edge e, Edge f) {
    method check (line 130) | private boolean check(EdgeWeightedGraph graph) {
    method main (line 193) | public static void main(String[] args) {

FILE: src/main/java/edu/princeton/cs/algs4/BoyerMoore.java
  class BoyerMoore (line 46) | public class BoyerMoore {
    method BoyerMoore (line 58) | public BoyerMoore(String pat) {
    method BoyerMoore (line 76) | public BoyerMoore(char[] pattern, int R) {
    method search (line 98) | public int search(String txt) {
    method search (line 124) | public int search(char[] text) {
    method main (line 149) | public static void main(String[] args) {

FILE: src/main/java/edu/princeton/cs/algs4/BreadthFirstDirectedPaths.java
  class BreadthFirstDirectedPaths (line 50) | public class BreadthFirstDirectedPaths {
    method BreadthFirstDirectedPaths (line 62) | public BreadthFirstDirectedPaths(Digraph digraph, int s) {
    method BreadthFirstDirectedPaths (line 82) | public BreadthFirstDirectedPaths(Digraph digraph, Iterable<Integer> so...
    method bfs (line 93) | private void bfs(Digraph digraph, int s) {
    method bfs (line 112) | private void bfs(Digraph digraph, Iterable<Integer> sources) {
    method hasPathTo (line 138) | public boolean hasPathTo(int v) {
    method distTo (line 151) | public int distTo(int v) {
    method pathTo (line 163) | public Iterable<Integer> pathTo(int v) {
    method validateVertex (line 176) | private void validateVertex(int v) {
    method validateVertices (line 184) | private void validateVertices(Iterable<Integer> vertices) {
    method main (line 206) | public static void main(String[] args) {

FILE: src/main/java/edu/princeton/cs/algs4/BreadthFirstPaths.java
  class BreadthFirstPaths (line 64) | public class BreadthFirstPaths {
    method BreadthFirstPaths (line 77) | public BreadthFirstPaths(Graph graph, int s) {
    method BreadthFirstPaths (line 97) | public BreadthFirstPaths(Graph graph, Iterable<Integer> sources) {
    method bfs (line 109) | private void bfs(Graph graph, int s) {
    method bfs (line 131) | private void bfs(Graph graph, Iterable<Integer> sources) {
    method hasPathTo (line 157) | public boolean hasPathTo(int v) {
    method distTo (line 170) | public int distTo(int v) {
    method pathTo (line 182) | public Iterable<Integer> pathTo(int v) {
    method check (line 195) | private boolean check(Graph graph, int s) {
    method validateVertex (line 239) | private void validateVertex(int v) {
    method validateVertices (line 247) | private void validateVertices(Iterable<Integer> vertices) {
    method main (line 269) | public static void main(String[] args) {

FILE: src/main/java/edu/princeton/cs/algs4/CC.java
  class CC (line 63) | public class CC {
    method CC (line 74) | public CC(Graph graph) {
    method CC (line 91) | public CC(EdgeWeightedGraph graph) {
    method dfs (line 104) | private void dfs(Graph graph, int v) {
    method dfs (line 116) | private void dfs(EdgeWeightedGraph graph, int v) {
    method id (line 136) | public int id(int v) {
    method size (line 148) | public int size(int v) {
    method count (line 158) | public int count() {
    method connected (line 173) | public boolean connected(int v, int w) {
    method areConnected (line 191) | @Deprecated
    method validateVertex (line 199) | private void validateVertex(int v) {
    method main (line 210) | public static void main(String[] args) {

FILE: src/main/java/edu/princeton/cs/algs4/CPM.java
  class CPM (line 51) | public class CPM {
    method CPM (line 54) | private CPM() { }
    method main (line 62) | public static void main(String[] args) {

FILE: src/main/java/edu/princeton/cs/algs4/Cat.java
  class Cat (line 40) | public class Cat {
    method Cat (line 43) | private Cat() { }
    method main (line 52) | public static void main(String[] args) {

FILE: src/main/java/edu/princeton/cs/algs4/ClosestPair.java
  class ClosestPair (line 37) | public class ClosestPair {
    method ClosestPair (line 50) | public ClosestPair(Point2D[] points) {
    method closest (line 91) | private double closest(Point2D[] pointsByX, Point2D[] pointsByY, Point...
    method either (line 137) | public Point2D either() {
    method other (line 147) | public Point2D other() {
    method distance (line 158) | public double distance() {
    method less (line 163) | private static boolean less(Comparable v, Comparable w) {
    method merge (line 169) | private static void merge(Comparable[] a, Comparable[] aux, int lo, in...
    method main (line 196) | public static void main(String[] args) {

FILE: src/main/java/edu/princeton/cs/algs4/CollisionSystem.java
  class CollisionSystem (line 35) | public class CollisionSystem {
    method CollisionSystem (line 48) | public CollisionSystem(Particle[] particles) {
    method predict (line 53) | private void predict(Particle a, double limit) {
    method redraw (line 71) | private void redraw(double limit) {
    method simulate (line 89) | public void simulate(double limit) {
    class Event (line 137) | private static class Event implements Comparable<Event> {
      method Event (line 144) | public Event(double t, Particle a, Particle b) {
      method compareTo (line 155) | public int compareTo(Event that) {
      method isValid (line 160) | public boolean isValid() {
    method main (line 177) | public static void main(String[] args) {

FILE: src/main/java/edu/princeton/cs/algs4/Complex.java
  class Complex (line 50) | public class Complex {
    method Complex (line 60) | public Complex(double real, double imag) {
    method toString (line 71) | public String toString() {
    method abs (line 84) | public double abs() {
    method phase (line 94) | public double phase() {
    method plus (line 104) | public Complex plus(Complex that) {
    method minus (line 117) | public Complex minus(Complex that) {
    method times (line 129) | public Complex times(Complex that) {
    method scale (line 141) | public Complex scale(double alpha) {
    method times (line 152) | @Deprecated
    method conjugate (line 162) | public Complex conjugate() {
    method reciprocal (line 171) | public Complex reciprocal() {
    method re (line 181) | public double re() {
    method im (line 190) | public double im() {
    method divides (line 201) | public Complex divides(Complex that) {
    method exp (line 210) | public Complex exp() {
    method sin (line 219) | public Complex sin() {
    method cos (line 228) | public Complex cos() {
    method tan (line 237) | public Complex tan() {
    method main (line 247) | public static void main(String[] args) {

FILE: src/main/java/edu/princeton/cs/algs4/Count.java
  class Count (line 49) | public class Count {
    method Count (line 52) | private Count() { }
    method main (line 62) | public static void main(String[] args) {

FILE: src/main/java/edu/princeton/cs/algs4/Counter.java
  class Counter (line 33) | public class Counter implements Comparable<Counter> {
    method Counter (line 43) | public Counter(String id) {
    method increment (line 50) | public void increment() {
    method tally (line 59) | public int tally() {
    method toString (line 68) | public String toString() {
    method compareTo (line 83) | @Override
    method main (line 95) | public static void main(String[] args) {

FILE: src/main/java/edu/princeton/cs/algs4/Cycle.java
  class Cycle (line 49) | public class Cycle {
    method Cycle (line 60) | public Cycle(Graph graph) {
    method hasSelfLoop (line 77) | private boolean hasSelfLoop(Graph graph) {
    method hasParallelEdges (line 93) | private boolean hasParallelEdges(Graph graph) {
    method hasCycle (line 123) | public boolean hasCycle() {
    method cycle (line 132) | public Iterable<Integer> cycle() {
    method dfs (line 136) | private void dfs(Graph graph, int u, int v) {
    method main (line 165) | public static void main(String[] args) {

FILE: src/main/java/edu/princeton/cs/algs4/Date.java
  class Date (line 23) | public class Date implements Comparable<Date> {
    method Date (line 37) | public Date(int month, int day, int year) {
    method Date (line 49) | public Date(String date) {
    method month (line 64) | public int month() {
    method day (line 72) | public int day() {
    method year (line 80) | public int year() {
    method isValid (line 86) | private static boolean isValid(int m, int d, int y) {
    method isLeapYear (line 94) | private static boolean isLeapYear(int y) {
    method next (line 105) | public Date next() {
    method isAfter (line 117) | public boolean isAfter(Date that) {
    method isBefore (line 127) | public boolean isBefore(Date that) {
    method compareTo (line 139) | @Override
    method toString (line 155) | @Override
    method equals (line 166) | @Override
    method hashCode (line 180) | @Override
    method main (line 190) | public static void main(String[] args) {

FILE: src/main/java/edu/princeton/cs/algs4/DeDup.java
  class DeDup (line 46) | public class DeDup {
    method DeDup (line 49) | private DeDup() { }
    method main (line 51) | public static void main(String[] args) {

FILE: src/main/java/edu/princeton/cs/algs4/DegreesOfSeparation.java
  class DegreesOfSeparation (line 77) | public class DegreesOfSeparation {
    method DegreesOfSeparation (line 80) | private DegreesOfSeparation() { }
    method main (line 94) | public static void main(String[] args) {

FILE: src/main/java/edu/princeton/cs/algs4/DepthFirstDirectedPaths.java
  class DepthFirstDirectedPaths (line 51) | public class DepthFirstDirectedPaths {
    method DepthFirstDirectedPaths (line 62) | public DepthFirstDirectedPaths(Digraph digraph, int s) {
    method dfs (line 70) | private void dfs(Digraph digraph, int v) {
    method hasPathTo (line 87) | public boolean hasPathTo(int v) {
    method pathTo (line 101) | public Iterable<Integer> pathTo(int v) {
    method validateVertex (line 112) | private void validateVertex(int v) {
    method main (line 123) | public static void main(String[] args) {

FILE: src/main/java/edu/princeton/cs/algs4/DepthFirstOrder.java
  class DepthFirstOrder (line 55) | public class DepthFirstOrder {
    method DepthFirstOrder (line 68) | public DepthFirstOrder(Digraph digraph) {
    method DepthFirstOrder (line 84) | public DepthFirstOrder(EdgeWeightedDigraph digraph) {
    method dfs (line 95) | private void dfs(Digraph digraph, int v) {
    method dfs (line 109) | private void dfs(EdgeWeightedDigraph digraph, int v) {
    method pre (line 129) | public int pre(int v) {
    method post (line 140) | public int post(int v) {
    method post (line 149) | public Iterable<Integer> post() {
    method pre (line 157) | public Iterable<Integer> pre() {
    method reversePost (line 165) | public Iterable<Integer> reversePost() {
    method check (line 174) | private boolean check() {
    method validateVertex (line 200) | private void validateVertex(int v) {
    method main (line 211) | public static void main(String[] args) {

FILE: src/main/java/edu/princeton/cs/algs4/DepthFirstPaths.java
  class DepthFirstPaths (line 52) | public class DepthFirstPaths {
    method DepthFirstPaths (line 63) | public DepthFirstPaths(Graph graph, int s) {
    method dfs (line 72) | private void dfs(Graph graph, int v) {
    method hasPathTo (line 88) | public boolean hasPathTo(int v) {
    method pathTo (line 101) | public Iterable<Integer> pathTo(int v) {
    method validateVertex (line 112) | private void validateVertex(int v) {
    method main (line 123) | public static void main(String[] args) {

FILE: src/main/java/edu/princeton/cs/algs4/DepthFirstSearch.java
  class DepthFirstSearch (line 44) | public class DepthFirstSearch {
    method DepthFirstSearch (line 55) | public DepthFirstSearch(Graph graph, int s) {
    method dfs (line 62) | private void dfs(Graph graph, int v) {
    method marked (line 78) | public boolean marked(int v) {
    method count (line 87) | public int count() {
    method validateVertex (line 92) | private void validateVertex(int v) {
    method main (line 103) | public static void main(String[] args) {

FILE: src/main/java/edu/princeton/cs/algs4/Digraph.java
  class Digraph (line 65) | public class Digraph {
    method Digraph (line 79) | public Digraph(int V) {
    method Digraph (line 102) | public Digraph(In in) {
    method Digraph (line 131) | public Digraph(Digraph digraph) {
    method V (line 166) | public int V() {
    method E (line 175) | public int E() {
    method validateVertex (line 181) | private void validateVertex(int v) {
    method addEdge (line 193) | public void addEdge(int v, int w) {
    method adj (line 208) | public Iterable<Integer> adj(int v) {
    method outdegree (line 221) | public int outdegree(int v) {
    method indegree (line 234) | public int indegree(int v) {
    method reverse (line 244) | public Digraph reverse() {
    method toString (line 260) | public String toString() {
    method toDot (line 295) | public String toDot() {
    method main (line 314) | public static void main(String[] args) {

FILE: src/main/java/edu/princeton/cs/algs4/DigraphGenerator.java
  class DigraphGenerator (line 24) | public class DigraphGenerator {
    class Edge (line 25) | private static final class Edge implements Comparable<Edge> {
      method Edge (line 29) | private Edge(int v, int w) {
      method compareTo (line 34) | public int compareTo(Edge that) {
    method DigraphGenerator (line 44) | private DigraphGenerator() { }
    method simple (line 54) | public static Digraph simple(int V, int E) {
    method simple (line 82) | public static Digraph simple(int V, double p) {
    method complete (line 101) | public static Digraph complete(int V) {
    method dag (line 118) | public static Digraph dag(int V, int E) {
    method tournament (line 146) | public static Digraph tournament(int V) {
    method completeRootedInDAG (line 165) | public static Digraph completeRootedInDAG(int V) {
    method rootedInDAG (line 187) | public static Digraph rootedInDAG(int V, int E) {
    method completeRootedOutDAG (line 226) | public static Digraph completeRootedOutDAG(int V) {
    method rootedOutDAG (line 248) | public static Digraph rootedOutDAG(int V, int E) {
    method rootedInTree (line 288) | public static Digraph rootedInTree(int V) {
    method rootedOutTree (line 300) | public static Digraph rootedOutTree(int V) {
    method path (line 309) | public static Digraph path(int V) {
    method binaryTree (line 326) | public static Digraph binaryTree(int V) {
    method cycle (line 343) | public static Digraph cycle(int V) {
    method eulerianCycle (line 365) | public static Digraph eulerianCycle(int V, int E) {
    method eulerianPath (line 390) | public static Digraph eulerianPath(int V, int E) {
    method strong (line 422) | public static Digraph strong(int V, int E, int c) {
    method main (line 493) | public static void main(String[] args) {

FILE: src/main/java/edu/princeton/cs/algs4/DijkstraAllPairsSP.java
  class DijkstraAllPairsSP (line 35) | public class DijkstraAllPairsSP {
    method DijkstraAllPairsSP (line 45) | public DijkstraAllPairsSP(EdgeWeightedDigraph G) {
    method path (line 60) | public Iterable<DirectedEdge> path(int s, int t) {
    method hasPath (line 75) | public boolean hasPath(int s, int t) {
    method dist (line 90) | public double dist(int s, int t) {
    method validateVertex (line 97) | private void validateVertex(int v) {
    method main (line 109) | public static void main(String[] args) {

FILE: src/main/java/edu/princeton/cs/algs4/DijkstraSP.java
  class DijkstraSP (line 63) | public class DijkstraSP {
    method DijkstraSP (line 77) | public DijkstraSP(EdgeWeightedDigraph digraph, int s) {
    method relax (line 106) | private void relax(DirectedEdge e) {
    method distTo (line 123) | public double distTo(int v) {
    method hasPathTo (line 136) | public boolean hasPathTo(int v) {
    method pathTo (line 149) | public Iterable<DirectedEdge> pathTo(int v) {
    method check (line 163) | private boolean check(EdgeWeightedDigraph digraph, int s) {
    method validateVertex (line 212) | private void validateVertex(int v) {
    method main (line 223) | public static void main(String[] args) {

FILE: src/main/java/edu/princeton/cs/algs4/DijkstraUndirectedSP.java
  class DijkstraUndirectedSP (line 70) | public class DijkstraUndirectedSP {
    method DijkstraUndirectedSP (line 84) | public DijkstraUndirectedSP(EdgeWeightedGraph G, int s) {
    method relax (line 113) | private void relax(Edge e, int v) {
    method distTo (line 132) | public double distTo(int v) {
    method hasPathTo (line 146) | public boolean hasPathTo(int v) {
    method pathTo (line 159) | public Iterable<Edge> pathTo(int v) {
    method check (line 175) | private boolean check(EdgeWeightedGraph G, int s) {
    method validateVertex (line 224) | private void validateVertex(int v) {
    method main (line 235) | public static void main(String[] args) {

FILE: src/main/java/edu/princeton/cs/algs4/DirectedCycle.java
  class DirectedCycle (line 45) | public class DirectedCycle {
    method DirectedCycle (line 56) | public DirectedCycle(Digraph digraph) {
    method dfs (line 65) | private void dfs(Digraph digraph, int v) {
    method hasCycle (line 97) | public boolean hasCycle() {
    method cycle (line 106) | public Iterable<Integer> cycle() {
    method check (line 112) | private boolean check() {
    method main (line 136) | public static void main(String[] args) {

FILE: src/main/java/edu/princeton/cs/algs4/DirectedCycleX.java
  class DirectedCycleX (line 40) | public class DirectedCycleX {
    method DirectedCycleX (line 43) | public DirectedCycleX(Digraph digraph) {
    method cycle (line 104) | public Iterable<Integer> cycle() {
    method hasCycle (line 112) | public boolean hasCycle() {
    method check (line 117) | private boolean check() {
    method main (line 137) | public static void main(String[] args) {

FILE: src/main/java/edu/princeton/cs/algs4/DirectedDFS.java
  class DirectedDFS (line 46) | public class DirectedDFS {
    method DirectedDFS (line 57) | public DirectedDFS(Digraph digraph, int s) {
    method DirectedDFS (line 73) | public DirectedDFS(Digraph digraph, Iterable<Integer> sources) {
    method dfs (line 81) | private void dfs(Digraph digraph, int v) {
    method marked (line 96) | public boolean marked(int v) {
    method count (line 107) | public int count() {
    method validateVertex (line 112) | private void validateVertex(int v) {
    method validateVertices (line 120) | private void validateVertices(Iterable<Integer> vertices) {
    method main (line 142) | public static void main(String[] args) {

FILE: src/main/java/edu/princeton/cs/algs4/DirectedEdge.java
  class DirectedEdge (line 26) | public class DirectedEdge {
    method DirectedEdge (line 41) | public DirectedEdge(int v, int w, double weight) {
    method from (line 54) | public int from() {
    method to (line 62) | public int to() {
    method weight (line 70) | public double weight() {
    method toString (line 78) | public String toString() {
    method main (line 87) | public static void main(String[] args) {

FILE: src/main/java/edu/princeton/cs/algs4/DirectedEulerianCycle.java
  class DirectedEulerianCycle (line 41) | public class DirectedEulerianCycle {
    method DirectedEulerianCycle (line 49) | public DirectedEulerianCycle(Digraph digraph) {
    method cycle (line 96) | public Iterable<Integer> cycle() {
    method hasEulerianCycle (line 106) | public boolean hasEulerianCycle() {
    method nonIsolatedVertex (line 111) | private static int nonIsolatedVertex(Digraph digraph) {
    method satisfiesNecessaryAndSufficientConditions (line 131) | private static boolean satisfiesNecessaryAndSufficientConditions(Digra...
    method certifySolution (line 158) | private boolean certifySolution(Digraph digraph) {
    method unitTest (line 179) | private static void unitTest(Digraph digraph, String description) {
    method main (line 205) | public static void main(String[] args) {

FILE: src/main/java/edu/princeton/cs/algs4/DirectedEulerianPath.java
  class DirectedEulerianPath (line 40) | public class DirectedEulerianPath {
    method DirectedEulerianPath (line 48) | public DirectedEulerianPath(Digraph digraph) {
    method path (line 101) | public Iterable<Integer> path() {
    method hasEulerianPath (line 111) | public boolean hasEulerianPath() {
    method nonIsolatedVertex (line 117) | private static int nonIsolatedVertex(Digraph digraph) {
    method satisfiesNecessaryAndSufficientConditions (line 138) | private static boolean satisfiesNecessaryAndSufficientConditions(Digra...
    method check (line 166) | private boolean check(Digraph digraph) {
    method unitTest (line 187) | private static void unitTest(Digraph digraph, String description) {
    method main (line 212) | public static void main(String[] args) {

FILE: src/main/java/edu/princeton/cs/algs4/DoublingRatio.java
  class DoublingRatio (line 31) | public class DoublingRatio {
    method DoublingRatio (line 35) | private DoublingRatio() { }
    method timeTrial (line 44) | public static double timeTrial(int n) {
    method main (line 61) | public static void main(String[] args) {

FILE: src/main/java/edu/princeton/cs/algs4/DoublingTest.java
  class DoublingTest (line 29) | public class DoublingTest {
    method DoublingTest (line 33) | private DoublingTest() { }
    method timeTrial (line 42) | public static double timeTrial(int n) {
    method main (line 58) | public static void main(String[] args) {

FILE: src/main/java/edu/princeton/cs/algs4/Draw.java
  class Draw (line 97) | public final class Draw implements ActionListener, MouseListener, MouseM...
    method Draw (line 324) | public Draw() {
    method initCanvas (line 330) | private void initCanvas() {
    method initGUI (line 356) | private void initGUI() {
    method setVisible (line 390) | public void setVisible(boolean isVisible) {
    method setLocationOnScreen (line 403) | public void setLocationOnScreen(int x, int y) {
    method setDefaultCloseOperation (line 415) | public void setDefaultCloseOperation(int value) {
    method setCanvasSize (line 424) | public void setCanvasSize() {
    method setCanvasSize (line 438) | public void setCanvasSize(int canvasWidth, int canvasHeight) {
    method createMenuBar (line 450) | private JMenuBar createMenuBar() {
    method close (line 470) | public void close() {
    method validate (line 479) | private static void validate(double x, String name) {
    method validateNonnegative (line 485) | private static void validateNonnegative(double x, String name) {
    method validateNotNull (line 490) | private static void validateNotNull(Object x, String name) {
    method setTitle (line 505) | public void setTitle(String windowTitle) {
    method setXscale (line 518) | public void setXscale() {
    method setYscale (line 525) | public void setYscale() {
    method setXscale (line 537) | public void setXscale(double min, double max) {
    method setYscale (line 554) | public void setYscale(double min, double max) {
    method setScale (line 566) | public void setScale() {
    method setScale (line 578) | public void setScale(double min, double max) {
    method scaleX (line 585) | private double  scaleX(double x) { return width  * (x - xmin) / (xmax ...
    method scaleY (line 586) | private double  scaleY(double y) { return height * (ymax - y) / (ymax ...
    method factorX (line 587) | private double factorX(double w) { return w * width  / Math.abs(xmax -...
    method factorY (line 588) | private double factorY(double h) { return h * height / Math.abs(ymax -...
    method userX (line 589) | private double   userX(double x) { return xmin + x * (xmax - xmin) / w...
    method userY (line 590) | private double   userY(double y) { return ymax - y * (ymax - ymin) / h...
    method clear (line 596) | public void clear() {
    method clear (line 607) | public void clear(Color color) {
    method getPenRadius (line 622) | public double getPenRadius() {
    method setPenRadius (line 629) | public void setPenRadius() {
    method setPenRadius (line 639) | public void setPenRadius(double radius) {
    method getPenColor (line 654) | public Color getPenColor() {
    method getBackgroundColor (line 663) | public Color getBackgroundColor() {
    method setPenColor (line 670) | public void setPenColor() {
    method setPenColor (line 680) | public void setPenColor(Color color) {
    method setPenColor (line 695) | public void setPenColor(int red, int green, int blue) {
    method xorOn (line 706) | public void xorOn() {
    method xorOff (line 713) | public void xorOff() {
    method getJLabel (line 722) | public JLabel getJLabel() {
    method getFont (line 731) | public Font getFont() {
    method setFont (line 738) | public void setFont() {
    method setFont (line 748) | public void setFont(Font font) {
    method line (line 767) | public void line(double x0, double y0, double x1, double y1) {
    method pixel (line 783) | private void pixel(double x, double y) {
    method point (line 796) | public void point(double x, double y) {
    method circle (line 820) | public void circle(double x, double y, double radius) {
    method filledCircle (line 844) | public void filledCircle(double x, double y, double radius) {
    method ellipse (line 872) | public void ellipse(double x, double y, double semiMajorAxis, double s...
    method filledEllipse (line 901) | public void filledEllipse(double x, double y, double semiMajorAxis, do...
    method arc (line 931) | public void arc(double x, double y, double radius, double angle1, doub...
    method square (line 958) | public void square(double x, double y, double halfLength) {
    method filledSquare (line 982) | public void filledSquare(double x, double y, double halfLength) {
    method rectangle (line 1008) | public void rectangle(double x, double y, double halfWidth, double hal...
    method filledRectangle (line 1035) | public void filledRectangle(double x, double y, double halfWidth, doub...
    method polygon (line 1065) | public void polygon(double[] x, double[] y) {
    method filledPolygon (line 1099) | public void filledPolygon(double[] x, double[] y) {
    method getImage (line 1127) | private static Image getImage(String filename) {
    method picture (line 1178) | public void picture(double x, double y, String filename) {
    method picture (line 1207) | public void picture(double x, double y, String filename, double degree...
    method picture (line 1243) | public void picture(double x, double y, String filename, double scaled...
    method picture (line 1284) | public void picture(double x, double y, String filename, double scaled...
    method text (line 1326) | public void text(double x, double y, String text) {
    method text (line 1351) | public void text(double x, double y, String text, double degrees) {
    method textLeft (line 1372) | public void textLeft(double x, double y, String text) {
    method textRight (line 1396) | public void textRight(double x, double y, String text) {
    method show (line 1418) | @Deprecated
    method pause (line 1430) | public void pause(int t) {
    method show (line 1443) | public void show() {
    method draw (line 1457) | private void draw() {
    method enableDoubleBuffering (line 1467) | public void enableDoubleBuffering() {
    method disableDoubleBuffering (line 1477) | public void disableDoubleBuffering() {
    method save (line 1493) | public void save(String filename) {
    method actionPerformed (line 1525) | @Override
    method addListener (line 1552) | public void addListener(DrawListener listener) {
    method isMousePressed (line 1571) | public boolean isMousePressed() {
    method mousePressed (line 1584) | @Deprecated
    method mouseX (line 1595) | public double mouseX() {
    method mouseY (line 1606) | public double mouseY() {
    method mouseEntered (line 1617) | @Override
    method mouseExited (line 1625) | @Override
    method mousePressed (line 1633) | @Override
    method mouseReleased (line 1650) | @Override
    method mouseClicked (line 1664) | @Override
    method mouseDragged (line 1676) | @Override
    method mouseMoved (line 1690) | @Override
    method hasNextKeyTyped (line 1708) | public boolean hasNextKeyTyped() {
    method nextKeyTyped (line 1719) | public char nextKeyTyped() {
    method isKeyPressed (line 1737) | public boolean isKeyPressed(int keycode) {
    method keyTyped (line 1746) | @Override
    method keyPressed (line 1760) | @Override
    method keyReleased (line 1774) | @Override
    method enableTimer (line 1795) | public void enableTimer(int callsPerSecond) {
    method disableTimer (line 1801) | public void disableTimer() {
    class MyTimerTask (line 1805) | private class MyTimerTask extends TimerTask {
      method run (line 1806) | public void run() {
    class RetinaImageIcon (line 1816) | private static class RetinaImageIcon extends ImageIcon {
      method RetinaImageIcon (line 1818) | public RetinaImageIcon(Image image) {
      method getIconWidth (line 1822) | public int getIconWidth() {
      method getIconHeight (line 1831) | public int getIconHeight() {
      method paintIcon (line 1835) | public synchronized void paintIcon(Component c, Graphics g, int x, i...
    method main (line 1851) | public static void main(String[] args) {

FILE: src/main/java/edu/princeton/cs/algs4/DrawListener.java
  type DrawListener (line 27) | public interface DrawListener {
    method mousePressed (line 35) | default void mousePressed(double x, double y) {
    method mouseDragged (line 45) | default void mouseDragged(double x, double y) {
    method mouseReleased (line 55) | default void mouseReleased(double x, double y) {
    method mouseClicked (line 70) | default void mouseClicked(double x, double y) {
    method keyTyped (line 79) | default void keyTyped(char c) {
    method keyPressed (line 88) | default void keyPressed(int keycode) {
    method keyReleased (line 97) | default void keyReleased(int keycode) {
    method update (line 104) | default void update() {

FILE: src/main/java/edu/princeton/cs/algs4/Edge.java
  class Edge (line 26) | public class Edge implements Comparable<Edge> {
    method Edge (line 43) | public Edge(int v, int w, double weight) {
    method weight (line 57) | public double weight() {
    method either (line 66) | public int either() {
    method other (line 78) | public int other(int vertex) {
    method compareTo (line 94) | @Override
    method toString (line 104) | public String toString() {
    method main (line 113) | public static void main(String[] args) {

FILE: src/main/java/edu/princeton/cs/algs4/EdgeWeightedDigraph.java
  class EdgeWeightedDigraph (line 47) | public class EdgeWeightedDigraph {
    method EdgeWeightedDigraph (line 61) | public EdgeWeightedDigraph(int V) {
    method EdgeWeightedDigraph (line 79) | public EdgeWeightedDigraph(int V, int E) {
    method EdgeWeightedDigraph (line 103) | public EdgeWeightedDigraph(In in) {
    method EdgeWeightedDigraph (line 135) | public EdgeWeightedDigraph(EdgeWeightedDigraph G) {
    method V (line 157) | public int V() {
    method E (line 166) | public int E() {
    method validateVertex (line 171) | private void validateVertex(int v) {
    method addEdge (line 183) | public void addEdge(DirectedEdge e) {
    method adj (line 201) | public Iterable<DirectedEdge> adj(int v) {
    method outdegree (line 214) | public int outdegree(int v) {
    method indegree (line 227) | public int indegree(int v) {
    method edges (line 239) | public Iterable<DirectedEdge> edges() {
    method toString (line 255) | public String toString() {
    method toDot (line 290) | public String toDot() {
    method main (line 310) | public static void main(String[] args) {

FILE: src/main/java/edu/princeton/cs/algs4/EdgeWeightedDirectedCycle.java
  class EdgeWeightedDirectedCycle (line 39) | public class EdgeWeightedDirectedCycle {
    method EdgeWeightedDirectedCycle (line 50) | public EdgeWeightedDirectedCycle(EdgeWeightedDigraph G) {
    method dfs (line 62) | private void dfs(EdgeWeightedDigraph G, int v) {
    method hasCycle (line 100) | public boolean hasCycle() {
    method cycle (line 110) | public Iterable<DirectedEdge> cycle() {
    method check (line 116) | private boolean check() {
    method main (line 155) | public static void main(String[] args) {

FILE: src/main/java/edu/princeton/cs/algs4/EdgeWeightedGraph.java
  class EdgeWeightedGraph (line 61) | public class EdgeWeightedGraph {
    method EdgeWeightedGraph (line 74) | public EdgeWeightedGraph(int V) {
    method EdgeWeightedGraph (line 92) | public EdgeWeightedGraph(int V, int E) {
    method EdgeWeightedGraph (line 116) | public EdgeWeightedGraph(In in) {
    method EdgeWeightedGraph (line 149) | public EdgeWeightedGraph(EdgeWeightedGraph G) {
    method V (line 170) | public int V() {
    method E (line 179) | public int E() {
    method validateVertex (line 184) | private void validateVertex(int v) {
    method addEdge (line 195) | public void addEdge(Edge e) {
    method adj (line 212) | public Iterable<Edge> adj(int v) {
    method degree (line 224) | public int degree(int v) {
    method edges (line 236) | public Iterable<Edge> edges() {
    method toString (line 261) | public String toString() {
    method toDot (line 296) | public String toDot() {
    method main (line 315) | public static void main(String[] args) {

FILE: src/main/java/edu/princeton/cs/algs4/EulerianCycle.java
  class EulerianCycle (line 44) | public class EulerianCycle {
    class Edge (line 48) | private static class Edge {
      method Edge (line 53) | public Edge(int v, int w) {
      method other (line 60) | public int other(int vertex) {
    method EulerianCycle (line 72) | public EulerianCycle(Graph graph) {
    method cycle (line 142) | public Iterable<Integer> cycle() {
    method hasEulerianCycle (line 152) | public boolean hasEulerianCycle() {
    method nonIsolatedVertex (line 157) | private static int nonIsolatedVertex(Graph graph) {
    method satisfiesNecessaryAndSufficientConditions (line 175) | private static boolean satisfiesNecessaryAndSufficientConditions(Graph...
    method certifySolution (line 196) | private boolean certifySolution(Graph graph) {
    method unitTest (line 224) | private static void unitTest(Graph graph, String description) {
    method main (line 250) | public static void main(String[] args) {

FILE: src/main/java/edu/princeton/cs/algs4/EulerianPath.java
  class EulerianPath (line 38) | public class EulerianPath {
    class Edge (line 42) | private static class Edge {
      method Edge (line 47) | public Edge(int v, int w) {
      method other (line 54) | public int other(int vertex) {
    method EulerianPath (line 66) | public EulerianPath(Graph graph) {
    method path (line 145) | public Iterable<Integer> path() {
    method hasEulerianPath (line 155) | public boolean hasEulerianPath() {
    method nonIsolatedVertex (line 161) | private static int nonIsolatedVertex(Graph graph) {
    method satisfiesNecessaryAndSufficientConditions (line 180) | private static boolean satisfiesNecessaryAndSufficientConditions(Graph...
    method certifySolution (line 201) | private boolean certifySolution(Graph graph) {
    method unitTest (line 222) | private static void unitTest(Graph graph, String description) {
    method main (line 248) | public static void main(String[] args) {

FILE: src/main/java/edu/princeton/cs/algs4/FFT.java
  class FFT (line 89) | public class FFT {
    method FFT (line 94) | private FFT() { }
    method fft (line 103) | public static Complex[] fft(Complex[] x) {
    method ifft (line 149) | public static Complex[] ifft(Complex[] x) {
    method cconvolve (line 184) | public static Complex[] cconvolve(Complex[] x, Complex[] y) {
    method convolve (line 217) | public static Complex[] convolve(Complex[] x, Complex[] y) {
    method show (line 234) | private static void show(Complex[] x, String title) {
    method main (line 253) | public static void main(String[] args) {

FILE: src/main/java/edu/princeton/cs/algs4/FarthestPair.java
  class FarthestPair (line 41) | public class FarthestPair {
    method FarthestPair (line 54) | public FarthestPair(Point2D[] points) {
    method either (line 122) | public Point2D either() {
    method other (line 132) | public Point2D other() {
    method distance (line 144) | public double distance() {
    method main (line 157) | public static void main(String[] args) {

FILE: src/main/java/edu/princeton/cs/algs4/FenwickTree.java
  class FenwickTree (line 42) | public class FenwickTree {
    method FenwickTree (line 46) | public FenwickTree(int size) {
    method rsq (line 59) | public int rsq(int ind) {
    method rsq (line 82) | public int rsq(int a, int b) {
    method update (line 97) | public void update(int ind, int value) {
    method size (line 106) | public int size() {
    method main (line 131) | public static void main(String[] args) {

FILE: src/main/java/edu/princeton/cs/algs4/FibonacciMinPQ.java
  class FibonacciMinPQ (line 34) | public class FibonacciMinPQ<Key> implements Iterable<Key> {
    class Node (line 42) | private class Node {
    method FibonacciMinPQ (line 54) | public FibonacciMinPQ(Comparator<Key> C) {
    method FibonacciMinPQ (line 62) | public FibonacciMinPQ() {
    method FibonacciMinPQ (line 71) | public FibonacciMinPQ(Key[] a) {
    method FibonacciMinPQ (line 82) | public FibonacciMinPQ(Comparator<Key> C, Key[] a) {
    method isEmpty (line 92) | public boolean isEmpty() {
    method size (line 101) | public int size() {
    method insert (line 110) | public void insert(Key key) {
    method minKey (line 125) | public Key minKey() {
    method delMin (line 136) | public Key delMin() {
    method union (line 159) | public FibonacciMinPQ<Key> union(FibonacciMinPQ<Key> that) {
    method greater (line 171) | private boolean greater(Key n, Key m) {
    method link (line 178) | private void link(Node root1, Node root2) {
    method consolidate (line 188) | private void consolidate() {
    method insert (line 225) | private Node insert(Node x, Node head) {
    method cut (line 239) | private Node cut(Node x, Node head) {
    method meld (line 256) | private Node meld(Node x, Node y) {
    method iterator (line 279) | public Iterator<Key> iterator() {
    class MyIterator (line 283) | private class MyIterator implements Iterator<Key> {
      method MyIterator (line 288) | public MyIterator() {
      method insertAll (line 293) | private void insertAll(Node head) {
      method remove (line 303) | public void remove() {
      method hasNext (line 307) | public boolean hasNext() {
      method next (line 312) | public Key next() {
    class MyComparator (line 323) | private class MyComparator implements Comparator<Key> {
      method compare (line 324) | @Override

FILE: src/main/java/edu/princeton/cs/algs4/FileIndex.java
  class FileIndex (line 43) | public class FileIndex {
    method FileIndex (line 46) | private FileIndex() { }
    method main (line 48) | public static void main(String[] args) {

FILE: src/main/java/edu/princeton/cs/algs4/FlowEdge.java
  class FlowEdge (line 27) | public class FlowEdge {
    method FlowEdge (line 46) | public FlowEdge(int v, int w, double capacity) {
    method FlowEdge (line 69) | public FlowEdge(int v, int w, double capacity, double flow) {
    method FlowEdge (line 85) | public FlowEdge(FlowEdge e) {
    method from (line 96) | public int from() {
    method to (line 104) | public int to() {
    method capacity (line 112) | public double capacity() {
    method flow (line 120) | public double flow() {
    method other (line 133) | public int other(int vertex) {
    method residualCapacityTo (line 149) | public double residualCapacityTo(int vertex) {
    method addResidualFlowTo (line 167) | public void addResidualFlowTo(int vertex, double delta) {
    method toString (line 189) | public String toString() {
    method main (line 199) | public static void main(String[] args) {

FILE: src/main/java/edu/princeton/cs/algs4/FlowNetwork.java
  class FlowNetwork (line 36) | public class FlowNetwork {
    method FlowNetwork (line 48) | public FlowNetwork(int V) {
    method FlowNetwork (line 65) | public FlowNetwork(int V, int E) {
    method FlowNetwork (line 86) | public FlowNetwork(In in) {
    method V (line 105) | public int V() {
    method E (line 113) | public int E() {
    method validateVertex (line 118) | private void validateVertex(int v) {
    method addEdge (line 129) | public void addEdge(FlowEdge e) {
    method adj (line 146) | public Iterable<FlowEdge> adj(int v) {
    method edges (line 152) | public Iterable<FlowEdge> edges() {
    method toString (line 169) | public String toString() {
    method main (line 187) | public static void main(String[] args) {

FILE: src/main/java/edu/princeton/cs/algs4/FloydWarshall.java
  class FloydWarshall (line 50) | public class FloydWarshall {
    method FloydWarshall (line 61) | public FloydWarshall(AdjMatrixEdgeWeightedDigraph G) {
    method hasNegativeCycle (line 111) | public boolean hasNegativeCycle() {
    method negativeCycle (line 120) | public Iterable<DirectedEdge> negativeCycle() {
    method hasPath (line 146) | public boolean hasPath(int s, int t) {
    method dist (line 161) | public double dist(int s, int t) {
    method path (line 178) | public Iterable<DirectedEdge> path(int s, int t) {
    method check (line 192) | private boolean check(AdjMatrixEdgeWeightedDigraph G) {
    method validateVertex (line 212) | private void validateVertex(int v) {
    method main (line 223) | public static void main(String[] args) {

FILE: src/main/java/edu/princeton/cs/algs4/FordFulkerson.java
  class FordFulkerson (line 40) | public class FordFulkerson {
    method FordFulkerson (line 60) | public FordFulkerson(FlowNetwork G, int s, int t) {
    method value (line 94) | public double value()  {
    method inCut (line 106) | public boolean inCut(int v)  {
    method validate (line 112) | private void validate(int v)  {
    method hasAugmentingPath (line 122) | private boolean hasAugmentingPath(FlowNetwork G, int s, int t) {
    method excess (line 154) | private double excess(FlowNetwork G, int v) {
    method isFeasible (line 164) | private boolean isFeasible(FlowNetwork G, int s, int t) {
    method check (line 200) | private boolean check(FlowNetwork G, int s, int t) {
    method main (line 241) | public static void main(String[] args) {

FILE: src/main/java/edu/princeton/cs/algs4/FrequencyCounter.java
  class FrequencyCounter (line 41) | public class FrequencyCounter {
    method FrequencyCounter (line 44) | private FrequencyCounter() { }
    method main (line 55) | public static void main(String[] args) {

FILE: src/main/java/edu/princeton/cs/algs4/GREP.java
  class GREP (line 41) | public class GREP {
    method GREP (line 44) | private GREP() { }
    method main (line 55) | public static void main(String[] args) {

FILE: src/main/java/edu/princeton/cs/algs4/GabowSCC.java
  class GabowSCC (line 55) | public class GabowSCC {
    method GabowSCC (line 70) | public GabowSCC(Digraph digraph) {
    method dfs (line 87) | private void dfs(Digraph digraph, int v) {
    method count (line 116) | public int count() {
    method stronglyConnected (line 129) | public boolean stronglyConnected(int v, int w) {
    method id (line 141) | public int id(int v) {
    method check (line 147) | private boolean check(Digraph digraph) {
    method validateVertex (line 159) | private void validateVertex(int v) {
    method main (line 170) | public static void main(String[] args) {

FILE: src/main/java/edu/princeton/cs/algs4/GaussJordanElimination.java
  class GaussJordanElimination (line 67) | public class GaussJordanElimination {
    method GaussJordanElimination (line 82) | public GaussJordanElimination(double[][] A, double[] b) {
    method solve (line 103) | private void solve() {
    method swap (line 133) | private void swap(int row1, int row2) {
    method pivot (line 141) | private void pivot(int p, int q) {
    method primal (line 167) | public double[] primal() {
    method dual (line 185) | public double[] dual() {
    method isFeasible (line 204) | public boolean isFeasible() {
    method show (line 209) | private void show() {
    method certifySolution (line 225) | private boolean certifySolution(double[][] A, double[] b) {
    method test (line 272) | private static void test(String name, double[][] A, double[] b) {
    method test1 (line 297) | private static void test1() {
    method test2 (line 308) | private static void test2() {
    method test3 (line 320) | private static void test3() {
    method test4 (line 333) | private static void test4() {
    method test5 (line 347) | private static void test5() {
    method test6 (line 358) | private static void test6() {
    method main (line 373) | public static void main(String[] args) {

FILE: src/main/java/edu/princeton/cs/algs4/GaussianElimination.java
  class GaussianElimination (line 64) | public class GaussianElimination {
    method GaussianElimination (line 81) | public GaussianElimination(double[][] A, double[] b) {
    method forwardElimination (line 101) | private void forwardElimination() {
    method swap (line 126) | private void swap(int row1, int row2) {
    method pivot (line 133) | private void pivot(int p) {
    method primal (line 148) | public double[] primal() {
    method isFeasible (line 182) | public boolean isFeasible() {
    method certifySolution (line 188) | private boolean certifySolution(double[][] A, double[] b) {
    method test (line 209) | private static void test(String name, double[][] A, double[] b) {
    method test1 (line 229) | private static void test1() {
    method test2 (line 240) | private static void test2() {
    method test3 (line 251) | private static void test3() {
    method test4 (line 264) | private static void test4() {
    method test5 (line 277) | private static void test5() {
    method test6 (line 288) | private static void test6() {
    method test7 (line 299) | private static void test7() {
    method test8 (line 311) | private static void test8() {
    method test9 (line 323) | private static void test9() {
    method main (line 338) | public static void main(String[] args) {

FILE: src/main/java/edu/princeton/cs/algs4/Genome.java
  class Genome (line 31) | public class Genome {
    method Genome (line 34) | private Genome() { }
    method compress (line 41) | public static void compress() {
    method expand (line 60) | public static void expand() {
    method main (line 78) | public static void main(String[] args) {

FILE: src/main/java/edu/princeton/cs/algs4/GlobalMincut.java
  class GlobalMincut (line 50) | public class GlobalMincut {
    class CutPhase (line 69) | private class CutPhase {
      method CutPhase (line 74) | public CutPhase(double weight, int s, int t) {
    method GlobalMincut (line 89) | public GlobalMincut(EdgeWeightedGraph G) {
    method validate (line 103) | private void validate(EdgeWeightedGraph G) {
    method weight (line 115) | public double weight() {
    method cut (line 132) | public boolean cut(int v) {
    method makeCut (line 146) | private void makeCut(int t, UF uf) {
    method minCut (line 160) | private void minCut(EdgeWeightedGraph G, int a) {
    method minCutPhase (line 190) | private void minCutPhase(EdgeWeightedGraph G, boolean[] marked, CutPha...
    method contractEdge (line 221) | private EdgeWeightedGraph contractEdge(EdgeWeightedGraph G, int s, int...
    method check (line 243) | private boolean check(EdgeWeightedGraph G) {
    method validateVertex (line 267) | private void validateVertex(int v) {
    method main (line 278) | public static void main(String[] args) {

FILE: src/main/java/edu/princeton/cs/algs4/GrahamScan.java
  class GrahamScan (line 46) | public class GrahamScan {
    method GrahamScan (line 57) | public GrahamScan(Point2D[] points) {
    method hull (line 111) | public Iterable<Point2D> hull() {
    method isConvex (line 118) | private boolean isConvex() {
    method main (line 145) | public static void main(String[] args) {

FILE: src/main/java/edu/princeton/cs/algs4/Graph.java
  class Graph (line 71) | public class Graph {
    method Graph (line 85) | public Graph(int V) {
    method Graph (line 107) | public Graph(In in) {
    method Graph (line 138) | public Graph(Graph graph) {
    method V (line 166) | public int V() {
    method E (line 175) | public int E() {
    method validateVertex (line 180) | private void validateVertex(int v) {
    method addEdge (line 192) | public void addEdge(int v, int w) {
    method adj (line 208) | public Iterable<Integer> adj(int v) {
    method degree (line 220) | public int degree(int v) {
    method toString (line 232) | public String toString() {
    method toDot (line 267) | public String toDot() {
    method main (line 295) | public static void main(String[] args) {

FILE: src/main/java/edu/princeton/cs/algs4/GraphGenerator.java
  class GraphGenerator (line 26) | public class GraphGenerator {
    class Edge (line 27) | private static final class Edge implements Comparable<Edge> {
      method Edge (line 31) | private Edge(int v, int w) {
      method compareTo (line 42) | public int compareTo(Edge that) {
    method GraphGenerator (line 52) | private GraphGenerator() { }
    method simple (line 62) | public static Graph simple(int V, int E) {
    method simple (line 89) | public static Graph simple(int V, double p) {
    method complete (line 105) | public static Graph complete(int V) {
    method completeBipartite (line 116) | public static Graph completeBipartite(int V1, int V2) {
    method bipartite (line 130) | public static Graph bipartite(int V1, int V2, int E) {
    method bipartite (line 163) | public static Graph bipartite(int V1, int V2, double p) {
    method path (line 183) | public static Graph path(int V) {
    method binaryTree (line 200) | public static Graph binaryTree(int V) {
    method cycle (line 217) | public static Graph cycle(int V) {
    method eulerianCycle (line 239) | public static Graph eulerianCycle(int V, int E) {
    method eulerianPath (line 264) | public static Graph eulerianPath(int V, int E) {
    method wheel (line 285) | public static Graph wheel(int V) {
    method star (line 313) | public static Graph star(int V) {
    method regular (line 338) | public static Graph regular(int V, int k) {
    method tree (line 366) | public static Graph tree(int V) {
    method main (line 409) | public static void main(String[] args) {

FILE: src/main/java/edu/princeton/cs/algs4/GrayscalePicture.java
  class GrayscalePicture (line 85) | public final class GrayscalePicture implements ActionListener {
    method GrayscalePicture (line 102) | public GrayscalePicture(int width, int height) {
    method GrayscalePicture (line 116) | public GrayscalePicture(GrayscalePicture picture) {
    method GrayscalePicture (line 136) | public GrayscalePicture(String filename) {
    method toGray (line 188) | private static Color toGray(Color color) {
    method getJLabel (line 202) | public JLabel getJLabel() {
    method setOriginUpperLeft (line 211) | public void setOriginUpperLeft() {
    method setOriginLowerLeft (line 218) | public void setOriginLowerLeft() {
    method show (line 225) | public void show() {
    method hide (line 263) | public void hide() {
    method isVisible (line 274) | public boolean isVisible() {
    method height (line 283) | public int height() {
    method width (line 292) | public int width() {
    method validateRowIndex (line 296) | private void validateRowIndex(int row) {
    method validateColumnIndex (line 301) | private void validateColumnIndex(int col) {
    method validateGrayscaleValue (line 306) | private void validateGrayscaleValue(int gray) {
    method get (line 319) | public Color get(int col, int row) {
    method getGrayscale (line 337) | public int getGrayscale(int col, int row) {
    method set (line 353) | public void set(int col, int row, Color color) {
    method setGrayscale (line 370) | public void setGrayscale(int col, int row, int gray) {
    method equals (line 386) | public boolean equals(Object other) {
    method toString (line 406) | public String toString() {
    method hashCode (line 427) | public int hashCode() {
    method save (line 441) | public void save(String filename) {
    method save (line 453) | public void save(File file) {
    method actionPerformed (line 485) | @Override
    method main (line 509) | public static void main(String[] args) {

FILE: src/main/java/edu/princeton/cs/algs4/Heap.java
  class Heap (line 45) | public class Heap {
    method Heap (line 48) | private Heap() { }
    method sort (line 54) | public static void sort(Comparable[] pq) {
    method sink (line 73) | private static void sink(Comparable[] pq, int k, int n) {
    method less (line 87) | private static boolean less(Comparable[] pq, int i, int j) {
    method exch (line 91) | private static void exch(Object[] pq, int i, int j) {
    method show (line 98) | private static void show(Comparable[] a) {
    method main (line 110) | public static void main(String[] args) {

FILE: src/main/java/edu/princeton/cs/algs4/HexDump.java
  class HexDump (line 45) | public class HexDump {
    method HexDump (line 48) | private HexDump() { }
    method main (line 59) | public static void main(String[] args) {

FILE: src/main/java/edu/princeton/cs/algs4/HopcroftKarp.java
  class HopcroftKarp (line 56) | public class HopcroftKarp {
    method HopcroftKarp (line 75) | public HopcroftKarp(Graph G) {
    method toString (line 147) | private static String toString(Iterable<Integer> path) {
    method isLevelGraphEdge (line 157) | private boolean isLevelGraphEdge(int v, int w) {
    method isResidualGraphEdge (line 162) | private boolean isResidualGraphEdge(int v, int w) {
    method hasAugmentingPath (line 179) | private boolean hasAugmentingPath(Graph G) {
    method mate (line 233) | public int mate(int v) {
    method isMatched (line 248) | public boolean isMatched(int v) {
    method size (line 258) | public int size() {
    method isPerfect (line 270) | public boolean isPerfect() {
    method inMinVertexCover (line 283) | public boolean inMinVertexCover(int v) {
    method validate (line 289) | private void validate(int v) {
    method certifySolution (line 301) | private boolean certifySolution(Graph G) {
    method main (line 361) | public static void main(String[] args) {

FILE: src/main/java/edu/princeton/cs/algs4/Huffman.java
  class Huffman (line 37) | public class Huffman {
    method Huffman (line 43) | private Huffman() { }
    class Node (line 46) | private static class Node implements Comparable<Node> {
      method Node (line 51) | Node(char ch, int freq, Node left, Node right) {
      method isLeaf (line 59) | private boolean isLeaf() {
      method compareTo (line 65) | public int compareTo(Node that) {
    method compress (line 75) | public static void compress() {
    method buildTrie (line 117) | private static Node buildTrie(int[] freq) {
    method writeTrie (line 137) | private static void writeTrie(Node x) {
    method buildCode (line 149) | private static void buildCode(String[] st, Node x, String s) {
    method expand (line 163) | public static void expand() {
    method readTrie (line 185) | private static Node readTrie() {
    method main (line 201) | public static void main(String[] args) {

FILE: src/main/java/edu/princeton/cs/algs4/In.java
  class In (line 59) | public final class In {
    method In (line 87) | public In() {
    method In (line 99) | public In(Socket socket) {
    method In (line 118) | public In(URL url) {
    method In (line 138) | public In(File file) {
    method In (line 161) | public In(String name) {
    method In (line 217) | public In(Scanner scanner) {
    method exists (line 227) | public boolean exists()  {
    method isEmpty (line 242) | public boolean isEmpty() {
    method hasNextLine (line 255) | public boolean hasNextLine() {
    method hasNextChar (line 267) | public boolean hasNextChar() {
    method readLine (line 280) | public String readLine() {
    method readChar (line 297) | public char readChar() {
    method readAll (line 318) | public String readAll() {
    method readString (line 335) | public String readString() {
    method readInt (line 353) | public int readInt() {
    method readDouble (line 376) | public double readDouble() {
    method readFloat (line 399) | public float readFloat() {
    method readLong (line 422) | public long readLong() {
    method readShort (line 445) | public short readShort() {
    method readByte (line 470) | public byte readByte() {
    method readBoolean (line 494) | public boolean readBoolean() {
    method readAllStrings (line 516) | public String[] readAllStrings() {
    method readAllLines (line 534) | public String[] readAllLines() {
    method readAllInts (line 549) | public int[] readAllInts() {
    method readAllLongs (line 563) | public long[] readAllLongs() {
    method readAllDoubles (line 577) | public double[] readAllDoubles() {
    method close (line 590) | public void close() {
    method readInts (line 602) | @Deprecated
    method readDoubles (line 615) | @Deprecated
    method readStrings (line 628) | @Deprecated
    method readInts (line 640) | @Deprecated
    method readDoubles (line 652) | @Deprecated
    method readStrings (line 664) | @Deprecated
    method main (line 674) | public static void main(String[] args) {

FILE: src/main/java/edu/princeton/cs/algs4/IndexBinomialMinPQ.java
  class IndexBinomialMinPQ (line 35) | public class IndexBinomialMinPQ<Key> implements Iterable<Integer> {
    class Node (line 42) | private class Node<Key> {
    method IndexBinomialMinPQ (line 56) | public IndexBinomialMinPQ(int N) {
    method IndexBinomialMinPQ (line 70) | public IndexBinomialMinPQ(int N, Comparator<Key> comparator) {
    method isEmpty (line 82) | public boolean isEmpty() {
    method contains (line 93) | public boolean contains(int i) {
    method size (line 103) | public int size() {
    method insert (line 121) | public void insert(int i, Key key) {
    method minIndex (line 141) | public int minIndex() {
    method minKey (line 159) | public Key minKey() {
    method delMin (line 177) | public int delMin() {
    method keyOf (line 208) | public Key keyOf(int i) {
    method changeKey (line 223) | public void changeKey(int i, Key key) {
    method decreaseKey (line 240) | public void decreaseKey(int i, Key key) {
    method increaseKey (line 259) | public void increaseKey(int i, Key key) {
    method delete (line 275) | public void delete(int i) {
    method greater (line 304) | private boolean greater(Key n, Key m) {
    method exchange (line 311) | private void exchange(Node<Key> x, Node<Key> y) {
    method link (line 319) | private void link(Node<Key> root1, Node<Key> root2) {
    method swim (line 331) | private void swim(int i) {
    method toTheRoot (line 342) | private void toTheRoot(int i) {
    method erase (line 357) | private Node<Key> erase(int i) {
    method eraseMin (line 372) | private Node<Key> eraseMin() {
    method merge (line 394) | private Node<Key> merge(Node<Key> h, Node<Key> x, Node<Key> y) {
    method union (line 406) | private IndexBinomialMinPQ<Key> union(IndexBinomialMinPQ<Key> heap) {
    method IndexBinomialMinPQ (line 435) | private IndexBinomialMinPQ() { comparator = null; }
    method iterator (line 450) | public Iterator<Integer> iterator() {
    class MyIterator (line 454) | private class MyIterator implements Iterator<Integer> {
      method MyIterator (line 459) | public MyIterator() {
      method clone (line 464) | private Node<Key> clone(Node<Key> x, Node<Key> parent) {
      method hasNext (line 476) | public boolean hasNext() {
      method next (line 480) | public Integer next() {
      method remove (line 485) | public void remove() {
    class MyComparator (line 495) | private class MyComparator implements Comparator<Key> {
      method compare (line 496) | @Override

FILE: src/main/java/edu/princeton/cs/algs4/IndexFibonacciMinPQ.java
  class IndexFibonacciMinPQ (line 39) | public class IndexFibonacciMinPQ<Key> implements Iterable<Integer> {
    class Node (line 49) | private class Node<Key> {
    method IndexFibonacciMinPQ (line 64) | public IndexFibonacciMinPQ(int N) {
    method IndexFibonacciMinPQ (line 78) | public IndexFibonacciMinPQ(Comparator<Key> C, int N) {
    method isEmpty (line 91) | public boolean isEmpty() {
    method contains (line 103) | public boolean contains(int i) {
    method size (line 114) | public int size() {
    method insert (line 127) | public void insert(int i, Key key) {
    method minIndex (line 147) | public int minIndex() {
    method minKey (line 159) | public Key minKey() {
    method delMin (line 171) | public int delMin() {
    method keyOf (line 201) | public Key keyOf(int i) {
    method changeKey (line 217) | public void changeKey(int i, Key key) {
    method decreaseKey (line 234) | public void decreaseKey(int i, Key key) {
    method increaseKey (line 256) | public void increaseKey(int i, Key key) {
    method delete (line 272) | public void delete(int i) {
    method greater (line 302) | private boolean greater(Key n, Key m) {
    method link (line 309) | private void link(Node<Key> root1, Node<Key> root2) {
    method cut (line 321) | private void cut(int i) {
    method consolidate (line 339) | private void consolidate() {
    method insert (line 374) | private Node<Key> insert(Node<Key> x, Node<Key> head) {
    method cut (line 388) | private Node<Key> cut(Node<Key> x, Node<Key> head) {
    method meld (line 405) | private Node<Key> meld(Node<Key> x, Node<Key> y) {
    method iterator (line 428) | public Iterator<Integer> iterator() {
    class MyIterator (line 432) | private class MyIterator implements Iterator<Integer> {
      method MyIterator (line 437) | public MyIterator() {
      method remove (line 444) | public void remove() {
      method hasNext (line 448) | public boolean hasNext() {
      method next (line 453) | public Integer next() {
    class MyComparator (line 464) | private class MyComparator implements Comparator<Key> {
      method compare (line 465) | @Override

FILE: src/main/java/edu/princeton/cs/algs4/IndexMaxPQ.java
  class IndexMaxPQ (line 44) | public class IndexMaxPQ<Key extends Comparable<Key>> implements Iterable...
    method IndexMaxPQ (line 58) | public IndexMaxPQ(int maxN) {
    method isEmpty (line 75) | public boolean isEmpty() {
    method contains (line 87) | public boolean contains(int i) {
    method size (line 97) | public int size() {
    method insert (line 110) | public void insert(int i, Key key) {
    method maxIndex (line 126) | public int maxIndex() {
    method maxKey (line 137) | public Key maxKey() {
    method delMax (line 148) | public int delMax() {
    method keyOf (line 169) | public Key keyOf(int i) {
    method changeKey (line 182) | public void changeKey(int i, Key key) {
    method change (line 198) | @Deprecated
    method increaseKey (line 213) | public void increaseKey(int i, Key key) {
    method decreaseKey (line 234) | public void decreaseKey(int i, Key key) {
    method delete (line 252) | public void delete(int i) {
    method validateIndex (line 264) | private void validateIndex(int i) {
    method less (line 272) | private boolean less(int i, int j) {
    method exch (line 276) | private void exch(int i, int j) {
    method swim (line 288) | private void swim(int k) {
    method sink (line 295) | private void sink(int k) {
    method iterator (line 313) | public Iterator<Integer> iterator() {
    class HeapIterator (line 317) | private class HeapIterator implements Iterator<Integer> {
      method HeapIterator (line 323) | public HeapIterator() {
      method hasNext (line 329) | public boolean hasNext()  { return !copy.isEmpty();                 ...
      method remove (line 330) | public void remove()      { throw new UnsupportedOperationException(...
      method next (line 332) | public Integer next() {
    method main (line 343) | public static void main(String[] args) {

FILE: src/main/java/edu/princeton/cs/algs4/IndexMinPQ.java
  class IndexMinPQ (line 44) | public class IndexMinPQ<Key extends Comparable<Key>> implements Iterable...
    method IndexMinPQ (line 58) | public IndexMinPQ(int maxN) {
    method isEmpty (line 75) | public boolean isEmpty() {
    method contains (line 87) | public boolean contains(int i) {
    method size (line 97) | public int size() {
    method insert (line 110) | public void insert(int i, Key key) {
    method minIndex (line 126) | public int minIndex() {
    method minKey (line 137) | public Key minKey() {
    method delMin (line 147) | public int delMin() {
    method keyOf (line 167) | public Key keyOf(int i) {
    method changeKey (line 181) | public void changeKey(int i, Key key) {
    method change (line 197) | @Deprecated
    method decreaseKey (line 211) | public void decreaseKey(int i, Key key) {
    method increaseKey (line 231) | public void increaseKey(int i, Key key) {
    method delete (line 249) | public void delete(int i) {
    method validateIndex (line 261) | private void validateIndex(int i) {
    method greater (line 269) | private boolean greater(int i, int j) {
    method exch (line 273) | private void exch(int i, int j) {
    method swim (line 285) | private void swim(int k) {
    method sink (line 292) | private void sink(int k) {
    method iterator (line 314) | public Iterator<Integer> iterator() { return new HeapIterator(); }
    class HeapIterator (line 316) | private class HeapIterator implements Iterator<Integer> {
      method HeapIterator (line 322) | public HeapIterator() {
      method hasNext (line 328) | public boolean hasNext()  { return !copy.isEmpty();                 ...
      method remove (line 329) | public void remove()      { throw new UnsupportedOperationException(...
      method next (line 331) | public Integer next() {
    method main (line 343) | public static void main(String[] args) {

FILE: src/main/java/edu/princeton/cs/algs4/IndexMultiwayMinPQ.java
  class IndexMultiwayMinPQ (line 40) | public class IndexMultiwayMinPQ<Key> implements Iterable<Integer> {
    method IndexMultiwayMinPQ (line 58) | public IndexMultiwayMinPQ(int N, int D) {
    method IndexMultiwayMinPQ (line 79) | public IndexMultiwayMinPQ(int N, Comparator<Key> C, int D) {
    method isEmpty (line 96) | public boolean isEmpty() {
    method contains (line 107) | public boolean contains(int i) {
    method size (line 117) | public int size() {
    method insert (line 129) | public void insert(int i, Key key) {
    method minIndex (line 144) | public int minIndex() {
    method minKey (line 155) | public Key minKey() {
    method delMin (line 166) | public int delMin() {
    method keyOf (line 185) | public Key keyOf(int i) {
    method changeKey (line 200) | public void changeKey(int i, Key key) {
    method decreaseKey (line 218) | public void decreaseKey(int i, Key key) {
    method increaseKey (line 235) | public void increaseKey(int i, Key key) {
    method delete (line 250) | public void delete(int i) {
    method greater (line 266) | private boolean greater(int i, int j) {
    method exch (line 271) | private void exch(int x, int y) {
    method swim (line 285) | private void swim(int i) {
    method sink (line 293) | private void sink(int i) {
    method minChild (line 308) | private int minChild(int i) {
    method iterator (line 330) | public Iterator<Integer> iterator() {
    class MyIterator (line 335) | private class MyIterator implements Iterator<Integer> {
      method MyIterator (line 338) | public MyIterator() {
      method hasNext (line 345) | public boolean hasNext() {
      method next (line 349) | public Integer next() {
      method remove (line 354) | public void remove() {
    class MyComparator (line 364) | private class MyComparator implements Comparator<Key> {
      method compare (line 365) | @Override

FILE: src/main/java/edu/princeton/cs/algs4/InplaceMSD.java
  class InplaceMSD (line 41) | public class InplaceMSD {
    method InplaceMSD (line 46) | private InplaceMSD() { }
    method sort (line 54) | public static void sort(String[] a) {
    method charAt (line 60) | private static int charAt(String s, int d) {
    method sort (line 67) | private static void sort(String[] a, int lo, int hi, int d) {
    method insertion (line 109) | private static void insertion(String[] a, int lo, int hi, int d) {
    method exch (line 116) | private static void exch(String[] a, int i, int j) {
    method less (line 123) | private static boolean less(String v, String w, int d) {
    method main (line 140) | public static void main(String[] args) {

FILE: src/main/java/edu/princeton/cs/algs4/Insertion.java
  class Insertion (line 51) | public class Insertion {
    method Insertion (line 54) | private Insertion() { }
    method sort (line 60) | public static void sort(Comparable[] a) {
    method sort (line 77) | public static void sort(Comparable[] a, int lo, int hi) {
    method sort (line 91) | public static void sort(Object[] a, Comparator comparator) {
    method sort (line 109) | public static void sort(Object[] a, int lo, int hi, Comparator compara...
    method indexSort (line 127) | public static int[] indexSort(Comparable[] a) {
    method less (line 145) | private static boolean less(Comparable v, Comparable w) {
    method less (line 150) | private static boolean less(Object v, Object w, Comparator comparator) {
    method exch (line 155) | private static void exch(Object[] a, int i, int j) {
    method exch (line 162) | private static void exch(int[] a, int i, int j) {
    method isSorted (line 171) | private static boolean isSorted(Comparable[] a) {
    method isSorted (line 176) | private static boolean isSorted(Comparable[] a, int lo, int hi) {
    method isSorted (line 182) | private static boolean isSorted(Object[] a, Comparator comparator) {
    method isSorted (line 187) | private static boolean isSorted(Object[] a, int lo, int hi, Comparator...
    method show (line 194) | private static void show(Comparable[] a) {
    method main (line 206) | public static void main(String[] args) {

FILE: src/main/java/edu/princeton/cs/algs4/InsertionX.java
  class InsertionX (line 48) | public class InsertionX {
    method InsertionX (line 51) | private InsertionX() { }
    method sort (line 57) | public static void sort(Comparable[] a) {
    method less (line 91) | private static boolean less(Comparable v, Comparable w) {
    method exch (line 96) | private static void exch(Object[] a, int i, int j) {
    method isSorted (line 106) | private static boolean isSorted(Comparable[] a) {
    method show (line 113) | private static void show(Comparable[] a) {
    method main (line 125) | public static void main(String[] args) {

FILE: src/main/java/edu/princeton/cs/algs4/Interval1D.java
  class Interval1D (line 29) | public class Interval1D {
    method Interval1D (line 60) | public Interval1D(double min, double max) {
    method left (line 83) | @Deprecated
    method right (line 93) | @Deprecated
    method min (line 103) | public double min() {
    method max (line 112) | public double max() {
    method intersects (line 123) | public boolean intersects(Interval1D that) {
    method contains (line 136) | public boolean contains(Interval1D that) {
    method contains (line 147) | public boolean contains(double x) {
    method length (line 156) | public double length() {
    method toString (line 165) | public String toString() {
    method equals (line 176) | public boolean equals(Object other) {
    method hashCode (line 189) | public int hashCode() {
    class MinEndpointComparator (line 196) | private static class MinEndpointComparator implements Comparator<Inter...
      method compare (line 197) | public int compare(Interval1D a, Interval1D b) {
    class MaxEndpointComparator (line 207) | private static class MaxEndpointComparator implements Comparator<Inter...
      method compare (line 208) | public int compare(Interval1D a, Interval1D b) {
    class LengthComparator (line 218) | private static class LengthComparator implements Comparator<Interval1D> {
      method compare (line 219) | public int compare(Interval1D a, Interval1D b) {
    method main (line 236) | public static void main(String[] args) {

FILE: src/main/java/edu/princeton/cs/algs4/Interval2D.java
  class Interval2D (line 29) | public class Interval2D {
    method Interval2D (line 38) | public Interval2D(Interval1D x, Interval1D y) {
    method intersects (line 49) | public boolean intersects(Interval2D that) {
    method contains (line 61) | public boolean contains(Interval2D that) {
    method contains (line 70) | public boolean contains(Point2D p) {
    method area (line 78) | public double area() {
    method toString (line 87) | public String toString() {
    method equals (line 96) | public boolean equals(Object other) {
    method hashCode (line 109) | public int hashCode() {
    method draw (line 118) | public void draw() {
    method main (line 129) | public static void main(String[] args) {

FILE: src/main/java/edu/princeton/cs/algs4/Inversions.java
  class Inversions (line 30) | public class Inversions {
    method Inversions (line 33) | private Inversions() { }
    method merge (line 36) | private static long merge(int[] a, int[] aux, int lo, int mid, int hi) {
    method count (line 57) | private static long count(int[] a, int[] b, int[] aux, int lo, int hi) {
    method count (line 77) | public static long count(int[] a) {
    method merge (line 89) | private static <Key extends Comparable<Key>> long merge(Key[] a, Key[]...
    method count (line 110) | private static <Key extends Comparable<Key>> long count(Key[] a, Key[]...
    method count (line 131) | public static <Key extends Comparable<Key>> long count(Key[] a) {
    method less (line 140) | private static <Key extends Comparable<Key>> boolean less(Key v, Key w) {
    method brute (line 145) | private static <Key extends Comparable<Key>> long brute(Key[] a, int l...
    method brute (line 154) | private static long brute(int[] a, int lo, int hi) {
    method main (line 168) | public static void main(String[] args) {

FILE: src/main/java/edu/princeton/cs/algs4/KMP.java
  class KMP (line 48) | public class KMP {
    method KMP (line 58) | public KMP(String pat) {
    method KMP (line 79) | public KMP(char[] pattern, int R) {
    method search (line 103) | public int search(String txt) {
    method search (line 123) | public int search(char[] text) {
    method main (line 143) | public static void main(String[] args) {

FILE: src/main/java/edu/princeton/cs/algs4/KWIK.java
  class KWIK (line 52) | public class KWIK {
    method KWIK (line 55) | private KWIK() { }
    method main (line 67) | public static void main(String[] args) {

FILE: src/main/java/edu/princeton/cs/algs4/Knuth.java
  class Knuth (line 65) | public class Knuth {
    method Knuth (line 68) | private Knuth() { }
    method shuffle (line 76) | public static void shuffle(Object[] a) {
    method shuffleAlternate (line 93) | public static void shuffleAlternate(Object[] a) {
    method main (line 110) | public static void main(String[] args) {

FILE: src/main/java/edu/princeton/cs/algs4/KosarajuSharirSCC.java
  class KosarajuSharirSCC (line 97) | public class KosarajuSharirSCC {
    method KosarajuSharirSCC (line 106) | public KosarajuSharirSCC(Digraph digraph) {
    method dfs (line 126) | private void dfs(Digraph digraph, int v) {
    method count (line 138) | public int count() {
    method stronglyConnected (line 151) | public boolean stronglyConnected(int v, int w) {
    method id (line 163) | public int id(int v) {
    method check (line 169) | private boolean check(Digraph digraph) {
    method validateVertex (line 181) | private void validateVertex(int v) {
    method main (line 192) | public static void main(String[] args) {

FILE: src/main/java/edu/princeton/cs/algs4/KruskalMST.java
  class KruskalMST (line 73) | public class KruskalMST {
    method KruskalMST (line 83) | public KruskalMST(EdgeWeightedGraph graph) {
    method edges (line 117) | public Iterable<Edge> edges() {
    method weight (line 125) | public double weight() {
    method check (line 130) | private boolean check(EdgeWeightedGraph graph) {
    method main (line 194) | public static void main(String[] args) {

FILE: src/main/java/edu/princeton/cs/algs4/LSD.java
  class LSD (line 43) | public class LSD {
    method LSD (line 47) | private LSD() { }
    method sort (line 55) | public static void sort(String[] a, int w) {
    method sort (line 88) | public static void sort(int[] a) {
    method main (line 143) | public static void main(String[] args) {

FILE: src/main/java/edu/princeton/cs/algs4/LZW.java
  class LZW (line 35) | public class LZW {
    method LZW (line 41) | private LZW() { }
    method compress (line 48) | public static void compress() {
    method expand (line 75) | public static void expand() {
    method main (line 106) | public static void main(String[] args) {

FILE: src/main/java/edu/princeton/cs/algs4/LazyPrimMST.java
  class LazyPrimMST (line 72) | public class LazyPrimMST {
    method LazyPrimMST (line 84) | public LazyPrimMST(EdgeWeightedGraph G) {
    method prim (line 96) | private void prim(EdgeWeightedGraph G, int s) {
    method scan (line 111) | private void scan(EdgeWeightedGraph G, int v) {
    method edges (line 123) | public Iterable<Edge> edges() {
    method weight (line 131) | public double weight() {
    method check (line 136) | private boolean check(EdgeWeightedGraph G) {
    method main (line 200) | public static void main(String[] args) {

FILE: src/main/java/edu/princeton/cs/algs4/LinearProbingHashST.java
  class LinearProbingHashST (line 43) | public class LinearProbingHashST<Key, Value> {
    method LinearProbingHashST (line 57) | public LinearProbingHashST() {
    method LinearProbingHashST (line 66) | public LinearProbingHashST(int capacity) {
    method size (line 78) | public int size() {
    method isEmpty (line 88) | public boolean isEmpty() {
    method contains (line 100) | public boolean contains(Key key) {
    method hashTextbook (line 106) | private int hashTextbook(Key key) {
    method hash (line 112) | private int hash(Key key) {
    method resize (line 119) | private void resize(int capacity) {
    method put (line 141) | public void put(Key key, Value val) {
    method get (line 171) | public Value get(Key key) {
    method delete (line 186) | public void delete(Key key) {
    method keys (line 228) | public Iterable<Key> keys() {
    method check (line 237) | private boolean check() {
    method main (line 262) | public static void main(String[] args) {

FILE: src/main/java/edu/princeton/cs/algs4/LinearProgramming.java
  class LinearProgramming (line 45) | public class LinearProgramming {
    method LinearProgramming (line 65) | public LinearProgramming(double[][] A, double[] b, double[] c) {
    method solve (line 93) | private void solve() {
    method bland (line 113) | private int bland() {
    method dantzig (line 120) | private int dantzig() {
    method minRatioRule (line 131) | private int minRatioRule(int q) {
    method pivot (line 143) | private void pivot(int p, int q) {
    method value (line 166) | public double value() {
    method primal (line 175) | public double[] primal() {
    method dual (line 187) | public double[] dual() {
    method isPrimalFeasible (line 198) | private boolean isPrimalFeasible(double[][] A, double[] b) {
    method isDualFeasible (line 225) | private boolean isDualFeasible(double[][] A, double[] c) {
    method isOptimal (line 252) | private boolean isOptimal(double[] b, double[] c) {
    method check (line 272) | private boolean check(double[][]A, double[] b, double[] c) {
    method show (line 277) | private void show() {
    method test (line 294) | private static void test(double[][] A, double[] b, double[] c) {
    method test1 (line 313) | private static void test1() {
    method test2 (line 328) | private static void test2() {
    method test3 (line 340) | private static void test3() {
    method test4 (line 351) | private static void test4() {
    method main (line 368) | public static void main(String[] args) {

FILE: src/main/java/edu/princeton/cs/algs4/LinearRegression.java
  class LinearRegression (line 28) | public class LinearRegression {
    method LinearRegression (line 40) | public LinearRegression(double[] x, double[] y) {
    method intercept (line 87) | public double intercept() {
    method slope (line 96) | public double slope() {
    method R2 (line 106) | public double R2() {
    method interceptStdErr (line 115) | public double interceptStdErr() {
    method slopeStdErr (line 124) | public double slopeStdErr() {
    method predict (line 136) | public double predict(double x) {
    method toString (line 147) | public String toString() {

FILE: src/main/java/edu/princeton/cs/algs4/LinkedBag.java
  class LinkedBag (line 51) | public class LinkedBag<Item> implements Iterable<Item> {
    class Node (line 56) | private class Node {
    method LinkedBag (line 64) | public LinkedBag() {
    method isEmpty (line 73) | public boolean isEmpty() {
    method size (line 81) | public int size() {
    method add (line 89) | public void add(Item item) {
    method iterator (line 101) | public Iterator<Item> iterator()  {
    class LinkedIterator (line 106) | private class LinkedIterator implements Iterator<Item> {
      method LinkedIterator (line 110) | public LinkedIterator() {
      method hasNext (line 115) | public boolean hasNext() {
      method next (line 120) | public Item next() {
    method main (line 133) | public static void main(String[] args) {

FILE: src/main/java/edu/princeton/cs/algs4/LinkedQueue.java
  class LinkedQueue (line 38) | public class LinkedQueue<Item> implements Iterable<Item> {
    class Node (line 44) | private class Node {
    method LinkedQueue (line 52) | public LinkedQueue() {
    method isEmpty (line 63) | public boolean isEmpty() {
    method size (line 71) | public int size() {
    method peek (line 80) | public Item peek() {
    method enqueue (line 89) | public void enqueue(Item item) {
    method dequeue (line 105) | public Item dequeue() {
    method toString (line 119) | public String toString() {
    method check (line 127) | private boolean check() {
    method iterator (line 169) | public Iterator<Item> iterator()  {
    class LinkedIterator (line 174) | private class LinkedIterator implements Iterator<Item> {
      method hasNext (line 177) | public boolean hasNext() {
      method next (line 181) | public Item next() {
    method main (line 195) | public static void main(String[] args) {

FILE: src/main/java/edu/princeton/cs/algs4/LinkedStack.java
  class LinkedStack (line 43) | public class LinkedStack<Item> implements Iterable<Item> {
    class Node (line 48) | private class Node {
    method LinkedStack (line 56) | public LinkedStack() {
    method isEmpty (line 66) | public boolean isEmpty() {
    method size (line 74) | public int size() {
    method push (line 82) | public void push(Item item) {
    method pop (line 96) | public Item pop() {
    method peek (line 111) | public Item peek() {
    method toString (line 120) | public String toString() {
    method iterator (line 131) | public Iterator<Item> iterator() {
    class LinkedIterator (line 136) | private class LinkedIterator implements Iterator<Item> {
      method hasNext (line 139) | public boolean hasNext() {
      method next (line 143) | public Item next() {
    method check (line 153) | private boolean check() {
    method main (line 186) | public static void main(String[] args) {

FILE: src/main/java/edu/princeton/cs/algs4/LongestCommonSubstring.java
  class LongestCommonSubstring (line 36) | public class LongestCommonSubstring {
    method LongestCommonSubstring (line 39) | private LongestCommonSubstring() { }
    method lcp (line 42) | private static String lcp(String s, int p, String t, int q) {
    method compare (line 52) | private static int compare(String s, int p, String t, int q) {
    method lcs (line 72) | public static String lcs(String s, String t) {
    method main (line 98) | public static void main(String[] args) {

FILE: src/main/java/edu/princeton/cs/algs4/LongestRepeatedSubstring.java
  class LongestRepeatedSubstring (line 46) | public class LongestRepeatedSubstring {
    method LongestRepeatedSubstring (line 49) | private LongestRepeatedSubstring() { }
    method lrs (line 66) | public static String lrs(String text) {
    method main (line 85) | public static void main(String[] args) {

FILE: src/main/java/edu/princeton/cs/algs4/LookupCSV.java
  class LookupCSV (line 47) | public class LookupCSV {
    method LookupCSV (line 50) | private LookupCSV() { }
    method main (line 52) | public static void main(String[] args) {

FILE: src/main/java/edu/princeton/cs/algs4/LookupIndex.java
  class LookupIndex (line 51) | public class LookupIndex {
    method LookupIndex (line 54) | private LookupIndex() { }
    method main (line 56) | public static void main(String[] args) {

FILE: src/main/java/edu/princeton/cs/algs4/MSD.java
  class MSD (line 41) | public class MSD {
    method MSD (line 48) | private MSD() { }
    method sort (line 55) | public static void sort(String[] a) {
    method charAt (line 62) | private static int charAt(String s, int d) {
    method sort (line 69) | private static void sort(String[] a, int lo, int hi, int d, String[] a...
    method insertion (line 106) | private static void insertion(String[] a, int lo, int hi, int d) {
    method exch (line 113) | private static void exch(String[] a, int i, int j) {
    method less (line 120) | private static boolean less(String v, String w, int d) {
    method sort (line 136) | public static void sort(int[] a) {
    method sort (line 143) | private static void sort(int[] a, int lo, int hi, int d, int[] aux) {
    method insertion (line 204) | private static void insertion(int[] a, int lo, int hi) {
    method exch (line 211) | private static void exch(int[] a, int i, int j) {
    method main (line 225) | public static void main(String[] args) {

FILE: src/main/java/edu/princeton/cs/algs4/MaxPQ.java
  class MaxPQ (line 54) | public class MaxPQ<Key> implements Iterable<Key> {
    method MaxPQ (line 64) | public MaxPQ(int initCapacity) {
    method MaxPQ (line 72) | public MaxPQ() {
    method MaxPQ (line 83) | public MaxPQ(int initCapacity, Comparator<Key> comparator) {
    method MaxPQ (line 94) | public MaxPQ(Comparator<Key> comparator) {
    method MaxPQ (line 104) | public MaxPQ(Key[] keys) {
    method isEmpty (line 122) | public boolean isEmpty() {
    method size (line 131) | public int size() {
    method max (line 141) | public Key max() {
    method resize (line 147) | private void resize(int capacity) {
    method insert (line 162) | public void insert(Key x) {
    method delMax (line 179) | public Key delMax() {
    method swim (line 195) | private void swim(int k) {
    method sink (line 202) | private void sink(int k) {
    method less (line 215) | private boolean less(int i, int j) {
    method exch (line 224) | private void exch(int i, int j) {
    method isMaxHeap (line 231) | private boolean isMaxHeap() {
    method isMaxHeapOrdered (line 243) | private boolean isMaxHeapOrdered(int k) {
    method iterator (line 264) | public Iterator<Key> iterator() {
    class HeapIterator (line 268) | private class HeapIterator implements Iterator<Key> {
      method HeapIterator (line 275) | public HeapIterator() {
      method hasNext (line 282) | public boolean hasNext()  { return !copy.isEmpty();                 ...
      method remove (line 283) | public void remove()      { throw new UnsupportedOperationException(...
      method next (line 285) | public Key next() {
    method main (line 296) | public static void main(String[] args) {

FILE: src/main/java/edu/princeton/cs/algs4/Merge.java
  class Merge (line 47) | public class Merge {
    method Merge (line 50) | private Merge() { }
    method merge (line 53) | private static void merge(Comparable[] a, Comparable[] aux, int lo, in...
    method sort (line 77) | private static void sort(Comparable[] a, Comparable[] aux, int lo, int...
    method sort (line 89) | public static void sort(Comparable[] a) {
    method less (line 101) | private static boolean less(Comparable v, Comparable w) {
    method isSorted (line 108) | private static boolean isSorted(Comparable[] a) {
    method isSorted (line 112) | private static boolean isSorted(Comparable[] a, int lo, int hi) {
    method merge (line 123) | private static void merge(Comparable[] a, int[] index, int[] aux, int ...
    method indexSort (line 146) | public static int[] indexSort(Comparable[] a) {
    method sort (line 158) | private static void sort(Comparable[] a, int[] index, int[] aux, int l...
    method show (line 167) | private static void show(Comparable[] a) {
    method main (line 179) | public static void main(String[] args) {

FILE: src/main/java/edu/princeton/cs/algs4/MergeBU.java
  class MergeBU (line 47) | public class MergeBU {
    method MergeBU (line 50) | private MergeBU() { }
    method merge (line 53) | private static void merge(Comparable[] a, Comparable[] aux, int lo, in...
    method sort (line 75) | public static void sort(Comparable[] a) {
    method less (line 93) | private static boolean less(Comparable v, Comparable w) {
    method isSorted (line 101) | private static boolean isSorted(Comparable[] a) {
    method show (line 108) | private static void show(Comparable[] a) {
    method main (line 120) | public static void main(String[] args) {

FILE: src/main/java/edu/princeton/cs/algs4/MergeX.java
  class MergeX (line 47) | public class MergeX {
    method MergeX (line 51) | private MergeX() { }
    method merge (line 53) | private static void merge(Comparable[] src, Comparable[] dst, int lo, ...
    method sort (line 71) | private static void sort(Comparable[] src, Comparable[] dst, int lo, i...
    method sort (line 99) | public static void sort(Comparable[] a) {
    method insertionSort (line 106) | private static void insertionSort(Comparable[] a, int lo, int hi) {
    method exch (line 118) | private static void exch(Object[] a, int i, int j) {
    method less (line 125) | private static boolean less(Comparable a, Comparable b) {
    method less (line 130) | private static boolean less(Object a, Object b, Comparator comparator) {
    method sort (line 145) | public static void sort(Object[] a, Comparator comparator) {
    method merge (line 151) | private static void merge(Object[] src, Object[] dst, int lo, int mid,...
    method sort (line 170) | private static void sort(Object[] src, Object[] dst, int lo, int hi, C...
    method insertionSort (line 190) | private static void insertionSort(Object[] a, int lo, int hi, Comparat...
    method isSorted (line 200) | private static boolean isSorted(Comparable[] a) {
    method isSorted (line 204) | private static boolean isSorted(Comparable[] a, int lo, int hi) {
    method isSorted (line 210) | private static boolean isSorted(Object[] a, Comparator comparator) {
    method isSorted (line 214) | private static boolean isSorted(Object[] a, int lo, int hi, Comparator...
    method show (line 221) | private static void show(Object[] a) {
    method main (line 234) | public static void main(String[] args) {

FILE: src/main/java/edu/princeton/cs/algs4/MinPQ.java
  class MinPQ (line 52) | public class MinPQ<Key> implements Iterable<Key> {
    method MinPQ (line 62) | public MinPQ(int initCapacity) {
    method MinPQ (line 70) | public MinPQ() {
    method MinPQ (line 81) | public MinPQ(int initCapacity, Comparator<Key> comparator) {
    method MinPQ (line 92) | public MinPQ(Comparator<Key> comparator) {
    method MinPQ (line 103) | public MinPQ(Key[] keys) {
    method isEmpty (line 119) | public boolean isEmpty() {
    method size (line 128) | public int size() {
    method min (line 138) | public Key min() {
    method resize (line 144) | private void resize(int capacity) {
    method insert (line 158) | public void insert(Key x) {
    method delMin (line 174) | public Key delMin() {
    method swim (line 190) | private void swim(int k) {
    method sink (line 197) | private void sink(int k) {
    method greater (line 210) | private boolean greater(int i, int j) {
    method exch (line 219) | private void exch(int i, int j) {
    method isMinHeap (line 226) | private boolean isMinHeap() {
    method isMinHeapOrdered (line 238) | private boolean isMinHeapOrdered(int k) {
    method iterator (line 256) | public Iterator<Key> iterator() {
    class HeapIterator (line 260) | private class HeapIterator implements Iterator<Key> {
      method HeapIterator (line 266) | public HeapIterator() {
      method hasNext (line 273) | public boolean hasNext()  { return !copy.isEmpty();                 ...
      method remove (line 274) | public void remove()      { throw new UnsupportedOperationException(...
      method next (line 276) | public Key next() {
    method main (line 287) | public static void main(String[] args) {

FILE: src/main/java/edu/princeton/cs/algs4/Multiway.java
  class Multiway (line 42) | public class Multiway {
    method Multiway (line 45) | private Multiway() { }
    method merge (line 48) | private static void merge(In[] streams) {
    method main (line 74) | public static void main(String[] args) {

FILE: src/main/java/edu/princeton/cs/algs4/MultiwayMinPQ.java
  class MultiwayMinPQ (line 33) | public class MultiwayMinPQ<Key> implements Iterable<Key> {
    method MultiwayMinPQ (line 48) | public MultiwayMinPQ(int d) {
    method MultiwayMinPQ (line 64) | public MultiwayMinPQ(Comparator<Key> comparator, int d) {
    method MultiwayMinPQ (line 80) | public MultiwayMinPQ(Key[] a, int d) {
    method MultiwayMinPQ (line 98) | public MultiwayMinPQ(Comparator<Key> comparator, Key[] a, int d) {
    method isEmpty (line 112) | public boolean isEmpty() {
    method size (line 121) | public int size() {
    method insert (line 130) | public void insert(Key key) {
    method minKey (line 145) | public Key minKey() {
    method delMin (line 156) | public Key delMin() {
    method greater (line 175) | private boolean greater(int x, int y) {
    method exch (line 183) | private void exch(int x, int y) {
    method getN (line 191) | private int getN(int order) {
    method swim (line 200) | private void swim(int i) {
    method sink (line 208) | private void sink(int i) {
    method minChild (line 224) | private int minChild(int i) {
    method resize (line 240) | private void resize(int N) {
    method iterator (line 262) | public Iterator<Key> iterator() {
    class MyIterator (line 267) | private class MyIterator implements Iterator<Key> {
      method MyIterator (line 270) | public MyIterator() {
      method hasNext (line 279) | public boolean hasNext() {
      method next (line 283) | public Key next() {
      method remove (line 288) | public void remove() {
    class MyComparator (line 298) | private class MyComparator implements Comparator<Key> {
      method compare (line 299) | @Override

FILE: src/main/java/edu/princeton/cs/algs4/NFA.java
  class NFA (line 57) | public class NFA {
    method NFA (line 68) | public NFA(String regexp) {
    method recognizes (line 110) | public boolean recognizes(String txt) {
    method main (line 149) | public static void main(String[] args) {

FILE: src/main/java/edu/princeton/cs/algs4/NonrecursiveDFS.java
  class NonrecursiveDFS (line 63) | public class NonrecursiveDFS {
    method NonrecursiveDFS (line 71) | public NonrecursiveDFS(Graph graph, int s) {
    method marked (line 113) | public boolean marked(int v) {
    method validateVertex (line 119) | private void validateVertex(int v) {
    method main (line 130) | public static void main(String[] args) {

FILE: src/main/java/edu/princeton/cs/algs4/NonrecursiveDirectedDFS.java
  class NonrecursiveDirectedDFS (line 46) | public class NonrecursiveDirectedDFS {
    method NonrecursiveDirectedDFS (line 56) | public NonrecursiveDirectedDFS(Digraph digraph, int s) {
    method marked (line 97) | public boolean marked(int v) {
    method validateVertex (line 103) | private void validateVertex(int v) {
    method main (line 114) | public static void main(String[] args) {

FILE: src/main/java/edu/princeton/cs/algs4/Out.java
  class Out (line 35) | public class Out {
    method Out (line 50) | public Out(OutputStream os) {
    method Out (line 58) | public Out() {
    method Out (line 69) | public Out(Socket socket) {
    method Out (line 91) | public Out(String filename) {
    method close (line 113) | public void close() {
    method println (line 120) | public void println() {
    method println (line 129) | public void println(Object x) {
    method println (line 138) | public void println(boolean x) {
    method println (line 147) | public void println(char x) {
    method println (line 156) | public void println(double x) {
    method println (line 165) | public void println(float x) {
    method println (line 174) | public void println(int x) {
    method println (line 183) | public void println(long x) {
    method println (line 194) | public void println(byte x) {
    method print (line 203) | public void print() {
    method print (line 212) | public void print(Object x) {
    method print (line 222) | public void print(boolean x) {
    method print (line 232) | public void print(char x) {
    method print (line 242) | public void print(double x) {
    method print (line 252) | public void print(float x) {
    method print (line 262) | public void print(int x) {
    method print (line 272) | public void print(long x) {
    method print (line 282) | public void print(byte x) {
    method printf (line 294) | public void printf(String format, Object... args) {
    method printf (line 307) | public void printf(Locale locale, String format, Object... args) {
    method main (line 318) | public static void main(String[] args) {

FILE: src/main/java/edu/princeton/cs/algs4/Particle.java
  class Particle (line 29) | public class Particle {
    method Particle (line 51) | public Particle(double rx, double ry, double vx, double vy, double rad...
    method Particle (line 70) | public Particle() {
    method move (line 86) | public void move(double dt) {
    method draw (line 94) | public void draw() {
    method count (line 109) | public int count() {
    method timeToHit (line 122) | public double timeToHit(Particle that) {
    method timeToHitVerticalWall (line 155) | public double timeToHitVerticalWall() {
    method timeToHitHorizontalWall (line 170) | public double timeToHitHorizontalWall() {
    method bounceOff (line 183) | public void bounceOff(Particle that) {
    method bounceOffVerticalWall (line 214) | public void bounceOffVerticalWall() {
    method bounceOffHorizontalWall (line 224) | public void bounceOffHorizontalWall() {
    method kineticEnergy (line 236) | public double kineticEnergy() {

FILE: src/main/java/edu/princeton/cs/algs4/PatriciaSET.java
  class PatriciaSET (line 93) | public class PatriciaSET implements Iterable<String> {
    class Node (line 100) | private class Node {
      method Node (line 105) | public Node(String key, int b) {
    method PatriciaSET (line 117) | public PatriciaSET() {
    method add (line 130) | public void add(String key) {
    method contains (line 171) | public boolean contains(String key) {
    method delete (line 190) | public void delete(String key) {
    method isEmpty (line 238) | boolean isEmpty() {
    method size (line 246) | int size() {
    method iterator (line 256) | public Iterator<String> iterator() {
    method collect (line 263) | private void collect(Node x, int b, Queue<String> queue) {
    method toString (line 276) | public String toString() {
    method safeBitTest (line 298) | private static boolean safeBitTest(String key, int b) {
    method bitTest (line 304) | private static int bitTest(String key, int b) {
    method safeCharAt (line 313) | private static int safeCharAt(String key, int i) {
    method firstDifferingBit (line 333) | private static int firstDifferingBit(String k1, String k2) {
    method main (line 358) | public static void main(String[] args) {

FILE: src/main/java/edu/princeton/cs/algs4/PatriciaST.java
  class PatriciaST (line 96) | public class PatriciaST<Value> {
    class Node (line 103) | private class Node {
      method Node (line 109) | public Node(String key, Value val, int b) {
    method PatriciaST (line 122) | public PatriciaST() {
    method put (line 139) | public void put(String key, Value val) {
    method get (line 182) | public Value get(String key) {
    method delete (line 203) | public void delete(String key) {
    method contains (line 255) | public boolean contains(String key) {
    method isEmpty (line 264) | boolean isEmpty() {
    method size (line 272) | int size() {
    method keys (line 283) | public Iterable<String> keys() {
    method keys (line 290) | private void keys(Node x, int b, Queue<String> queue) {
    method safeBitTest (line 313) | private static boolean safeBitTest(String key, int b) {
    method bitTest (line 319) | private static int bitTest(String key, int b) {
    method safeCharAt (line 328) | private static int safeCharAt(String key, int i) {
    method firstDifferingBit (line 348) | private static int firstDifferingBit(String k1, String k2) {
    method main (line 373) | public static void main(String[] args) {

FILE: src/main/java/edu/princeton/cs/algs4/Picture.java
  class Picture (line 237) | public final class Picture implements ActionListener {
    method Picture (line 255) | public Picture(int width, int height) {
    method Picture (line 270) | public Picture(Picture picture) {
    method Picture (line 293) | public Picture(String filename) {
    method Picture (line 355) | public Picture(File file) {
    method createGUI (line 378) | @SuppressWarnings("deprecation")
    method getJLabel (line 416) | public JLabel getJLabel() {
    method setOriginUpperLeft (line 425) | public void setOriginUpperLeft() {
    method setOriginLowerLeft (line 432) | public void setOriginLowerLeft() {
    method show (line 442) | @SuppressWarnings("deprecation")
    method hide (line 464) | public void hide() {
    method isVisible (line 475) | public boolean isVisible() {
    method height (line 484) | public int height() {
    method width (line 493) | public int width() {
    method validateRowIndex (line 497) | private void validateRowIndex(int row) {
    method validateColumnIndex (line 502) | private void validateColumnIndex(int col) {
    method get (line 515) | public Color get(int col, int row) {
    method getARGB (line 532) | public int getARGB(int col, int row) {
    method set (line 548) | public void set(int col, int row, Color color) {
    method setARGB (line 564) | public void setARGB(int col, int row, int argb) {
    method equals (line 579) | public boolean equals(Object other) {
    method toString (line 600) | public String toString() {
    method hashCode (line 621) | public int hashCode() {
    method setTitle (line 630) | public void setTitle(String title) {
    method hasAlpha (line 636) | private boolean hasAlpha() {
    method save (line 662) | public void save(String filename) {
    method save (line 681) | public void save(File file) {
    method actionPerformed (line 711) | @Override
    method main (line 735) | public static void main(String[] args) {

FILE: src/main/java/edu/princeton/cs/algs4/PictureDump.java
  class PictureDump (line 35) | public class PictureDump {
    method PictureDump (line 38) | private PictureDump() { }
    method main (line 48) | public static void main(String[] args) {

FILE: src/main/java/edu/princeton/cs/algs4/Point2D.java
  class Point2D (line 31) | public final class Point2D implements Comparable<Point2D> {
    method Point2D (line 59) | public Point2D(double x, double y) {
    method x (line 75) | public double x() {
    method y (line 83) | public double y() {
    method r (line 91) | public double r() {
    method theta (line 99) | public double theta() {
    method angleTo (line 107) | private double angleTo(Point2D that) {
    method ccw (line 120) | public static int ccw(Point2D a, Point2D b, Point2D c) {
    method area2 (line 134) | public static double area2(Point2D a, Point2D b, Point2D c) {
    method distanceTo (line 143) | public double distanceTo(Point2D that) {
    method distanceSquaredTo (line 154) | public double distanceSquaredTo(Point2D that) {
    method compareTo (line 172) | public int compareTo(Point2D that) {
    method polarOrder (line 185) | public Comparator<Point2D> polarOrder() {
    method atan2Order (line 194) | public Comparator<Point2D> atan2Order() {
    method distanceToOrder (line 203) | public Comparator<Point2D> distanceToOrder() {
    class XOrder (line 208) | private static class XOrder implements Comparator<Point2D> {
      method compare (line 209) | public int compare(Point2D p, Point2D q) {
    class YOrder (line 215) | private static class YOrder implements Comparator<Point2D> {
      method compare (line 216) | public int compare(Point2D p, Point2D q) {
    class ROrder (line 222) | private static class ROrder implements Comparator<Point2D> {
      method compare (line 223) | public int compare(Point2D p, Point2D q) {
    class Atan2Order (line 230) | private class Atan2Order implements Comparator<Point2D> {
      method compare (line 231) | public int compare(Point2D q1, Point2D q2) {
    class PolarOrder (line 239) | private class PolarOrder implements Comparator<Point2D> {
      method compare (line 240) | public int compare(Point2D q1, Point2D q2) {
    class DistanceToOrder (line 260) | private class DistanceToOrder implements Comparator<Point2D> {
      method compare (line 261) | public int compare(Point2D p, Point2D q) {
    method equals (line 276) | @Override
    method toString (line 289) | @Override
    method hashCode (line 298) | @Override
    method draw (line 308) | public void draw() {
    method drawTo (line 316) | public void drawTo(Point2D that) {
    method main (line 326) | public static void main(String[] args) {

FILE: src/main/java/edu/princeton/cs/algs4/Polynomial.java
  class Polynomial (line 42) | public class Polynomial {
    method Polynomial (line 52) | public Polynomial(int a, int b) {
    method reduce (line 63) | private void reduce() {
    method degree (line 77) | public int degree() {
    method plus (line 87) | public Polynomial plus(Polynomial that) {
    method minus (line 102) | public Polynomial minus(Polynomial that) {
    method times (line 118) | public Polynomial times(Polynomial that) {
    method compose (line 136) | public Polynomial compose(Polynomial that) {
    method equals (line 153) | @Override
    method differentiate (line 170) | public Polynomial differentiate() {
    method evaluate (line 185) | public int evaluate(int x) {
    method compareTo (line 202) | public int compareTo(Polynomial that) {
    method toString (line 217) | @Override
    method main (line 238) | public static void main(String[] args) {

FILE: src/main/java/edu/princeton/cs/algs4/PrimMST.java
  class PrimMST (line 75) | public class PrimMST {
    method PrimMST (line 87) | public PrimMST(EdgeWeightedGraph graph) {
    method prim (line 103) | private void prim(EdgeWeightedGraph graph, int s) {
    method scan (line 113) | private void scan(EdgeWeightedGraph graph, int v) {
    method edges (line 132) | public Iterable<Edge> edges() {
    method weight (line 147) | public double weight() {
    method check (line 156) | private boolean check(EdgeWeightedGraph graph) {
    method main (line 219) | public static void main(String[] args) {

FILE: src/main/java/edu/princeton/cs/algs4/Queue.java
  class Queue (line 42) | public class Queue<Item> implements Iterable<Item> {
    class Node (line 48) | private static class Node<Item> {
    method Queue (line 56) | public Queue() {
    method isEmpty (line 67) | public boolean isEmpty() {
    method size (line 76) | public int size() {
    method peek (line 86) | public Item peek() {
    method enqueue (line 96) | public void enqueue(Item item) {
    method dequeue (line 112) | public Item dequeue() {
    method toString (line 126) | public String toString() {
    method iterator (line 140) | public Iterator<Item> iterator()  {
    class LinkedIterator (line 145) | private class LinkedIterator implements Iterator<Item> {
      method LinkedIterator (line 148) | public LinkedIterator(Node<Item> first) {
      method hasNext (line 152) | public boolean hasNext() {
      method next (line 156) | public Item next() {
    method main (line 170) | public static void main(String[] args) {

FILE: src/main/java/edu/princeton/cs/algs4/Quick.java
  class Quick (line 42) | public class Quick {
    method Quick (line 45) | private Quick() { }
    method sort (line 51) | public static void sort(Comparable[] a) {
    method sort (line 58) | private static void sort(Comparable[] a, int lo, int hi) {
    method partition (line 68) | private static int partition(Comparable[] a, int lo, int hi) {
    method select (line 107) | public static Comparable select(Comparable[] a, int k) {
    method less (line 129) | private static boolean less(Comparable v, Comparable w) {
    method exch (line 135) | private static void exch(Object[] a, int i, int j) {
    method isSorted (line 145) | private static boolean isSorted(Comparable[] a) {
    method isSorted (line 149) | private static boolean isSorted(Comparable[] a, int lo, int hi) {
    method show (line 157) | private static void show(Comparable[] a) {
    method main (line 171) | public static void main(String[] args) {

FILE: src/main/java/edu/princeton/cs/algs4/Quick3string.java
  class Quick3string (line 42) | public class Quick3string {
    method Quick3string (line 46) | private Quick3string() { }
    method sort (line 53) | public static void sort(String[] a) {
    method charAt (line 60) | private static int charAt(String s, int d) {
    method sort (line 68) | private static void sort(String[] a, int lo, int hi, int d) {
    method insertion (line 93) | private static void insertion(String[] a, int lo, int hi, int d) {
    method exch (line 100) | private static void exch(String[] a, int i, int j) {
    method less (line 114) | private static boolean less(String v, String w, int d) {
    method isSorted (line 124) | private static boolean isSorted(String[] a) {
    method main (line 138) | public static void main(String[] args) {

FILE: src/main/java/edu/princeton/cs/algs4/Quick3way.java
  class Quick3way (line 37) | public class Quick3way {
    method Quick3way (line 40) | private Quick3way() { }
    method sort (line 46) | public static void sort(Comparable[] a) {
    method sort (line 53) | private static void sort(Comparable[] a, int lo, int hi) {
    method less (line 78) | private static boolean less(Comparable v, Comparable w) {
    method exch (line 83) | private static void exch(Object[] a, int i, int j) {
    method isSorted (line 93) | private static boolean isSorted(Comparable[] a) {
    method isSorted (line 97) | private static boolean isSorted(Comparable[] a, int lo, int hi) {
    method show (line 106) | private static void show(Comparable[] a) {
    method main (line 118) | public static void main(String[] args) {

FILE: src/main/java/edu/princeton/cs/algs4/QuickBentleyMcIlroy.java
  class QuickBentleyMcIlroy (line 32) | public class QuickBentleyMcIlroy {
    method QuickBentleyMcIlroy (line 41) | private QuickBentleyMcIlroy() { }
    method sort (line 47) | public static void sort(Comparable[] a) {
    method sort (line 51) | private static void sort(Comparable[] a, int lo, int hi) {
    method insertionSort (line 110) | private static void insertionSort(Comparable[] a, int lo, int hi) {
    method median3 (line 118) | private static int median3(Comparable[] a, int i, int j, int k) {
    method less (line 129) | private static boolean less(Comparable v, Comparable w) {
    method eq (line 135) | private static boolean eq(Comparable v, Comparable w) {
    method exch (line 141) | private static void exch(Object[] a, int i, int j) {
    method isSorted (line 151) | private static boolean isSorted(Comparable[] a) {
    method show (line 158) | private static void show(Comparable[] a) {
    method main (line 171) | public static void main(String[] args) {

FILE: src/main/java/edu/princeton/cs/algs4/QuickFindUF.java
  class QuickFindUF (line 65) | public class QuickFindUF {
    method QuickFindUF (line 77) | public QuickFindUF(int n) {
    method count (line 89) | public int count() {
    method find (line 100) | public int find(int p) {
    method validate (line 106) | private void validate(int p) {
    method connected (line 124) | @Deprecated
    method union (line 140) | public void union(int p, int q) {
    method main (line 163) | public static void main(String[] args) {

FILE: src/main/java/edu/princeton/cs/algs4/QuickUnionUF.java
  class QuickUnionUF (line 64) | public class QuickUnionUF {
    method QuickUnionUF (line 76) | public QuickUnionUF(int n) {
    method count (line 89) | public int count() {
    method find (line 100) | public int find(int p) {
    method validate (line 108) | private void validate(int p) {
    method connected (line 126) | @Deprecated
    method union (line 140) | public void union(int p, int q) {
    method main (line 157) | public static void main(String[] args) {

FILE: src/main/java/edu/princeton/cs/algs4/QuickX.java
  class QuickX (line 28) | public class QuickX {
    method QuickX (line 34) | private QuickX() { }
    method sort (line 40) | public static void sort(Comparable[] a) {
    method sort (line 47) | private static void sort(Comparable[] a, int lo, int hi) {
    method partition (line 64) | private static int partition(Comparable[] a, int lo, int hi) {
    method median3 (line 98) | private static int median3(Comparable[] a, int i, int j, int k) {
    method less (line 109) | private static boolean less(Comparable v, Comparable w) {
    method exch (line 114) | private static void exch(Object[] a, int i, int j) {
    method isSorted (line 124) | private static boolean isSorted(Comparable[] a) {
    method show (line 131) | private static void show(Comparable[] a) {
    method main (line 144) | public static void main(String[] args) {

FILE: src/main/java/edu/princeton/cs/algs4/RabinKarp.java
  class RabinKarp (line 49) | public class RabinKarp {
    method RabinKarp (line 63) | public RabinKarp(char[] pattern, int R) {
    method RabinKarp (line 74) | public RabinKarp(String pat) {
    method hash (line 88) | private long hash(String key, int m) {
    method check (line 96) | private boolean check(String txt, int i) {
    method search (line 116) | public int search(String txt) {
    method longRandomPrime (line 143) | private static long longRandomPrime() {
    method main (line 155) | public static void main(String[] args) {

FILE: src/main/java/edu/princeton/cs/algs4/RandomSeq.java
  class RandomSeq (line 29) | public class RandomSeq {
    method RandomSeq (line 32) | private RandomSeq() { }
    method main (line 41) | public static void main(String[] args) {

FILE: src/main/java/edu/princeton/cs/algs4/RectHV.java
  class RectHV (line 25) | public final class RectHV {
    method RectHV (line 42) | public RectHV(double xmin, double ymin, double xmax, double ymax) {
    method xmin (line 66) | public double xmin() {
    method xmax (line 75) | public double xmax() {
    method ymin (line 84) | public double ymin() {
    method ymax (line 93) | public double ymax() {
    method width (line 102) | public double width() {
    method height (line 111) | public double height() {
    method intersects (line 125) | public boolean intersects(RectHV that) {
    method contains (line 137) | public boolean contains(Point2D p) {
    method distanceTo (line 149) | public double distanceTo(Point2D p) {
    method distanceSquaredTo (line 161) | public double distanceSquaredTo(Point2D p) {
    method equals (line 177) | @Override
    method hashCode (line 194) | @Override
    method toString (line 209) | @Override
    method draw (line 217) | public void draw() {

FILE: src/main/java/edu/princeton/cs/algs4/RedBlackBST.java
  class RedBlackBST (line 79) | public class RedBlackBST<Key extends Comparable<Key>, Value> {
    class Node (line 87) | private class Node {
      method Node (line 94) | public Node(Key key, Value val, boolean color, int size) {
    method RedBlackBST (line 105) | public RedBlackBST() {
    method isRed (line 112) | private boolean isRed(Node x) {
    method size (line 118) | private int size(Node x) {
    method size (line 128) | public int size() {
    method isEmpty (line 136) | public boolean isEmpty() {
    method get (line 152) | public Value get(Key key) {
    method get (line 158) | private Value get(Node x, Key key) {
    method contains (line 175) | public boolean contains(Key key) {
    method put (line 193) | public void put(Key key, Value val) {
    method put (line 206) | private Node put(Node h, Key key, Value val) {
    method deleteMin (line 231) | public void deleteMin() {
    method deleteMin (line 244) | private Node deleteMin(Node h) {
    method deleteMax (line 260) | public void deleteMax() {
    method deleteMax (line 273) | private Node deleteMax(Node h) {
    method delete (line 295) | public void delete(Key key) {
    method delete (line 309) | private Node delete(Node h, Key key) {
    method rotateRight (line 342) | private Node rotateRight(Node h) {
    method rotateLeft (line 356) | private Node rotateLeft(Node h) {
    method flipColors (line 370) | private void flipColors(Node h) {
    method moveRedLeft (line 382) | private Node moveRedLeft(Node h) {
    method moveRedRight (line 397) | private Node moveRedRight(Node h) {
    method balance (line 409) | private Node balance(Node h) {
    method height (line 429) | public int height() {
    method height (line 432) | private int height(Node x) {
    method min (line 446) | public Key min() {
    method min (line 452) | private Node min(Node x) {
    method max (line 463) | public Key max() {
    method max (line 469) | private Node max(Node x) {
    method floor (line 483) | public Key floor(Key key) {
    method floor (line 492) | private Node floor(Node x, Key key) {
    method ceiling (line 509) | public Key ceiling(Key key) {
    method ceiling (line 518) | private Node ceiling(Node x, Key key) {
    method select (line 539) | public Key select(int rank) {
    method select (line 548) | private Key select(Node x, int rank) {
    method rank (line 562) | public int rank(Key key) {
    method rank (line 568) | private int rank(Key key, Node x) {
    method keys (line 586) | public Iterable<Key> keys() {
    method keys (line 602) | public Iterable<Key> keys(Key lo, Key hi) {
    method keys (line 614) | private void keys(Node x, Queue<Key> queue, Key lo, Key hi) {
    method size (line 633) | public int size(Key lo, Key hi) {
    method check (line 646) | private boolean check() {
    method isBST (line 657) | private boolean isBST() {
    method isBST (line 664) | private boolean isBST(Node x, Key min, Key max) {
    method isSizeConsistent (line 672) | private boolean isSizeConsistent() { return isSizeConsistent(root); }
    method isSizeConsistent (line 673) | private boolean isSizeConsistent(Node x) {
    method isRankConsistent (line 680) | private boolean isRankConsistent() {
    method is23 (line 690) | private boolean is23() { return is23(root); }
    method is23 (line 691) | private boolean is23(Node x) {
    method isBalanced (line 700) | private boolean isBalanced() {
    method isBalanced (line 711) | private boolean isBalanced(Node x, int black) {
    method main (line 723) | public static void main(String[] args) {

FILE: src/main/java/edu/princeton/cs/algs4/ResizingArrayBag.java
  class ResizingArrayBag (line 32) | public class ResizingArrayBag<Item> implements Iterable<Item> {
    method ResizingArrayBag (line 42) | public ResizingArrayBag() {
    method isEmpty (line 51) | public boolean isEmpty() {
    method size (line 59) | public int size() {
    method resize (line 64) | private void resize(int capacity) {
    method add (line 76) | public void add(Item item) {
    method iterator (line 86) | public Iterator<Item> iterator() {
    class ArrayIterator (line 91) | private class ArrayIterator implements Iterator<Item> {
      method hasNext (line 94) | public boolean hasNext() {
      method next (line 98) | public Item next() {
    method main (line 109) | public static void main(String[] args) {

FILE: src/main/java/edu/princeton/cs/algs4/ResizingArrayQueue.java
  class ResizingArrayQueue (line 39) | public class ResizingArrayQueue<Item> implements Iterable<Item> {
    method ResizingArrayQueue (line 52) | public ResizingArrayQueue() {
    method isEmpty (line 63) | public boolean isEmpty() {
    method size (line 71) | public int size() {
    method resize (line 76) | private void resize(int capacity) {
    method enqueue (line 91) | public void enqueue(Item item) {
    method dequeue (line 104) | public Item dequeue() {
    method peek (line 121) | public Item peek() {
    method iterator (line 131) | public Iterator<Item> iterator() {
    class ArrayIterator (line 136) | private class ArrayIterator implements Iterator<Item> {
      method hasNext (line 139) | public boolean hasNext() {
      method next (line 143) | public Item next() {
    method main (line 156) | public static void main(String[] args) {

FILE: src/main/java/edu/princeton/cs/algs4/ResizingArrayStack.java
  class ResizingArrayStack (line 42) | public class ResizingArrayStack<Item> implements Iterable<Item> {
    method ResizingArrayStack (line 54) | public ResizingArrayStack() {
    method isEmpty (line 63) | public boolean isEmpty() {
    method size (line 71) | public int size() {
    method resize (line 77) | private void resize(int capacity) {
    method push (line 97) | public void push(Item item) {
    method pop (line 107) | public Item pop() {
    method peek (line 123) | public Item peek() {
    method iterator (line 132) | public Iterator<Item> iterator() {
    class ReverseArrayIterator (line 137) | private class ReverseArrayIterator implements Iterator<Item> {
      method ReverseArrayIterator (line 140) | public ReverseArrayIterator() {
      method hasNext (line 144) | public boolean hasNext() {
      method next (line 148) | public Item next() {
    method main (line 160) | public static void main(String[] args) {

FILE: src/main/java/edu/princeton/cs/algs4/RunLength.java
  class RunLength (line 39) | public class RunLength {
    method RunLength (line 44) | private RunLength() { }
    method expand (line 51) | public static void expand() {
    method compress (line 67) | public static void compress() {
    method main (line 97) | public static void main(String[] args) {

FILE: src/main/java/edu/princeton/cs/algs4/SET.java
  class SET (line 52) | public class SET<Key extends Comparable<Key>> implements Iterable<Key> {
    method SET (line 58) | public SET() {
    method SET (line 67) | public SET(SET<Key> x) {
    method add (line 77) | public void add(Key key) {
    method contains (line 91) | public boolean contains(Key key) {
    method delete (line 103) | public void delete(Key key) {
    method remove (line 115) | public void remove(Key key) {
    method size (line 125) | public int size() {
    method isEmpty (line 135) | public boolean isEmpty() {
    method iterator (line 146) | public Iterator<Key> iterator() {
    method max (line 156) | public Key max() {
    method min (line 167) | public Key min() {
    method ceiling (line 181) | public Key ceiling(Key key) {
    method floor (line 196) | public Key floor(Key key) {
    method union (line 210) | public SET<Key> union(SET<Key> that) {
    method intersects (line 229) | public SET<Key> intersects(SET<Key> that) {
    method equals (line 257) | @Override
    method hashCode (line 272) | @Override
    method toString (line 283) | @Override
    method main (line 294) | public static void main(String[] args) {

FILE: src/main/java/edu/princeton/cs/algs4/ST.java
  class ST (line 57) | public class ST<Key extends Comparable<Key>, Value> implements Iterable<...
    method ST (line 64) | public ST() {
    method get (line 77) | public Value get(Key key) {
    method put (line 92) | public void put(Key key, Value val) {
    method delete (line 106) | public void delete(Key key) {
    method remove (line 119) | public void remove(Key key) {
    method contains (line 132) | public boolean contains(Key key) {
    method size (line 142) | public int size() {
    method isEmpty (line 151) | public boolean isEmpty() {
    method keys (line 164) | public Iterable<Key> keys() {
    method iterator (line 179) | @Deprecated
    method min (line 190) | public Key min() {
    method max (line 201) | public Key max() {
    method ceiling (line 214) | public Key ceiling(Key key) {
    method floor (line 229) | public Key floor(Key key) {
    method main (line 241) | public static void main(String[] args) {

FILE: src/main/java/edu/princeton/cs/algs4/SegmentTree.java
  class SegmentTree (line 34) | public class SegmentTree {
    method SegmentTree (line 45) | public SegmentTree(int[] array) {
    method size (line 54) | public int size() {
    method build (line 59) | private void build(int v, int from, int size) {
    method rsq (line 87) | public int rsq(int from, int to) {
    method rsq (line 91) | private int rsq(int v, int from, int to) {
    method rMinQ (line 123) | public int rMinQ(int from, int to) {
    method rMinQ (line 127) | private int rMinQ(int v, int from, int to) {
    method update (line 165) | public void update(int from, int to, int value) {
    method update (line 169) | private void update(int v, int from, int to, int value) {
    method propagate (line 202) | private void propagate(int v) {
    method change (line 213) | private void change(Node n, int value) {
    method contains (line 222) | private boolean contains(int from1, int to1, int from2, int to2) {
    method intersects (line 227) | private boolean intersects(int from1, int to1, int from2, int to2) {
    class Node (line 233) | static class Node {
      method size (line 241) | int size() {
    method main (line 268) | public static void main(String[] args) {

FILE: src/main/java/edu/princeton/cs/algs4/Selection.java
  class Selection (line 45) | public class Selection {
    method Selection (line 48) | private Selection() { }
    method sort (line 54) | public static void sort(Comparable[] a) {
    method sort (line 72) | public static void sort(Object[] a, Comparator comparator) {
    method less (line 91) | private static boolean less(Comparable v, Comparable w) {
    method less (line 96) | private static boolean less(Comparator comparator, Object v, Object w) {
    method exch (line 102) | private static void exch(Object[] a, int i, int j) {
    method isSorted (line 114) | private static boolean isSorted(Comparable[] a) {
    method isSorted (line 119) | private static boolean isSorted(Comparable[] a, int lo, int hi) {
    method isSorted (line 126) | private static boolean isSorted(Object[] a, Comparator comparator) {
    method isSorted (line 131) | private static boolean isSorted(Object[] a, Comparator comparator, int...
    method show (line 140) | private static void show(Comparable[] a) {
    method main (line 152) | public static void main(String[] args) {

FILE: src/main/java/edu/princeton/cs/algs4/SeparateChainingHashST.java
  class SeparateChainingHashST (line 43) | public class SeparateChainingHashST<Key, Value> {
    method SeparateChainingHashST (line 54) | public SeparateChainingHashST() {
    method SeparateChainingHashST (line 62) | public SeparateChainingHashST(int m) {
    method resize (line 71) | private void resize(int chains) {
    method hashTextbook (line 84) | private int hashTextbook(Key key) {
    method hash (line 90) | private int hash(Key key) {
    method size (line 101) | public int size() {
    method isEmpty (line 111) | public boolean isEmpty() {
    method contains (line 123) | public boolean contains(Key key) {
    method get (line 136) | public Value get(Key key) {
    method put (line 152) | public void put(Key key, Value val) {
    method delete (line 174) | public void delete(Key key) {
    method keys (line 186) | public Iterable<Key> keys() {
    method main (line 201) | public static void main(String[] args) {

FILE: src/main/java/edu/princeton/cs/algs4/SequentialSearchST.java
  class SequentialSearchST (line 61) | public class SequentialSearchST<Key, Value> {
    class Node (line 66) | private class Node {
      method Node (line 71) | public Node(Key key, Value val, Node next)  {
    method SequentialSearchST (line 81) | public SequentialSearchST() {
    method size (line 89) | public int size() {
    method isEmpty (line 99) | public boolean isEmpty() {
    method contains (line 111) | public boolean contains(Key key) {
    method get (line 124) | public Value get(Key key) {
    method put (line 143) | public void put(Key key, Value val) {
    method delete (line 167) | public void delete(Key key) {
    method delete (line 174) | private Node delete(Node x, Key key) {
    method keys (line 192) | public Iterable<Key> keys()  {
    method main (line 205) | public static void main(String[] args) {

FILE: src/main/java/edu/princeton/cs/algs4/Shell.java
  class Shell (line 45) | public class Shell {
    method Shell (line 48) | private Shell() { }
    method sort (line 54) | public static void sort(Comparable[] a) {
    method less (line 81) | private static boolean less(Comparable v, Comparable w) {
    method exch (line 86) | private static void exch(Object[] a, int i, int j) {
    method isSorted (line 96) | private static boolean isSorted(Comparable[] a) {
    method isHsorted (line 103) | private static boolean isHsorted(Comparable[] a, int h) {
    method show (line 110) | private static void show(Comparable[] a) {
    method main (line 122) | public static void main(String[] args) {

FILE: src/main/java/edu/princeton/cs/algs4/SparseVector.java
  class SparseVector (line 32) | public class SparseVector {
    method SparseVector (line 40) | public SparseVector(int d) {
    method put (line 52) | public void put(int i, double value) {
    method get (line 65) | public double get(int i) {
    method nnz (line 76) | public int nnz() {
    method size (line 86) | @Deprecated
    method dimension (line 96) | public int dimension() {
    method dot (line 107) | public double dot(SparseVector that) {
    method dot (line 131) | public double dot(double[] that) {
    method magnitude (line 144) | public double magnitude() {
    method norm (line 155) | @Deprecated
    method scale (line 166) | public SparseVector scale(double alpha) {
    method plus (line 179) | public SparseVector plus(SparseVector that) {
    method toString (line 192) | public String toString() {
    method main (line 206) | public static void main(String[] args) {

FILE: src/main/java/edu/princeton/cs/algs4/Stack.java
  class Stack (line 50) | public class Stack<Item> implements Iterable<Item> {
    class Node (line 55) | private static class Node<Item> {
    method Stack (line 63) | public Stack() {
    method isEmpty (line 73) | public boolean isEmpty() {
    method size (line 82) | public int size() {
    method push (line 91) | public void push(Item item) {
    method pop (line 105) | public Item pop() {
    method peek (line 120) | public Item peek() {
    method toString (line 130) | public String toString() {
    method iterator (line 145) | public Iterator<Item> iterator() {
    class LinkedIterator (line 150) | private class LinkedIterator implements Iterator<Item> {
      method LinkedIterator (line 153) | public LinkedIterator(Node<Item> first) {
      method hasNext (line 158) | public boolean hasNext() {
      method next (line 163) | public Item next() {
    method main (line 177) | public static void main(String[] args) {

FILE: src/main/java/edu/princeton/cs/algs4/StaticSETofInts.java
  class StaticSETofInts (line 29) | public class StaticSETofInts {
    method StaticSETofInts (line 37) | public StaticSETofInts(int[] keys) {
    method contains (line 58) | public boolean contains(int key) {
    method rank (line 69) | public int rank(int key) {

FILE: src/main/java/edu/princeton/cs/algs4/StdArrayIO.java
  class StdArrayIO (line 65) | public class StdArrayIO {
    method StdArrayIO (line 68) | private StdArrayIO() { }
    method readDouble1D (line 75) | public static double[] readDouble1D() {
    method print (line 89) | public static void print(double[] a) {
    method readDouble2D (line 103) | public static double[][] readDouble2D() {
    method print (line 120) | public static void print(double[][] a) {
    method readInt1D (line 138) | public static int[] readInt1D() {
    method print (line 152) | public static void print(int[] a) {
    method readInt2D (line 166) | public static int[][] readInt2D() {
    method print (line 183) | public static void print(int[][] a) {
    method readBoolean1D (line 200) | public static boolean[] readBoolean1D() {
    method print (line 214) | public static void print(boolean[] a) {
    method readBoolean2D (line 229) | public static boolean[][] readBoolean2D() {
    method print (line 246) | public static void print(boolean[][] a) {
    method main (line 264) | public static void main(String[] args) {

FILE: src/main/java/edu/princeton/cs/algs4/StdAudio.java
  class StdAudio (line 213) | public final class StdAudio {
    method StdAudio (line 244) | private StdAudio() {
    method init (line 254) | private static void init() {
    method getAudioInputStreamFromFile (line 277) | private static AudioInputStream getAudioInputStreamFromFile(String fil...
    method drain (line 320) | public static void drain() {
    method play (line 346) | public static void play(double sample) {
    method play (line 379) | public static void play(double[] samples) {
    method play (line 395) | public static void play(String filename) {
    method read (line 440) | public static double[] read(String filename) {
    method save (line 504) | public static void save(String filename, double[] samples) {
    method stopInBackground (line 561) | public static synchronized void stopInBackground() {
    method playInBackground (line 578) | public static synchronized void playInBackground(final String filename) {
    class BackgroundRunnable (line 584) | private static class BackgroundRunnable implements Runnable {
      method BackgroundRunnable (line 588) | public BackgroundRunnable(String filename) {
      method run (line 595) | public void run() {
      method stop (line 625) | public void stop() {
    method loopInBackground (line 641) | @Deprecated
    method startRecording (line 676) | public static void startRecording() {
    method stopRecording (line 690) | public static double[] stopRecording() {
    class QueueOfDoubles (line 706) | private static class QueueOfDoubles {
      method QueueOfDoubles (line 712) | public QueueOfDoubles() {
      method resize (line 718) | private void resize(int capacity) {
      method enqueue (line 727) | public void enqueue(double item) {
      method size (line 734) | public int size() {
      method toArray (line 739) | public double[] toArray() {
    method main (line 754) | public static void main(String[] args) {

FILE: src/main/java/edu/princeton/cs/algs4/StdAudioStereo.java
  class StdAudioStereo (line 232) | public final class StdAudioStereo {
    method StdAudioStereo (line 267) | private StdAudioStereo() {
    method init (line 277) | private static void init() {
    method getAudioInputStreamFromFile (line 300) | private static AudioInputStream getAudioInputStreamFromFile(String fil...
    method drain (line 343) | public static void drain() {
    method play (line 372) | public static void play(double sampleLeft, double sampleRight) {
    method play (line 415) | public static void play(double sample) {
    method play (line 427) | public static void play(double[] samples) {
    method play (line 445) | public static void play(double[] samplesLeft, double[] samplesRight) {
    method play (line 462) | public static void play(String filename) {
    method readChannel (line 502) | private static double[] readChannel(String filename, boolean channel) {
    method readLeft (line 554) | public static double[] readLeft(String filename) {
    method readRight (line 571) | public static double[] readRight(String filename) {
    method read (line 588) | public static double[] read(String filename) {
    method save (line 628) | private static void save(String filename, byte[] data, AudioFormat for...
    method save (line 675) | public static void save(String filename, double[] samples) {
    method save (line 720) | public static void save(String filename, double[] samplesLeft, double[...
    method stopInBackground (line 755) | public static synchronized void stopInBackground() {
    method playInBackground (line 770) | public static synchronized void playInBackground(final String filename) {
    class BackgroundRunnable (line 776) | private static class BackgroundRunnable implements Runnable {
      method BackgroundRunnable (line 780) | public BackgroundRunnable(String filename) {
      method run (line 787) | public void run() {
      method stop (line 817) | public void stop() {
    method loopInBackground (line 833) | @Deprecated
    method startRecording (line 872) | public static void startRecording() {
    method stopRecording (line 888) | public static void stopRecording() {
    method getRecordingLeft (line 905) | public static double[] getRecordingLeft() {
    method getRecordingRight (line 926) | public static double[] getRecordingRight() {
    method getRecordingMono (line 948) | public static double[] getRecordingMono() {
    class QueueOfDoubles (line 970) | private static class QueueOfDoubles {
      method QueueOfDoubles (line 976) | public QueueOfDoubles() {
      method resize (line 982) | private void resize(int capacity) {
      method enqueue (line 991) | public void enqueue(double item) {
      method size (line 998) | public int size() {
      method toArray (line 1003) | public double[] toArray() {
    method main (line 1018) | public static void main(String[] args) {

FILE: src/main/java/edu/princeton/cs/algs4/StdDraw.java
  class StdDraw (line 505) | public final class StdDraw implements ActionListener, MouseListener, Mou...
    method StdDraw (line 725) | private StdDraw() { }
    method setVisible (line 740) | public static void setVisible(boolean isVisible) {
    method setCanvasSize (line 752) | public static void setCanvasSize() {
    method setCanvasSize (line 768) | public static void setCanvasSize(int canvasWidth, int canvasHeight) {
    method initCanvas (line 778) | private static void initCanvas() {
    method initGUI (line 804) | private static void initGUI() {
    method createMenuBar (line 832) | private static JMenuBar createMenuBar() {
    method close (line 852) | public static void close() {
    method validate (line 861) | private static void validate(double x, String name) {
    method validateNonnegative (line 867) | private static void validateNonnegative(double x, String name) {
    method validateNotNull (line 872) | private static void validateNotNull(Object x, String name) {
    method setTitle (line 887) | public static void setTitle(String title) {
    method setXscale (line 900) | public static void setXscale() {
    method setYscale (line 907) | public static void setYscale() {
    method setScale (line 915) | public static void setScale() {
    method setXscale (line 928) | public static void setXscale(double min, double max) {
    method setYscale (line 947) | public static void setYscale(double min, double max) {
    method setScale (line 966) | public static void setScale(double min, double max) {
    method scaleX (line 980) | private static double  scaleX(double x) { return width  * (x - xmin) /...
    method scaleY (line 981) | private static double  scaleY(double y) { return height * (ymax - y) /...
    method factorX (line 982) | private static double factorX(double w) { return w * width  / Math.abs...
    method factorY (line 983) | private static double factorY(double h) { return h * height / Math.abs...
    method userX (line 984) | private static double   userX(double x) { return xmin + x * (xmax - xm...
    method userY (line 985) | private static double   userY(double y) { return ymax - y * (ymax - ym...
    method clear (line 991) | public static void clear() {
    method clear (line 1002) | public static void clear(Color color) {
    method getPenRadius (line 1020) | public static double getPenRadius() {
    method setPenRadius (line 1030) | public static void setPenRadius() {
    method setPenRadius (line 1043) | public static void setPenRadius(double radius) {
    method getPenColor (line 1059) | public static Color getPenColor() {
    method getBackgroundColor (line 1068) | public static Color getBackgroundColor() {
    method setPenColor (line 1075) | public static void setPenColor() {
    method setPenColor (line 1089) | public static void setPenColor(Color color) {
    method setPenColor (line 1104) | public static void setPenColor(int red, int green, int blue) {
    method getFont (line 1116) | public static Font getFont() {
    method setFont (line 1123) | public static void setFont() {
    method setFont (line 1133) | public static void setFont(Font font) {
    method line (line 1153) | public static void line(double x0, double y0, double x1, double y1) {
    method pixel (line 1171) | private static void pixel(double x, double y) {
    method point (line 1186) | public static void point(double x, double y) {
    method circle (line 1213) | public static void circle(double x, double y, double radius) {
    method filledCircle (line 1237) | public static void filledCircle(double x, double y, double radius) {
    method ellipse (line 1265) | public static void ellipse(double x, double y, double semiMajorAxis, d...
    method filledEllipse (line 1294) | public static void filledEllipse(double x, double y, double semiMajorA...
    method arc (line 1325) | public static void arc(double x, double y, double radius, double angle...
    method square (line 1352) | public static void square(double x, double y, double halfLength) {
    method filledSquare (line 1376) | public static void filledSquare(double x, double y, double halfLength) {
    method rectangle (line 1402) | public static void rectangle(double x, double y, double halfWidth, dou...
    method filledRectangle (line 1429) | public static void filledRectangle(double x, double y, double halfWidt...
    method polygon (line 1460) | public static void polygon(double[] x, double[] y) {
    method filledPolygon (line 1494) | public static void filledPolygon(double[] x, double[] y) {
    method getImage (line 1520) | private static Image getImage(String filename) {
    method picture (line 1614) | public static void picture(double x, double y, String filename) {
    method picture (line 1646) | public static void picture(double x, double y, String filename, double...
    method picture (line 1685) | public static void picture(double x, double y, String filename, double...
    method picture (line 1726) | public static void picture(double x, double y, String filename, double...
    method text (line 1767) | public static void text(double x, double y, String text) {
    method text (line 1792) | public static void text(double x, double y, String text, double degree...
    method textLeft (line 1814) | public static void textLeft(double x, double y, String text) {
    method textRight (line 1837) | public static void textRight(double x, double y, String text) {
    method show (line 1860) | @Deprecated
    method pause (line 1873) | public static void pause(int t) {
    method show (line 1887) | public static void show() {
    method draw (line 1899) | private static void draw() {
    method enableDoubleBuffering (line 1909) | public static void enableDoubleBuffering() {
    method disableDoubleBuffering (line 1919) | public static void disableDoubleBuffering() {
    method save (line 1940) | public static void save(String filename) {
    method actionPerformed (line 1973) | @Override
    method isMousePressed (line 1999) | public static boolean isMousePressed() {
    method mousePressed (line 2011) | @Deprecated
    method mouseX (line 2023) | public static double mouseX() {
    method mouseY (line 2034) | public static double mouseY() {
    method mouseClicked (line 2044) | @Override
    method mouseEntered (line 2052) | @Override
    method mouseExited (line 2060) | @Override
    method mousePressed (line 2068) | @Override
    method mouseReleased (line 2080) | @Override
    method mouseDragged (line 2090) | @Override
    method mouseMoved (line 2101) | @Override
    method hasNextKeyTyped (line 2120) | public static boolean hasNextKeyTyped() {
    method nextKeyTyped (line 2138) | public static char nextKeyTyped() {
    method isKeyPressed (line 2160) | public static boolean isKeyPressed(int keycode) {
    method keyTyped (line 2170) | @Override
    method keyPressed (line 2180) | @Override
    method keyReleased (line 2190) | @Override
    class RetinaImageIcon (line 2202) | private static class RetinaImageIcon extends ImageIcon {
      method RetinaImageIcon (line 2204) | public RetinaImageIcon(Image image) {
      method getIconWidth (line 2208) | public int getIconWidth() {
      method getIconHeight (line 2217) | public int getIconHeight() {
      method paintIcon (line 2221) | public synchronized void paintIcon(Component c, Graphics g, int x, i...
    method main (line 2238) | public static void main(String[] args) {

FILE: src/main/java/edu/princeton/cs/algs4/StdIn.java
  class StdIn (line 213) | public final class StdIn {
    method StdIn (line 238) | private StdIn() { }
    method isEmpty (line 251) | public static boolean isEmpty() {
    method hasNextLine (line 264) | public static boolean hasNextLine() {
    method hasNextChar (line 276) | public static boolean hasNextChar() {
    method readLine (line 290) | public static String readLine() {
    method readChar (line 307) | public static char readChar() {
    method readAll (line 328) | public static String readAll() {
    method readString (line 345) | public static String readString() {
    method readInt (line 362) | public static int readInt() {
    method readDouble (line 385) | public static double readDouble() {
    method readFloat (line 407) | public static float readFloat() {
    method readLong (line 429) | public static long readLong() {
    method readShort (line 451) | public static short readShort() {
    method readByte (line 473) | public static byte readByte() {
    method readBoolean (line 498) | public static boolean readBoolean() {
    method readAllStrings (line 520) | public static String[] readAllStrings() {
    method readAllLines (line 538) | public static String[] readAllLines() {
    method readAllInts (line 552) | public static int[] readAllInts() {
    method readAllLongs (line 566) | public static long[] readAllLongs() {
    method readAllDoubles (line 580) | public static double[] readAllDoubles() {
    method resync (line 598) | private static void resync() {
    method setScanner (line 602) | private static void setScanner(Scanner scanner) {
    method readInts (line 614) | @Deprecated
    method readDoubles (line 626) | @Deprecated
    method readStrings (line 636) | @Deprecated
    method main (line 647) | public static void main(String[] args) {

FILE: src/main/java/edu/princeton/cs/algs4/StdOut.java
  class StdOut (line 67) | public final class StdOut {
    method StdOut (line 84) | private StdOut() { }
    method println (line 89) | public static void println() {
    method println (line 98) | public static void println(Object x) {
    method println (line 107) | public static void println(boolean x) {
    method println (line 116) | public static void println(char x) {
    method println (line 125) | public static void println(double x) {
    method println (line 134) | public static void println(float x) {
    method println (line 143) | public static void println(int x) {
    method println (line 152) | public static void println(long x) {
    method println (line 161) | public static void println(short x) {
    method println (line 172) | public static void println(byte x) {
    method print (line 179) | public static void print() {
    method print (line 188) | public static void print(Object x) {
    method print (line 198) | public static void print(boolean x) {
    method print (line 208) | public static void print(char x) {
    method print (line 218) | public static void print(double x) {
    method print (line 228) | public static void print(float x) {
    method print (line 238) | public static void print(int x) {
    method print (line 248) | public static void print(long x) {
    method print (line 258) | public static void print(short x) {
    method print (line 268) | public static void print(byte x) {
    method printf (line 281) | public static void printf(String format, Object... args) {
    method printf (line 294) | public static void printf(Locale locale, String format, Object... args) {
    method main (line 304) | public static void main(String[] args) {

FILE: src/main/java/edu/princeton/cs/algs4/StdPicture.java
  class StdPicture (line 175) | public final class StdPicture {
    method StdPicture (line 184) | private StdPicture() { }
    method init (line 195) | public static void init(int width, int height) {
    method read (line 216) | public static void read(String filename) {
    method isVisible (line 245) | public static boolean isVisible() {
    method show (line 252) | public static void show() {
    method hide (line 259) | public static void hide() {
    method pause (line 268) | public static void pause(int t) {
    method height (line 283) | public static int height() {
    method width (line 292) | public static int width() {
    method getAlpha (line 304) | public static int getAlpha(int col, int row) {
    method getRed (line 317) | public static int getRed(int col, int row) {
    method getGreen (line 330) | public static int getGreen(int col, int row) {
    method getBlue (line 343) | public static int getBlue(int col, int row) {
    method getARGB (line 356) | public static int getARGB(int col, int row) {
    method setRGB (line 374) | public static void setRGB(int col, int row, int r, int g, int b) {
    method setARGB (line 397) | public static void setARGB(int col, int row, int a, int r, int g, int ...
    method setARGB (line 433) | public static void setARGB(int col, int row, int argb) {
    method setTitle (line 443) | public static void setTitle(String title) {
    method save (line 460) | public static void save(String filename) {
    method validateComponent (line 464) | private static void validateComponent(int val, String name) {
    method main (line 477) | public static void main(String[] args) {

FILE: src/main/java/edu/princeton/cs/algs4/StdRandom.java
  class StdRandom (line 82) | public final class StdRandom {
    method StdRandom (line 95) | private StdRandom() { }
    method setSeed (line 105) | public static void setSeed(long s) {
    method getSeed (line 115) | public static long getSeed() {
    method uniform (line 125) | @Deprecated
    method uniformDouble (line 135) | public static double uniformDouble() {
    method uniform (line 147) | @Deprecated
    method uniformInt (line 159) | public static int uniformInt(int n) {
    method uniform (line 172) | @Deprecated
    method uniformLong (line 184) | public static long uniformLong(long n) {
    method random (line 215) | @Deprecated
    method uniform (line 230) | @Deprecated
    method uniformInt (line 244) | public static int uniformInt(int a, int b) {
    method uniform (line 260) | @Deprecated
    method uniformDouble (line 273) | public static double uniformDouble(double a, double b) {
    method bernoulli (line 289) | public static boolean bernoulli(double p) {
    method bernoulli (line 302) | public static boolean bernoulli() {
    method gaussian (line 312) | public static double gaussian() {
    method gaussian (line 335) | public static double gaussian(double mu, double sigma) {
    method geometric (line 351) | public static int geometric(double p) {
    method poisson (line 369) | public static int poisson(double lambda) {
    method pareto (line 391) | public static double pareto() {
    method pareto (line 404) | public static double pareto(double alpha) {
    method cauchy (line 415) | public static double cauchy() {
    method discrete (line 429) | public static int discrete(double[] probabilities) {
    method discrete (line 464) | public static int discrete(int[] frequencies) {
    method exponential (line 499) | public static double exponential(double lambda) {
    method exp (line 515) | @Deprecated
    method shuffle (line 526) | public static void shuffle(Object[] a) {
    method shuffle (line 543) | public static void shuffle(double[] a) {
    method shuffle (line 560) | public static void shuffle(int[] a) {
    method shuffle (line 577) | public static void shuffle(char[] a) {
    method shuffle (line 598) | public static void shuffle(Object[] a, int lo, int hi) {
    method shuffle (line 619) | public static void shuffle(double[] a, int lo, int hi) {
    method shuffle (line 640) | public static void shuffle(int[] a, int lo, int hi) {
    method permutation (line 660) | public static int[] permutation(int n) {
    method permutation (line 679) | public static int[] permutation(int n, int k) {
    method validateNotNull (line 697) | private static void validateNotNull(Object x) {
    method validateSubarrayIndices (line 704) | private static void validateSubarrayIndices(int lo, int hi, int length) {
    method main (line 715) | public static void main(String[] args) {

FILE: src/main/java/edu/princeton/cs/algs4/StdStats.java
  class StdStats (line 49) | public final class StdStats {
    method StdStats (line 51) | private StdStats() { }
    method max (line 60) | public static double max(double[] a) {
    method max (line 82) | public static double max(double[] a, int lo, int hi) {
    method max (line 101) | public static int max(int[] a) {
    method min (line 118) | public static double min(double[] a) {
    method min (line 140) | public static double min(double[] a, int lo, int hi) {
    method min (line 159) | public static int min(int[] a) {
    method mean (line 176) | public static double mean(double[] a) {
    method mean (line 195) | public static double mean(double[] a, int lo, int hi) {
    method mean (line 213) | public static double mean(int[] a) {
    method var (line 228) | public static double var(double[] a) {
    method var (line 251) | public static double var(double[] a, int lo, int hi) {
    method var (line 273) | public static double var(int[] a) {
    method varp (line 291) | public static double varp(double[] a) {
    method varp (line 313) | public static double varp(double[] a, int lo, int hi) {
    method stddev (line 335) | public static double stddev(double[] a) {
    method stddev (line 347) | public static double stddev(int[] a) {
    method stddev (line 363) | public static double stddev(double[] a, int lo, int hi) {
    method stddevp (line 378) | public static double stddevp(double[] a) {
    method stddevp (line 394) | public static double stddevp(double[] a, int lo, int hi) {
    method sum (line 408) | private static double sum(double[] a) {
    method sum (line 428) | private static double sum(double[] a, int lo, int hi) {
    method sum (line 446) | private static int sum(int[] a) {
    method plotPoints (line 461) | public static void plotPoints(double[] a) {
    method plotLines (line 479) | public static void plotLines(double[] a) {
    method plotBars (line 496) | public static void plotBars(double[] a) {
    method validateNotNull (line 507) | private static void validateNotNull(Object x) {
    method validateSubarrayIndices (line 513) | private static void validateSubarrayIndices(int lo, int hi, int length) {
    method main (line 525) | public static void main(String[] args) {

FILE: src/main/java/edu/princeton/cs/algs4/Stopwatch.java
  class Stopwatch (line 45) | public class Stopwatch {
    method Stopwatch (line 52) | public Stopwatch() {
    method elapsedTime (line 62) | public double elapsedTime() {
    method main (line 79) | public static void main(String[] args) {

FILE: src/main/java/edu/princeton/cs/algs4/StopwatchCPU.java
  class StopwatchCPU (line 32) | public class StopwatchCPU {
    method StopwatchCPU (line 41) | public StopwatchCPU() {
    method elapsedTime (line 51) | public double elapsedTime() {
    method main (line 67) | public static void main(String[] args) {

FILE: src/main/java/edu/princeton/cs/algs4/SuffixArray.java
  class SuffixArray (line 63) | public class SuffixArray {
    method SuffixArray (line 70) | public SuffixArray(String text) {
    class Suffix (line 78) | private static class Suffix implements Comparable<Suffix> {
      method Suffix (line 82) | private Suffix(String text, int index) {
      method length (line 86) | private int length() {
      method charAt (line 89) | private char charAt(int i) {
      method compareTo (line 93) | public int compareTo(Suffix that) {
      method toString (line 103) | public String toString() {
    method length (line 112) | public int length() {
    method index (line 124) | public int index(int i) {
    method lcp (line 138) | public int lcp(int i) {
    method lcpSuffix (line 144) | private static int lcpSuffix(Suffix s, Suffix t) {
    method select (line 158) | public String select(int i) {
    method rank (line 170) | public int rank(String query) {
    method compare (line 183) | private static int compare(String query, Suffix suffix) {
    method main (line 197) | public static void main(String[] args) {

FILE: src/main/java/edu/princeton/cs/algs4/SuffixArrayX.java
  class SuffixArrayX (line 63) | public class SuffixArrayX {
    method SuffixArrayX (line 74) | public SuffixArrayX(String text) {
    method sort (line 86) | private void sort(int lo, int hi, int d) {
    method insertion (line 111) | private void insertion(int lo, int hi, int d) {
    method less (line 118) | private boolean less(int i, int j, int d) {
    method exch (line 132) | private void exch(int i, int j) {
    method length (line 142) | public int length() {
    method index (line 154) | public int index(int i) {
    method lcp (line 167) | public int lcp(int i) {
    method lcp (line 173) | private int lcp(int i, int j) {
    method select (line 190) | public String select(int i) {
    method rank (line 202) | public int rank(String query) {
    method compare (line 215) | private int compare(String query, int i) {
    method main (line 235) | public static void main(String[] args) {

FILE: src/main/java/edu/princeton/cs/algs4/SymbolDigraph.java
  class SymbolDigraph (line 43) | public class SymbolDigraph {
    method SymbolDigraph (line 56) | public SymbolDigraph(String filename, String delimiter) {
    method contains (line 95) | public boolean contains(String s) {
    method index (line 105) | @Deprecated
    method indexOf (line 115) | public int indexOf(String s) {
    method name (line 126) | @Deprecated
    method nameOf (line 138) | public String nameOf(int v) {
    method G (line 150) | @Deprecated
    method digraph (line 161) | public Digraph digraph() {
    method validateVertex (line 166) | private void validateVertex(int v) {
    method main (line 177) | public static void main(String[] args) {

FILE: src/main/java/edu/princeton/cs/algs4/SymbolGraph.java
  class SymbolGraph (line 68) | public class SymbolGraph {
    method SymbolGraph (line 81) | public SymbolGraph(String filename, String delimiter) {
    method contains (line 121) | public boolean contains(String s) {
    method index (line 131) | @Deprecated
    method indexOf (line 142) | public int indexOf(String s) {
    method name (line 153) | @Deprecated
    method nameOf (line 165) | public String nameOf(int v) {
    method G (line 176) | @Deprecated
    method graph (line 186) | public Graph graph() {
    method validateVertex (line 191) | private void validateVertex(int v) {
    method main (line 203) | public static void main(String[] args) {

FILE: src/main/java/edu/princeton/cs/algs4/TST.java
  class TST (line 63) | public class TST<Value> {
    class Node (line 67) | private static class Node<Value> {
    method TST (line 76) | public TST() {
    method size (line 83) | public int size() {
    method contains (line 94) | public boolean contains(String key) {
    method get (line 108) | public Value get(String key) {
    method get (line 119) | private Node<Value> get(Node<Value> x, String key, int d) {
    method put (line 137) | public void put(String key, Value val) {
    method put (line 146) | private Node<Value> put(Node<Value> x, String key, Value val, int d) {
    method longestPrefixOf (line 167) | public String longestPrefixOf(String query) {
    method keys (line 194) | public Iterable<String> keys() {
    method keysWithPrefix (line 207) | public Iterable<String> keysWithPrefix(String prefix) {
    method collect (line 220) | private void collect(Node<Value> x, StringBuilder prefix, Queue<String...
    method keysThatMatch (line 237) | public Iterable<String> keysThatMatch(String pattern) {
    method collect (line 243) | private void collect(Node<Value> x, StringBuilder prefix, int i, Strin...
    method main (line 263) | public static void main(String[] args) {

FILE: src/main/java/edu/princeton/cs/algs4/TarjanSCC.java
  class TarjanSCC (line 56) | public class TarjanSCC {
    method TarjanSCC (line 71) | public TarjanSCC(Digraph digraph) {
    method dfs (line 84) | private void dfs(Digraph digraph, int v) {
    method count (line 111) | public int count() {
    method stronglyConnected (line 125) | public boolean stronglyConnected(int v, int w) {
    method id (line 137) | public int id(int v) {
    method check (line 143) | private boolean check(Digraph digraph) {
    method validateVertex (line 155) | private void validateVertex(int v) {
    method main (line 166) | public static void main(String[] args) {

FILE: src/main/java/edu/princeton/cs/algs4/ThreeSum.java
  class ThreeSum (line 44) | public class ThreeSum {
    method ThreeSum (line 47) | private ThreeSum() { }
    method printAll (line 55) | public static void printAll(int[] a) {
    method count (line 76) | public static int count(int[] a) {
    method main (line 98) | public static void main(String[] args)  {

FILE: src/main/java/edu/princeton/cs/algs4/ThreeSumFast.java
  class ThreeSumFast (line 60) | public class ThreeSumFast {
    method ThreeSumFast (line 63) | private ThreeSumFast() { }
    method containsDuplicates (line 66) | private static boolean containsDuplicates(int[] a) {
    method printAll (line 79) | public static void printAll(int[] a) {
    method count (line 99) | public static int count(int[] a) {
    method main (line 120) | public static void main(String[] args)  {

FILE: src/main/java/edu/princeton/cs/algs4/TopM.java
  class TopM (line 35) | public class TopM {
    method TopM (line 38) | private TopM() { }
    method main (line 47) | public static void main(String[] args) {

FILE: src/main/java/edu/princeton/cs/algs4/Topological.java
  class Topological (line 59) | public class Topological {
    method Topological (line 68) | public Topological(Digraph digraph) {
    method Topological (line 85) | public Topological(EdgeWeightedDigraph digraph) {
    method order (line 100) | public Iterable<Integer> order() {
    method hasOrder (line 109) | public boolean hasOrder() {
    method isDAG (line 119) | @Deprecated
    method rank (line 133) | public int rank(int v) {
    method validateVertex (line 140) | private void validateVertex(int v) {
    method main (line 151) | public static void main(String[] args) {

FILE: src/main/java/edu/princeton/cs/algs4/TopologicalX.java
  class TopologicalX (line 40) | public class TopologicalX {
    method TopologicalX (line 49) | public TopologicalX(Digraph digraph) {
    method TopologicalX (line 90) | public TopologicalX(EdgeWeightedDigraph digraph) {
    method order (line 134) | public Iterable<Integer> order() {
    method hasOrder (line 143) | public boolean hasOrder() {
    method rank (line 156) | public int rank(int v) {
    method check (line 163) | private boolean check(Digraph digraph) {
    method check (line 206) | private boolean check(EdgeWeightedDigraph digraph) {
    method validateVertex (line 250) | private void validateVertex(int v) {
    method main (line 261) | public static void main(String[] args) {

FILE: src/main/java/edu/princeton/cs/algs4/Transaction.java
  class Transaction (line 26) | public class Transaction implements Comparable<Transaction> {
    method Transaction (line 42) | public Transaction(String who, Date when, double amount) {
    method Transaction (line 58) | public Transaction(String transaction) {
    method who (line 72) | public String who() {
    method when (line 81) | public Date when() {
    method amount (line 90) | public double amount() {
    method toString (line 99) | @Override
    method compareTo (line 112) | public int compareTo(Transaction that) {
    method equals (line 122) | @Override
    method hashCode (line 138) | public int hashCode() {
    class WhoOrder (line 150) | public static class WhoOrder implements Comparator<Transaction> {
      method compare (line 152) | @Override
    class WhenOrder (line 161) | public static class WhenOrder implements Comparator<Transaction> {
      method compare (line 163) | @Override
    class HowMuchOrder (line 172) | public static class HowMuchOrder implements Comparator<Transaction> {
      method compare (line 174) | @Override
    method main (line 186) | public static void main(String[] args) {

FILE: src/main/java/edu/princeton/cs/algs4/TransitiveClosure.java
  class TransitiveClosure (line 58) | public class TransitiveClosure {
    method TransitiveClosure (line 65) | public TransitiveClosure(Digraph digraph) {
    method reachable (line 80) | public boolean reachable(int v, int w) {
    method validateVertex (line 87) | private void validateVertex(int v) {
    method main (line 98) | public static void main(String[] args) {

FILE: src/main/java/edu/princeton/cs/algs4/TrieSET.java
  class TrieSET (line 39) | public class TrieSET implements Iterable<String> {
    class Node (line 46) | private static class Node {
    method TrieSET (line 54) | public TrieSET() {
    method contains (line 64) | public boolean contains(String key) {
    method get (line 71) | private Node get(Node x, String key, int d) {
    method add (line 83) | public void add(String key) {
    method add (line 88) | private Node add(Node x, String key, int d) {
    method size (line 105) | public int size() {
    method isEmpty (line 113) | public boolean isEmpty() {
    method iterator (line 123) | public Iterator<String> iterator() {
    method keysWithPrefix (line 133) | public Iterable<String> keysWithPrefix(String prefix) {
    method collect (line 140) | private void collect(Node x, StringBuilder prefix, Queue<String> resul...
    method keysThatMatch (line 157) | public Iterable<String> keysThatMatch(String pattern) {
    method collect (line 164) | private void collect(Node x, StringBuilder prefix, String pattern, Que...
    method longestPrefixOf (line 194) | public String longestPrefixOf(String query) {
    method longestPrefixOf (line 205) | private int longestPrefixOf(Node x, String query, int d, int length) {
    method delete (line 218) | public void delete(String key) {
    method delete (line 223) | private Node delete(Node x, String key, int d) {
    method main (line 248) | public static void main(String[] args) {

FILE: src/main/java/edu/princeton/cs/algs4/TrieST.java
  class TrieST (line 50) | public class TrieST<Value> {
    class Node (line 58) | private static class Node {
    method TrieST (line 66) | public TrieST() {
    method get (line 77) | public Value get(String key) {
    method contains (line 91) | public boolean contains(String key) {
    method get (line 96) | private Node get(Node x, String key, int d) {
    method put (line 111) | public void put(String key, Value val) {
    method put (line 117) | private Node put(Node x, String key, Value val, int d) {
    method size (line 133) | public int size() {
    method isEmpty (line 141) | public boolean isEmpty() {
    method keys (line 151) | public Iterable<String> keys() {
    method keysWithPrefix (line 161) | public Iterable<String> keysWithPrefix(String prefix) {
    method collect (line 168) | private void collect(Node x, StringBuilder prefix, Queue<String> resul...
    method keysThatMatch (line 185) | public Iterable<String> keysThatMatch(String pattern) {
    method collect (line 191) | private void collect(Node x, StringBuilder prefix, String pattern, Que...
    method longestPrefixOf (line 221) | public String longestPrefixOf(String query) {
    method longestPrefixOf (line 232) | private int longestPrefixOf(Node x, String query, int d, int length) {
    method delete (line 245) | public void delete(String key) {
    method delete (line 250) | private Node delete(Node x, String key, int d) {
    method main (line 274) | public static void main(String[] args) {

FILE: src/main/java/edu/princeton/cs/algs4/TwoPersonZeroSumGame.java
  class TwoPersonZeroSumGame (line 53) | public class TwoPersonZeroSumGame {
    method TwoPersonZeroSumGame (line 68) | public TwoPersonZeroSumGame(double[][] payoff) {
    method value (line 106) | public double value() {
    method scale (line 112) | private double scale() {
    method row (line 125) | public double[] row() {
    method column (line 138) | public double[] column() {
    method isPrimalFeasible (line 154) | private boolean isPrimalFeasible() {
    method isDualFeasible (line 174) | private boolean isDualFeasible() {
    method isNashEquilibrium (line 194) | private boolean isNashEquilibrium(double[][] payoff) {
    method certifySolution (line 233) | private boolean certifySolution(double[][] payoff) {
    method test (line 238) | private static void test(String description, double[][] payoff) {
    method test1 (line 263) | private static void test1() {
    method test2 (line 273) | private static void test2() {
    method test3 (line 287) | private static void test3() {
    method test4 (line 305) | private static void test4() {
    method test5 (line 322) | private static void test5() {
    method main (line 337) | public static void main(String[] args) {

FILE: src/main/java/edu/princeton/cs/algs4/UF.java
  class UF (line 83) | public class UF {
    method UF (line 97) | public UF(int n) {
    method find (line 115) | public int find(int p) {
    method count (line 129) | public int count() {
    method connected (line 144) | @Deprecated
    method union (line 158) | public void union(int p, int q) {
    method validate (line 174) | private void validate(int p) {
    method main (line 190) | public static void main(String[] args) {

FILE: src/main/java/edu/princeton/cs/algs4/Vector.java
  class Vector (line 43) | public class Vector {
    method Vector (line 54) | public Vector(int d) {
    method Vector (line 66) | public Vector(double... a) {
    method length (line 81) | @Deprecated
    method dimension (line 91) | public int dimension() {
    method dot (line 102) | public double dot(Vector that) {
    method magnitude (line 116) | public double magnitude() {
    method distanceTo (line 127) | public double distanceTo(Vector that) {
    method plus (line 139) | public Vector plus(Vector that) {
    method minus (line 154) | public Vector minus(Vector that) {
    method cartesian (line 168) | public double cartesian(int i) {
    method times (line 179) | @Deprecated
    method scale (line 193) | public Vector scale(double alpha) {
    method direction (line 206) | public Vector direction() {
    method toString (line 218) | public String toString() {
    method main (line 230) | public static void main(String[] args) {

FILE: src/main/java/edu/princeton/cs/algs4/WeightedQuickUnionUF.java
  class WeightedQuickUnionUF (line 65) | public class WeightedQuickUnionUF {
    method WeightedQuickUnionUF (line 78) | public WeightedQuickUnionUF(int n) {
    method count (line 93) | public int count() {
    method find (line 104) | public int find(int p) {
    method connected (line 122) | @Deprecated
    method validate (line 128) | private void validate(int p) {
    method union (line 144) | public void union(int p, int q) {
    method main (line 171) | public static void main(String[] args) {