CC Chapter 4 Tree and Graph --Graph

1. Graphs

A tree is actually a type of graph, but not all graphs are trees. Simply put, a tree is a connected graph without cycles. 

A graph is simply a collection of nodes with edges between (some of) them. 

• Graphs can be either directed or undirected. While directed edges are like a one-way street, undirected edges are like a two-way street. 
• The graph might consist of multiple isolated subgraphs. If there is a path between every pair of vertices, it is called a connected graph. 
• The graph can also have cycles(or not). An "Acyclic graph" is one without cycles. 

Representation

(1) Adjacency List

Every vertex stores a list of adjacent vertices. In an undirected graph, an edge like (a, b) store twice. once in a's adjacent vertices and once in b's adjacent vertices.

class Graph{
       public Node[] nodes;
}

class Node{
       public String name;
       public Node[] children;
}

(2) Adjacency Matrices

An adjacency matrix is an N* N boolean matrix( where N is the number of nodes), where a true value at matrix[i][j] indicates an edge from node i to node j. (or 0s and 1s)

2. Graph Search

DFS(depth-first search): start at root, explore each branch completely before moving onto the next branch. Go deep first we go wide.

BFS(Breadth -first search): start at root, and explore each neighbor before going on to any of their children. Go wide before we go deep.

void DFS(Node root)
{
       if(root == null) return;
       visit(root);
       root.visited = true;
       foreach(Node n in root.adjacent){
             if(n.visited == false){
                  DFS(n);
             }
       }
}

void BFS(Node root){
       Queue queue = new Queue();
       root.marked = true;
       queue.enqueue(root); //add to the end of queue

       while(!queue.isEmpty()){
             Node r = queue.dequeue(); //remove from the front of the queue
            visit(r);
            foreach(Node in r.adjacent){
                     if(n.marked == false){
                          n.marked = true;
                          queue.enqueue(n);
                     }
           }
       }
}

Bidirectional Search : find the shortest path between a source and destination node. It operates by essentially running two simultaneous breath-first searches, one from each node. When their searches collide, we have found a path.