▶ 书中第四章部分程序,包括在加上自己补充的代码,图的前序、后序和逆后续遍历,以及传递闭包

● 图的前序、后序和逆后续遍历

 package package01;

 import edu.princeton.cs.algs4.In;
import edu.princeton.cs.algs4.StdOut;
import edu.princeton.cs.algs4.Digraph;
import edu.princeton.cs.algs4.EdgeWeightedDigraph;
import edu.princeton.cs.algs4.DirectedEdge;
import edu.princeton.cs.algs4.Queue;
import edu.princeton.cs.algs4.Stack; public class class01
{
private boolean[] marked;
private int[] pre; // 前序顶点列表(索引 -> 顶点)
private int[] post; // 后序顶点列表
private Queue<Integer> preorder; // 前序队列(顶点)
private Queue<Integer> postorder; // 后续队列
private int preCounter; // 前序计数器
private int postCounter; // 后序计数器 public class01(Digraph G)
{
pre = new int[G.V()];
post = new int[G.V()];
postorder = new Queue<Integer>();
preorder = new Queue<Integer>();
marked = new boolean[G.V()];
for (int v = 0; v < G.V(); v++)
{
if (!marked[v])
dfs(G, v);
}
} public class01(EdgeWeightedDigraph G)
{
pre = new int[G.V()];
post = new int[G.V()];
postorder = new Queue<Integer>();
preorder = new Queue<Integer>();
marked = new boolean[G.V()];
for (int v = 0; v < G.V(); v++)
{
if (!marked[v])
dfs(G, v);
}
} private void dfs(Digraph G, int v)
{
marked[v] = true;
pre[v] = preCounter++; // 前序和后序差别在于,将当前顶点加入队列以及递归的先后顺序
preorder.enqueue(v);
for (int w : G.adj(v))
{
if (!marked[w])
dfs(G, w);
}
postorder.enqueue(v);
post[v] = postCounter++;
} private void dfs(EdgeWeightedDigraph G, int v)
{
marked[v] = true;
pre[v] = preCounter++;
preorder.enqueue(v);
for (DirectedEdge e : G.adj(v))
{
int w = e.to();
if (!marked[w])
dfs(G, w);
}
postorder.enqueue(v);
post[v] = postCounter++;
} public int pre(int v)
{
return pre[v];
} public int post(int v)
{
return post[v];
} public Iterable<Integer> pre()
{
return preorder;
} public Iterable<Integer> post()
{
return postorder;
} public Iterable<Integer> reversePost() // 用后续队列生成逆后序栈
{
Stack<Integer> reverse = new Stack<Integer>();
for (int v : postorder)
reverse.push(v);
return reverse;
} public static void main(String[] args)
{
In in = new In(args[0]);
Digraph G = new Digraph(in);
class01 dfs = new class01(G);
StdOut.println(" v pre post");
StdOut.println("--------------");
for (int v = 0; v < G.V(); v++)
StdOut.printf("%4d %4d %4d\n", v, dfs.pre(v), dfs.post(v)); StdOut.print("Preorder: "); // 分别输出前序、后序和逆后序
for (int v : dfs.pre())
StdOut.print(v + " ");
StdOut.println(); StdOut.print("Postorder: ");
for (int v : dfs.post())
StdOut.print(v + " ");
StdOut.println(); StdOut.print("Reverse postorder: ");
for (int v : dfs.reversePost())
StdOut.print(v + " ");
StdOut.println();
}
}

● 传递闭包

 package package01;

 import edu.princeton.cs.algs4.In;
import edu.princeton.cs.algs4.StdOut;
import edu.princeton.cs.algs4.Digraph;
import edu.princeton.cs.algs4.DirectedDFS; public class class01
{
private DirectedDFS[] tc; public class01(Digraph G)
{
tc = new DirectedDFS[G.V()];
for (int v = 0; v < G.V(); v++) // 循环尝试从所有点开始深度优先遍历整个图,返回可达点的迭代器
tc[v] = new DirectedDFS(G, v);
} public boolean reachable(int v, int w)
{
return tc[v].marked(w);
} public static void main(String[] args)
{
In in = new In(args[0]);
Digraph G = new Digraph(in);
class01 tc = new class01(G); StdOut.print(" ");
for (int v = 0; v < G.V(); v++)
StdOut.printf("%3d", v);
StdOut.println("\n--------------------------------------------"); for (int v = 0; v < G.V(); v++)
{
StdOut.printf("%3d: ", v);
for (int w = 0; w < G.V(); w++)
StdOut.printf(tc.reachable(v, w) ? " T" : " ");
StdOut.println();
}
}
}

《算法》第四章部分程序 part 13的更多相关文章

  1. 《算法》第四章部分程序 part 19

    ▶ 书中第四章部分程序,包括在加上自己补充的代码,有边权有向图的邻接矩阵,FloydWarshall 算法可能含负环的有边权有向图任意两点之间的最短路径 ● 有边权有向图的邻接矩阵 package p ...

  2. 《算法》第四章部分程序 part 18

    ▶ 书中第四章部分程序,包括在加上自己补充的代码,在有权有向图中寻找环,Bellman - Ford 算法求最短路径,套汇算法 ● 在有权有向图中寻找环 package package01; impo ...

  3. 《算法》第四章部分程序 part 16

    ▶ 书中第四章部分程序,包括在加上自己补充的代码,Dijkstra 算法求有向 / 无向图最短路径,以及所有顶点对之间的最短路径 ● Dijkstra 算法求有向图最短路径 package packa ...

  4. 《算法》第四章部分程序 part 15

    ▶ 书中第四章部分程序,包括在加上自己补充的代码,Kruskal 算法和 Boruvka 算法求最小生成树 ● Kruskal 算法求最小生成树 package package01; import e ...

  5. 《算法》第四章部分程序 part 14

    ▶ 书中第四章部分程序,包括在加上自己补充的代码,两种 Prim 算法求最小生成树 ● 简单 Prim 算法求最小生成树 package package01; import edu.princeton ...

  6. 《算法》第四章部分程序 part 10

    ▶ 书中第四章部分程序,包括在加上自己补充的代码,包括无向图连通分量,Kosaraju - Sharir 算法.Tarjan 算法.Gabow 算法计算有向图的强连通分量 ● 无向图连通分量 pack ...

  7. 《算法》第四章部分程序 part 9

    ▶ 书中第四章部分程序,包括在加上自己补充的代码,两种拓扑排序的方法 ● 拓扑排序 1 package package01; import edu.princeton.cs.algs4.Digraph ...

  8. 《算法》第四章部分程序 part 17

    ▶ 书中第四章部分程序,包括在加上自己补充的代码,无环图最短 / 最长路径通用程序,关键路径方法(critical path method)解决任务调度问题 ● 无环图最短 / 最长路径通用程序 pa ...

  9. 《算法》第四章部分程序 part 12

    ▶ 书中第四章部分程序,包括在加上自己补充的代码,图的几种补充数据结构,包括无向 / 有向符号图,有权边结构,有边权有向图 ● 无向符号图 package package01; import edu. ...

随机推荐

  1. awk 文本处理工具

    awk: 强大的文本处理工具,擅长对日志文件进行分析: 不仅用于Linux,也是任何环境中现在的功能最强大的数据处理引擎: 语法说明: awk '{pattern + action}' {filena ...

  2. 开始使用Chronograf(官方说明)

    地址:https://docs.influxdata.com/chronograf/v1.6/introduction/getting-started/ 开始使用Chronograf 在本页面 入门概 ...

  3. linux svn客户端通过 https访问windows VisualSVN Server Manager

    1)需求: 已经在阿里云windwos系统 下面安装了VisualSVN Server Manager 做为svn服务器: 现在要在腾讯云源码安装新版本客户端 2)开始源码编译安装TortoiseSV ...

  4. <亲测>centos安装 .net core 2.1

    https://www.microsoft.com/net/learn/get-started-with-dotnet-tutorial#install .NET Tutorial - Hello W ...

  5. S域传递函数的零点和极点

    传递函数的极点就是对应微分方程的特征根(回忆一下,$\frac{1}{s+a}$是$e^{-a t}$的Laplace变换),因此它们决定了系统自由运动的模态. 传递函数的零点不直接形成自由运动的模态 ...

  6. Hadoop概念学习系列之为什么hadoop/spark执行作业时,输出路径必须要不存在?(三十九)

    很多人只会,但没深入体会和想为什么要这样? 拿Hadoop来说,当然,spark也一样的道理. 输出路径由Hadoop自己创建,实际的结果文件遵守part-nnnn的约定. 如何指定一个已有目录作为H ...

  7. java设计模式-Iterator

    Iterator模式 主要是用在容器的遍历上,其他的地方都不怎么用:理解一下,会用了就可以了:   1.背景 请动手自己写一个可以动态添加对象的容器: 代码: ArrayList.java(是自己实现 ...

  8. Java-Runoob-高级教程-实例-方法:15. Java 实例 – 重载(overloading)方法中使用 Varargs

    ylbtech-Java-Runoob-高级教程-实例-方法:15. Java 实例 – 重载(overloading)方法中使用 Varargs 1.返回顶部 1. Java 实例 - 重载(ove ...

  9. 学习笔记之TensorFlow

    TensorFlow https://www.tensorflow.org/ An open source machine learning framework for everyone Tensor ...

  10. [转][Oracle][null]

    trim(nvl(ipaddress,'')) != '' 这段SQL 并没有像 MSSQL  IsNull 一样返回不含空白或null 的内容 经尝试发现  trim('') 为 null a fr ...