我最近正在接受Java Developer的职位面试。我接受了一项任务：考虑用Java表示电路（如下图所示）的好方法。
picture for illustration http://oi40.tinypic.com/nnr4wj.jpgg
电路是逻辑门XOR，AND，OR等的组合。每个门有两个输入端口和一个输出端口。每个输出连接到另一个门的输入，该门一直连接到更高的门（如图所示）。使系统简单，不允许循环（尽管现实生活中的电路可以使用它们）。 我被要求考虑使用以下指南在Java中表示此模型的好方法：
我选择将系统设计为树，面试官告诉我这是一个不错的选择。然后我建立这些类：
节点
public class gate_node {
gate_node right_c,left_c;
Oprtator op;
int value;
int right_v,left_v;
public gate_node(gate_node right,gate_node left,Oprtator op){
this.left_c=left;
this.right_c=right;
this.op=op;
right_v=left_v=0;
}
}
树
public class tree {
gate_node head;
tree(gate_node head) {
this.head = head;
}
void go_right() {
head = head.right_c;
}
void go_left() {
head = head.left_c;
}
static int arr[] = { 0, 0, 1, 0 };
static int counter=0;
static int compute(gate_node head) {
if ((head.left_c == null) && (head.right_c == null))
{
int ret=(head.op.calc(arr[counter], arr[counter+1]));
counter++;
counter++;
return ret;
}
return (head.op.calc(compute(head.left_c), compute(head.right_c)));
}
public static void main(String[] args) {
tree t = new tree(new gate_node(null, null, new and()));
t.head.left_c = new gate_node(null, null, new and());
t.head.right_c = new gate_node(null, null, new or());
System.out.println(tree.compute(t.head));
}
}
Oprtator课程：
public abstract class Oprtator {
abstract int calc(int x, int y);
}
或门：
public class or extends Oprtator {
public int calc(int x, int y){
return (x|y);
}
}
在上面的代码中，我将电路板实现为具有当前磁头的树（可以向下/向右/向右移动）。每个节点有2个子节点（也是节点类型），2个条目（0/1），一个值和一个运算符（抽象类，可以通过OR / AND扩展..）。
我使用了一个计数器和一个数组将值插入到树的相应叶子中（如代码中所述）。
它有效，但我仍然觉得我的面试官想要更多东西。我的代码是否正确？有没有人有更好的方式来代表这个电路板以及如何提供良好的输出（在复杂性或使用从一个类到另一个类的更好连接，设计模式，还有其他什么？）
答案 0 :(得分：3)
这不是一个“完美”的答案，但您可以使用几个类来解决这个问题，以保持逻辑连接/评估，然后递归评估电路。
创建一个基类LogicalNode并为其提供要管理的输入列表。给它一个基类函数来评估所有输入并返回一个输出。这在派生类中被覆盖。每种类型的节点（INPUT，NOT，AND，OR）都会获得一个带有特殊“ComputOutput”重写版本的派生类。如果计算输出节点的输出，它应该递归树，计算输入输入的所有输入等，直到它到达“INPUT”节点，这些节点是系统的固定/逻辑输入。
您可以相当快速地创建新类型（请参阅代码）。这里没有很多评论，但它应该有点自我解释。
像这样（在C＃中）：
public class LogicalNode
{
private List<LogicalNode> _inputs = new List<LogicalNode>();
private String _name = "Not Set";
public override string ToString()
{
return String.Format("Node {0}", _name);
}
public void Reset()
{
_inputs.Clear();
}
public void SetName(String name)
{
_name = name;
}
protected List<LogicalNode> GetInputs()
{
return _inputs;
}
public void AddInput(LogicalNode node)
{
_inputs.Add(node);
}
protected virtual bool ComputeOutputInternal()
{
return false;
}
public bool ComputeOutput()
{
// Console.WriteLine("Computing output on {0}.", _name);
return ComputeOutputInternal();
}
}
public class LogicalInput : LogicalNode
{
private bool _state = true;
public void SetState(bool state)
{
_state = state;
}
public bool GetState() { return _state; }
protected override bool ComputeOutputInternal()
{
return _state;
}
}
public class LogicalAND : LogicalNode
{
protected override bool ComputeOutputInternal()
{
List<LogicalNode> inputs = GetInputs();
bool result = true;
for (Int32 idx = 0; idx < inputs.Count && result; idx++)
{
result = result && inputs[idx].ComputeOutput();
}
return result;
}
}
public class LogicalOR : LogicalNode
{
protected override bool ComputeOutputInternal()
{
List<LogicalNode> inputs = GetInputs();
bool result = false;
for (Int32 idx = 0; idx < inputs.Count; idx++)
{
result = inputs[idx].ComputeOutput();
if (result)
// If we get one true, that is enough.
break;
}
return result;
}
}
public class LogicalNOT : LogicalNode
{
protected override bool ComputeOutputInternal()
{
List<LogicalNode> inputs = GetInputs();
if (inputs.Count > 0)
{ // NOTE: This is not an optimal design for
// handling distinct different kinds of circuits.
//
// It it demonstrative only!!!!
return !inputs[0].ComputeOutput();
}
return false;
}
然后（快速）测试它：
static void Main(string[] args)
{
// The test circuit
// !((A&&B) || C)
// A B C Out
// 1 1 1 0
// 1 1 0 0
// 1 0 1 0
// 1 0 0 1
// 0 1 1 0
// 0 1 0 1
// 0 0 1 0
// 0 0 0 1
//
//
//
/* ------- -------
* A - | | | |
* | AND |-----| | -------
* B - | (D) | | | | |
* ------- | OR |----| NOT |----
* | (E) | | (F) |
* C --------------| | | |
* ------- -------
*/
LogicalInput A = new LogicalInput();
LogicalInput B = new LogicalInput();
LogicalInput C = new LogicalInput();
LogicalAND D = new LogicalAND();
LogicalOR E = new LogicalOR();
LogicalNOT F = new LogicalNOT();
A.SetName("A");
B.SetName("B");
C.SetName("C");
D.SetName("D");
E.SetName("E");
F.SetName("F");
D.AddInput(A);
D.AddInput(B);
E.AddInput(D);
E.AddInput(C);
F.AddInput(E);
// Truth Table
bool[] states = new bool[]{ true, false };
for(int idxA = 0; idxA < 2; idxA++)
{
for(int idxB = 0; idxB < 2; idxB++)
{
for(int idxC = 0; idxC < 2; idxC++)
{
A.SetState(states[idxA]);
B.SetState(states[idxB]);
C.SetState(states[idxC]);
bool result = F.ComputeOutput();
Console.WriteLine("A = {0}, B = {1}, C = {2}, Output = {3}",
A.GetState(), B.GetState(), C.GetState(), result.ToString());
}
}
}
}
}
输出：
A = True, B = True, C = True, Output = False
A = True, B = True, C = False, Output = False
A = True, B = False, C = True, Output = False
A = True, B = False, C = False, Output = True
A = False, B = True, C = True, Output = False
A = False, B = True, C = False, Output = True
A = False, B = False, C = True, Output = False
A = False, B = False, C = False, Output = True
这有用吗？
答案 1 :(得分：2)
虽然我显然无法确切地说出面试官正在寻找什么，但如果我正在采访你，我可能会敦促你让你的compute方法成为gate_node课程的非静态成员。通过这种方式，您的网络不必在一侧或另一侧“平衡”（它们可以更深，更多输入）。
换句话说，看看你的计算代码，我认为它不适用于一般电路。
或许类似于以下内容（在gate_node中）：
int compute() {
/* The following use of a static sInputCounter assumes that the static/global
* input array is ordered from left to right, irrespective of "depth". */
final int left = (null != left_c ? left_c.compute() : sInput[sInputCounter++]);
final int right = (null != right_c ? right_c.compute() : sInput[sInputCounter++]);
return op.calc(left, right);
}
这样，“树”只能由头部/根gate_node表示（尽管你可能仍然想要一个类似tree类的类 - 我可能只称它为“网络”使用静态方法构建树，设置输入等，以避免混淆，并通过调用head.compute()来触发网络评估。
当然，您仍然存在从某些外部规范构建网络的重要问题。我想，面试官的另一个问题可能就是你的解决方案中没有明确指出这方面的问题。 （我也不在这里，对不起。）