Java的递归算法

最近在一段程序的时候,需要生成一棵后台的菜单树,所以最后还是用递归实现的.

首先来说递归的思想是:对于一个复杂的问题,把原问题分解为若干个相对简单类的子问题,继续下去直到子问题简单到直接求解,也就是说到了递推的出口,这样原问题就有了递推得解.

关键要抓住的是:

1.递归出口

2.逐步向出口逼近

代码实例:

import java.util.ArrayList;
import java.util.List;
public class Menu {
	private int id;
	private String name;
	private int pid;
	private List<Menu> childList = new ArrayList<Menu>();

	public List<Menu> getChildList() {
		return childList;
	}

	public void setChildList(List<Menu> childList) {
		this.childList = childList;
	}

	public Menu() {
	}

	public Menu(int id, String name, int pid) {
		this.id = id;
		this.name = name;
		this.pid = pid;
	}

	public static void main(String[] args) {
		List<Menu> mList = new ArrayList<Menu>();

		Menu menu1 = new Menu(1, "1", 0);
		mList.add(menu1);
		Menu menu2 = new Menu(2, "1.1", 1);
		mList.add(menu2);
		Menu menu3 = new Menu(3, "1.2", 1);
		mList.add(menu3);

		Menu menu4 = new Menu(4, "2", 0);
		mList.add(menu4);
		Menu menu5 = new Menu(5, "2.1", 4);
		mList.add(menu5);
		Menu menu7 = new Menu(7, "2.1.1", 5);
		mList.add(menu7);
		Menu menu8 = new Menu(8, "2.1.2", 5);
		mList.add(menu8);
		Menu menu9 = new Menu(9, "2.1.2.1", 8);
		mList.add(menu9);
		Menu menu6 = new Menu(6, "2.2", 4);
		mList.add(menu6);

		List<Menu> yiList = new ArrayList<Menu>();
		for (int i = 0; i < mList.size(); i++) {
			Menu menu = mList.get(i);
			if (menu.getPid() == 0) {
				yiList.add(menu);
			}
		}
		mList.removeAll(yiList);

		for (int i = 0; i < yiList.size(); i++) {
			Menu menu = new Menu();
			menu.pase(yiList.get(i), mList);
		}

		for (int i = 0; i < yiList.size(); i++) {
			Menu menu = yiList.get(i);
			Menu aaa = new Menu();
			aaa.outMenu(menu);
		}

	}

	public void outMenu(Menu menu) {
		System.out.println(menu.name);
		for (int i = 0; i < menu.childList.size(); i++) {
			Menu menu2 = menu.childList.get(i);
			outMenu(menu2);
		}
	}

	public Menu pase(Menu menu, List<Menu> lmenu2) {
		for (int j = 0; j < lmenu2.size(); j++) {
			Menu menu2 = lmenu2.get(j);
			if (menu2.pid == menu.id) {
				menu.childList.add(menu2);
				pase(menu2, lmenu2);
			}
		}
		return menu;
	}

	public int getId() {
		return id;
	}

	public void setId(int id) {
		this.id = id;
	}

	public String getName() {
		return name;
	}

	public void setName(String name) {
		this.name = name;
	}

	public int getPid() {
		return pid;
	}

	public void setPid(int pid) {
		this.pid = pid;
	}

}

输出结果:

1
1.1
1.2
2
2.1
2.1.1
2.1.2
2.1.2.1
2.2

其实递归调用是一种特殊的嵌套调用,是某个函数调用自己,而不是另外一个函数.一种是逻辑思想,将一个大工作分为逐渐减少的校工作,我的功能树,实现就是由根结点开始遍历,只到子类没有可以输出的对象,这样程序就结束了,一开始写程序的的时候还有点神秘,但是随着实现了,回头想想就是一个方法自己调用自己,解决问题.