G = (V, E)

function Graph() {
    this.vertices = [] // 顶点集合
    this.edges = new Map() // 边集合
}
Graph.prototype.addVertex = function(v) { // 添加顶点方法
    this.vertices.push(v)
    this.edges.set(v, [])
}
Graph.prototype.addEdge = function(v, w) { // 添加边方法
    let vEdge = this.edges.get(v)
    vEdge.push(w)
    let wEdge = this.edges.get(w)
    wEdge.push(v)
    this.edges.set(v, vEdge)
    this.edges.set(w, wEdge)
}
Graph.prototype.toString = function() {
    var s = ''
    for (var i=0; i<this.vertices.length; i++) {
        s += this.vertices[i] + ' -> '
        var neighors = this.edges.get(this.vertices[i])
        for (var j=0; j<neighors.length; j++) {
            s += neighors[j] + ' '
        }
        s += '\n'
    }
    return s
}

var graph = new Graph()
var vertices = [1, 2, 3, 4, 5]
for (var i=0; i<vertices.length; i++) {
    graph.addVertex(vertices[i])
}
graph.addEdge(1, 4); //增加边
graph.addEdge(1, 3);
graph.addEdge(2, 3);
graph.addEdge(2, 5);

console.log(graph.toString())
// 1 -> 4 3 
// 2 -> 3 5 
// 3 -> 1 2 
// 4 -> 1 
// 5 -> 2

Graph.prototype.dfs = function() {
    var marked = []
    for (var i=0; i<this.vertices.length; i++) {
        if (!marked[this.vertices[i]]) {
            dfsVisit(this.vertices[i])
        }
    }
    
    function dfsVisit(u) {
        let edges = this.edges
        marked[u] = true
        console.log(u)
        var neighbors = edges.get(u)
        for (var i=0; i<neighbors.length; i++) {
            var w = neighbors[i]
            if (!marked[w]) {
                dfsVisit(w)
            }
        }
    }
}

graph.dfs()
// 1
// 4
// 3
// 2
// 5

Graph.prototype.bfs = function(v) {
    var queue = [], marked = []
    marked[v] = true
    queue.push(v) // 添加到队尾
    while(queue.length > 0) {
        var s = queue.shift() // 从队首移除
        if (this.edges.has(s)) {
            console.log('visited vertex: ', s)
        }
        let neighbors = this.edges.get(s)
        for(let i=0;i<neighbors.length;i++) {
            var w = neighbors[i]
            if (!marked[w]) {
                marked[w] = true
                queue.push(w)
            }
        }
    }
}

graph.bfs(1)
// visited vertex:  1
// visited vertex:  4
// visited vertex:  3
// visited vertex:  2
// visited vertex:  5

const data = [{
       name: 'a',
       children: [{
           name: 'a1',
           children: [{
               name: 'a11'
           }, {
               name: 'a12'
           }]
       }, {
           name: 'a2',
           children: [{
               name: 'a21'
           }, {
               name: 'a22'
           }]
       }, {
           name: 'a3',
           children: [{
               name: 'a31'
           }, {
               name: 'a32'
           }]
       }, ],
   }, {
       name: 'b',
       children: [{
           name: 'b1',
           children: [{
               name: 'b11'
           }, {
               name: 'b12'
           }]
       }, {
           name: 'b2',
           children: [{
               name: 'b21'
           }, {
               name: 'b22'
           }]
       }, {
           name: 'b3',
           children: [{
               name: 'b31'
           }, {
               name: 'b32'
           }]
       }, ],
   }];

   let result = [];
   // 深度遍历

   function deep(ary) {
       for (const val of ary) {
           result.push(val.name);
           if (Array.isArray(val.children)) {
               deep(val.children);
           }
       }
       return result.join(',');
   }
   // const str = deep(data);

   // 广度遍历

   function bfs(ary) {   // 对比了下楼上的,我发现我这运行效率有点低,233333
       let quee = [];
       for (let i = 0; i < ary.length; i++) {
           result.push(ary[i].name);
           if (Array.isArray(ary[i].children)) {
               quee.push(...ary[i].children);
               if (i === ary.length - 1) {
                   bfs(quee);
               }
           }
       }
       return result.join(',');
   }

   const str = bfs(data);
   console.log(str);

class TreeNode {
  constructor(val, left = null, right = null) {
    this.val = val;
    this.left = left;
    this.right = right;
  }
}

const root = new TreeNode(
  1,
  new TreeNode(2, null, new TreeNode(4)),
  new TreeNode(3, new TreeNode(5))
);
console.log(root);

function dfs(root) {
  if (!root) return;
  console.log(root.val);
  dfs(root.left);
  dfs(root.right);
}
function bfs(root) {
  if (!root) return
  const queue = []
  queue.push(root)
  while(queue.length){
    let len = queue.length
    for(let i = 0; i < len; i++){
      let cur = queue.shift()
      console.log(cur.val);
      if(cur.left) queue.push(cur.left)
      if(cur.right) queue.push(cur.right)
    }
  }
}

console.log("------------------dfs-----------------");
dfs(root);
console.log("------------------bfs-----------------");
bfs(root);

function Graph() {
  this.vertices = []; //顶点集合
  this.edges = new Map(); //边集合
}

//添加顶点方法
Graph.prototype.addVertex = function (v) {
  this.vertices.push(v);
  this.edges.set(v, []);
};

//添加边方法
Graph.prototype.addEdge = function (v, w) {
  if (v === w) return;
  let vEdge = this.edges.get(v);
  vEdge.push(w);
  let wEdge = this.edges.get(w);
  wEdge.push(v);
  this.edges.set(v, vEdge);
  this.edges.set(w, wEdge);
};

// 打印出顶点和与其相邻的顶点
Graph.prototype.toString = function () {
  let s = "";
  for (const vertex of this.vertices) {
    s += vertex + " -> ";
    const neighbors = this.edges.get(vertex);
    for (const neighbor of neighbors) {
      s += neighbor + " ";
    }
    s += "\n";
  }
  return s;
};

// 测试
const graph = new Graph();
const vertices = ["A", "B", "C", "D", "E", "F", "G", "H", "I"];
for (v of vertices) {
  graph.addVertex(v);
}

graph.addEdge("A", "B");
graph.addEdge("A", "F");

graph.addEdge("B", "C");
graph.addEdge("B", "I");
graph.addEdge("B", "G");

graph.addEdge("C", "D");
graph.addEdge("C", "I");

graph.addEdge("D", "E");
graph.addEdge("D", "H");
graph.addEdge("D", "G");
graph.addEdge("D", "I");

graph.addEdge("E", "F");
graph.addEdge("E", "H");

graph.addEdge("F", "G");

graph.addEdge("H", "G");

console.log(graph.toString());
// A -> B F       
// B -> A C I G   
// C -> B D I     
// D -> C E H G I 
// E -> D F H     
// F -> A E G     
// G -> B D F H   
// H -> D E G     
// I -> B C D    

Graph.prototype.dfs = function () {
  // 原例子用的是数组 因为它存的顶点是number类型
  // 但我这边是string 所以使用map 同时也兼容number类型的情况
  const marked = new Map();
  const edges = this.edges;
  for (const vertex of this.vertices) {
    if (!marked.get(vertex)) {
      dfsVisit(vertex);
    }
  }

  function dfsVisit(u) {
    marked.set(u, true);
    console.log(u);
    const neighbors = edges.get(u);
    for (const w of neighbors) {
      if (!marked.get(w)) {
        dfsVisit(w);
      }
    }
  }
};

graph.dfs();
// A
// B
// C
// D
// E
// F
// G
// H
// I

Graph.prototype.bfs = function (v) {
  const queue = [];
  const marked = new Map();
  marked.set(v, true);
  queue.push(v); //添加到队尾
  while (queue.length > 0) {
    const s = queue.shift(); //从队首移除
    if (this.edges.has(s)) {
      console.log(s);
    }
    const neighbors = this.edges.get(s);
    for (const w of neighbors) {
      if (!marked.get(w)) {
        marked.set(w, true);
        queue.push(w);
      }
    }
  }
};

graph.bfs("A");
// A
// B
// F
// C
// I
// G
// E
// D
// H

//撰写图的构造函数和方法
function Graph() {
  this.vertices = [];
  this.edges = new Map();
}

Graph.prototype.addVertex = function (v) {
  this.vertices.push(v);
  this.edges.set(v, []); //给顶点set一个边集合（空）
};

Graph.prototype.addEdge = function (v, w) {
  if (v === w) return;
  //分别拿到v w 的相邻点集合 push进去 不需要再set
  this.edges.get(v).push(w);
  this.edges.get(w).push(v);
};

//Depth First Search
Graph.prototype.dfs = function () {
  //图的dfs需要一个map来存放traversal过的顶点
  //因为不是树形结构 所以会出现traversal回来的情况
  const marked = new Map();
  //储存变量方便traversal函数使用 因为this是undefined
  const edges = this.edges;
  //遍历所有的点
  for (const vertex of this.vertices) {
    //若没有被traversal过 则traversal它
    if (!marked.get(vertex)) {
      traversal(vertex);
    }
  }
	//函数声明会提升 但是const定义变量不会提升 
	//所以edges要在前面定义好了
  function traversal(u) {
    marked.set(u, true);
    //操作
    console.log(u, "-dfsTraversal");
    const neighbors = edges.get(u);
    //** 一直往下遍历
    for (const w of neighbors) {
      if (!marked.get(w)) {
        traversal(w);
      }
    }
  }
};

//Breadth First Search
//需要一个起始节点
Graph.prototype.bfs = function (v) {
  if (!this.edges.has(v)) {
    console.log("需要一个正确的起始节点");
    return;
  }
  //需要维护一个队列
  const queue = [];
  const marked = new Map();
	//添加到队尾
  queue.push(v);
  //入队marked设置为true
  marked.set(v, true);
  while (queue.length > 0) {
    //remove first element 出队
    const u = queue.shift();
    //操作
    console.log(u, "-bfsTraversal");
    //需要将它的neighbor中未被遍历过的点加入队列
    const neighbor = this.edges.get(u);
    for (const w of neighbor) {
      //保证队列里都是未被遍历过的顶点
      if (!marked.get(w)) {
        //**只要进入了队列 就当做被遍历过 marked中设置为true
        //这样可以避免无限向队列里添加点
        marked.set(w, true);
        queue.push(w);
      }
    }
  }
};

// 树的dfs不需要存marked标记 自上而下的递归就行了（因为不可能往回走）
const dfs1 = node => {
	if (node != null) {
		for (const child of node.children) {
			//操作
			console.dir(child);
			//递归
			dfs1(child);
		}
	}
	};

//不使用递归
const dfs2 = node => {
	const stack = [];
	if (node !== null) {
		stack.push(node);
		//while(stack.length)也行
		while (stack.length > 0) {
			//后进(push)先出(pop)
			const item = stack.pop();
			//操作
			console.dir(item, "stack");
			const children = item.children;
			//循环入栈children
			//倒着循环是为了和上述结果保持一致 for of 也可以
			for (let i = children.length - 1; i >= 0; i--) {
				stack.push(children[i]);
			}
		}
	}
};

const bfs = node => {
	const queue = [];
	if (node != null) {
		queue.push(node);
		while (queue.length > 0) {
			//出队
			const item = queue.shift();
			//操作
			console.dir(item);
			const children = item.children;
			//子节点入队
			for (const child of children) {
				queue.push(child);
			}
		}
	}
};