一个简单的求总和运算

Question

实体类(员工类):
public class Employees {
public int Wage;//工资
public List<Employees> employees;//下属员工
public List<Employees> getEmployees() {
return employees;
}
public void setEmployees(List<Employees> employees) {
this.employees = employees;
}
public int getWage() {
return Wage;
}
public void setWage(int wage) {
Wage = wage;
}
}要求写个方法,接收个参数Employees(也就是一名员工),计算出该员工以及其下属员工的工资总和;要求用两种方法,我只写了一种,还差一种方法;我的写的一个方法:
public int getWages(Employees employees)
{
int WagesNum=employees.Wage;
if(employees.employees!=null)
{
for (Employees e : employees.employees) {
WagesNum+=getWages(e);
}

}
return WagesNum;
}求另一种方法;

Answer 1

答:
1)是的.是采用递归计算的.
2)兄弟,你的类 class Employees 中数据成员( Wage , List <Employees> employees)怎么都定义成了public了?这样就不需要你的什么getXXX()与setXXX()之类的方法了.而者变量名:Wage首字母大写,我猛一看,还以为是一个类呢.
3)求另一种方法:方法1:当然就是用 栈  了.实际对应是"深度优先"次序计算. 方法2:当然就是用 队列 了,.实际对应是类似层序的"广度优先"次序计算了. 其它的方法:...

Answer 2

楼主的算法是递归的。理论上，任何一个递归算法都可以用非递归方法来实现，所以，至少还存在另一种非递归的算法。递归算法是利用操作系统或虚拟机的调用栈（Call Stack）来实现的。使用一个带有栈功能的数据机构，就很容易手动模拟递归，这也就是递归程序的非递归实现方法的原理。我整理了一下你的代码，你可以参考一下：另外如5楼说的，还有一种广度优先的算法，我没有实现，楼主可以参考一些数据结构与算法方面的教材自己实现。// Employee.javaimport java.util.*;public class Employee { private int wage;
private List<Employee> employees;

public int getWage() {
return wage;
}

public void setWage(int w) {
wage = w;
} public List<Employee> getEmployees() {
return employees;
}

public void setEmployees(List<Employee> emp) {
employees = emp;
}

public int getWageTotal() {  // 递归的
int sum = wage;
if (employees != null) {
for (Employee emp : employees)
sum += emp.getWageTotal();
}
return sum;
}

public int getWageTotal1() {  // 非递归的（深度优先）
int sum = 0;
LinkedList<Employee> stack = new LinkedList<Employee>();  // 非递归使用的栈

Employee currentEmployee = this;
stack.push(currentEmployee);  // 当前对象入栈 while (!stack.isEmpty()) {
currentEmployee = stack.pop(); // 出栈
sum += currentEmployee.wage;
if (currentEmployee.employees != null)
for (Employee emp : currentEmployee.employees)
stack.push(emp); //将子对象逐一入栈
}
return sum;
}}
测试程序示例：
import java.util.*;public class EmployeeTest { public static void main(String[] args) {
Employee ceo = new Employee();
ceo.setWage(100000);

List<Employee> managers = new ArrayList<Employee>();

// 第一部门
Employee manager1 = new Employee();
manager1.setWage(50000);

List<Employee> employeesDepart1 = new ArrayList<Employee>();
Employee employee1 = new Employee();
employee1.setWage(10000);
employeesDepart1.add(employee1);
Employee employee2 = new Employee();
employee2.setWage(8000);
employeesDepart1.add(employee2);

manager1.setEmployees(employeesDepart1);
managers.add(manager1);

// 第二部门
Employee manager2 = new Employee();
manager2.setWage(30000);

List<Employee> employeesDepart2 = new ArrayList<Employee>();
Employee employee3 = new Employee();
employee3.setWage(7000);
employeesDepart2.add(employee3);
Employee employee4 = new Employee();
employee4.setWage(4000);
employeesDepart2.add(employee4);

manager2.setEmployees(employeesDepart2);
managers.add(manager2);

ceo.setEmployees(managers);

System.out.println("wage of ceo: " + getWage(ceo, false));
System.out.println("wage of ceo (total): " + getWage(ceo, true));
System.out.println("wage of manager1: " + getWage(manager1, false));
System.out.println("wage of manager1 (total): " + getWage(manager1, true));
System.out.println("wage of manager2: " + getWage(manager2, false));
System.out.println("wage of manager2 (total): " + getWage(manager2, true));
}

public static int getWage(Employee emp, Boolean total) {
if (total) return emp.getWageTotal1();
else return emp.getWage();
}
}